github.com/blixtra/nomad@v0.7.2-0.20171221000451-da9a1d7bb050/command/agent/node_endpoint.go (about) 1 package agent 2 3 import ( 4 "net/http" 5 "strconv" 6 "strings" 7 8 "github.com/hashicorp/nomad/nomad/structs" 9 ) 10 11 func (s *HTTPServer) NodesRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { 12 if req.Method != "GET" { 13 return nil, CodedError(405, ErrInvalidMethod) 14 } 15 16 args := structs.NodeListRequest{} 17 if s.parse(resp, req, &args.Region, &args.QueryOptions) { 18 return nil, nil 19 } 20 21 var out structs.NodeListResponse 22 if err := s.agent.RPC("Node.List", &args, &out); err != nil { 23 return nil, err 24 } 25 26 setMeta(resp, &out.QueryMeta) 27 if out.Nodes == nil { 28 out.Nodes = make([]*structs.NodeListStub, 0) 29 } 30 return out.Nodes, nil 31 } 32 33 func (s *HTTPServer) NodeSpecificRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) { 34 path := strings.TrimPrefix(req.URL.Path, "/v1/node/") 35 switch { 36 case strings.HasSuffix(path, "/evaluate"): 37 nodeName := strings.TrimSuffix(path, "/evaluate") 38 return s.nodeForceEvaluate(resp, req, nodeName) 39 case strings.HasSuffix(path, "/allocations"): 40 nodeName := strings.TrimSuffix(path, "/allocations") 41 return s.nodeAllocations(resp, req, nodeName) 42 case strings.HasSuffix(path, "/drain"): 43 nodeName := strings.TrimSuffix(path, "/drain") 44 return s.nodeToggleDrain(resp, req, nodeName) 45 case strings.HasSuffix(path, "/purge"): 46 nodeName := strings.TrimSuffix(path, "/purge") 47 return s.nodePurge(resp, req, nodeName) 48 default: 49 return s.nodeQuery(resp, req, path) 50 } 51 } 52 53 func (s *HTTPServer) nodeForceEvaluate(resp http.ResponseWriter, req *http.Request, 54 nodeID string) (interface{}, error) { 55 if req.Method != "PUT" && req.Method != "POST" { 56 return nil, CodedError(405, ErrInvalidMethod) 57 } 58 args := structs.NodeEvaluateRequest{ 59 NodeID: nodeID, 60 } 61 s.parseWriteRequest(req, &args.WriteRequest) 62 63 var out structs.NodeUpdateResponse 64 if err := s.agent.RPC("Node.Evaluate", &args, &out); err != nil { 65 return nil, err 66 } 67 setIndex(resp, out.Index) 68 return out, nil 69 } 70 71 func (s *HTTPServer) nodeAllocations(resp http.ResponseWriter, req *http.Request, 72 nodeID string) (interface{}, error) { 73 if req.Method != "GET" { 74 return nil, CodedError(405, ErrInvalidMethod) 75 } 76 args := structs.NodeSpecificRequest{ 77 NodeID: nodeID, 78 } 79 if s.parse(resp, req, &args.Region, &args.QueryOptions) { 80 return nil, nil 81 } 82 83 var out structs.NodeAllocsResponse 84 if err := s.agent.RPC("Node.GetAllocs", &args, &out); err != nil { 85 return nil, err 86 } 87 88 setMeta(resp, &out.QueryMeta) 89 if out.Allocs == nil { 90 out.Allocs = make([]*structs.Allocation, 0) 91 } 92 for _, alloc := range out.Allocs { 93 alloc.SetEventDisplayMessages() 94 } 95 return out.Allocs, nil 96 } 97 98 func (s *HTTPServer) nodeToggleDrain(resp http.ResponseWriter, req *http.Request, 99 nodeID string) (interface{}, error) { 100 if req.Method != "PUT" && req.Method != "POST" { 101 return nil, CodedError(405, ErrInvalidMethod) 102 } 103 104 // Get the enable value 105 enableRaw := req.URL.Query().Get("enable") 106 if enableRaw == "" { 107 return nil, CodedError(400, "missing enable value") 108 } 109 enable, err := strconv.ParseBool(enableRaw) 110 if err != nil { 111 return nil, CodedError(400, "invalid enable value") 112 } 113 114 args := structs.NodeUpdateDrainRequest{ 115 NodeID: nodeID, 116 Drain: enable, 117 } 118 s.parseWriteRequest(req, &args.WriteRequest) 119 120 var out structs.NodeDrainUpdateResponse 121 if err := s.agent.RPC("Node.UpdateDrain", &args, &out); err != nil { 122 return nil, err 123 } 124 setIndex(resp, out.Index) 125 return out, nil 126 } 127 128 func (s *HTTPServer) nodeQuery(resp http.ResponseWriter, req *http.Request, 129 nodeID string) (interface{}, error) { 130 if req.Method != "GET" { 131 return nil, CodedError(405, ErrInvalidMethod) 132 } 133 args := structs.NodeSpecificRequest{ 134 NodeID: nodeID, 135 } 136 if s.parse(resp, req, &args.Region, &args.QueryOptions) { 137 return nil, nil 138 } 139 140 var out structs.SingleNodeResponse 141 if err := s.agent.RPC("Node.GetNode", &args, &out); err != nil { 142 return nil, err 143 } 144 145 setMeta(resp, &out.QueryMeta) 146 if out.Node == nil { 147 return nil, CodedError(404, "node not found") 148 } 149 return out.Node, nil 150 } 151 152 func (s *HTTPServer) nodePurge(resp http.ResponseWriter, req *http.Request, nodeID string) (interface{}, error) { 153 if req.Method != "PUT" && req.Method != "POST" { 154 return nil, CodedError(405, ErrInvalidMethod) 155 } 156 args := structs.NodeDeregisterRequest{ 157 NodeID: nodeID, 158 } 159 s.parseWriteRequest(req, &args.WriteRequest) 160 var out structs.NodeUpdateResponse 161 if err := s.agent.RPC("Node.Deregister", &args, &out); err != nil { 162 return nil, err 163 } 164 setIndex(resp, out.Index) 165 return out, nil 166 }