dotcloud/docker

package convert // import "github.com/docker/docker/daemon/cluster/convert"

import (
    volumetypes "github.com/docker/docker/api/types/volume"
    gogotypes "github.com/gogo/protobuf/types"
    swarmapi "github.com/moby/swarmkit/v2/api"
)

// VolumeFromGRPC converts a swarmkit api Volume object to a docker api Volume
// object
func VolumeFromGRPC(v *swarmapi.Volume) volumetypes.Volume {
    clusterVolumeSpec := volumetypes.ClusterVolumeSpec{
        Group:                     v.Spec.Group,
        AccessMode:                accessModeFromGRPC(v.Spec.AccessMode),
        AccessibilityRequirements: topologyRequirementFromGRPC(v.Spec.AccessibilityRequirements),
        CapacityRange:             capacityRangeFromGRPC(v.Spec.CapacityRange),
        Secrets:                   volumeSecretsFromGRPC(v.Spec.Secrets),
        Availability:              volumeAvailabilityFromGRPC(v.Spec.Availability),
    }

    clusterVolume := &volumetypes.ClusterVolume{
        ID:            v.ID,
        Spec:          clusterVolumeSpec,
        PublishStatus: volumePublishStatusFromGRPC(v.PublishStatus),
        Info:          volumeInfoFromGRPC(v.VolumeInfo),
    }

    clusterVolume.Version.Index = v.Meta.Version.Index
    clusterVolume.CreatedAt, _ = gogotypes.TimestampFromProto(v.Meta.CreatedAt)
    clusterVolume.UpdatedAt, _ = gogotypes.TimestampFromProto(v.Meta.UpdatedAt)

    return volumetypes.Volume{
        ClusterVolume: clusterVolume,
        CreatedAt:     clusterVolume.CreatedAt.String(),
        Driver:        v.Spec.Driver.Name,
        Labels:        v.Spec.Annotations.Labels,
        Name:          v.Spec.Annotations.Name,
        Options:       v.Spec.Driver.Options,
        Scope:         "global",
    }
}

func volumeSpecToGRPC(spec volumetypes.ClusterVolumeSpec) *swarmapi.VolumeSpec {
    swarmSpec := &swarmapi.VolumeSpec{
        Group: spec.Group,
    }

    if spec.AccessMode != nil {
        swarmSpec.AccessMode = &swarmapi.VolumeAccessMode{}

        switch spec.AccessMode.Scope {
        case volumetypes.ScopeSingleNode:
            swarmSpec.AccessMode.Scope = swarmapi.VolumeScopeSingleNode
        case volumetypes.ScopeMultiNode:
            swarmSpec.AccessMode.Scope = swarmapi.VolumeScopeMultiNode
        }

        switch spec.AccessMode.Sharing {
        case volumetypes.SharingNone:
            swarmSpec.AccessMode.Sharing = swarmapi.VolumeSharingNone
        case volumetypes.SharingReadOnly:
            swarmSpec.AccessMode.Sharing = swarmapi.VolumeSharingReadOnly
        case volumetypes.SharingOneWriter:
            swarmSpec.AccessMode.Sharing = swarmapi.VolumeSharingOneWriter
        case volumetypes.SharingAll:
            swarmSpec.AccessMode.Sharing = swarmapi.VolumeSharingAll
        }

        if spec.AccessMode.BlockVolume != nil {
            swarmSpec.AccessMode.AccessType = &swarmapi.VolumeAccessMode_Block{
                Block: &swarmapi.VolumeAccessMode_BlockVolume{},
            }
        }
        if spec.AccessMode.MountVolume != nil {
            swarmSpec.AccessMode.AccessType = &swarmapi.VolumeAccessMode_Mount{
                Mount: &swarmapi.VolumeAccessMode_MountVolume{
                    FsType:     spec.AccessMode.MountVolume.FsType,
                    MountFlags: spec.AccessMode.MountVolume.MountFlags,
                },
            }
        }
    }

    for _, secret := range spec.Secrets {
        swarmSpec.Secrets = append(swarmSpec.Secrets, &swarmapi.VolumeSecret{
            Key:    secret.Key,
            Secret: secret.Secret,
        })
    }

    if spec.AccessibilityRequirements != nil {
        swarmSpec.AccessibilityRequirements = &swarmapi.TopologyRequirement{}

        for _, top := range spec.AccessibilityRequirements.Requisite {
            swarmSpec.AccessibilityRequirements.Requisite = append(
                swarmSpec.AccessibilityRequirements.Requisite,
                &swarmapi.Topology{
                    Segments: top.Segments,
                },
            )
        }

        for _, top := range spec.AccessibilityRequirements.Preferred {
            swarmSpec.AccessibilityRequirements.Preferred = append(
                swarmSpec.AccessibilityRequirements.Preferred,
                &swarmapi.Topology{
                    Segments: top.Segments,
                },
            )
        }
    }

    if spec.CapacityRange != nil {
        swarmSpec.CapacityRange = &swarmapi.CapacityRange{
            RequiredBytes: spec.CapacityRange.RequiredBytes,
            LimitBytes:    spec.CapacityRange.LimitBytes,
        }
    }

    // availability is not a pointer, it is a value. if the user does not
    // specify an availability, it will be inferred as the 0-value, which is
    // "active".
    switch spec.Availability {
    case volumetypes.AvailabilityActive:
        swarmSpec.Availability = swarmapi.VolumeAvailabilityActive
    case volumetypes.AvailabilityPause:
        swarmSpec.Availability = swarmapi.VolumeAvailabilityPause
    case volumetypes.AvailabilityDrain:
        swarmSpec.Availability = swarmapi.VolumeAvailabilityDrain
    }

    return swarmSpec
}

