tyler.durden
/
compose
mirror of https://github.com/docker/compose.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

backend.local: Refactor conversion code 

Signed-off-by: Chris Crone <christopher.crone@docker.com>
This commit is contained in:
Chris Crone 2020-11-03 15:13:50 +01:00
parent 6a9eca9bdf
commit b8adb4b3dd
3 changed files with 181 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
local/backend.go
View File

@ -21,10 +21,7 @@ package local
import (
"bufio"
"context"
"fmt"
"io"
"sort"
"strconv"
"strings"
"time"
@ -33,7 +30,6 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/pkg/stdcopy"
"github.com/docker/docker/pkg/stringid"
"github.com/docker/go-connections/nat"
"github.com/pkg/errors"
"github.com/docker/compose-cli/api/compose"
@ -102,8 +98,8 @@ func (ms *local) Inspect(ctx context.Context, id string) (containers.Container,
command = strings.Join(c.Config.Cmd, " ")
}
rc := containerJSONToRuntimeConfig(&c)
hc := containerJSONToHostConfig(&c)
rc := toRuntimeConfig(&c)
hc := toHostConfig(&c)
return containers.Container{
ID: stringid.TruncateID(c.ID),
@ -116,66 +112,6 @@ func (ms *local) Inspect(ctx context.Context, id string) (containers.Container,
}, nil
}
func containerJSONToRuntimeConfig(m *types.ContainerJSON) *containers.RuntimeConfig {
if m.Config == nil {
return nil
}
var env map[string]string
if m.Config.Env != nil {
env = make(map[string]string)
for _, e := range m.Config.Env {
tokens := strings.Split(e, "=")
if len(tokens) != 2 {
continue
}
env[tokens[0]] = tokens[1]
}
}
var labels []string
if m.Config.Labels != nil {
for k, v := range m.Config.Labels {
labels = append(labels, fmt.Sprintf("%s=%s", k, v))
}
}
sort.Strings(labels)
if env == nil &&
labels == nil {
return nil
}
return &containers.RuntimeConfig{
Env: env,
Labels: labels,
}
}
func containerJSONToHostConfig(m *types.ContainerJSON) *containers.HostConfig {
if m.HostConfig == nil {
return nil
}
var restartPolicy string
switch m.HostConfig.RestartPolicy.Name {
case "always":
restartPolicy = containers.RestartPolicyAny
case "on-failure":
restartPolicy = containers.RestartPolicyOnFailure
case "no", "":
fallthrough
default:
restartPolicy = containers.RestartPolicyNone
}
return &containers.HostConfig{
AutoRemove: m.HostConfig.AutoRemove,
RestartPolicy: restartPolicy,
CPULimit: float64(m.HostConfig.Resources.NanoCPUs) / 1e9,
MemoryLimit: uint64(m.HostConfig.Resources.Memory),
}
}
func (ms *local) List(ctx context.Context, all bool) ([]containers.Container, error) {
css, err := ms.apiClient.ContainerList(ctx, types.ContainerListOptions{
All: all,
@ -352,47 +288,3 @@ func (ms *local) Delete(ctx context.Context, containerID string, request contain
}
return err
}
func toPorts(ports []types.Port) []containers.Port {
result := []containers.Port{}
for _, port := range ports {
result = append(result, containers.Port{
ContainerPort: uint32(port.PrivatePort),
HostPort: uint32(port.PublicPort),
HostIP: port.IP,
Protocol: port.Type,
})
}
return result
}
func fromPorts(ports []containers.Port) (map[nat.Port]struct{}, map[nat.Port][]nat.PortBinding, error) {
var (
exposedPorts = make(map[nat.Port]struct{}, len(ports))
bindings = make(map[nat.Port][]nat.PortBinding)
)
for _, port := range ports {
p, err := nat.NewPort(port.Protocol, strconv.Itoa(int(port.ContainerPort)))
if err != nil {
return nil, nil, err
}
if _, exists := exposedPorts[p]; !exists {
exposedPorts[p] = struct{}{}
}
portBinding := nat.PortBinding{
HostIP: port.HostIP,
HostPort: strconv.Itoa(int(port.HostPort)),
}
bslice, exists := bindings[p]
if !exists {
bslice = []nat.PortBinding{}
}
bindings[p] = append(bslice, portBinding)
}
return exposedPorts, bindings, nil
}

150
local/convert.go Normal file
View File

@ -0,0 +1,150 @@
// +build local
/*
Copyright 2020 Docker Compose CLI authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package local
import (
"fmt"
"sort"
"strconv"
"strings"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/go-connections/nat"
"github.com/docker/compose-cli/api/containers"
)
func toRuntimeConfig(m *types.ContainerJSON) *containers.RuntimeConfig {
if m.Config == nil {
return nil
}
var env map[string]string
if m.Config.Env != nil {
env = make(map[string]string)
for _, e := range m.Config.Env {
tokens := strings.Split(e, "=")
if len(tokens) != 2 {
continue
}
env[tokens[0]] = tokens[1]
}
}
var labels []string
if m.Config.Labels != nil {
for k, v := range m.Config.Labels {
labels = append(labels, fmt.Sprintf("%s=%s", k, v))
}
}
sort.Strings(labels)
if env == nil &&
labels == nil {
return nil
}
return &containers.RuntimeConfig{
Env: env,
Labels: labels,
}
}
func toHostConfig(m *types.ContainerJSON) *containers.HostConfig {
if m.HostConfig == nil {
return nil
}
return &containers.HostConfig{
AutoRemove: m.HostConfig.AutoRemove,
RestartPolicy: fromRestartPolicyName(m.HostConfig.RestartPolicy.Name),
CPULimit: float64(m.HostConfig.Resources.NanoCPUs) / 1e9,
MemoryLimit: uint64(m.HostConfig.Resources.Memory),
}
}
func toPorts(ports []types.Port) []containers.Port {
result := []containers.Port{}
for _, port := range ports {
result = append(result, containers.Port{
ContainerPort: uint32(port.PrivatePort),
HostPort: uint32(port.PublicPort),
HostIP: port.IP,
Protocol: port.Type,
})
}
return result
}
func fromPorts(ports []containers.Port) (map[nat.Port]struct{}, map[nat.Port][]nat.PortBinding, error) {
var (
exposedPorts = make(map[nat.Port]struct{}, len(ports))
bindings = make(map[nat.Port][]nat.PortBinding)
)
for _, port := range ports {
p, err := nat.NewPort(port.Protocol, strconv.Itoa(int(port.ContainerPort)))
if err != nil {
return nil, nil, err
}
if _, exists := exposedPorts[p]; !exists {
exposedPorts[p] = struct{}{}
}
portBinding := nat.PortBinding{
HostIP: port.HostIP,
HostPort: strconv.Itoa(int(port.HostPort)),
}
bslice, exists := bindings[p]
if !exists {
bslice = []nat.PortBinding{}
}
bindings[p] = append(bslice, portBinding)
}
return exposedPorts, bindings, nil
}
func fromRestartPolicyName(m string) string {
switch m {
case "always":
return containers.RestartPolicyAny
case "on-failure":
return containers.RestartPolicyOnFailure
case "no", "":
fallthrough
default:
return containers.RestartPolicyNone
}
}
func toRestartPolicy(p string) container.RestartPolicy {
switch p {
case containers.RestartPolicyAny:
return container.RestartPolicy{Name: "always"}
case containers.RestartPolicyOnFailure:
return container.RestartPolicy{Name: "on-failure"}
case containers.RestartPolicyNone:
fallthrough
default:
return container.RestartPolicy{Name: "no"}
}
}

31
local/backend_test.go → local/convert_test.go
View File

@ -36,7 +36,7 @@ func TestToRuntimeConfig(t *testing.T) {
Labels: map[string]string{"foo1": "bar1", "foo2": "bar2"},
},
}
rc := containerJSONToRuntimeConfig(m)
rc := toRuntimeConfig(m)
res := &containers.RuntimeConfig{
Env: map[string]string{"FOO1": "BAR1", "FOO2": "BAR2"},
Labels: []string{"foo1=bar1", "foo2=bar2"},
@ -65,7 +65,7 @@ func TestToHostConfig(t *testing.T) {
},
ContainerJSONBase: base,
}
hc := containerJSONToHostConfig(m)
hc := toHostConfig(m)
res := &containers.HostConfig{
AutoRemove: true,
RestartPolicy: containers.RestartPolicyNone,
@ -74,3 +74,30 @@ func TestToHostConfig(t *testing.T) {
}
assert.DeepEqual(t, hc, res)
}
func TestFromRestartPolicyName(t *testing.T) {
t.Parallel()
moby := []string{"always", "on-failure", "no", ""}
ours := []string{
containers.RestartPolicyAny,
containers.RestartPolicyOnFailure,
containers.RestartPolicyNone,
containers.RestartPolicyNone,
}
for i, p := range moby {
assert.Equal(t, fromRestartPolicyName(p), ours[i])
}
}
func TestToRestartPolicy(t *testing.T) {
t.Parallel()
ours := []string{containers.RestartPolicyAny, containers.RestartPolicyOnFailure, containers.RestartPolicyNone}
moby := []container.RestartPolicy{
{Name: "always"},
{Name: "on-failure"},
{Name: "no"},
}
for i, p := range ours {
assert.Equal(t, toRestartPolicy(p), moby[i])
}
}