func (self *ResMan) Run(master string) {
frameworkIdStr := FRAMEWORK_ID
frameworkId := &mesos.FrameworkID{Value: &frameworkIdStr}
driver := mesos.SchedulerDriver{
Master: master,
Framework: mesos.FrameworkInfo{
Name: proto.String("TyrantFramework"),
User: proto.String(""),
FailoverTimeout: failoverTimeout,
Id: frameworkId,
},
Scheduler: &mesos.Scheduler{
ResourceOffers: self.OnResourceOffers,
StatusUpdate: self.OnStatusUpdate,
Error: self.OnError,
Disconnected: self.OnDisconnected,
Registered: self.OnRegister,
Reregistered: self.OnReregister,
},
}
driver.Init()
defer driver.Destroy()
go self.EventLoop()
driver.Start()
<-self.exit
log.Debug("exit")
driver.Stop(false)
}
func (self *ResMan) Run() {
master := flag.String("master", "localhost:5050", "Location of leading Mesos master")
flag.Parse()
frameworkIdStr := "tyrant"
frameworkId := &mesos.FrameworkID{Value: &frameworkIdStr}
failoverTimeout := flag.Float64("failoverTimeout", 60, "failover timeout")
driver := mesos.SchedulerDriver{
Master: *master,
Framework: mesos.FrameworkInfo{
Name: proto.String("GoFramework"),
User: proto.String(""),
FailoverTimeout: failoverTimeout,
Id: frameworkId,
},
Scheduler: &mesos.Scheduler{
ResourceOffers: self.OnResourceOffers,
StatusUpdate: self.OnStatusUpdate,
Error: self.OnError,
Disconnected: self.OnDisconnected,
Registered: self.OnRegister,
Reregistered: self.OnReregister,
},
}
driver.Init()
defer driver.Destroy()
go self.EventLoop()
driver.Start()
<-self.exit
log.Debug("exit")
driver.Stop(false)
}
func main() {
finishedLocales := 0
runningLocales := 0
taskId := 0
exit := make(chan bool)
agents := make(map[string]uint64)
saturated := false
master := flag.String("master", "localhost:5050", "Location of leading Mesos master")
namenode := flag.String("name-node", "localhost", "Location of bootstrap package and executables")
locales := flag.Int("locales", 1, "Number of Chapel locales i.e. number of nodes")
flag.Parse()
chapel_program := flag.Args()
args := len(chapel_program)
if args == 0 {
fmt.Println("No Chapel program found")
fmt.Println("Syntax: ./chapel (<options>) <chapel-program>")
os.Exit(1)
}
chapel_program = append(chapel_program, "-nl "+strconv.Itoa(*locales))
driver := mesos.SchedulerDriver{
Master: *master,
Framework: mesos.FrameworkInfo{
Name: proto.String("Chapel: " + strings.Join(chapel_program, " ")),
User: proto.String(""),
},
Scheduler: &mesos.Scheduler{
ResourceOffers: func(driver *mesos.SchedulerDriver, offers []mesos.Offer) {
for _, offer := range offers {
if saturated {
driver.DeclineOffer(offer.Id)
continue
}
var port uint64 = 0
var cpus float64 = 0
var mem float64 = 0
for _, resource := range offer.Resources {
if resource.GetName() == "cpus" {
cpus = *resource.GetScalar().Value
}
if resource.GetName() == "mem" {
mem = *resource.GetScalar().Value
}
if resource.GetName() == "ports" {
r := (*resource).GetRanges().Range[0]
port = r.GetBegin()
}
}
agents[*offer.Hostname] = port
bootstrap := *namenode + "/chapel/chapel-bootstrap.tgz"
target := *namenode + "/chapel/" + chapel_program[0] + "_real"
command := &mesos.CommandInfo{
Uris: []*mesos.CommandInfo_URI{
&mesos.CommandInfo_URI{Value: &bootstrap},
&mesos.CommandInfo_URI{Value: &target},
},
Value: proto.String("./bin/chapel-agent -port=" + strconv.FormatUint(port, 10)),
}
taskId++
tasks := []mesos.TaskInfo{
mesos.TaskInfo{
Name: proto.String("Chapel-agent"),
TaskId: &mesos.TaskID{
Value: proto.String("Chapel-agent-" + strconv.Itoa(taskId)),
},
SlaveId: offer.SlaveId,
Command: command,
Resources: []*mesos.Resource{
mesos.ScalarResource("cpus", cpus),
mesos.ScalarResource("mem", mem),
mesos.RangeResource("ports", port, port),
},
},
}
driver.LaunchTasks(offer.Id, tasks)
}
},
StatusUpdate: func(driver *mesos.SchedulerDriver, status mesos.TaskStatus) {
if *status.State == mesos.TaskState_TASK_FINISHED {
finishedLocales++
if finishedLocales >= *locales {
exit <- true
}
} else if *status.State == mesos.TaskState_TASK_RUNNING {
runningLocales++
if !saturated {
fmt.Println("[", runningLocales, "/", *locales, "] Setting up locale..")
if runningLocales >= *locales {
saturated = true
triggerAgents(chapel_program, agents)
}
}
} else {
fmt.Println("Received task status: " + mesos.TaskState_name[int32(*status.State)])
if status.Message != nil {
fmt.Println("Message: " + *status.Message)
}
}
},
},
}
driver.Init()
defer driver.Destroy()
driver.Start()
<-exit
driver.Stop(false)
}
func main() {
taskLimit := 5
taskId := 0
exit := make(chan bool)
localExecutor, _ := executorPath()
master := flag.String("master", "localhost:5050", "Location of leading Mesos master")
executorUri := flag.String("executor-uri", localExecutor, "URI of executor executable")
flag.Parse()
executor := &mesos.ExecutorInfo{
ExecutorId: &mesos.ExecutorID{Value: proto.String("default")},
Command: &mesos.CommandInfo{
Value: proto.String("./example_executor"),
Uris: []*mesos.CommandInfo_URI{
&mesos.CommandInfo_URI{Value: executorUri},
},
},
Name: proto.String("Test Executor (Go)"),
Source: proto.String("go_test"),
}
driver := mesos.SchedulerDriver{
Master: *master,
Framework: mesos.FrameworkInfo{
Name: proto.String("GoFramework"),
User: proto.String(""),
},
Scheduler: &mesos.Scheduler{
ResourceOffers: func(driver *mesos.SchedulerDriver, offers []mesos.Offer) {
for _, offer := range offers {
taskId++
fmt.Printf("Launching task: %d\n", taskId)
tasks := []mesos.TaskInfo{
mesos.TaskInfo{
Name: proto.String("go-task"),
TaskId: &mesos.TaskID{
Value: proto.String("go-task-" + strconv.Itoa(taskId)),
},
SlaveId: offer.SlaveId,
Executor: executor,
Resources: []*mesos.Resource{
mesos.ScalarResource("cpus", 1),
mesos.ScalarResource("mem", 512),
},
},
}
driver.LaunchTasks(offer.Id, tasks)
}
},
StatusUpdate: func(driver *mesos.SchedulerDriver, status mesos.TaskStatus) {
fmt.Println("Received task status: " + *status.Message)
if *status.State == mesos.TaskState_TASK_FINISHED {
taskLimit--
if taskLimit <= 0 {
exit <- true
}
}
},
},
}
driver.Init()
defer driver.Destroy()
driver.Start()
<-exit
driver.Stop(false)
}