@@ -24,6 +24,7 @@ clone git github.com/docker/go-units 651fc226e7441360384da338d0fd37f2440ffbe3

 clone git github.com/docker/go-connections v0.1.2

 clone git github.com/docker/engine-api v0.2.1

 clone git github.com/RackSec/srslog 6eb773f331e46fbba8eecb8e794e635e75fc04de

+clone git github.com/imdario/mergo 0.2.1

 #get libnetwork packages

 clone git github.com/docker/libnetwork v0.5.4

new file mode 100644

@@ -0,0 +1,2 @@

+language: go

+install: go get -t

new file mode 100644

@@ -0,0 +1,28 @@

+Copyright (c) 2013 Dario Castañé. All rights reserved.

+Copyright (c) 2012 The Go Authors. All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions are

+met:

+

+   * Redistributions of source code must retain the above copyright

+notice, this list of conditions and the following disclaimer.

+   * Redistributions in binary form must reproduce the above

+copyright notice, this list of conditions and the following disclaimer

+in the documentation and/or other materials provided with the

+distribution.

+   * Neither the name of Google Inc. nor the names of its

+contributors may be used to endorse or promote products derived from

+this software without specific prior written permission.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

new file mode 100644

@@ -0,0 +1,122 @@

+# Mergo

+

+A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

+

