Golang Container.LimitDisk方法代码示例

func (b *LinuxBackend) ApplyLimits(container garden.Container, limits garden.Limits) error {
	if limits.CPU != (garden.CPULimits{}) {
		if err := container.LimitCPU(limits.CPU); err != nil {
			return err
		}
	}

	if limits.Disk != (garden.DiskLimits{}) {
		if err := container.LimitDisk(limits.Disk); err != nil {
			return err
		}
	}

	if limits.Bandwidth != (garden.BandwidthLimits{}) {
		if err := container.LimitBandwidth(limits.Bandwidth); err != nil {
			return err
		}
	}

	if limits.Memory != (garden.MemoryLimits{}) {
		if err := container.LimitMemory(limits.Memory); err != nil {
			return err
		}
	}

	return nil
}

			BeforeEach(func() {
				fakeConnection.LimitCPUReturns(garden.CPULimits{}, disaster)
			})

			It("returns the error", func() {
				err := container.LimitCPU(garden.CPULimits{})
				Ω(err).Should(Equal(disaster))
			})
		})
	})

	Describe("LimitDisk", func() {
		It("sends a limit bandwidth request", func() {
			err := container.LimitDisk(garden.DiskLimits{
				ByteHard: 1,
			})
			Ω(err).ShouldNot(HaveOccurred())

			handle, limits := fakeConnection.LimitDiskArgsForCall(0)
			Ω(handle).Should(Equal("some-handle"))
			Ω(limits).Should(Equal(garden.DiskLimits{ByteHard: 1}))
		})

		Context("when the request fails", func() {
			disaster := errors.New("oh no!")

			BeforeEach(func() {
				fakeConnection.LimitDiskReturns(garden.DiskLimits{}, disaster)
			})

	Describe("LimitDisk", func() {
		Context("with quotas disabled", func() {
			BeforeEach(func() {
				startGardenArgs = []string{"-disableQuotas=true"}
				rootfs = runner.RootFSPath
				privilegedContainer = true
			})

			Context("and there is a disk limit", func() {
				quotaLimit := garden.DiskLimits{
					ByteSoft: 5 * 1024 * 1024,
					ByteHard: 5 * 1024 * 1024,
				}

				JustBeforeEach(func() {
					Expect(container.LimitDisk(quotaLimit)).To(Succeed())
				})

				It("reports the disk limit size of the container as zero", func() {
					limit, err := container.CurrentDiskLimits()
					Expect(err).ToNot(HaveOccurred())
					Expect(limit).To(Equal(garden.DiskLimits{}))
				})

				Context("and it runs a process that exceeds the limit", func() {
					It("does not kill the process", func() {
						dd, err := container.Run(garden.ProcessSpec{
							User: "alice",
							Path: "dd",
							Args: []string{"if=/dev/zero", "of=/tmp/some-file", "bs=1M", "count=6"},
						}, garden.ProcessIO{})

				close(done)
			}, 10.0)
		})

		Describe("disk limits", func() {
			var container garden.Container

			AfterEach(func() {
				err := client.Destroy(container.Handle())
				Expect(err).ShouldNot(HaveOccurred())
			})

			It("generated data is enforced", func() {
				container = createDefaultContainer()
				limitInBytes := uint64(15 * 1024 * 1024)
				err := container.LimitDisk(garden.DiskLimits{ByteHard: limitInBytes})
				Expect(err).ShouldNot(HaveOccurred())

				buf := make([]byte, 0, 1024*1024)
				stdout := bytes.NewBuffer(buf)

				process, err := container.Run(garden.ProcessSpec{
					Path: "bin/consume.exe",
					Args: []string{"disk", "10"},
				}, garden.ProcessIO{Stdout: stdout})
				Expect(err).ShouldNot(HaveOccurred())

				exitCode, err := process.Wait()
				Expect(err).ShouldNot(HaveOccurred())
				Expect(stdout.String()).To(ContainSubstring("Consumed:  3 mb"))
				Expect(stdout.String()).NotTo(ContainSubstring("Consumed:  10 mb"))

			BeforeEach(func() {
				setLimits = garden.DiskLimits{
					BlockSoft: 111,
					BlockHard: 222,

					InodeSoft: 333,
					InodeHard: 444,

					ByteSoft: 555,
					ByteHard: 666,
				}
			})

			It("sets the container's disk limits and returns the current limits", func() {
				err := container.LimitDisk(setLimits)
				Ω(err).ShouldNot(HaveOccurred())

				Ω(fakeContainer.LimitDiskArgsForCall(0)).Should(Equal(setLimits))
			})

			itResetsGraceTimeWhenHandling(func() {
				err := container.LimitDisk(setLimits)
				Ω(err).ShouldNot(HaveOccurred())
			})

			itFailsWhenTheContainerIsNotFound(func() error {
				return container.LimitDisk(garden.DiskLimits{})
			})

			Context("when limiting the disk fails", func() {

					ghttp.CombineHandlers(
						ghttp.VerifyRequest("POST", "/api/containers/containerhandle/disk_limit"),
						ghttp.RespondWith(200, `{}`),
						func(w http.ResponseWriter, req *http.Request) {
							body, err := ioutil.ReadAll(req.Body)
							req.Body.Close()
							Expect(err).ShouldNot(HaveOccurred())
							requestBody = string(body)
						},
					),
				)
			})

			It("sets limits on the container", func() {
				limit := garden.DiskLimits{ByteHard: 555}
				err := container.LimitDisk(limit)
				Expect(err).NotTo(HaveOccurred())

				Expect(server.ReceivedRequests()).Should(HaveLen(1))
				Expect(requestBody).Should(Equal(`{"byte_hard":555}`))
			})
		})

		Context("Containerizer returns non 200", func() {
			BeforeEach(func() {
				server.AppendHandlers(
					ghttp.CombineHandlers(
						ghttp.VerifyRequest("POST", "/api/containers/containerhandle/disk_limit"),
						ghttp.RespondWith(500, "{}"),
					),
				)