@@ -103,6 +103,9 @@ func (cli *DockerCli) CmdInfo(args ...string) error {

 	}

 	ioutils.FprintfIfTrue(cli.out, "Experimental: %v\n", info.ExperimentalBuild)

+	if info.ClusterStore != "" {

+		fmt.Fprintf(cli.out, "Cluster store: %s\n", info.ClusterStore)

+	}

 	return nil

 }

@@ -216,6 +216,7 @@ type Info struct {

 	Labels             []string

 	ExperimentalBuild  bool

 	ServerVersion      string

+	ClusterStore       string

 }

 // ExecStartCheck is a temp struct used by execStart

@@ -33,7 +33,16 @@ type CommonConfig struct {

 	Root           string

 	TrustKeyPath   string

 	DefaultNetwork string

-	NetworkKVStore string

+

+	// ClusterStore is the storage backend used for the cluster information. It is used by both

+	// multihost networking (to store networks and endpoints information) and by the node discovery

+	// mechanism.

+	ClusterStore string

+

+	// ClusterAdvertise is the network endpoint that the Engine advertises for the purpose of node

+	// discovery. This should be a 'host:port' combination on which that daemon instance is

+	// reachable by other hosts.

+	ClusterAdvertise string

 }

 // InstallCommonFlags adds command-line options to the top-level flag parser for

@@ -57,4 +66,6 @@ func (config *Config) InstallCommonFlags(cmd *flag.FlagSet, usageFn func(string)

 	cmd.Var(opts.NewListOptsRef(&config.Labels, opts.ValidateLabel), []string{"-label"}, usageFn("Set key=value labels to the daemon"))

 	cmd.StringVar(&config.LogConfig.Type, []string{"-log-driver"}, "json-file", usageFn("Default driver for container logs"))

 	cmd.Var(opts.NewMapOpts(config.LogConfig.Config, nil), []string{"-log-opt"}, usageFn("Set log driver options"))

+	cmd.StringVar(&config.ClusterAdvertise, []string{"-cluster-advertise"}, "", usageFn("Address of the daemon instance to advertise"))

+	cmd.StringVar(&config.ClusterStore, []string{"-cluster-store"}, "", usageFn("Set the cluster store"))

 }

@@ -6,5 +6,4 @@ import flag "github.com/docker/docker/pkg/mflag"

 func (config *Config) attachExperimentalFlags(cmd *flag.FlagSet, usageFn func(string) string) {

 	cmd.StringVar(&config.DefaultNetwork, []string{"-default-network"}, "", usageFn("Set default network"))

-	cmd.StringVar(&config.NetworkKVStore, []string{"-kv-store"}, "", usageFn("Set KV Store configuration"))

 }

