func (sched *Scheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { logOffers(offers) jobs, err := getLaunchableJobs() if err != nil { log.Errorf("Unable to get pending jobs! %s\n", err.Error()) return } offersAndTasks, err := packJobsInOffers(jobs, offers) if err != nil { log.Errorf("Unable to pack jobs into offers! %s\n", err.Error()) return } for _, ot := range offersAndTasks { if len(ot.Tasks) == 0 { log.Infof("Declining unused offer %s", ot.Offer.Id.GetValue()) driver.DeclineOffer(ot.Offer.Id, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) continue } else { log.Infof("Launching %d tasks for offer %s\n", len(ot.Tasks), ot.Offer.Id.GetValue()) driver.LaunchTasks([]*mesos.OfferID{ot.Offer.Id}, ot.Tasks, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) sched.tasksLaunched = sched.tasksLaunched + len(ot.Tasks) } } }
func (s *MemcacheScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { log.Printf("Received %d resource offers", len(offers)) for _, offer := range offers { select { case <-s.shutdown: log.Println("Shutting down: declining offer on [", offer.Hostname, "]") driver.DeclineOffer(offer.Id, defaultFilter) if s.tasksRunning == 0 { close(s.done) } continue default: } tasks := []*mesos.TaskInfo{} if canLaunchNewTask(offer) && s.shouldLaunchNewTask() { fmt.Println("Accepting Offer: ", offer) task := s.newMemcacheTask(offer) tasks = append(tasks, task) } if len(tasks) == 0 { driver.DeclineOffer(offer.Id, defaultFilter) } else { driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, defaultFilter) s.lastTaskCreatedAt = time.Now() return // limit one at a time } } }
// ResourceOffers handles the Resource Offers func (s *Scheduler) ResourceOffers(driver mesossched.SchedulerDriver, offers []*mesosproto.Offer) { logrus.WithField("offers", len(offers)).Debug("Received offers") var offer *mesosproto.Offer loop: for len(offers) > 0 { select { case <-s.shutdown: logrus.Info("Shutting down: declining offers") break loop case tid := <-s.tasks: logrus.WithField("task_id", tid).Debug("Trying to find offer to launch task with") t, _ := s.database.ReadUnmaskedTask(tid) if t.IsTerminating() { logrus.Debug("Dropping terminating task.") t.UpdateStatus(eremetic.Status{ Status: eremetic.TaskKilled, Time: time.Now().Unix(), }) s.database.PutTask(&t) continue } offer, offers = matchOffer(t, offers) if offer == nil { logrus.WithField("task_id", tid).Warn("Unable to find a matching offer") tasksDelayed.Inc() go func() { s.tasks <- tid }() break loop } logrus.WithFields(logrus.Fields{ "task_id": tid, "offer_id": offer.Id.GetValue(), }).Debug("Preparing to launch task") t, task := createTaskInfo(t, offer) t.UpdateStatus(eremetic.Status{ Status: eremetic.TaskStaging, Time: time.Now().Unix(), }) s.database.PutTask(&t) driver.LaunchTasks([]*mesosproto.OfferID{offer.Id}, []*mesosproto.TaskInfo{task}, defaultFilter) tasksLaunched.Inc() queueSize.Dec() continue default: break loop } } logrus.Debug("No tasks to launch. Declining offers.") for _, offer := range offers { driver.DeclineOffer(offer.Id, defaultFilter) } }
func (s *rancherScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { task := tasks.GetNextTask() if task == nil { for _, of := range offers { driver.DeclineOffer(of.Id, defaultFilter) } return } if task.RegistrationUrl == "" { tasks.AddTask(task) for _, of := range offers { driver.DeclineOffer(of.Id, defaultFilter) } return } taskBytes, err := task.Marshal() if err != nil { log.WithFields(log.Fields{ "err": err, }).Error("Error Marshalling task") for _, of := range offers { driver.DeclineOffer(of.Id, defaultFilter) } return } for _, offer := range offers { inadequate := false for _, res := range offer.GetResources() { if res.GetName() == "cpus" && *res.GetScalar().Value < taskCPUs { driver.DeclineOffer(offer.Id, defaultFilter) inadequate = true continue } if res.GetName() == "mem" && *res.GetScalar().Value < taskMem { driver.DeclineOffer(offer.Id, defaultFilter) inadequate = true continue } } if inadequate { continue } mesosTask := &mesos.TaskInfo{ TaskId: &mesos.TaskID{ Value: proto.String(task.HostUuid), }, SlaveId: offer.SlaveId, Resources: []*mesos.Resource{ mesosutil.NewScalarResource("cpus", taskCPUs), mesosutil.NewScalarResource("mem", taskMem), }, Data: taskBytes, Name: &task.Name, Executor: s.rancherExecutor, } driver.LaunchTasks([]*mesos.OfferID{offer.Id}, []*mesos.TaskInfo{mesosTask}, defaultFilter) } }
func (s *StackDeployScheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) { Logger.Debug("[ResourceOffers] %s", pretty.Offers(offers)) for _, offer := range offers { declineReason := s.acceptOffer(driver, offer) if declineReason != "" { driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(10)}) Logger.Debug("Declined offer %s: %s", pretty.Offer(offer), declineReason) } } }
// mesos.Scheduler interface method. // Invoked when resources have been offered to this framework. func (this *ElodinaTransportScheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) { log.Logger.Info("Received offers") offersAndTasks := make(map[*mesos.Offer][]*mesos.TaskInfo) remainingPartitions, err := this.GetTopicPartitions() if err != nil { return } remainingPartitions.RemoveAll(this.TakenTopicPartitions.GetArray()) log.Logger.Debug("%v", remainingPartitions) tps := remainingPartitions.GetArray() offersAndResources := this.wrapInOfferAndResources(offers) for !remainingPartitions.IsEmpty() { log.Logger.Debug("Iteration %v", remainingPartitions) if this.hasEnoughInstances() { for _, transfer := range this.taskIdToTaskState { if len(transfer.assignment) < this.config.ThreadsPerTask { transfer.assignment = append(transfer.assignment, tps[0]) remainingPartitions.Remove(tps[0]) this.TakenTopicPartitions.Add(tps[0]) if len(tps) > 1 { tps = tps[1:] } else { tps = []consumer.TopicAndPartition{} } } } } else { log.Logger.Debug("Trying to launch new task") offer, task := this.launchNewTask(offersAndResources) if offer != nil && task != nil { offersAndTasks[offer] = append(offersAndTasks[offer], task) } else { for _, offer := range offers { if _, exists := offersAndTasks[offer]; !exists { offersAndTasks[offer] = make([]*mesos.TaskInfo, 0) } } break } } } this.assignPendingPartitions() for _, offer := range offers { if tasks, ok := offersAndTasks[offer]; ok { driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) } else { driver.DeclineOffer(offer.Id, &mesos.Filters{RefuseSeconds: proto.Float64(10)}) } } }
// decline declines an offer. func (s *EtcdScheduler) decline( driver scheduler.SchedulerDriver, offer *mesos.Offer, ) { log.V(2).Infof("Declining offer %s.", offer.Id.GetValue()) driver.DeclineOffer( offer.Id, &mesos.Filters{ // Decline offers for 5 seconds. RefuseSeconds: proto.Float64(float64(5)), }, ) }
func (s *Scheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) { Logger.Debugf("[ResourceOffers] %s", pretty.Offers(offers)) for _, offer := range offers { declineReason := s.acceptOffer(driver, offer) if declineReason != "" { driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(10)}) Logger.Debugf("Declined offer: %s", declineReason) } } s.reconcileTasks(false) s.cluster.Save() }
func (sched *ScraperScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { logOffers(offers) for _, offer := range offers { if sched.tasksLaunched >= sched.totalTasks || len(sched.urls) == 0 { log.Infof("Declining offer %s", offer.Id.GetValue()) driver.DeclineOffer(offer.Id, &mesos.Filters{}) continue } remainingCpus := getOfferCpu(offer) remainingMems := getOfferMem(offer) var tasks []*mesos.TaskInfo for sched.cpuPerTask <= remainingCpus && sched.memPerTask <= remainingMems && sched.tasksLaunched < sched.totalTasks { log.Infof("Processing url %v of %v\n", sched.tasksLaunched, sched.totalTasks) log.Infof("Total Tasks: %d", sched.totalTasks) log.Infof("Tasks Launched: %d", sched.tasksLaunched) uri := sched.urls[sched.tasksLaunched] log.Infof("URI: %s", uri) sched.tasksLaunched++ taskId := &mesos.TaskID{ Value: proto.String(strconv.Itoa(sched.tasksLaunched)), } task := &mesos.TaskInfo{ Name: proto.String("go-task-" + taskId.GetValue()), TaskId: taskId, SlaveId: offer.SlaveId, Executor: sched.executor, Resources: []*mesos.Resource{ util.NewScalarResource("cpus", sched.cpuPerTask), util.NewScalarResource("mem", sched.memPerTask), }, Data: []byte(uri), } log.Infof("Prepared task: %s with offer %s for launch\n", task.GetName(), offer.Id.GetValue()) tasks = append(tasks, task) remainingCpus -= sched.cpuPerTask remainingMems -= sched.memPerTask } log.Infoln("Launching ", len(tasks), "tasks for offer", offer.Id.GetValue()) driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) } }
func (sched *ReflexScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { for _, offer := range offers { // CPUs cpuResources := util.FilterResources( offer.Resources, func(res *mesos.Resource) bool { return res.GetName() == "cpus" }, ) cpus := 0.0 for _, res := range cpuResources { cpus += res.GetScalar().GetValue() } // Mem memResources := util.FilterResources( offer.Resources, func(res *mesos.Resource) bool { return res.GetName() == "mem" }, ) mem := 0.0 for _, res := range memResources { mem += res.GetScalar().GetValue() } logrus.WithFields(logrus.Fields{ "cpus": cpus, "mem": mem, }).Debug("got offer") for _, pair := range sched.waitingPairs { if pair.InProgress { continue } task := pair.Task if cpus >= task.CPU && mem >= task.Mem { logrus.WithField("task", task).Info("would have launched a task") } } driver.DeclineOffer(offer.GetId(), new(mesos.Filters)) } }
func (s *rendlerScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { log.Printf("Received %d resource offers", len(offers)) for _, offer := range offers { select { case <-s.shutdown: log.Println("Shutting down: declining offer on [", offer.Hostname, "]") driver.DeclineOffer(offer.Id, defaultFilter) if s.tasksRunning == 0 { close(s.done) } continue default: } tasks := []*mesos.TaskInfo{} tasksToLaunch := maxTasksForOffer(offer) for tasksToLaunch > 0 { if s.crawlQueue.Front() != nil { url := s.crawlQueue.Front().Value.(string) s.crawlQueue.Remove(s.crawlQueue.Front()) task := s.newCrawlTask(url, offer) tasks = append(tasks, task) tasksToLaunch-- } if s.renderQueue.Front() != nil { url := s.renderQueue.Front().Value.(string) s.renderQueue.Remove(s.renderQueue.Front()) task := s.newRenderTask(url, offer) tasks = append(tasks, task) tasksToLaunch-- } if s.crawlQueue.Front() == nil && s.renderQueue.Front() == nil { break } } if len(tasks) == 0 { driver.DeclineOffer(offer.Id, defaultFilter) } else { driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, defaultFilter) } } }
// ResourceOffers handles the Resource Offers func (s *eremeticScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { log.Tracef("Received %d resource offers", len(offers)) var offer *mesos.Offer loop: for len(offers) > 0 { select { case <-s.shutdown: log.Info("Shutting down: declining offers") break loop case tid := <-s.tasks: log.Debugf("Trying to find offer to launch %s with", tid) t, _ := database.ReadTask(tid) offer, offers = matchOffer(t, offers) if offer == nil { log.Warnf("Could not find a matching offer for %s", tid) TasksDelayed.Inc() go func() { s.tasks <- tid }() break loop } log.Debugf("Preparing to launch task %s with offer %s", tid, offer.Id.GetValue()) t, task := s.newTask(t, offer) database.PutTask(&t) driver.LaunchTasks([]*mesos.OfferID{offer.Id}, []*mesos.TaskInfo{task}, defaultFilter) TasksLaunched.Inc() QueueSize.Dec() continue default: break loop } } log.Trace("No tasks to launch. Declining offers.") for _, offer := range offers { driver.DeclineOffer(offer.Id, defaultFilter) } }
func (s *Scheduler) ResourceOffers(driver scheduler.SchedulerDriver, offers []*mesos.Offer) { Logger.Debugf("[ResourceOffers] %s", offersString(offers)) s.activeLock.Lock() defer s.activeLock.Unlock() if !s.active { Logger.Debug("Scheduler is inactive. Declining all offers.") for _, offer := range offers { driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(1)}) } return } for _, offer := range offers { declineReason := s.acceptOffer(driver, offer) if declineReason != "" { driver.DeclineOffer(offer.GetId(), &mesos.Filters{RefuseSeconds: proto.Float64(1)}) Logger.Debugf("Declined offer: %s", declineReason) } } }
// ResourceOffers handles the Resource Offers func (s *eremeticScheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { log.Tracef("Received %d resource offers", len(offers)) for _, offer := range offers { select { case <-s.shutdown: log.Infof("Shutting down: declining offer on [%s]", offer.Hostname) driver.DeclineOffer(offer.Id, defaultFilter) continue case tid := <-s.tasks: log.Debugf("Preparing to launch task %s with offer %s", tid, offer.Id.GetValue()) t, _ := database.ReadTask(tid) task := s.newTask(offer, &t) database.PutTask(&t) driver.LaunchTasks([]*mesos.OfferID{offer.Id}, []*mesos.TaskInfo{task}, defaultFilter) continue default: } log.Trace("No tasks to launch. Declining offer.") driver.DeclineOffer(offer.Id, defaultFilter) } }
func (self *MesosManager) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { log.Printf("ResourceOffers\n") computeCount := 0 for _, offer := range offers { offer_cpus := 0 for _, res := range offer.Resources { if *res.Name == "cpus" { computeCount += int(*res.Scalar.Value) offer_cpus += int(*res.Scalar.Value) } } tasks := make([]*mesos.TaskInfo, 0, computeCount) for offer_cpus_taken := 0; offer_cpus_taken < offer_cpus; { job := self.engine.GetJobToRun() if job != nil { log.Printf("Launch job: %s", job) mesos_taskinfo := self.BuildTaskInfo(job, offer) log.Printf("MesosTask: %s", mesos_taskinfo) tasks = append(tasks, mesos_taskinfo) offer_cpus_taken += 1 } else { offer_cpus_taken = offer_cpus } } if len(tasks) > 0 { _, err := driver.LaunchTasks([]*mesos.OfferID{offer.Id}, tasks, &mesos.Filters{}) if err != nil { fmt.Print("Error: %s", err) } } else { driver.DeclineOffer(offer.Id, &mesos.Filters{}) } } self.computeCount = computeCount log.Printf("CPUsOffered: %d", self.computeCount) }
// Schedule handles Mesos resource offers and based on the received offers launches PENDING Tasks // // It monitors PENDING Tasks Queue and tries to launch as many Tasks as possible for a single offer. // If no PENDING Tasks are available within QueueTimeout interval it declines the offer and retries Queue read again func (bw *BasicWorker) ScheduleTasks(driver scheduler.SchedulerDriver, offers []*mesos.Offer) { ReadOffers: for _, offer := range offers { remainingCpus := taurus.ScalarResourceVal("cpus", offer.Resources) remainingMems := taurus.ScalarResourceVal("mem", offer.Resources) log.Println("Taurus Received Offer <", offer.Id.GetValue(), "> with cpus=", remainingCpus, " mem=", remainingMems) // Map to avoid launching duplicate tasks in the same batch slice launchTaskMap := make(map[string]bool) launchTasks := make([]*mesos.TaskInfo, 0, 0) var taskCpu, taskMem float64 var retryCount int ReadTasks: for { task, err := bw.pending.ReadTask(QueueTimeout) if err != nil { retryCount += 1 switch { case bw.pending.TimedOut(err): log.Printf("No %s tasks available", taurus.PENDING) case bw.pending.Closed(err): break ReadTasks default: log.Printf("Failed to read from %s queue: %s", taurus.PENDING, err) } if retryCount == QueueRetry { break ReadTasks } continue ReadTasks } if task != nil { taskId := task.Info.TaskId.GetValue() // Don't add the same task bwice into launchTasks slice if launchTaskMap[taskId] { log.Printf("Skipping already queued Task %s", taskId) continue ReadTasks } taskCpu = taurus.ScalarResourceVal("cpus", task.Info.Resources) taskMem = taurus.ScalarResourceVal("mem", task.Info.Resources) if remainingCpus >= taskCpu && remainingMems >= taskMem { task.Info.SlaveId = offer.SlaveId launchTasks = append(launchTasks, task.Info) launchTaskMap[taskId] = true remainingCpus -= taskCpu remainingMems -= taskMem } else { break ReadTasks } } } if len(launchTasks) > 0 { log.Printf("Launching %d tasks for offer %s", len(launchTasks), offer.Id.GetValue()) launchStatus, err := driver.LaunchTasks( []*mesos.OfferID{offer.Id}, launchTasks, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) if err != nil { log.Printf("Mesos status: %#v Failed to launch Tasks %s: %s", launchStatus, launchTasks, err) continue ReadOffers } } else { log.Println("Declining offer ", offer.Id.GetValue()) declineStatus, err := driver.DeclineOffer( offer.Id, &mesos.Filters{RefuseSeconds: proto.Float64(1)}) if err != nil { log.Printf("Error declining offer for mesos status %#v: %s", declineStatus, err) } } } }
func (sched *Scheduler) ResourceOffers(driver sched.SchedulerDriver, offers []*mesos.Offer) { glog.Infof("received %d offer(s)", len(offers)) for _, offer := range offers { driver.DeclineOffer(offer.GetId(), refuseFor(10*time.Second)) } }