Vendor integration dependencies.

integration/vendor/github.com/docker/libcompose/lookup/composable.go

@@ -0,0 +1,25 @@
+package lookup
+
+import (
+	"github.com/docker/libcompose/config"
+)
+
+// ComposableEnvLookup is a structure that implements the project.EnvironmentLookup interface.
+// It holds an ordered list of EnvironmentLookup to call to look for the environment value.
+type ComposableEnvLookup struct {
+	Lookups []config.EnvironmentLookup
+}
+
+// Lookup creates a string slice of string containing a "docker-friendly" environment string
+// in the form of 'key=value'. It loop through the lookups and returns the latest value if
+// more than one lookup return a result.
+func (l *ComposableEnvLookup) Lookup(key, serviceName string, config *config.ServiceConfig) []string {
+	result := []string{}
+	for _, lookup := range l.Lookups {
+		env := lookup.Lookup(key, serviceName, config)
+		if len(env) == 1 {
+			result = env
+		}
+	}
+	return result
+}

integration/vendor/github.com/docker/libcompose/lookup/envfile.go

@@ -0,0 +1,31 @@
+package lookup
+
+import (
+	"strings"
+
+	"github.com/docker/docker/runconfig/opts"
+	"github.com/docker/libcompose/config"
+)
+
+// EnvfileLookup is a structure that implements the project.EnvironmentLookup interface.
+// It holds the path of the file where to lookup environment values.
+type EnvfileLookup struct {
+	Path string
+}
+
+// Lookup creates a string slice of string containing a "docker-friendly" environment string
+// in the form of 'key=value'. It gets environment values using a '.env' file in the specified
+// path.
+func (l *EnvfileLookup) Lookup(key, serviceName string, config *config.ServiceConfig) []string {
+	envs, err := opts.ParseEnvFile(l.Path)
+	if err != nil {
+		return []string{}
+	}
+	for _, env := range envs {
+		e := strings.Split(env, "=")
+		if e[0] == key {
+			return []string{env}
+		}
+	}
+	return []string{}
+}

integration/vendor/github.com/docker/libcompose/lookup/file.go

@@ -0,0 +1,66 @@
+package lookup
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/Sirupsen/logrus"
+)
+
+// relativePath returns the proper relative path for the given file path. If
+// the relativeTo string equals "-", then it means that it's from the stdin,
+// and the returned path will be the current working directory. Otherwise, if
+// file is really an absolute path, then it will be returned without any
+// changes. Otherwise, the returned path will be a combination of relativeTo
+// and file.
+func relativePath(file, relativeTo string) string {
+	// stdin: return the current working directory if possible.
+	if relativeTo == "-" {
+		if cwd, err := os.Getwd(); err == nil {
+			return cwd
+		}
+	}
+
+	// If the given file is already an absolute path, just return it.
+	// Otherwise, the returned path will be relative to the given relativeTo
+	// path.
+	if filepath.IsAbs(file) {
+		return file
+	}
+
+	abs, err := filepath.Abs(filepath.Join(path.Dir(relativeTo), file))
+	if err != nil {
+		logrus.Errorf("Failed to get absolute directory: %s", err)
+		return file
+	}
+	return abs
+}
+
+// FileConfigLookup is a "bare" structure that implements the project.ResourceLookup interface
+type FileConfigLookup struct {
+}
+
+// Lookup returns the content and the actual filename of the file that is "built" using the
+// specified file and relativeTo string. file and relativeTo are supposed to be file path.
+// If file starts with a slash ('/'), it tries to load it, otherwise it will build a
+// filename using the folder part of relativeTo joined with file.
+func (f *FileConfigLookup) Lookup(file, relativeTo string) ([]byte, string, error) {
+	file = relativePath(file, relativeTo)
+	logrus.Debugf("Reading file %s", file)
+	bytes, err := ioutil.ReadFile(file)
+	return bytes, file, err
+}
+
+// ResolvePath returns the path to be used for the given path volume. This
+// function already takes care of relative paths.
+func (f *FileConfigLookup) ResolvePath(path, inFile string) string {
+	vs := strings.SplitN(path, ":", 2)
+	if len(vs) != 2 || filepath.IsAbs(vs[0]) {
+		return path
+	}
+	vs[0] = relativePath(vs[0], inFile)
+	return strings.Join(vs, ":")
+}

integration/vendor/github.com/docker/libcompose/lookup/simple_env.go

@@ -0,0 +1,24 @@
+package lookup
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/docker/libcompose/config"
+)
+
+// OsEnvLookup is a "bare" structure that implements the project.EnvironmentLookup interface
+type OsEnvLookup struct {
+}
+
+// Lookup creates a string slice of string containing a "docker-friendly" environment string
+// in the form of 'key=value'. It gets environment values using os.Getenv.
+// If the os environment variable does not exists, the slice is empty. serviceName and config
+// are not used at all in this implementation.
+func (o *OsEnvLookup) Lookup(key, serviceName string, config *config.ServiceConfig) []string {
+	ret := os.Getenv(key)
+	if ret == "" {
+		return []string{}
+	}
+	return []string{fmt.Sprintf("%s=%s", key, ret)}
+}