@@ -15,8 +15,8 @@ import (

 	"time"

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

-	"github.com/dotcloud/docker/pkg/cgroups"

 	"github.com/dotcloud/docker/pkg/label"

+	"github.com/dotcloud/docker/pkg/libcontainer/cgroups"

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

 	"github.com/dotcloud/docker/utils"

 )

@@ -13,8 +13,8 @@ import (

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

 	"github.com/dotcloud/docker/pkg/apparmor"

-	"github.com/dotcloud/docker/pkg/cgroups"

 	"github.com/dotcloud/docker/pkg/libcontainer"

+	"github.com/dotcloud/docker/pkg/libcontainer/cgroups"

 	"github.com/dotcloud/docker/pkg/libcontainer/nsinit"

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

 )

@@ -2,8 +2,8 @@ package template

 import (

 	"github.com/dotcloud/docker/pkg/apparmor"

-	"github.com/dotcloud/docker/pkg/cgroups"

 	"github.com/dotcloud/docker/pkg/libcontainer"

+	"github.com/dotcloud/docker/pkg/libcontainer/cgroups"

 )

 // New returns the docker default configuration for libcontainer

deleted file mode 100644

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

-Michael Crosby <michael@crosbymichael.com> (@crosbymichael)

-Rohit Jnagal <jnagal@google.com> (@rjnagal)

-Victor Marmol <vmarmol@google.com> (@vmarmol)

deleted file mode 100644

@@ -1,30 +0,0 @@

-package cgroups

-

-import (

-	"errors"

-)

-

-var (

-	ErrNotFound = errors.New("mountpoint not found")

-)

-

-type Cgroup struct {

-	Name   string `json:"name,omitempty"`

-	Parent string `json:"parent,omitempty"`

-

-	DeviceAccess      bool   `json:"device_access,omitempty"`      // name of parent cgroup or slice

-	Memory            int64  `json:"memory,omitempty"`             // Memory limit (in bytes)

-	MemoryReservation int64  `json:"memory_reservation,omitempty"` // Memory reservation or soft_limit (in bytes)

-	MemorySwap        int64  `json:"memory_swap,omitempty"`        // Total memory usage (memory + swap); set `-1' to disable swap

-	CpuShares         int64  `json:"cpu_shares,omitempty"`         // CPU shares (relative weight vs. other containers)

-	CpuQuota          int64  `json:"cpu_quota,omitempty"`          // CPU hardcap limit (in usecs). Allowed cpu time in a given period.

-	CpuPeriod         int64  `json:"cpu_period,omitempty"`         // CPU period to be used for hardcapping (in usecs). 0 to use system default.

-	CpusetCpus        string `json:"cpuset_cpus,omitempty"`        // CPU to use

-	Freezer           string `json:"freezer,omitempty"`            // set the freeze value for the process

-

-	Slice string `json:"slice,omitempty"` // Parent slice to use for systemd

-}

-

-type ActiveCgroup interface {

-	Cleanup() error

-}

deleted file mode 100644

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

-package cgroups

-

-import (

-	"bytes"

-	"testing"

-)

-

-const (

-	cgroupsContents = `11:hugetlb:/

-10:perf_event:/

-9:blkio:/

-8:net_cls:/

-7:freezer:/

-6:devices:/

-5:memory:/

-4:cpuacct,cpu:/

-3:cpuset:/

-2:name=systemd:/user.slice/user-1000.slice/session-16.scope`

-)

-

-func TestParseCgroups(t *testing.T) {

-	r := bytes.NewBuffer([]byte(cgroupsContents))

-	_, err := parseCgroupFile("blkio", r)

-	if err != nil {

-		t.Fatal(err)

-	}

-}

deleted file mode 100644

@@ -1,155 +0,0 @@

-package fs

-

-import (

-	"fmt"

-	"io/ioutil"

-	"os"

-	"path/filepath"

-	"strconv"

-

-	"github.com/dotcloud/docker/pkg/cgroups"

-)

-

