Archive
/
Rssmon2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

no more logger

master
Bel LaPointe 2019-05-02 09:35:57 -06:00
parent 7bfae2f004
commit a57dff60d8
5 changed files with 36 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
exchange/exchange.go
View File

@ -6,7 +6,6 @@ import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"local/logger"
"local/rssmon2/monitor" "local/rssmon2/monitor"
"local/rssmon2/rss" "local/rssmon2/rss"
"local/rssmon2/server" "local/rssmon2/server"
@ -68,12 +67,12 @@ func (ex *Exchange) LoadDB() error {
func (ex *Exchange) NewFeed(url, itemFilter, contentFilter string, tags []string, interval time.Duration) { func (ex *Exchange) NewFeed(url, itemFilter, contentFilter string, tags []string, interval time.Duration) {
feed, err := rss.New(url, itemFilter, contentFilter, tags, interval) feed, err := rss.New(url, itemFilter, contentFilter, tags, interval)
if err != nil { if err != nil {
logger.Logf("can't create new RSS %q: %v", url, err) log.Printf("can't create new RSS %q: %v", url, err)
return return
} }
ex.allFeeds[url] = feed ex.allFeeds[url] = feed
if err := ex.Mon.Submit(url, feed.Interval); err != nil { if err := ex.Mon.Submit(url, feed.Interval); err != nil {
logger.Logf("Cannot accept new feed %q: %v", url, err) log.Printf("Cannot accept new feed %q: %v", url, err)
} }
} }
@ -191,48 +190,48 @@ func (ex *Exchange) UpdateFeed(url string) {
if !ok { if !ok {
f, err := rss.New(url, "", "", nil, time.Minute) f, err := rss.New(url, "", "", nil, time.Minute)
if err != nil { if err != nil {
logger.Logf("cannot identify unknown feed triggered in monitor: %q: %v", url, err) log.Printf("cannot identify unknown feed triggered in monitor: %q: %v", url, err)
return return
} }
b, err := ex.SClient.Get(nsForFeeds, f.ID()) b, err := ex.SClient.Get(nsForFeeds, f.ID())
if err != nil { if err != nil {
logger.Logf("cannot get unknown feed triggered in monitor: %q: %v", url, err) log.Printf("cannot get unknown feed triggered in monitor: %q: %v", url, err)
return return
} }
feed, err = rss.Deserialize(b) feed, err = rss.Deserialize(b)
if err != nil { if err != nil {
logger.Logf("cannot deserialize feed triggered in monitor: %q: %v", url, err) log.Printf("cannot deserialize feed triggered in monitor: %q: %v", url, err)
return return
} }
} }
items, err := ex.allFeeds[url].Update() items, err := ex.allFeeds[url].Update()
if err != nil { if err != nil {
logger.Logf("can't update old RSS %q: %v", url, err) log.Printf("can't update old RSS %q: %v", url, err)
return return
} }
b, err := feed.Serialize() b, err := feed.Serialize()
if err != nil { if err != nil {
logger.Logf("can't serialize to save RSS %q: %v", url, err) log.Printf("can't serialize to save RSS %q: %v", url, err)
return return
} }
if err := ex.SClient.Set(nsForFeeds, feed.ID(), b); err != nil { if err := ex.SClient.Set(nsForFeeds, feed.ID(), b); err != nil {
logger.Logf("can't save RSS %q.%q: %v", nsForFeeds, feed.ID(), err) log.Printf("can't save RSS %q.%q: %v", nsForFeeds, feed.ID(), err)
return return
} }
logger.Log("Saved feed", feed) log.Print("Saved feed", feed)
for i := range items { for i := range items {
b, err := items[i].Serialize() b, err := items[i].Serialize()
if err != nil { if err != nil {
logger.Logf("can't save rss item %q.%q: %v", url, items[i].Link, err) log.Printf("can't save rss item %q.%q: %v", url, items[i].Link, err)
return return
} }
if err := ex.SClient.Set(feed.ID(), items[i].ID(), b); err != nil { if err := ex.SClient.Set(feed.ID(), items[i].ID(), b); err != nil {
logger.Logf("can't save rss item %q.%q: %v", feed.ID(), items[i].ID(), err) log.Printf("can't save rss item %q.%q: %v", feed.ID(), items[i].ID(), err)
return return
} }
//logger.Log("Saved feed item", feed.ID(), items[i].ID(), items[i]) //log.Print("Saved feed item", feed.ID(), items[i].ID(), items[i])
} }
logger.Logf("Saved %d feed items for %s", len(items), feed.Title) log.Printf("Saved %d feed items for %s", len(items), feed.Title)
go ex.handlerByTag(feed.Tags, items) go ex.handlerByTag(feed.Tags, items)
} }
@ -289,13 +288,13 @@ func (ex *Exchange) handlerPodcast(item *rss.Item) {
func (ex *Exchange) handlerTorrent(item *rss.Item) { func (ex *Exchange) handlerTorrent(item *rss.Item) {
magnet := regexp.MustCompile("magnet:.xt[^ $]*") magnet := regexp.MustCompile("magnet:.xt[^ $]*")
if !magnet.MatchString(item.Content) { if !magnet.MatchString(item.Content) {
logger.Log("no magnet link: ", item.Content) log.Print("no magnet link: ", item.Content)
} }
match := magnet.FindString(item.Content) match := magnet.FindString(item.Content)
resp, err := http.Get(ex.toraddr) resp, err := http.Get(ex.toraddr)
if err != nil { if err != nil {
logger.Logf("cannot get session id at %v: %v", ex.toraddr, err) log.Printf("cannot get session id at %v: %v", ex.toraddr, err)
return return
} }
sessionID := resp.Header.Get("X-Transmission-Session-Id") sessionID := resp.Header.Get("X-Transmission-Session-Id")
@ -307,28 +306,28 @@ func (ex *Exchange) handlerTorrent(item *rss.Item) {
}, },
}) })
if err != nil { if err != nil {
logger.Log("cannot build request body: %v", err) log.Print("cannot build request body: %v", err)
return return
} }
req, err := http.NewRequest("POST", ex.toraddr, bytes.NewBuffer(requestBody)) req, err := http.NewRequest("POST", ex.toraddr, bytes.NewBuffer(requestBody))
if err != nil { if err != nil {
logger.Log("cannot POST request: %v", err) log.Print("cannot POST request: %v", err)
return return
} }
req.Header.Add("X-Transmission-Session-Id", sessionID) req.Header.Add("X-Transmission-Session-Id", sessionID)
resp, err = (&http.Client{}).Do(req) resp, err = (&http.Client{}).Do(req)
if err != nil { if err != nil {
logger.Log("failed POST: %v", err) log.Print("failed POST: %v", err)
return return
} }
var out map[string]interface{} var out map[string]interface{}
if err := json.NewDecoder(resp.Body).Decode(&out); err != nil { if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
logger.Log("cannot decode response: %v", err) log.Print("cannot decode response: %v", err)
return return
} }
if v, ok := out["result"]; !ok || v != "success" { if v, ok := out["result"]; !ok || v != "success" {
logger.Logf("failed magnet submission for feed item %v: %v", item.Name, v) log.Printf("failed magnet submission for feed item %v: %v", item.Name, v)
} }
} }

