Golang garden.Client類代碼示例

func cleanupContainers(client garden.Client) {
	containers, err := client.Containers(nil)
	if err != nil {
		panic(err)
	}

	for _, container := range containers {
		err = client.Destroy(container.Handle())
		if err != nil {
			panic(err)
		}
	}

	listContainers(client)
}

func listContainers(client garden.Client) {
	containers, err := client.Containers(nil)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Current containers: \n")
	for _, c := range containers {
		fmt.Printf("\t%+v\n", c)
	}
}

func CleanupGarden(gardenClient garden.Client) []error {
	containers, err := gardenClient.Containers(nil)
	Expect(err).NotTo(HaveOccurred())

	fmt.Fprintf(ginkgo.GinkgoWriter, "cleaning up %d Garden containers", len(containers))

	// even if containers fail to destroy, stop garden, but still report the
	// errors
	destroyContainerErrors := []error{}
	for _, container := range containers {
		info, _ := container.Info()

		fmt.Fprintf(ginkgo.GinkgoWriter, "cleaning up container %s (%s)", container.Handle(), info.ContainerPath)

	RETRY_LOOP:
		// try to Destroy the container up to 3 times
		for i := 0; i < 3; i++ {
			err := gardenClient.Destroy(container.Handle())
			switch {
			case err == nil:
				// move on if Destroy succeeds
				break RETRY_LOOP
			case strings.Contains(err.Error(), "unknown handle"):
				// move on if container doesn't exist
				break RETRY_LOOP
			case strings.Contains(err.Error(), "container already being destroyed"):
				// move on if container is already being destroyed
				break RETRY_LOOP
			case i == 2:
				// record an error if Destroy failed 3 times
				destroyContainerErrors = append(destroyContainerErrors, err)
			default:
				// try Destroy again otherwise
				time.Sleep(50 * time.Millisecond)
			}
		}
	}

	return destroyContainerErrors
}

func createContainer(gardenClient garden.Client) (string, error) {
	container, err := gardenClient.Create(garden.ContainerSpec{})
	if err != nil {
		return "", err
	}

	processSpec := garden.ProcessSpec{
		Path: "sleep",
		Args: []string{"1000000"},
		User: "root",
	}
	processIO := garden.ProcessIO{}
	_, err = container.Run(processSpec, processIO)
	if err != nil {
		panic(err)
	}

	handle := container.Handle()
	fmt.Println(handle)

	return handle, nil
}

func (exchanger exchanger) Infos(logger lager.Logger, gardenClient garden.Client, gardenContainers []garden.Container) ([]executor.Container, error) {
	handles := make([]string, 0, len(gardenContainers))
	for _, c := range gardenContainers {
		handles = append(handles, c.Handle())
	}
	logger = logger.Session("infos", lager.Data{"handles": handles})

	logger.Debug("get-bulk-info")
	infos, err := gardenClient.BulkInfo(handles)
	if err != nil {
		logger.Error("failed-bulk-info", err)
		return []executor.Container{}, err
	}
	logger.Debug("succeeded-bulk-info")

	var containerInfos []executor.Container

	for handle, info := range infos {
		if info.Err != nil {
			logger.Error("failed-garden-info", info.Err, lager.Data{
				"handle": handle,
			})
			continue
		}

		container, err := garden2executor(handle, info.Info)
		if err != nil {
			logger.Error("failed-garden2executor", err, lager.Data{
				"handle": handle,
			})
			continue
		}

		containerInfos = append(containerInfos, container)
	}

	return containerInfos, nil
}

func destroyContainers(gardenClient garden.Client, containersFetcher *executorContainers, logger lager.Logger) {
	logger.Info("executor-fetching-containers-to-destroy")
	containers, err := containersFetcher.Containers()
	if err != nil {
		logger.Fatal("executor-failed-to-get-containers", err)
		return
	} else {
		logger.Info("executor-fetched-containers-to-destroy", lager.Data{"num-containers": len(containers)})
	}

	for _, container := range containers {
		logger.Info("executor-destroying-container", lager.Data{"container-handle": container.Handle()})
		err := gardenClient.Destroy(container.Handle())
		if err != nil {
			logger.Fatal("executor-failed-to-destroy-container", err, lager.Data{
				"handle": container.Handle(),
			})
		} else {
			logger.Info("executor-destroyed-stray-container", lager.Data{
				"handle": container.Handle(),
			})
		}
	}
}

func createContainer(client garden.Client, spec garden.ContainerSpec) garden.Container {
	container, err := client.Create(spec)
	Ω(err).ShouldNot(HaveOccurred(), fmt.Sprintf("Error while creating container with spec: %+v", spec))
	return container
}

	"github.com/cloudfoundry-incubator/garden/fakes"
	"github.com/cloudfoundry-incubator/garden/server"
)

var _ = Describe("When a client connects", func() {
	var socketPath string
	var tmpdir string

	var serverBackend *fakes.FakeBackend

	var serverContainerGraceTime time.Duration

	var logger *lagertest.TestLogger

	var apiServer *server.GardenServer
	var apiClient garden.Client
	var isRunning bool

	BeforeEach(func() {
		logger = lagertest.NewTestLogger("test")

		var err error
		tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
		Ω(err).ShouldNot(HaveOccurred())

		socketPath = path.Join(tmpdir, "api.sock")
		serverBackend = new(fakes.FakeBackend)
		serverContainerGraceTime = 42 * time.Second

		apiServer = server.New(
			"unix",

				logger,
			)

			err = apiServer.Start()
			Ω(err).Should(HaveOccurred())
		})
	})

	Describe("shutting down", func() {
		var socketPath string

		var serverBackend garden.Backend
		var fakeBackend *fakes.FakeBackend

		var apiServer *server.GardenServer
		var apiClient garden.Client

		BeforeEach(func() {
			var err error
			tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
			Ω(err).ShouldNot(HaveOccurred())

			socketPath = path.Join(tmpdir, "api.sock")
			fakeBackend = new(fakes.FakeBackend)

			serverBackend = fakeBackend

			apiClient = client.New(connection.New("unix", socketPath))
		})

		JustBeforeEach(func() {