-var (

-	subsystems = map[string]subsystem{

-		"devices":    &devicesGroup{},

-		"memory":     &memoryGroup{},

-		"cpu":        &cpuGroup{},

-		"cpuset":     &cpusetGroup{},

-		"cpuacct":    &cpuacctGroup{},

-		"blkio":      &blkioGroup{},

-		"perf_event": &perfEventGroup{},

-		"freezer":    &freezerGroup{},

-	}

-)

-

-type subsystem interface {

-	Set(*data) error

-	Remove(*data) error

-	Stats(*data) (map[string]float64, error)

-}

-

-type data struct {

-	root   string

-	cgroup string

-	c      *cgroups.Cgroup

-	pid    int

-}

-

-func Apply(c *cgroups.Cgroup, pid int) (cgroups.ActiveCgroup, error) {

-	// We have two implementation of cgroups support, one is based on

-	// systemd and the dbus api, and one is based on raw cgroup fs operations

-	// following the pre-single-writer model docs at:

-	// http://www.freedesktop.org/wiki/Software/systemd/PaxControlGroups/

-	//

-	// we can pick any subsystem to find the root

-

-	cgroupRoot, err := cgroups.FindCgroupMountpoint("cpu")

-	if err != nil {

-		return nil, err

-	}

-	cgroupRoot = filepath.Dir(cgroupRoot)

-

-	if _, err := os.Stat(cgroupRoot); err != nil {

-		return nil, fmt.Errorf("cgroups fs not found")

-	}

-

-	cgroup := c.Name

-	if c.Parent != "" {

-		cgroup = filepath.Join(c.Parent, cgroup)

-	}

-

-	d := &data{

-		root:   cgroupRoot,

-		cgroup: cgroup,

-		c:      c,

-		pid:    pid,

-	}

-	for _, sys := range subsystems {

-		if err := sys.Set(d); err != nil {

-			d.Cleanup()

-			return nil, err

-		}

-	}

-	return d, nil

-}

-

-func GetStats(c *cgroups.Cgroup, subsystem string, pid int) (map[string]float64, error) {

-	cgroupRoot, err := cgroups.FindCgroupMountpoint("cpu")

-	if err != nil {

-		return nil, err

-	}

-	cgroupRoot = filepath.Dir(cgroupRoot)

-

-	if _, err := os.Stat(cgroupRoot); err != nil {

-		return nil, fmt.Errorf("cgroups fs not found")

-	}

-

-	cgroup := c.Name

-	if c.Parent != "" {

-		cgroup = filepath.Join(c.Parent, cgroup)

-	}

-

-	d := &data{

-		root:   cgroupRoot,

-		cgroup: cgroup,

-		c:      c,

-		pid:    pid,

-	}

-	sys, exists := subsystems[subsystem]

-	if !exists {

-		return nil, fmt.Errorf("subsystem %s does not exist", subsystem)

-	}

-	return sys.Stats(d)

-}

-

-func (raw *data) parent(subsystem string) (string, error) {

-	initPath, err := cgroups.GetInitCgroupDir(subsystem)

-	if err != nil {

-		return "", err

-	}

-	return filepath.Join(raw.root, subsystem, initPath), nil

-}

-

-func (raw *data) path(subsystem string) (string, error) {

-	parent, err := raw.parent(subsystem)

-	if err != nil {

-		return "", err

-	}

-	return filepath.Join(parent, raw.cgroup), nil

-}

-

-func (raw *data) join(subsystem string) (string, error) {

-	path, err := raw.path(subsystem)

-	if err != nil {

-		return "", err

-	}

-	if err := os.MkdirAll(path, 0755); err != nil && !os.IsExist(err) {

-		return "", err

-	}

-	if err := writeFile(path, "cgroup.procs", strconv.Itoa(raw.pid)); err != nil {

-		return "", err

-	}

-	return path, nil

-}

-

-func (raw *data) Cleanup() error {

-	for _, sys := range subsystems {

-		sys.Remove(raw)

-	}

-	return nil

-}

-

-func writeFile(dir, file, data string) error {

-	return ioutil.WriteFile(filepath.Join(dir, file), []byte(data), 0700)

-}

-

