github.com/fabiokung/docker@v0.11.2-0.20170222101415-4534dcd49497/daemon/cluster/nodes.go (about)

     1  package cluster
     2  
     3  import (
     4  	apierrors "github.com/docker/docker/api/errors"
     5  	apitypes "github.com/docker/docker/api/types"
     6  	types "github.com/docker/docker/api/types/swarm"
     7  	"github.com/docker/docker/daemon/cluster/convert"
     8  	swarmapi "github.com/docker/swarmkit/api"
     9  )
    10  
    11  // GetNodes returns a list of all nodes known to a cluster.
    12  func (c *Cluster) GetNodes(options apitypes.NodeListOptions) ([]types.Node, error) {
    13  	c.mu.RLock()
    14  	defer c.mu.RUnlock()
    15  
    16  	state := c.currentNodeState()
    17  	if !state.IsActiveManager() {
    18  		return nil, c.errNoManager(state)
    19  	}
    20  
    21  	filters, err := newListNodesFilters(options.Filters)
    22  	if err != nil {
    23  		return nil, err
    24  	}
    25  
    26  	ctx, cancel := c.getRequestContext()
    27  	defer cancel()
    28  
    29  	r, err := state.controlClient.ListNodes(
    30  		ctx,
    31  		&swarmapi.ListNodesRequest{Filters: filters})
    32  	if err != nil {
    33  		return nil, err
    34  	}
    35  
    36  	nodes := []types.Node{}
    37  
    38  	for _, node := range r.Nodes {
    39  		nodes = append(nodes, convert.NodeFromGRPC(*node))
    40  	}
    41  	return nodes, nil
    42  }
    43  
    44  // GetNode returns a node based on an ID.
    45  func (c *Cluster) GetNode(input string) (types.Node, error) {
    46  	c.mu.RLock()
    47  	defer c.mu.RUnlock()
    48  
    49  	state := c.currentNodeState()
    50  	if !state.IsActiveManager() {
    51  		return types.Node{}, c.errNoManager(state)
    52  	}
    53  
    54  	ctx, cancel := c.getRequestContext()
    55  	defer cancel()
    56  
    57  	node, err := getNode(ctx, state.controlClient, input)
    58  	if err != nil {
    59  		return types.Node{}, err
    60  	}
    61  	return convert.NodeFromGRPC(*node), nil
    62  }
    63  
    64  // UpdateNode updates existing nodes properties.
    65  func (c *Cluster) UpdateNode(input string, version uint64, spec types.NodeSpec) error {
    66  	c.mu.RLock()
    67  	defer c.mu.RUnlock()
    68  
    69  	state := c.currentNodeState()
    70  	if !state.IsActiveManager() {
    71  		return c.errNoManager(state)
    72  	}
    73  
    74  	nodeSpec, err := convert.NodeSpecToGRPC(spec)
    75  	if err != nil {
    76  		return apierrors.NewBadRequestError(err)
    77  	}
    78  
    79  	ctx, cancel := c.getRequestContext()
    80  	defer cancel()
    81  
    82  	currentNode, err := getNode(ctx, state.controlClient, input)
    83  	if err != nil {
    84  		return err
    85  	}
    86  
    87  	_, err = state.controlClient.UpdateNode(
    88  		ctx,
    89  		&swarmapi.UpdateNodeRequest{
    90  			NodeID: currentNode.ID,
    91  			Spec:   &nodeSpec,
    92  			NodeVersion: &swarmapi.Version{
    93  				Index: version,
    94  			},
    95  		},
    96  	)
    97  	return err
    98  }
    99  
   100  // RemoveNode removes a node from a cluster
   101  func (c *Cluster) RemoveNode(input string, force bool) error {
   102  	c.mu.RLock()
   103  	defer c.mu.RUnlock()
   104  
   105  	state := c.currentNodeState()
   106  	if !state.IsActiveManager() {
   107  		return c.errNoManager(state)
   108  	}
   109  
   110  	ctx, cancel := c.getRequestContext()
   111  	defer cancel()
   112  
   113  	node, err := getNode(ctx, state.controlClient, input)
   114  	if err != nil {
   115  		return err
   116  	}
   117  
   118  	_, err = state.controlClient.RemoveNode(ctx, &swarmapi.RemoveNodeRequest{NodeID: node.ID, Force: force})
   119  	return err
   120  }