func forbidden(c context.Context, r *http.Request) bool {
if v, ok := c.Get(r, readeef.CtxKey("forbidden")); ok {
if f, ok := v.(bool); ok {
return f
}
}
return false
}
func RegisterControllers(config readeef.Config, dispatcher *webfw.Dispatcher, apiPattern string) {
dispatcher.Renderer = renderer.NewRenderer(dispatcher.Config.Renderer.Dir,
dispatcher.Config.Renderer.Base)
hasProxy := false
for _, p := range config.FeedParser.Processors {
if p == "proxy-http" {
hasProxy = true
break
}
}
if !hasProxy {
for _, p := range config.Content.ArticleProcessors {
if p == "proxy-http" {
hasProxy = true
break
}
}
}
mw := make([]string, 0, len(dispatcher.Config.Dispatcher.Middleware))
for _, m := range dispatcher.Config.Dispatcher.Middleware {
switch m {
case "Session":
if hasProxy {
mw = append(mw, m)
}
default:
mw = append(mw, m)
}
}
dispatcher.Config.Dispatcher.Middleware = mw
dispatcher.Renderer.Delims("{%", "%}")
dispatcher.Context.SetGlobal(readeef.CtxKey("config"), config)
dispatcher.Context.SetGlobal(context.BaseCtxKey("readeefConfig"), config)
middleware.InitializeDefault(dispatcher)
dispatcher.Handle(NewApp())
dispatcher.Handle(NewComponent(dispatcher, apiPattern))
if hasProxy {
dispatcher.Handle(NewProxy())
}
}
func RegisterControllers(config readeef.Config, dispatcher *webfw.Dispatcher, logger webfw.Logger) error {
repo, err := repo.New(config.DB.Driver, config.DB.Connect, logger)
if err != nil {
return err
}
capabilities := capabilities{
I18N: len(dispatcher.Config.I18n.Languages) > 1,
Popularity: len(config.Popularity.Providers) > 0,
}
var ap []content.ArticleProcessor
for _, p := range config.Content.ArticleProcessors {
switch p {
case "relative-url":
ap = append(ap, contentProcessor.NewRelativeUrl(logger))
case "proxy-http":
template := config.Content.ProxyHTTPURLTemplate
if template != "" {
p, err := contentProcessor.NewProxyHTTP(logger, template)
if err != nil {
return fmt.Errorf("Error initializing Proxy HTTP article processor: %v", err)
}
ap = append(ap, p)
capabilities.ProxyHTTP = true
}
case "insert-thumbnail-target":
ap = append(ap, contentProcessor.NewInsertThumbnailTarget(logger))
}
}
repo.ArticleProcessors(ap)
if err := initAdminUser(repo, []byte(config.Auth.Secret)); err != nil {
return err
}
mw := make([]string, 0, len(dispatcher.Config.Dispatcher.Middleware))
for _, m := range dispatcher.Config.Dispatcher.Middleware {
switch m {
case "I18N", "Static", "Url", "Sitemap":
case "Session":
if capabilities.ProxyHTTP {
mw = append(mw, m)
}
default:
mw = append(mw, m)
}
}
dispatcher.Config.Dispatcher.Middleware = mw
dispatcher.Context.SetGlobal(readeef.CtxKey("config"), config)
dispatcher.Context.SetGlobal(context.BaseCtxKey("readeefConfig"), config)
dispatcher.Context.SetGlobal(readeef.CtxKey("repo"), repo)
fm := readeef.NewFeedManager(repo, config, logger)
var processors []parser.Processor
for _, p := range config.FeedParser.Processors {
switch p {
case "relative-url":
processors = append(processors, processor.NewRelativeUrl(logger))
case "proxy-http":
template := config.FeedParser.ProxyHTTPURLTemplate
if template != "" {
p, err := processor.NewProxyHTTP(logger, template)
if err != nil {
return fmt.Errorf("Error initializing Proxy HTTP processor: %v", err)
}
processors = append(processors, p)
capabilities.ProxyHTTP = true
}
case "cleanup":
processors = append(processors, processor.NewCleanup(logger))
case "top-image-marker":
processors = append(processors, processor.NewTopImageMarker(logger))
}
}
fm.ParserProcessors(processors)
var sp content.SearchProvider
switch config.Content.SearchProvider {
case "elastic":
if sp, err = search.NewElastic(config.Content.ElasticURL, config.Content.SearchBatchSize, logger); err != nil {
logger.Printf("Error initializing Elastic search: %v\n", err)
}
case "bleve":
fallthrough
default:
if sp, err = search.NewBleve(config.Content.BlevePath, config.Content.SearchBatchSize, logger); err != nil {
logger.Printf("Error initializing Bleve search: %v\n", err)
}
}
if sp != nil {
if sp.IsNewIndex() {
go func() {
sp.IndexAllFeeds(repo)
}()
}
}
var ce content.Extractor
switch config.Content.Extractor {
case "readability":
if ce, err = extractor.NewReadability(config.Content.ReadabilityKey); err != nil {
return fmt.Errorf("Error initializing Readability extractor: %v\n", err)
}
case "goose":
fallthrough
default:
if ce, err = extractor.NewGoose(dispatcher.Config.Renderer.Dir); err != nil {
return fmt.Errorf("Error initializing Goose extractor: %v\n", err)
}
}
if ce != nil {
capabilities.Extractor = true
}
var t content.Thumbnailer
switch config.Content.Thumbnailer {
case "extract":
if t, err = thumbnailer.NewExtract(ce, logger); err != nil {
return fmt.Errorf("Error initializing Extract thumbnailer: %v\n", err)
}
case "description":
fallthrough
default:
t = thumbnailer.NewDescription(logger)
}
monitors := []content.FeedMonitor{monitor.NewUnread(repo, logger)}
for _, m := range config.FeedManager.Monitors {
switch m {
case "index":
if sp != nil {
monitors = append(monitors, monitor.NewIndex(sp, logger))
capabilities.Search = true
}
case "thumbnailer":
if t != nil {
monitors = append(monitors, monitor.NewThumbnailer(t, logger))
}
}
}
webSocket := NewWebSocket(fm, sp, ce, capabilities)
dispatcher.Handle(webSocket)
monitors = append(monitors, webSocket)
if config.Hubbub.CallbackURL != "" {
hubbub := readeef.NewHubbub(repo, config, logger, dispatcher.Pattern,
fm.RemoveFeedChannel())
if err := hubbub.InitSubscriptions(); err != nil {
return fmt.Errorf("Error initializing hubbub subscriptions: %v", err)
}
hubbub.FeedMonitors(monitors)
fm.Hubbub(hubbub)
}
fm.FeedMonitors(monitors)
fm.Start()
nonce := readeef.NewNonce()
controllers := []webfw.Controller{
NewAuth(capabilities),
NewFeed(fm, sp),
NewArticle(config, ce),
NewUser(),
NewUserSettings(),
NewNonce(nonce),
}
if fm.Hubbub() != nil {
controllers = append(controllers, NewHubbubController(fm.Hubbub(), config.Hubbub.RelativePath,
fm.AddFeedChannel(), fm.RemoveFeedChannel()))
}
for _, e := range config.API.Emulators {
switch e {
case "tt-rss":
controllers = append(controllers, NewTtRss(fm, sp))
case "fever":
controllers = append(controllers, NewFever())
}
}
for _, c := range controllers {
dispatcher.Handle(c)
}
middleware.InitializeDefault(dispatcher)
dispatcher.RegisterMiddleware(readeef.Auth{Pattern: dispatcher.Pattern, Nonce: nonce, IgnoreURLPrefix: config.Auth.IgnoreURLPrefix})
dispatcher.Renderer = renderer.NewRenderer(dispatcher.Config.Renderer.Dir,
dispatcher.Config.Renderer.Base)
dispatcher.Renderer.Delims("{%", "%}")
go func() {
for {
select {
case <-time.After(5 * time.Minute):
nonce.Clean(45 * time.Second)
}
}
}()
return nil
}
func (con WebSocket) AuthReject(c context.Context, r *http.Request) {
c.Set(r, readeef.CtxKey("forbidden"), true)
}
func RegisterControllers(config readeef.Config, dispatcher *webfw.Dispatcher, logger webfw.Logger) error {
repo, err := repo.New(config.DB.Driver, config.DB.Connect, logger)
if err != nil {
return err
}
if err := initAdminUser(repo, []byte(config.Auth.Secret)); err != nil {
return err
}
dispatcher.Context.SetGlobal(readeef.CtxKey("config"), config)
dispatcher.Context.SetGlobal(context.BaseCtxKey("readeefConfig"), config)
dispatcher.Context.SetGlobal(readeef.CtxKey("repo"), repo)
um := &readeef.UpdateFeedReceiverManager{}
fm := readeef.NewFeedManager(repo, config, logger, um)
if config.Hubbub.CallbackURL != "" {
hubbub := readeef.NewHubbub(repo, config, logger, dispatcher.Pattern, fm.RemoveFeedChannel(), fm.AddFeedChannel(), um)
if err := hubbub.InitSubscriptions(); err != nil {
return fmt.Errorf("Error initializing hubbub subscriptions: %v", err)
}
fm.SetHubbub(hubbub)
dispatcher.Handle(readeef.NewHubbubController(hubbub))
}
var si readeef.SearchIndex
if config.SearchIndex.BlevePath != "" {
var err error
si, err = readeef.NewSearchIndex(repo, config, logger)
if err != nil {
return fmt.Errorf("Error initializing bleve search: %v", err)
}
if si.IsNewIndex() {
go func() {
si.IndexAllArticles()
}()
}
fm.SetSearchIndex(si)
}
fm.Start()
nonce := readeef.NewNonce()
var patternController webfw.PatternController
var multiPatternController webfw.MultiPatternController
patternController = NewAuth()
dispatcher.Handle(patternController)
multiPatternController = NewFeed(fm)
dispatcher.Handle(multiPatternController)
multiPatternController = NewArticle(config)
dispatcher.Handle(multiPatternController)
if config.SearchIndex.BlevePath != "" {
patternController = NewSearch(si)
dispatcher.Handle(patternController)
}
multiPatternController = NewUser()
dispatcher.Handle(multiPatternController)
patternController = NewUserSettings()
dispatcher.Handle(patternController)
patternController = NewNonce(nonce)
dispatcher.Handle(patternController)
if config.API.Fever {
patternController = NewFever(fm)
dispatcher.Handle(patternController)
}
webSocket := NewWebSocket(fm, si)
dispatcher.Handle(webSocket)
um.AddUpdateReceiver(webSocket)
middleware.InitializeDefault(dispatcher)
dispatcher.RegisterMiddleware(readeef.Auth{Pattern: dispatcher.Pattern, Nonce: nonce, IgnoreURLPrefix: config.Auth.IgnoreURLPrefix})
dispatcher.Renderer = renderer.NewRenderer(dispatcher.Config.Renderer.Dir,
dispatcher.Config.Renderer.Base)
dispatcher.Renderer.Delims("{%", "%}")
go func() {
for {
select {
case <-time.After(5 * time.Minute):
nonce.Clean(45 * time.Second)
}
}
}()
return nil
}
func RegisterControllers(config readeef.Config, dispatcher *webfw.Dispatcher, logger *log.Logger) error {
db := readeef.NewDB(config.DB.Driver, config.DB.Connect)
if err := db.Connect(); err != nil {
return errors.New(fmt.Sprintf("Error connecting to database: %v", err))
}
updateFeed := make(chan readeef.Feed)
fm := readeef.NewFeedManager(db, config, logger, updateFeed)
if config.Hubbub.CallbackURL != "" {
hubbub := readeef.NewHubbub(db, config, logger, dispatcher.Pattern, fm.RemoveFeedChannel(), fm.AddFeedChannel(), updateFeed)
if err := hubbub.InitSubscriptions(); err != nil {
return errors.New(fmt.Sprintf("Error initializing hubbub subscriptions: %v", err))
}
fm.SetHubbub(hubbub)
dispatcher.Handle(readeef.NewHubbubController(hubbub))
}
fm.Start()
nonce := readeef.NewNonce()
var controller webfw.Controller
controller = NewAuth()
dispatcher.Handle(controller)
controller = NewFeed(fm)
dispatcher.Handle(controller)
controller = NewArticle()
dispatcher.Handle(controller)
controller = NewUser()
dispatcher.Handle(controller)
controller = NewUserSettings()
dispatcher.Handle(controller)
controller = NewFeedUpdateNotificator(updateFeed)
dispatcher.Handle(controller)
controller = NewNonce(nonce)
dispatcher.Handle(controller)
middleware.InitializeDefault(dispatcher)
dispatcher.RegisterMiddleware(readeef.Auth{DB: db, Pattern: dispatcher.Pattern, Nonce: nonce, IgnoreURLPrefix: config.Auth.IgnoreURLPrefix})
dispatcher.Context.SetGlobal(readeef.CtxKey("config"), config)
dispatcher.Context.SetGlobal(readeef.CtxKey("db"), db)
dispatcher.Renderer = renderer.NewRenderer(dispatcher.Config.Renderer.Dir,
dispatcher.Config.Renderer.Base)
dispatcher.Renderer.Delims("{%", "%}")
go func() {
for {
select {
case <-time.After(5 * time.Minute):
nonce.Clean(45 * time.Second)
}
}
}()
return nil
}