@@ -34,6 +34,7 @@ import (

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/pkg/archive"

 	"github.com/docker/docker/pkg/broadcastwriter"

+	"github.com/docker/docker/pkg/discovery"

 	"github.com/docker/docker/pkg/fileutils"

 	"github.com/docker/docker/pkg/graphdb"

 	"github.com/docker/docker/pkg/ioutils"

@@ -116,6 +117,7 @@ type Daemon struct {

 	EventsService    *events.Events

 	netController    libnetwork.NetworkController

 	volumes          *store.VolumeStore

+	discoveryWatcher discovery.Watcher

 	root             string

 	shutdown         bool

 }

@@ -751,6 +753,16 @@ func NewDaemon(config *Config, registryService *registry.Service) (daemon *Daemo

 		return nil, err

 	}

+	// Discovery is only enabled when the daemon is launched with an address to advertise.  When

+	// initialized, the daemon is registered and we can store the discovery backend as its read-only

+	// DiscoveryWatcher version.

+	if config.ClusterStore != "" && config.ClusterAdvertise != "" {

+		var err error

+		if d.discoveryWatcher, err = initDiscovery(config.ClusterStore, config.ClusterAdvertise); err != nil {

+			return nil, fmt.Errorf("discovery initialization failed (%v)", err)

+		}

+	}

+

 	d.ID = trustKey.PublicKey().KeyID()

 	d.repository = daemonRepo

 	d.containers = &contStore{s: make(map[string]*Container)}

@@ -312,8 +312,8 @@ func networkOptions(dconfig *Config) ([]nwconfig.Option, error) {

 		options = append(options, nwconfig.OptionDefaultNetwork(dn))

 	}

-	if strings.TrimSpace(dconfig.NetworkKVStore) != "" {

-		kv := strings.Split(dconfig.NetworkKVStore, "://")

+	if strings.TrimSpace(dconfig.ClusterStore) != "" {

+		kv := strings.Split(dconfig.ClusterStore, "://")

 		if len(kv) < 2 {

 			return nil, fmt.Errorf("kv store daemon config must be of the form KV-PROVIDER://KV-URL")

 		}

new file mode 100644

@@ -0,0 +1,48 @@

+package daemon

+

+import (

+	"time"

+

+	log "github.com/Sirupsen/logrus"

+	"github.com/docker/docker/pkg/discovery"

+

+	// Register the libkv backends for discovery.

+	_ "github.com/docker/docker/pkg/discovery/kv"

+)

+

+const (

+	// defaultDiscoveryHeartbeat is the default value for discovery heartbeat interval.

+	defaultDiscoveryHeartbeat = 20 * time.Second

+

+	// defaultDiscoveryTTL is the default TTL interface for discovery.

+	defaultDiscoveryTTL = 60 * time.Second

+)

+

+// initDiscovery initialized the nodes discovery subsystem by connecting to the specified backend

+// and start a registration loop to advertise the current node under the specified address.

+func initDiscovery(backend, address string) (discovery.Backend, error) {

+	var (

+		discoveryBackend discovery.Backend

+		err              error

+	)

+	if discoveryBackend, err = discovery.New(backend, defaultDiscoveryHeartbeat, defaultDiscoveryTTL); err != nil {

+		return nil, err

+	}

+

+	// We call Register() on the discovery backend in a loop for the whole lifetime of the daemon,

+	// but we never actually Watch() for nodes appearing and disappearing for the moment.

+	go registrationLoop(discoveryBackend, address)

+	return discoveryBackend, nil

+}

+

+// registrationLoop registers the current node against the discovery backend using the specified

+// address. The function never returns, as registration against the backend comes with a TTL and

+// requires regular heartbeats.

+func registrationLoop(discoveryBackend discovery.Backend, address string) {

+	for {

+		if err := discoveryBackend.Register(address); err != nil {

+			log.Errorf("Registering as %q in discovery failed: %v", address, err)

+		}

+		time.Sleep(defaultDiscoveryHeartbeat)

+	}

+}

@@ -92,6 +92,7 @@ func (daemon *Daemon) SystemInfo(ctx context.Context) (*types.Info, error) {

 		Labels:             daemon.config().Labels,

 		ExperimentalBuild:  utils.ExperimentalBuild(),

 		ServerVersion:      dockerversion.VERSION,

+		ClusterStore:       daemon.config().ClusterStore,

 	}

 	// TODO Windows. Refactor this more once sysinfo is refactored into

@@ -1821,6 +1821,7 @@ Display system-wide information

         "CpuCfsPeriod": true,

         "CpuCfsQuota": true,

         "Debug": false,

+        "DiscoveryBackend": "etcd://localhost:2379",

         "DockerRootDir": "/var/lib/docker",

         "Driver": "btrfs",

         "DriverStatus": [[""]],

@@ -22,6 +22,8 @@ weight=1

       -D, --debug=false                      Enable debug mode

       --default-gateway=""                   Container default gateway IPv4 address

       --default-gateway-v6=""                Container default gateway IPv6 address

+      --cluster-store=""                     URL of the distributed storage backend

+      --cluster-advertise=""                 Address of the daemon instance to advertise

       --dns=[]                               DNS server to use

       --dns-opt=[]                           DNS options to use

       --dns-search=[]                        DNS search domains to use

@@ -484,6 +486,12 @@ Be careful setting `nproc` with the `ulimit` flag as `nproc` is designed by Linu

 set the maximum number of processes available to a user, not to a container. For details

 please check the [run](run.md) reference.

+## Nodes discovery

+

+`--cluster-advertise` specifies the 'host:port' combination that this particular

+daemon instance should use when advertising itself to the cluster. The daemon

+should be reachable by remote hosts on this 'host:port' combination.

+

 ## Miscellaneous options

 IP masquerading uses address translation to allow containers without a public

@@ -5,10 +5,10 @@ Using the above experimental UI `docker network`, `docker service` and `--publis

 Since `network` and `service` objects are globally significant, this feature requires distributed states provided by the `libkv` project.

 Using `libkv`, the user can plug any of the supported Key-Value store (such as consul, etcd or zookeeper).

-User can specify the Key-Value store of choice using the `--kv-store` daemon flag, which takes configuration value of format `PROVIDER:URL`, where

+User can specify the Key-Value store of choice using the `--cluster-store` daemon flag, which takes configuration value of format `PROVIDER:URL`, where

 `PROVIDER` is the name of the Key-Value store (such as consul, etcd or zookeeper) and

 `URL` is the url to reach the Key-Value store.

-Example : `docker daemon --kv-store=consul:localhost:8500`

+Example : `docker daemon --cluster-store=consul://localhost:8500`

 Send us feedback and comments on [#14083](https://github.com/docker/docker/issues/14083)

 or on the usual Google Groups (docker-user, docker-dev) and IRC channels.

@@ -108,6 +108,8 @@ clean() {

 	findArgs=(

 		# This directory contains only .c and .h files which are necessary

 		-path vendor/src/github.com/mattn/go-sqlite3/code

+		# This directory is needed for compiling the unit tests

+		-o -path vendor/src/github.com/stretchr/objx

 	)

 	for import in "${imports[@]}"; do

 		[ "${#findArgs[@]}" -eq 0 ] || findArgs+=( -or )

@@ -16,6 +16,7 @@ clone git github.com/kr/pty 5cf931ef8f

 clone git github.com/mattn/go-sqlite3 v1.1.0

 clone git github.com/microsoft/hcsshim 7f646aa6b26bcf90caee91e93cde4a80d0d8a83e

 clone git github.com/mistifyio/go-zfs v2.1.1

+clone git github.com/stretchr/objx cbeaeb16a013161a98496fad62933b1d21786672

 clone git github.com/stretchr/testify 7c2b1e5640dcf2631213ca962d892bffa1e08860

 clone git github.com/tchap/go-patricia v2.1.0

 clone git golang.org/x/net 3cffabab72adf04f8e3b01c5baf775361837b5fe https://github.com/golang/net.git

@@ -1,8 +1,10 @@

 package main

 import (

+	"fmt"

 	"strings"

+	"github.com/docker/docker/pkg/integration/checker"

 	"github.com/docker/docker/utils"

 	"github.com/go-check/check"

 )

@@ -35,3 +37,20 @@ func (s *DockerSuite) TestInfoEnsureSucceeds(c *check.C) {

 		}

 	}

 }

+

+// TestInfoDiscoveryBackend verifies that a daemon run with `--cluster-advertise` and

+// `--cluster-store` properly show the backend's endpoint in info output.

+func (s *DockerSuite) TestInfoDiscoveryBackend(c *check.C) {

+	testRequires(c, SameHostDaemon)

+

+	d := NewDaemon(c)

+	discoveryBackend := "consul://consuladdr:consulport/some/path"

+	if err := d.Start(fmt.Sprintf("--cluster-store=%s", discoveryBackend), "--cluster-advertise=foo"); err != nil {

+		c.Fatal(err)

+	}

+	defer d.Stop()

+

+	out, err := d.Cmd("info")

+	c.Assert(err, checker.IsNil)

+	c.Assert(out, checker.Contains, fmt.Sprintf("Cluster store: %s\n", discoveryBackend))

+}

new file mode 100644

@@ -0,0 +1,113 @@

+package mock

+

+import (

+	"github.com/docker/libkv/store"

+	"github.com/stretchr/testify/mock"

+)

+

+// Mock store. Mocks all Store functions using testify.Mock

+type Mock struct {

+	mock.Mock

+

+	// Endpoints passed to InitializeMock

+	Endpoints []string

+

+	// Options passed to InitializeMock

+	Options *store.Config

+}

+

+// New creates a Mock store

+func New(endpoints []string, options *store.Config) (store.Store, error) {

+	s := &Mock{}

+	s.Endpoints = endpoints

+	s.Options = options

+	return s, nil

+}

+

+// Put mock

+func (s *Mock) Put(key string, value []byte, opts *store.WriteOptions) error {

+	args := s.Mock.Called(key, value, opts)

+	return args.Error(0)

+}

+

+// Get mock

+func (s *Mock) Get(key string) (*store.KVPair, error) {

+	args := s.Mock.Called(key)

+	return args.Get(0).(*store.KVPair), args.Error(1)

+}

+

+// Delete mock

+func (s *Mock) Delete(key string) error {

+	args := s.Mock.Called(key)

+	return args.Error(0)

+}

+

+// Exists mock

+func (s *Mock) Exists(key string) (bool, error) {

+	args := s.Mock.Called(key)

+	return args.Bool(0), args.Error(1)

+}

+

+// Watch mock

+func (s *Mock) Watch(key string, stopCh <-chan struct{}) (<-chan *store.KVPair, error) {

+	args := s.Mock.Called(key, stopCh)

+	return args.Get(0).(<-chan *store.KVPair), args.Error(1)

+}

+

+// WatchTree mock

+func (s *Mock) WatchTree(prefix string, stopCh <-chan struct{}) (<-chan []*store.KVPair, error) {

+	args := s.Mock.Called(prefix, stopCh)

+	return args.Get(0).(chan []*store.KVPair), args.Error(1)

+}

+

+// NewLock mock

+func (s *Mock) NewLock(key string, options *store.LockOptions) (store.Locker, error) {

+	args := s.Mock.Called(key, options)

+	return args.Get(0).(store.Locker), args.Error(1)

+}

+

+// List mock

+func (s *Mock) List(prefix string) ([]*store.KVPair, error) {

+	args := s.Mock.Called(prefix)

+	return args.Get(0).([]*store.KVPair), args.Error(1)

+}

+

+// DeleteTree mock

+func (s *Mock) DeleteTree(prefix string) error {

+	args := s.Mock.Called(prefix)

+	return args.Error(0)

+}

+

+// AtomicPut mock

+func (s *Mock) AtomicPut(key string, value []byte, previous *store.KVPair, opts *store.WriteOptions) (bool, *store.KVPair, error) {

+	args := s.Mock.Called(key, value, previous, opts)

+	return args.Bool(0), args.Get(1).(*store.KVPair), args.Error(2)

+}

+

+// AtomicDelete mock

+func (s *Mock) AtomicDelete(key string, previous *store.KVPair) (bool, error) {

+	args := s.Mock.Called(key, previous)

+	return args.Bool(0), args.Error(1)

+}

+

+// Lock mock implementation of Locker

+type Lock struct {

+	mock.Mock

+}

+

+// Lock mock

+func (l *Lock) Lock() (<-chan struct{}, error) {

+	args := l.Mock.Called()

+	return args.Get(0).(<-chan struct{}), args.Error(1)

+}

+

+// Unlock mock

+func (l *Lock) Unlock() error {

+	args := l.Mock.Called()

+	return args.Error(0)

+}

+

+// Close mock

+func (s *Mock) Close() {

+	return

+}

new file mode 100644

@@ -0,0 +1,22 @@

+# Compiled Object files, Static and Dynamic libs (Shared Objects)

+*.o

+*.a

+*.so

+

+# Folders

+_obj

+_test

+

+# Architecture specific extensions/prefixes

+*.[568vq]

+[568vq].out

+

+*.cgo1.go

+*.cgo2.c

+_cgo_defun.c

+_cgo_gotypes.go

+_cgo_export.*

+

+_testmain.go

+

+*.exe

new file mode 100644

@@ -0,0 +1,23 @@

+objx - by Mat Ryer and Tyler Bunnell

+

+The MIT License (MIT)

+

+Copyright (c) 2014 Stretchr, Inc.

+

+Permission is hereby granted, free of charge, to any person obtaining a copy

+of this software and associated documentation files (the "Software"), to deal

+in the Software without restriction, including without limitation the rights

+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+copies of the Software, and to permit persons to whom the Software is

+furnished to do so, subject to the following conditions:

+

+The above copyright notice and this permission notice shall be included in all

+copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+SOFTWARE.

new file mode 100644

@@ -0,0 +1,3 @@

+# objx

+

+  * Jump into the [API Documentation](http://godoc.org/github.com/stretchr/objx)

new file mode 100644

@@ -0,0 +1,179 @@

+package objx

+

+import (

+	"fmt"

+	"regexp"

+	"strconv"

+	"strings"

+)

+

+// arrayAccesRegexString is the regex used to extract the array number

+// from the access path

+const arrayAccesRegexString = `^(.+)\[([0-9]+)\]$`

+

+// arrayAccesRegex is the compiled arrayAccesRegexString

+var arrayAccesRegex = regexp.MustCompile(arrayAccesRegexString)

+

+// Get gets the value using the specified selector and

+// returns it inside a new Obj object.

+//

+// If it cannot find the value, Get will return a nil

+// value inside an instance of Obj.

+//

+// Get can only operate directly on map[string]interface{} and []interface.

+//

+// Example

+//

+// To access the title of the third chapter of the second book, do:

+//

+//    o.Get("books[1].chapters[2].title")

+func (m Map) Get(selector string) *Value {

+	rawObj := access(m, selector, nil, false, false)

+	return &Value{data: rawObj}

+}

+

+// Set sets the value using the specified selector and

+// returns the object on which Set was called.

+//

+// Set can only operate directly on map[string]interface{} and []interface

+//

+// Example

+//

+// To set the title of the third chapter of the second book, do:

+//

+//    o.Set("books[1].chapters[2].title","Time to Go")

+func (m Map) Set(selector string, value interface{}) Map {

+	access(m, selector, value, true, false)

+	return m

+}

+

+// access accesses the object using the selector and performs the

+// appropriate action.

+func access(current, selector, value interface{}, isSet, panics bool) interface{} {

+

+	switch selector.(type) {

+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:

+

+		if array, ok := current.([]interface{}); ok {

+			index := intFromInterface(selector)

+

+			if index >= len(array) {

+				if panics {

+					panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))

+				}

+				return nil

+			}

+

+			return array[index]

+		}

+

+		return nil

+

+	case string:

+

+		selStr := selector.(string)

+		selSegs := strings.SplitN(selStr, PathSeparator, 2)

+		thisSel := selSegs[0]

+		index := -1

+		var err error

+

+		// https://github.com/stretchr/objx/issues/12

+		if strings.Contains(thisSel, "[") {

+

+			arrayMatches := arrayAccesRegex.FindStringSubmatch(thisSel)

+

+			if len(arrayMatches) > 0 {

+

+				// Get the key into the map

+				thisSel = arrayMatches[1]

+

+				// Get the index into the array at the key

+				index, err = strconv.Atoi(arrayMatches[2])

+

+				if err != nil {

+					// This should never happen. If it does, something has gone

+					// seriously wrong. Panic.

+					panic("objx: Array index is not an integer.  Must use array[int].")

+				}

+

+			}

+		}

+

+		if curMap, ok := current.(Map); ok {

+			current = map[string]interface{}(curMap)

+		}

+

+		// get the object in question

+		switch current.(type) {

+		case map[string]interface{}:

+			curMSI := current.(map[string]interface{})

+			if len(selSegs) <= 1 && isSet {

+				curMSI[thisSel] = value

+				return nil

+			} else {

+				current = curMSI[thisSel]

+			}

+		default:

+			current = nil

+		}

+

+		if current == nil && panics {

+			panic(fmt.Sprintf("objx: '%v' invalid on object.", selector))

+		}

+

+		// do we need to access the item of an array?

+		if index > -1 {

+			if array, ok := current.([]interface{}); ok {

+				if index < len(array) {

+					current = array[index]

+				} else {

+					if panics {

+						panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))

+					}

+					current = nil

+				}

+			}

+		}

+

+		if len(selSegs) > 1 {

+			current = access(current, selSegs[1], value, isSet, panics)

+		}

+

+	}

+

+	return current

+

+}

