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())
