Merge pull request #16 from thediveo/develop

implements #15

Author: thediveo

README.md

@@ -7,7 +7,7 @@
 ![build and test](https://github.com/thediveo/morbyd/actions/workflows/buildandtest.yaml/badge.svg?branch=master)
 ![goroutines](https://img.shields.io/badge/go%20routines-not%20leaking-success)
 [![Go Report Card](https://goreportcard.com/badge/github.com/thediveo/morbyd)](https://goreportcard.com/report/github.com/thediveo/morbyd)
-![Coverage](https://img.shields.io/badge/Coverage-98.7%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-98.6%25-brightgreen)
 
 `morbyd` is a thin layer on top of the standard Docker Go client to easily build
 and run throw-away test Docker images and containers. And to easily run commands

container.go

@@ -135,6 +135,16 @@ func (c *Container) PID(ctx context.Context) (int, error) {
 	}
 }
 
+// Pause the container.
+func (c *Container) Pause(ctx context.Context) error {
+	return c.Session.moby.ContainerPause(ctx, c.ID)
+}
+
+// Unpause the container.
+func (c *Container) Unpause(ctx context.Context) error {
+	return c.Session.moby.ContainerUnpause(ctx, c.ID)
+}
+
 // Stop the container by sending it a termination signal. Default is SIGTERM,
 // unless changed using [run.WithStopSignal].
 func (c *Container) Stop(ctx context.Context) {

container_test.go

@@ -57,6 +57,23 @@ var _ = Describe("containers", Ordered, func() {
 		Expect(time.Since(start)).To(BeNumerically(">=", 4*time.Second))
 	})
 
+	It("pauses and unpauses a container", func(ctx context.Context) {
+		cntr := Successful(sess.Run(ctx, "busybox",
+			run.WithCommand("/bin/sh", "-c", "while true; do sleep 1; done"),
+			run.WithAutoRemove(),
+			run.WithCombinedOutput(timestamper.New(GinkgoWriter)),
+		))
+		Expect(cntr.PID(ctx)).Error().NotTo(HaveOccurred())
+
+		Expect(cntr.Pause(ctx)).To(Succeed())
+		Expect(cntr.Refresh(ctx)).To(Succeed())
+		Expect(cntr.Details.State.Paused).To(BeTrue())
+
+		Expect(cntr.Unpause(ctx)).To(Succeed())
+		Expect(cntr.Refresh(ctx)).To(Succeed())
+		Expect(cntr.Details.State.Paused).To(BeFalse())
+	})
+
 	It("stops a container cooperatively", func(ctx context.Context) {
 		var buff safe.Buffer
 

morbyd.code-workspace

@@ -11,6 +11,27 @@
 			"-v",
 			"-race",
 			"--ginkgo.no-color"
+		],
+		"statsBar.memoUsage.format": "$(chip) ${used}/${total} ${unit}, ${percent}%",
+		"statsBar.location": "Right",
+	},
+	"launch": {
+		"version": "0.2.0",
+		"configurations": [
+			{
+				"name": "Debug/Test Package",
+				"type": "go",
+				"request": "launch",
+				"mode": "auto",
+				"program": "${fileDirname}"
+			}
+		],
+		"compounds": []
+	},
+	"extensions": {
+		"recommendations": [
+			"ms-vscode.live-server",
+			"njzy.stats-bar"
 		]
 	}
 }

registry_test.go

@@ -17,6 +17,7 @@ package morbyd
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"time"
 
 	"github.com/thediveo/morbyd/pull"
@@ -51,10 +52,23 @@ var _ = Describe("given a (local) registry", Ordered, Serial, func() {
 			sess.Close(ctx)
 		})
 		By("starting a local container registry")
-		_ = Successful(sess.Run(ctx, "registry:2",
+		Expect(sess.Run(ctx, "registry:2",
 			run.WithName("local-registry"),
 			run.WithPublishedPort(fmt.Sprintf("127.0.0.1:%d:5000", registryPort)),
-			run.WithAutoRemove()))
+			run.WithAutoRemove())).Error().NotTo(HaveOccurred())
+		By("waiting for the registry to become operational")
+		Eventually(func() error {
+			resp, err := http.Get(fmt.Sprintf("http://127.0.0.1:%d/v2/", registryPort))
+			if err != nil {
+				return err
+			}
+			defer resp.Body.Close()
+			if resp.StatusCode != http.StatusOK {
+				return fmt.Errorf("HTTP status code %d", resp.StatusCode)
+			}
+			return nil
+		}).Within(5 * time.Second).ProbeEvery(250 * time.Millisecond).
+			Should(Succeed())
 	})
 
 	BeforeEach(func(ctx context.Context) {

run/doc.go

@@ -1,4 +1,11 @@
 /*
 Package run provides configuration options for running containers.
+
+In many cases, Docker's documentation on [docker container run] and the
+[containers/create API endpoint] can give useful hints as to what various API
+configuration settings might do.
+
+[docker container run]: https://docs.docker.com/reference/cli/docker/container/run/
+[containers/create API endpoint]: https://docs.docker.com/reference/api/engine/version/v1.39/#tag/Container/operation/ContainerCreate
 */
 package run

run/options.go

@@ -632,6 +632,37 @@ func WithAllPortsPublished() Opt {
 	}
 }
 
+// WithCPUSet configures the [set of CPUs] on which processes of the container
+// are allowed to execute. The list of CPUs is a comma-separated list of CPU
+// numbers and ranges of numbers, where the numbers are decimal numbers. For
+// instance, “1,3,5”, "0-42,666", et cetera.
+//
+// To avoid stuttering this option is simply named “WithCPUSet” instead of
+// “WithCpusetCPUs”, or similar awkward letter salads.
+//
+// [set of CPUs]: https://man7.org/linux/man-pages/man7/cpuset.7.html
+func WithCPUSet(cpulist string) Opt {
+	return func(o *Options) error {
+		o.Host.CpusetCpus = cpulist
+		return nil
+	}
+}
+
+// WithMems configures the [set of memory nodes] on which processes of the
+// container are allowed to allocate memory. The list of memory nodes is a
+// comma-separated list of memory node numbers and ranges of numbers, where the
+// numbers are decimal numbers. For instance, “1,3,5”, "0-42,666", et cetera.
+//
+// [set of memory nodes]: https://man7.org/linux/man-pages/man7/cpuset.7.html
+func WithMems(memlist string) Opt {
+	return func(o *Options) error {
+		o.Host.CpusetMems = memlist
+		return nil
+	}
+}
+
+// WithCustomInit instructs Docker to run an init inside the container that
+// forwards signals and reaps processes.
 func WithCustomInit() Opt {
 	return func(o *Options) error {
 		customInit := true

run/options_test.go

@@ -112,6 +112,8 @@ var _ = Describe("run (container) options", func() {
 			WithPublishedPort("[fe80::dead:beef]:2345:1234"),
 			WithPublishedPort("127.0.0.1:1234"),
 			WithPublishedPort("127.0.0.2:12345/udp"),
+			WithCPUSet("1,3,5,99"),
+			WithMems("6,66"),
 			WithCustomInit(),
 		)
 
@@ -167,6 +169,8 @@ var _ = Describe("run (container) options", func() {
 			nat.Port("12345/udp"),
 			ConsistOf(nat.PortBinding{HostIP: "127.0.0.2", HostPort: "0"})))
 
+		Expect(o.Host.CpusetCpus).To(Equal("1,3,5,99"))
+		Expect(o.Host.CpusetMems).To(Equal("6,66"))
 		Expect(o.Host.Init).To(gstruct.PointTo(BeTrue()))
 
 		o = opts(WithLabel("foo=bar"))