+

+// intFromInterface converts an interface object to the largest

+// representation of an unsigned integer using a type switch and

+// assertions

+func intFromInterface(selector interface{}) int {

+	var value int

+	switch selector.(type) {

+	case int:

+		value = selector.(int)

+	case int8:

+		value = int(selector.(int8))

+	case int16:

+		value = int(selector.(int16))

+	case int32:

+		value = int(selector.(int32))

+	case int64:

+		value = int(selector.(int64))

+	case uint:

+		value = int(selector.(uint))

+	case uint8:

+		value = int(selector.(uint8))

+	case uint16:

+		value = int(selector.(uint16))

+	case uint32:

+		value = int(selector.(uint32))

+	case uint64:

+		value = int(selector.(uint64))

+	default:

+		panic("objx: array access argument is not an integer type (this should never happen)")

+	}

+

+	return value

+}

new file mode 100644

@@ -0,0 +1,13 @@

+package objx

+

+const (

+	// PathSeparator is the character used to separate the elements

+	// of the keypath.

+	//

+	// For example, `location.address.city`

+	PathSeparator string = "."

+

+	// SignatureSeparator is the character that is used to

+	// separate the Base64 string from the security signature.

+	SignatureSeparator = "_"

+)

new file mode 100644

@@ -0,0 +1,117 @@

