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: "******",
}
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() {