@@ -28,11 +28,11 @@ import (

 	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/pkg/ulimit"

-	"github.com/docker/docker/pkg/units"

 	"github.com/docker/docker/pkg/urlutil"

 	"github.com/docker/docker/registry"

 	tagpkg "github.com/docker/docker/tag"

 	"github.com/docker/docker/utils"

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

 )

 // CmdBuild builds a new image from the source code at a given path.

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

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/docker/docker/pkg/stringutils"

-	"github.com/docker/docker/pkg/units"

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

 )

 // CmdHistory shows the history of an image.

@@ -13,7 +13,7 @@ import (

 	"github.com/docker/docker/opts"

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/stringid"

-	"github.com/docker/docker/pkg/units"

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

 )

 // CmdImages lists the images in a specified repository, or all top-level images if no repository is specified.

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

 	Cli "github.com/docker/docker/cli"

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

 	flag "github.com/docker/docker/pkg/mflag"

-	"github.com/docker/docker/pkg/units"

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

 )

 // CmdInfo displays system-wide information.

@@ -9,8 +9,8 @@ import (

 	"strconv"

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

-	"github.com/docker/docker/pkg/units"

 	"github.com/docker/docker/runconfig"

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

 )

 var headerRegexp = regexp.MustCompile(`\ADocker/.+\s\((.+)\)\z`)

@@ -10,7 +10,7 @@ import (

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

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/docker/docker/pkg/stringutils"

-	"github.com/docker/docker/pkg/units"

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

 )

 const (

@@ -13,7 +13,7 @@ import (

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

 	Cli "github.com/docker/docker/cli"

 	"github.com/docker/docker/pkg/jsonmessage"

-	"github.com/docker/docker/pkg/units"

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

 )

 type containerStats struct {

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

 	"github.com/docker/docker/daemon/execdriver"

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

-	"github.com/docker/docker/pkg/units"

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

 )

 // State holds the current container state, and has methods to get and

@@ -26,7 +26,7 @@ import (

 	"github.com/docker/docker/pkg/idtools"

 	"github.com/docker/docker/pkg/mount"

 	"github.com/docker/docker/pkg/parsers"

-	"github.com/docker/docker/pkg/units"

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

 	"github.com/opencontainers/runc/libcontainer/label"

 )

@@ -15,7 +15,7 @@ import (

 	"github.com/docker/docker/pkg/devicemapper"

 	"github.com/docker/docker/pkg/idtools"

 	"github.com/docker/docker/pkg/mount"

-	"github.com/docker/docker/pkg/units"

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

 )

 func init() {

@@ -14,7 +14,7 @@ import (

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/daemon/logger/loggerutils"

 	"github.com/docker/docker/pkg/jsonlog"

-	"github.com/docker/docker/pkg/units"

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

 )

 // Name is the name of the file that the jsonlogger logs to.

@@ -20,6 +20,7 @@ clone git github.com/mistifyio/go-zfs v2.1.1

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

 clone git github.com/vdemeester/shakers 3c10293ce22b900c27acad7b28656196fcc2f73b

 clone git golang.org/x/net 47990a1ba55743e6ef1affd3a14e5bac8553615d https://github.com/golang/net.git

+clone git github.com/docker/go-units v0.2.0

 #get libnetwork packages

 clone git github.com/docker/libnetwork bbd6e6d8ca1e7c9b42f6f53277b0bde72847ff90

@@ -49,7 +50,7 @@ clone git github.com/miekg/pkcs11 80f102b5cac759de406949c47f0928b99bd64cdf

 clone git github.com/jfrazelle/go v1.5.1-1

 clone git github.com/agl/ed25519 d2b94fd789ea21d12fac1a4443dd3a3f79cda72c

-clone git github.com/opencontainers/runc v0.0.6 # libcontainer

+clone git github.com/opencontainers/runc ba1568de399395774ad84c2ace65937814c542ed # libcontainer

 clone git github.com/opencontainers/specs 46d949ea81080c5f60dfb72ee91468b1e9fb2998 # specs

 clone git github.com/seccomp/libseccomp-golang 1b506fc7c24eec5a3693cdcbed40d9c226cfc6a1

 # libcontainer deps (see src/github.com/opencontainers/runc/Godeps/Godeps.json)

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

 	"github.com/docker/docker/pkg/blkiodev"

 	"github.com/docker/docker/pkg/parsers"

-	"github.com/docker/docker/pkg/units"

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

 )

 var (

@@ -9,7 +9,7 @@ import (

 	"github.com/docker/docker/pkg/jsonlog"

 	"github.com/docker/docker/pkg/term"

-	"github.com/docker/docker/pkg/units"

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

 )

 // JSONError wraps a concrete Code and Message, `Code` is

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

 	"strconv"

 	"strings"

-	"github.com/docker/docker/pkg/units"

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

 )

 // ReadMemInfo retrieves memory statistics of the host system and returns a

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

 	"strings"

 	"testing"

-	"github.com/docker/docker/pkg/units"

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

 )

 // TestMemInfo tests parseMemInfo with a static meminfo string

