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)
	}
}
Exemple #2
0
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 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)
}
	Context("and the client sends a ListRequest", func() {
		BeforeEach(func() {
			c1 := new(fakes.FakeContainer)
			c1.HandleReturns("some-handle")

			c2 := new(fakes.FakeContainer)
			c2.HandleReturns("another-handle")

			c3 := new(fakes.FakeContainer)
			c3.HandleReturns("super-handle")

			serverBackend.ContainersReturns([]garden.Container{c1, c2, c3}, nil)
		})

		It("returns the containers from the backend", func() {
			containers, err := apiClient.Containers(nil)
			Ω(err).ShouldNot(HaveOccurred())

			Ω(containers).Should(HaveLen(3))

			handles := make([]string, 3)
			for i, c := range containers {
				handles[i] = c.Handle()
			}

			Ω(handles).Should(ContainElement("some-handle"))
			Ω(handles).Should(ContainElement("another-handle"))
			Ω(handles).Should(ContainElement("super-handle"))
		})

		Context("when getting the containers fails", func() {