@@ -26,14 +26,13 @@ import (

 	"github.com/docker/docker/container"

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

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

-	"github.com/docker/docker/daemon/initlayer"

-	"github.com/docker/docker/dockerversion"

-	"github.com/docker/docker/plugin"

-	"github.com/docker/libnetwork/cluster"

 	// register graph drivers

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

+	"github.com/docker/docker/daemon/initlayer"

+	"github.com/docker/docker/daemon/stats"

 	dmetadata "github.com/docker/docker/distribution/metadata"

 	"github.com/docker/docker/distribution/xfer"

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

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/layer"

 	"github.com/docker/docker/libcontainerd"

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

 	"github.com/docker/docker/pkg/sysinfo"

 	"github.com/docker/docker/pkg/system"

 	"github.com/docker/docker/pkg/truncindex"

+	"github.com/docker/docker/plugin"

 	"github.com/docker/docker/reference"

 	"github.com/docker/docker/registry"

 	"github.com/docker/docker/runconfig"

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

 	"github.com/docker/docker/volume/local"

 	"github.com/docker/docker/volume/store"

 	"github.com/docker/libnetwork"

+	"github.com/docker/libnetwork/cluster"

 	nwconfig "github.com/docker/libnetwork/config"

 	"github.com/docker/libtrust"

 	"github.com/pkg/errors"

@@ -82,7 +83,7 @@ type Daemon struct {

 	trustKey                  libtrust.PrivateKey

 	idIndex                   *truncindex.TruncIndex

 	configStore               *Config

-	statsCollector            *statsCollector

+	statsCollector            *stats.Collector

 	defaultLogConfig          containertypes.LogConfig

 	RegistryService           registry.Service

 	EventsService             *events.Events

@@ -106,6 +107,8 @@ type Daemon struct {

 	clusterProvider           cluster.Provider

 	cluster                   Cluster

+	machineMemory uint64

+

 	seccompProfile     []byte

 	seccompProfilePath string

 }

@@ -1125,8 +1125,8 @@ func (daemon *Daemon) stats(c *container.Container) (*types.StatsJSON, error) {

 			Limit:    mem.Limit,

 		}

 		// if the container does not set memory limit, use the machineMemory

-		if mem.Limit > daemon.statsCollector.machineMemory && daemon.statsCollector.machineMemory > 0 {

-			s.MemoryStats.Limit = daemon.statsCollector.machineMemory

+		if mem.Limit > daemon.machineMemory && daemon.machineMemory > 0 {

+			s.MemoryStats.Limit = daemon.machineMemory

 		}

 		if cgs.PidsStats != nil {

 			s.PidsStats = types.PidsStats{

@@ -89,7 +89,7 @@ func (daemon *Daemon) cleanupContainer(container *container.Container, forceRemo

 	// stop collection of stats for the container regardless

 	// if stats are currently getting collected.

-	daemon.statsCollector.stopCollection(container)

+	daemon.statsCollector.StopCollection(container)

 	if err = daemon.containerStop(container, 3); err != nil {

 		return err

@@ -133,11 +133,11 @@ func (daemon *Daemon) ContainerStats(ctx context.Context, prefixOrName string, c

 }

 func (daemon *Daemon) subscribeToContainerStats(c *container.Container) chan interface{} {

-	return daemon.statsCollector.collect(c)

+	return daemon.statsCollector.Collect(c)

 }

 func (daemon *Daemon) unsubscribeToContainerStats(c *container.Container, ch chan interface{}) {

-	daemon.statsCollector.unsubscribe(c, ch)

+	daemon.statsCollector.Unsubscribe(c, ch)

 }

 // GetContainerStats collects all the stats published by a container

new file mode 100644

@@ -0,0 +1,101 @@

+// +build !solaris

+

+package stats

+

+import (

+	"time"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/container"

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

+)

+

+// Collect registers the container with the collector and adds it to

+// the event loop for collection on the specified interval returning

+// a channel for the subscriber to receive on.

+func (s *Collector) Collect(c *container.Container) chan interface{} {

+	s.m.Lock()

+	defer s.m.Unlock()

+	publisher, exists := s.publishers[c]

+	if !exists {

+		publisher = pubsub.NewPublisher(100*time.Millisecond, 1024)

+		s.publishers[c] = publisher

+	}

+	return publisher.Subscribe()

+}

+

+// StopCollection closes the channels for all subscribers and removes

+// the container from metrics collection.

+func (s *Collector) StopCollection(c *container.Container) {

+	s.m.Lock()

+	if publisher, exists := s.publishers[c]; exists {

+		publisher.Close()

+		delete(s.publishers, c)

+	}

+	s.m.Unlock()

+}

+

+// Unsubscribe removes a specific subscriber from receiving updates for a container's stats.

+func (s *Collector) Unsubscribe(c *container.Container, ch chan interface{}) {

+	s.m.Lock()

+	publisher := s.publishers[c]

+	if publisher != nil {

+		publisher.Evict(ch)

+		if publisher.Len() == 0 {

+			delete(s.publishers, c)

+		}

+	}

+	s.m.Unlock()

+}

+

+// Run starts the collectors and will indefinitely collect stats from the supervisor

+func (s *Collector) Run() {

+	type publishersPair struct {

+		container *container.Container

+		publisher *pubsub.Publisher

+	}

+	// we cannot determine the capacity here.

+	// it will grow enough in first iteration

+	var pairs []publishersPair

+

+	for range time.Tick(s.interval) {

+		// it does not make sense in the first iteration,

+		// but saves allocations in further iterations

+		pairs = pairs[:0]

+

+		s.m.Lock()

+		for container, publisher := range s.publishers {

+			// copy pointers here to release the lock ASAP

+			pairs = append(pairs, publishersPair{container, publisher})

+		}

+		s.m.Unlock()

+		if len(pairs) == 0 {

+			continue

+		}

+

+		systemUsage, err := s.getSystemCPUUsage()

+		if err != nil {

+			logrus.Errorf("collecting system cpu usage: %v", err)

+			continue

+		}

+

+		for _, pair := range pairs {

+			stats, err := s.supervisor.GetContainerStats(pair.container)

+			if err != nil {

+				if _, ok := err.(notRunningErr); !ok {

+					logrus.Errorf("collecting stats for %s: %v", pair.container.ID, err)

+				}

+				continue

+			}

+			// FIXME: move to containerd on Linux (not Windows)

+			stats.CPUStats.SystemUsage = systemUsage

+

+			pair.publisher.Publish(*stats)

+		}

+	}

+}

+

+type notRunningErr interface {

+	error

+	ContainerIsRunning() bool

+}

new file mode 100644

@@ -0,0 +1,29 @@

+package stats

+

+import (

+	"github.com/docker/docker/container"

+)

+

+// platformNewStatsCollector performs platform specific initialisation of the

+// Collector structure. This is a no-op on Windows.

+func platformNewStatsCollector(s *Collector) {

+}

+

+// Collect registers the container with the collector and adds it to

+// the event loop for collection on the specified interval returning

+// a channel for the subscriber to receive on.

+// Currently not supported on Solaris

+func (s *Collector) Collect(c *container.Container) chan interface{} {

+	return nil

+}

+

+// StopCollection closes the channels for all subscribers and removes

+// the container from metrics collection.

+// Currently not supported on Solaris

+func (s *Collector) StopCollection(c *container.Container) {

+}

+

+// Unsubscribe removes a specific subscriber from receiving updates for a container's stats.

+// Currently not supported on Solaris

+func (s *Collector) Unsubscribe(c *container.Container, ch chan interface{}) {

+}

new file mode 100644

@@ -0,0 +1,66 @@

+// +build !windows,!solaris

+

+package stats

+

+import (

+	"fmt"

+	"os"

+	"strconv"

+	"strings"

+

+	"github.com/opencontainers/runc/libcontainer/system"

+)

+

+// platformNewStatsCollector performs platform specific initialisation of the

+// Collector structure.

+func platformNewStatsCollector(s *Collector) {

+	s.clockTicksPerSecond = uint64(system.GetClockTicks())

+}

+

+const nanoSecondsPerSecond = 1e9

+

+// getSystemCPUUsage returns the host system's cpu usage in

+// nanoseconds. An error is returned if the format of the underlying

+// file does not match.

+//

+// Uses /proc/stat defined by POSIX. Looks for the cpu

+// statistics line and then sums up the first seven fields

+// provided. See `man 5 proc` for details on specific field

+// information.

+func (s *Collector) getSystemCPUUsage() (uint64, error) {

+	var line string

+	f, err := os.Open("/proc/stat")

+	if err != nil {

+		return 0, err

+	}

+	defer func() {

+		s.bufReader.Reset(nil)

+		f.Close()

+	}()

+	s.bufReader.Reset(f)

+	err = nil

+	for err == nil {

+		line, err = s.bufReader.ReadString('\n')

+		if err != nil {

+			break

+		}

+		parts := strings.Fields(line)

+		switch parts[0] {

+		case "cpu":

+			if len(parts) < 8 {

+				return 0, fmt.Errorf("invalid number of cpu fields")

+			}

+			var totalClockTicks uint64

+			for _, i := range parts[1:8] {

+				v, err := strconv.ParseUint(i, 10, 64)

+				if err != nil {

+					return 0, fmt.Errorf("Unable to convert value %s to int: %s", i, err)

+				}

+				totalClockTicks += v

+			}

+			return (totalClockTicks * nanoSecondsPerSecond) /

+				s.clockTicksPerSecond, nil

+		}

+	}

+	return 0, fmt.Errorf("invalid stat format. Error trying to parse the '/proc/stat' file")

+}

new file mode 100644

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

+// +build windows

+

+package stats

+

+// platformNewStatsCollector performs platform specific initialisation of the

+// Collector structure. This is a no-op on Windows.

+func platformNewStatsCollector(s *Collector) {

+}

+

+// getSystemCPUUsage returns the host system's cpu usage in

+// nanoseconds. An error is returned if the format of the underlying

+// file does not match. This is a no-op on Windows.

+func (s *Collector) getSystemCPUUsage() (uint64, error) {

+	return 0, nil

+}

new file mode 100644

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

+package stats

+

+import (

+	"bufio"

+	"sync"

+	"time"

+

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

+	"github.com/docker/docker/container"

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

+)

+

+type supervisor interface {

+	// GetContainerStats collects all the stats related to a container

+	GetContainerStats(container *container.Container) (*types.StatsJSON, error)

+}

+

+// NewCollector creates a stats collector that will poll the supervisor with the specified interval

+func NewCollector(supervisor supervisor, interval time.Duration) *Collector {

+	s := &Collector{

+		interval:   interval,

+		supervisor: supervisor,

+		publishers: make(map[*container.Container]*pubsub.Publisher),

+		bufReader:  bufio.NewReaderSize(nil, 128),

+	}

+

+	platformNewStatsCollector(s)

+

+	return s

+}

+

+// Collector manages and provides container resource stats

+type Collector struct {

+	m          sync.Mutex

+	supervisor supervisor

+	interval   time.Duration

+	publishers map[*container.Container]*pubsub.Publisher

+	bufReader  *bufio.Reader

+

+	// The following fields are not set on Windows currently.

+	clockTicksPerSecond uint64

+}

@@ -1,132 +1,26 @@

-// +build !solaris

-

 package daemon

 import (

-	"bufio"

-	"sync"

+	"runtime"

 	"time"

-	"github.com/Sirupsen/logrus"

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

-	"github.com/docker/docker/container"

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

+	"github.com/docker/docker/daemon/stats"

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

 )

-type statsSupervisor interface {

-	// GetContainerStats collects all the stats related to a container

-	GetContainerStats(container *container.Container) (*types.StatsJSON, error)

-}

-

 // newStatsCollector returns a new statsCollector that collections

 // stats for a registered container at the specified interval.

 // The collector allows non-running containers to be added

 // and will start processing stats when they are started.

-func (daemon *Daemon) newStatsCollector(interval time.Duration) *statsCollector {

-	s := &statsCollector{

-		interval:   interval,

-		supervisor: daemon,

-		publishers: make(map[*container.Container]*pubsub.Publisher),

-		bufReader:  bufio.NewReaderSize(nil, 128),

-	}

-	platformNewStatsCollector(s)

-	go s.run()

-	return s

-}

-

-// statsCollector manages and provides container resource stats

-type statsCollector struct {

-	m          sync.Mutex

-	supervisor statsSupervisor

-	interval   time.Duration

-	publishers map[*container.Container]*pubsub.Publisher

-	bufReader  *bufio.Reader

-

-	// The following fields are not set on Windows currently.

-	clockTicksPerSecond uint64

-	machineMemory       uint64

-}

-

-// collect registers the container with the collector and adds it to

-// the event loop for collection on the specified interval returning

-// a channel for the subscriber to receive on.

-func (s *statsCollector) collect(c *container.Container) chan interface{} {

-	s.m.Lock()

-	defer s.m.Unlock()

-	publisher, exists := s.publishers[c]

-	if !exists {

-		publisher = pubsub.NewPublisher(100*time.Millisecond, 1024)

-		s.publishers[c] = publisher

-	}

-	return publisher.Subscribe()

-}

-

-// stopCollection closes the channels for all subscribers and removes

-// the container from metrics collection.

-func (s *statsCollector) stopCollection(c *container.Container) {

-	s.m.Lock()

-	if publisher, exists := s.publishers[c]; exists {

-		publisher.Close()

-		delete(s.publishers, c)

-	}

-	s.m.Unlock()

-}

-

-// unsubscribe removes a specific subscriber from receiving updates for a container's stats.

-func (s *statsCollector) unsubscribe(c *container.Container, ch chan interface{}) {

-	s.m.Lock()

-	publisher := s.publishers[c]

-	if publisher != nil {

-		publisher.Evict(ch)

-		if publisher.Len() == 0 {

-			delete(s.publishers, c)

-		}

-	}

-	s.m.Unlock()

-}

-

-func (s *statsCollector) run() {

-	type publishersPair struct {

-		container *container.Container

-		publisher *pubsub.Publisher

-	}

-	// we cannot determine the capacity here.

-	// it will grow enough in first iteration

-	var pairs []publishersPair

-

-	for range time.Tick(s.interval) {

-		// it does not make sense in the first iteration,

-		// but saves allocations in further iterations

-		pairs = pairs[:0]

-

-		s.m.Lock()

-		for container, publisher := range s.publishers {

-			// copy pointers here to release the lock ASAP

-			pairs = append(pairs, publishersPair{container, publisher})

-		}

-		s.m.Unlock()

-		if len(pairs) == 0 {

-			continue

-		}

-

-		systemUsage, err := s.getSystemCPUUsage()

-		if err != nil {

-			logrus.Errorf("collecting system cpu usage: %v", err)

-			continue

-		}

-

-		for _, pair := range pairs {

-			stats, err := s.supervisor.GetContainerStats(pair.container)

-			if err != nil {

-				if _, ok := err.(errNotRunning); !ok {

-					logrus.Errorf("collecting stats for %s: %v", pair.container.ID, err)

-				}

-				continue

-			}

-			// FIXME: move to containerd on Linux (not Windows)

-			stats.CPUStats.SystemUsage = systemUsage

-

-			pair.publisher.Publish(*stats)

+func (daemon *Daemon) newStatsCollector(interval time.Duration) *stats.Collector {

+	// FIXME(vdemeester) move this elsewhere

+	if runtime.GOOS == "linux" {

+		meminfo, err := system.ReadMemInfo()

+		if err == nil && meminfo.MemTotal > 0 {

+			daemon.machineMemory = uint64(meminfo.MemTotal)

 		}

 	}

+	s := stats.NewCollector(daemon, interval)

+	go s.Run()

+	return s

 }

deleted file mode 100644

@@ -1,34 +0,0 @@

-package daemon

-

-import (

-	"github.com/docker/docker/container"

-	"time"

-)

-

-// newStatsCollector returns a new statsCollector for collection stats

-// for a registered container at the specified interval. The collector allows

-// non-running containers to be added and will start processing stats when

-// they are started.

-func (daemon *Daemon) newStatsCollector(interval time.Duration) *statsCollector {

-	return &statsCollector{}

-}

-

-// statsCollector manages and provides container resource stats

-type statsCollector struct {

-}

-

-// collect registers the container with the collector and adds it to

-// the event loop for collection on the specified interval returning

-// a channel for the subscriber to receive on.

-func (s *statsCollector) collect(c *container.Container) chan interface{} {

-	return nil

-}

-

-// stopCollection closes the channels for all subscribers and removes

-// the container from metrics collection.

-func (s *statsCollector) stopCollection(c *container.Container) {

-}

-

-// unsubscribe removes a specific subscriber from receiving updates for a container's stats.

-func (s *statsCollector) unsubscribe(c *container.Container, ch chan interface{}) {

-}

deleted file mode 100644

@@ -1,71 +0,0 @@

-// +build !windows,!solaris

-

-package daemon

-

-import (

-	"fmt"

-	"os"

-	"strconv"

-	"strings"

-

-	sysinfo "github.com/docker/docker/pkg/system"

-	"github.com/opencontainers/runc/libcontainer/system"

-)

-

-// platformNewStatsCollector performs platform specific initialisation of the

-// statsCollector structure.

-func platformNewStatsCollector(s *statsCollector) {

-	s.clockTicksPerSecond = uint64(system.GetClockTicks())

-	meminfo, err := sysinfo.ReadMemInfo()

-	if err == nil && meminfo.MemTotal > 0 {

-		s.machineMemory = uint64(meminfo.MemTotal)

-	}

-}

-

-const nanoSecondsPerSecond = 1e9

-

-// getSystemCPUUsage returns the host system's cpu usage in

-// nanoseconds. An error is returned if the format of the underlying

-// file does not match.

-//

-// Uses /proc/stat defined by POSIX. Looks for the cpu

-// statistics line and then sums up the first seven fields

-// provided. See `man 5 proc` for details on specific field

-// information.

-func (s *statsCollector) getSystemCPUUsage() (uint64, error) {

-	var line string

-	f, err := os.Open("/proc/stat")

-	if err != nil {

-		return 0, err

-	}

-	defer func() {

-		s.bufReader.Reset(nil)

-		f.Close()

-	}()

-	s.bufReader.Reset(f)

-	err = nil

-	for err == nil {

-		line, err = s.bufReader.ReadString('\n')

-		if err != nil {

-			break

-		}

-		parts := strings.Fields(line)

-		switch parts[0] {

-		case "cpu":

-			if len(parts) < 8 {

-				return 0, fmt.Errorf("invalid number of cpu fields")

-			}

-			var totalClockTicks uint64

-			for _, i := range parts[1:8] {

-				v, err := strconv.ParseUint(i, 10, 64)

-				if err != nil {

-					return 0, fmt.Errorf("Unable to convert value %s to int: %s", i, err)

-				}

-				totalClockTicks += v

-			}

-			return (totalClockTicks * nanoSecondsPerSecond) /

-				s.clockTicksPerSecond, nil

-		}

-	}

-	return 0, fmt.Errorf("invalid stat format. Error trying to parse the '/proc/stat' file")

-}

deleted file mode 100644

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

-// +build windows

-

-package daemon

-

-// platformNewStatsCollector performs platform specific initialisation of the

-// statsCollector structure. This is a no-op on Windows.

-func platformNewStatsCollector(s *statsCollector) {

-}

-

-// getSystemCPUUsage returns the host system's cpu usage in

-// nanoseconds. An error is returned if the format of the underlying

-// file does not match. This is a no-op on Windows.

-func (s *statsCollector) getSystemCPUUsage() (uint64, error) {

-	return 0, nil

-}