Rssmon2/main.go

package main

import (
	"errors"
	"local1/logger"
	"local3/rssmon2/config"
	"local3/rssmon2/monitor"
	"local3/rssmon2/rss"
	"local3/rssmon2/server"
	"local3/rssmon2/store"
	"strings"
	"time"
)

const nsForFeeds = "FEEDS"

func main() {
	core()
}

func core() {
	config := config.New()

	var sclient store.Client
	var err error
	if sclient, err = store.NewBolt(config.DBPath); err != nil {
		panic(err)
	}
	defer sclient.Close()

	allFeeds := make(map[string]*rss.Feed)
	mon, err := monitor.New(func(url string) {
		feed, ok := allFeeds[url]
		if !ok {
			f, err := rss.New(url, "", "", time.Minute)
			if err != nil {
				logger.Logf("cannot identify unknown feed triggered in monitor: %q: %v", url, err)
				return
			}
			b, err := sclient.Get(nsForFeeds, f.ID())
			if err != nil {
				logger.Logf("cannot get unknown feed triggered in monitor: %q: %v", url, err)
				return
			}
			feed, err = rss.Deserialize(b)
			if err != nil {
				logger.Logf("cannot deserialize feed triggered in monitor: %q: %v", url, err)
				return
			}
		}
		items, err := allFeeds[url].Update()
		if err != nil {
			logger.Logf("can't update old RSS %q: %v", url, err)
			return
		}
		b, err := feed.Serialize()
		if err != nil {
			logger.Logf("can't serialize to save RSS %q: %v", url, err)
			return
		}
		if err := sclient.Set(nsForFeeds, feed.ID(), b); err != nil {
			logger.Logf("can't save RSS %q.%q: %v", nsForFeeds, feed.ID(), err)
			return
		}
		logger.Log("Saved feed", feed)
		for i := range items {
			b, err := items[i].Serialize()
			if err != nil {
				logger.Logf("can't save rss item %q.%q: %v", url, items[i].Link, err)
				return
			}
			if err := 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)
				return
			}
			logger.Log("Saved feed item", feed.ID(), items[i].ID(), items[i])
		}
	})
	if err != nil {
		panic(err)
	}
	if err := mon.Start(); err != nil {
		panic(err)
	}
	defer mon.Stop()

	server, err := server.New(config.Port,
		func(url string, itemFilter, contentFilter string, interval time.Duration) {
			feed, err := rss.New(url, itemFilter, contentFilter, interval)
			if err != nil {
				logger.Logf("can't create new RSS %q: %v", url, err)
				return
			}
			allFeeds[url] = feed
			if err := mon.Submit(url, feed.Interval); err != nil {
				logger.Logf("Cannot accept new feed %q: %v", url, err)
			}
		},
		func(url string, n int) (string, error) {
			feed, ok := allFeeds[url]
			if !ok {
				return "", errors.New("unknown feed " + url)
			}
			itemKeys, err := sclient.List(feed.ID(), "", false, n)
			if err != nil {
				return "", err
			}
			items := make([]*rss.Item, len(itemKeys))
			for i := range itemKeys {
				b, err := sclient.Get(feed.ID(), itemKeys[i])
				if err != nil {
					return "", errors.New("cannot get feed item " + itemKeys[i])
				}
				items[i], err = rss.DeserializeItem(b)
				if err != nil {
					return "", errors.New("cannot deserialize feed item" + itemKeys[i])
				}
			}
			return rss.ToRSS(feed, items)
		},
		func(ID string) (string, error) {
			b, err := sclient.Get(strings.Split(ID, ".")[0], strings.Join(strings.Split(ID, ".")[1:], "."))
			if err != nil {
				return "", errors.New("cannot get feed item " + ID)
			}
			item, err := rss.DeserializeItem(b)
			if err != nil {
				return "", errors.New("cannot deserialize feed item" + ID)
			}
			return item.Content, nil
		},
	)
	if err != nil {
		panic(err)
	}

	oldFeeds, err := sclient.List(nsForFeeds, "", true, -1)
	if err != nil {
		panic(err)
	}
	for _, feedID := range oldFeeds {
		b, err := sclient.Get(nsForFeeds, feedID)
		if err != nil {
			panic(err)
		}
		feed, err := rss.Deserialize(b)
		if err != nil {
			panic(err)
		}
		allFeeds[feed.Link] = feed
		if err := mon.Submit(feed.Link, feed.Interval); err != nil {
			panic(err)
		}
	}

	logger.Log("Starting with", config)
	if err := server.Serve(); err != nil {
		panic(err)
	}
}