github.com/olljanat/moby@v1.13.1/daemon/cluster/convert/network.go (about) 1 package convert 2 3 import ( 4 "strings" 5 6 basictypes "github.com/docker/docker/api/types" 7 networktypes "github.com/docker/docker/api/types/network" 8 types "github.com/docker/docker/api/types/swarm" 9 swarmapi "github.com/docker/swarmkit/api" 10 "github.com/docker/swarmkit/protobuf/ptypes" 11 ) 12 13 func networkAttachementFromGRPC(na *swarmapi.NetworkAttachment) types.NetworkAttachment { 14 if na != nil { 15 return types.NetworkAttachment{ 16 Network: networkFromGRPC(na.Network), 17 Addresses: na.Addresses, 18 } 19 } 20 return types.NetworkAttachment{} 21 } 22 23 func networkFromGRPC(n *swarmapi.Network) types.Network { 24 if n != nil { 25 network := types.Network{ 26 ID: n.ID, 27 Spec: types.NetworkSpec{ 28 IPv6Enabled: n.Spec.Ipv6Enabled, 29 Internal: n.Spec.Internal, 30 Attachable: n.Spec.Attachable, 31 IPAMOptions: ipamFromGRPC(n.Spec.IPAM), 32 }, 33 IPAMOptions: ipamFromGRPC(n.IPAM), 34 } 35 36 // Meta 37 network.Version.Index = n.Meta.Version.Index 38 network.CreatedAt, _ = ptypes.Timestamp(n.Meta.CreatedAt) 39 network.UpdatedAt, _ = ptypes.Timestamp(n.Meta.UpdatedAt) 40 41 //Annotations 42 network.Spec.Name = n.Spec.Annotations.Name 43 network.Spec.Labels = n.Spec.Annotations.Labels 44 45 //DriverConfiguration 46 if n.Spec.DriverConfig != nil { 47 network.Spec.DriverConfiguration = &types.Driver{ 48 Name: n.Spec.DriverConfig.Name, 49 Options: n.Spec.DriverConfig.Options, 50 } 51 } 52 53 //DriverState 54 if n.DriverState != nil { 55 network.DriverState = types.Driver{ 56 Name: n.DriverState.Name, 57 Options: n.DriverState.Options, 58 } 59 } 60 61 return network 62 } 63 return types.Network{} 64 } 65 66 func ipamFromGRPC(i *swarmapi.IPAMOptions) *types.IPAMOptions { 67 var ipam *types.IPAMOptions 68 if i != nil { 69 ipam = &types.IPAMOptions{} 70 if i.Driver != nil { 71 ipam.Driver.Name = i.Driver.Name 72 ipam.Driver.Options = i.Driver.Options 73 } 74 75 for _, config := range i.Configs { 76 ipam.Configs = append(ipam.Configs, types.IPAMConfig{ 77 Subnet: config.Subnet, 78 Range: config.Range, 79 Gateway: config.Gateway, 80 }) 81 } 82 } 83 return ipam 84 } 85 86 func endpointSpecFromGRPC(es *swarmapi.EndpointSpec) *types.EndpointSpec { 87 var endpointSpec *types.EndpointSpec 88 if es != nil { 89 endpointSpec = &types.EndpointSpec{} 90 endpointSpec.Mode = types.ResolutionMode(strings.ToLower(es.Mode.String())) 91 92 for _, portState := range es.Ports { 93 endpointSpec.Ports = append(endpointSpec.Ports, types.PortConfig{ 94 Name: portState.Name, 95 Protocol: types.PortConfigProtocol(strings.ToLower(swarmapi.PortConfig_Protocol_name[int32(portState.Protocol)])), 96 PublishMode: types.PortConfigPublishMode(strings.ToLower(swarmapi.PortConfig_PublishMode_name[int32(portState.PublishMode)])), 97 TargetPort: portState.TargetPort, 98 PublishedPort: portState.PublishedPort, 99 }) 100 } 101 } 102 return endpointSpec 103 } 104 105 func endpointFromGRPC(e *swarmapi.Endpoint) types.Endpoint { 106 endpoint := types.Endpoint{} 107 if e != nil { 108 if espec := endpointSpecFromGRPC(e.Spec); espec != nil { 109 endpoint.Spec = *espec 110 } 111 112 for _, portState := range e.Ports { 113 endpoint.Ports = append(endpoint.Ports, types.PortConfig{ 114 Name: portState.Name, 115 Protocol: types.PortConfigProtocol(strings.ToLower(swarmapi.PortConfig_Protocol_name[int32(portState.Protocol)])), 116 PublishMode: types.PortConfigPublishMode(strings.ToLower(swarmapi.PortConfig_PublishMode_name[int32(portState.PublishMode)])), 117 TargetPort: portState.TargetPort, 118 PublishedPort: portState.PublishedPort, 119 }) 120 } 121 122 for _, v := range e.VirtualIPs { 123 endpoint.VirtualIPs = append(endpoint.VirtualIPs, types.EndpointVirtualIP{ 124 NetworkID: v.NetworkID, 125 Addr: v.Addr}) 126 } 127 128 } 129 130 return endpoint 131 } 132 133 // BasicNetworkFromGRPC converts a grpc Network to a NetworkResource. 134 func BasicNetworkFromGRPC(n swarmapi.Network) basictypes.NetworkResource { 135 spec := n.Spec 136 var ipam networktypes.IPAM 137 if spec.IPAM != nil { 138 if spec.IPAM.Driver != nil { 139 ipam.Driver = spec.IPAM.Driver.Name 140 ipam.Options = spec.IPAM.Driver.Options 141 } 142 ipam.Config = make([]networktypes.IPAMConfig, 0, len(spec.IPAM.Configs)) 143 for _, ic := range spec.IPAM.Configs { 144 ipamConfig := networktypes.IPAMConfig{ 145 Subnet: ic.Subnet, 146 IPRange: ic.Range, 147 Gateway: ic.Gateway, 148 AuxAddress: ic.Reserved, 149 } 150 ipam.Config = append(ipam.Config, ipamConfig) 151 } 152 } 153 154 nr := basictypes.NetworkResource{ 155 ID: n.ID, 156 Name: n.Spec.Annotations.Name, 157 Scope: "swarm", 158 EnableIPv6: spec.Ipv6Enabled, 159 IPAM: ipam, 160 Internal: spec.Internal, 161 Attachable: spec.Attachable, 162 Labels: n.Spec.Annotations.Labels, 163 } 164 165 if n.DriverState != nil { 166 nr.Driver = n.DriverState.Name 167 nr.Options = n.DriverState.Options 168 } 169 170 return nr 171 } 172 173 // BasicNetworkCreateToGRPC converts a NetworkCreateRequest to a grpc NetworkSpec. 174 func BasicNetworkCreateToGRPC(create basictypes.NetworkCreateRequest) swarmapi.NetworkSpec { 175 ns := swarmapi.NetworkSpec{ 176 Annotations: swarmapi.Annotations{ 177 Name: create.Name, 178 Labels: create.Labels, 179 }, 180 DriverConfig: &swarmapi.Driver{ 181 Name: create.Driver, 182 Options: create.Options, 183 }, 184 Ipv6Enabled: create.EnableIPv6, 185 Internal: create.Internal, 186 Attachable: create.Attachable, 187 } 188 if create.IPAM != nil { 189 driver := create.IPAM.Driver 190 if driver == "" { 191 driver = "default" 192 } 193 ns.IPAM = &swarmapi.IPAMOptions{ 194 Driver: &swarmapi.Driver{ 195 Name: driver, 196 Options: create.IPAM.Options, 197 }, 198 } 199 ipamSpec := make([]*swarmapi.IPAMConfig, 0, len(create.IPAM.Config)) 200 for _, ipamConfig := range create.IPAM.Config { 201 ipamSpec = append(ipamSpec, &swarmapi.IPAMConfig{ 202 Subnet: ipamConfig.Subnet, 203 Range: ipamConfig.IPRange, 204 Gateway: ipamConfig.Gateway, 205 }) 206 } 207 ns.IPAM.Configs = ipamSpec 208 } 209 return ns 210 }