deleted file mode 100644

@@ -1,33 +0,0 @@

-// Package units provides helper function to parse and print size and time units

-// in human-readable format.

-package units

-

-import (

-	"fmt"

-	"time"

-)

-

-// HumanDuration returns a human-readable approximation of a duration

-// (eg. "About a minute", "4 hours ago", etc.).

-func HumanDuration(d time.Duration) string {

-	if seconds := int(d.Seconds()); seconds < 1 {

-		return "Less than a second"

-	} else if seconds < 60 {

-		return fmt.Sprintf("%d seconds", seconds)

-	} else if minutes := int(d.Minutes()); minutes == 1 {

-		return "About a minute"

-	} else if minutes < 60 {

-		return fmt.Sprintf("%d minutes", minutes)

-	} else if hours := int(d.Hours()); hours == 1 {

-		return "About an hour"

-	} else if hours < 48 {

-		return fmt.Sprintf("%d hours", hours)

-	} else if hours < 24*7*2 {

-		return fmt.Sprintf("%d days", hours/24)

-	} else if hours < 24*30*3 {

-		return fmt.Sprintf("%d weeks", hours/24/7)

-	} else if hours < 24*365*2 {

-		return fmt.Sprintf("%d months", hours/24/30)

-	}

-	return fmt.Sprintf("%d years", int(d.Hours())/24/365)

-}

deleted file mode 100644

@@ -1,46 +0,0 @@

-package units

-

-import (

-	"testing"

-	"time"

-)

-

-func TestHumanDuration(t *testing.T) {

-	// Useful duration abstractions

-	day := 24 * time.Hour

-	week := 7 * day

-	month := 30 * day

-	year := 365 * day

-

-	assertEquals(t, "Less than a second", HumanDuration(450*time.Millisecond))

-	assertEquals(t, "47 seconds", HumanDuration(47*time.Second))

-	assertEquals(t, "About a minute", HumanDuration(1*time.Minute))

-	assertEquals(t, "3 minutes", HumanDuration(3*time.Minute))

-	assertEquals(t, "35 minutes", HumanDuration(35*time.Minute))

-	assertEquals(t, "35 minutes", HumanDuration(35*time.Minute+40*time.Second))

-	assertEquals(t, "About an hour", HumanDuration(1*time.Hour))

-	assertEquals(t, "About an hour", HumanDuration(1*time.Hour+45*time.Minute))

-	assertEquals(t, "3 hours", HumanDuration(3*time.Hour))

-	assertEquals(t, "3 hours", HumanDuration(3*time.Hour+59*time.Minute))

-	assertEquals(t, "4 hours", HumanDuration(3*time.Hour+60*time.Minute))

-	assertEquals(t, "24 hours", HumanDuration(24*time.Hour))

-	assertEquals(t, "36 hours", HumanDuration(1*day+12*time.Hour))

-	assertEquals(t, "2 days", HumanDuration(2*day))

-	assertEquals(t, "7 days", HumanDuration(7*day))

-	assertEquals(t, "13 days", HumanDuration(13*day+5*time.Hour))

-	assertEquals(t, "2 weeks", HumanDuration(2*week))

-	assertEquals(t, "2 weeks", HumanDuration(2*week+4*day))

-	assertEquals(t, "3 weeks", HumanDuration(3*week))

-	assertEquals(t, "4 weeks", HumanDuration(4*week))

-	assertEquals(t, "4 weeks", HumanDuration(4*week+3*day))

-	assertEquals(t, "4 weeks", HumanDuration(1*month))

-	assertEquals(t, "6 weeks", HumanDuration(1*month+2*week))

-	assertEquals(t, "8 weeks", HumanDuration(2*month))

-	assertEquals(t, "3 months", HumanDuration(3*month+1*week))

-	assertEquals(t, "5 months", HumanDuration(5*month+2*week))

-	assertEquals(t, "13 months", HumanDuration(13*month))

-	assertEquals(t, "23 months", HumanDuration(23*month))

-	assertEquals(t, "24 months", HumanDuration(24*month))

-	assertEquals(t, "2 years", HumanDuration(24*month+2*week))

-	assertEquals(t, "3 years", HumanDuration(3*year+2*month))

-}

