// NewCluster for mesos Cluster creation func NewCluster(scheduler *scheduler.Scheduler, TLSConfig *tls.Config, master string, options cluster.DriverOpts, engineOptions *cluster.EngineOpts) (cluster.Cluster, error) { log.WithFields(log.Fields{"name": "mesos"}).Debug("Initializing cluster") // Enabling mesos-go glog logging if log.GetLevel() == log.DebugLevel { flag.Lookup("logtostderr").Value.Set("true") } cluster := &Cluster{ dockerEnginePort: defaultDockerEnginePort, eventHandlers: cluster.NewEventHandlers(), master: master, agents: make(map[string]*agent), TLSConfig: TLSConfig, options: &options, offerTimeout: defaultOfferTimeout, taskCreationTimeout: defaultTaskCreationTimeout, engineOpts: engineOptions, refuseTimeout: defaultRefuseTimeout, } cluster.pendingTasks = task.NewTasks(cluster) // Empty string is accepted by the scheduler. user, _ := options.String("mesos.user", "SWARM_MESOS_USER") // Override the hostname here because mesos-go will try // to shell out to the hostname binary and it won't work with our official image. // Do not check error here, so mesos-go can still try. hostname, _ := os.Hostname() driverConfig := mesosscheduler.DriverConfig{ Framework: &mesosproto.FrameworkInfo{Name: proto.String(frameworkName), User: &user}, Master: cluster.master, HostnameOverride: hostname, } if taskCreationTimeout, ok := options.String("mesos.tasktimeout", "SWARM_MESOS_TASK_TIMEOUT"); ok { d, err := time.ParseDuration(taskCreationTimeout) if err != nil { return nil, err } cluster.taskCreationTimeout = d } // Changing port for https if cluster.TLSConfig != nil { cluster.dockerEnginePort = defaultDockerEngineTLSPort } if bindingPort, ok := options.Uint("mesos.port", "SWARM_MESOS_PORT"); ok { driverConfig.BindingPort = uint16(bindingPort) } if bindingAddress, ok := options.IP("mesos.address", "SWARM_MESOS_ADDRESS"); ok { if bindingAddress == nil { value, _ := options.String("mesos.address", "SWARM_MESOS_ADDRESS") return nil, fmt.Errorf( "invalid IP address for cluster-opt mesos.address: \"%s\"", value) } driverConfig.BindingAddress = bindingAddress } if checkpointFailover, ok := options.Bool("mesos.checkpointfailover", "SWARM_MESOS_CHECKPOINT_FAILOVER"); ok { driverConfig.Framework.Checkpoint = &checkpointFailover } if offerTimeout, ok := options.String("mesos.offertimeout", "SWARM_MESOS_OFFER_TIMEOUT"); ok { d, err := time.ParseDuration(offerTimeout) if err != nil { return nil, err } cluster.offerTimeout = d } if refuseTimeout, ok := options.String("mesos.offerrefusetimeout", "SWARM_MESOS_OFFER_REFUSE_TIMEOUT"); ok { d, err := time.ParseDuration(refuseTimeout) if err != nil { return nil, err } cluster.refuseTimeout = d } sched, err := NewScheduler(driverConfig, cluster, scheduler) if err != nil { return nil, err } cluster.scheduler = sched status, err := sched.driver.Start() if err != nil { log.Debugf("Mesos driver started, status/err %v: %v", status, err) return nil, err } log.Debugf("Mesos driver started, status %v", status) go func() { status, err := sched.driver.Join() log.Debugf("Mesos driver stopped unexpectedly, status/err %v: %v", status, err) }() return cluster, nil }
// NewCluster for mesos Cluster creation func NewCluster(scheduler *scheduler.Scheduler, store *state.Store, TLSConfig *tls.Config, master string, options cluster.DriverOpts) (cluster.Cluster, error) { log.WithFields(log.Fields{"name": "mesos"}).Debug("Initializing cluster") cluster := &Cluster{ dockerEnginePort: defaultDockerEnginePort, master: master, slaves: make(map[string]*slave), scheduler: scheduler, store: store, TLSConfig: TLSConfig, options: &options, offerTimeout: defaultOfferTimeout, taskCreationTimeout: defaultTaskCreationTimeout, } cluster.pendingTasks = queue.NewQueue() // Empty string is accepted by the scheduler. user, _ := options.String("mesos.user", "SWARM_MESOS_USER") // Override the hostname here because mesos-go will try // to shell out to the hostname binary and it won't work with our official image. // Do not check error here, so mesos-go can still try. hostname, _ := os.Hostname() driverConfig := mesosscheduler.DriverConfig{ Scheduler: cluster, Framework: &mesosproto.FrameworkInfo{Name: proto.String(frameworkName), User: &user}, Master: cluster.master, HostnameOverride: hostname, } if taskCreationTimeout, ok := options.String("mesos.tasktimeout", "SWARM_MESOS_TASK_TIMEOUT"); ok { d, err := time.ParseDuration(taskCreationTimeout) if err != nil { return nil, err } cluster.taskCreationTimeout = d } // Changing port for https if cluster.TLSConfig != nil { cluster.dockerEnginePort = defaultDockerEngineTLSPort } if bindingPort, ok := options.Uint("mesos.port", "SWARM_MESOS_PORT"); ok { driverConfig.BindingPort = uint16(bindingPort) } if bindingAddress, ok := options.IP("mesos.address", "SWARM_MESOS_ADDRESS"); ok { if bindingAddress == nil { return nil, fmt.Errorf("invalid address %s", bindingAddress) } driverConfig.BindingAddress = bindingAddress } if offerTimeout, ok := options.String("mesos.offertimeout", "SWARM_MESOS_OFFER_TIMEOUT"); ok { d, err := time.ParseDuration(offerTimeout) if err != nil { return nil, err } cluster.offerTimeout = d } driver, err := mesosscheduler.NewMesosSchedulerDriver(driverConfig) if err != nil { return nil, err } cluster.driver = driver status, err := driver.Start() if err != nil { log.Debugf("Mesos driver started, status/err %v: %v", status, err) return nil, err } log.Debugf("Mesos driver started, status %v", status) return cluster, nil }
func (sc *SchedulerCore) Run(mesosMaster string) { sc.schedulerState.MesosMaster = mesosMaster var frameworkId *mesos.FrameworkID if sc.schedulerState.FrameworkID == nil { frameworkId = nil } else { frameworkId = &mesos.FrameworkID{ Value: sc.schedulerState.FrameworkID, } } fwinfo := &mesos.FrameworkInfo{ Name: proto.String(sc.frameworkName), Id: frameworkId, FailoverTimeout: proto.Float64(86400), WebuiUrl: proto.String(sc.schedulerHTTPServer.GetURI()), Checkpoint: proto.Bool(true), Role: proto.String(sc.frameworkRole), } if sc.user != "" { fwinfo.User = proto.String(sc.user) } else { guestUser := "******" fwinfo.User = &guestUser } cred := (*mesos.Credential)(nil) if sc.mesosAuthPrincipal != "" { fwinfo.Principal = proto.String(sc.mesosAuthPrincipal) } if sc.mesosAuthSecretFile != "" && sc.mesosAuthPrincipal != "" { secret, err := ioutil.ReadFile(sc.mesosAuthSecretFile) if err != nil { log.Fatal(err) } cred = &mesos.Credential{ Principal: proto.String(sc.mesosAuthPrincipal), Secret: secret, } } hostname, err := os.Hostname() if err != nil { log.Fatal(err) } config := sched.DriverConfig{ Scheduler: sc, Framework: fwinfo, Master: mesosMaster, Credential: cred, HostnameOverride: hostname, } if sc.schedulerIPAddr != "" { config.BindingAddress = parseIP(sc.schedulerIPAddr) } if sc.authProvider != "" && sc.mesosAuthPrincipal != "" { config.WithAuthContext = func(ctx context.Context) context.Context { ctx = auth.WithLoginProvider(ctx, sc.authProvider) if sc.schedulerIPAddr != "" { ctx = sasl.WithBindingAddress(ctx, parseIP(sc.schedulerIPAddr)) } return ctx } } log.Infof("Running scheduler with FrameworkInfo: %v and DriverConfig: %v", fwinfo, config) driver, err := sched.NewMesosSchedulerDriver(config) if err != nil { log.Error("Unable to create a SchedulerDriver ", err.Error()) } sc.rServer = newReconciliationServer(driver, sc) sc.mgr.SetupFramework(sc.schedulerHTTPServer.URI) if stat, err := driver.Run(); err != nil { log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error()) } }