Example #1
0
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)
}
Example #2
0
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)
}
Example #3
0
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)
}
Example #4
0
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)
}