deleted file mode 100644

@@ -1,95 +0,0 @@

-package units

-

-import (

-	"fmt"

-	"regexp"

-	"strconv"

-	"strings"

-)

-

-// See: http://en.wikipedia.org/wiki/Binary_prefix

-const (

-	// Decimal

-

-	KB = 1000

-	MB = 1000 * KB

-	GB = 1000 * MB

-	TB = 1000 * GB

-	PB = 1000 * TB

-

-	// Binary

-

-	KiB = 1024

-	MiB = 1024 * KiB

-	GiB = 1024 * MiB

-	TiB = 1024 * GiB

-	PiB = 1024 * TiB

-)

-

-type unitMap map[string]int64

-

-var (

-	decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}

-	binaryMap  = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}

-	sizeRegex  = regexp.MustCompile(`^(\d+)([kKmMgGtTpP])?[bB]?$`)

-)

-

-var decimapAbbrs = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}

-var binaryAbbrs = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}

-

-// CustomSize returns a human-readable approximation of a size

-// using custom format.

-func CustomSize(format string, size float64, base float64, _map []string) string {

-	i := 0

-	for size >= base {

-		size = size / base

-		i++

-	}

-	return fmt.Sprintf(format, size, _map[i])

-}

-

-// HumanSize returns a human-readable approximation of a size

-// capped at 4 valid numbers (eg. "2.746 MB", "796 KB").

-func HumanSize(size float64) string {

-	return CustomSize("%.4g %s", size, 1000.0, decimapAbbrs)

-}

-

-// BytesSize returns a human-readable size in bytes, kibibytes,

-// mebibytes, gibibytes, or tebibytes (eg. "44kiB", "17MiB").

-func BytesSize(size float64) string {

-	return CustomSize("%.4g %s", size, 1024.0, binaryAbbrs)

-}

-

-// FromHumanSize returns an integer from a human-readable specification of a

-// size using SI standard (eg. "44kB", "17MB").

-func FromHumanSize(size string) (int64, error) {

-	return parseSize(size, decimalMap)

-}

-

-// RAMInBytes parses a human-readable string representing an amount of RAM

-// in bytes, kibibytes, mebibytes, gibibytes, or tebibytes and

-// returns the number of bytes, or -1 if the string is unparseable.

-// Units are case-insensitive, and the 'b' suffix is optional.

-func RAMInBytes(size string) (int64, error) {

-	return parseSize(size, binaryMap)

-}

-

-// Parses the human-readable size string into the amount it represents.

-func parseSize(sizeStr string, uMap unitMap) (int64, error) {

-	matches := sizeRegex.FindStringSubmatch(sizeStr)

-	if len(matches) != 3 {

-		return -1, fmt.Errorf("invalid size: '%s'", sizeStr)

-	}

-

-	size, err := strconv.ParseInt(matches[1], 10, 0)

-	if err != nil {

-		return -1, err

-	}

-

-	unitPrefix := strings.ToLower(matches[2])

-	if mul, ok := uMap[unitPrefix]; ok {

-		size *= mul

-	}

-

-	return size, nil

-}

