rss.go

rss.go

package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"github.com/coopernurse/gorp"
	"github.com/kghost/rss"
	_ "github.com/mattn/go-sqlite3"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

type Rss struct {
	Source string
	Last   int64
}

func (rss *Rss) String() string {
	return fmt.Sprintf("%s %s", rss.Source, rss.Last)
}

func main() {
	type Config struct {
		Server     string
		BaseDir    string
		Database   string
		SourceSets []struct {
			Target  string
			Sources []string
		}
	}
	config, err := func() (config Config, err error) {
		file, err := os.Open("config.json")
		if err != nil {
			return config, err
		}
		defer file.Close()
		decoder := json.NewDecoder(file)
		err = decoder.Decode(&config)
		return config, err
	}()
	if err != nil {
		log.Println(err)
		return
	}

	db, err := sql.Open("sqlite3", config.Database)
	if err != nil {
		log.Println(err)
		return
	}
	defer db.Close()
	dbmap := &gorp.DbMap{Db: db, Dialect: gorp.SqliteDialect{}}
	dbmap.AddTable(Rss{}).SetKeys(false, "Source")
	dbmap.CreateTables()

	var session = ""
	client := &http.Client{}
	for _, set := range config.SourceSets {
		for _, url := range set.Sources {
			row, err := dbmap.Get(Rss{}, url)
			if err != nil {
				log.Println(err)
				continue
			}

			var last time.Time
			if row != nil {
				last = time.Unix(row.(*Rss).Last, int64(0))
			} else {
				last = time.Unix(int64(0), int64(0))
			}

			feed, err := rss.Fetch(url)
			if err != nil {
				log.Println(err)
				continue
			}

			var next = last
			for _, item := range feed.Items {
				if item.Date.After(last) {
					log.Println("New Item: %v", item.Title)

					if item.Date.After(next) {
						next = item.Date
					}

					data, err := json.Marshal(map[string]interface{}{
						"method": "torrent-add",
						"arguments": map[string]interface{}{
							"filename":     item.Link,
							"download-dir": config.BaseDir + set.Target,
							"paused":       false,
						},
					})
					if err != nil {
						log.Println("Marshal: %v", err)
						continue
					}

					var rpc func()
					rpc = func() {
						req, err := http.NewRequest("POST", config.Server, strings.NewReader(string(data)))
						if err != nil {
							log.Println("Post: %v", err)
							return
						}
						if session != "" {
							req.Header.Add("X-Transmission-Session-Id", session)
						}
						resp, err := client.Do(req)
						if err != nil {
							log.Println("Post: %v", err)
							return
						}
						defer resp.Body.Close()
						if resp.StatusCode != 200 {
							if resp.StatusCode == 409 {
								session = resp.Header["X-Transmission-Session-Id"][0]
								rpc()
								return
							}
							body, err := ioutil.ReadAll(resp.Body)
							if err != nil {
								log.Println("ReadAll: %v", err)
								return
							}
							log.Println("Server error: %v", body)
							return
						}
						body, err := ioutil.ReadAll(resp.Body)
						if err != nil {
							log.Println("ReadAll: %v", err)
							return
						}
						result := make(map[string]interface{})
						err = json.Unmarshal(body, &result)
						if err != nil {
							log.Println("Unmarshal: %v", err)
							return
						}
						log.Println(result)
					}
					rpc()
				}
			}

			if row != nil {
				if next.After(last) {
					_, err = dbmap.Update(&Rss{Source: url, Last: next.Unix()})
				}
			} else {
				err = dbmap.Insert(&Rss{Source: url, Last: next.Unix()})
			}
			if err != nil {
				log.Println(err)
			}
		}
	}
}