// VolumeCreateToGRPC takes a VolumeCreateBody and outputs the matching
// swarmapi VolumeSpec.
func VolumeCreateToGRPC(volume *volumetypes.CreateOptions) *swarmapi.VolumeSpec {
    var swarmSpec *swarmapi.VolumeSpec
    if volume != nil && volume.ClusterVolumeSpec != nil {
        swarmSpec = volumeSpecToGRPC(*volume.ClusterVolumeSpec)
    } else {
        swarmSpec = &swarmapi.VolumeSpec{}
    }

    swarmSpec.Annotations = swarmapi.Annotations{
        Name:   volume.Name,
        Labels: volume.Labels,
    }

    swarmSpec.Driver = &swarmapi.Driver{
        Name:    volume.Driver,
        Options: volume.DriverOpts,
    }

    return swarmSpec
}

func volumeInfoFromGRPC(info *swarmapi.VolumeInfo) *volumetypes.Info {
    if info == nil {
        return nil
    }

    var accessibleTopology []volumetypes.Topology
    if info.AccessibleTopology != nil {
        accessibleTopology = make([]volumetypes.Topology, len(info.AccessibleTopology))
        for i, top := range info.AccessibleTopology {
            accessibleTopology[i] = topologyFromGRPC(top)
        }
    }

    return &volumetypes.Info{
        CapacityBytes:      info.CapacityBytes,
        VolumeContext:      info.VolumeContext,
        VolumeID:           info.VolumeID,
        AccessibleTopology: accessibleTopology,
    }
}

func volumePublishStatusFromGRPC(publishStatus []*swarmapi.VolumePublishStatus) []*volumetypes.PublishStatus {
    if publishStatus == nil {
        return nil
    }

    vps := make([]*volumetypes.PublishStatus, len(publishStatus))
    for i, status := range publishStatus {
        var state volumetypes.PublishState
        switch status.State {
        case swarmapi.VolumePublishStatus_PENDING_PUBLISH:
            state = volumetypes.StatePending
        case swarmapi.VolumePublishStatus_PUBLISHED:
            state = volumetypes.StatePublished
        case swarmapi.VolumePublishStatus_PENDING_NODE_UNPUBLISH:
            state = volumetypes.StatePendingNodeUnpublish
        case swarmapi.VolumePublishStatus_PENDING_UNPUBLISH:
            state = volumetypes.StatePendingUnpublish
        }

        vps[i] = &volumetypes.PublishStatus{
            NodeID:         status.NodeID,
            State:          state,
            PublishContext: status.PublishContext,
        }
    }

    return vps
}