deleted file mode 100644

@@ -1,108 +0,0 @@

-package units

-

-import (

-	"reflect"

-	"runtime"

-	"strings"

-	"testing"

-)

-

-func TestBytesSize(t *testing.T) {

-	assertEquals(t, "1 KiB", BytesSize(1024))

-	assertEquals(t, "1 MiB", BytesSize(1024*1024))

-	assertEquals(t, "1 MiB", BytesSize(1048576))

-	assertEquals(t, "2 MiB", BytesSize(2*MiB))

-	assertEquals(t, "3.42 GiB", BytesSize(3.42*GiB))

-	assertEquals(t, "5.372 TiB", BytesSize(5.372*TiB))

-	assertEquals(t, "2.22 PiB", BytesSize(2.22*PiB))

-}

-

-func TestHumanSize(t *testing.T) {

-	assertEquals(t, "1 kB", HumanSize(1000))

-	assertEquals(t, "1.024 kB", HumanSize(1024))

-	assertEquals(t, "1 MB", HumanSize(1000000))

-	assertEquals(t, "1.049 MB", HumanSize(1048576))

-	assertEquals(t, "2 MB", HumanSize(2*MB))

-	assertEquals(t, "3.42 GB", HumanSize(float64(3.42*GB)))

-	assertEquals(t, "5.372 TB", HumanSize(float64(5.372*TB)))

-	assertEquals(t, "2.22 PB", HumanSize(float64(2.22*PB)))

-}

-

-func TestFromHumanSize(t *testing.T) {

-	assertSuccessEquals(t, 32, FromHumanSize, "32")

-	assertSuccessEquals(t, 32, FromHumanSize, "32b")

-	assertSuccessEquals(t, 32, FromHumanSize, "32B")

-	assertSuccessEquals(t, 32*KB, FromHumanSize, "32k")

-	assertSuccessEquals(t, 32*KB, FromHumanSize, "32K")

-	assertSuccessEquals(t, 32*KB, FromHumanSize, "32kb")

-	assertSuccessEquals(t, 32*KB, FromHumanSize, "32Kb")

-	assertSuccessEquals(t, 32*MB, FromHumanSize, "32Mb")

-	assertSuccessEquals(t, 32*GB, FromHumanSize, "32Gb")

-	assertSuccessEquals(t, 32*TB, FromHumanSize, "32Tb")

-	assertSuccessEquals(t, 32*PB, FromHumanSize, "32Pb")

-

-	assertError(t, FromHumanSize, "")

-	assertError(t, FromHumanSize, "hello")

-	assertError(t, FromHumanSize, "-32")

-	assertError(t, FromHumanSize, "32.3")

-	assertError(t, FromHumanSize, " 32 ")

-	assertError(t, FromHumanSize, "32.3Kb")

-	assertError(t, FromHumanSize, "32 mb")

-	assertError(t, FromHumanSize, "32m b")

-	assertError(t, FromHumanSize, "32bm")

-}

-

-func TestRAMInBytes(t *testing.T) {

-	assertSuccessEquals(t, 32, RAMInBytes, "32")

-	assertSuccessEquals(t, 32, RAMInBytes, "32b")

-	assertSuccessEquals(t, 32, RAMInBytes, "32B")

-	assertSuccessEquals(t, 32*KiB, RAMInBytes, "32k")

-	assertSuccessEquals(t, 32*KiB, RAMInBytes, "32K")

-	assertSuccessEquals(t, 32*KiB, RAMInBytes, "32kb")

-	assertSuccessEquals(t, 32*KiB, RAMInBytes, "32Kb")

-	assertSuccessEquals(t, 32*MiB, RAMInBytes, "32Mb")

-	assertSuccessEquals(t, 32*GiB, RAMInBytes, "32Gb")

-	assertSuccessEquals(t, 32*TiB, RAMInBytes, "32Tb")

-	assertSuccessEquals(t, 32*PiB, RAMInBytes, "32Pb")

-	assertSuccessEquals(t, 32*PiB, RAMInBytes, "32PB")

-	assertSuccessEquals(t, 32*PiB, RAMInBytes, "32P")

-

-	assertError(t, RAMInBytes, "")

-	assertError(t, RAMInBytes, "hello")

-	assertError(t, RAMInBytes, "-32")

-	assertError(t, RAMInBytes, "32.3")

-	assertError(t, RAMInBytes, " 32 ")

-	assertError(t, RAMInBytes, "32.3Kb")

-	assertError(t, RAMInBytes, "32 mb")

-	assertError(t, RAMInBytes, "32m b")

-	assertError(t, RAMInBytes, "32bm")

-}

