func (p *LinuxContainerPool) Restore(snapshot io.Reader) (linux_backend.Container, error) {
var containerSnapshot linux_backend.ContainerSnapshot
err := json.NewDecoder(snapshot).Decode(&containerSnapshot)
if err != nil {
return nil, err
}
id := containerSnapshot.ID
log.Println("restoring", id)
resources := containerSnapshot.Resources
err = p.uidPool.Remove(resources.UID)
if err != nil {
return nil, err
}
err = p.networkPool.Remove(resources.Network)
if err != nil {
p.uidPool.Release(resources.UID)
return nil, err
}
for _, port := range resources.Ports {
err = p.portPool.Remove(port)
if err != nil {
p.uidPool.Release(resources.UID)
p.networkPool.Release(resources.Network)
for _, port := range resources.Ports {
p.portPool.Release(port)
}
return nil, err
}
}
containerPath := path.Join(p.depotPath, id)
cgroupsManager := cgroups_manager.New("/tmp/warden/cgroup", id)
bandwidthManager := bandwidth_manager.New(containerPath, id, p.runner)
container := linux_backend.NewLinuxContainer(
id,
containerSnapshot.Handle,
containerPath,
containerSnapshot.Properties,
containerSnapshot.GraceTime,
linux_backend.NewResources(
resources.UID,
resources.Network,
resources.Ports,
),
p.portPool,
p.runner,
cgroupsManager,
p.quotaManager,
bandwidthManager,
)
err = container.Restore(containerSnapshot)
if err != nil {
return nil, err
}
return container, nil
}
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/cloudfoundry-incubator/garden/warden"
"github.com/cloudfoundry-incubator/warden-linux/linux_backend/bandwidth_manager"
"github.com/cloudfoundry/gunk/command_runner/fake_command_runner"
. "github.com/cloudfoundry/gunk/command_runner/fake_command_runner/matchers"
)
var fakeRunner *fake_command_runner.FakeCommandRunner
var bandwidthManager *bandwidth_manager.ContainerBandwidthManager
var _ = Describe("setting rate limits", func() {
BeforeEach(func() {
fakeRunner = fake_command_runner.New()
bandwidthManager = bandwidth_manager.New("/depot/some-id", "some-id", fakeRunner)
})
It("executes net_rate.sh with the appropriate environment", func() {
limits := warden.BandwidthLimits{
RateInBytesPerSecond: 128,
BurstRateInBytesPerSecond: 256,
}
err := bandwidthManager.SetLimits(limits)
Expect(err).ToNot(HaveOccurred())
Expect(fakeRunner).To(HaveExecutedSerially(
fake_command_runner.CommandSpec{
Path: "/depot/some-id/net_rate.sh",
Env: []string{
func (p *LinuxContainerPool) Create(spec warden.ContainerSpec) (linux_backend.Container, error) {
uid, err := p.uidPool.Acquire()
if err != nil {
return nil, err
}
network, err := p.networkPool.Acquire()
if err != nil {
p.uidPool.Release(uid)
return nil, err
}
id := <-p.containerIDs
containerPath := path.Join(p.depotPath, id)
cgroupsManager := cgroups_manager.New("/tmp/warden/cgroup", id)
bandwidthManager := bandwidth_manager.New(containerPath, id, p.runner)
handle := id
if spec.Handle != "" {
handle = spec.Handle
}
container := linux_backend.NewLinuxContainer(
id,
handle,
containerPath,
spec.Properties,
spec.GraceTime,
linux_backend.NewResources(uid, network, []uint32{}),
p.portPool,
p.runner,
cgroupsManager,
p.quotaManager,
bandwidthManager,
)
create := &exec.Cmd{
Path: path.Join(p.binPath, "create.sh"),
Args: []string{containerPath},
Env: []string{
"id=" + container.ID(),
"rootfs_path=" + p.rootFSPath,
fmt.Sprintf("user_uid=%d", uid),
fmt.Sprintf("network_host_ip=%s", network.HostIP()),
fmt.Sprintf("network_container_ip=%s", network.ContainerIP()),
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
},
}
err = p.runner.Run(create)
if err != nil {
p.uidPool.Release(uid)
p.networkPool.Release(network)
return nil, err
}
err = p.writeBindMounts(containerPath, spec.BindMounts)
if err != nil {
return nil, err
}
return container, nil
}
func (p *LinuxContainerPool) Create(spec warden.ContainerSpec) (linux_backend.Container, error) {
uid, err := p.uidPool.Acquire()
if err != nil {
return nil, err
}
network, err := p.networkPool.Acquire()
if err != nil {
p.uidPool.Release(uid)
return nil, err
}
id := <-p.containerIDs
containerPath := path.Join(p.depotPath, id)
cgroupsManager := cgroups_manager.New("/tmp/warden/cgroup", id)
bandwidthManager := bandwidth_manager.New(containerPath, id, p.runner)
handle := id
if spec.Handle != "" {
handle = spec.Handle
}
rootFSPath := p.rootFSPath
rootFSRaw := false
if strings.HasPrefix(spec.RootFSPath, imagePrefix) {
repoSegments := strings.SplitN(spec.RootFSPath[len(imagePrefix):], ":", 2)
repoName := repoSegments[0]
tag := "latest"
if len(repoSegments) >= 2 {
tag = repoSegments[1]
}
imageID, err := p.repoFetcher.Fetch(repoName, tag)
if err != nil {
return nil, err
}
err = p.graphDriver.Create(id, imageID)
if err != nil {
return nil, err
}
rootFSPath, err = p.graphDriver.Get(id, "")
if err != nil {
return nil, err
}
rootFSRaw = true
} else if spec.RootFSPath != "" {
rootFSPath = spec.RootFSPath
}
container := linux_backend.NewLinuxContainer(
id,
handle,
containerPath,
spec.Properties,
spec.GraceTime,
linux_backend.NewResources(uid, network, []uint32{}),
p.portPool,
p.runner,
cgroupsManager,
p.quotaManager,
bandwidthManager,
)
create := &exec.Cmd{
Path: path.Join(p.binPath, "create.sh"),
Args: []string{containerPath},
Env: []string{
"id=" + container.ID(),
"rootfs_path=" + rootFSPath,
fmt.Sprintf("rootfs_raw=%v", rootFSRaw),
fmt.Sprintf("user_uid=%d", uid),
fmt.Sprintf("network_host_ip=%s", network.HostIP()),
fmt.Sprintf("network_container_ip=%s", network.ContainerIP()),
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
},
}
err = p.runner.Run(create)
if err != nil {
p.uidPool.Release(uid)
p.networkPool.Release(network)
return nil, err
}
err = p.writeBindMounts(containerPath, spec.BindMounts)
if err != nil {
return nil, err
}
return container, nil
}