+Also a lovely [comune](http://en.wikipedia.org/wiki/Mergo) (municipality) in the Province of Ancona in the Italian region Marche.

+

+![Mergo dall'alto](http://www.comune.mergo.an.it/Siti/Mergo/Immagini/Foto/mergo_dall_alto.jpg)

+

+## Status

+

+It is ready for production use. It works fine after extensive use in the wild.

+

+[![Build Status][1]][2]

+[![GoDoc](https://godoc.org/github.com/imdario/mergo?status.svg)](https://godoc.org/github.com/imdario/mergo)

+

+[1]: https://travis-ci.org/imdario/mergo.png

+[2]: https://travis-ci.org/imdario/mergo

+

+### Important note

+

+Mergo is intended to assign **only** zero value fields on destination with source value. Since April 6th it works like this. Before it didn't work properly, causing some random overwrites. After some issues and PRs I found it didn't merge as I designed it. Thanks to [imdario/mergo#8](https://github.com/imdario/mergo/pull/8) overwriting functions were added and the wrong behavior was clearly detected.

+

+If you were using Mergo **before** April 6th 2015, please check your project works as intended after updating your local copy with ```go get -u github.com/imdario/mergo```. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause (I hope it won't!) in existing projects after the change (release 0.2.0).

+

+### Mergo in the wild

+

+- [imdario/zas](https://github.com/imdario/zas)

+- [GoogleCloudPlatform/kubernetes](https://github.com/GoogleCloudPlatform/kubernetes)

+- [soniah/dnsmadeeasy](https://github.com/soniah/dnsmadeeasy)

+- [EagerIO/Stout](https://github.com/EagerIO/Stout)

+- [lynndylanhurley/defsynth-api](https://github.com/lynndylanhurley/defsynth-api)

+- [russross/canvasassignments](https://github.com/russross/canvasassignments)

+- [rdegges/cryptly-api](https://github.com/rdegges/cryptly-api)

+- [casualjim/exeggutor](https://github.com/casualjim/exeggutor)

+- [divshot/gitling](https://github.com/divshot/gitling)

+- [RWJMurphy/gorl](https://github.com/RWJMurphy/gorl)

+- [andrerocker/deploy42](https://github.com/andrerocker/deploy42)

+- [elwinar/rambler](https://github.com/elwinar/rambler)

+- [tmaiaroto/gopartman](https://github.com/tmaiaroto/gopartman)

+- [jfbus/impressionist](https://github.com/jfbus/impressionist)

+- [Jmeyering/zealot](https://github.com/Jmeyering/zealot)

+- [godep-migrator/rigger-host](https://github.com/godep-migrator/rigger-host)

+- [Dronevery/MultiwaySwitch-Go](https://github.com/Dronevery/MultiwaySwitch-Go)

+- [thoas/picfit](https://github.com/thoas/picfit)

+- [mantasmatelis/whooplist-server](https://github.com/mantasmatelis/whooplist-server)

+- [jnuthong/item_search](https://github.com/jnuthong/item_search)

+

+## Installation

+

+    go get github.com/imdario/mergo

+

+    // use in your .go code

+    import (

+        "github.com/imdario/mergo"

+    )

+

+## Usage

+

+You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. Also maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).

+

+    if err := mergo.Merge(&dst, src); err != nil {

+        // ...

+    }

+

+Additionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field.

+

+    if err := mergo.Map(&dst, srcMap); err != nil {

+        // ...

+    }

+

+Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values.

+

+More information and examples in [godoc documentation](http://godoc.org/github.com/imdario/mergo).

+

+### Nice example

+

+```go

+package main

+

+import (

+	"fmt"

+	"github.com/imdario/mergo"

+)

+

+type Foo struct {

+	A string

+	B int64

+}

+

+func main() {

+	src := Foo{

+		A: "one",

+	}

+

+	dest := Foo{

+		A: "two",

+		B: 2,

+	}

+

+	mergo.Merge(&dest, src)

+

+	fmt.Println(dest)

+	// Will print

+	// {two 2}

+}

+```

+

+Note: if test are failing due missing package, please execute:

+

+    go get gopkg.in/yaml.v1

+

+## Contact me

+

+If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario)

+

+## About

+

+Written by [Dario Castañé](http://dario.im).

+

+## License

+

+[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE).

new file mode 100644

@@ -0,0 +1,44 @@

+// Copyright 2013 Dario Castañé. All rights reserved.

+// Copyright 2009 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+/*

+Package mergo merges same-type structs and maps by setting default values in zero-value fields.

+

+Mergo won't merge unexported (private) fields but will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

+

+Usage

+

+From my own work-in-progress project:

+

+	type networkConfig struct {

+		Protocol string

+		Address string

+		ServerType string `json: "server_type"`

+		Port uint16

+	}

+

+	type FssnConfig struct {

+		Network networkConfig

+	}

+

+	var fssnDefault = FssnConfig {

+		networkConfig {

+			"tcp",

+			"127.0.0.1",

+			"http",

+			31560,

+		},

+	}

+

+	// Inside a function [...]

+

+	if err := mergo.Merge(&config, fssnDefault); err != nil {

+		log.Fatal(err)

+	}

+

+	// More code [...]

+

+*/

+package mergo

new file mode 100644

@@ -0,0 +1,154 @@

+// Copyright 2014 Dario Castañé. All rights reserved.

+// Copyright 2009 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// Based on src/pkg/reflect/deepequal.go from official

+// golang's stdlib.

+

+package mergo

+

+import (

+	"fmt"

+	"reflect"

+	"unicode"

+	"unicode/utf8"

+)

+

+func changeInitialCase(s string, mapper func(rune) rune) string {

+	if s == "" {

+		return s

+	}

+	r, n := utf8.DecodeRuneInString(s)

+	return string(mapper(r)) + s[n:]

+}

+

+func isExported(field reflect.StructField) bool {

+	r, _ := utf8.DecodeRuneInString(field.Name)

+	return r >= 'A' && r <= 'Z'

+}

+

+// Traverses recursively both values, assigning src's fields values to dst.

+// The map argument tracks comparisons that have already been seen, which allows

+// short circuiting on recursive types.

+func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, overwrite bool) (err error) {

+	if dst.CanAddr() {

+		addr := dst.UnsafeAddr()

+		h := 17 * addr

+		seen := visited[h]

+		typ := dst.Type()

+		for p := seen; p != nil; p = p.next {

+			if p.ptr == addr && p.typ == typ {

+				return nil

+			}

+		}

+		// Remember, remember...

+		visited[h] = &visit{addr, typ, seen}

+	}

+	zeroValue := reflect.Value{}

+	switch dst.Kind() {

+	case reflect.Map:

+		dstMap := dst.Interface().(map[string]interface{})

+		for i, n := 0, src.NumField(); i < n; i++ {

+			srcType := src.Type()

+			field := srcType.Field(i)

+			if !isExported(field) {

+				continue

+			}

+			fieldName := field.Name

+			fieldName = changeInitialCase(fieldName, unicode.ToLower)

+			if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v)) || overwrite) {

+				dstMap[fieldName] = src.Field(i).Interface()

+			}

+		}

+	case reflect.Struct:

+		srcMap := src.Interface().(map[string]interface{})

+		for key := range srcMap {

+			srcValue := srcMap[key]

+			fieldName := changeInitialCase(key, unicode.ToUpper)

+			dstElement := dst.FieldByName(fieldName)

+			if dstElement == zeroValue {

+				// We discard it because the field doesn't exist.

+				continue

+			}

+			srcElement := reflect.ValueOf(srcValue)

+			dstKind := dstElement.Kind()

+			srcKind := srcElement.Kind()

+			if srcKind == reflect.Ptr && dstKind != reflect.Ptr {

+				srcElement = srcElement.Elem()

+				srcKind = reflect.TypeOf(srcElement.Interface()).Kind()

+			} else if dstKind == reflect.Ptr {

+				// Can this work? I guess it can't.

+				if srcKind != reflect.Ptr && srcElement.CanAddr() {

+					srcPtr := srcElement.Addr()

+					srcElement = reflect.ValueOf(srcPtr)

+					srcKind = reflect.Ptr

+				}

+			}

+			if !srcElement.IsValid() {

+				continue

+			}

+			if srcKind == dstKind {

+				if err = deepMerge(dstElement, srcElement, visited, depth+1, overwrite); err != nil {

+					return

+				}

+			} else {

+				if srcKind == reflect.Map {

+					if err = deepMap(dstElement, srcElement, visited, depth+1, overwrite); err != nil {

+						return

+					}

+				} else {

+					return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)

+				}

+			}

+		}

+	}

+	return

+}

+

+// Map sets fields' values in dst from src.

+// src can be a map with string keys or a struct. dst must be the opposite:

+// if src is a map, dst must be a valid pointer to struct. If src is a struct,

+// dst must be map[string]interface{}.

+// It won't merge unexported (private) fields and will do recursively

+// any exported field.

+// If dst is a map, keys will be src fields' names in lower camel case.

+// Missing key in src that doesn't match a field in dst will be skipped. This

+// doesn't apply if dst is a map.

+// This is separated method from Merge because it is cleaner and it keeps sane

+// semantics: merging equal types, mapping different (restricted) types.

+func Map(dst, src interface{}) error {

+	return _map(dst, src, false)

+}

+

+func MapWithOverwrite(dst, src interface{}) error {

+	return _map(dst, src, true)

+}

+

+func _map(dst, src interface{}, overwrite bool) error {

+	var (

+		vDst, vSrc reflect.Value

+		err        error

+	)

+	if vDst, vSrc, err = resolveValues(dst, src); err != nil {

+		return err

+	}

+	// To be friction-less, we redirect equal-type arguments

+	// to deepMerge. Only because arguments can be anything.

+	if vSrc.Kind() == vDst.Kind() {

+		return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, overwrite)

+	}

+	switch vSrc.Kind() {

+	case reflect.Struct:

+		if vDst.Kind() != reflect.Map {

+			return ErrExpectedMapAsDestination

+		}

+	case reflect.Map:

+		if vDst.Kind() != reflect.Struct {

+			return ErrExpectedStructAsDestination

+		}

+	default:

+		return ErrNotSupported

+	}

+	return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, overwrite)

+}

new file mode 100644

@@ -0,0 +1,120 @@

+// Copyright 2013 Dario Castañé. All rights reserved.

+// Copyright 2009 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// Based on src/pkg/reflect/deepequal.go from official

+// golang's stdlib.

+

+package mergo

+

+import (

+	"reflect"

+)

+

+// Traverses recursively both values, assigning src's fields values to dst.

+// The map argument tracks comparisons that have already been seen, which allows

+// short circuiting on recursive types.

+func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, overwrite bool) (err error) {

+	if !src.IsValid() {

+		return

+	}

+	if dst.CanAddr() {

+		addr := dst.UnsafeAddr()

+		h := 17 * addr

+		seen := visited[h]

+		typ := dst.Type()

+		for p := seen; p != nil; p = p.next {

+			if p.ptr == addr && p.typ == typ {

+				return nil

+			}

+		}

+		// Remember, remember...

+		visited[h] = &visit{addr, typ, seen}

+	}

+	switch dst.Kind() {

+	case reflect.Struct:

+		for i, n := 0, dst.NumField(); i < n; i++ {

+			if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, overwrite); err != nil {

+				return

+			}

+		}

+	case reflect.Map:

+		for _, key := range src.MapKeys() {

+			srcElement := src.MapIndex(key)

+			if !srcElement.IsValid() {

+				continue

+			}

+			dstElement := dst.MapIndex(key)

+			switch srcElement.Kind() {

+			case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Slice:

+				if srcElement.IsNil() {

+					continue

+				}

+				fallthrough

+			default:

+				switch reflect.TypeOf(srcElement.Interface()).Kind() {

+				case reflect.Struct:

+					fallthrough

+				case reflect.Ptr:

+					fallthrough

+				case reflect.Map:

+					if err = deepMerge(dstElement, srcElement, visited, depth+1, overwrite); err != nil {

+						return

+					}

+				}

+			}

+			if !isEmptyValue(srcElement) && (overwrite || (!dstElement.IsValid() || isEmptyValue(dst))) {

+				if dst.IsNil() {

+					dst.Set(reflect.MakeMap(dst.Type()))

+				}

+				dst.SetMapIndex(key, srcElement)

+			}

+		}

+	case reflect.Ptr:

+		fallthrough

+	case reflect.Interface:

+		if src.IsNil() {

+			break

+		} else if dst.IsNil() {

+			if dst.CanSet() && (overwrite || isEmptyValue(dst)) {

+				dst.Set(src)

+			}

+		} else if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, overwrite); err != nil {

+			return

+		}

+	default:

+		if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) {

+			dst.Set(src)

+		}

+	}

+	return

+}

+

+// Merge sets fields' values in dst from src if they have a zero

+// value of their type.

+// dst and src must be valid same-type structs and dst must be

+// a pointer to struct.

+// It won't merge unexported (private) fields and will do recursively

+// any exported field.

+func Merge(dst, src interface{}) error {

+	return merge(dst, src, false)

+}

+

+func MergeWithOverwrite(dst, src interface{}) error {

+	return merge(dst, src, true)

+}

+

+func merge(dst, src interface{}, overwrite bool) error {

+	var (

+		vDst, vSrc reflect.Value

+		err        error

+	)

+	if vDst, vSrc, err = resolveValues(dst, src); err != nil {

+		return err

+	}

+	if vDst.Type() != vSrc.Type() {

+		return ErrDifferentArgumentsTypes

+	}

+	return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, overwrite)

+}

new file mode 100644

@@ -0,0 +1,90 @@

+// Copyright 2013 Dario Castañé. All rights reserved.

+// Copyright 2009 The Go Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style

+// license that can be found in the LICENSE file.

+

+// Based on src/pkg/reflect/deepequal.go from official

+// golang's stdlib.

+

+package mergo

+

+import (

+	"errors"

+	"reflect"

+)

+

+// Errors reported by Mergo when it finds invalid arguments.

+var (

+	ErrNilArguments                = errors.New("src and dst must not be nil")

+	ErrDifferentArgumentsTypes     = errors.New("src and dst must be of same type")

+	ErrNotSupported                = errors.New("only structs and maps are supported")

+	ErrExpectedMapAsDestination    = errors.New("dst was expected to be a map")

+	ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")

+)

+

+// During deepMerge, must keep track of checks that are

+// in progress.  The comparison algorithm assumes that all

+// checks in progress are true when it reencounters them.

+// Visited are stored in a map indexed by 17 * a1 + a2;

+type visit struct {

+	ptr  uintptr

+	typ  reflect.Type

+	next *visit

+}

+

+// From src/pkg/encoding/json.

+func isEmptyValue(v reflect.Value) bool {

+	switch v.Kind() {

+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:

+		return v.Len() == 0

+	case reflect.Bool:

+		return !v.Bool()

+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

+		return v.Int() == 0

+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:

+		return v.Uint() == 0

+	case reflect.Float32, reflect.Float64:

+		return v.Float() == 0

+	case reflect.Interface, reflect.Ptr:

+		return v.IsNil()

+	}

+	return false

+}

+

+func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {

+	if dst == nil || src == nil {

+		err = ErrNilArguments

+		return

+	}

+	vDst = reflect.ValueOf(dst).Elem()

+	if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map {

+		err = ErrNotSupported

+		return

+	}

+	vSrc = reflect.ValueOf(src)

+	// We check if vSrc is a pointer to dereference it.

+	if vSrc.Kind() == reflect.Ptr {

+		vSrc = vSrc.Elem()

+	}

+	return

+}

+

+// Traverses recursively both values, assigning src's fields values to dst.

+// The map argument tracks comparisons that have already been seen, which allows

+// short circuiting on recursive types.

+func deeper(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) {

+	if dst.CanAddr() {

+		addr := dst.UnsafeAddr()

+		h := 17 * addr

+		seen := visited[h]

+		typ := dst.Type()

+		for p := seen; p != nil; p = p.next {

+			if p.ptr == addr && p.typ == typ {

+				return nil

+			}

+		}

+		// Remember, remember...

+		visited[h] = &visit{addr, typ, seen}

+	}

+	return // TODO refactor

+}