func (s *ServerSuite) SetUpTest(c *C) {
st := stapler.New()
m, err := New(s.lastId, st, Options{})
c.Assert(err, IsNil)
s.mux = m
s.st = st
}
func (s *ServerSuite) TestCustomNotFound(c *C) {
st := stapler.New()
m, err := New(s.lastId, st, Options{NotFoundMiddleware: &appender{append: "Custom Not Found handler"}})
c.Assert(err, IsNil)
t := reflect.TypeOf(m.router.NotFound)
c.Assert(t.String(), Equals, "*proxy.appender")
}
func (s *ApiSuite) SetUpTest(c *C) {
newProxy := func(id int) (proxy.Proxy, error) {
return proxy.New(id, stapler.New(), proxy.Options{})
}
s.ng = memng.New(registry.GetRegistry())
sv := supervisor.New(newProxy, s.ng, make(chan error), supervisor.Options{})
app := scroll.NewApp()
InitProxyController(s.ng, sv, app)
s.testServer = httptest.NewServer(app.GetHandler())
s.client = NewClient(s.testServer.URL, registry.GetRegistry())
}
func (s *CmdSuite) SetUpTest(c *C) {
s.ng = memng.New(registry.GetRegistry())
newProxy := func(id int) (proxy.Proxy, error) {
return proxy.New(id, stapler.New(), proxy.Options{})
}
sv := supervisor.New(newProxy, s.ng, make(chan error), supervisor.Options{})
sv.Start()
s.sv = sv
app := scroll.NewApp()
api.InitProxyController(s.ng, sv, app)
s.testServer = httptest.NewServer(app.GetHandler())
s.out = &bytes.Buffer{}
s.cmd = &Command{registry: registry.GetRegistry(), out: s.out, vulcanUrl: s.testServer.URL}
}
func (s *Service) Start() error {
log.Init([]*log.LogConfig{&log.LogConfig{Name: s.options.Log}})
log.SetSeverity(s.options.LogSeverity.s)
log.Infof("Service starts with options: %#v", s.options)
if s.options.PidPath != "" {
ioutil.WriteFile(s.options.PidPath, []byte(fmt.Sprint(os.Getpid())), 0644)
}
if s.options.StatsdAddr != "" {
var err error
s.metricsClient, err = metrics.NewWithOptions(s.options.StatsdAddr, s.options.StatsdPrefix, metrics.Options{UseBuffering: true})
if err != nil {
return err
}
}
apiFile, muxFiles, err := s.getFiles()
if err != nil {
return err
}
if err := s.newEngine(); err != nil {
return err
}
s.stapler = stapler.New()
s.supervisor = supervisor.New(
s.newProxy, s.ng, s.errorC, supervisor.Options{Files: muxFiles})
// Tells configurator to perform initial proxy configuration and start watching changes
if err := s.supervisor.Start(); err != nil {
return err
}
if err := s.initApi(); err != nil {
return err
}
go func() {
s.errorC <- s.startApi(apiFile)
}()
if s.metricsClient != nil {
go s.reportSystemMetrics()
}
signal.Notify(s.sigC, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGUSR2, syscall.SIGCHLD)
// Block until a signal is received or we got an error
for {
select {
case signal := <-s.sigC:
switch signal {
case syscall.SIGTERM, syscall.SIGINT:
log.Infof("Got signal '%s', shutting down gracefully", signal)
s.supervisor.Stop(true)
log.Infof("All servers stopped")
return nil
case syscall.SIGKILL:
log.Infof("Got signal '%s', exiting now without waiting", signal)
s.supervisor.Stop(false)
return nil
case syscall.SIGUSR2:
log.Infof("Got signal '%s', forking a new self", signal)
if err := s.startChild(); err != nil {
log.Infof("Failed to start self: %s", err)
} else {
log.Infof("Successfully started self")
}
case syscall.SIGCHLD:
log.Warningf("Child exited, got '%s', collecting status", signal)
var wait syscall.WaitStatus
syscall.Wait4(-1, &wait, syscall.WNOHANG, nil)
log.Warningf("Collected exit status from child")
default:
log.Infof("Ignoring '%s'", signal)
}
case err := <-s.errorC:
log.Infof("Got request to shutdown with error: %s", err)
return err
}
}
}
func newProxy(id int) (proxy.Proxy, error) {
return proxy.New(id, stapler.New(), proxy.Options{})
}