func TestServer_Serve_Success(t *testing.T) { // clear any previous responses var ( ts testServer // You can typically find this on your mac here: "/usr/local/Cellar/collectd/5.4.1/share/collectd/types.db" s = collectd.NewServer(ts, "./collectd_test.conf") addr = "127.0.0.1:25830" ) s.Database = "counter" e := collectd.ListenAndServe(s, addr) defer s.Close() if e != nil { t.Fatalf("err does not match. expected %v, got %v", nil, e) } conn, e := net.Dial("udp", addr) defer conn.Close() if e != nil { t.Fatalf("err does not match. expected %v, got %v", nil, e) } buf, e := hex.DecodeString("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") if e != nil { t.Fatalf("err from hex.DecodeString does not match. expected %v, got %v", nil, e) } _, e = conn.Write(buf) if e != nil { t.Fatalf("err does not match. expected %v, got %v", nil, e) } if _, err := ts.ResponseN(33); err != nil { t.Fatal(err) } }
func TestServer_ListenAndServe_ErrDatabaseNotSpecified(t *testing.T) { var ( ts testServer s = collectd.NewServer(ts, "foo") ) e := collectd.ListenAndServe(s, "127.0.0.1:25826") if e == nil { t.Fatalf("expected an error, got %v", e) } }
func TestServer_ListenAndServe_ErrBindAddressRequired(t *testing.T) { var ( ts testServer s = collectd.NewServer(ts, "foo") ) e := collectd.ListenAndServe(s, "") if e == nil { t.Fatalf("expected an error, got %v", e) } }
func TestServer_ListenAndServe_ErrCouldNotParseTypesDBFile(t *testing.T) { var ( ts testServer s = collectd.NewServer(ts, "foo") ) s.Database = "foo" e := collectd.ListenAndServe(s, "127.0.0.1:25829") if e == nil { t.Fatalf("expected an error, got %v", e) } }
func TestServer_ListenAndServe_ErrResolveUDPAddr(t *testing.T) { var ( ts testServer s = collectd.NewServer(ts, "./collectd_test.conf") ) s.Database = "counter" e := collectd.ListenAndServe(s, "foo") if e == nil { t.Fatalf("expected an error, got %v", e) } }
func TestServer_ListenAndServe_Success(t *testing.T) { var ( ts testServer // You can typically find this on your mac here: "/usr/local/Cellar/collectd/5.4.1/share/collectd/types.db" s = collectd.NewServer(ts, "./collectd_test.conf") ) s.Database = "counter" e := collectd.ListenAndServe(s, "127.0.0.1:25830") defer s.Close() if e != nil { t.Fatalf("err does not match. expected %v, got %v", nil, e) } }
func TestServer_ListenAndServe_ErrListenUDP(t *testing.T) { var ( ts testServer s = collectd.NewServer(ts, "./collectd_test.conf") ) //Open a udp listener on the port prior to force it to err addr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:25826") conn, _ := net.ListenUDP("udp", addr) defer conn.Close() s.Database = "counter" e := collectd.ListenAndServe(s, "127.0.0.1:25826") if e == nil { t.Fatalf("expected an error, got %v", e) } }
// execRun runs the "run" command. func execRun(args []string) { // Parse command flags. fs := flag.NewFlagSet("", flag.ExitOnError) var ( configPath = fs.String("config", "", "") pidPath = fs.String("pidfile", "", "") hostname = fs.String("hostname", "", "") join = fs.String("join", "", "") ) fs.Usage = printRunUsage fs.Parse(args) // Print sweet InfluxDB logo and write the process id to file. log.Print(logo) log.SetPrefix(`[srvr] `) log.SetFlags(log.LstdFlags) writePIDFile(*pidPath) // Parse the configuration and determine if a broker and/or server exist. config := parseConfig(*configPath, *hostname) configExists := *configPath != "" initializing := !fileExists(config.BrokerDir()) && !fileExists(config.DataDir()) // Parse join urls from the --join flag. var joinURLs []*url.URL if *join == "" { joinURLs = parseURLs(config.JoinURLs()) } else { joinURLs = parseURLs(*join) } // Open broker, initialize or join as necessary. b := openBroker(config.BrokerDir(), config.BrokerURL(), initializing, joinURLs) // Start the broker handler. var h *Handler if b != nil { h = &Handler{brokerHandler: messaging.NewHandler(b)} go func() { log.Fatal(http.ListenAndServe(config.BrokerAddr(), h)) }() log.Printf("broker listening on %s", config.BrokerAddr()) } // Open server, initialize or join as necessary. s := openServer(config.DataDir(), config.DataURL(), b, initializing, configExists, joinURLs) // Start the server handler. Attach to broker if listening on the same port. if s != nil { sh := httpd.NewHandler(s, config.Authentication.Enabled, version) if h != nil && config.BrokerAddr() == config.DataAddr() { h.serverHandler = sh } else { go func() { log.Fatal(http.ListenAndServe(config.DataAddr(), sh)) }() } log.Printf("data node #%d listening on %s", s.ID(), config.DataAddr()) // Spin up the collectd server if config.Collectd.Enabled { c := config.Collectd cs := collectd.NewServer(s, c.TypesDB) cs.Database = c.Database err := collectd.ListenAndServe(cs, c.ConnectionString(config.BindAddress)) if err != nil { log.Printf("failed to start collectd Server: %v\n", err.Error()) } } // Spin up any Graphite servers for _, c := range config.Graphites { if !c.Enabled { continue } // Configure Graphite parsing. parser := graphite.NewParser() parser.Separator = c.NameSeparatorString() parser.LastEnabled = c.LastEnabled() // Start the relevant server. if strings.ToLower(c.Protocol) == "tcp" { g := graphite.NewTCPServer(parser, s) g.Database = c.Database err := g.ListenAndServe(c.ConnectionString(config.BindAddress)) if err != nil { log.Printf("failed to start TCP Graphite Server: %v\n", err.Error()) } } else if strings.ToLower(c.Protocol) == "udp" { g := graphite.NewUDPServer(parser, s) g.Database = c.Database err := g.ListenAndServe(c.ConnectionString(config.BindAddress)) if err != nil { log.Printf("failed to start UDP Graphite Server: %v\n", err.Error()) } } else { log.Fatalf("unrecognized Graphite Server prototcol %s", c.Protocol) } } } // Wait indefinitely. <-(chan struct{})(nil) }
func Run(config *Config, join, version string, logWriter *os.File) (*messaging.Broker, *influxdb.Server) { log.Printf("influxdb started, version %s, commit %s", version, commit) // Parse the configuration and determine if a broker and/or server exist. configExists := config != nil if config == nil { config = NewConfig() } var initBroker, initServer bool if initBroker = !fileExists(config.BrokerDir()); initBroker { log.Printf("Broker directory missing. Need to create a broker.") } if initServer = !fileExists(config.DataDir()); initServer { log.Printf("Data directory missing. Need to create data directory.") } initServer = initServer || initBroker // Parse join urls from the --join flag. var joinURLs []*url.URL if join == "" { joinURLs = parseURLs(config.JoinURLs()) } else { joinURLs = parseURLs(join) } // Open broker, initialize or join as necessary. b := openBroker(config.BrokerDir(), config.BrokerURL(), initBroker, joinURLs, logWriter) // Configure debug of Raft module. b.EnableRaftDebug(config.Logging.RaftTracing) // Start the broker handler. var h *Handler if b != nil { h = &Handler{brokerHandler: messaging.NewHandler(b.Broker)} // We want to make sure we are spun up before we exit this function, so we manually listen and serve listener, err := net.Listen("tcp", config.BrokerAddr()) if err != nil { log.Fatalf("Broker failed to listen on %s. %s ", config.BrokerAddr(), err) } go func() { err := http.Serve(listener, h) if err != nil { log.Fatalf("Broker failed to server on %s.: %s", config.BrokerAddr(), err) } }() log.Printf("broker listening on %s", config.BrokerAddr()) // have it occasionally tell a data node in the cluster to run continuous queries if config.ContinuousQuery.Disable { log.Printf("Not running continuous queries. [continuous_queries].disable is set to true.") } else { b.RunContinuousQueryLoop() } } // Open server, initialize or join as necessary. s := openServer(config, b, initServer, initBroker, configExists, joinURLs, logWriter) s.SetAuthenticationEnabled(config.Authentication.Enabled) // Enable retention policy enforcement if requested. if config.Data.RetentionCheckEnabled { interval := time.Duration(config.Data.RetentionCheckPeriod) if err := s.StartRetentionPolicyEnforcement(interval); err != nil { log.Fatalf("retention policy enforcement failed: %s", err.Error()) } log.Printf("broker enforcing retention policies with check interval of %s", interval) } // Start shard group pre-create interval := config.ShardGroupPreCreateCheckPeriod() if err := s.StartShardGroupsPreCreate(interval); err != nil { log.Fatalf("shard group pre-create failed: %s", err.Error()) } log.Printf("shard group pre-create with check interval of %s", interval) // Start the server handler. Attach to broker if listening on the same port. if s != nil { sh := httpd.NewHandler(s, config.Authentication.Enabled, version) sh.SetLogOutput(logWriter) sh.WriteTrace = config.Logging.WriteTracing if h != nil && config.BrokerAddr() == config.DataAddr() { h.serverHandler = sh } else { // We want to make sure we are spun up before we exit this function, so we manually listen and serve listener, err := net.Listen("tcp", config.DataAddr()) if err != nil { log.Fatal(err) } go func() { log.Fatal(http.Serve(listener, sh)) }() } log.Printf("data node #%d listening on %s", s.ID(), config.DataAddr()) // Start the admin interface on the default port if config.Admin.Enabled { port := fmt.Sprintf(":%d", config.Admin.Port) log.Printf("starting admin server on %s", port) a := admin.NewServer(port) go a.ListenAndServe() } // Spin up the collectd server if config.Collectd.Enabled { c := config.Collectd cs := collectd.NewServer(s, c.TypesDB) cs.Database = c.Database err := collectd.ListenAndServe(cs, c.ConnectionString(config.BindAddress)) if err != nil { log.Printf("failed to start collectd Server: %v\n", err.Error()) } } // Start the server bound to a UDP listener if config.UDP.Enabled { log.Printf("Starting UDP listener on %s", config.DataAddrUDP()) u := udp.NewUDPServer(s) if err := u.ListenAndServe(config.DataAddrUDP()); err != nil { log.Printf("Failed to start UDP listener on %s: %s", config.DataAddrUDP(), err) } } // Spin up any Graphite servers for _, c := range config.Graphites { if !c.Enabled { continue } // Configure Graphite parsing. parser := graphite.NewParser() parser.Separator = c.NameSeparatorString() parser.LastEnabled = c.LastEnabled() if err := s.CreateDatabaseIfNotExists(c.DatabaseString()); err != nil { log.Fatalf("failed to create database for %s Graphite server: %s", c.Protocol, err.Error()) } // Spin up the server. var g graphite.Server g, err := graphite.NewServer(c.Protocol, parser, s, c.DatabaseString()) if err != nil { log.Fatalf("failed to initialize %s Graphite server: %s", c.Protocol, err.Error()) } g.SetLogOutput(logWriter) err = g.ListenAndServe(c.ConnectionString(config.BindAddress)) if err != nil { log.Fatalf("failed to start %s Graphite server: %s", c.Protocol, err.Error()) } } } // unless disabled, start the loop to report anonymous usage stats every 24h if !config.ReportingDisabled { // Make sure we have a config object b4 we try to use it. if configObj := b.Broker.Log().Config(); configObj != nil { clusterID := configObj.ClusterID go s.StartReportingLoop(version, clusterID) } } return b.Broker, s }