github.com/rita33cool1/iot-system-gateway@v0.0.0-20200911033302-e65bde238cc5/docker-engine/internal/test/daemon/swarm.go (about)

     1  package daemon
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	"github.com/docker/docker/api/types/swarm"
     8  	"github.com/gotestyourself/gotestyourself/assert"
     9  	"github.com/pkg/errors"
    10  )
    11  
    12  const (
    13  	defaultSwarmPort       = 2477
    14  	defaultSwarmListenAddr = "0.0.0.0"
    15  )
    16  
    17  // StartAndSwarmInit starts the daemon (with busybox) and init the swarm
    18  func (d *Daemon) StartAndSwarmInit(t testingT) {
    19  	// avoid networking conflicts
    20  	args := []string{"--iptables=false", "--swarm-default-advertise-addr=lo"}
    21  	d.StartWithBusybox(t, args...)
    22  
    23  	d.SwarmInit(t, swarm.InitRequest{})
    24  }
    25  
    26  // StartAndSwarmJoin starts the daemon (with busybox) and join the specified swarm as worker or manager
    27  func (d *Daemon) StartAndSwarmJoin(t testingT, leader *Daemon, manager bool) {
    28  	// avoid networking conflicts
    29  	args := []string{"--iptables=false", "--swarm-default-advertise-addr=lo"}
    30  	d.StartWithBusybox(t, args...)
    31  
    32  	tokens := leader.JoinTokens(t)
    33  	token := tokens.Worker
    34  	if manager {
    35  		token = tokens.Manager
    36  	}
    37  	d.SwarmJoin(t, swarm.JoinRequest{
    38  		RemoteAddrs: []string{leader.SwarmListenAddr()},
    39  		JoinToken:   token,
    40  	})
    41  }
    42  
    43  // SpecConstructor defines a swarm spec constructor
    44  type SpecConstructor func(*swarm.Spec)
    45  
    46  // SwarmListenAddr returns the listen-addr used for the daemon
    47  func (d *Daemon) SwarmListenAddr() string {
    48  	return fmt.Sprintf("%s:%d", d.swarmListenAddr, d.SwarmPort)
    49  }
    50  
    51  // NodeID returns the swarm mode node ID
    52  func (d *Daemon) NodeID() string {
    53  	return d.CachedInfo.Swarm.NodeID
    54  }
    55  
    56  // SwarmInit initializes a new swarm cluster.
    57  func (d *Daemon) SwarmInit(t assert.TestingT, req swarm.InitRequest) {
    58  	if req.ListenAddr == "" {
    59  		req.ListenAddr = fmt.Sprintf("%s:%d", d.swarmListenAddr, d.SwarmPort)
    60  	}
    61  	cli := d.NewClientT(t)
    62  	defer cli.Close()
    63  	_, err := cli.SwarmInit(context.Background(), req)
    64  	assert.NilError(t, err, "initializing swarm")
    65  	d.CachedInfo = d.Info(t)
    66  }
    67  
    68  // SwarmJoin joins a daemon to an existing cluster.
    69  func (d *Daemon) SwarmJoin(t assert.TestingT, req swarm.JoinRequest) {
    70  	if req.ListenAddr == "" {
    71  		req.ListenAddr = fmt.Sprintf("%s:%d", d.swarmListenAddr, d.SwarmPort)
    72  	}
    73  	cli := d.NewClientT(t)
    74  	defer cli.Close()
    75  	err := cli.SwarmJoin(context.Background(), req)
    76  	assert.NilError(t, err, "initializing swarm")
    77  	d.CachedInfo = d.Info(t)
    78  }
    79  
    80  // SwarmLeave forces daemon to leave current cluster.
    81  func (d *Daemon) SwarmLeave(force bool) error {
    82  	cli, err := d.NewClient()
    83  	if err != nil {
    84  		return fmt.Errorf("leaving swarm: failed to create client %v", err)
    85  	}
    86  	defer cli.Close()
    87  	err = cli.SwarmLeave(context.Background(), force)
    88  	if err != nil {
    89  		err = fmt.Errorf("leaving swarm: %v", err)
    90  	}
    91  	return err
    92  }
    93  
    94  // SwarmInfo returns the swarm information of the daemon
    95  func (d *Daemon) SwarmInfo(t assert.TestingT) swarm.Info {
    96  	cli := d.NewClientT(t)
    97  	info, err := cli.Info(context.Background())
    98  	assert.NilError(t, err, "get swarm info")
    99  	return info.Swarm
   100  }
   101  
   102  // SwarmUnlock tries to unlock a locked swarm
   103  func (d *Daemon) SwarmUnlock(req swarm.UnlockRequest) error {
   104  	cli, err := d.NewClient()
   105  	if err != nil {
   106  		return fmt.Errorf("unlocking swarm: failed to create client %v", err)
   107  	}
   108  	defer cli.Close()
   109  	err = cli.SwarmUnlock(context.Background(), req)
   110  	if err != nil {
   111  		err = errors.Wrap(err, "unlocking swarm")
   112  	}
   113  	return err
   114  }
   115  
   116  // GetSwarm returns the current swarm object
   117  func (d *Daemon) GetSwarm(t assert.TestingT) swarm.Swarm {
   118  	cli := d.NewClientT(t)
   119  	defer cli.Close()
   120  
   121  	sw, err := cli.SwarmInspect(context.Background())
   122  	assert.NilError(t, err)
   123  	return sw
   124  }
   125  
   126  // UpdateSwarm updates the current swarm object with the specified spec constructors
   127  func (d *Daemon) UpdateSwarm(t assert.TestingT, f ...SpecConstructor) {
   128  	cli := d.NewClientT(t)
   129  	defer cli.Close()
   130  
   131  	sw := d.GetSwarm(t)
   132  	for _, fn := range f {
   133  		fn(&sw.Spec)
   134  	}
   135  
   136  	err := cli.SwarmUpdate(context.Background(), sw.Version, sw.Spec, swarm.UpdateFlags{})
   137  	assert.NilError(t, err)
   138  }
   139  
   140  // RotateTokens update the swarm to rotate tokens
   141  func (d *Daemon) RotateTokens(t assert.TestingT) {
   142  	cli := d.NewClientT(t)
   143  	defer cli.Close()
   144  
   145  	sw, err := cli.SwarmInspect(context.Background())
   146  	assert.NilError(t, err)
   147  
   148  	flags := swarm.UpdateFlags{
   149  		RotateManagerToken: true,
   150  		RotateWorkerToken:  true,
   151  	}
   152  
   153  	err = cli.SwarmUpdate(context.Background(), sw.Version, sw.Spec, flags)
   154  	assert.NilError(t, err)
   155  }
   156  
   157  // JoinTokens returns the current swarm join tokens
   158  func (d *Daemon) JoinTokens(t assert.TestingT) swarm.JoinTokens {
   159  	cli := d.NewClientT(t)
   160  	defer cli.Close()
   161  
   162  	sw, err := cli.SwarmInspect(context.Background())
   163  	assert.NilError(t, err)
   164  	return sw.JoinTokens
   165  }