func accessModeFromGRPC(accessMode *swarmapi.VolumeAccessMode) *volumetypes.AccessMode {
    if accessMode == nil {
        return nil
    }

    convertedAccessMode := &volumetypes.AccessMode{}

    switch accessMode.Scope {
    case swarmapi.VolumeScopeSingleNode:
        convertedAccessMode.Scope = volumetypes.ScopeSingleNode
    case swarmapi.VolumeScopeMultiNode:
        convertedAccessMode.Scope = volumetypes.ScopeMultiNode
    }

    switch accessMode.Sharing {
    case swarmapi.VolumeSharingNone:
        convertedAccessMode.Sharing = volumetypes.SharingNone
    case swarmapi.VolumeSharingReadOnly:
        convertedAccessMode.Sharing = volumetypes.SharingReadOnly
    case swarmapi.VolumeSharingOneWriter:
        convertedAccessMode.Sharing = volumetypes.SharingOneWriter
    case swarmapi.VolumeSharingAll:
        convertedAccessMode.Sharing = volumetypes.SharingAll
    }

    if block := accessMode.GetBlock(); block != nil {
        convertedAccessMode.BlockVolume = &volumetypes.TypeBlock{}
    }
    if mount := accessMode.GetMount(); mount != nil {
        convertedAccessMode.MountVolume = &volumetypes.TypeMount{
            FsType:     mount.FsType,
            MountFlags: mount.MountFlags,
        }
    }

    return convertedAccessMode
}

func volumeSecretsFromGRPC(secrets []*swarmapi.VolumeSecret) []volumetypes.Secret {
    if secrets == nil {
        return nil
    }
    convertedSecrets := make([]volumetypes.Secret, len(secrets))
    for i, secret := range secrets {
        convertedSecrets[i] = volumetypes.Secret{
            Key:    secret.Key,
            Secret: secret.Secret,
        }
    }
    return convertedSecrets
}

func topologyRequirementFromGRPC(top *swarmapi.TopologyRequirement) *volumetypes.TopologyRequirement {
    if top == nil {
        return nil
    }

    convertedTop := &volumetypes.TopologyRequirement{}
    if top.Requisite != nil {
        convertedTop.Requisite = make([]volumetypes.Topology, len(top.Requisite))
        for i, req := range top.Requisite {
            convertedTop.Requisite[i] = topologyFromGRPC(req)
        }
    }

    if top.Preferred != nil {
        convertedTop.Preferred = make([]volumetypes.Topology, len(top.Preferred))
        for i, pref := range top.Preferred {
            convertedTop.Preferred[i] = topologyFromGRPC(pref)
        }
    }

    return convertedTop
}

func topologyFromGRPC(top *swarmapi.Topology) volumetypes.Topology {
    if top == nil {
        return volumetypes.Topology{}
    }
    return volumetypes.Topology{
        Segments: top.Segments,
    }
}

func capacityRangeFromGRPC(capacity *swarmapi.CapacityRange) *volumetypes.CapacityRange {
    if capacity == nil {
        return nil
    }

    return &volumetypes.CapacityRange{
        RequiredBytes: capacity.RequiredBytes,
        LimitBytes:    capacity.LimitBytes,
    }
}

func volumeAvailabilityFromGRPC(availability swarmapi.VolumeSpec_VolumeAvailability) volumetypes.Availability {
    switch availability {
    case swarmapi.VolumeAvailabilityActive:
        return volumetypes.AvailabilityActive
    case swarmapi.VolumeAvailabilityPause:
        return volumetypes.AvailabilityPause
    }
    return volumetypes.AvailabilityDrain
}