func newServerCommon(configFile string, ssl bool, c *C) *Server {
config := configuration.LoadConfiguration("../../" + configFile)
s := &Server{configFile: configFile, apiPort: config.ApiHttpPort, sslApiPort: config.ApiHttpSslPort, sslOnly: ssl}
c.Assert(os.RemoveAll(config.DataDir), IsNil)
c.Assert(os.RemoveAll(config.WalDir), IsNil)
c.Assert(os.RemoveAll(config.RaftDir), IsNil)
err := s.Start()
c.Assert(err, IsNil)
s.WaitForServerToStart()
return s
}
func (self *Server) DoesWalExist() error {
config := configuration.LoadConfiguration("../../" + self.configFile)
_, err := os.Stat(filepath.Join(config.WalDir, "log.1"))
return err
}
func main() {
fileName := flag.String("config", "config.toml.sample", "Config file")
wantsVersion := flag.Bool("v", false, "Get version number")
resetRootPassword := flag.Bool("reset-root", false, "Reset root password")
pidFile := flag.String("pidfile", "", "the pid file")
cpuProfiler := flag.String("cpuprofile", "", "filename where cpu profile data will be written")
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
startProfiler(cpuProfiler)
if wantsVersion != nil && *wantsVersion {
fmt.Printf("InfluxDB v%s (git: %s)\n", version, gitSha)
return
}
config := configuration.LoadConfiguration(*fileName)
setupLogging(config.LogLevel, config.LogFile)
if pidFile != nil && *pidFile != "" {
pid := strconv.Itoa(os.Getpid())
if err := ioutil.WriteFile(*pidFile, []byte(pid), 0644); err != nil {
panic(err)
}
}
log.Info("Starting Influx Server...")
log.Info(`
+---------------------------------------------+
| _____ __ _ _____ ____ |
| |_ _| / _| | | __ \| _ \ |
| | | _ __ | |_| |_ ___ _| | | | |_) | |
| | | | '_ \| _| | | | \ \/ / | | | _ < |
| _| |_| | | | | | | |_| |> <| |__| | |_) | |
| |_____|_| |_|_| |_|\__,_/_/\_\_____/|____/ |
+---------------------------------------------+
`)
os.MkdirAll(config.RaftDir, 0744)
os.MkdirAll(config.DataDir, 0744)
server, err := server.NewServer(config)
if err != nil {
panic(err)
}
if *resetRootPassword {
// TODO: make this not suck
// This is ghetto as hell, but it'll work for now.
go func() {
time.Sleep(2 * time.Second) // wait for the raft server to join the cluster
log.Warn("Resetting root's password to %s", coordinator.DEFAULT_ROOT_PWD)
if err := server.RaftServer.CreateRootUser(); err != nil {
panic(err)
}
}()
}
err = server.ListenAndServe()
if err != nil {
log.Error("ListenAndServe failed: ", err)
}
}
func main() {
fileName := flag.String("config", "config.json.sample", "Config file")
wantsVersion := flag.Bool("v", false, "Get version number")
resetRootPassword := flag.Bool("reset-root", false, "Reset root password")
pidFile := flag.String("pidfile", "", "the pid file")
cpuProfiler := flag.String("cpuprofile", "", "filename where cpu profile data will be written")
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
startProfiler(cpuProfiler)
if wantsVersion != nil && *wantsVersion {
fmt.Printf("InfluxDB v%s (git: %s)\n", version, gitSha)
return
}
config := configuration.LoadConfiguration(*fileName)
if pidFile != nil && *pidFile != "" {
pid := strconv.Itoa(os.Getpid())
if err := ioutil.WriteFile(*pidFile, []byte(pid), 0644); err != nil {
panic(err)
}
}
log.Println("Starting Influx Server...")
clusterConfig := coordinator.NewClusterConfiguration()
os.MkdirAll(config.RaftDir, 0744)
raftServer := coordinator.NewRaftServer(config.RaftDir, "localhost", config.RaftServerPort, clusterConfig)
go func() {
raftServer.ListenAndServe(config.SeedServers, false)
}()
if *resetRootPassword {
time.Sleep(2 * time.Second) // wait for the raft server to join the cluster
fmt.Printf("Resetting root's password to %s", coordinator.DEFAULT_ROOT_PWD)
if err := raftServer.CreateRootUser(); err != nil {
panic(err)
}
}
os.MkdirAll(config.DataDir, 0744)
log.Println("Opening database at ", config.DataDir)
db, err := datastore.NewLevelDbDatastore(config.DataDir)
if err != nil {
panic(err)
}
coord := coordinator.NewCoordinatorImpl(db, raftServer, clusterConfig)
eng, err := engine.NewQueryEngine(coord)
if err != nil {
panic(err)
}
log.Println()
adminServer := admin.NewHttpServer(config.AdminAssetsDir, config.AdminHttpPortString())
log.Println("Starting admin interface on port", config.AdminHttpPort)
go func() {
adminServer.ListenAndServe()
}()
log.Println("Starting Http Api server on port", config.ApiHttpPort)
server := http.NewHttpServer(config.ApiHttpPortString(), eng, coord, coord)
server.ListenAndServe()
}
func main() {
fileName := flag.String("config", "config.sample.toml", "Config file")
wantsVersion := flag.Bool("v", false, "Get version number")
resetRootPassword := flag.Bool("reset-root", false, "Reset root password")
hostname := flag.String("hostname", "", "Override the hostname, the `hostname` config option will be overridden")
raftPort := flag.Int("raft-port", 0, "Override the raft port, the `raft.port` config option will be overridden")
protobufPort := flag.Int("protobuf-port", 0, "Override the protobuf port, the `protobuf_port` config option will be overridden")
pidFile := flag.String("pidfile", "", "the pid file")
repairLeveldb := flag.Bool("repair-ldb", false, "set to true to repair the leveldb files")
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
version := fmt.Sprintf("InfluxDB v%s (git: %s) (leveldb: %d.%d)", version, gitSha, levigo.GetLevelDBMajorVersion(), levigo.GetLevelDBMinorVersion())
if wantsVersion != nil && *wantsVersion {
fmt.Println(version)
return
}
config := configuration.LoadConfiguration(*fileName)
// override the hostname if it was specified on the command line
if hostname != nil && *hostname != "" {
config.Hostname = *hostname
}
if raftPort != nil && *raftPort != 0 {
config.RaftServerPort = *raftPort
}
if protobufPort != nil && *protobufPort != 0 {
config.ProtobufPort = *protobufPort
}
config.Version = version
setupLogging(config.LogLevel, config.LogFile)
if *repairLeveldb {
log.Info("Repairing leveldb")
files, err := ioutil.ReadDir(config.DataDir)
if err != nil {
panic(err)
}
o := levigo.NewOptions()
defer o.Close()
for _, f := range files {
p := path.Join(config.DataDir, f.Name())
log.Info("Repairing %s", p)
if err := levigo.RepairDatabase(p, o); err != nil {
panic(err)
}
}
}
if pidFile != nil && *pidFile != "" {
pid := strconv.Itoa(os.Getpid())
if err := ioutil.WriteFile(*pidFile, []byte(pid), 0644); err != nil {
panic(err)
}
}
if config.BindAddress == "" {
log.Info("Starting Influx Server %s...", version)
} else {
log.Info("Starting Influx Server %s bound to %s...", version, config.BindAddress)
}
fmt.Printf(`
+---------------------------------------------+
| _____ __ _ _____ ____ |
| |_ _| / _| | | __ \| _ \ |
| | | _ __ | |_| |_ ___ _| | | | |_) | |
| | | | '_ \| _| | | | \ \/ / | | | _ < |
| _| |_| | | | | | | |_| |> <| |__| | |_) | |
| |_____|_| |_|_| |_|\__,_/_/\_\_____/|____/ |
+---------------------------------------------+
`)
os.MkdirAll(config.RaftDir, 0744)
os.MkdirAll(config.DataDir, 0744)
server, err := server.NewServer(config)
if err != nil {
// sleep for the log to flush
time.Sleep(time.Second)
panic(err)
}
if err := startProfiler(server); err != nil {
panic(err)
}
if *resetRootPassword {
// TODO: make this not suck
// This is ghetto as hell, but it'll work for now.
go func() {
time.Sleep(2 * time.Second) // wait for the raft server to join the cluster
log.Warn("Resetting root's password to %s", coordinator.DEFAULT_ROOT_PWD)
if err := server.RaftServer.CreateRootUser(); err != nil {
panic(err)
}
}()
}
err = server.ListenAndServe()
if err != nil {
log.Error("ListenAndServe failed: ", err)
}
}