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  }