github.com/olljanat/moby@v1.13.1/daemon/cluster/secrets.go (about)

     1  package cluster
     2  
     3  import (
     4  	apitypes "github.com/docker/docker/api/types"
     5  	types "github.com/docker/docker/api/types/swarm"
     6  	"github.com/docker/docker/daemon/cluster/convert"
     7  	swarmapi "github.com/docker/swarmkit/api"
     8  )
     9  
    10  // GetSecret returns a secret from a managed swarm cluster
    11  func (c *Cluster) GetSecret(id string) (types.Secret, error) {
    12  	c.RLock()
    13  	defer c.RUnlock()
    14  
    15  	if !c.isActiveManager() {
    16  		return types.Secret{}, c.errNoManager()
    17  	}
    18  
    19  	ctx, cancel := c.getRequestContext()
    20  	defer cancel()
    21  
    22  	r, err := c.node.client.GetSecret(ctx, &swarmapi.GetSecretRequest{SecretID: id})
    23  	if err != nil {
    24  		return types.Secret{}, err
    25  	}
    26  
    27  	return convert.SecretFromGRPC(r.Secret), nil
    28  }
    29  
    30  // GetSecrets returns all secrets of a managed swarm cluster.
    31  func (c *Cluster) GetSecrets(options apitypes.SecretListOptions) ([]types.Secret, error) {
    32  	c.RLock()
    33  	defer c.RUnlock()
    34  
    35  	if !c.isActiveManager() {
    36  		return nil, c.errNoManager()
    37  	}
    38  
    39  	filters, err := newListSecretsFilters(options.Filters)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  	ctx, cancel := c.getRequestContext()
    44  	defer cancel()
    45  
    46  	r, err := c.node.client.ListSecrets(ctx,
    47  		&swarmapi.ListSecretsRequest{Filters: filters})
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  
    52  	secrets := []types.Secret{}
    53  
    54  	for _, secret := range r.Secrets {
    55  		secrets = append(secrets, convert.SecretFromGRPC(secret))
    56  	}
    57  
    58  	return secrets, nil
    59  }
    60  
    61  // CreateSecret creates a new secret in a managed swarm cluster.
    62  func (c *Cluster) CreateSecret(s types.SecretSpec) (string, error) {
    63  	c.RLock()
    64  	defer c.RUnlock()
    65  
    66  	if !c.isActiveManager() {
    67  		return "", c.errNoManager()
    68  	}
    69  
    70  	ctx, cancel := c.getRequestContext()
    71  	defer cancel()
    72  
    73  	secretSpec := convert.SecretSpecToGRPC(s)
    74  
    75  	r, err := c.node.client.CreateSecret(ctx,
    76  		&swarmapi.CreateSecretRequest{Spec: &secretSpec})
    77  	if err != nil {
    78  		return "", err
    79  	}
    80  
    81  	return r.Secret.ID, nil
    82  }
    83  
    84  // RemoveSecret removes a secret from a managed swarm cluster.
    85  func (c *Cluster) RemoveSecret(id string) error {
    86  	c.RLock()
    87  	defer c.RUnlock()
    88  
    89  	if !c.isActiveManager() {
    90  		return c.errNoManager()
    91  	}
    92  
    93  	ctx, cancel := c.getRequestContext()
    94  	defer cancel()
    95  
    96  	req := &swarmapi.RemoveSecretRequest{
    97  		SecretID: id,
    98  	}
    99  
   100  	if _, err := c.node.client.RemoveSecret(ctx, req); err != nil {
   101  		return err
   102  	}
   103  	return nil
   104  }
   105  
   106  // UpdateSecret updates a secret in a managed swarm cluster.
   107  // Note: this is not exposed to the CLI but is available from the API only
   108  func (c *Cluster) UpdateSecret(id string, version uint64, spec types.SecretSpec) error {
   109  	c.RLock()
   110  	defer c.RUnlock()
   111  
   112  	if !c.isActiveManager() {
   113  		return c.errNoManager()
   114  	}
   115  
   116  	ctx, cancel := c.getRequestContext()
   117  	defer cancel()
   118  
   119  	secretSpec := convert.SecretSpecToGRPC(spec)
   120  
   121  	if _, err := c.client.UpdateSecret(ctx,
   122  		&swarmapi.UpdateSecretRequest{
   123  			SecretID: id,
   124  			SecretVersion: &swarmapi.Version{
   125  				Index: version,
   126  			},
   127  			Spec: &secretSpec,
   128  		}); err != nil {
   129  		return err
   130  	}
   131  
   132  	return nil
   133  }