-func removePath(p string, err error) error {

-	if err != nil {

-		return err

-	}

-	if p != "" {

-		return os.RemoveAll(p)

-	}

-	return nil

-}

deleted file mode 100644

@@ -1,121 +0,0 @@

-package fs

-

-import (

-	"bufio"

-	"fmt"

-	"io/ioutil"

-	"os"

-	"path/filepath"

-	"strconv"

-	"strings"

-

-	"github.com/dotcloud/docker/pkg/cgroups"

-)

-

-type blkioGroup struct {

-}

-

-func (s *blkioGroup) Set(d *data) error {

-	// we just want to join this group even though we don't set anything

-	if _, err := d.join("blkio"); err != nil && err != cgroups.ErrNotFound {

-		return err

-	}

-	return nil

-}

-

-func (s *blkioGroup) Remove(d *data) error {

-	return removePath(d.path("blkio"))

-}

-

-/*

-examples:

-

-    blkio.sectors

-    8:0 6792

-

-    blkio.io_service_bytes

-    8:0 Read 1282048

-    8:0 Write 2195456

-    8:0 Sync 2195456

-    8:0 Async 1282048

-    8:0 Total 3477504

-    Total 3477504

-

-    blkio.io_serviced

-    8:0 Read 124

-    8:0 Write 104

-    8:0 Sync 104

-    8:0 Async 124

-    8:0 Total 228

-    Total 228

-

-    blkio.io_queued

-    8:0 Read 0

-    8:0 Write 0

-    8:0 Sync 0

-    8:0 Async 0

-    8:0 Total 0

-    Total 0

-*/

-func (s *blkioGroup) Stats(d *data) (map[string]float64, error) {

-	var (

-		paramData = make(map[string]float64)

-		params    = []string{

-			"io_service_bytes_recursive",

-			"io_serviced_recursive",

-			"io_queued_recursive",

-		}

-	)

-

-	path, err := d.path("blkio")

-	if err != nil {

-		return nil, err

-	}

-

-	k, v, err := s.getSectors(path)

-	if err != nil {

-		return nil, err

-	}

-	paramData[fmt.Sprintf("blkio.sectors_recursive:%s", k)] = v

-

-	for _, param := range params {

-		f, err := os.Open(filepath.Join(path, fmt.Sprintf("blkio.%s", param)))

-		if err != nil {

-			return nil, err

-		}

-		defer f.Close()

-

-		sc := bufio.NewScanner(f)

-		for sc.Scan() {

-			// format: dev type amount

-			fields := strings.Fields(sc.Text())

-			switch len(fields) {

-			case 3:

-				v, err := strconv.ParseFloat(fields[2], 64)

-				if err != nil {

-					return nil, err

-				}

-				paramData[fmt.Sprintf("%s:%s:%s", param, fields[0], fields[1])] = v

-			case 2:

-				// this is the total line, skip

-			default:

-				return nil, ErrNotValidFormat

-			}

-		}

-	}

-	return paramData, nil

-}

-

-func (s *blkioGroup) getSectors(path string) (string, float64, error) {

-	f, err := os.Open(filepath.Join(path, "blkio.sectors_recursive"))

-	if err != nil {

-		return "", 0, err

-	}

-	defer f.Close()

-

-	data, err := ioutil.ReadAll(f)

-	if err != nil {

-		return "", 0, err

-	}

-	return getCgroupParamKeyValue(string(data))

-}

deleted file mode 100644

@@ -1,169 +0,0 @@

-package fs

-

-import (

-	"testing"

-)

-

-const (

-	sectorsRecursiveContents      = `8:0 1024`

-	serviceBytesRecursiveContents = `8:0 Read 100

-8:0 Write 400

-8:0 Sync 200

-8:0 Async 300

-8:0 Total 500

-Total 500`

-	servicedRecursiveContents = `8:0 Read 10

-8:0 Write 40

-8:0 Sync 20

-8:0 Async 30

-8:0 Total 50

-Total 50`

-	queuedRecursiveContents = `8:0 Read 1

-8:0 Write 4

-8:0 Sync 2

-8:0 Async 3

-8:0 Total 5

-Total 5`

-)

