// NewServer returns a new instance of Server.
func NewServer(c *server.Config) *Server {
configureLogging()
buildInfo := server.BuildInfo{
Version: "testServer",
Commit: "testCommit",
Branch: "testBranch",
}
c.HTTP.LogEnabled = testing.Verbose()
ls := loggingtest.New()
srv, err := server.New(c, buildInfo, ls)
if err != nil {
panic(err)
}
s := Server{
Server: srv,
Config: c,
}
return &s
}
// Run parses the config from args and runs the server.
func (cmd *Command) Run(args ...string) error {
// Parse the command line flags.
options, err := cmd.ParseFlags(args...)
if err != nil {
return err
}
// Print sweet Kapacitor logo.
fmt.Print(logo)
// Parse config
config, err := cmd.ParseConfig(FindConfigPath(options.ConfigPath))
if err != nil {
return fmt.Errorf("parse config: %s", err)
}
// Apply any environment variables on top of the parsed config
if err := config.ApplyEnvOverrides(); err != nil {
return fmt.Errorf("apply env config: %v", err)
}
// Override config hostname if specified in the command line args.
if options.Hostname != "" {
config.Hostname = options.Hostname
}
// Override config logging file if specified in the command line args.
if options.LogFile != "" {
config.Logging.File = options.LogFile
}
// Override config logging level if specified in the command line args.
if options.LogLevel != "" {
config.Logging.Level = options.LogLevel
}
// Initialize Logging Services
cmd.logService = logging.NewService(config.Logging, cmd.Stdout, cmd.Stderr)
err = cmd.logService.Open()
if err != nil {
return fmt.Errorf("init logging: %s", err)
}
// Initialize packages loggers
tick.SetLogger(cmd.logService.NewLogger("[tick] ", log.LstdFlags))
// Initialize cmd logger
cmd.Logger = cmd.logService.NewLogger("[run] ", log.LstdFlags)
// Mark start-up in log.,
cmd.Logger.Printf("I! Kapacitor starting, version %s, branch %s, commit %s", cmd.Version, cmd.Branch, cmd.Commit)
cmd.Logger.Printf("I! Go version %s", runtime.Version())
// Write the PID file.
if err := cmd.writePIDFile(options.PIDFile); err != nil {
return fmt.Errorf("write pid file: %s", err)
}
// Create server from config and start it.
buildInfo := server.BuildInfo{Version: cmd.Version, Commit: cmd.Commit, Branch: cmd.Branch}
s, err := server.New(config, buildInfo, cmd.logService)
if err != nil {
return fmt.Errorf("create server: %s", err)
}
s.CPUProfile = options.CPUProfile
s.MemProfile = options.MemProfile
if err := s.Open(); err != nil {
return fmt.Errorf("open server: %s", err)
}
cmd.Server = s
// Begin monitoring the server's error channel.
go cmd.monitorServerErrors()
return nil
}