+package objx

+

+import (

+	"bytes"

+	"encoding/base64"

+	"encoding/json"

+	"errors"

+	"fmt"

+	"net/url"

+)

+

+// JSON converts the contained object to a JSON string

+// representation

+func (m Map) JSON() (string, error) {

+

+	result, err := json.Marshal(m)

+

+	if err != nil {

+		err = errors.New("objx: JSON encode failed with: " + err.Error())

+	}

+

+	return string(result), err

+

+}

+

+// MustJSON converts the contained object to a JSON string

+// representation and panics if there is an error

+func (m Map) MustJSON() string {

+	result, err := m.JSON()

+	if err != nil {

+		panic(err.Error())

+	}

+	return result

+}

+

+// Base64 converts the contained object to a Base64 string

+// representation of the JSON string representation

+func (m Map) Base64() (string, error) {

+

+	var buf bytes.Buffer

+

+	jsonData, err := m.JSON()

+	if err != nil {

+		return "", err

+	}

+

+	encoder := base64.NewEncoder(base64.StdEncoding, &buf)

+	encoder.Write([]byte(jsonData))

+	encoder.Close()

+

+	return buf.String(), nil

+

+}

+

+// MustBase64 converts the contained object to a Base64 string

+// representation of the JSON string representation and panics

+// if there is an error

