func createDriver(scheduler *Scheduler, settings *Settings) (*mesossched.MesosSchedulerDriver, error) {
publishedAddr := net.ParseIP(settings.MessengerAddress)
bindingPort := settings.MessengerPort
credential, err := getCredential(settings)
if err != nil {
return nil, err
}
return mesossched.NewMesosSchedulerDriver(mesossched.DriverConfig{
Master: settings.Master,
Framework: &mesosproto.FrameworkInfo{
Id: getFrameworkID(settings),
Name: proto.String(settings.Name),
User: proto.String(settings.User),
Checkpoint: proto.Bool(settings.Checkpoint),
FailoverTimeout: proto.Float64(settings.FailoverTimeout),
Principal: getPrincipalID(credential),
},
Scheduler: scheduler,
BindingAddress: net.ParseIP("0.0.0.0"),
PublishedAddress: publishedAddr,
BindingPort: bindingPort,
Credential: credential,
WithAuthContext: getAuthContext,
})
}
func main() {
minTasks := flag.Int("min", 1, "The start size of the cluster")
port := flag.Int("port", 10001, "The port the framework should listen on")
master := flag.String("master", "10.0.0.26:5050", "Location of leading Mesos master")
flag.Parse()
scheduler := newMemcacheScheduler(*minTasks)
// PICK UP HERE, make this return registered memcache endpoints. Make memcache start on actually allocated ports
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(scheduler.TaskStatuses); err != nil {
fmt.Println(err)
}
})
go http.ListenAndServe(":"+strconv.Itoa(*port), nil)
driver, err := sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: *master,
Framework: &mesos.FrameworkInfo{
Name: proto.String("MEMCACHE"),
User: proto.String(""),
},
Scheduler: scheduler,
})
if err != nil {
log.Printf("Unable to create scheduler driver: %s", err)
return
}
// Catch interrupt
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
s := <-c
if s != os.Interrupt {
return
}
log.Println("Memcache is shutting down")
close(scheduler.shutdown)
select {
case <-scheduler.done:
case <-time.After(SHUTDOWN_TIMEOUT):
}
// we have shut down
driver.Stop(false)
}()
log.Printf("Starting driver")
if status, err := driver.Run(); err != nil {
log.Printf("Framework stopped with status %s and error: %s\n", status.String(), err.Error())
}
log.Println("Exiting...")
}
func main() {
// build command executor
exec := prepareExecutorInfo()
// the framework
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Test Framework (Go)"),
}
cred := (*mesos.Credential)(nil)
if *mesosAuthPrincipal != "" {
fwinfo.Principal = proto.String(*mesosAuthPrincipal)
cred = &mesos.Credential{
Principal: proto.String(*mesosAuthPrincipal),
}
if *mesosAuthSecretFile != "" {
_, err := os.Stat(*mesosAuthSecretFile)
if err != nil {
log.Fatal("missing secret file: ", err.Error())
}
secret, err := ioutil.ReadFile(*mesosAuthSecretFile)
if err != nil {
log.Fatal("failed to read secret file: ", err.Error())
}
cred.Secret = proto.String(string(secret))
}
}
bindingAddress := parseIP(*address)
config := sched.DriverConfig{
Scheduler: newExampleScheduler(exec),
Framework: fwinfo,
Master: *master,
Credential: cred,
BindingAddress: bindingAddress,
WithAuthContext: func(ctx context.Context) context.Context {
ctx = auth.WithLoginProvider(ctx, *authProvider)
ctx = sasl.WithBindingAddress(ctx, bindingAddress)
return ctx
},
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Errorln("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
time.Sleep(2 * time.Second)
os.Exit(1)
}
log.Infof("framework terminating")
}
func main() {
flag.Parse()
var user, pass string
if flag.NArg() == 1 {
user = ""
pass = flag.Arg(0)
} else if flag.NArg() == 2 {
user = flag.Arg(0)
pass = flag.Arg(1)
} else {
printUsage()
println(flag.NArg())
return
}
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""),
Name: proto.String("BTC Mining Framework (Go)"),
}
cred := (*mesos.Credential)(nil)
if *mesosAuthPrincipal != "" {
fwinfo.Principal = proto.String(*mesosAuthPrincipal)
secret, err := ioutil.ReadFile(*mesosAuthSecretFile)
if err != nil {
log.Fatal(err)
}
cred = &mesos.Credential{
Principal: proto.String(*mesosAuthPrincipal),
Secret: secret,
}
}
config := sched.DriverConfig{
Scheduler: newMinerScheduler(user, pass),
Framework: fwinfo,
Master: *master,
Credential: cred,
WithAuthContext: func(ctx context.Context) context.Context {
ctx = auth.WithLoginProvider(ctx, *authProvider)
return ctx
},
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Errorln("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}
func startScheduler() (reflex *scheduler.ReflexScheduler, start func()) {
exec := &mesos.ExecutorInfo{
ExecutorId: util.NewExecutorID("default"),
Name: proto.String("BH executor (Go)"),
Source: proto.String("bh_test"),
Command: &mesos.CommandInfo{
Value: proto.String(""),
Uris: []*mesos.CommandInfo_URI{},
},
}
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""),
Name: proto.String("reflex"),
}
// skipping creds for now...
// cred := (*mesos.Credential)(nil)
// if *mesosAuthPrincipal != "" {
// fwinfo.Principal = proto.String(*mesosAuthPrincipal)
// secret, err := ioutil.ReadFile(*mesosAuthSecretFile)
// if err != nil {
// logrus.WithField("error", err).Fatal("failed reading secret file")
// }
// cred = &mesos.Credential{
// Principal: proto.String(*mesosAuthPrincipal),
// Secret: secret,
// }
// }
reflex = scheduler.NewScheduler(exec)
config := sched.DriverConfig{
Scheduler: reflex,
Framework: fwinfo,
Master: "127.0.0.1:5050", // TODO: grab this from somewhere
// Credential: cred,
}
start = func() {
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
logrus.WithField("error", err).Fatal("unable to create a SchedulerDriver")
}
if stat, err := driver.Run(); err != nil {
logrus.WithFields(logrus.Fields{
"status": stat.String(),
"error": err,
}).Info("framework stopped")
}
}
return reflex, start
}
func main() {
startDrone()
// build command executor
exec := prepareExecutorInfo()
// the framework
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Drone Framework"),
}
cred := (*mesos.Credential)(nil)
if *mesosAuthPrincipal != "" {
fwinfo.Principal = proto.String(*mesosAuthPrincipal)
secret, err := ioutil.ReadFile(*mesosAuthSecretFile)
if err != nil {
log.Fatal(err)
}
cred = &mesos.Credential{
Principal: proto.String(*mesosAuthPrincipal),
Secret: secret,
}
}
fmt.Println("Address: ", address)
fmt.Println("Master: ", master)
bindingAddress := parseIP(address)
fmt.Println("bindingAddress: ", bindingAddress)
config := sched.DriverConfig{
Scheduler: newExampleScheduler(exec),
Framework: fwinfo,
Master: master,
Credential: cred,
BindingAddress: bindingAddress,
WithAuthContext: func(ctx context.Context) context.Context {
ctx = auth.WithLoginProvider(ctx, *authProvider)
ctx = sasl.WithBindingAddress(ctx, bindingAddress)
return ctx
},
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Errorln("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}
func (s *Scheduler) Start() error {
Logger.Infof("Starting scheduler with configuration: \n%s", Config)
sched = s // set this scheduler reachable for http server
ctrlc := make(chan os.Signal, 1)
signal.Notify(ctrlc, os.Interrupt)
if err := s.resolveDeps(); err != nil {
return err
}
listenAddr := s.listenAddr()
s.httpServer = NewHttpServer(listenAddr)
go s.httpServer.Start()
s.cluster = NewCluster()
s.labels = os.Getenv("STACK_LABELS")
frameworkInfo := &mesos.FrameworkInfo{
User: proto.String(Config.User),
Name: proto.String(Config.FrameworkName),
Role: proto.String(Config.FrameworkRole),
Checkpoint: proto.Bool(true),
Labels: utils.StringToLabels(s.labels),
}
driverConfig := scheduler.DriverConfig{
Scheduler: s,
Framework: frameworkInfo,
Master: Config.Master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
go func() {
<-ctrlc
s.Shutdown(driver)
}()
if err != nil {
return fmt.Errorf("Unable to create SchedulerDriver: %s", err)
}
if stat, err := driver.Run(); err != nil {
Logger.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err)
return err
}
//TODO stop http server
return nil
}
func main() {
flag.Parse()
ctrlc := make(chan os.Signal, 1)
signal.Notify(ctrlc, os.Interrupt)
frameworkInfo := &mesosproto.FrameworkInfo{
User: proto.String(*user),
Name: proto.String("Syphon Framework"),
}
schedulerConfig := framework.NewElodinaTransportSchedulerConfig()
schedulerConfig.CpuPerTask = *cpuPerTask
schedulerConfig.MemPerTask = *memPerTask
schedulerConfig.Topics = strings.Split(*topics, ",")
schedulerConfig.ExecutorBinaryName = "executor"
schedulerConfig.ServiceHost = *artifactServerHost
schedulerConfig.ServicePort = *artifactServerPort
schedulerConfig.ThreadsPerTask = *threadsPerTask
schedulerConfig.TargetURL = *targetUrl
schedulerConfig.SSLCertFilePath = *certFile
schedulerConfig.SSLKeyFilePath = *keyFile
schedulerConfig.SSLCACertFilePath = *caFile
schedulerConfig.ApiKey = *apiKey
schedulerConfig.ApiUser = *apiUser
schedulerConfig.Insecure = *insecure
schedulerConfig.ConsumerConfig = mustReadConsumerConfig(*consumerConfigPath)
transportScheduler := framework.NewElodinaTransportScheduler(schedulerConfig)
driverConfig := scheduler.DriverConfig{
Scheduler: transportScheduler,
Framework: frameworkInfo,
Master: *master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
go func() {
<-ctrlc
transportScheduler.Shutdown(driver)
driver.Stop(false)
}()
if err != nil {
fmt.Println("Unable to create a SchedulerDriver ", err.Error())
}
go startArtifactServer()
if stat, err := driver.Run(); err != nil {
fmt.Println("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}
func NewDriver(master string, s sched.Scheduler) (sched.SchedulerDriver, error) {
if master == "" {
return nil, errors.New("driver: empty master")
}
return sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: master,
Framework: &pb.FrameworkInfo{
Name: proto.String("Fuzzlr"),
// User: proto.String(""),
},
Scheduler: s,
})
}
func main() {
// Start HTTP server hosting executor binary
uri := ServeExecutorArtifact(*address, *artifactPort, *executorPath)
// Executor
exec := prepareExecutorInfo(uri, getExecutorCmd(*executorPath))
// Scheduler
numTasks, err := strconv.Atoi(*taskCount)
if err != nil {
log.Fatalf("Failed to convert '%v' to an integer with error: %v\n", taskCount, err)
os.Exit(-1)
}
scheduler := NewExampleScheduler(exec, numTasks, CPUS_PER_TASK, MEM_PER_TASK, *externalServer)
if err != nil {
log.Fatalf("Failed to create scheduler with error: %v\n", err)
os.Exit(-2)
}
//Start trigger server
go trigger.RunTriggerServer(scheduler)
// Framework
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Test Framework (Go)"),
}
// Scheduler Driver
config := sched.DriverConfig{
Scheduler: scheduler,
Framework: fwinfo,
Master: *master,
Credential: (*mesos.Credential)(nil),
BindingAddress: parseIP(*address),
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Fatalf("Unable to create a SchedulerDriver: %v\n", err.Error())
os.Exit(-3)
}
if stat, err := driver.Run(); err != nil {
log.Fatalf("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
os.Exit(-4)
}
}
// NewScheduler for Scheduler mesos driver creation
func NewScheduler(config mesosscheduler.DriverConfig, cluster *Cluster, sched *scheduler.Scheduler) (*Scheduler, error) {
scheduler := Scheduler{
Scheduler: *sched,
cluster: cluster,
}
config.Scheduler = &scheduler
driver, err := mesosscheduler.NewMesosSchedulerDriver(config)
if err != nil {
return nil, err
}
scheduler.driver = driver
return &scheduler, nil
}
func main() {
seedURL := flag.String("seed", "http://mesosphere.com", "The first URL to crawl")
master := flag.String("master", "127.0.1.1:5050", "Location of leading Mesos master")
localMode := flag.Bool("local", true, "If true, saves rendered web pages on local disk")
flag.Parse()
scheduler := newRendlerScheduler(*seedURL, *localMode)
driver, err := sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: *master,
Framework: &mesos.FrameworkInfo{
Name: proto.String("RENDLER"),
User: proto.String(""),
},
Scheduler: scheduler,
})
if err != nil {
log.Printf("Unable to create scheduler driver: %s", err)
return
}
// Catch interrupt
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
s := <-c
if s != os.Interrupt {
return
}
log.Println("RENDLER is shutting down")
close(scheduler.shutdown)
select {
case <-scheduler.done:
case <-time.After(shutdownTimeout):
}
if err := rendler.WriteDOTFile(scheduler.crawlResults, scheduler.renderResults); err != nil {
log.Printf("Could not write DOT file: %s", err)
}
// we have shut down
driver.Stop(false)
}()
if status, err := driver.Run(); err != nil {
log.Printf("Framework stopped with status %s and error: %s\n", status.String(), err.Error())
}
log.Println("Exiting...")
}
func InitializeScheduler() (*DiegoScheduler, *sched.MesosSchedulerDriver) {
exec := prepareExecutorInfo()
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Diego Scheduler"),
}
cred := (*mesos.Credential)(nil)
if *mesosAuthPrincipal != "" {
fwinfo.Principal = proto.String(*mesosAuthPrincipal)
secret_bytes, err := ioutil.ReadFile(*mesosAuthSecretFile)
secret := string(secret_bytes[:])
if err != nil {
log.Fatal(err)
}
cred = &mesos.Credential{
Principal: proto.String(*mesosAuthPrincipal),
Secret: &secret,
}
}
bindingAddressParsed := parseIP(*bindingAddress)
publishedAddressParsed := bindingAddressParsed
if *publishedAddress != "" {
publishedAddressParsed = parseIP(*publishedAddress)
}
digoScheduler := NewDiegoScheduler(exec)
config := sched.DriverConfig{
Scheduler: digoScheduler,
Framework: fwinfo,
Master: *master,
Credential: cred,
BindingAddress: bindingAddressParsed,
PublishedAddress: publishedAddressParsed,
WithAuthContext: func(ctx context.Context) context.Context {
ctx = auth.WithLoginProvider(ctx, *authProvider)
ctx = sasl.WithBindingAddress(ctx, bindingAddressParsed)
return ctx
},
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Fatal("Unable to create a SchedulerDriver ", err.Error())
}
return digoScheduler, driver
}
func NewDriver(master string, s sched.Scheduler) (sched.SchedulerDriver, error) {
if master == "" {
return nil, errors.New("driver: empty master")
}
return sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: master,
Framework: &pb.FrameworkInfo{
Name: proto.String("Fuzzlr"),
Checkpoint: proto.Bool(true),
FailoverTimeout: proto.Float64(60 * 60 * 24 * 7),
// User: proto.String(""),
},
Scheduler: s,
})
}
func main() {
if *version {
fmt.Printf("NONE v%s\n", VERSION)
os.Exit(0)
}
workdirPath := tarWorkdir()
if workdirPath != nil {
defer os.Remove(*workdirPath)
}
uris = exportArtifacts(workdirPath)
containerInfo = prepareContainer()
cmdq := NewCommandQueue()
cs, err := ParseConstraints(constraints)
if err != nil {
log.Errorln("Error parsing constraints", err)
os.Exit(10)
}
handler := NewCommandHandler()
scheduler := NewNoneScheduler(cmdq, handler, prepareResourceFilter(cs))
fwinfo := prepareFrameworkInfo()
cred := prepateCredentials(fwinfo)
config, err := prepareDriver(scheduler, NewZkLeaderDetector(), fwinfo, cred)
if err != nil {
log.Errorln("Unable to create a mesos driver:", err.Error())
os.Exit(10)
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Errorln("Unable to create a SchedulerDriver:", err.Error())
os.Exit(10)
}
queueCommands(cmdq)
// run the driver and wait for it to finish
if stat, err := driver.Run(); err != nil {
log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
os.Exit(2)
}
if handler.HasFailures() {
os.Exit(1)
}
}
func main() {
execUri, execCmd = serveExecutorArtifact(*executorPath)
// the framework
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Test Framework (Go)"),
Role: proto.String(*role),
}
cred := (*mesos.Credential)(nil)
if *mesosAuthPrincipal != "" {
fwinfo.Principal = proto.String(*mesosAuthPrincipal)
if *mesosAuthSecretFile != "" {
secret, err := ioutil.ReadFile(*mesosAuthSecretFile)
if err != nil {
log.Fatal(err)
}
cred = &mesos.Credential{
Principal: proto.String(*mesosAuthPrincipal),
Secret: secret,
}
}
}
bindingAddress := parseIP(*address)
config := sched.DriverConfig{
Scheduler: newExampleScheduler(),
Framework: fwinfo,
Master: *master,
Credential: cred,
BindingAddress: bindingAddress,
WithAuthContext: func(ctx context.Context) context.Context {
ctx = auth.WithLoginProvider(ctx, *authProvider)
ctx = sasl.WithBindingAddress(ctx, bindingAddress)
return ctx
},
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Errorln("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
log.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
log.Infof("framework terminating")
}
func (s *Scheduler) Start() error {
Logger.Infof("Starting scheduler with configuration: \n%s", Config)
sched = s // set this scheduler reachable for http server
ctrlc := make(chan os.Signal, 1)
signal.Notify(ctrlc, os.Interrupt)
s.cluster = NewCluster()
s.cluster.Load()
s.httpServer = NewHttpServer(Config.Api)
go s.httpServer.Start()
frameworkInfo := &mesos.FrameworkInfo{
User: proto.String(Config.User),
Name: proto.String(Config.FrameworkName),
Role: proto.String(Config.FrameworkRole),
FailoverTimeout: proto.Float64(float64(Config.FrameworkTimeout / 1e9)),
Checkpoint: proto.Bool(true),
}
if s.cluster.frameworkID != "" {
frameworkInfo.Id = util.NewFrameworkID(s.cluster.frameworkID)
}
driverConfig := scheduler.DriverConfig{
Scheduler: s,
Framework: frameworkInfo,
Master: Config.Master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
s.schedulerDriver = driver
if err != nil {
return fmt.Errorf("Unable to create SchedulerDriver: %s", err)
}
go func() {
if stat, err := driver.Run(); err != nil {
Logger.Infof("Framework stopped with status %s and error: %s\n", stat.String(), err)
panic(err)
}
}()
<-ctrlc
return nil
}
func createDriver(scheduler *eremeticScheduler) (*sched.MesosSchedulerDriver, error) {
publishedAddr := net.ParseIP(viper.GetString("messenger_address"))
bindingPort := uint16(viper.GetInt("messenger_port"))
return sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: viper.GetString("master"),
Framework: &mesos.FrameworkInfo{
Name: proto.String("Eremetic"),
User: proto.String(""),
},
Scheduler: scheduler,
BindingAddress: net.ParseIP("0.0.0.0"),
PublishedAddress: publishedAddr,
BindingPort: bindingPort,
})
}
func main() {
parseAndValidateSchedulerArgs()
ctrlc := make(chan os.Signal, 1)
signal.Notify(ctrlc, os.Interrupt)
frameworkInfo := &mesosproto.FrameworkInfo{
User: proto.String(""),
Name: proto.String("Go LogLine Transform Framework"),
}
schedulerConfig := transform.NewTransformSchedulerConfig()
schedulerConfig.ArtifactServerHost = *artifactServerHost
schedulerConfig.ArtifactServerPort = *artifactServerPort
schedulerConfig.ExecutorArchiveName = *executorArchiveName
schedulerConfig.ExecutorBinaryName = *executorBinaryName
schedulerConfig.Instances = *instances
schedulerConfig.CpuPerTask = *cpuPerTask
schedulerConfig.MemPerTask = *memPerTask
schedulerConfig.ProducerConfig = *producerConfig
schedulerConfig.Topic = *topic
schedulerConfig.Sync = *sync
go startArtifactServer(schedulerConfig)
transformScheduler := transform.NewTransformScheduler(schedulerConfig)
driverConfig := scheduler.DriverConfig{
Scheduler: transformScheduler,
Framework: frameworkInfo,
Master: *master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
go func() {
<-ctrlc
transformScheduler.Shutdown(driver)
driver.Stop(false)
}()
if err != nil {
fmt.Println("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
fmt.Println("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}
func (s *StackDeployScheduler) Start() error {
Logger.Info("Starting scheduler")
frameworkInfo := &mesos.FrameworkInfo{
User: proto.String(s.User),
Name: proto.String(s.FrameworkName),
Role: proto.String(s.FrameworkRole),
FailoverTimeout: proto.Float64(float64(s.FailoverTimeout / 1e9)),
Checkpoint: proto.Bool(true),
}
if s.Storage.FrameworkID != "" {
frameworkInfo.Id = mesosutil.NewFrameworkID(s.Storage.FrameworkID)
}
driverConfig := scheduler.DriverConfig{
Scheduler: s,
Framework: frameworkInfo,
Master: s.Master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
if err != nil {
return fmt.Errorf("Unable to create SchedulerDriver: %s", err)
}
go func() {
if stat, err := driver.Run(); err != nil {
Logger.Info("Framework stopped with status %s and error: %s", stat.String(), err)
panic(err)
}
}()
s.Cron.Start()
go func() {
for {
Logger.Info("Cron entries: %v\n", s.Cron.Entries())
for _, entry := range s.Cron.Entries() {
Logger.Info("Entry: %v, %v, %v, %v", entry.Prev, entry.Next, entry.Schedule, entry.Job)
}
time.Sleep(10 * time.Second)
}
}()
return nil
}
func main() {
var master = flag.String("master", "127.0.0.1:5050", "Master address <ip:port>")
log.Infoln("Lancement PGAgentScheduler") //, time.Now())
flag.Parse()
config := scheduler.DriverConfig{
Master: *master,
Scheduler: forbin.NewDatabaseScheduler(
&mesos.ExecutorInfo{
ExecutorId: util.NewExecutorID("default"),
Name: proto.String("FBN"),
Source: proto.String("fb_test"),
Command: &mesos.CommandInfo{
Value: proto.String(CMD),
Uris: []*mesos.CommandInfo_URI{
&mesos.CommandInfo_URI{
Value: proto.String("http://localhost:8080/postgresql-bin.tar.gz"),
Extract: proto.Bool(true),
},
&mesos.CommandInfo_URI{
Value: proto.String("http://localhost:8080/tools.tar.gz"),
Extract: proto.Bool(true),
},
}},
},
),
Framework: &mesos.FrameworkInfo{
Name: proto.String(NAME),
User: proto.String(""),
},
}
driver, err := scheduler.NewMesosSchedulerDriver(config)
if err != nil {
log.Fatalln("Unable to create a SchedulerDriver ", err.Error())
}
if stat, err := driver.Run(); err != nil {
log.Infoln("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}
func createDriver(scheduler *eremeticScheduler) (*sched.MesosSchedulerDriver, error) {
publishedAddr := net.ParseIP(viper.GetString("messenger_address"))
bindingPort := uint16(viper.GetInt("messenger_port"))
return sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: viper.GetString("master"),
Framework: &mesos.FrameworkInfo{
Id: getFrameworkID(),
Name: proto.String(viper.GetString("name")),
User: proto.String(viper.GetString("user")),
Checkpoint: proto.Bool(viper.GetBool("checkpoint")),
FailoverTimeout: proto.Float64(viper.GetFloat64("failover_timeout")),
},
Scheduler: scheduler,
BindingAddress: net.ParseIP("0.0.0.0"),
PublishedAddress: publishedAddr,
BindingPort: bindingPort,
})
}
func runScheduler() error {
config := sched.DriverConfig{
Scheduler: newScheduler(),
Framework: &mesos.FrameworkInfo{
User: proto.String(""),
Name: proto.String("Elevators"),
},
Master: "127.0.0.1:5050",
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
return err
}
status, err := driver.Run()
if err != nil {
return fmt.Errorf("framework stopped with %s: %s", status, err)
}
return nil
}
func main() {
log.Info("Creating scheduler")
scheduler, err := NewScheduler()
if err != nil {
log.Fatalf("Unable to create scheduler: %s\n", err.Error())
os.Exit(1)
}
log.Infof("Created scheduler %+v\n", scheduler)
log.Info("Creating framework info")
fwinfo := &mesos.FrameworkInfo{
User: proto.String(""),
Name: proto.String("basicdocker-2"),
}
log.Infof("Created fwinfo %+v\n", fwinfo)
log.Info("Creating scheduler driver config")
config := sched.DriverConfig{
Scheduler: scheduler,
Framework: fwinfo,
Master: *master,
Credential: (*mesos.Credential)(nil),
}
log.Infof("Created driver config %+v\n", config)
log.Info("Creating new scheduler driver from config")
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Fatalf("Unable to create a SchedulerDriver: %v\n", err.Error())
os.Exit(3)
}
log.Infof("Created scheduler driver %+v\n", driver)
log.Info("Starting scheduler driver")
if stat, err := driver.Run(); err != nil {
log.Fatalf("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
os.Exit(4)
}
}
func main() {
// Start HTTP server hosting executor binary
uri := ServeSchedulerAPI(*address, *artifactPort)
// Executor
executorInfo := prepareExecutorInfo(uri, getExecutorCmd(*executorPath))
// Scheduler
scheduler, err := NewScraperScheduler(executorInfo, CPUS_PER_TASK, MEM_PER_TASK)
if err != nil {
log.Fatalf("Failed to create scheduler with error: %v\n", err)
os.Exit(-2)
}
// Framework
frameworkInfo := &mesos.FrameworkInfo{
User: proto.String(""), // Mesos-go will fill in user.
Name: proto.String("Web Scraper"),
}
// Scheduler Driver
config := sched.DriverConfig{
Scheduler: scheduler,
Framework: frameworkInfo,
Master: *master,
Credential: (*mesos.Credential)(nil),
BindingAddress: parseIP(*address),
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Fatalf("Unable to create a SchedulerDriver: %v\n", err.Error())
os.Exit(-3)
}
if stat, err := driver.Run(); err != nil {
log.Fatalf("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
os.Exit(-4)
}
}
func main() {
log.V(1).Infoln("Initializing the Example Scheduler...")
config = loadConfig()
// the framework
fwinfo := fwinfo()
driver, err := sched.NewMesosSchedulerDriver(driverConfig(fwinfo))
if err != nil {
log.Errorln("Unable to create a SchedulerDriver ", err.Error())
}
// Don't block on this call because we need printLogs to be the process blocker to ensure we retrieve all the logs.
go func() {
if stat, err := driver.Run(); err != nil {
log.V(1).Infof("Framework stopped with status %s and error: %s\n", stat.String(), err.Error())
}
}()
printLogs()
}
func NewScheduler(mesosMaster, bridgeCIDR string) error {
log.Info("Rancher Mesos Scheduler started")
scheduler := &rancherScheduler{
rancherExecutor: &mesos.ExecutorInfo{
Command: &mesos.CommandInfo{
Value: proto.String(cmd + " --bridge_cidr=" + bridgeCIDR),
Uris: []*mesos.CommandInfo_URI{},
},
ExecutorId: &mesos.ExecutorID{Value: proto.String("rancher-mesos-executor")},
Name: proto.String("RancherExecutor"),
},
}
driver, err := sched.NewMesosSchedulerDriver(sched.DriverConfig{
Master: mesosMaster,
Framework: &mesos.FrameworkInfo{
Name: proto.String("RancherMesos"),
User: proto.String("root"), // make this configurable
},
Scheduler: scheduler,
})
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Error("Error starting scheduler driver")
return err
}
_, err = driver.Run()
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Error("Error Running driver")
return err
}
_, err = driver.Stop(false)
return err
}
func (self *MesosManager) Start(engine *agro_engine.WorkEngine) {
self.engine = engine
self.executor = self.BuildExecutorInfo()
//frameworkIdStr := FRAMEWORK_ID
failoverTimeout := 0.0
//frameworkId := &mesos.FrameworkID{Value: &frameworkIdStr}
config := sched.DriverConfig{
Master: self.master,
Framework: &mesos.FrameworkInfo{
Name: proto.String("AgroFramework"),
User: proto.String(""),
FailoverTimeout: &failoverTimeout,
//Id: frameworkId,
},
Scheduler: self,
}
driver, err := sched.NewMesosSchedulerDriver(config)
if err != nil {
log.Printf("Driver Error: %s", err)
panic(err)
}
//driver.Init()
//defer driver.Destroy()
//go self.EventLoop()
status, err := driver.Start()
log.Printf("Driver Status:%s", status)
if err != nil {
log.Printf("Mesos Start Error: %s", err)
panic(err)
}
//<-self.exit
//log.Printf("Mesos Exit")
//driver.Stop(false)
}
// NewFramework initializes Taurus framework with the provided configuration options
//
// NewFramework initializes Mesos Scheduler driver and creates HTTP API server
// It returns error if either Mesos driver or HTTP API server could not be created
func NewFramework(config *Config) (*Taurus, error) {
fwInfo := &mesos.FrameworkInfo{
User: proto.String(config.User),
Name: proto.String(FrameworkName),
}
sched, err := NewScheduler(config.Worker, config.Master)
if err != nil {
return nil, fmt.Errorf("Unable to create %s Scheduler: %s", FrameworkName, err)
}
driverConfig := scheduler.DriverConfig{
Scheduler: sched,
Framework: fwInfo,
Master: config.Master,
}
driver, err := scheduler.NewMesosSchedulerDriver(driverConfig)
if err != nil {
return nil, fmt.Errorf("Unable to create a SchedulerDriver: %s", err)
}
api, err := NewApi(&ApiConfig{
Address: config.ListenAddr,
TlsConfig: config.TlsConfig,
Store: config.Store,
})
if err != nil {
return nil, fmt.Errorf("Could not create %s API server: %s", FrameworkName, err)
}
return &Taurus{
fwInfo: fwInfo,
driver: driver,
scheduler: sched,
api: api,
}, 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
}