switch to moby/moby in the docker_environment

Gopkg.lock

@@ -7,79 +7,63 @@
   revision = "af5e0ef38369dfb5819b56d27d593142841e4600"
   version = "0.1.2"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/Azure/go-ansiterm"
-  packages = [
-    ".",
-    "winterm"
-  ]
-  revision = "d6e3b3328b783f23731bc4d058875b0371ff8109"
-
 [[projects]]
   name = "github.com/Microsoft/go-winio"
   packages = ["."]
   revision = "7da180ee92d8bd8bb8c37fc560e673e6557c392f"
   version = "v0.4.7"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/Nvveen/Gotty"
-  packages = ["."]
-  revision = "cd527374f1e5bff4938207604a14f2e38a9cf512"
-
 [[projects]]
   branch = "master"
   name = "github.com/StackExchange/wmi"
   packages = ["."]
   revision = "5d049714c4a64225c3c79a7cf7d02f7fb5b96338"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/containerd/continuity"
-  packages = ["pathdriver"]
-  revision = "d8fb8589b0e8e85b8c8bbaa8840226d0dfeb7371"
-
 [[projects]]
   name = "github.com/davecgh/go-spew"
   packages = ["spew"]
   revision = "346938d642f2ec3594ed81d874461961cd0faa76"
   version = "v1.1.0"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/docker/distribution"
+  packages = [
+    "digestset",
+    "reference"
+  ]
+  revision = "6664ec703991875e14419ff4960921cce7678bab"
+
 [[projects]]
   name = "github.com/docker/docker"
   packages = [
+    "api",
     "api/types",
     "api/types/blkiodev",
     "api/types/container",
+    "api/types/events",
     "api/types/filters",
+    "api/types/image",
     "api/types/mount",
     "api/types/network",
     "api/types/registry",
     "api/types/strslice",
     "api/types/swarm",
     "api/types/swarm/runtime",
+    "api/types/time",
     "api/types/versions",
-    "opts",
+    "api/types/volume",
-    "pkg/archive",
+    "client"
-    "pkg/fileutils",
-    "pkg/homedir",
-    "pkg/idtools",
-    "pkg/ioutils",
-    "pkg/jsonmessage",
-    "pkg/longpath",
-    "pkg/mount",
-    "pkg/pools",
-    "pkg/stdcopy",
-    "pkg/system",
-    "pkg/term",
-    "pkg/term/windows"
   ]
-  revision = "fe8aac6f5ae413a967adb0adad0b54abdfb825c4"
+  revision = "e3831a62a3052472d7252049bc59835d5d7dc8bd"
 
 [[projects]]
   name = "github.com/docker/go-connections"
-  packages = ["nat"]
+  packages = [
+    "nat",
+    "sockets",
+    "tlsconfig"
+  ]
   revision = "3ede32e2033de7505e6500d6c868c2b9ed9f169d"
   version = "v0.3.0"
 
@@ -95,12 +79,6 @@
   revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
   version = "v1.4.7"
 
-[[projects]]
-  name = "github.com/fsouza/go-dockerclient"
-  packages = ["."]
-  revision = "2ff310040c161b75fa19fb9b287a90a6e03c0012"
-  version = "1.1"
-
 [[projects]]
   name = "github.com/gin-gonic/gin"
   packages = [
@@ -211,15 +189,6 @@
   revision = "d60099175f88c47cd379c4738d158884749ed235"
   version = "v1.0.1"
 
-[[projects]]
-  name = "github.com/opencontainers/runc"
-  packages = [
-    "libcontainer/system",
-    "libcontainer/user"
-  ]
-  revision = "baf6536d6259209c3edfa2b22237af82942d3dfa"
-  version = "v0.1.1"
-
 [[projects]]
   name = "github.com/pelletier/go-toml"
   packages = ["."]
@@ -251,11 +220,18 @@
     "host",
     "internal/common",
     "mem",
+    "net",
     "process"
   ]
   revision = "c432be29ccce470088d07eea25b3ea7e68a8afbb"
   version = "v2.18.01"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/shirou/w32"
+  packages = ["."]
+  revision = "bb4de0191aa41b5507caa14b0650cdbddcd9280b"
+
 [[projects]]
   name = "github.com/sirupsen/logrus"
   packages = ["."]