-

-func assertEquals(t *testing.T, expected, actual interface{}) {

-	if expected != actual {

-		t.Errorf("Expected '%v' but got '%v'", expected, actual)

-	}

-}

-

-// func that maps to the parse function signatures as testing abstraction

-type parseFn func(string) (int64, error)

-

-// Define 'String()' for pretty-print

-func (fn parseFn) String() string {

-	fnName := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()

-	return fnName[strings.LastIndex(fnName, ".")+1:]

-}

-

-func assertSuccessEquals(t *testing.T, expected int64, fn parseFn, arg string) {

-	res, err := fn(arg)

-	if err != nil || res != expected {

-		t.Errorf("%s(\"%s\") -> expected '%d' but got '%d' with error '%v'", fn, arg, expected, res, err)

-	}

-}

-

-func assertError(t *testing.T, fn parseFn, arg string) {

-	res, err := fn(arg)

-	if err == nil && res != -1 {

-		t.Errorf("%s(\"%s\") -> expected error but got '%d'", fn, arg, res)

-	}

-}

@@ -12,8 +12,8 @@ import (

 	"github.com/docker/docker/pkg/parsers"

 	"github.com/docker/docker/pkg/signal"

 	"github.com/docker/docker/pkg/stringutils"

-	"github.com/docker/docker/pkg/units"

 	"github.com/docker/docker/volume"

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

 )

 var (

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 2015 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,11 @@

+# Introduction

+

+go-units is a library to transform human friendly measurements into machine friendly values.

+

+## Usage

+

+See the [docs in godoc](https://godoc.org/github.com/docker/go-units) for examples and documentation.

+

+## License

+

+go-units is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text.

new file mode 100644

@@ -0,0 +1,33 @@

+// Package units provides helper function to parse and print size and time units

+// in human-readable format.

+package units

+

+import (

+	"fmt"

+	"time"

+)

+

+// HumanDuration returns a human-readable approximation of a duration

+// (eg. "About a minute", "4 hours ago", etc.).

+func HumanDuration(d time.Duration) string {

+	if seconds := int(d.Seconds()); seconds < 1 {

+		return "Less than a second"

+	} else if seconds < 60 {

+		return fmt.Sprintf("%d seconds", seconds)

+	} else if minutes := int(d.Minutes()); minutes == 1 {

+		return "About a minute"

+	} else if minutes < 60 {

+		return fmt.Sprintf("%d minutes", minutes)

+	} else if hours := int(d.Hours()); hours == 1 {

+		return "About an hour"

+	} else if hours < 48 {

+		return fmt.Sprintf("%d hours", hours)

+	} else if hours < 24*7*2 {

+		return fmt.Sprintf("%d days", hours/24)

+	} else if hours < 24*30*3 {

+		return fmt.Sprintf("%d weeks", hours/24/7)

+	} else if hours < 24*365*2 {

+		return fmt.Sprintf("%d months", hours/24/30)

+	}

+	return fmt.Sprintf("%d years", int(d.Hours())/24/365)

+}

new file mode 100644

@@ -0,0 +1,95 @@

+package units

+

+import (

+	"fmt"

+	"regexp"

+	"strconv"

+	"strings"

+)

+

+// See: http://en.wikipedia.org/wiki/Binary_prefix

+const (

+	// Decimal

+

+	KB = 1000

+	MB = 1000 * KB

+	GB = 1000 * MB

+	TB = 1000 * GB

+	PB = 1000 * TB

+

+	// Binary

+

+	KiB = 1024

+	MiB = 1024 * KiB

+	GiB = 1024 * MiB

+	TiB = 1024 * GiB

+	PiB = 1024 * TiB

+)

+

+type unitMap map[string]int64

+

+var (

+	decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}

+	binaryMap  = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}

+	sizeRegex  = regexp.MustCompile(`^(\d+)([kKmMgGtTpP])?[bB]?$`)

+)

