// StartFlexVolumeAPI starts the flexvolume API on the given port.
func StartFlexVolumeAPI(port uint16) error {
grpcServer := grpc.NewServer(grpc.MaxConcurrentStreams(math.MaxUint32))
flexvolume.RegisterAPIServer(grpcServer, flexvolume.NewAPIServer(newFlexVolumeClient()))
listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
if err != nil {
return err
}
go func() {
if err := grpcServer.Serve(listener); err != nil {
dlog.Errorln(err.Error())
}
}()
return nil
}
func (c *ClusterManager) Start() error {
dlog.Infoln("Cluster manager starting...")
c.gEnabled = true
c.selfNode = api.Node{}
c.selfNode.GenNumber = uint64(time.Now().UnixNano())
c.selfNode.Id = c.config.NodeId
c.selfNode.Status = api.Status_STATUS_OK
c.selfNode.MgmtIp, c.selfNode.DataIp, _ = ExternalIp(&c.config)
c.selfNode.NodeData = make(map[string]interface{})
c.system = systemutils.New()
// Start the gossip protocol.
// XXX Make the port configurable.
gob.Register(api.Node{})
c.gossip = gossip.New("0.0.0.0:9002", types.NodeId(c.config.NodeId),
c.selfNode.GenNumber)
c.gossip.SetGossipInterval(2 * time.Second)
kvdb := kvdb.Instance()
kvlock, err := kvdb.Lock(clusterLockKey, 60)
if err != nil {
dlog.Panicln("Fatal, Unable to obtain cluster lock.", err)
}
defer kvdb.Unlock(kvlock)
db, err := readDatabase()
if err != nil {
dlog.Panicln(err)
}
// Cluster database max size... 0 if unlimited.
c.size = db.Size
if db.Status == api.Status_STATUS_INIT {
dlog.Infoln("Will initialize a new cluster.")
c.status = api.Status_STATUS_OK
db.Status = api.Status_STATUS_OK
self, _ := c.initNode(&db)
err = c.initCluster(&db, self, false)
if err != nil {
dlog.Errorln("Failed to initialize the cluster.", err)
return err
}
// Update the new state of the cluster in the KV Database
err := writeDatabase(&db)
if err != nil {
dlog.Errorln("Failed to save the database.", err)
return err
}
} else if db.Status&api.Status_STATUS_OK > 0 {
dlog.Infoln("Cluster state is OK... Joining the cluster.")
c.status = api.Status_STATUS_OK
self, exist := c.initNode(&db)
err = c.joinCluster(&db, self, exist)
if err != nil {
dlog.Errorln("Failed to join cluster.", err)
return err
}
err := writeDatabase(&db)
if err != nil {
return err
}
} else {
return errors.New("Fatal, Cluster is in an unexpected state.")
}
// Start heartbeating to other nodes.
go c.startHeartBeat()
go c.updateClusterStatus()
kvdb.WatchKey(ClusterDBKey, 0, nil, c.watchDB)
return nil
}
func start(c *cli.Context) {
if !osdcli.DaemonMode(c) {
cli.ShowAppHelp(c)
return
}
datastores := []string{mem.Name, etcd.Name, consul.Name}
// We are in daemon mode.
file := c.String("file")
if file == "" {
dlog.Warnln("OSD configuration file not specified. Visit openstorage.org for an example.")
return
}
cfg, err := config.Parse(file)
if err != nil {
dlog.Errorln(err)
return
}
kvdbURL := c.String("kvdb")
u, err := url.Parse(kvdbURL)
scheme := u.Scheme
u.Scheme = "http"
kv, err := kvdb.New(scheme, "openstorage", []string{u.String()}, nil)
if err != nil {
dlog.Warnf("Failed to initialize KVDB: %v (%v)", scheme, err)
dlog.Warnf("Supported datastores: %v", datastores)
return
}
err = kvdb.SetInstance(kv)
if err != nil {
dlog.Warnf("Failed to initialize KVDB: %v", err)
return
}
// Start the cluster state machine, if enabled.
clusterInit := false
if cfg.Osd.ClusterConfig.NodeId != "" && cfg.Osd.ClusterConfig.ClusterId != "" {
dlog.Infof("OSD enabling cluster mode.")
if err := cluster.Init(cfg.Osd.ClusterConfig); err != nil {
dlog.Errorln("Unable to init cluster server: %v", err)
return
}
clusterInit = true
if err := server.StartClusterAPI(config.ClusterAPIBase); err != nil {
dlog.Warnf("Unable to start cluster API server: %v", err)
return
}
}
// Start the volume drivers.
for d, v := range cfg.Osd.Drivers {
dlog.Infof("Starting volume driver: %v", d)
if _, err := volume.New(d, v); err != nil {
dlog.Warnf("Unable to start volume driver: %v, %v", d, err)
return
}
if err := server.StartPluginAPI(d, config.DriverAPIBase, config.PluginAPIBase); err != nil {
dlog.Warnf("Unable to start volume plugin: %v", err)
return
}
}
if err := server.StartFlexVolumeAPI(config.FlexVolumePort); err != nil {
dlog.Warnf("Unable to start flexvolume API: %v", err)
return
}
// Start the graph drivers.
for d, _ := range cfg.Osd.GraphDrivers {
dlog.Infof("Starting graph driver: %v", d)
if err := server.StartGraphAPI(d, config.PluginAPIBase); err != nil {
dlog.Warnf("Unable to start graph plugin: %v", err)
return
}
}
if clusterInit {
cm, err := cluster.Inst()
if err != nil {
dlog.Warnf("Unable to find cluster instance: %v", err)
return
}
if err := cm.Start(); err != nil {
dlog.Warnf("Unable to start cluster manager: %v", err)
return
}
}
// Daemon does not exit.
select {}
}