@@ -318,7 +294,8 @@
   name = "golang.org/x/net"
   packages = [
     "context",
-    "context/ctxhttp"
+    "context/ctxhttp",
+    "proxy"
   ]
   revision = "cbe0f9307d0156177f9dd5dc85da1a31abc5f2fb"
 
@@ -359,6 +336,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "983bf3264628787237fa4445a0aa430be028dbfb056756d99a30e583d14e8514"
+  inputs-digest = "c81145698e213e2c8f26c3d5b7e52033c4a2438cfb8eda51b6864770fac71fe4"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -60,3 +60,11 @@
 [prune]
   go-tests = true
   unused-packages = true
+
+[[constraint]]
+  name = "github.com/docker/docker"
+  revision = "e3831a62a3052472d7252049bc59835d5d7dc8bd"
+
+[[override]]
+  name = "github.com/docker/distribution"
+  branch = "master"

constants/constants.go

@@ -30,3 +30,6 @@ const JSONIndent = "  "
 // DockerContainerPrefix is the prefix used for naming Docker containers.
 // It's also used to prefix the hostnames of the docker containers.
 const DockerContainerPrefix = "ptdl-"
+
+// WSMaxMessages is the maximum number of messages that are sent in one transfer.
+const WSMaxMessages = 10

control/console_handler.go

@@ -0,0 +1,33 @@
+package control
+
+import (
+	"io"
+
+	"github.com/pterodactyl/wings/api/websockets"
+)
+
+type ConsoleHandler struct {
+	Websockets  *websockets.Collection
+	HandlerFunc *func(string)
+}
+
+var _ io.Writer = ConsoleHandler{}
+
+func (c ConsoleHandler) Write(b []byte) (n int, e error) {
+	l := make([]byte, len(b))
+	copy(l, b)
+	line := string(l)
+	m := websockets.Message{
+		Type: websockets.MessageTypeConsole,
+		Payload: websockets.ConsolePayload{
+			Line:   line,
+			Level:  websockets.ConsoleLevelPlain,
+			Source: websockets.ConsoleSourceServer,
+		},
+	}
+	c.Websockets.Broadcast <- m
+	if c.HandlerFunc != nil {
+		(*c.HandlerFunc)(line)
+	}
+	return len(b), nil
+}

control/docker_environment.go

@@ -5,25 +5,21 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/client"
 	"github.com/pterodactyl/wings/constants"
-
-	"github.com/fsouza/go-dockerclient"
-	"github.com/pterodactyl/wings/api/websockets"
 	log "github.com/sirupsen/logrus"
 )
 
 type dockerEnvironment struct {
 	baseEnvironment
 
-	client    *docker.Client
+	client   *client.Client
-	container *docker.Container
+	hires    types.HijackedResponse
-	context   context.Context
-
 	attached bool
-	containerInput  io.Writer
-	containerOutput io.Writer
-	closeWaiter     docker.CloseWaiter
 
 	server *ServerStruct
 }