+func (m Map) MustBase64() string {

+	result, err := m.Base64()

+	if err != nil {

+		panic(err.Error())

+	}

+	return result

+}

+

+// SignedBase64 converts the contained object to a Base64 string

+// representation of the JSON string representation and signs it

+// using the provided key.

+func (m Map) SignedBase64(key string) (string, error) {

+

+	base64, err := m.Base64()

+	if err != nil {

+		return "", err

+	}

+

+	sig := HashWithKey(base64, key)

+

+	return base64 + SignatureSeparator + sig, nil

+

+}

+

+// MustSignedBase64 converts the contained object to a Base64 string

+// representation of the JSON string representation and signs it

+// using the provided key and panics if there is an error

+func (m Map) MustSignedBase64(key string) string {

+	result, err := m.SignedBase64(key)

+	if err != nil {

+		panic(err.Error())

+	}

+	return result

+}

+

+/*

+	URL Query

+	------------------------------------------------

+*/

+

+// URLValues creates a url.Values object from an Obj. This

+// function requires that the wrapped object be a map[string]interface{}

+func (m Map) URLValues() url.Values {

+

+	vals := make(url.Values)

+

+	for k, v := range m {

+		//TODO: can this be done without sprintf?

+		vals.Set(k, fmt.Sprintf("%v", v))

+	}

+

+	return vals

+}

