func (c *ProxyController) updateLogSeverity(w http.ResponseWriter, r *http.Request, params map[string]string) (interface{}, error) {
s, err := log.SeverityFromString(r.Form.Get("severity"))
if err != nil {
return nil, formatError(err)
}
log.SetSeverity(s)
return scroll.Response{"message": fmt.Sprintf("Severity has been updated to %v", s)}, nil
}
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 (m *Mem) SetLogSeverity(sev log.Severity) {
m.LogSeverity = sev
log.SetSeverity(m.LogSeverity)
}