func newTestUniverse(t *testing.T) *universe.Universe {
	c := universe.Config{
		BerksOnly: true,
	}

	return universe.NewCache(c)
}
Beispiel #2
0
func main() {
	u := universe.NewCache(universe.Config{
		BerksOnly: config.Opts.BerksOnly,
	})

	// add handlers to help us track memory usage - they don't track memory until they're told to
	profiler.AddMemoryProfilingHandlers()
	profiler.RegisterExtraServiceInfoRetriever(u.ServiceInfo)
	profiler.StartProfiling()

	ghsConfig := gh.Config{
		Token:        config.Opts.Token,
		Org:          config.Opts.Org,
		SyncInterval: config.Opts.SyncInterval,
		MaxVersions:  config.Opts.MaxGithubVersions,
	}
	ghs := gh.New(ghsConfig, u)
	var wg sync.WaitGroup
	wg.Add(1) // we want to do some stuff after github is done, this is so we can block on the gh repo processing before we do something like add in other sources

	// Add supermarket to the universe after github
	d, _ := time.ParseDuration("6h") // not exposed as a tunable yet
	conf := supermarket.Config{SyncInterval: d}
	sm := supermarket.New(conf, u)

	// ye yea hate the ! no sync, but default behavior should be to sync
	if !config.Opts.NoSync {
		go func() {
			if err := ghs.Sync(); err != nil {
				log.Printf("Error syncing github org %s %s", ghs.Conf.Org, err.Error())
			} else {
				wg.Done()
			}
		}()
	}
	go periodicSync(ghs)
	go periodicSync(sm)

	// create our custom http server/router
	router := httprouter.New()
	server := &http.Server{
		Addr:    fmt.Sprintf("%s:%d", config.Opts.Bind, config.Opts.Port),
		Handler: Log(router),
	}

	ghook = hook.NewServer()
	ghook.Secret = config.Opts.Secret
	ghook.Path = "/hook"

	router.GET("/", rootHandler)
	// can see a post or refresh or purge going here as well
	router.GET("/cookbook/:cook", u.CookBookHandler)

	router.HandlerFunc("GET", "/profiler/info.html", profiler.MemStatsHTMLHandler)
	router.HandlerFunc("GET", "/profiler/info", profiler.ProfilingInfoJSONHandler)
	router.HandlerFunc("GET", "/profiler/start", profiler.StartProfilingHandler)
	router.HandlerFunc("GET", "/profiler/stop", profiler.StopProfilingHandler)

	// github rate info
	router.HandlerFunc("GET", "/rate", ghs.RateHandler)
	// throw these standard handlers in the router
	router.HandlerFunc("GET", "/universe", u.Handler)
	router.HandlerFunc("PUT", "/hook", ghook.ServeHTTP)
	router.HandlerFunc("POST", "/hook", ghook.ServeHTTP)

	// TODO:(jnelson) the EventProcessor is tied to a gh source, but really it should be not a global event stream, but configerd per-org since the gh sources can be multi-org.
	//                Potentially we should setup a WebHook on the Source interface, so each source could have a configured hook/hook path.. Sun Sep 20 03:25:05 2015
	go ghs.EventProcessor(ghook.Events)

	if !config.Opts.NoSync {
		wg.Wait()                         // make sure we have processed everything from github before other sources
		if err := sm.Sync(); err != nil { // sync supermarket
			log.Println("Error syncing supermarket ", err)
		}
	}

	log.Printf("starting server on %s:%d\n", config.Opts.Bind, config.Opts.Port)
	if config.Opts.TLS {
		log.Fatal(server.ListenAndServeTLS(config.Opts.Cert, config.Opts.Key))
	} else {
		log.Fatal(server.ListenAndServe())
	}
}