// applyPlan is used to apply the plan result and to return the alloc index func (s *Server) applyPlan(result *structs.PlanResult, snap *state.StateSnapshot) (raft.ApplyFuture, error) { req := structs.AllocUpdateRequest{} for _, updateList := range result.NodeUpdate { req.Alloc = append(req.Alloc, updateList...) } for _, allocList := range result.NodeAllocation { req.Alloc = append(req.Alloc, allocList...) } req.Alloc = append(req.Alloc, result.FailedAllocs...) // Dispatch the Raft transaction future, err := s.raftApplyFuture(structs.AllocUpdateRequestType, &req) if err != nil { return nil, err } // Optimistically apply to our state view if snap != nil { nextIdx := s.raft.AppliedIndex() + 1 if err := snap.UpsertAllocs(nextIdx, req.Alloc); err != nil { return future, err } } return future, nil }
// applyPlan is used to apply the plan result and to return the alloc index func (s *Server) applyPlan(result *structs.PlanResult, snap *state.StateSnapshot) (raft.ApplyFuture, error) { req := structs.AllocUpdateRequest{} for _, updateList := range result.NodeUpdate { req.Alloc = append(req.Alloc, updateList...) } for _, allocList := range result.NodeAllocation { req.Alloc = append(req.Alloc, allocList...) } req.Alloc = append(req.Alloc, result.FailedAllocs...) // Set the time the alloc was applied for the first time. This can be used // to approximate the scheduling time. now := time.Now().UTC().UnixNano() for _, alloc := range req.Alloc { if alloc.CreateTime == 0 { alloc.CreateTime = now } } // Dispatch the Raft transaction future, err := s.raftApplyFuture(structs.AllocUpdateRequestType, &req) if err != nil { return nil, err } // Optimistically apply to our state view if snap != nil { nextIdx := s.raft.AppliedIndex() + 1 if err := snap.UpsertAllocs(nextIdx, req.Alloc); err != nil { return future, err } } return future, nil }
// applyPlan is used to apply the plan result and to return the alloc index func (s *Server) applyPlan(result *structs.PlanResult) (uint64, error) { defer metrics.MeasureSince([]string{"nomad", "plan", "apply"}, time.Now()) req := structs.AllocUpdateRequest{} for _, updateList := range result.NodeUpdate { req.Alloc = append(req.Alloc, updateList...) } for _, allocList := range result.NodeAllocation { req.Alloc = append(req.Alloc, allocList...) } req.Alloc = append(req.Alloc, result.FailedAllocs...) _, index, err := s.raftApply(structs.AllocUpdateRequestType, &req) return index, err }
// applyPlan is used to apply the plan result and to return the alloc index func (s *Server) applyPlan(job *structs.Job, result *structs.PlanResult, snap *state.StateSnapshot) (raft.ApplyFuture, error) { // Determine the miniumum number of updates, could be more if there // are multiple updates per node minUpdates := len(result.NodeUpdate) minUpdates += len(result.NodeAllocation) minUpdates += len(result.FailedAllocs) // Setup the update request req := structs.AllocUpdateRequest{ Job: job, Alloc: make([]*structs.Allocation, 0, minUpdates), } for _, updateList := range result.NodeUpdate { req.Alloc = append(req.Alloc, updateList...) } for _, allocList := range result.NodeAllocation { req.Alloc = append(req.Alloc, allocList...) } req.Alloc = append(req.Alloc, result.FailedAllocs...) // Set the time the alloc was applied for the first time. This can be used // to approximate the scheduling time. now := time.Now().UTC().UnixNano() for _, alloc := range req.Alloc { if alloc.CreateTime == 0 { alloc.CreateTime = now } } // Dispatch the Raft transaction future, err := s.raftApplyFuture(structs.AllocUpdateRequestType, &req) if err != nil { return nil, err } // Optimistically apply to our state view if snap != nil { nextIdx := s.raft.AppliedIndex() + 1 if err := snap.UpsertAllocs(nextIdx, req.Alloc); err != nil { return future, err } } return future, nil }