+

+// URLQuery gets an encoded URL query representing the given

+// Obj. This function requires that the wrapped object be a

+// map[string]interface{}

+func (m Map) URLQuery() (string, error) {

+	return m.URLValues().Encode(), nil

+}

new file mode 100644

@@ -0,0 +1,72 @@

+// objx - Go package for dealing with maps, slices, JSON and other data.

+//

+// Overview

+//

+// Objx provides the `objx.Map` type, which is a `map[string]interface{}` that exposes

+// a powerful `Get` method (among others) that allows you to easily and quickly get

+// access to data within the map, without having to worry too much about type assertions,

+// missing data, default values etc.

+//

+// Pattern

+//

+// Objx uses a preditable pattern to make access data from within `map[string]interface{}'s

+// easy.

+//

+// Call one of the `objx.` functions to create your `objx.Map` to get going:

+//

+//     m, err := objx.FromJSON(json)

+//

+// NOTE: Any methods or functions with the `Must` prefix will panic if something goes wrong,

+// the rest will be optimistic and try to figure things out without panicking.

+//

+// Use `Get` to access the value you're interested in.  You can use dot and array

+// notation too:

+//

+//     m.Get("places[0].latlng")

+//

+// Once you have saught the `Value` you're interested in, you can use the `Is*` methods