-

-func TestBlkioStats(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": serviceBytesRecursiveContents,

-		"blkio.io_serviced_recursive":      servicedRecursiveContents,

-		"blkio.io_queued_recursive":        queuedRecursiveContents,

-		"blkio.sectors_recursive":          sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	stats, err := blkio.Stats(helper.CgroupData)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	// Verify expected stats.

-	expectedStats := map[string]float64{

-		"blkio.sectors_recursive:8:0": 1024.0,

-

-		// Serviced bytes.

-		"io_service_bytes_recursive:8:0:Read":  100.0,

-		"io_service_bytes_recursive:8:0:Write": 400.0,

-		"io_service_bytes_recursive:8:0:Sync":  200.0,

-		"io_service_bytes_recursive:8:0:Async": 300.0,

-		"io_service_bytes_recursive:8:0:Total": 500.0,

-

-		// Serviced requests.

-		"io_serviced_recursive:8:0:Read":  10.0,

-		"io_serviced_recursive:8:0:Write": 40.0,

-		"io_serviced_recursive:8:0:Sync":  20.0,

-		"io_serviced_recursive:8:0:Async": 30.0,

-		"io_serviced_recursive:8:0:Total": 50.0,

-

-		// Queued requests.

-		"io_queued_recursive:8:0:Read":  1.0,

-		"io_queued_recursive:8:0:Write": 4.0,

-		"io_queued_recursive:8:0:Sync":  2.0,

-		"io_queued_recursive:8:0:Async": 3.0,

-		"io_queued_recursive:8:0:Total": 5.0,

-	}

-	expectStats(t, expectedStats, stats)

-}

-

