'Exec' as an alternative to 'Url'

4 files changed, 66 insertions, 16 deletions

diff --git a/internal/feed/feed.go b/internal/feed/feed.go
index ef51251..4e84443 100644
--- a/internal/feed/feed.go
+++ b/internal/feed/feed.go
@@ -1,6 +1,7 @@
 package feed
 
 import (
+	"strings"
 	"time"
 
 	"github.com/mmcdole/gofeed"
@@ -25,9 +26,15 @@ type feedDescriptor struct {
 }
 
 func (feed *Feed) descriptor() feedDescriptor {
+	var url string
+	if feed.Url != "" {
+		url = feed.Url
+	} else {
+		url = "exec://" + strings.Join(feed.Exec, "/")
+	}
 	return feedDescriptor{
 		Name: feed.Name,
-		Url:  feed.Url,
+		Url:  url,
 	}
 }
 
diff --git a/internal/feed/mail.go b/internal/feed/mail.go
index c03a27b..55cb569 100644
--- a/internal/feed/mail.go
+++ b/internal/feed/mail.go
@@ -251,9 +251,19 @@ func getBody(content, description string, bodyCfg config.Body) string {
 
 func (item *item) buildBody() {
 	feed := item.feed
-	feedUrl, err := url.Parse(feed.Url)
-	if err != nil {
-		panic(fmt.Sprintf("URL '%s' of feed '%s' is not a valid URL. How have we ended up here?", feed.Url, feed.Name))
+
+	var feedUrl *url.URL
+	var err error
+	if feed.Url != "" {
+		feedUrl, err = url.Parse(feed.Url)
+		if err != nil {
+			panic(fmt.Sprintf("URL '%s' of feed '%s' is not a valid URL. How have we ended up here?", feed.Url, feed.Name))
+		}
+	} else if feed.feed.Link != "" {
+		feedUrl, err = url.Parse(feed.feed.Link)
+		if err != nil {
+			panic(fmt.Sprintf("Link '%s' of feed '%s' is not a valid URL.", feed.feed.Link, feed.Name))
+		}
 	}
 
 	body := getBody(item.Content, item.Description, feed.Body)
@@ -288,13 +298,15 @@ func (item *item) buildBody() {
 			return
 		}
 
-		srcUrl, err := url.Parse(src)
+		imgUrl, err := url.Parse(src)
 		if err != nil {
 			log.Errorf("Feed %s: Item %s: Error parsing URL '%s' embedded in item: %s",
 				feed.Name, item.Link, src, err)
 			return
 		}
-		imgUrl := feedUrl.ResolveReference(srcUrl)
+		if feedUrl != nil {
+			imgUrl = feedUrl.ResolveReference(imgUrl)
+		}
 
 		img, mime, err := getImage(imgUrl.String(), feed.Global.Timeout, feed.NoTLS)
 		if err != nil {
diff --git a/internal/feed/parse.go b/internal/feed/parse.go
index a8f705a..77dfe69 100644
--- a/internal/feed/parse.go
+++ b/internal/feed/parse.go
@@ -2,6 +2,8 @@ package feed
 
 import (
 	"fmt"
+	"io"
+	"os/exec"
 
 	"github.com/google/uuid"
 	"github.com/mmcdole/gofeed"
@@ -13,15 +15,44 @@ import (
 func (feed *Feed) parse() error {
 	fp := gofeed.NewParser()
 
-	// we do not use the http support in gofeed, so that we can control the behavior of http requests
-	// and ensure it to be the same in all places
-	resp, cancel, err := http.Get(feed.Url, feed.Global.Timeout, feed.NoTLS)
-	if err != nil {
-		return fmt.Errorf("while fetching %s from %s: %w", feed.Name, feed.Url, err)
+	var reader io.Reader
+	var cleanup func() error
+
+	if feed.Url != "" {
+		// we do not use the http support in gofeed, so that we can control the behavior of http requests
+		// and ensure it to be the same in all places
+		resp, cancel, err := http.Get(feed.Url, feed.Global.Timeout, feed.NoTLS)
+		if err != nil {
+			return fmt.Errorf("while fetching %s from %s: %w", feed.Name, feed.Url, err)
+		}
+		defer cancel() // includes resp.Body.Close
+
+		reader = resp.Body
+		cleanup = func() error { return nil }
+	} else { // exec
+		// we use the same context as for HTTP
+		ctx, cancel := http.Context(feed.Global.Timeout)
+		cmd := exec.CommandContext(ctx, feed.Exec[0], feed.Exec[1:]...)
+		defer func() {
+			cancel()
+			// cmd.Wait might have already been called -- but call it again to be sure
+			_ = cmd.Wait()
+		}()
+
+		stdout, err := cmd.StdoutPipe()
+		if err != nil {
+			return fmt.Errorf("preparing exec for feed '%s': %w", feed.Name, err)
+		}
+
+		if err = cmd.Start(); err != nil {
+			return fmt.Errorf("starting exec for feed '%s: %w", feed.Name, err)
+		}
+
+		reader = stdout
+		cleanup = cmd.Wait
 	}
-	defer cancel() // includes resp.Body.Close
 
-	parsedFeed, err := fp.Parse(resp.Body)
+	parsedFeed, err := fp.Parse(reader)
 	if err != nil {
 		return fmt.Errorf("parsing feed '%s': %w", feed.Name, err)
 	}
@@ -31,7 +62,7 @@ func (feed *Feed) parse() error {
 	for idx, feedItem := range parsedFeed.Items {
 		feed.items[idx] = item{Feed: parsedFeed, Item: feedItem, itemId: uuid.New(), feed: feed}
 	}
-	return nil
+	return cleanup()
 }
 
 func handleFeed(feed *Feed) {
diff --git a/internal/http/client.go b/internal/http/client.go
index c9af26e..230c333 100644
--- a/internal/http/client.go
+++ b/internal/http/client.go
@@ -35,7 +35,7 @@ func init() {
 	unsafeClient = &http.Client{Transport: transport}
 }
 
-func context(timeout int) (ctxt.Context, ctxt.CancelFunc) {
+func Context(timeout int) (ctxt.Context, ctxt.CancelFunc) {
 	return ctxt.WithTimeout(ctxt.Background(), time.Duration(timeout)*time.Second)
 }
 
@@ -50,7 +50,7 @@ var noop ctxt.CancelFunc = func() {}
 
 func Get(url string, timeout int, disableTLS bool) (resp *http.Response, cancel ctxt.CancelFunc, err error) {
 	prematureExit := true
-	ctx, ctxCancel := context(timeout)
+	ctx, ctxCancel := Context(timeout)
 
 	cancel = func() {
 		if resp != nil {