service.go 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366
  1. package convert
  2. import (
  3. "fmt"
  4. "strings"
  5. types "github.com/docker/docker/api/types/swarm"
  6. "github.com/docker/docker/pkg/namesgenerator"
  7. swarmapi "github.com/docker/swarmkit/api"
  8. "github.com/docker/swarmkit/protobuf/ptypes"
  9. )
  10. // ServiceFromGRPC converts a grpc Service to a Service.
  11. func ServiceFromGRPC(s swarmapi.Service) types.Service {
  12. service := types.Service{
  13. ID: s.ID,
  14. Spec: *serviceSpecFromGRPC(&s.Spec),
  15. PreviousSpec: serviceSpecFromGRPC(s.PreviousSpec),
  16. Endpoint: endpointFromGRPC(s.Endpoint),
  17. }
  18. // Meta
  19. service.Version.Index = s.Meta.Version.Index
  20. service.CreatedAt, _ = ptypes.Timestamp(s.Meta.CreatedAt)
  21. service.UpdatedAt, _ = ptypes.Timestamp(s.Meta.UpdatedAt)
  22. // UpdateStatus
  23. service.UpdateStatus = types.UpdateStatus{}
  24. if s.UpdateStatus != nil {
  25. switch s.UpdateStatus.State {
  26. case swarmapi.UpdateStatus_UPDATING:
  27. service.UpdateStatus.State = types.UpdateStateUpdating
  28. case swarmapi.UpdateStatus_PAUSED:
  29. service.UpdateStatus.State = types.UpdateStatePaused
  30. case swarmapi.UpdateStatus_COMPLETED:
  31. service.UpdateStatus.State = types.UpdateStateCompleted
  32. }
  33. service.UpdateStatus.StartedAt, _ = ptypes.Timestamp(s.UpdateStatus.StartedAt)
  34. service.UpdateStatus.CompletedAt, _ = ptypes.Timestamp(s.UpdateStatus.CompletedAt)
  35. service.UpdateStatus.Message = s.UpdateStatus.Message
  36. }
  37. return service
  38. }
  39. func serviceSpecFromGRPC(spec *swarmapi.ServiceSpec) *types.ServiceSpec {
  40. if spec == nil {
  41. return nil
  42. }
  43. serviceNetworks := make([]types.NetworkAttachmentConfig, 0, len(spec.Networks))
  44. for _, n := range spec.Networks {
  45. serviceNetworks = append(serviceNetworks, types.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
  46. }
  47. taskNetworks := make([]types.NetworkAttachmentConfig, 0, len(spec.Task.Networks))
  48. for _, n := range spec.Task.Networks {
  49. taskNetworks = append(taskNetworks, types.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
  50. }
  51. containerConfig := spec.Task.Runtime.(*swarmapi.TaskSpec_Container).Container
  52. convertedSpec := &types.ServiceSpec{
  53. Annotations: types.Annotations{
  54. Name: spec.Annotations.Name,
  55. Labels: spec.Annotations.Labels,
  56. },
  57. TaskTemplate: types.TaskSpec{
  58. ContainerSpec: containerSpecFromGRPC(containerConfig),
  59. Resources: resourcesFromGRPC(spec.Task.Resources),
  60. RestartPolicy: restartPolicyFromGRPC(spec.Task.Restart),
  61. Placement: placementFromGRPC(spec.Task.Placement),
  62. LogDriver: driverFromGRPC(spec.Task.LogDriver),
  63. Networks: taskNetworks,
  64. ForceUpdate: spec.Task.ForceUpdate,
  65. },
  66. Networks: serviceNetworks,
  67. EndpointSpec: endpointSpecFromGRPC(spec.Endpoint),
  68. }
  69. // UpdateConfig
  70. if spec.Update != nil {
  71. convertedSpec.UpdateConfig = &types.UpdateConfig{
  72. Parallelism: spec.Update.Parallelism,
  73. MaxFailureRatio: spec.Update.MaxFailureRatio,
  74. }
  75. convertedSpec.UpdateConfig.Delay, _ = ptypes.Duration(&spec.Update.Delay)
  76. if spec.Update.Monitor != nil {
  77. convertedSpec.UpdateConfig.Monitor, _ = ptypes.Duration(spec.Update.Monitor)
  78. }
  79. switch spec.Update.FailureAction {
  80. case swarmapi.UpdateConfig_PAUSE:
  81. convertedSpec.UpdateConfig.FailureAction = types.UpdateFailureActionPause
  82. case swarmapi.UpdateConfig_CONTINUE:
  83. convertedSpec.UpdateConfig.FailureAction = types.UpdateFailureActionContinue
  84. }
  85. }
  86. // Mode
  87. switch t := spec.GetMode().(type) {
  88. case *swarmapi.ServiceSpec_Global:
  89. convertedSpec.Mode.Global = &types.GlobalService{}
  90. case *swarmapi.ServiceSpec_Replicated:
  91. convertedSpec.Mode.Replicated = &types.ReplicatedService{
  92. Replicas: &t.Replicated.Replicas,
  93. }
  94. }
  95. return convertedSpec
  96. }
  97. // ServiceSpecToGRPC converts a ServiceSpec to a grpc ServiceSpec.
  98. func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
  99. name := s.Name
  100. if name == "" {
  101. name = namesgenerator.GetRandomName(0)
  102. }
  103. serviceNetworks := make([]*swarmapi.NetworkAttachmentConfig, 0, len(s.Networks))
  104. for _, n := range s.Networks {
  105. serviceNetworks = append(serviceNetworks, &swarmapi.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
  106. }
  107. taskNetworks := make([]*swarmapi.NetworkAttachmentConfig, 0, len(s.TaskTemplate.Networks))
  108. for _, n := range s.TaskTemplate.Networks {
  109. taskNetworks = append(taskNetworks, &swarmapi.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
  110. }
  111. spec := swarmapi.ServiceSpec{
  112. Annotations: swarmapi.Annotations{
  113. Name: name,
  114. Labels: s.Labels,
  115. },
  116. Task: swarmapi.TaskSpec{
  117. Resources: resourcesToGRPC(s.TaskTemplate.Resources),
  118. LogDriver: driverToGRPC(s.TaskTemplate.LogDriver),
  119. Networks: taskNetworks,
  120. ForceUpdate: s.TaskTemplate.ForceUpdate,
  121. },
  122. Networks: serviceNetworks,
  123. }
  124. containerSpec, err := containerToGRPC(s.TaskTemplate.ContainerSpec)
  125. if err != nil {
  126. return swarmapi.ServiceSpec{}, err
  127. }
  128. spec.Task.Runtime = &swarmapi.TaskSpec_Container{Container: containerSpec}
  129. restartPolicy, err := restartPolicyToGRPC(s.TaskTemplate.RestartPolicy)
  130. if err != nil {
  131. return swarmapi.ServiceSpec{}, err
  132. }
  133. spec.Task.Restart = restartPolicy
  134. if s.TaskTemplate.Placement != nil {
  135. spec.Task.Placement = &swarmapi.Placement{
  136. Constraints: s.TaskTemplate.Placement.Constraints,
  137. }
  138. }
  139. if s.UpdateConfig != nil {
  140. var failureAction swarmapi.UpdateConfig_FailureAction
  141. switch s.UpdateConfig.FailureAction {
  142. case types.UpdateFailureActionPause, "":
  143. failureAction = swarmapi.UpdateConfig_PAUSE
  144. case types.UpdateFailureActionContinue:
  145. failureAction = swarmapi.UpdateConfig_CONTINUE
  146. default:
  147. return swarmapi.ServiceSpec{}, fmt.Errorf("unrecongized update failure action %s", s.UpdateConfig.FailureAction)
  148. }
  149. spec.Update = &swarmapi.UpdateConfig{
  150. Parallelism: s.UpdateConfig.Parallelism,
  151. Delay: *ptypes.DurationProto(s.UpdateConfig.Delay),
  152. FailureAction: failureAction,
  153. MaxFailureRatio: s.UpdateConfig.MaxFailureRatio,
  154. }
  155. if s.UpdateConfig.Monitor != 0 {
  156. spec.Update.Monitor = ptypes.DurationProto(s.UpdateConfig.Monitor)
  157. }
  158. }
  159. if s.EndpointSpec != nil {
  160. if s.EndpointSpec.Mode != "" &&
  161. s.EndpointSpec.Mode != types.ResolutionModeVIP &&
  162. s.EndpointSpec.Mode != types.ResolutionModeDNSRR {
  163. return swarmapi.ServiceSpec{}, fmt.Errorf("invalid resolution mode: %q", s.EndpointSpec.Mode)
  164. }
  165. spec.Endpoint = &swarmapi.EndpointSpec{}
  166. spec.Endpoint.Mode = swarmapi.EndpointSpec_ResolutionMode(swarmapi.EndpointSpec_ResolutionMode_value[strings.ToUpper(string(s.EndpointSpec.Mode))])
  167. for _, portConfig := range s.EndpointSpec.Ports {
  168. spec.Endpoint.Ports = append(spec.Endpoint.Ports, &swarmapi.PortConfig{
  169. Name: portConfig.Name,
  170. Protocol: swarmapi.PortConfig_Protocol(swarmapi.PortConfig_Protocol_value[strings.ToUpper(string(portConfig.Protocol))]),
  171. PublishMode: swarmapi.PortConfig_PublishMode(swarmapi.PortConfig_PublishMode_value[strings.ToUpper(string(portConfig.PublishMode))]),
  172. TargetPort: portConfig.TargetPort,
  173. PublishedPort: portConfig.PublishedPort,
  174. })
  175. }
  176. }
  177. // Mode
  178. if s.Mode.Global != nil && s.Mode.Replicated != nil {
  179. return swarmapi.ServiceSpec{}, fmt.Errorf("cannot specify both replicated mode and global mode")
  180. }
  181. if s.Mode.Global != nil {
  182. spec.Mode = &swarmapi.ServiceSpec_Global{
  183. Global: &swarmapi.GlobalService{},
  184. }
  185. } else if s.Mode.Replicated != nil && s.Mode.Replicated.Replicas != nil {
  186. spec.Mode = &swarmapi.ServiceSpec_Replicated{
  187. Replicated: &swarmapi.ReplicatedService{Replicas: *s.Mode.Replicated.Replicas},
  188. }
  189. } else {
  190. spec.Mode = &swarmapi.ServiceSpec_Replicated{
  191. Replicated: &swarmapi.ReplicatedService{Replicas: 1},
  192. }
  193. }
  194. return spec, nil
  195. }
  196. func resourcesFromGRPC(res *swarmapi.ResourceRequirements) *types.ResourceRequirements {
  197. var resources *types.ResourceRequirements
  198. if res != nil {
  199. resources = &types.ResourceRequirements{}
  200. if res.Limits != nil {
  201. resources.Limits = &types.Resources{
  202. NanoCPUs: res.Limits.NanoCPUs,
  203. MemoryBytes: res.Limits.MemoryBytes,
  204. }
  205. }
  206. if res.Reservations != nil {
  207. resources.Reservations = &types.Resources{
  208. NanoCPUs: res.Reservations.NanoCPUs,
  209. MemoryBytes: res.Reservations.MemoryBytes,
  210. }
  211. }
  212. }
  213. return resources
  214. }
  215. func resourcesToGRPC(res *types.ResourceRequirements) *swarmapi.ResourceRequirements {
  216. var reqs *swarmapi.ResourceRequirements
  217. if res != nil {
  218. reqs = &swarmapi.ResourceRequirements{}
  219. if res.Limits != nil {
  220. reqs.Limits = &swarmapi.Resources{
  221. NanoCPUs: res.Limits.NanoCPUs,
  222. MemoryBytes: res.Limits.MemoryBytes,
  223. }
  224. }
  225. if res.Reservations != nil {
  226. reqs.Reservations = &swarmapi.Resources{
  227. NanoCPUs: res.Reservations.NanoCPUs,
  228. MemoryBytes: res.Reservations.MemoryBytes,
  229. }
  230. }
  231. }
  232. return reqs
  233. }
  234. func restartPolicyFromGRPC(p *swarmapi.RestartPolicy) *types.RestartPolicy {
  235. var rp *types.RestartPolicy
  236. if p != nil {
  237. rp = &types.RestartPolicy{}
  238. switch p.Condition {
  239. case swarmapi.RestartOnNone:
  240. rp.Condition = types.RestartPolicyConditionNone
  241. case swarmapi.RestartOnFailure:
  242. rp.Condition = types.RestartPolicyConditionOnFailure
  243. case swarmapi.RestartOnAny:
  244. rp.Condition = types.RestartPolicyConditionAny
  245. default:
  246. rp.Condition = types.RestartPolicyConditionAny
  247. }
  248. if p.Delay != nil {
  249. delay, _ := ptypes.Duration(p.Delay)
  250. rp.Delay = &delay
  251. }
  252. if p.Window != nil {
  253. window, _ := ptypes.Duration(p.Window)
  254. rp.Window = &window
  255. }
  256. rp.MaxAttempts = &p.MaxAttempts
  257. }
  258. return rp
  259. }
  260. func restartPolicyToGRPC(p *types.RestartPolicy) (*swarmapi.RestartPolicy, error) {
  261. var rp *swarmapi.RestartPolicy
  262. if p != nil {
  263. rp = &swarmapi.RestartPolicy{}
  264. switch p.Condition {
  265. case types.RestartPolicyConditionNone:
  266. rp.Condition = swarmapi.RestartOnNone
  267. case types.RestartPolicyConditionOnFailure:
  268. rp.Condition = swarmapi.RestartOnFailure
  269. case types.RestartPolicyConditionAny:
  270. rp.Condition = swarmapi.RestartOnAny
  271. default:
  272. if string(p.Condition) != "" {
  273. return nil, fmt.Errorf("invalid RestartCondition: %q", p.Condition)
  274. }
  275. rp.Condition = swarmapi.RestartOnAny
  276. }
  277. if p.Delay != nil {
  278. rp.Delay = ptypes.DurationProto(*p.Delay)
  279. }
  280. if p.Window != nil {
  281. rp.Window = ptypes.DurationProto(*p.Window)
  282. }
  283. if p.MaxAttempts != nil {
  284. rp.MaxAttempts = *p.MaxAttempts
  285. }
  286. }
  287. return rp, nil
  288. }
  289. func placementFromGRPC(p *swarmapi.Placement) *types.Placement {
  290. var r *types.Placement
  291. if p != nil {
  292. r = &types.Placement{}
  293. r.Constraints = p.Constraints
  294. }
  295. return r
  296. }
  297. func driverFromGRPC(p *swarmapi.Driver) *types.Driver {
  298. if p == nil {
  299. return nil
  300. }
  301. return &types.Driver{
  302. Name: p.Name,
  303. Options: p.Options,
  304. }
  305. }
  306. func driverToGRPC(p *types.Driver) *swarmapi.Driver {
  307. if p == nil {
  308. return nil
  309. }
  310. return &swarmapi.Driver{
  311. Name: p.Name,
  312. Options: p.Options,
  313. }
  314. }