-func TestBlkioStatsNoSectorsFile(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": serviceBytesRecursiveContents,

-		"blkio.io_serviced_recursive":      servicedRecursiveContents,

-		"blkio.io_queued_recursive":        queuedRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

-

-func TestBlkioStatsNoServiceBytesFile(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_serviced_recursive": servicedRecursiveContents,

-		"blkio.io_queued_recursive":   queuedRecursiveContents,

-		"blkio.sectors_recursive":     sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

-

-func TestBlkioStatsNoServicedFile(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": serviceBytesRecursiveContents,

-		"blkio.io_queued_recursive":        queuedRecursiveContents,

-		"blkio.sectors_recursive":          sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

-

-func TestBlkioStatsNoQueuedFile(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": serviceBytesRecursiveContents,

-		"blkio.io_serviced_recursive":      servicedRecursiveContents,

-		"blkio.sectors_recursive":          sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

-

-func TestBlkioStatsUnexpectedNumberOfFields(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": "8:0 Read 100 100",

-		"blkio.io_serviced_recursive":      servicedRecursiveContents,

-		"blkio.io_queued_recursive":        queuedRecursiveContents,

-		"blkio.sectors_recursive":          sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

-

-func TestBlkioStatsUnexpectedFieldType(t *testing.T) {

-	helper := NewCgroupTestUtil("blkio", t)

-	defer helper.cleanup()

-	helper.writeFileContents(map[string]string{

-		"blkio.io_service_bytes_recursive": "8:0 Read Write",

-		"blkio.io_serviced_recursive":      servicedRecursiveContents,

-		"blkio.io_queued_recursive":        queuedRecursiveContents,

-		"blkio.sectors_recursive":          sectorsRecursiveContents,

-	})

-

-	blkio := &blkioGroup{}

-	_, err := blkio.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not")

-	}

-}

deleted file mode 100644

@@ -1,64 +0,0 @@

-package fs

-

-import (

-	"bufio"

-	"os"

-	"path/filepath"

-	"strconv"

-)

-

-type cpuGroup struct {

-}

-

-func (s *cpuGroup) Set(d *data) error {

-	// We always want to join the cpu group, to allow fair cpu scheduling

-	// on a container basis

-	dir, err := d.join("cpu")

-	if err != nil {

-		return err

-	}

-	if d.c.CpuShares != 0 {

-		if err := writeFile(dir, "cpu.shares", strconv.FormatInt(d.c.CpuShares, 10)); err != nil {

-			return err

-		}

-	}

-	if d.c.CpuPeriod != 0 {

-		if err := writeFile(dir, "cpu.cfs_period_us", strconv.FormatInt(d.c.CpuPeriod, 10)); err != nil {

-			return err

-		}

-	}

-	if d.c.CpuQuota != 0 {

-		if err := writeFile(dir, "cpu.cfs_quota_us", strconv.FormatInt(d.c.CpuQuota, 10)); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-func (s *cpuGroup) Remove(d *data) error {

-	return removePath(d.path("cpu"))

-}

-

-func (s *cpuGroup) Stats(d *data) (map[string]float64, error) {

-	paramData := make(map[string]float64)

-	path, err := d.path("cpu")

-	if err != nil {

-		return nil, err

-	}

-

-	f, err := os.Open(filepath.Join(path, "cpu.stat"))

-	if err != nil {

-		return nil, err

-	}

-	defer f.Close()

-

-	sc := bufio.NewScanner(f)

-	for sc.Scan() {

-		t, v, err := getCgroupParamKeyValue(sc.Text())

-		if err != nil {

-			return nil, err

-		}

-		paramData[t] = v

-	}

-	return paramData, nil

-}

deleted file mode 100644

@@ -1,57 +0,0 @@

-package fs

-

-import (

-	"testing"

-)

-

-func TestCpuStats(t *testing.T) {

-	helper := NewCgroupTestUtil("cpu", t)

-	defer helper.cleanup()

-	cpuStatContent := `nr_periods 2000

-	nr_throttled 200

-	throttled_time 42424242424`

-	helper.writeFileContents(map[string]string{

-		"cpu.stat": cpuStatContent,

-	})

-

-	cpu := &cpuGroup{}

-	stats, err := cpu.Stats(helper.CgroupData)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	expected_stats := map[string]float64{

-		"nr_periods":     2000.0,

-		"nr_throttled":   200.0,

-		"throttled_time": 42424242424.0,

-	}

-	expectStats(t, expected_stats, stats)

-}

-

-func TestNoCpuStatFile(t *testing.T) {

-	helper := NewCgroupTestUtil("cpu", t)

-	defer helper.cleanup()

-

-	cpu := &cpuGroup{}

-	_, err := cpu.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected to fail, but did not.")

-	}

-}

-

-func TestInvalidCpuStat(t *testing.T) {

-	helper := NewCgroupTestUtil("cpu", t)

-	defer helper.cleanup()

-	cpuStatContent := `nr_periods 2000

-	nr_throttled 200

-	throttled_time fortytwo`

-	helper.writeFileContents(map[string]string{

-		"cpu.stat": cpuStatContent,

-	})

-

-	cpu := &cpuGroup{}

-	_, err := cpu.Stats(helper.CgroupData)

-	if err == nil {

-		t.Fatal("Expected failed stat parsing.")

-	}

-}

deleted file mode 100644

@@ -1,143 +0,0 @@

-package fs

-

-import (

-	"bufio"

-	"fmt"

-	"os"

-	"path/filepath"

-	"runtime"

-	"strconv"

-	"strings"

-	"time"

-

-	"github.com/dotcloud/docker/pkg/cgroups"

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

-)

-

-var (

-	cpuCount   = float64(runtime.NumCPU())

-	clockTicks = float64(system.GetClockTicks())

-)

-

-type cpuacctGroup struct {

-}

-

-func (s *cpuacctGroup) Set(d *data) error {

-	// we just want to join this group even though we don't set anything

-	if _, err := d.join("cpuacct"); err != nil && err != cgroups.ErrNotFound {

-		return err

-	}

-	return nil

-}

-

-func (s *cpuacctGroup) Remove(d *data) error {

-	return removePath(d.path("cpuacct"))

-}

-

-func (s *cpuacctGroup) Stats(d *data) (map[string]float64, error) {

-	var (

-		startCpu, lastCpu, startSystem, lastSystem, startUsage, lastUsage float64

-		percentage                                                        float64

-		paramData                                                         = make(map[string]float64)

-	)

-	path, err := d.path("cpuacct")

-	if startCpu, err = s.getCpuUsage(d, path); err != nil {

-		return nil, err

-	}

-	if startSystem, err = s.getSystemCpuUsage(d); err != nil {

-		return nil, err

-	}

-	startUsageTime := time.Now()

-	if startUsage, err = getCgroupParamFloat64(path, "cpuacct.usage"); err != nil {

-		return nil, err

-	}

-	// sample for 100ms

-	time.Sleep(100 * time.Millisecond)

-	if lastCpu, err = s.getCpuUsage(d, path); err != nil {

-		return nil, err

-	}

-	if lastSystem, err = s.getSystemCpuUsage(d); err != nil {

-		return nil, err

-	}

-	usageSampleDuration := time.Since(startUsageTime)

-	if lastUsage, err = getCgroupParamFloat64(path, "cpuacct.usage"); err != nil {

-		return nil, err

-	}

-

-	var (

-		deltaProc   = lastCpu - startCpu

-		deltaSystem = lastSystem - startSystem

-		deltaUsage  = lastUsage - startUsage

-	)

-	if deltaSystem > 0.0 {

-		percentage = ((deltaProc / deltaSystem) * clockTicks) * cpuCount

-	}

-	// NOTE: a percentage over 100% is valid for POSIX because that means the

-	// processes is using multiple cores

-	paramData["percentage"] = percentage

-

-	// Delta usage is in nanoseconds of CPU time so get the usage (in cores) over the sample time.

-	paramData["usage"] = deltaUsage / float64(usageSampleDuration.Nanoseconds())

-	return paramData, nil

-}

-

-func (s *cpuacctGroup) getProcStarttime(d *data) (float64, error) {

-	rawStart, err := system.GetProcessStartTime(d.pid)

-	if err != nil {

-		return 0, err

-	}

-	return strconv.ParseFloat(rawStart, 64)

-}

-

-func (s *cpuacctGroup) getSystemCpuUsage(d *data) (float64, error) {

-

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

-	if err != nil {

-		return 0, err

-	}

-	defer f.Close()

-

-	sc := bufio.NewScanner(f)

-	for sc.Scan() {

-		parts := strings.Fields(sc.Text())

-		switch parts[0] {

-		case "cpu":

-			if len(parts) < 8 {

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

-			}

-

-			var total float64

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

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

-				if err != nil {

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

-				}

-				total += v

-			}

-			return total, nil

-		default:

-			continue

-		}

-	}

-	return 0, fmt.Errorf("invalid stat format")

-}

-

-func (s *cpuacctGroup) getCpuUsage(d *data, path string) (float64, error) {

-	cpuTotal := 0.0

-	f, err := os.Open(filepath.Join(path, "cpuacct.stat"))

-	if err != nil {

-		return 0.0, err

-	}

-	defer f.Close()

-

-	sc := bufio.NewScanner(f)

-	for sc.Scan() {

-		_, v, err := getCgroupParamKeyValue(sc.Text())

-		if err != nil {

-			return 0.0, err

-		}

-		// set the raw data in map

-		cpuTotal += v

-	}

-	return cpuTotal, nil

-}

deleted file mode 100644

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

-package fs

-

-import (

-	"bytes"

-	"io/ioutil"

-	"os"

-	"path/filepath"

-	"strconv"

-)

-

-type cpusetGroup struct {

-}

-

-func (s *cpusetGroup) Set(d *data) error {

-	// we don't want to join this cgroup unless it is specified

-	if d.c.CpusetCpus != "" {

-		dir, err := d.path("cpuset")

-		if err != nil {

-			return err

-		}

-		if err := s.ensureParent(dir); err != nil {

-			return err

-		}

-

-		// because we are not using d.join we need to place the pid into the procs file

-		// unlike the other subsystems

-		if err := writeFile(dir, "cgroup.procs", strconv.Itoa(d.pid)); err != nil {

-			return err

-		}

-		if err := writeFile(dir, "cpuset.cpus", d.c.CpusetCpus); err != nil {