func (store *GardenStore) transitionToComplete(logger lager.Logger, gardenContainer garden.Container, result executor.ContainerRunResult) error { resultJson, err := json.Marshal(result) if err != nil { return err } err = gardenContainer.SetProperty(ContainerResultProperty, string(resultJson)) if err != nil { return err } err = gardenContainer.SetProperty(ContainerStateProperty, string(executor.StateCompleted)) if err != nil { return err } executorContainer, err := store.exchanger.Info(logger, gardenContainer) if err != nil { return err } store.eventEmitter.Emit(executor.NewContainerCompleteEvent(executorContainer)) return nil }
func (a *AllocationStore) Fail(logger lager.Logger, guid string, reason string) (executor.Container, error) { a.lock.Lock() defer a.lock.Unlock() container, err := a.lookup(guid) if err != nil { logger.Error("failed-completing-container", err) return executor.Container{}, err } if container.State == executor.StateCompleted { logger.Error( "failed-completing-container", executor.ErrInvalidTransition, lager.Data{ "current_state": container.State, "expected_state": executor.StateInitializing, }, ) return executor.Container{}, executor.ErrInvalidTransition } logger.Debug("marking-container-completed-with-failure-reason", lager.Data{ "guid": guid, "failure_reason": reason, }) container.State = executor.StateCompleted container.RunResult = executor.ContainerRunResult{ Failed: true, FailureReason: reason, } a.allocated[guid] = container a.eventEmitter.Emit(executor.NewContainerCompleteEvent(container)) return container, nil }
BeforeEach(func() { container = executor.Container{ Guid: "some-instance-guid", State: executor.StateCompleted, Tags: executor.Tags{ rep.ProcessGuidTag: "some-process-guid", rep.DomainTag: "some-domain", rep.ProcessIndexTag: "1", }, } }) JustBeforeEach(func() { receivedEvents <- executor.NewContainerCompleteEvent(container) }) Context("when the lifecycle is LRP", func() { BeforeEach(func() { container.Tags[rep.LifecycleTag] = rep.LRPLifecycle }) It("yields an operation for that container", func() { var operation operationq.Operation Eventually(stream).Should(Receive(&operation)) Expect(operation.Key()).To(Equal(container.Guid)) }) }) Context("when the lifecycle is Task", func() {
}) It("it is marked as COMPLETED with failure reason", func() { emitCallCount := fakeEventEmitter.EmitCallCount() allocation, err := allocationStore.Fail(logger, req.Guid, "failure-reason") Expect(err).NotTo(HaveOccurred()) Expect(allocation.Guid).To(Equal(req.Guid)) Expect(allocation.State).To(Equal(executor.StateCompleted)) Expect(allocation.RunResult).To(Equal(executor.ContainerRunResult{ Failed: true, FailureReason: "failure-reason", })) Expect(fakeEventEmitter.EmitCallCount()).To(Equal(emitCallCount + 1)) Expect(fakeEventEmitter.EmitArgsForCall(emitCallCount)).To(Equal(executor.NewContainerCompleteEvent(allocation))) }) It("remains in the allocation store as reserved", func() { c, err := allocationStore.Lookup(req.Guid) Expect(err).NotTo(HaveOccurred()) Expect(c.State).To(Equal(executor.StateReserved)) }) Context("when the container is already in the completed state", func() { BeforeEach(func() { runReq := executor.NewRunRequest(req.Guid, &executor.RunInfo{}, executor.Tags{}) err := allocationStore.Initialize(logger, &runReq) Expect(err).NotTo(HaveOccurred()) _, err = allocationStore.Fail(logger, req.Guid, "force-completed")