func (dr *dropletRunner) BuildDroplet(taskName, dropletName, buildpackUrl string, environment map[string]string, memoryMB, cpuWeight, diskMB int) error {
builderConfig := buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{buildpackUrl}, true, false)
action := models.WrapAction(&models.SerialAction{
Actions: []*models.Action{
models.WrapAction(&models.DownloadAction{
From: "http://file-server.service.cf.internal:8080/v1/static/cell-helpers/cell-helpers.tgz",
To: "/tmp",
User: "******",
}),
models.WrapAction(&models.DownloadAction{
From: "http://file-server.service.cf.internal:8080/v1/static/buildpack_app_lifecycle/buildpack_app_lifecycle.tgz",
To: "/tmp",
User: "******",
}),
dr.blobStore.DownloadAppBitsAction(dropletName),
dr.blobStore.DeleteAppBitsAction(dropletName),
models.WrapAction(&models.RunAction{
Path: "/bin/chmod",
Dir: "/tmp/app",
Args: []string{"-R", "a+X", "."},
User: "******",
}),
models.WrapAction(&models.RunAction{
Path: "/tmp/builder",
Dir: "/",
Args: builderConfig.Args(),
User: "******",
}),
dr.blobStore.UploadDropletAction(dropletName),
dr.blobStore.UploadDropletMetadataAction(dropletName),
},
})
environment["CF_STACK"] = DropletStack
environment["MEMORY_LIMIT"] = fmt.Sprintf("%dM", memoryMB)
proxyConf, err := dr.proxyConfReader.ProxyConf()
if err != nil {
return err
}
environment["http_proxy"] = proxyConf.HTTPProxy
environment["https_proxy"] = proxyConf.HTTPSProxy
environment["no_proxy"] = proxyConf.NoProxy
createTaskParams := task_runner.NewCreateTaskParams(
action,
taskName,
DropletRootFS,
"lattice",
"BUILD",
environment,
[]*models.SecurityGroupRule{},
memoryMB,
cpuWeight,
diskMB,
)
return dr.taskRunner.CreateTask(createTaskParams)
}
func (dr *dropletRunner) BuildDroplet(taskName, dropletName, buildpackUrl string, environment map[string]string, memoryMB, cpuWeight, diskMB int) error {
builderConfig := buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{buildpackUrl}, true, false)
action := &models.SerialAction{
Actions: []models.Action{
&models.DownloadAction{
From: "http://file_server.service.dc1.consul:8080/v1/static/lattice-cell-helpers.tgz",
To: "/tmp",
User: "******",
},
dr.blobStore.DownloadAppBitsAction(dropletName),
dr.blobStore.DeleteAppBitsAction(dropletName),
&models.RunAction{
Path: "/bin/chmod",
Dir: "/tmp/app",
Args: []string{"-R", "a+X", "."},
User: "******",
},
&models.RunAction{
Path: "/tmp/builder",
Dir: "/",
Args: builderConfig.Args(),
User: "******",
},
dr.blobStore.UploadDropletAction(dropletName),
dr.blobStore.UploadDropletMetadataAction(dropletName),
},
}
environment["CF_STACK"] = DropletStack
environment["MEMORY_LIMIT"] = fmt.Sprintf("%dM", memoryMB)
createTaskParams := task_runner.NewCreateTaskParams(
action,
taskName,
DropletRootFS,
"lattice",
"BUILD",
environment,
[]models.SecurityGroupRule{},
memoryMB,
cpuWeight,
diskMB,
)
return dr.taskRunner.CreateTask(createTaskParams)
}
func main() {
config := buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{}, false, false)
if err := config.Parse(os.Args[1:len(os.Args)]); err != nil {
println(err.Error())
os.Exit(1)
}
if err := config.Validate(); err != nil {
println(err.Error())
usage()
}
runner := buildpackrunner.New(&config)
err := runner.Run()
if err != nil {
println(err.Error())
os.Exit(1)
}
os.Exit(0)
}
import (
"github.com/cloudfoundry-incubator/buildpack_app_lifecycle"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("LifecycleBuilderConfig", func() {
var builderConfig buildpack_app_lifecycle.LifecycleBuilderConfig
var skipDetect bool
BeforeEach(func() {
skipDetect = false
})
JustBeforeEach(func() {
builderConfig = buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{"ocaml-buildpack", "haskell-buildpack", "bash-buildpack"}, skipDetect, false)
})
Context("with defaults", func() {
It("generates a script for running its builder", func() {
commandFlags := []string{
"-buildDir=/tmp/app",
"-buildpackOrder=ocaml-buildpack,haskell-buildpack,bash-buildpack",
"-buildpacksDir=/tmp/buildpacks",
"-buildArtifactsCacheDir=/tmp/cache",
"-outputDroplet=/tmp/droplet",
"-outputMetadata=/tmp/result.json",
"-outputBuildArtifactsCache=/tmp/output-cache",
"-skipCertVerify=false",
"-skipDetect=false",
}
func (dr *dropletRunner) BuildDroplet(taskName, dropletName, buildpackUrl string, environment map[string]string) error {
builderConfig := buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{buildpackUrl}, true, false)
action := &models.SerialAction{
Actions: []models.Action{
&models.DownloadAction{
From: "http://file_server.service.dc1.consul:8080/v1/static/lattice-cell-helpers.tgz",
To: "/tmp",
},
&models.RunAction{
Path: "/tmp/s3downloader",
Dir: "/",
Args: []string{
dr.config.BlobTarget().AccessKey,
dr.config.BlobTarget().SecretKey,
fmt.Sprintf("http://%s:%d/", dr.config.BlobTarget().TargetHost, dr.config.BlobTarget().TargetPort),
dr.config.BlobTarget().BucketName,
fmt.Sprintf("%s/bits.tgz", dropletName),
"/tmp/bits.tgz",
},
User: "******",
},
&models.RunAction{
Path: "/bin/mkdir",
Dir: "/",
Args: []string{"/tmp/app"},
User: "******",
},
&models.RunAction{
Path: "/bin/tar",
Dir: "/",
Args: []string{"-C", "/tmp/app", "-xf", "/tmp/bits.tgz"},
User: "******",
},
&models.RunAction{
Path: "/tmp/builder",
Dir: "/",
Args: builderConfig.Args(),
User: "******",
},
&models.RunAction{
Path: "/tmp/s3uploader",
Dir: "/",
Args: []string{
dr.config.BlobTarget().AccessKey,
dr.config.BlobTarget().SecretKey,
fmt.Sprintf("http://%s:%d/", dr.config.BlobTarget().TargetHost, dr.config.BlobTarget().TargetPort),
dr.config.BlobTarget().BucketName,
fmt.Sprintf("%s/droplet.tgz", dropletName),
"/tmp/droplet",
},
User: "******",
},
&models.RunAction{
Path: "/tmp/s3uploader",
Dir: "/",
Args: []string{
dr.config.BlobTarget().AccessKey,
dr.config.BlobTarget().SecretKey,
fmt.Sprintf("http://%s:%d/", dr.config.BlobTarget().TargetHost, dr.config.BlobTarget().TargetPort),
dr.config.BlobTarget().BucketName,
fmt.Sprintf("%s/result.json", dropletName),
"/tmp/result.json",
},
User: "******",
},
},
}
environment["CF_STACK"] = DropletStack
createTaskParams := task_runner.NewCreateTaskParams(
action,
taskName,
DropletRootFS,
"lattice",
"BUILD",
environment,
[]models.SecurityGroupRule{},
)
return dr.taskRunner.CreateTask(createTaskParams)
}
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
}
func (dr *dropletRunner) BuildDroplet(taskName, dropletName, buildpackUrl string, environment map[string]string, memoryMB, cpuWeight, diskMB int) error {
builderConfig := buildpack_app_lifecycle.NewLifecycleBuilderConfig([]string{buildpackUrl}, true, false)
dropletURL := fmt.Sprintf("http://%s:%s@%s:%s%s",
dr.config.BlobStore().Username,
dr.config.BlobStore().Password,
dr.config.BlobStore().Host,
dr.config.BlobStore().Port,
path.Join("/blobs", dropletName))
action := &models.SerialAction{
Actions: []models.Action{
&models.DownloadAction{
From: "http://file_server.service.dc1.consul:8080/v1/static/lattice-cell-helpers.tgz",
To: "/tmp",
User: "******",
},
&models.DownloadAction{
From: dropletURL + "/bits.zip",
To: "/tmp/app",
User: "******",
},
&models.RunAction{
Path: "/tmp/davtool",
Dir: "/",
Args: []string{"delete", dropletURL + "/bits.zip"},
User: "******",
},
&models.RunAction{
Path: "/bin/chmod",
Dir: "/tmp/app",
Args: []string{"-R", "a+X", "."},
User: "******",
},
&models.RunAction{
Path: "/tmp/builder",
Dir: "/",
Args: builderConfig.Args(),
User: "******",
},
&models.RunAction{
Path: "/tmp/davtool",
Dir: "/",
Args: []string{"put", dropletURL + "/droplet.tgz", "/tmp/droplet"},
User: "******",
},
&models.RunAction{
Path: "/tmp/davtool",
Dir: "/",
Args: []string{"put", dropletURL + "/result.json", "/tmp/result.json"},
User: "******",
},
},
}
environment["CF_STACK"] = DropletStack
environment["MEMORY_LIMIT"] = fmt.Sprintf("%dM", memoryMB)
createTaskParams := task_runner.NewCreateTaskParams(
action,
taskName,
DropletRootFS,
"lattice",
"BUILD",
environment,
[]models.SecurityGroupRule{},
memoryMB,
cpuWeight,
diskMB,
)
return dr.taskRunner.CreateTask(createTaskParams)
}