+

+var decimapAbbrs = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}

+var binaryAbbrs = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}

+

+// CustomSize returns a human-readable approximation of a size

+// using custom format.

+func CustomSize(format string, size float64, base float64, _map []string) string {

+	i := 0

+	for size >= base {

+		size = size / base

+		i++

+	}

+	return fmt.Sprintf(format, size, _map[i])

+}

+

+// HumanSize returns a human-readable approximation of a size

+// capped at 4 valid numbers (eg. "2.746 MB", "796 KB").

+func HumanSize(size float64) string {

+	return CustomSize("%.4g %s", size, 1000.0, decimapAbbrs)

+}

+

+// BytesSize returns a human-readable size in bytes, kibibytes,

+// mebibytes, gibibytes, or tebibytes (eg. "44kiB", "17MiB").

+func BytesSize(size float64) string {

+	return CustomSize("%.4g %s", size, 1024.0, binaryAbbrs)

+}

+

+// FromHumanSize returns an integer from a human-readable specification of a

+// size using SI standard (eg. "44kB", "17MB").

+func FromHumanSize(size string) (int64, error) {

+	return parseSize(size, decimalMap)

+}

+

+// RAMInBytes parses a human-readable string representing an amount of RAM

+// in bytes, kibibytes, mebibytes, gibibytes, or tebibytes and

+// returns the number of bytes, or -1 if the string is unparseable.

+// Units are case-insensitive, and the 'b' suffix is optional.

+func RAMInBytes(size string) (int64, error) {

+	return parseSize(size, binaryMap)

+}

+

+// Parses the human-readable size string into the amount it represents.

+func parseSize(sizeStr string, uMap unitMap) (int64, error) {

+	matches := sizeRegex.FindStringSubmatch(sizeStr)

+	if len(matches) != 3 {

+		return -1, fmt.Errorf("invalid size: '%s'", sizeStr)

+	}

+

+	size, err := strconv.ParseInt(matches[1], 10, 0)

+	if err != nil {

+		return -1, err

+	}

+

+	unitPrefix := strings.ToLower(matches[2])

+	if mul, ok := uMap[unitPrefix]; ok {

+		size *= mul

+	}

+

+	return size, nil

+}

@@ -13,7 +13,7 @@ import (

 	"time"

 	"github.com/docker/docker/pkg/mount"

-	"github.com/docker/docker/pkg/units"

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

 )

 const cgroupNamePrefix = "name="

@@ -78,6 +78,13 @@ func (p Process) Signal(sig os.Signal) error {

 	return p.ops.signal(sig)

 }

+// IO holds the process's STDIO

+type IO struct {

+	Stdin  io.WriteCloser

+	Stdout io.ReadCloser

+	Stderr io.ReadCloser

+}

+

 // NewConsole creates new console for process and returns it

 func (p *Process) NewConsole(rootuid int) (Console, error) {

 	console, err := NewConsole(rootuid, rootuid)

@@ -320,3 +320,44 @@ func getPipeFds(pid int) ([]string, error) {

 	}

 	return fds, nil

 }

+

+// InitializeIO creates pipes for use with the process's STDIO

+// and returns the opposite side for each

+func (p *Process) InitializeIO(rootuid int) (i *IO, err error) {

+	var fds []uintptr

+	i = &IO{}

+	// cleanup in case of an error

+	defer func() {

+		if err != nil {

+			for _, fd := range fds {

+				syscall.Close(int(fd))

+			}

+		}

+	}()

+	// STDIN

+	r, w, err := os.Pipe()

+	if err != nil {

+		return nil, err

+	}

+	fds = append(fds, r.Fd(), w.Fd())