github.com/kardianos/nomad@v0.1.3-0.20151022182107-b13df73ee850/command/agent/agent_endpoint.go (about)

     1  package agent
     2  
     3  import (
     4  	"net"
     5  	"net/http"
     6  
     7  	"github.com/hashicorp/serf/serf"
     8  )
     9  
    10  type Member struct {
    11  	Name        string
    12  	Addr        net.IP
    13  	Port        uint16
    14  	Tags        map[string]string
    15  	Status      string
    16  	ProtocolMin uint8
    17  	ProtocolMax uint8
    18  	ProtocolCur uint8
    19  	DelegateMin uint8
    20  	DelegateMax uint8
    21  	DelegateCur uint8
    22  }
    23  
    24  func nomadMember(m serf.Member) Member {
    25  	return Member{
    26  		Name:        m.Name,
    27  		Addr:        m.Addr,
    28  		Port:        m.Port,
    29  		Tags:        m.Tags,
    30  		Status:      m.Status.String(),
    31  		ProtocolMin: m.ProtocolMin,
    32  		ProtocolMax: m.ProtocolMax,
    33  		ProtocolCur: m.ProtocolCur,
    34  		DelegateMin: m.DelegateMin,
    35  		DelegateMax: m.DelegateMax,
    36  		DelegateCur: m.DelegateCur,
    37  	}
    38  }
    39  
    40  func (s *HTTPServer) AgentSelfRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
    41  	if req.Method != "GET" {
    42  		return nil, CodedError(405, ErrInvalidMethod)
    43  	}
    44  
    45  	// Get the member as a server
    46  	var member serf.Member
    47  	srv := s.agent.Server()
    48  	if srv != nil {
    49  		member = srv.LocalMember()
    50  	}
    51  
    52  	self := agentSelf{
    53  		Config: s.agent.config,
    54  		Member: nomadMember(member),
    55  		Stats:  s.agent.Stats(),
    56  	}
    57  	return self, nil
    58  }
    59  
    60  func (s *HTTPServer) AgentJoinRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
    61  	if req.Method != "PUT" && req.Method != "POST" {
    62  		return nil, CodedError(405, ErrInvalidMethod)
    63  	}
    64  	srv := s.agent.Server()
    65  	if srv == nil {
    66  		return nil, CodedError(501, ErrInvalidMethod)
    67  	}
    68  
    69  	// Get the join addresses
    70  	query := req.URL.Query()
    71  	addrs := query["address"]
    72  	if len(addrs) == 0 {
    73  		return nil, CodedError(400, "missing address to join")
    74  	}
    75  
    76  	// Attempt the join
    77  	num, err := srv.Join(addrs)
    78  	var errStr string
    79  	if err != nil {
    80  		errStr = err.Error()
    81  	}
    82  	return joinResult{num, errStr}, nil
    83  }
    84  
    85  func (s *HTTPServer) AgentMembersRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
    86  	if req.Method != "GET" {
    87  		return nil, CodedError(405, ErrInvalidMethod)
    88  	}
    89  	srv := s.agent.Server()
    90  	if srv == nil {
    91  		return nil, CodedError(501, ErrInvalidMethod)
    92  	}
    93  
    94  	serfMembers := srv.Members()
    95  	members := make([]Member, len(serfMembers))
    96  	for i, mem := range serfMembers {
    97  		members[i] = nomadMember(mem)
    98  	}
    99  	return members, nil
   100  }
   101  
   102  func (s *HTTPServer) AgentForceLeaveRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
   103  	if req.Method != "PUT" && req.Method != "POST" {
   104  		return nil, CodedError(405, ErrInvalidMethod)
   105  	}
   106  	srv := s.agent.Server()
   107  	if srv == nil {
   108  		return nil, CodedError(501, ErrInvalidMethod)
   109  	}
   110  
   111  	// Get the node to eject
   112  	node := req.URL.Query().Get("node")
   113  	if node == "" {
   114  		return nil, CodedError(400, "missing node to force leave")
   115  	}
   116  
   117  	// Attempt remove
   118  	err := srv.RemoveFailedNode(node)
   119  	return nil, err
   120  }
   121  
   122  func (s *HTTPServer) AgentServersRequest(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
   123  	switch req.Method {
   124  	case "PUT", "POST":
   125  		return s.updateServers(resp, req)
   126  	case "GET":
   127  		return s.listServers(resp, req)
   128  	default:
   129  		return nil, CodedError(405, ErrInvalidMethod)
   130  	}
   131  }
   132  
   133  func (s *HTTPServer) listServers(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
   134  	client := s.agent.Client()
   135  	if client == nil {
   136  		return nil, CodedError(501, ErrInvalidMethod)
   137  	}
   138  
   139  	// Get the current list of servers
   140  	return client.Servers(), nil
   141  }
   142  
   143  func (s *HTTPServer) updateServers(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
   144  	client := s.agent.Client()
   145  	if client == nil {
   146  		return nil, CodedError(501, ErrInvalidMethod)
   147  	}
   148  
   149  	// Get the servers from the request
   150  	servers := req.URL.Query()["address"]
   151  	if len(servers) == 0 {
   152  		return nil, CodedError(400, "missing server address")
   153  	}
   154  
   155  	// Set the servers list into the client
   156  	client.SetServers(servers)
   157  	return nil, nil
   158  }
   159  
   160  type agentSelf struct {
   161  	Config *Config                      `json:"config"`
   162  	Member Member                       `json:"member,omitempty"`
   163  	Stats  map[string]map[string]string `json:"stats"`
   164  }
   165  
   166  type joinResult struct {
   167  	NumJoined int    `json:"num_joined"`
   168  	Error     string `json:"error"`
   169  }