kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Update libcontainer to db65c35051d05f3fb218a0e84a1

Browse source 
Signed-off-by: Michael Crosby <michael@docker.com>
This commit is contained in:
Michael Crosby 2014-08-20 11:19:55 -07:00
parent 997336fd95
commit 624b944896
10 changed files with 76 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
hack/vendor.sh
View file

@ -59,7 +59,7 @@ rm -rf src/code.google.com/p/go
mkdir -p src/code.google.com/p/go/src/pkg/archive
mv tmp-tar src/code.google.com/p/go/src/pkg/archive/tar
clone git github.com/docker/libcontainer 29363e2d2d7b8f62a5f353be333758f83df540a9
clone git github.com/docker/libcontainer db65c35051d05f3fb218a0e84a11267e0894fe0a
# see src/github.com/docker/libcontainer/update-vendor.sh which is the "source of truth" for libcontainer deps (just like this file)
rm -rf src/github.com/docker/libcontainer/vendor
eval "$(grep '^clone ' src/github.com/docker/libcontainer/update-vendor.sh | grep -v 'github.com/codegangsta/cli')"

29
vendor/src/github.com/docker/libcontainer/cgroups/cgroups.go vendored
View file

@ -1,15 +1,11 @@
package cgroups
import (
"errors"
"fmt"
"github.com/docker/libcontainer/devices"
)
var (
ErrNotFound = errors.New("mountpoint not found")
)
type FreezerState string
const (
@ -18,6 +14,29 @@ const (
Thawed FreezerState = "THAWED"
)
type NotFoundError struct {
Subsystem string
}
func (e *NotFoundError) Error() string {
return fmt.Sprintf("mountpoint for %s not found", e.Subsystem)
}
func NewNotFoundError(sub string) error {
return &NotFoundError{
Subsystem: sub,
}
}
func IsNotFound(err error) bool {
if err == nil {
return false
}
_, ok := err.(*NotFoundError)
return ok
}
type Cgroup struct {
Name string `json:"name,omitempty"`
Parent string `json:"parent,omitempty"` // name of parent cgroup or slice

24
vendor/src/github.com/docker/libcontainer/cgroups/fs/apply_raw.go vendored
View file

@ -76,7 +76,7 @@ func GetStats(c *cgroups.Cgroup) (*cgroups.Stats, error) {
path, err := d.path(sysname)
if err != nil {
// Don't fail if a cgroup hierarchy was not found, just skip this subsystem
if err == cgroups.ErrNotFound {
if cgroups.IsNotFound(err) {
continue
}
@ -155,25 +155,45 @@ func (raw *data) parent(subsystem string) (string, error) {
func (raw *data) Paths() (map[string]string, error) {
paths := make(map[string]string)
for sysname := range subsystems {
path, err := raw.path(sysname)
if err != nil {
// Don't fail if a cgroup hierarchy was not found, just skip this subsystem
if cgroups.IsNotFound(err) {
continue
}
return nil, err
}
paths[sysname] = path
}
return paths, nil
}
func (raw *data) path(subsystem string) (string, error) {
// If the cgroup name/path is absolute do not look relative to the cgroup of the init process.
if filepath.IsAbs(raw.cgroup) {
return filepath.Join(raw.root, subsystem, raw.cgroup), nil
path := filepath.Join(raw.root, subsystem, raw.cgroup)
if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
return "", cgroups.NewNotFoundError(subsystem)
}
return "", err
}
return path, nil
}
parent, err := raw.parent(subsystem)
if err != nil {
return "", err
}
return filepath.Join(parent, raw.cgroup), nil
}

3
vendor/src/github.com/docker/libcontainer/cgroups/fs/blkio.go vendored
View file

@ -16,9 +16,10 @@ 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 {
if _, err := d.join("blkio"); err != nil && !cgroups.IsNotFound(err) {
return err
}
return nil
}

3
vendor/src/github.com/docker/libcontainer/cgroups/fs/cpuacct.go vendored
View file

@ -27,9 +27,10 @@ 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 {
if _, err := d.join("cpuacct"); err != nil && !cgroups.IsNotFound(err) {
return err
}
return nil
}

2
vendor/src/github.com/docker/libcontainer/cgroups/fs/freezer.go vendored
View file

@ -33,7 +33,7 @@ func (s *FreezerGroup) Set(d *data) error {
time.Sleep(1 * time.Millisecond)
}
default:
if _, err := d.join("freezer"); err != nil && err != cgroups.ErrNotFound {
if _, err := d.join("freezer"); err != nil && !cgroups.IsNotFound(err) {
return err
}
}

2
vendor/src/github.com/docker/libcontainer/cgroups/fs/perf_event.go vendored
View file

@ -9,7 +9,7 @@ type PerfEventGroup struct {
func (s *PerfEventGroup) Set(d *data) error {
// we just want to join this group even though we don't set anything
if _, err := d.join("perf_event"); err != nil && err != cgroups.ErrNotFound {
if _, err := d.join("perf_event"); err != nil && !cgroups.IsNotFound(err) {
return err
}
return nil

19
vendor/src/github.com/docker/libcontainer/cgroups/fs/utils_test.go vendored
View file

@ -5,8 +5,6 @@ import (
"os"
"path/filepath"
"testing"
"github.com/docker/libcontainer/cgroups"
)
const (
@ -68,20 +66,3 @@ func TestGetCgroupParamsInt(t *testing.T) {
t.Fatal("Expecting error, got none")
}
}
func TestAbsolutePathHandling(t *testing.T) {
testCgroup := cgroups.Cgroup{
Name: "bar",
Parent: "/foo",
}
cgroupData := data{
root: "/sys/fs/cgroup",
cgroup: "/foo/bar",
c: &testCgroup,
pid: 1,
}
expectedPath := filepath.Join(cgroupData.root, "cpu", testCgroup.Parent, testCgroup.Name)
if path, err := cgroupData.path("cpu"); path != expectedPath || err != nil {
t.Fatalf("expected path %s but got %s %s", expectedPath, path, err)
}
}

32
vendor/src/github.com/docker/libcontainer/cgroups/systemd/apply_systemd.go vendored
View file

@ -13,8 +13,7 @@ import (
"sync"
"time"
systemd1 "github.com/coreos/go-systemd/dbus"
"github.com/docker/docker/pkg/systemd"
systemd "github.com/coreos/go-systemd/dbus"
"github.com/docker/libcontainer/cgroups"
"github.com/docker/libcontainer/cgroups/fs"
"github.com/godbus/dbus"
@ -30,7 +29,7 @@ type subsystem interface {
var (
connLock sync.Mutex
theConn *systemd1.Conn
theConn *systemd.Conn
hasStartTransientUnit bool
subsystems = map[string]subsystem{
"devices": &fs.DevicesGroup{},
@ -45,7 +44,8 @@ var (
)
func UseSystemd() bool {
if !systemd.SdBooted() {
s, err := os.Stat("/run/systemd/system")
if err != nil || !s.IsDir() {
return false
}
@ -54,7 +54,7 @@ func UseSystemd() bool {
if theConn == nil {
var err error
theConn, err = systemd1.New()
theConn, err = systemd.New()
if err != nil {
return false
}
@ -88,7 +88,7 @@ func Apply(c *cgroups.Cgroup, pid int) (cgroups.ActiveCgroup, error) {
var (
unitName = getUnitName(c)
slice = "system.slice"
properties []systemd1.Property
properties []systemd.Property
res = &systemdCgroup{}
)
@ -99,27 +99,27 @@ func Apply(c *cgroups.Cgroup, pid int) (cgroups.ActiveCgroup, error) {
}
properties = append(properties,
systemd1.Property{"Slice", dbus.MakeVariant(slice)},
systemd1.Property{"Description", dbus.MakeVariant("docker container " + c.Name)},
systemd1.Property{"PIDs", dbus.MakeVariant([]uint32{uint32(pid)})},
systemd.Property{"Slice", dbus.MakeVariant(slice)},
systemd.Property{"Description", dbus.MakeVariant("docker container " + c.Name)},
systemd.Property{"PIDs", dbus.MakeVariant([]uint32{uint32(pid)})},
)
// Always enable accounting, this gets us the same behaviour as the fs implementation,
// plus the kernel has some problems with joining the memory cgroup at a later time.
properties = append(properties,
systemd1.Property{"MemoryAccounting", dbus.MakeVariant(true)},
systemd1.Property{"CPUAccounting", dbus.MakeVariant(true)},
systemd1.Property{"BlockIOAccounting", dbus.MakeVariant(true)})
systemd.Property{"MemoryAccounting", dbus.MakeVariant(true)},
systemd.Property{"CPUAccounting", dbus.MakeVariant(true)},
systemd.Property{"BlockIOAccounting", dbus.MakeVariant(true)})
if c.Memory != 0 {
properties = append(properties,
systemd1.Property{"MemoryLimit", dbus.MakeVariant(uint64(c.Memory))})
systemd.Property{"MemoryLimit", dbus.MakeVariant(uint64(c.Memory))})
}
// TODO: MemoryReservation and MemorySwap not available in systemd
if c.CpuShares != 0 {
properties = append(properties,
systemd1.Property{"CPUShares", dbus.MakeVariant(uint64(c.CpuShares))})
systemd.Property{"CPUShares", dbus.MakeVariant(uint64(c.CpuShares))})
}
if _, err := theConn.StartTransientUnit(unitName, "replace", properties...); err != nil {
@ -166,7 +166,7 @@ func (c *systemdCgroup) Paths() (map[string]string, error) {
subsystemPath, err := getSubsystemPath(c.cgroup, sysname)
if err != nil {
// Don't fail if a cgroup hierarchy was not found, just skip this subsystem
if err == cgroups.ErrNotFound {
if cgroups.IsNotFound(err) {
continue
}
@ -274,7 +274,7 @@ func GetStats(c *cgroups.Cgroup) (*cgroups.Stats, error) {
subsystemPath, err := getSubsystemPath(c, sysname)
if err != nil {
// Don't fail if a cgroup hierarchy was not found, just skip this subsystem
if err == cgroups.ErrNotFound {
if cgroups.IsNotFound(err) {
continue
}

9
vendor/src/github.com/docker/libcontainer/cgroups/utils.go vendored
View file

@ -29,7 +29,8 @@ func FindCgroupMountpoint(subsystem string) (string, error) {
}
}
}
return "", ErrNotFound
return "", NewNotFoundError(subsystem)
}
type Mount struct {
@ -153,19 +154,23 @@ func ReadProcsFile(dir string) ([]int, error) {
func parseCgroupFile(subsystem string, r io.Reader) (string, error) {
s := bufio.NewScanner(r)
for s.Scan() {
if err := s.Err(); err != nil {
return "", err
}
text := s.Text()
parts := strings.Split(text, ":")
for _, subs := range strings.Split(parts[1], ",") {
if subs == subsystem {
return parts[2], nil
}
}
}
return "", ErrNotFound
return "", NewNotFoundError(subsystem)
}
func pathExists(path string) bool {