+// to determine its type.

+//

+//     if m.Get("code").IsStr() { /* ... */ }

+//

+// Or you can just assume the type, and use one of the strong type methods to

+// extract the real value:

+//

+//     m.Get("code").Int()

+//

+// If there's no value there (or if it's the wrong type) then a default value

+// will be returned, or you can be explicit about the default value.

+//

+//     Get("code").Int(-1)

+//

+// If you're dealing with a slice of data as a value, Objx provides many useful

+// methods for iterating, manipulating and selecting that data.  You can find out more

+// by exploring the index below.

+//

+// Reading data

+//

+// A simple example of how to use Objx:

+//

+//     // use MustFromJSON to make an objx.Map from some JSON

+//     m := objx.MustFromJSON(`{"name": "Mat", "age": 30}`)

+//

+//     // get the details

+//     name := m.Get("name").Str()

+//     age := m.Get("age").Int()

+//

+//     // get their nickname (or use their name if they

+//     // don't have one)

+//     nickname := m.Get("nickname").Str(name)

+//

+// Ranging

+//

+// Since `objx.Map` is a `map[string]interface{}` you can treat it as such.  For

+// example, to `range` the data, do what you would expect:

+//

+//     m := objx.MustFromJSON(json)

+//     for key, value := range m {

+//

+//       /* ... do your magic ... */

+//

+//     }

+package objx

new file mode 100644

@@ -0,0 +1,222 @@

+package objx

+

+import (

+	"encoding/base64"

+	"encoding/json"

+	"errors"

+	"io/ioutil"

+	"net/url"

+	"strings"

+)

+

+// MSIConvertable is an interface that defines methods for converting your

+// custom types to a map[string]interface{} representation.

+type MSIConvertable interface {

+	// MSI gets a map[string]interface{} (msi) representing the

+	// object.

+	MSI() map[string]interface{}

+}

+

+// Map provides extended functionality for working with

+// untyped data, in particular map[string]interface (msi).

+type Map map[string]interface{}

+

+// Value returns the internal value instance

+func (m Map) Value() *Value {

+	return &Value{data: m}

+}

+

+// Nil represents a nil Map.

+var Nil Map = New(nil)

+

+// New creates a new Map containing the map[string]interface{} in the data argument.

+// If the data argument is not a map[string]interface, New attempts to call the

+// MSI() method on the MSIConvertable interface to create one.

+func New(data interface{}) Map {

+	if _, ok := data.(map[string]interface{}); !ok {

+		if converter, ok := data.(MSIConvertable); ok {

+			data = converter.MSI()

+		} else {

+			return nil

+		}