@@ -248,6 +248,15 @@ func (cli *DaemonCli) start(opts daemonOptions) (err error) {

 		return fmt.Errorf("Error starting daemon: %v", err)

 	}

+	if cli.Config.MetricsAddress != "" {

+		if !d.HasExperimental() {

+			return fmt.Errorf("metrics-addr is only supported when experimental is enabled")

+		}

+		if err := startMetricsServer(cli.Config.MetricsAddress); err != nil {

+			return err

+		}

+	}

+

 	name, _ := os.Hostname()

 	c, err := cluster.New(cluster.Config{

new file mode 100644

@@ -0,0 +1,27 @@

+package main

+

+import (

+	"net"

+	"net/http"

+

+	"github.com/Sirupsen/logrus"

+	metrics "github.com/docker/go-metrics"

+)

+

+func startMetricsServer(addr string) error {

+	if err := allocateDaemonPort(addr); err != nil {

+		return err

+	}

+	l, err := net.Listen("tcp", addr)

+	if err != nil {

+		return err

+	}

+	mux := http.NewServeMux()

+	mux.Handle("/metrics", metrics.Handler())

+	go func() {

+		if err := http.Serve(l, mux); err != nil {

+			logrus.Errorf("serve metrics api: %s", err)

+		}

+	}()

+	return nil

+}

@@ -1,9 +1,14 @@

 package daemon

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

+import (

+	"time"

+

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

+)

 // ContainerChanges returns a list of container fs changes

 func (daemon *Daemon) ContainerChanges(name string) ([]archive.Change, error) {

+	start := time.Now()

 	container, err := daemon.GetContainer(name)

 	if err != nil {

 		return nil, err

@@ -11,5 +16,10 @@ func (daemon *Daemon) ContainerChanges(name string) ([]archive.Change, error) {

 	container.Lock()

 	defer container.Unlock()

-	return container.RWLayer.Changes()

+	c, err := container.RWLayer.Changes()

+	if err != nil {

+		return nil, err

+	}

+	containerActions.WithValues("changes").UpdateSince(start)

+	return c, nil

 }

@@ -120,6 +120,7 @@ func merge(userConf, imageConf *containertypes.Config) error {

 // Commit creates a new filesystem image from the current state of a container.

 // The image can optionally be tagged into a repository.

 func (daemon *Daemon) Commit(name string, c *backend.ContainerCommitConfig) (string, error) {

+	start := time.Now()

 	container, err := daemon.GetContainer(name)

 	if err != nil {

 		return "", err

@@ -244,6 +245,7 @@ func (daemon *Daemon) Commit(name string, c *backend.ContainerCommitConfig) (str

 		"comment": c.Comment,

 	}

 	daemon.LogContainerEventWithAttributes(container, "commit", attributes)

+	containerActions.WithValues("commit").UpdateSince(start)

 	return id.String(), nil

 }

@@ -146,6 +146,7 @@ type CommonConfig struct {

 	// given to the /swarm/init endpoint and no advertise address is

 	// specified.

 	SwarmDefaultAdvertiseAddr string `json:"swarm-default-advertise-addr"`

+	MetricsAddress            string `json:"metrics-addr"`

 	LogConfig

 	bridgeConfig // bridgeConfig holds bridge network specific configuration.

@@ -191,6 +192,8 @@ func (config *Config) InstallCommonFlags(flags *pflag.FlagSet) {

 	flags.StringVar(&config.SwarmDefaultAdvertiseAddr, "swarm-default-advertise-addr", "", "Set default address or interface for swarm advertised address")

 	flags.BoolVar(&config.Experimental, "experimental", false, "Enable experimental features")

+	flags.StringVar(&config.MetricsAddress, "metrics-addr", "", "Set default address and port to serve the metrics api on")

+

 	config.MaxConcurrentDownloads = &maxConcurrentDownloads

 	config.MaxConcurrentUploads = &maxConcurrentUploads

 }

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

 	"path"

 	"runtime"

 	"strings"

+	"time"

 	"github.com/Sirupsen/logrus"

 	derr "github.com/docker/docker/api/errors"

@@ -284,8 +285,11 @@ func (daemon *Daemon) updateEndpointNetworkSettings(container *container.Contain

 // UpdateNetwork is used to update the container's network (e.g. when linked containers

 // get removed/unlinked).

 func (daemon *Daemon) updateNetwork(container *container.Container) error {

-	ctrl := daemon.netController

-	sid := container.NetworkSettings.SandboxID

+	var (

+		start = time.Now()

+		ctrl  = daemon.netController

+		sid   = container.NetworkSettings.SandboxID

+	)

 	sb, err := ctrl.SandboxByID(sid)

 	if err != nil {

@@ -319,6 +323,8 @@ func (daemon *Daemon) updateNetwork(container *container.Container) error {

 		return fmt.Errorf("Update network failed: Failure in refresh sandbox %s: %v", sid, err)

 	}

+	networkActions.WithValues("update").UpdateSince(start)

+

 	return nil

 }

@@ -452,6 +458,7 @@ func (daemon *Daemon) updateContainerNetworkSettings(container *container.Contai

 }

 func (daemon *Daemon) allocateNetwork(container *container.Container) error {

+	start := time.Now()

 	controller := daemon.netController

 	if daemon.netController == nil {

@@ -503,7 +510,11 @@ func (daemon *Daemon) allocateNetwork(container *container.Container) error {

 		}

 	}

-	return container.WriteHostConfig()

+	if err := container.WriteHostConfig(); err != nil {

+		return err

+	}

+	networkActions.WithValues("allocate").UpdateSince(start)

+	return nil

 }

 func (daemon *Daemon) getNetworkSandbox(container *container.Container) libnetwork.Sandbox {

@@ -613,16 +624,15 @@ func (daemon *Daemon) updateNetworkConfig(container *container.Container, n libn

 }

 func (daemon *Daemon) connectToNetwork(container *container.Container, idOrName string, endpointConfig *networktypes.EndpointSettings, updateSettings bool) (err error) {

+	start := time.Now()

 	if container.HostConfig.NetworkMode.IsContainer() {

 		return runconfig.ErrConflictSharedNetwork

 	}

-

 	if containertypes.NetworkMode(idOrName).IsBridge() &&

 		daemon.configStore.DisableBridge {

 		container.Config.NetworkDisabled = true

 		return nil

 	}

-

 	if endpointConfig == nil {

 		endpointConfig = &networktypes.EndpointSettings{}

 	}

@@ -714,6 +724,7 @@ func (daemon *Daemon) connectToNetwork(container *container.Container, idOrName

 	container.NetworkSettings.Ports = getPortMapInfo(sb)

 	daemon.LogNetworkEventWithAttributes(n, "connect", map[string]string{"container": container.ID})

+	networkActions.WithValues("connect").UpdateSince(start)

 	return nil

 }

@@ -835,6 +846,7 @@ func (daemon *Daemon) getNetworkedContainer(containerID, connectedContainerID st

 }

 func (daemon *Daemon) releaseNetwork(container *container.Container) {

+	start := time.Now()

 	if daemon.netController == nil {

 		return

 	}

@@ -885,6 +897,7 @@ func (daemon *Daemon) releaseNetwork(container *container.Container) {

 		}

 		daemon.LogNetworkEventWithAttributes(nw, "disconnect", attributes)

 	}

+	networkActions.WithValues("release").UpdateSince(start)

 }

 func errRemovalContainer(containerID string) error {

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

 	"fmt"

 	"net"

 	"strings"

+	"time"

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/errors"

@@ -31,6 +32,7 @@ func (daemon *Daemon) ContainerCreate(params types.ContainerCreateConfig, valida

 }

 func (daemon *Daemon) containerCreate(params types.ContainerCreateConfig, managed bool, validateHostname bool) (types.ContainerCreateResponse, error) {

+	start := time.Now()

 	if params.Config == nil {

 		return types.ContainerCreateResponse{}, fmt.Errorf("Config cannot be empty in order to create a container")

 	}

@@ -57,7 +59,7 @@ func (daemon *Daemon) containerCreate(params types.ContainerCreateConfig, manage

 	if err != nil {

 		return types.ContainerCreateResponse{Warnings: warnings}, daemon.imageNotExistToErrcode(err)

 	}

-

+	containerActions.WithValues("create").UpdateSince(start)

 	return types.ContainerCreateResponse{ID: container.ID, Warnings: warnings}, nil

 }

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

 	"github.com/docker/docker/container"

 	"github.com/docker/docker/daemon/events"

 	"github.com/docker/docker/daemon/exec"

+	"github.com/docker/docker/dockerversion"

 	"github.com/docker/libnetwork/cluster"

 	// register graph drivers

 	_ "github.com/docker/docker/daemon/graphdriver/register"

@@ -684,12 +685,25 @@ func NewDaemon(config *Config, registryService registry.Service, containerdRemot

 		return nil, err

 	}

+	// FIXME: this method never returns an error

+	info, _ := d.SystemInfo()

+

+	engineVersion.WithValues(

+		dockerversion.Version,

+		dockerversion.GitCommit,

+		info.Architecture,

+		info.Driver,

+		info.KernelVersion,

+		info.OperatingSystem,

+	).Set(1)

+	engineCpus.Set(float64(info.NCPU))

+	engineMemory.Set(float64(info.MemTotal))

+

 	return d, nil

 }

 func (daemon *Daemon) shutdownContainer(c *container.Container) error {

 	stopTimeout := c.StopTimeout()

-

 	// TODO(windows): Handle docker restart with paused containers

 	if c.IsPaused() {

 		// To terminate a process in freezer cgroup, we should send

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

 	"os"

 	"path"

 	"strings"

+	"time"

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/errors"

@@ -19,6 +20,7 @@ import (

 // fails. If the remove succeeds, the container name is released, and

 // network links are removed.

 func (daemon *Daemon) ContainerRm(name string, config *types.ContainerRmConfig) error {

+	start := time.Now()

 	container, err := daemon.GetContainer(name)

 	if err != nil {

 		return err

@@ -40,7 +42,10 @@ func (daemon *Daemon) ContainerRm(name string, config *types.ContainerRmConfig)

 		return daemon.rmLink(container, name)

 	}

-	return daemon.cleanupContainer(container, config.ForceRemove, config.RemoveVolume)

+	err = daemon.cleanupContainer(container, config.ForceRemove, config.RemoveVolume)

+	containerActions.WithValues("delete").UpdateSince(start)

+

+	return err

 }

 func (daemon *Daemon) rmLink(container *container.Container, name string) error {

@@ -33,6 +33,7 @@ func New() *Events {

 // of interface{}, so you need type assertion), and a function to call

 // to stop the stream of events.

 func (e *Events) Subscribe() ([]eventtypes.Message, chan interface{}, func()) {

+	eventSubscribers.Inc()

 	e.mu.Lock()

 	current := make([]eventtypes.Message, len(e.events))

 	copy(current, e.events)

@@ -49,6 +50,7 @@ func (e *Events) Subscribe() ([]eventtypes.Message, chan interface{}, func()) {

 // last events, a channel in which you can expect new events (in form

 // of interface{}, so you need type assertion).

 func (e *Events) SubscribeTopic(since, until time.Time, ef *Filter) ([]eventtypes.Message, chan interface{}) {

+	eventSubscribers.Inc()

 	e.mu.Lock()

 	var topic func(m interface{}) bool

@@ -72,12 +74,14 @@ func (e *Events) SubscribeTopic(since, until time.Time, ef *Filter) ([]eventtype

 // Evict evicts listener from pubsub

 func (e *Events) Evict(l chan interface{}) {

+	eventSubscribers.Dec()

 	e.pub.Evict(l)

 }

 // Log broadcasts event to listeners. Each listener has 100 millisecond for

 // receiving event or it will be skipped.

 func (e *Events) Log(action, eventType string, actor eventtypes.Actor) {

+	eventsCounter.Inc()

 	now := time.Now().UTC()

 	jm := eventtypes.Message{

 		Action:   action,

new file mode 100644

@@ -0,0 +1,15 @@

+package events

+

+import "github.com/docker/go-metrics"

+

+var (

+	eventsCounter    metrics.Counter

+	eventSubscribers metrics.Gauge

+)

+

+func init() {

+	ns := metrics.NewNamespace("engine", "daemon", nil)

+	eventsCounter = ns.NewCounter("events", "The number of events logged")

+	eventSubscribers = ns.NewGauge("events_subscribers", "The number of current subscribers to events", metrics.Total)

+	metrics.Register(ns)

+}

@@ -60,6 +60,7 @@ type cmdProbe struct {

 // exec the healthcheck command in the container.

 // Returns the exit code and probe output (if any)

 func (p *cmdProbe) run(ctx context.Context, d *Daemon, container *container.Container) (*types.HealthcheckResult, error) {

+

 	cmdSlice := strslice.StrSlice(container.Config.Healthcheck.Test)[1:]

 	if p.shell {

 		if runtime.GOOS != "windows" {

@@ -157,8 +158,10 @@ func monitor(d *Daemon, c *container.Container, stop chan struct{}, probe probe)

 			ctx, cancelProbe := context.WithTimeout(context.Background(), probeTimeout)

 			results := make(chan *types.HealthcheckResult)

 			go func() {

+				healthChecksCounter.Inc()

 				result, err := probe.run(ctx, d, c)

 				if err != nil {

+					healthChecksFailedCounter.Inc()

 					logrus.Warnf("Health check for container %s error: %v", c.ID, err)

 					results <- &types.HealthcheckResult{

 						ExitCode: -1,

@@ -3,6 +3,7 @@ package daemon

 import (

 	"fmt"

 	"strings"

+	"time"

 	"github.com/docker/docker/api/errors"

 	"github.com/docker/docker/api/types"

@@ -61,6 +62,7 @@ const (

 // package. This would require that we no longer need the daemon to determine

 // whether images are being used by a stopped or running container.

 func (daemon *Daemon) ImageDelete(imageRef string, force, prune bool) ([]types.ImageDelete, error) {

+	start := time.Now()

 	records := []types.ImageDelete{}

 	imgID, err := daemon.GetImageID(imageRef)

@@ -168,7 +170,13 @@ func (daemon *Daemon) ImageDelete(imageRef string, force, prune bool) ([]types.I

 		}

 	}

-	return records, daemon.imageDeleteHelper(imgID, &records, force, prune, removedRepositoryRef)

+	if err := daemon.imageDeleteHelper(imgID, &records, force, prune, removedRepositoryRef); err != nil {

+		return nil, err

+	}

+

+	imageActions.WithValues("delete").UpdateSince(start)

+

+	return records, nil

 }

 // isSingleReference returns true when all references are from one repository

@@ -2,6 +2,7 @@ package daemon

 import (

 	"fmt"

+	"time"

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/layer"

@@ -11,6 +12,7 @@ import (

 // ImageHistory returns a slice of ImageHistory structures for the specified image

 // name by walking the image lineage.

 func (daemon *Daemon) ImageHistory(name string) ([]*types.ImageHistory, error) {

+	start := time.Now()

 	img, err := daemon.GetImage(name)

 	if err != nil {

 		return nil, err

@@ -77,6 +79,6 @@ func (daemon *Daemon) ImageHistory(name string) ([]*types.ImageHistory, error) {

 			break

 		}

 	}

-

+	imageActions.WithValues("history").UpdateSince(start)

 	return history, nil

 }

@@ -165,7 +165,9 @@ func (daemon *Daemon) filterByNameIDMatches(ctx *listContext) []*container.Conta

 // reduceContainers parses the user's filtering options and generates the list of containers to return based on a reducer.

 func (daemon *Daemon) reduceContainers(config *types.ContainerListOptions, reducer containerReducer) ([]*types.Container, error) {

-	containers := []*types.Container{}

+	var (

+		containers = []*types.Container{}

+	)

 	ctx, err := daemon.foldFilter(config)

 	if err != nil {

@@ -190,6 +192,7 @@ func (daemon *Daemon) reduceContainers(config *types.ContainerListOptions, reduc

 			ctx.idx++

 		}

 	}

+

 	return containers, nil

 }

new file mode 100644

@@ -0,0 +1,42 @@

+package daemon

+

+import "github.com/docker/go-metrics"

+

+var (

+	containerActions          metrics.LabeledTimer

+	imageActions              metrics.LabeledTimer

+	networkActions            metrics.LabeledTimer

+	engineVersion             metrics.LabeledGauge

+	engineCpus                metrics.Gauge

+	engineMemory              metrics.Gauge

+	healthChecksCounter       metrics.Counter

+	healthChecksFailedCounter metrics.Counter

+)

+

+func init() {

+	ns := metrics.NewNamespace("engine", "daemon", nil)

+	containerActions = ns.NewLabeledTimer("container_actions", "The number of seconds it takes to process each container action", "action")

+	for _, a := range []string{

+		"start",

+		"changes",

+		"commit",

+		"create",

+		"delete",

+	} {

+		containerActions.WithValues(a).Update(0)

+	}

+	networkActions = ns.NewLabeledTimer("network_actions", "The number of seconds it takes to process each network action", "action")

+	engineVersion = ns.NewLabeledGauge("engine", "The version and commit information for the engine process", metrics.Unit("info"),

+		"version",

+		"commit",

+		"architecture",

+		"graph_driver", "kernel",

+		"os",

+	)

+	engineCpus = ns.NewGauge("engine_cpus", "The number of cpus that the host system of the engine has", metrics.Unit("cpus"))

+	engineMemory = ns.NewGauge("engine_memory", "The number of bytes of memory that the host system of the engine has", metrics.Bytes)

+	healthChecksCounter = ns.NewCounter("health_checks", "The total number of health checks")

+	healthChecksFailedCounter = ns.NewCounter("health_checks_failed", "The total number of failed health checks")

+	imageActions = ns.NewLabeledTimer("image_actions", "The number of seconds it takes to process each image action", "action")

+	metrics.Register(ns)

+}

@@ -292,6 +292,7 @@ func (daemon *Daemon) createNetwork(create types.NetworkCreateRequest, id string

 	}

 	daemon.LogNetworkEvent(n, "create")

+

 	return &types.NetworkCreateResponse{

 		ID:      n.ID(),

 		Warning: warning,

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

 	"runtime"

 	"strings"

 	"syscall"

+	"time"

 	"google.golang.org/grpc"

@@ -90,6 +91,7 @@ func (daemon *Daemon) Start(container *container.Container) error {

 // between containers. The container is left waiting for a signal to

 // begin running.

 func (daemon *Daemon) containerStart(container *container.Container, checkpoint string, resetRestartManager bool) (err error) {

+	start := time.Now()

 	container.Lock()

 	defer container.Unlock()

@@ -177,6 +179,8 @@ func (daemon *Daemon) containerStart(container *container.Container, checkpoint

 		return fmt.Errorf("%s", errDesc)

 	}

+	containerActions.WithValues("start").UpdateSince(start)

+

 	return nil

 }

@@ -175,4 +175,7 @@ clone git github.com/spf13/pflag dabebe21bf790f782ea4c7bbd2efc430de182afd

 clone git github.com/inconshreveable/mousetrap 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75

 clone git github.com/flynn-archive/go-shlex 3f9db97f856818214da2e1057f8ad84803971cff

+# metrics

+clone git github.com/docker/go-metrics 86138d05f285fd9737a99bee2d9be30866b59d72

+

 clean

@@ -379,7 +379,7 @@ func (s *DockerExternalGraphdriverSuite) testExternalGraphDriver(name string, ex

 	c.Assert(s.ec[ext].removals >= 1, check.Equals, true)

 	c.Assert(s.ec[ext].gets >= 1, check.Equals, true)

 	c.Assert(s.ec[ext].puts >= 1, check.Equals, true)

-	c.Assert(s.ec[ext].stats, check.Equals, 3)

+	c.Assert(s.ec[ext].stats, check.Equals, 5)

 	c.Assert(s.ec[ext].cleanups, check.Equals, 2)

 	c.Assert(s.ec[ext].applydiff >= 1, check.Equals, true)

 	c.Assert(s.ec[ext].changes, check.Equals, 1)

new file mode 100644

@@ -0,0 +1,55 @@

+# Contributing

+

+## Sign your work

+

+The sign-off is a simple line at the end of the explanation for the patch. Your

+signature certifies that you wrote the patch or otherwise have the right to pass

+it on as an open-source patch. The rules are pretty simple: if you can certify

+the below (from [developercertificate.org](http://developercertificate.org/)):

+

+```

+Developer Certificate of Origin

+Version 1.1

+

+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.

+660 York Street, Suite 102,

+San Francisco, CA 94110 USA

+

+Everyone is permitted to copy and distribute verbatim copies of this

+license document, but changing it is not allowed.

+

+Developer's Certificate of Origin 1.1

+

+By making a contribution to this project, I certify that:

+

+(a) The contribution was created in whole or in part by me and I

+    have the right to submit it under the open source license

+    indicated in the file; or

+

+(b) The contribution is based upon previous work that, to the best

+    of my knowledge, is covered under an appropriate open source

+    license and I have the right under that license to submit that

+    work with modifications, whether created in whole or in part

+    by me, under the same open source license (unless I am

+    permitted to submit under a different license), as indicated

+    in the file; or

+

+(c) The contribution was provided directly to me by some other

+    person who certified (a), (b) or (c) and I have not modified

+    it.

+

+(d) I understand and agree that this project and the contribution

+    are public and that a record of the contribution (including all

+    personal information I submit with it, including my sign-off) is

+    maintained indefinitely and may be redistributed consistent with

+    this project or the open source license(s) involved.

+```

+

+Then you just add a line to every git commit message:

+

+    Signed-off-by: Joe Smith <joe.smith@email.com>

+

+Use your real name (sorry, no pseudonyms or anonymous contributions.)

+

+If you set your `user.name` and `user.email` git configs, you can sign your

+commit automatically with `git commit -s`.

new file mode 100644

@@ -0,0 +1,191 @@

+

+                                 Apache License

+                           Version 2.0, January 2004

+                        https://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

+      direction or management of such entity, whether by contract or

+      otherwise, or (ii) ownership of fifty percent (50%) or more of the

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct

+      or contributory patent infringement, then any patent licenses

+      granted to You under this License for that Work shall terminate

+      as of the date such litigation is filed.

+

+   4. Redistribution. You may reproduce and distribute copies of the

+      Work or Derivative Works thereof in any medium, with or without

+      modifications, and in Source or Object form, provided that You

+      meet the following conditions:

+

+      (a) You must give any other recipients of the Work or

+          Derivative Works a copy of this License; and

+

+      (b) You must cause any modified files to carry prominent notices

+          stating that You changed the files; and

+

+      (c) You must retain, in the Source form of any Derivative Works

+          that You distribute, all copyright, patent, trademark, and

+          attribution notices from the Source form of the Work,

+          excluding those notices that do not pertain to any part of

+          the Derivative Works; and

+

+      (d) If the Work includes a "NOTICE" text file as part of its

+          distribution, then any Derivative Works that You distribute must

+          include a readable copy of the attribution notices contained

+          within such NOTICE file, excluding those notices that do not

+          pertain to any part of the Derivative Works, in at least one

+          of the following places: within a NOTICE text file distributed

+          as part of the Derivative Works; within the Source form or

+          documentation, if provided along with the Derivative Works; or,

+          within a display generated by the Derivative Works, if and

+          wherever such third-party notices normally appear. The contents

+          of the NOTICE file are for informational purposes only and

+          do not modify the License. You may add Your own attribution

+          notices within Derivative Works that You distribute, alongside

+          or as an addendum to the NOTICE text from the Work, provided

+          that such additional attribution notices cannot be construed

+          as modifying the License.

+

+      You may add Your own copyright statement to Your modifications and

+      may provide additional or different license terms and conditions

+      for use, reproduction, or distribution of Your modifications, or

+      for any such Derivative Works as a whole, provided Your use,

+      reproduction, and distribution of the Work otherwise complies with

+      the conditions stated in this License.

+

+   5. Submission of Contributions. Unless You explicitly state otherwise,

+      any Contribution intentionally submitted for inclusion in the Work

+      by You to the Licensor shall be under the terms and conditions of

+      this License, without any additional terms or conditions.

+      Notwithstanding the above, nothing herein shall supersede or modify

+      the terms of any separate license agreement you may have executed

+      with Licensor regarding such Contributions.

+

+   6. Trademarks. This License does not grant permission to use the trade

+      names, trademarks, service marks, or product names of the Licensor,

+      except as required for reasonable and customary use in describing the

+      origin of the Work and reproducing the content of the NOTICE file.

+

+   7. Disclaimer of Warranty. Unless required by applicable law or

+      agreed to in writing, Licensor provides the Work (and each

+      Contributor provides its Contributions) on an "AS IS" BASIS,

+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

+      implied, including, without limitation, any warranties or conditions

+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

+      PARTICULAR PURPOSE. You are solely responsible for determining the

+      appropriateness of using or redistributing the Work and assume any

+      risks associated with Your exercise of permissions under this License.

+

+   8. Limitation of Liability. In no event and under no legal theory,

+      whether in tort (including negligence), contract, or otherwise,

+      unless required by applicable law (such as deliberate and grossly

+      negligent acts) or agreed to in writing, shall any Contributor be

+      liable to You for damages, including any direct, indirect, special,

+      incidental, or consequential damages of any character arising as a

+      result of this License or out of the use or inability to use the

+      Work (including but not limited to damages for loss of goodwill,

+      work stoppage, computer failure or malfunction, or any and all

+      other commercial damages or losses), even if such Contributor

+      has been advised of the possibility of such damages.

+

+   9. Accepting Warranty or Additional Liability. While redistributing

+      the Work or Derivative Works thereof, You may choose to offer,

+      and charge a fee for, acceptance of support, warranty, indemnity,

+      or other liability obligations and/or rights consistent with this

+      License. However, in accepting such obligations, You may act only

+      on Your own behalf and on Your sole responsibility, not on behalf

+      of any other Contributor, and only if You agree to indemnify,

+      defend, and hold each Contributor harmless for any liability

+      incurred by, or claims asserted against, such Contributor by reason

+      of your accepting any such warranty or additional liability.

+

+   END OF TERMS AND CONDITIONS

+

+   Copyright 2013-2016 Docker, Inc.

+

+   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

+

+       https://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.

new file mode 100644

@@ -0,0 +1,425 @@

+Attribution-ShareAlike 4.0 International

+

+=======================================================================

+

+Creative Commons Corporation ("Creative Commons") is not a law firm and

+does not provide legal services or legal advice. Distribution of

+Creative Commons public licenses does not create a lawyer-client or

+other relationship. Creative Commons makes its licenses and related

+information available on an "as-is" basis. Creative Commons gives no

+warranties regarding its licenses, any material licensed under their

+terms and conditions, or any related information. Creative Commons

+disclaims all liability for damages resulting from their use to the

+fullest extent possible.

+

+Using Creative Commons Public Licenses

+

+Creative Commons public licenses provide a standard set of terms and

+conditions that creators and other rights holders may use to share

+original works of authorship and other material subject to copyright

+and certain other rights specified in the public license below. The

+following considerations are for informational purposes only, are not

+exhaustive, and do not form part of our licenses.

+

+     Considerations for licensors: Our public licenses are

+     intended for use by those authorized to give the public

+     permission to use material in ways otherwise restricted by

+     copyright and certain other rights. Our licenses are

+     irrevocable. Licensors should read and understand the terms

+     and conditions of the license they choose before applying it.

+     Licensors should also secure all rights necessary before

+     applying our licenses so that the public can reuse the

+     material as expected. Licensors should clearly mark any

+     material not subject to the license. This includes other CC-

+     licensed material, or material used under an exception or

+     limitation to copyright. More considerations for licensors:

+	wiki.creativecommons.org/Considerations_for_licensors

+

+     Considerations for the public: By using one of our public

+     licenses, a licensor grants the public permission to use the

+     licensed material under specified terms and conditions. If

+     the licensor's permission is not necessary for any reason--for

+     example, because of any applicable exception or limitation to

+     copyright--then that use is not regulated by the license. Our

+     licenses grant only permissions under copyright and certain

+     other rights that a licensor has authority to grant. Use of

+     the licensed material may still be restricted for other

+     reasons, including because others have copyright or other

+     rights in the material. A licensor may make special requests,

+     such as asking that all changes be marked or described.

+     Although not required by our licenses, you are encouraged to

+     respect those requests where reasonable. More_considerations

+     for the public:

+	wiki.creativecommons.org/Considerations_for_licensees

+

+=======================================================================

+

+Creative Commons Attribution-ShareAlike 4.0 International Public

+License

+

+By exercising the Licensed Rights (defined below), You accept and agree

+to be bound by the terms and conditions of this Creative Commons

+Attribution-ShareAlike 4.0 International Public License ("Public

+License"). To the extent this Public License may be interpreted as a

+contract, You are granted the Licensed Rights in consideration of Your

+acceptance of these terms and conditions, and the Licensor grants You

+such rights in consideration of benefits the Licensor receives from

+making the Licensed Material available under these terms and

+conditions.

+

+

+Section 1 -- Definitions.

+

+  a. Adapted Material means material subject to Copyright and Similar

+     Rights that is derived from or based upon the Licensed Material

+     and in which the Licensed Material is translated, altered,

+     arranged, transformed, or otherwise modified in a manner requiring

+     permission under the Copyright and Similar Rights held by the

+     Licensor. For purposes of this Public License, where the Licensed

+     Material is a musical work, performance, or sound recording,