func (c *CakeOrdinator) Destroy(logger lager.Logger, id, rootfs string) error {
cid := layercake.ContainerID(id)
if _, err := c.cake.Get(cid); err != nil {
logger.Info("layer-already-deleted-skipping", lager.Data{"id": id, "graphID": cid, "error": err.Error()})
return nil
}
return c.cake.Remove(cid)
}
func (provider *ContainerLayerCreator) Create(log lager.Logger, id string, parentImage *repository_fetcher.Image, spec Spec) (string, []string, error) {
var err error
var imageID layercake.ID = layercake.DockerImageID(parentImage.ImageID)
if spec.Namespaced {
provider.mutex.Lock()
imageID, err = provider.namespace(log, imageID)
provider.mutex.Unlock()
if err != nil {
return "", nil, err
}
}
containerID := layercake.ContainerID(id)
if err := provider.graph.Create(containerID, imageID, id); err != nil {
return "", nil, err
}
var rootPath string
if spec.QuotaSize > 0 && spec.QuotaScope == garden.DiskLimitScopeExclusive {
rootPath, err = provider.graph.QuotaedPath(containerID, spec.QuotaSize)
} else if spec.QuotaSize > 0 && spec.QuotaScope == garden.DiskLimitScopeTotal {
rootPath, err = provider.graph.QuotaedPath(containerID, spec.QuotaSize-parentImage.Size)
} else {
rootPath, err = provider.graph.Path(containerID)
}
if err != nil {
return "", nil, err
}
for _, v := range parentImage.Volumes {
if err = provider.volumeCreator.Create(rootPath, v); err != nil {
return "", nil, err
}
}
return rootPath, parentImage.Env, nil
}
func (c *CakeOrdinator) Metrics(logger lager.Logger, id, _ string) (garden.ContainerDiskStat, error) {
cid := layercake.ContainerID(id)
return c.metrics.Metrics(logger, cid)
}
Expect(diskQuota).To(BeNumerically("==", 33))
})
})
})
Describe("Metrics", func() {
It("delegates metrics retrieval to the metricser", func() {
fakeMetrics.MetricsReturns(garden.ContainerDiskStat{
TotalBytesUsed: 12,
}, nil)
metrics, err := cakeOrdinator.Metrics(logger, "something", "")
Expect(err).NotTo(HaveOccurred())
_, path := fakeMetrics.MetricsArgsForCall(0)
Expect(path).To(Equal(layercake.ContainerID("something")))
Expect(metrics).To(Equal(garden.ContainerDiskStat{
TotalBytesUsed: 12,
}))
})
Context("when it fails to get the metrics", func() {
BeforeEach(func() {
fakeMetrics.MetricsReturns(garden.ContainerDiskStat{}, errors.New("rotten banana"))
})
It("should return an error", func() {
_, err := cakeOrdinator.Metrics(logger, "something", "")
Expect(err).To(MatchError("rotten banana"))
})
Driver: driver,
}
})
AfterEach(func() {
Expect(syscall.Unmount(root, 0)).To(Succeed())
Expect(os.RemoveAll(root)).To(Succeed())
})
Describe("Register", func() {
Context("after registering a layer", func() {
var id layercake.ID
var parent layercake.ID
BeforeEach(func() {
id = layercake.ContainerID("")
parent = layercake.ContainerID("")
})
ItCanReadWriteTheLayer := func() {
It("can read and write files", func() {
p, err := cake.Path(id)
Expect(err).NotTo(HaveOccurred())
Expect(ioutil.WriteFile(path.Join(p, "foo"), []byte("hi"), 0700)).To(Succeed())
p, err = cake.Path(id)
Expect(err).NotTo(HaveOccurred())
Expect(path.Join(p, "foo")).To(BeAnExistingFile())
})
It("can get back the image", func() {
lagertest.NewTestLogger("test"),
"some-id",
&repository_fetcher.Image{
ImageID: "some-image-id",
Env: []string{"env1=env1value", "env2=env2value"},
},
rootfs_provider.Spec{
Namespaced: false,
QuotaSize: 0,
},
)
Expect(err).ToNot(HaveOccurred())
Expect(fakeCake.CreateCallCount()).To(Equal(1))
id, parent, containerID := fakeCake.CreateArgsForCall(0)
Expect(id).To(Equal(layercake.ContainerID("some-id")))
Expect(parent).To(Equal(layercake.DockerImageID("some-image-id")))
Expect(containerID).To(Equal("some-id"))
Expect(mountpoint).To(Equal("/some/graph/driver/mount/point"))
Expect(envvars).To(Equal(
[]string{
"env1=env1value",
"env2=env2value",
},
))
})
})
Context("when the quota is positive", func() {
It("should return the quotaed mount point path", func() {