@@ -39,16 +35,20 @@ func NewDockerEnvironment(server *ServerStruct) (Environment, error) {
 	env := dockerEnvironment{}
 
 	env.server = server
+	env.attached = false
+
+	cli, err := client.NewEnvClient()
+	env.client = cli
+	ctx := context.TODO()
+	cli.NegotiateAPIVersion(ctx)
 
-	client, err := docker.NewClient("unix:///var/run/docker.sock")
-	env.client = client
 	if err != nil {
 		log.WithError(err).Fatal("Failed to connect to docker.")
 		return nil, err
 	}
 
 	if env.server.DockerContainer.ID != "" {
-		if err := env.checkContainerExists(); err != nil {
+		if err := env.inspectContainer(ctx); err != nil {
 			log.WithError(err).Error("Failed to find the container with stored id, removing id.")
 			env.server.DockerContainer.ID = ""
 			env.server.Save()
@@ -58,68 +58,28 @@ func NewDockerEnvironment(server *ServerStruct) (Environment, error) {
 	return &env, nil
 }
 
-func (env *dockerEnvironment) checkContainerExists() error {
+func (env *dockerEnvironment) inspectContainer(ctx context.Context) error {
-	container, err := env.client.InspectContainer(env.server.DockerContainer.ID)
+	_, err := env.client.ContainerInspect(ctx, env.server.DockerContainer.ID)
-	if err != nil {
 	return err
 }
-	env.container = container
-	return nil
-}
 
 func (env *dockerEnvironment) attach() error {
 	if env.attached {
 		return nil
 	}
-	pr, pw := io.Pipe()
-	env.containerInput = pw
-
-	cw := websockets.ConsoleWriter{
-		Hub: env.server.websockets,
-	}
-
-	success := make(chan struct{})
-	w, err := env.client.AttachToContainerNonBlocking(docker.AttachToContainerOptions{
-		Container:    env.server.DockerContainer.ID,
-		InputStream:  pr,
-		OutputStream: cw,
-		ErrorStream:  cw,
-		Stdin:        true,
-		Stdout:       true,
-		Stderr:       true,
-		Stream:       true,
-		Success:      success,
-	})
-	env.closeWaiter = w
-
-	<-success
-	close(success)
 	env.attached = true
-	return err
+	return nil
 }
 
 // Create creates the docker container for the environment and applies all
 // settings to it
 func (env *dockerEnvironment) Create() error {
 	log.WithField("server", env.server.ID).Debug("Creating docker environment")
-	// Split image repository and tag
-	imageParts := strings.Split(env.server.GetService().DockerImage, ":")
-	imageRepoParts := strings.Split(imageParts[0], "/")
-	if len(imageRepoParts) >= 3 {
-		// TODO: Handle possibly required authentication
-	}
 
-	// Pull docker image
+	ctx := context.TODO()
-	var pullImageOpts = docker.PullImageOptions{
+
-		Repository: imageParts[0],
+	if err := env.pullImage(ctx); err != nil {
-	}
+		log.WithError(err).WithField("image", env.server.GetService().DockerImage).WithField("server", env.server.ID).Error("Failed to pull docker image.")
-	if len(imageParts) >= 2 {
-		pullImageOpts.Tag = imageParts[1]
-	}
-	log.WithField("image", env.server.GetService().DockerImage).Debug("Pulling docker image")
-	err := env.client.PullImage(pullImageOpts, docker.AuthConfiguration{})
-	if err != nil {
-		log.WithError(err).WithField("server", env.server.ID).Error("Failed to create docker environment")
 		return err
 	}
 
@@ -129,27 +89,31 @@ func (env *dockerEnvironment) Create() error {
 
 	// Create docker container
 	// TODO: apply cpu, io, disk limits.
-	containerConfig := &docker.Config{
+
+	containerConfig := &container.Config{
 		Image:        env.server.GetService().DockerImage,
 		Cmd:          strings.Split(env.server.StartupCommand, " "),
+		AttachStdin:  true,
 		OpenStdin:    true,
-		ArgsEscaped: false,
+		AttachStdout: true,
+		AttachStderr: true,
+		Tty:          true,
 		Hostname:     constants.DockerContainerPrefix + env.server.UUIDShort(),
 	}
-	containerHostConfig := &docker.HostConfig{
+
+	containerHostConfig := &container.HostConfig{
+		Resources: container.Resources{
 			Memory:     env.server.Settings.Memory,
 			MemorySwap: env.server.Settings.Swap,
+		},
 		// TODO: Allow custom binds via some kind of settings in the service
 		Binds: []string{env.server.dataPath() + ":/home/container"},
 		// TODO: Add port bindings
 	}
-	createContainerOpts := docker.CreateContainerOptions{
+
-		Name:       constants.DockerContainerPrefix + env.server.UUIDShort(),
+	containerHostConfig.Memory = 0
-		Config:     containerConfig,
+
-		HostConfig: containerHostConfig,
+	container, err := env.client.ContainerCreate(ctx, containerConfig, containerHostConfig, nil, constants.DockerContainerPrefix+env.server.UUIDShort())
-		Context:    env.context,
-	}
-	container, err := env.client.CreateContainer(createContainerOpts)
 	if err != nil {
 		log.WithError(err).WithField("server", env.server.ID).Error("Failed to create docker container")
 		return err
@@ -157,11 +121,6 @@ func (env *dockerEnvironment) Create() error {
 
 	env.server.DockerContainer.ID = container.ID
 	env.server.Save()
-	env.container = container
-	if env.closeWaiter != nil {
-		env.closeWaiter.Close()
-	}
-	env.attached = false
 
 	log.WithField("server", env.server.ID).Debug("Docker environment created")
 	return nil
@@ -170,36 +129,29 @@ func (env *dockerEnvironment) Create() error {
 // Destroy removes the environment's docker container
 func (env *dockerEnvironment) Destroy() error {
 	log.WithField("server", env.server.ID).Debug("Destroying docker environment")
-	if _, err := env.client.InspectContainer(env.server.DockerContainer.ID); err != nil {
+
-		if _, ok := err.(*docker.NoSuchContainer); ok {
+	ctx := context.TODO()
+
+	if err := env.inspectContainer(ctx); err != nil {
+		log.WithError(err).Debug("Container not found error")
 		log.WithField("server", env.server.ID).Debug("Container not found, docker environment destroyed already.")
 		return nil
 	}
-		log.WithError(err).WithField("server", env.server.ID).Error("Could not destroy docker environment")
+
-		return err
+	if err := env.client.ContainerRemove(ctx, env.server.DockerContainer.ID, types.ContainerRemoveOptions{}); err != nil {
-	}
-	err := env.client.RemoveContainer(docker.RemoveContainerOptions{
-		ID: env.server.DockerContainer.ID,
-	})
-	if err != nil {
 		log.WithError(err).WithField("server", env.server.ID).Error("Failed to destroy docker environment")
 		return err
 	}
 
-	if env.closeWaiter != nil {
-		env.closeWaiter.Close()
-	}
-	env.attached = false
 	log.WithField("server", env.server.ID).Debug("Docker environment destroyed")
 	return nil
 }
 
 func (env *dockerEnvironment) Exists() bool {
-	if env.container != nil {
+	if err := env.inspectContainer(context.TODO()); err != nil {
-		return true
+		return false
 	}
-	env.checkContainerExists()
+	return true
-	return env.container != nil
 }
 
 // Start starts the environment's docker container
@@ -208,7 +160,8 @@ func (env *dockerEnvironment) Start() error {
 	if err := env.attach(); err != nil {
 		log.WithError(err).Error("Failed to attach to docker container")
 	}
-	if err := env.client.StartContainer(env.container.ID, nil); err != nil {
+
+	if err := env.client.ContainerStart(context.TODO(), env.server.DockerContainer.ID, types.ContainerStartOptions{}); err != nil {
 		log.WithError(err).Error("Failed to start docker container")
 		return err
 	}
@@ -218,7 +171,10 @@ func (env *dockerEnvironment) Start() error {
 // Stop stops the environment's docker container
 func (env *dockerEnvironment) Stop() error {
 	log.WithField("server", env.server.ID).Debug("Stopping service in docker environment")
-	if err := env.client.StopContainer(env.container.ID, 20000); err != nil {
+
+	// TODO: Decide after what timeout to kill the container, currently 10min
+	timeout := time.Minute * 10
+	if err := env.client.ContainerStop(context.TODO(), env.server.DockerContainer.ID, &timeout); err != nil {
 		log.WithError(err).Error("Failed to stop docker container")
 		return err
 	}
@@ -227,9 +183,8 @@ func (env *dockerEnvironment) Stop() error {
 
 func (env *dockerEnvironment) Kill() error {
 	log.WithField("server", env.server.ID).Debug("Killing service in docker environment")
-	if err := env.client.KillContainer(docker.KillContainerOptions{
+
-		ID: env.container.ID,
+	if err := env.client.ContainerKill(context.TODO(), env.server.DockerContainer.ID, "SIGKILL"); err != nil {
-	}); err != nil {
 		log.WithError(err).Error("Failed to kill docker container")
 		return err
 	}
@@ -238,7 +193,24 @@ func (env *dockerEnvironment) Kill() error {
 
 // Exec sends commands to the standard input of the docker container
 func (env *dockerEnvironment) Exec(command string) error {
-	log.Debug("Command: " + command)
+	//log.Debug("Command: " + command)
-	_, err := env.containerInput.Write([]byte(command + "\n"))
+	//_, err := env.containerInput.Write([]byte(command + "\n"))
+	//return err
+	return nil
+}
+
+func (env *dockerEnvironment) pullImage(ctx context.Context) error {
+	// Split image repository and tag
+	imageParts := strings.Split(env.server.GetService().DockerImage, ":")
+	imageRepoParts := strings.Split(imageParts[0], "/")
+	if len(imageRepoParts) >= 3 {
+		// TODO: Handle possibly required authentication
+	}
+
+	// Pull docker image
+	log.WithField("image", env.server.GetService().DockerImage).Debug("Pulling docker image")
+
+	rc, err := env.client.ImagePull(ctx, env.server.GetService().DockerImage, types.ImagePullOptions{})
+	defer rc.Close()
 	return err
 }

control/docker_environment_test.go

@@ -1,133 +1,125 @@
 package control
 
-import (
+// func testServer() *ServerStruct {
-	"fmt"
+// 	return &ServerStruct{
-	"testing"
+// 		ID: "testuuid-something-something",
+// 		service: &service{
+// 			DockerImage: "alpine:latest",
+// 		},
+// 	}
+// }
 
-	docker "github.com/fsouza/go-dockerclient"
+// func TestNewDockerEnvironment(t *testing.T) {
-	"github.com/stretchr/testify/assert"
+// 	env, err := createTestDockerEnv(nil)
-)
 
-func testServer() *ServerStruct {
+// 	assert.Nil(t, err)
-	return &ServerStruct{
+// 	assert.NotNil(t, env)
-		ID: "testuuid-something-something",
+// 	assert.NotNil(t, env.client)
-		service: &service{
+// }
-			DockerImage: "alpine:latest",
-		},
-	}
-}
 
-func TestNewDockerEnvironment(t *testing.T) {
+// func TestNewDockerEnvironmentExisting(t *testing.T) {
-	env, err := createTestDockerEnv(nil)
+// 	eenv, _ := createTestDockerEnv(nil)
+// 	eenv.Create()
 
-	assert.Nil(t, err)
+// 	env, err := createTestDockerEnv(eenv.server)
-	assert.NotNil(t, env)
-	assert.NotNil(t, env.client)
-}
 
-func TestNewDockerEnvironmentExisting(t *testing.T) {
+// 	assert.Nil(t, err)
-	eenv, _ := createTestDockerEnv(nil)
+// 	assert.NotNil(t, env)
-	eenv.Create()
+// 	assert.NotNil(t, env.container)
 
-	env, err := createTestDockerEnv(eenv.server)
+// 	eenv.Destroy()
+// }
 
-	assert.Nil(t, err)
+// func TestCreateDockerEnvironment(t *testing.T) {
-	assert.NotNil(t, env)
+// 	env, _ := createTestDockerEnv(nil)
-	assert.NotNil(t, env.container)
 
-	eenv.Destroy()
+// 	err := env.Create()
-}
 
-func TestCreateDockerEnvironment(t *testing.T) {
+// 	a := assert.New(t)
-	env, _ := createTestDockerEnv(nil)
+// 	a.Nil(err)
+// 	a.NotNil(env.container)
+// 	a.Equal(env.container.Name, "ptdl_testuuid")
 
-	err := env.Create()
+// 	if err := env.client.RemoveContainer(docker.RemoveContainerOptions{
+// 		ID: env.container.ID,
+// 	}); err != nil {
+// 		fmt.Println(err)
+// 	}
+// }
 
-	a := assert.New(t)
+// func TestDestroyDockerEnvironment(t *testing.T) {
-	a.Nil(err)
+// 	env, _ := createTestDockerEnv(nil)
-	a.NotNil(env.container)
+// 	env.Create()
-	a.Equal(env.container.Name, "ptdl_testuuid")
 
-	if err := env.client.RemoveContainer(docker.RemoveContainerOptions{
+// 	err := env.Destroy()
-		ID: env.container.ID,
-	}); err != nil {
-		fmt.Println(err)
-	}
-}
 
-func TestDestroyDockerEnvironment(t *testing.T) {
+// 	_, ierr := env.client.InspectContainer(env.container.ID)
-	env, _ := createTestDockerEnv(nil)
-	env.Create()
 
-	err := env.Destroy()
+// 	assert.Nil(t, err)
+// 	assert.IsType(t, ierr, &docker.NoSuchContainer{})
+// }
 
-	_, ierr := env.client.InspectContainer(env.container.ID)
+// func TestStartDockerEnvironment(t *testing.T) {
+// 	env, _ := createTestDockerEnv(nil)
+// 	env.Create()
+// 	err := env.Start()
 
-	assert.Nil(t, err)
+// 	i, ierr := env.client.InspectContainer(env.container.ID)
-	assert.IsType(t, ierr, &docker.NoSuchContainer{})
-}
 
-func TestStartDockerEnvironment(t *testing.T) {
+// 	assert.Nil(t, err)
-	env, _ := createTestDockerEnv(nil)
+// 	assert.Nil(t, ierr)
-	env.Create()
+// 	assert.True(t, i.State.Running)
-	err := env.Start()
 
-	i, ierr := env.client.InspectContainer(env.container.ID)
+// 	env.client.KillContainer(docker.KillContainerOptions{
+// 		ID: env.container.ID,
+// 	})
+// 	env.Destroy()
+// }
 
-	assert.Nil(t, err)
+// func TestStopDockerEnvironment(t *testing.T) {
-	assert.Nil(t, ierr)
+// 	env, _ := createTestDockerEnv(nil)
-	assert.True(t, i.State.Running)
+// 	env.Create()
+// 	env.Start()
+// 	err := env.Stop()
 
-	env.client.KillContainer(docker.KillContainerOptions{
+// 	i, ierr := env.client.InspectContainer(env.container.ID)
-		ID: env.container.ID,
-	})
-	env.Destroy()
-}
 
-func TestStopDockerEnvironment(t *testing.T) {
+// 	assert.Nil(t, err)
-	env, _ := createTestDockerEnv(nil)
+// 	assert.Nil(t, ierr)
-	env.Create()
+// 	assert.False(t, i.State.Running)
-	env.Start()
-	err := env.Stop()
 
-	i, ierr := env.client.InspectContainer(env.container.ID)
+// 	env.client.KillContainer(docker.KillContainerOptions{
+// 		ID: env.container.ID,
+// 	})
+// 	env.Destroy()
+// }
 
-	assert.Nil(t, err)
+// func TestKillDockerEnvironment(t *testing.T) {
-	assert.Nil(t, ierr)
+// 	env, _ := createTestDockerEnv(nil)
-	assert.False(t, i.State.Running)
+// 	env.Create()
+// 	env.Start()
+// 	err := env.Kill()
 
-	env.client.KillContainer(docker.KillContainerOptions{
+// 	i, ierr := env.client.InspectContainer(env.container.ID)
-		ID: env.container.ID,
-	})
-	env.Destroy()
-}
 
-func TestKillDockerEnvironment(t *testing.T) {
+// 	assert.Nil(t, err)
-	env, _ := createTestDockerEnv(nil)
+// 	assert.Nil(t, ierr)
-	env.Create()
+// 	assert.False(t, i.State.Running)
-	env.Start()
-	err := env.Kill()
 
-	i, ierr := env.client.InspectContainer(env.container.ID)
+// 	env.client.KillContainer(docker.KillContainerOptions{
+// 		ID: env.container.ID,
+// 	})
+// 	env.Destroy()
+// }
 
-	assert.Nil(t, err)
+// func TestExecDockerEnvironment(t *testing.T) {
-	assert.Nil(t, ierr)
-	assert.False(t, i.State.Running)
 
-	env.client.KillContainer(docker.KillContainerOptions{
+// }
-		ID: env.container.ID,
-	})
-	env.Destroy()
-}
 
-func TestExecDockerEnvironment(t *testing.T) {
+// func createTestDockerEnv(s *ServerStruct) (*dockerEnvironment, error) {
-
+// 	if s == nil {
-}
+// 		s = testServer()
-
+// 	}
-func createTestDockerEnv(s *ServerStruct) (*dockerEnvironment, error) {
+// 	env, err := NewDockerEnvironment(s)
-	if s == nil {
+// 	return env.(*dockerEnvironment), err
-		s = testServer()
+// }
-	}
-	env, err := NewDockerEnvironment(s)
-	return env.(*dockerEnvironment), err
-}