mirror of
https://github.com/cuigh/swirl
synced 2024-12-27 22:32:49 +00:00
366 lines
10 KiB
Go
366 lines
10 KiB
Go
package docker
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/cuigh/auxo/errors"
|
|
"github.com/cuigh/swirl/docker/compose"
|
|
composetypes "github.com/cuigh/swirl/docker/compose/types"
|
|
"github.com/docker/docker/api/types"
|
|
"github.com/docker/docker/api/types/container"
|
|
"github.com/docker/docker/api/types/filters"
|
|
"github.com/docker/docker/api/types/swarm"
|
|
"github.com/docker/docker/client"
|
|
)
|
|
|
|
const stackLabel = "com.docker.stack.namespace"
|
|
|
|
// StackList return all stacks.
|
|
func (d *Docker) StackList(ctx context.Context) (stacks map[string][]string, err error) {
|
|
err = d.call(func(c *client.Client) (err error) {
|
|
var services []swarm.Service
|
|
opts := types.ServiceListOptions{
|
|
Filters: filters.NewArgs(),
|
|
}
|
|
opts.Filters.Add("label", stackLabel)
|
|
services, err = c.ServiceList(ctx, opts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
stacks = make(map[string][]string)
|
|
for _, service := range services {
|
|
name := service.Spec.Labels[stackLabel]
|
|
stacks[name] = append(stacks[name], service.Spec.Name)
|
|
}
|
|
return
|
|
})
|
|
return
|
|
}
|
|
|
|
// StackRemove remove a stack.
|
|
func (d *Docker) StackRemove(ctx context.Context, name string) error {
|
|
return d.call(func(c *client.Client) (err error) {
|
|
var (
|
|
services []swarm.Service
|
|
networks []types.NetworkResource
|
|
secrets []swarm.Secret
|
|
configs []swarm.Config
|
|
errs []error
|
|
)
|
|
|
|
args := filters.NewArgs()
|
|
args.Add("label", stackLabel+"="+name)
|
|
|
|
services, err = c.ServiceList(ctx, types.ServiceListOptions{Filters: args})
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
networks, err = c.NetworkList(ctx, types.NetworkListOptions{Filters: args})
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// API version >= 1.25
|
|
secrets, err = c.SecretList(ctx, types.SecretListOptions{Filters: args})
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// API version >= 1.30
|
|
configs, err = c.ConfigList(ctx, types.ConfigListOptions{Filters: args})
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if len(services)+len(networks)+len(secrets)+len(configs) == 0 {
|
|
//return fmt.Errorf("nothing found in stack: %s", name)
|
|
return nil
|
|
}
|
|
|
|
// Remove services
|
|
for _, service := range services {
|
|
if err = c.ServiceRemove(ctx, service.ID); err != nil {
|
|
e := errors.Format("Failed to remove service %s: %s", service.Spec.Name, err)
|
|
errs = append(errs, e)
|
|
d.logger.Warn(e)
|
|
}
|
|
}
|
|
|
|
// Remove secrets
|
|
for _, secret := range secrets {
|
|
if err = c.SecretRemove(ctx, secret.ID); err != nil {
|
|
e := errors.Format("Failed to remove secret %s: %s", secret.Spec.Name, err)
|
|
errs = append(errs, e)
|
|
d.logger.Warn(e)
|
|
}
|
|
}
|
|
|
|
// Remove configs
|
|
for _, config := range configs {
|
|
if err = c.ConfigRemove(ctx, config.ID); err != nil {
|
|
e := errors.Format("Failed to remove config %s: %s", config.Spec.Name, err)
|
|
errs = append(errs, e)
|
|
d.logger.Warn(e)
|
|
}
|
|
}
|
|
|
|
// Remove networks
|
|
for _, network := range networks {
|
|
if err = c.NetworkRemove(ctx, network.ID); err != nil {
|
|
e := errors.Format("Failed to remove network %s: %s", network.Name, err)
|
|
errs = append(errs, e)
|
|
d.logger.Warn(e)
|
|
}
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return errors.List(errs...)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// StackDeploy deploy a stack.
|
|
func (d *Docker) StackDeploy(ctx context.Context, cfg *composetypes.Config, authes map[string]string) error {
|
|
c, err := d.client()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
namespace := compose.NewNamespace(cfg.Filename)
|
|
|
|
serviceNetworks := compose.GetServicesDeclaredNetworks(cfg.Services)
|
|
networks, externalNetworks := compose.Networks(namespace, cfg.Networks, serviceNetworks)
|
|
if err = validateExternalNetworks(ctx, c, externalNetworks); err != nil {
|
|
return err
|
|
}
|
|
if err = d.createNetworks(ctx, c, namespace, networks); err != nil {
|
|
return err
|
|
}
|
|
|
|
secrets, err := compose.Secrets(namespace, cfg.Secrets)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = createSecrets(ctx, c, secrets); err != nil {
|
|
return err
|
|
}
|
|
|
|
configs, err := compose.Configs(namespace, cfg.Configs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = createConfigs(ctx, c, configs); err != nil {
|
|
return err
|
|
}
|
|
|
|
services, err := compose.Services(namespace, cfg, c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return d.deployServices(ctx, c, services, namespace, authes)
|
|
}
|
|
|
|
// StackCount return number of stacks.
|
|
func (d *Docker) StackCount(ctx context.Context) (count int, err error) {
|
|
err = d.call(func(c *client.Client) (err error) {
|
|
var services []swarm.Service
|
|
opts := types.ServiceListOptions{Filters: filters.NewArgs()}
|
|
opts.Filters.Add("label", stackLabel)
|
|
services, err = c.ServiceList(ctx, opts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
m := make(map[string]struct{})
|
|
for _, service := range services {
|
|
labels := service.Spec.Labels
|
|
m[labels[stackLabel]] = struct{}{}
|
|
}
|
|
count = len(m)
|
|
return
|
|
})
|
|
return
|
|
}
|
|
|
|
func validateExternalNetworks(ctx context.Context, c *client.Client, externalNetworks []string) error {
|
|
for _, networkName := range externalNetworks {
|
|
if !container.NetworkMode(networkName).IsUserDefined() {
|
|
// Networks that are not user defined always exist on all nodes as
|
|
// local-scoped networks, so there's no need to inspect them.
|
|
continue
|
|
}
|
|
network, err := c.NetworkInspect(ctx, networkName, types.NetworkInspectOptions{})
|
|
switch {
|
|
case client.IsErrNotFound(err):
|
|
return errors.Format("network %q is declared as external, but could not be found. You need to create a swarm-scoped network before the stack is deployed", networkName)
|
|
case err != nil:
|
|
return err
|
|
case network.Scope != "swarm":
|
|
return errors.Format("network %q is declared as external, but it is not in the right scope: %q instead of \"swarm\"", networkName, network.Scope)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *Docker) createNetworks(ctx context.Context, c *client.Client, namespace compose.Namespace, networks map[string]types.NetworkCreate) error {
|
|
opts := types.NetworkListOptions{
|
|
Filters: filters.NewArgs(),
|
|
}
|
|
opts.Filters.Add("label", stackLabel+"="+namespace.Name())
|
|
existingNetworks, err := c.NetworkList(ctx, opts)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
existingNetworkMap := make(map[string]types.NetworkResource)
|
|
for _, network := range existingNetworks {
|
|
existingNetworkMap[network.Name] = network
|
|
}
|
|
|
|
for name, createOpts := range networks {
|
|
if _, exists := existingNetworkMap[name]; exists {
|
|
continue
|
|
}
|
|
|
|
if createOpts.Driver == "" {
|
|
createOpts.Driver = "overlay"
|
|
}
|
|
|
|
d.logger.Infof("Creating network %s", name)
|
|
if _, err = c.NetworkCreate(ctx, name, createOpts); err != nil {
|
|
return errors.Wrap(err, "failed to create network "+name)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func createSecrets(ctx context.Context, c *client.Client, secrets []swarm.SecretSpec) error {
|
|
for _, secretSpec := range secrets {
|
|
secret, _, err := c.SecretInspectWithRaw(ctx, secretSpec.Name)
|
|
switch {
|
|
case err == nil:
|
|
// secret already exists, then we update that
|
|
if err = c.SecretUpdate(ctx, secret.ID, secret.Meta.Version, secretSpec); err != nil {
|
|
return errors.Wrap(err, "failed to update secret "+secretSpec.Name)
|
|
}
|
|
case client.IsErrNotFound(err):
|
|
// secret does not exist, then we create a new one.
|
|
if _, err = c.SecretCreate(ctx, secretSpec); err != nil {
|
|
return errors.Wrap(err, "failed to create secret "+secretSpec.Name)
|
|
}
|
|
default:
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func createConfigs(ctx context.Context, c *client.Client, configs []swarm.ConfigSpec) error {
|
|
for _, configSpec := range configs {
|
|
config, _, err := c.ConfigInspectWithRaw(ctx, configSpec.Name)
|
|
switch {
|
|
case err == nil:
|
|
// config already exists, then we update that
|
|
if err = c.ConfigUpdate(ctx, config.ID, config.Meta.Version, configSpec); err != nil {
|
|
return errors.Wrap(err, "failed to update config "+configSpec.Name)
|
|
}
|
|
case client.IsErrNotFound(err):
|
|
// config does not exist, then we create a new one.
|
|
if _, err = c.ConfigCreate(ctx, configSpec); err != nil {
|
|
return errors.Wrap(err, "failed to create config "+configSpec.Name)
|
|
}
|
|
default:
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getServices(ctx context.Context, c *client.Client, namespace string) ([]swarm.Service, error) {
|
|
opts := types.ServiceListOptions{
|
|
Filters: filters.NewArgs(),
|
|
}
|
|
opts.Filters.Add("label", stackLabel+"="+namespace)
|
|
return c.ServiceList(ctx, opts)
|
|
}
|
|
|
|
func (d *Docker) deployServices(
|
|
ctx context.Context,
|
|
c *client.Client,
|
|
services map[string]swarm.ServiceSpec,
|
|
namespace compose.Namespace,
|
|
authes map[string]string,
|
|
//sendAuth bool,
|
|
//resolveImage string,
|
|
) error {
|
|
existingServices, err := getServices(ctx, c, namespace.Name())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
existingServiceMap := make(map[string]swarm.Service)
|
|
for _, service := range existingServices {
|
|
existingServiceMap[service.Spec.Name] = service
|
|
}
|
|
|
|
for internalName, serviceSpec := range services {
|
|
name := namespace.Scope(internalName)
|
|
|
|
// TODO: Add auth
|
|
encodedAuth := authes[serviceSpec.TaskTemplate.ContainerSpec.Image]
|
|
//image := serviceSpec.TaskTemplate.ContainerSpec.Image
|
|
//if sendAuth {
|
|
// // Retrieve encoded auth token from the image reference
|
|
// encodedAuth, err = command.RetrieveAuthTokenFromImage(ctx, dockerCli, image)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
//}
|
|
|
|
if service, exists := existingServiceMap[name]; exists {
|
|
d.logger.Infof("Updating service %s (id: %s)", name, service.ID)
|
|
|
|
updateOpts := types.ServiceUpdateOptions{
|
|
RegistryAuthFrom: types.RegistryAuthFromSpec,
|
|
EncodedRegistryAuth: encodedAuth,
|
|
}
|
|
|
|
//if resolveImage == resolveImageAlways || (resolveImage == resolveImageChanged && image != service.Spec.Labels[compose.LabelImage]) {
|
|
// updateOpts.QueryRegistry = true
|
|
//}
|
|
|
|
response, err := c.ServiceUpdate(
|
|
ctx,
|
|
service.ID,
|
|
service.Version,
|
|
serviceSpec,
|
|
updateOpts,
|
|
)
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to update service "+name)
|
|
}
|
|
|
|
for _, warning := range response.Warnings {
|
|
d.logger.Warn(warning)
|
|
}
|
|
} else {
|
|
d.logger.Infof("Creating service %s", name)
|
|
|
|
createOpts := types.ServiceCreateOptions{EncodedRegistryAuth: encodedAuth}
|
|
|
|
// query registry if flag disabling it was not set
|
|
//if resolveImage == resolveImageAlways || resolveImage == resolveImageChanged {
|
|
// createOpts.QueryRegistry = true
|
|
//}
|
|
|
|
if _, err = c.ServiceCreate(ctx, serviceSpec, createOpts); err != nil {
|
|
return errors.Wrap(err, "failed to create service "+name)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|