4
main.go
View File

@ -1,12 +1,12 @@
package main package main
import ( import (
"local/logger"
"local/rssmon2/config" "local/rssmon2/config"
"local/rssmon2/exchange" "local/rssmon2/exchange"
"local/rssmon2/monitor" "local/rssmon2/monitor"
"local/rssmon2/server" "local/rssmon2/server"
"local/rssmon2/store" "local/rssmon2/store"
"log"
) )
func main() { func main() {
@ -52,7 +52,7 @@ func core() {
panic(err) panic(err)
} }
logger.Log("Starting with", config) log.Print("Starting with", config)
if err := srv.Serve(); err != nil { if err := srv.Serve(); err != nil {
panic(err) panic(err)
} }

12
monitor/monitor.go
View File

@ -2,7 +2,7 @@ package monitor
import ( import (
"errors" "errors"
"local/logger" "log"
"time" "time"
"github.com/golang-collections/go-datastructures/queue" "github.com/golang-collections/go-datastructures/queue"
@ -59,29 +59,29 @@ func (monitor *Monitor) loop() error {
} }
var err error var err error
if nextEvent, err = nextEventTime(queue); err != nil { if nextEvent, err = nextEventTime(queue); err != nil {
logger.Log("no next event time", err) log.Print("no next event time", err)
nextEvent = time.Now().Add(time.Minute * 60) nextEvent = time.Now().Add(time.Minute * 60)
continue continue
} }
case <-time.After(nextEvent.Sub(time.Now())): case <-time.After(nextEvent.Sub(time.Now())):
items, err := queue.Get(1) items, err := queue.Get(1)
if err != nil { if err != nil {
logger.Fatal("can't get item") log.Fatal("can't get item")
} }
if len(items) == 0 { if len(items) == 0 {
logger.Log("no items in queue") log.Print("no items in queue")
nextEvent = time.Now().Add(time.Minute * 60) nextEvent = time.Now().Add(time.Minute * 60)
continue continue
} }
item, ok := items[0].(*Item) item, ok := items[0].(*Item)
if !ok { if !ok {
logger.Fatal("queue contains illegal item") log.Fatal("queue contains illegal item")
} }
go monitor.trigger(item.URL) go monitor.trigger(item.URL)
item.increment() item.increment()
queue.Put(item) queue.Put(item)
if nextEvent, err = nextEventTime(queue); err != nil { if nextEvent, err = nextEventTime(queue); err != nil {
logger.Log("no next event time", err) log.Print("no next event time", err)
nextEvent = time.Now().Add(time.Minute * 60) nextEvent = time.Now().Add(time.Minute * 60)
continue continue
} }

8
rss/feed.go
View File

@ -5,7 +5,7 @@ import (
"encoding/gob" "encoding/gob"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"local/logger" "log"
"net/http" "net/http"
"regexp" "regexp"
"strings" "strings"
@ -118,19 +118,19 @@ func (feed *Feed) appendNewItems(items []*gofeed.Item) ([]*Item, time.Time, erro
for i := range items { for i := range items {
t := gofeedItemTS(items[i]) t := gofeedItemTS(items[i])
if *t != (time.Time{}) && t.Before(feed.Updated) { if *t != (time.Time{}) && t.Before(feed.Updated) {
logger.Logf("\tnot adding %v because its timestamp before %v", items[i].Link, feed.Updated) log.Printf("\tnot adding %v because its timestamp before %v", items[i].Link, feed.Updated)
continue continue
} }
if t.After(latest) { if t.After(latest) {
latest = *t latest = *t
} }
if ok, _ := regexp.MatchString(feed.ItemFilter, items[i].Title); !ok { if ok, _ := regexp.MatchString(feed.ItemFilter, items[i].Title); !ok {
logger.Logf("\tnot adding %v because its title doesnt match item filter %v", items[i].Link, feed.ItemFilter) log.Printf("\tnot adding %v because its title doesnt match item filter %v", items[i].Link, feed.ItemFilter)
continue continue
} }
item := FromGofeedItem(items[i], feed.ContentFilter) item := FromGofeedItem(items[i], feed.ContentFilter)
newitems = append(newitems, item) newitems = append(newitems, item)
} }
logger.Logf("\tnew latest is %v", latest) log.Printf("\tnew latest is %v", latest)
return newitems, latest, nil return newitems, latest, nil
} }

8
server/server.go
View File

@ -3,7 +3,7 @@ package server
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"local/logger" "log"
"net/http" "net/http"
"net/url" "net/url"
"os" "os"
@ -166,7 +166,7 @@ func (s *Server) getFeedTag(w http.ResponseWriter, r *http.Request) {
} }
feedBody, err := s.getFeedTagHandler(url) feedBody, err := s.getFeedTagHandler(url)
if err != nil { if err != nil {
logger.Logf("cannot get feed tag %s: %v", url, err) log.Printf("cannot get feed tag %s: %v", url, err)
s.mybad(w, r) s.mybad(w, r)
return return
} }
@ -181,7 +181,7 @@ func (s *Server) getFeedItem(w http.ResponseWriter, r *http.Request) {
} }
feedBody, err := s.getFeedItemHandler(url) feedBody, err := s.getFeedItemHandler(url)
if err != nil { if err != nil {
logger.Logf("cannot get feed item %s: %v", url, err) log.Printf("cannot get feed item %s: %v", url, err)
s.mybad(w, r) s.mybad(w, r)
return return
} }
@ -202,7 +202,7 @@ func (s *Server) getFeed(w http.ResponseWriter, r *http.Request) {
} }
feedBody, err := s.getFeedHandler(url, limit) feedBody, err := s.getFeedHandler(url, limit)
if err != nil { if err != nil {
logger.Logf("cannot get feed %s: %v", url, err) log.Printf("cannot get feed %s: %v", url, err)
s.mybad(w, r) s.mybad(w, r)
return return
} }