func (s *S) SetUpTest(c *check.C) { queue.ResetQueue() err := rebuild.RegisterTask(func(appName string) (rebuild.RebuildApp, error) { a, err := app.GetByName(appName) if err == app.ErrAppNotFound { return nil, nil } return a, err }) c.Assert(err, check.IsNil) routertest.FakeRouter.Reset() provisiontest.ProvisionerInstance.Reset() err = dbtest.ClearAllCollections(s.conn.Apps().Database) c.Assert(err, check.IsNil) s.user = &auth.User{Email: "*****@*****.**", Password: "******", Quota: quota.Unlimited} nativeScheme := auth.ManagedScheme(native.NativeScheme{}) app.AuthScheme = nativeScheme _, err = nativeScheme.Create(s.user) c.Assert(err, check.IsNil) s.team = &auth.Team{Name: "admin"} c.Assert(err, check.IsNil) err = s.conn.Teams().Insert(s.team) c.Assert(err, check.IsNil) err = provision.AddPool(provision.AddPoolOptions{ Name: "p1", Default: true, Provisioner: "fake", }) c.Assert(err, check.IsNil) }
func (s *S) SetUpTest(c *check.C) { // Reset fake routers twice, first time will remove registered failures and // allow pending enqueued tasks to run, second time (after queue is reset) // will remove any routes added by executed queue tasks. routertest.FakeRouter.Reset() routertest.HCRouter.Reset() queue.ResetQueue() routertest.FakeRouter.Reset() routertest.HCRouter.Reset() err := rebuild.RegisterTask(func(appName string) (rebuild.RebuildApp, error) { a, err := GetByName(appName) if err == ErrAppNotFound { return nil, nil } return a, err }) c.Assert(err, check.IsNil) config.Set("docker:router", "fake") s.provisioner.Reset() repositorytest.Reset() dbtest.ClearAllCollections(s.conn.Apps().Database) s.createUserAndTeam(c) platform := Platform{Name: "python"} s.conn.Platforms().Insert(platform) s.defaultPlan = Plan{ Name: "default-plan", Memory: 1024, Swap: 1024, CpuShare: 100, Default: true, Router: "fake", } err = s.conn.Plans().Insert(s.defaultPlan) c.Assert(err, check.IsNil) s.Pool = "pool1" opts := provision.AddPoolOptions{Name: s.Pool, Default: true} err = provision.AddPool(opts) c.Assert(err, check.IsNil) repository.Manager().CreateUser(s.user.Email) factory, err := queue.Factory() c.Assert(err, check.IsNil) factory.Reset() }
func startServer(handler http.Handler) { shutdownChan := make(chan bool) shutdownTimeout, _ := config.GetInt("shutdown-timeout") if shutdownTimeout == 0 { shutdownTimeout = 10 * 60 } idleTracker := newIdleTracker() shutdown.Register(idleTracker) shutdown.Register(&logTracker) readTimeout, _ := config.GetInt("server:read-timeout") writeTimeout, _ := config.GetInt("server:write-timeout") listen, err := config.GetString("listen") if err != nil { fatal(err) } srv := &graceful.Server{ Timeout: time.Duration(shutdownTimeout) * time.Second, Server: &http.Server{ ReadTimeout: time.Duration(readTimeout) * time.Second, WriteTimeout: time.Duration(writeTimeout) * time.Second, Addr: listen, Handler: handler, }, ConnState: func(conn net.Conn, state http.ConnState) { idleTracker.trackConn(conn, state) }, NoSignalHandling: true, ShutdownInitiated: func() { fmt.Println("tsuru is shutting down, waiting for pending connections to finish.") handlers := shutdown.All() wg := sync.WaitGroup{} for _, h := range handlers { wg.Add(1) go func(h shutdown.Shutdownable) { defer wg.Done() fmt.Printf("running shutdown handler for %v...\n", h) h.Shutdown() fmt.Printf("running shutdown handler for %v. DONE.\n", h) }(h) } wg.Wait() close(shutdownChan) }, } sigChan := make(chan os.Signal, 1) signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM) go func() { <-sigChan srv.Stop(srv.Timeout) }() var startupMessage string routers, err := router.List() if err != nil { fatal(err) } for _, routerDesc := range routers { var r router.Router r, err = router.Get(routerDesc.Name) if err != nil { fatal(err) } fmt.Printf("Registered router %q", routerDesc.Name) if messageRouter, ok := r.(router.MessageRouter); ok { startupMessage, err = messageRouter.StartupMessage() if err == nil && startupMessage != "" { fmt.Printf(": %s", startupMessage) } } fmt.Println() } defaultRouter, _ := config.GetString("docker:router") fmt.Printf("Default router is %q.\n", defaultRouter) repoManager, err := config.GetString("repo-manager") if err != nil { repoManager = "gandalf" fmt.Println("Warning: configuration didn't declare a repository manager, using default manager.") } fmt.Printf("Using %q repository manager.\n", repoManager) err = rebuild.RegisterTask(appFinder) if err != nil { fatal(err) } scheme, err := getAuthScheme() if err != nil { fmt.Printf("Warning: configuration didn't declare auth:scheme, using default scheme.\n") } app.AuthScheme, err = auth.GetScheme(scheme) if err != nil { fatal(err) } fmt.Printf("Using %q auth scheme.\n", scheme) err = provision.InitializeAll() if err != nil { fatal(err) } _, err = healer.Initialize() if err != nil { fatal(err) } fmt.Println("Checking components status:") results := hc.Check() for _, result := range results { if result.Status != hc.HealthCheckOK { fmt.Printf(" WARNING: %q is not working: %s\n", result.Name, result.Status) } } fmt.Println(" Components checked.") tls, _ := config.GetBool("use-tls") if tls { var ( certFile string keyFile string ) certFile, err = config.GetString("tls:cert-file") if err != nil { fatal(err) } keyFile, err = config.GetString("tls:key-file") if err != nil { fatal(err) } fmt.Printf("tsuru HTTP/TLS server listening at %s...\n", listen) err = srv.ListenAndServeTLS(certFile, keyFile) } else { fmt.Printf("tsuru HTTP server listening at %s...\n", listen) err = srv.ListenAndServe() } if err != nil { fmt.Printf("Listening stopped: %s\n", err) if errOp, ok := err.(*net.OpError); ok { if errOp.Op == "listen" { os.Exit(1) } } } <-shutdownChan }