func NewValidDesiredLRP(guid string) *models.DesiredLRP { myRouterJSON := json.RawMessage(`{"foo":"bar"}`) modTag := models.NewModificationTag("epoch", 0) desiredLRP := &models.DesiredLRP{ ProcessGuid: guid, Domain: "some-domain", RootFs: "some:rootfs", Instances: 1, EnvironmentVariables: []*models.EnvironmentVariable{{Name: "FOO", Value: "bar"}}, CachedDependencies: []*models.CachedDependency{ {Name: "app bits", From: "blobstore.com/bits/app-bits", To: "/usr/local/app", CacheKey: "cache-key", LogSource: "log-source"}, {Name: "app bits with checksum", From: "blobstore.com/bits/app-bits-checksum", To: "/usr/local/app-checksum", CacheKey: "cache-key", LogSource: "log-source", ChecksumAlgorithm: "md5", ChecksumValue: "checksum-value"}, }, Setup: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), StartTimeoutMs: 15000, Monitor: models.WrapAction(models.EmitProgressFor( models.Timeout(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"}))), 10*time.Second, ), "start-message", "success-message", "failure-message", )), DiskMb: 512, MemoryMb: 1024, CpuWeight: 42, Routes: &models.Routes{"my-router": &myRouterJSON}, LogSource: "some-log-source", LogGuid: "some-log-guid", MetricsGuid: "some-metrics-guid", Annotation: "some-annotation", Network: &models.Network{ Properties: map[string]string{ "some-key": "some-value", "some-other-key": "some-other-value", }, }, EgressRules: []*models.SecurityGroupRule{{ Protocol: models.TCPProtocol, Destinations: []string{"1.1.1.1/32", "2.2.2.2/32"}, PortRange: &models.PortRange{Start: 10, End: 16000}, }}, ModificationTag: &modTag, LegacyDownloadUser: "******", TrustedSystemCertificatesPath: "/etc/somepath", VolumeMounts: []*models.VolumeMount{ { Driver: "my-driver", VolumeId: "my-volume", ContainerPath: "/mnt/mypath", Mode: models.BindMountMode_RO, }, }, } err := desiredLRP.Validate() Expect(err).NotTo(HaveOccurred()) return desiredLRP }
func NewValidDesiredLRP(guid string) *models.DesiredLRP { myRouterJSON := json.RawMessage(`{"foo":"bar"}`) modTag := models.NewModificationTag("epoch", 0) desiredLRP := &models.DesiredLRP{ ProcessGuid: guid, Domain: "some-domain", RootFs: "some:rootfs", Instances: 1, EnvironmentVariables: []*models.EnvironmentVariable{{Name: "FOO", Value: "bar"}}, Setup: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), StartTimeout: 15, Monitor: models.WrapAction(models.EmitProgressFor( models.Timeout(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"}))), 10*time.Second, ), "start-message", "success-message", "failure-message", )), DiskMb: 512, MemoryMb: 1024, CpuWeight: 42, Routes: &models.Routes{"my-router": &myRouterJSON}, LogSource: "some-log-source", LogGuid: "some-log-guid", MetricsGuid: "some-metrics-guid", Annotation: "some-annotation", EgressRules: []*models.SecurityGroupRule{{ Protocol: models.TCPProtocol, Destinations: []string{"1.1.1.1/32", "2.2.2.2/32"}, PortRange: &models.PortRange{Start: 10, End: 16000}, }}, ModificationTag: &modTag, } err := desiredLRP.Validate() Expect(err).NotTo(HaveOccurred()) return desiredLRP }
func (backend *dockerBackend) BuildRecipe(stagingGuid string, request cc_messages.StagingRequestFromCC) (*models.TaskDefinition, string, string, error) { logger := backend.logger.Session("build-recipe", lager.Data{"app-id": request.AppId, "staging-guid": stagingGuid}) logger.Info("staging-request") var lifecycleData cc_messages.DockerStagingData err := json.Unmarshal(*request.LifecycleData, &lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } err = backend.validateRequest(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } compilerURL, err := backend.compilerDownloadURL() if err != nil { return &models.TaskDefinition{}, "", "", err } cachedDependencies := []*models.CachedDependency{ &models.CachedDependency{ From: compilerURL.String(), To: path.Dir(DockerBuilderExecutablePath), CacheKey: "docker-lifecycle", }, } runActionArguments := []string{ "-outputMetadataJSONFilename", DockerBuilderOutputPath, "-dockerRef", lifecycleData.DockerImageUrl, } if len(backend.config.InsecureDockerRegistries) > 0 { insecureDockerRegistries := strings.Join(backend.config.InsecureDockerRegistries, ",") runActionArguments = append(runActionArguments, "-insecureDockerRegistries", insecureDockerRegistries) } fileDescriptorLimit := uint64(request.FileDescriptors) runAs := "vcap" actions := []models.ActionInterface{} if cacheDockerImage(request.Environment) { runAs = "root" additionalEgressRules, additionalArgs, err := cachingEgressRulesAndArgs( logger, backend.config.DockerRegistryAddress, backend.config.ConsulCluster, lifecycleData, ) if err != nil { return &models.TaskDefinition{}, "", "", err } runActionArguments = append(runActionArguments, additionalArgs...) request.EgressRules = append(request.EgressRules, additionalEgressRules...) actions = append( actions, models.EmitProgressFor( &models.RunAction{ Path: MountCgroupsPath, ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, User: runAs, }, "Preparing docker daemon...", "", "Failed to set up docker environment", ), ) } actions = append( actions, models.EmitProgressFor( &models.RunAction{ Path: DockerBuilderExecutablePath, Args: runActionArguments, Env: request.Environment, ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, User: runAs, }, "Staging...", "Staging Complete", "Staging Failed", ), ) annotationJson, _ := json.Marshal(cc_messages.StagingTaskAnnotation{ Lifecycle: DockerLifecycleName, CompletionCallback: request.CompletionCallback, }) taskDefinition := &models.TaskDefinition{ RootFs: models.PreloadedRootFS(backend.config.DockerStagingStack), ResultFile: DockerBuilderOutputPath, Privileged: true, MemoryMb: int32(request.MemoryMB), LogSource: TaskLogSource, LogGuid: request.LogGuid, EgressRules: request.EgressRules, DiskMb: int32(request.DiskMB), CompletionCallbackUrl: backend.config.CallbackURL(stagingGuid), Annotation: string(annotationJson), Action: models.WrapAction(models.Timeout(models.Serial(actions...), dockerTimeout(request, backend.logger))), CachedDependencies: cachedDependencies, LegacyDownloadUser: "******", TrustedSystemCertificatesPath: TrustedSystemCertificatesPath, } logger.Debug("staging-task-request") return taskDefinition, stagingGuid, backend.config.TaskDomain, nil }
func (backend *dockerBackend) BuildRecipe(stagingGuid string, request cc_messages.StagingRequestFromCC) (*models.TaskDefinition, string, string, error) { logger := backend.logger.Session("build-recipe", lager.Data{"app-id": request.AppId, "staging-guid": stagingGuid}) logger.Info("staging-request") var lifecycleData cc_messages.DockerStagingData err := json.Unmarshal(*request.LifecycleData, &lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } err = backend.validateRequest(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } compilerURL, err := backend.compilerDownloadURL() if err != nil { return &models.TaskDefinition{}, "", "", err } cacheDockerImage := false for _, envVar := range request.Environment { if envVar.Name == "DIEGO_DOCKER_CACHE" && envVar.Value == "true" { cacheDockerImage = true break } } actions := []models.ActionInterface{} //Download builder actions = append( actions, models.EmitProgressFor( &models.DownloadAction{ From: compilerURL.String(), To: path.Dir(DockerBuilderExecutablePath), CacheKey: "docker-lifecycle", User: "******", }, "", "", "Failed to set up docker environment", ), ) runActionArguments := []string{"-outputMetadataJSONFilename", DockerBuilderOutputPath, "-dockerRef", lifecycleData.DockerImageUrl} runAs := "vcap" if cacheDockerImage { runAs = "root" host, port, err := net.SplitHostPort(backend.config.DockerRegistryAddress) if err != nil { logger.Debug("invalid docker registry address", lager.Data{"address": backend.config.DockerRegistryAddress, "error": err.Error()}) return &models.TaskDefinition{}, "", "", ErrInvalidDockerRegistryAddress } registryServices, err := getDockerRegistryServices(backend.config.ConsulCluster, backend.logger) if err != nil { return &models.TaskDefinition{}, "", "", err } registryRules := addDockerRegistryRules(request.EgressRules, registryServices) request.EgressRules = append(request.EgressRules, registryRules...) registryIPs := strings.Join(buildDockerRegistryAddresses(registryServices), ",") runActionArguments, err = addDockerCachingArguments(runActionArguments, registryIPs, backend.config.InsecureDockerRegistry, host, port, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } } fileDescriptorLimit := uint64(request.FileDescriptors) // Run builder actions = append( actions, models.EmitProgressFor( &models.RunAction{ Path: DockerBuilderExecutablePath, Args: runActionArguments, Env: request.Environment, ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, User: runAs, }, "Staging...", "Staging Complete", "Staging Failed", ), ) annotationJson, _ := json.Marshal(cc_messages.StagingTaskAnnotation{ Lifecycle: DockerLifecycleName, }) taskDefinition := &models.TaskDefinition{ RootFs: models.PreloadedRootFS(backend.config.DockerStagingStack), ResultFile: DockerBuilderOutputPath, Privileged: true, MemoryMb: int32(request.MemoryMB), LogSource: TaskLogSource, LogGuid: request.LogGuid, EgressRules: request.EgressRules, DiskMb: int32(request.DiskMB), CompletionCallbackUrl: backend.config.CallbackURL(stagingGuid), Annotation: string(annotationJson), Action: models.WrapAction(models.Timeout(models.Serial(actions...), dockerTimeout(request, backend.logger))), } logger.Debug("staging-task-request") return taskDefinition, stagingGuid, backend.config.TaskDomain, nil }
"rabbit_hole": "rabbit-hole-compiler", "compiler_with_full_url": "http://the-full-compiler-url", "compiler_with_bad_url": "ftp://the-bad-compiler-url", "docker": "docker_lifecycle/docker_app_lifecycle.tgz", }, Sanitizer: func(msg string) *cc_messages.StagingError { return &cc_messages.StagingError{Message: msg + " was totally sanitized"} }, } downloadBuilderAction = models.EmitProgressFor( &models.DownloadAction{ From: "http://file-server.com/v1/static/docker_lifecycle/docker_app_lifecycle.tgz", To: "/tmp/docker_app_lifecycle", CacheKey: "docker-lifecycle", User: "******", }, "", "", "Failed to set up docker environment", ) fileDescriptorLimit := uint64(512) runAction = models.EmitProgressFor( &models.RunAction{ Path: "/tmp/docker_app_lifecycle/builder", Args: []string{ "-outputMetadataJSONFilename", "/tmp/docker-result/result.json", "-dockerRef",
"start_message": "reticulating splines", "success_message": "reticulated splines", "failure_message_prefix": "reticulation failed", "action": { "run": { "path": "echo", "resource_limits":{}, "user": "******", "suppress_log_output": false } } }`, models.WrapAction(models.EmitProgressFor( &models.RunAction{ Path: "echo", User: "******", ResourceLimits: &models.ResourceLimits{}, }, "reticulating splines", "reticulated splines", "reticulation failed", )), ) Describe("Validate", func() { var emitProgressAction *models.EmitProgressAction Context("when the action has 'action' specified", func() { It("is valid", func() { emitProgressAction = models.EmitProgressFor( &models.UploadAction{ From: "local_location", To: "web_location", User: "******",
func (backend *traditionalBackend) BuildRecipe(stagingGuid string, request cc_messages.StagingRequestFromCC) (*models.TaskDefinition, string, string, error) { logger := backend.logger.Session("build-recipe", lager.Data{"app-id": request.AppId, "staging-guid": stagingGuid}) logger.Info("staging-request") if request.LifecycleData == nil { return &models.TaskDefinition{}, "", "", ErrMissingLifecycleData } var lifecycleData cc_messages.BuildpackStagingData err := json.Unmarshal(*request.LifecycleData, &lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } err = backend.validateRequest(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } compilerURL, err := backend.compilerDownloadURL(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } buildpacksOrder := []string{} for _, buildpack := range lifecycleData.Buildpacks { buildpacksOrder = append(buildpacksOrder, buildpack.Key) } skipDetect := len(lifecycleData.Buildpacks) == 1 && lifecycleData.Buildpacks[0].SkipDetect builderConfig := buildpack_app_lifecycle.NewLifecycleBuilderConfig(buildpacksOrder, skipDetect, backend.config.SkipCertVerify) timeout := traditionalTimeout(request, backend.logger) actions := []models.ActionInterface{} //Download app package appDownloadAction := &models.DownloadAction{ Artifact: "app package", From: lifecycleData.AppBitsDownloadUri, To: builderConfig.BuildDir(), User: "******", } actions = append(actions, appDownloadAction) downloadActions := []models.ActionInterface{} downloadNames := []string{} //Download builder downloadActions = append( downloadActions, models.EmitProgressFor( &models.DownloadAction{ From: compilerURL.String(), To: path.Dir(builderConfig.ExecutablePath), CacheKey: fmt.Sprintf("buildpack-%s-lifecycle", lifecycleData.Stack), User: "******", }, "", "", "Failed to set up staging environment", ), ) //Download buildpacks buildpackNames := []string{} downloadMsgPrefix := "" if !skipDetect { downloadMsgPrefix = "No buildpack specified; fetching standard buildpacks to detect and build your application.\n" } for _, buildpack := range lifecycleData.Buildpacks { if buildpack.Name == cc_messages.CUSTOM_BUILDPACK { buildpackNames = append(buildpackNames, buildpack.Url) } else { buildpackNames = append(buildpackNames, buildpack.Name) downloadActions = append( downloadActions, &models.DownloadAction{ Artifact: buildpack.Name, From: buildpack.Url, To: builderConfig.BuildpackPath(buildpack.Key), CacheKey: buildpack.Key, User: "******", }, ) } } downloadNames = append(downloadNames, fmt.Sprintf("buildpacks (%s)", strings.Join(buildpackNames, ", "))) //Download buildpack artifacts cache downloadURL, err := backend.buildArtifactsDownloadURL(lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } if downloadURL != nil { downloadActions = append( downloadActions, models.Try( &models.DownloadAction{ Artifact: "build artifacts cache", From: downloadURL.String(), To: builderConfig.BuildArtifactsCacheDir(), User: "******", }, ), ) downloadNames = append(downloadNames, "build artifacts cache") } downloadMsg := downloadMsgPrefix + fmt.Sprintf("Downloading %s...", strings.Join(downloadNames, ", ")) actions = append(actions, models.EmitProgressFor(models.Parallel(downloadActions...), downloadMsg, "Downloaded buildpacks", "Downloading buildpacks failed")) fileDescriptorLimit := uint64(request.FileDescriptors) //Run Builder runEnv := append(request.Environment, &models.EnvironmentVariable{"CF_STACK", lifecycleData.Stack}) actions = append( actions, models.EmitProgressFor( &models.RunAction{ User: "******", Path: builderConfig.Path(), Args: builderConfig.Args(), Env: runEnv, ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, }, "Staging...", "Staging complete", "Staging failed", ), ) //Upload Droplet uploadActions := []models.ActionInterface{} uploadNames := []string{} uploadURL, err := backend.dropletUploadURL(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } uploadActions = append( uploadActions, &models.UploadAction{ Artifact: "droplet", From: builderConfig.OutputDroplet(), // get the droplet To: addTimeoutParamToURL(*uploadURL, timeout).String(), User: "******", }, ) uploadNames = append(uploadNames, "droplet") //Upload Buildpack Artifacts Cache uploadURL, err = backend.buildArtifactsUploadURL(request, lifecycleData) if err != nil { return &models.TaskDefinition{}, "", "", err } uploadActions = append(uploadActions, models.Try( &models.UploadAction{ Artifact: "build artifacts cache", From: builderConfig.OutputBuildArtifactsCache(), // get the compressed build artifacts cache To: addTimeoutParamToURL(*uploadURL, timeout).String(), User: "******", }, ), ) uploadNames = append(uploadNames, "build artifacts cache") uploadMsg := fmt.Sprintf("Uploading %s...", strings.Join(uploadNames, ", ")) actions = append(actions, models.EmitProgressFor(models.Parallel(uploadActions...), uploadMsg, "Uploading complete", "Uploading failed")) annotationJson, _ := json.Marshal(cc_messages.StagingTaskAnnotation{ Lifecycle: TraditionalLifecycleName, CompletionCallback: request.CompletionCallback, }) taskDefinition := &models.TaskDefinition{ RootFs: models.PreloadedRootFS(lifecycleData.Stack), ResultFile: builderConfig.OutputMetadata(), MemoryMb: int32(request.MemoryMB), DiskMb: int32(request.DiskMB), CpuWeight: uint32(StagingTaskCpuWeight), Action: models.WrapAction(models.Timeout(models.Serial(actions...), timeout)), LogGuid: request.LogGuid, LogSource: TaskLogSource, CompletionCallbackUrl: backend.config.CallbackURL(stagingGuid), EgressRules: request.EgressRules, Annotation: string(annotationJson), Privileged: true, EnvironmentVariables: []*models.EnvironmentVariable{{"LANG", DefaultLANG}}, } logger.Debug("staging-task-request") return taskDefinition, stagingGuid, backend.config.TaskDomain, nil }
fileDescriptorLimit := uint64(512) runAction := models.EmitProgressFor( &models.RunAction{ Path: "/tmp/docker_app_lifecycle/builder", Args: []string{ "-outputMetadataJSONFilename", "/tmp/docker-result/result.json", "-dockerRef", "busybox", "-insecureDockerRegistries", "http://registry-1.com,http://registry-2.com", }, Env: []*models.EnvironmentVariable{ { Name: "VCAP_APPLICATION", Value: "foo", }, { Name: "VCAP_SERVICES", Value: "bar", }, }, ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, User: "******", }, "Staging...", "Staging Complete", "Staging Failed", ) actions := actionsFromTaskDef(taskDef)
diskMb = 3072 fileDescriptors = 512 buildArtifactsCacheDownloadUri = "http://example-uri.com/bunny-droppings" appId = "bunny" buildpacks = []cc_messages.Buildpack{ {Name: "zfirst", Key: "zfirst-buildpack", Url: "first-buildpack-url"}, {Name: "asecond", Key: "asecond-buildpack", Url: "second-buildpack-url"}, } appBitsDownloadUri = "http://example-uri.com/bunny" downloadBuilderAction = models.EmitProgressFor( &models.DownloadAction{ From: "http://file-server.com/v1/static/rabbit-hole-compiler", To: "/tmp/lifecycle", CacheKey: "buildpack-rabbit_hole-lifecycle", User: "******", }, "", "", "Failed to set up staging environment", ) downloadAppAction = &models.DownloadAction{ Artifact: "app package", From: "http://example-uri.com/bunny", To: "/tmp/app", User: "******", } downloadFirstBuildpackAction = &models.DownloadAction{ Artifact: "zfirst",
stagingRequest.Environment = append(stagingRequest.Environment, &models.EnvironmentVariable{ Name: "DIEGO_DOCKER_CACHE", Value: "true", }) } return stagingRequest } Context("when docker registry is running", func() { var dockerDownloadAction = models.EmitProgressFor( &models.DownloadAction{ From: "http://file-server.com/v1/static/docker_lifecycle/docker_app_lifecycle.tgz", To: "/tmp/docker_app_lifecycle", CacheKey: "docker-lifecycle", User: "******", }, "", "", "Failed to set up docker environment", ) fileDescriptorLimit := uint64(512) var mountCgroupsAction = models.EmitProgressFor( &models.RunAction{ Path: "/tmp/docker_app_lifecycle/mount_cgroups", ResourceLimits: &models.ResourceLimits{ Nofile: &fileDescriptorLimit, }, User: "******", },
BeforeEach(func() { processGuid = "process-guid-1" desiredLRP = model_helpers.NewValidDesiredLRP(processGuid) desiredLRP.DeprecatedStartTimeoutS = 15 desiredLRP.Action = models.WrapAction(&models.TimeoutAction{Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), DeprecatedTimeoutNs: 4 * int64(time.Second), }) desiredLRP.Setup = models.WrapAction(&models.TimeoutAction{Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), DeprecatedTimeoutNs: 7 * int64(time.Second), }) desiredLRP.Monitor = models.WrapAction(models.EmitProgressFor( &models.TimeoutAction{ Action: models.WrapAction(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"})))), DeprecatedTimeoutNs: 10 * int64(time.Second), }, "start-message", "success-message", "failure-message", )) }) JustBeforeEach(func() { schedulingInfo, runInfo := desiredLRP.CreateComponents(fakeClock.Now()) runInfo.DeprecatedStartTimeoutS = 15 _, err := json.Marshal(desiredLRP.Routes) Expect(err).NotTo(HaveOccurred()) schedInfoData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &schedulingInfo) Expect(err).NotTo(HaveOccurred())
var newValidDesiredLRP = func(guid string) *models.DesiredLRP { myRouterJSON := json.RawMessage(`{"foo":"bar"}`) modTag := models.NewModificationTag("epoch", 0) desiredLRP := &models.DesiredLRP{ ProcessGuid: guid, Domain: "some-domain", RootFs: "some:rootfs", Instances: 1, EnvironmentVariables: []*models.EnvironmentVariable{{Name: "FOO", Value: "bar"}}, Setup: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}), DeprecatedStartTimeoutS: 15, Monitor: models.WrapAction(models.EmitProgressFor( models.Timeout(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"}))), 10*time.Second, ), "start-message", "success-message", "failure-message", )), DiskMb: 512, MemoryMb: 1024, CpuWeight: 42, Routes: &models.Routes{"my-router": &myRouterJSON}, LogSource: "some-log-source", LogGuid: "some-log-guid", MetricsGuid: "some-metrics-guid", Annotation: "some-annotation", EgressRules: []*models.SecurityGroupRule{{ Protocol: models.TCPProtocol, Destinations: []string{"1.1.1.1/32", "2.2.2.2/32"}, PortRange: &models.PortRange{Start: 10, End: 16000},
}) JustBeforeEach(func() { docker = setupDockerBackend(insecureDockerRegistry, fmt.Sprintf( `[ {"Address": "%s"}, {"Address": "%s"} ]`, dockerRegistryIPs[0], dockerRegistryIPs[1])) downloadBuilderAction = models.EmitProgressFor( &models.DownloadAction{ From: "http://file-server.com/v1/static/docker_lifecycle/docker_app_lifecycle.tgz", To: "/tmp/docker_app_lifecycle", CacheKey: "docker-lifecycle", User: "******", }, "", "", "Failed to set up docker environment", ) expectedEgressRules = setupEgressRules(dockerRegistryIPs) stagingRequest = setupStagingRequest() }) checkStagingInstructionsFunc := func() { taskDef, _, _, err := docker.BuildRecipe(stagingGuid, stagingRequest) Expect(err).NotTo(HaveOccurred())