builder/build/code_build.go
Rama main · réplica de lectura del repositorio original.
// RAINBOND, Application Management Platform
// Copyright (C) 2014-2017 Goodrain Co., Ltd.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. For any non-GPL usage of Rainbond,
// one or multiple Commercial Licenses authorized by Goodrain Co., Ltd.
// must be obtained first.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package build
import (
"context"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"os"
"os/exec"
"path"
"strings"
"time"
"github.com/goodrain/rainbond/db"
"github.com/eapache/channels"
"github.com/goodrain/rainbond/builder"
jobc "github.com/goodrain/rainbond/builder/job"
"github.com/goodrain/rainbond/builder/parser/code"
"github.com/goodrain/rainbond/builder/sources"
"github.com/goodrain/rainbond/util"
"github.com/sirupsen/logrus"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func slugBuilder() (Build, error) {
return &slugBuild{}, nil
}
type slugBuild struct {
tgzDir string
buildCacheDir string
re *Request
}
func (s *slugBuild) Build(re *Request) (*Response, error) {
re.Logger.Info(util.Translation("Start compiling the source code"), map[string]string{"step": "build-exector"})
s.tgzDir = re.TGZDir
normalizedReq := *re
normalizedReq.BuildEnvs = expandBuildEnvsForSlugBuild(re.BuildEnvs)
re = &normalizedReq
s.re = re
s.buildCacheDir = re.CacheDir
packageName := fmt.Sprintf("%s/%s.tgz", s.tgzDir, re.DeployVersion)
//Stops previous build tasks for the same component
//If an error occurs, it does not affect the current build task
if err := s.stopPreBuildJob(re); err != nil {
logrus.Errorf("stop pre build job for service %s failure %s", re.ServiceID, err.Error())
}
if err := s.runBuildJob(re); err != nil {
re.Logger.Error(util.Translation("Compiling the source code failure"), map[string]string{"step": "build-code", "status": "failure"})
logrus.Error("build slug in container error,", err.Error())
return nil, err
}
re.Logger.Info("code build success", map[string]string{"step": "build-exector"})
defer func() {
if err := os.Remove(packageName); err != nil && !strings.Contains(err.Error(), "no such file or directory") {
logrus.Warningf("pkg name: %s; remove slug pkg: %v", packageName, err)
}
}()
fileInfo, err := os.Stat(packageName)
if err != nil {
re.Logger.Error(util.Translation("Check that the build result failure"), map[string]string{"step": "build-code", "status": "failure"})
logrus.Error("build package check error", err.Error())
return nil, fmt.Errorf("build package failure")
}
if fileInfo.Size() == 0 {
re.Logger.Error(util.Translation("Source build failure and result slug size is 0"),
map[string]string{"step": "build-code", "status": "failure"})
return nil, fmt.Errorf("build package failure")
}
//After 5.1.5 version, wrap slug pacage in the runner image
imageName, err := s.buildRunnerImage(packageName)
if err != nil {
re.Logger.Error(util.Translation("Build runner image failure"),
map[string]string{"step": "build-code", "status": "failure"})
return nil, fmt.Errorf("build runner image failure")
}
re.Logger.Info(util.Translation("build runtime image success"), map[string]string{"step": "build-code", "status": "success"})
res := &Response{
MediumType: ImageMediumType,
MediumPath: imageName,
}
return res, nil
}
func expandBuildEnvsForSlugBuild(envs map[string]string) map[string]string {
if envs == nil {
return nil
}
expanded := make(map[string]string, len(envs)+8)
for key, value := range envs {
expanded[key] = value
}
legacyAliases := map[string]string{
"BUILD_NO_CACHE": "NO_CACHE",
"BUILD_ENABLE_ORACLEJDK": "ENABLE_ORACLEJDK",
"BUILD_ORACLEJDK_URL": "ORACLEJDK_URL",
"BUILD_MAVEN_SETTING_NAME": "MAVEN_SETTING_NAME",
"BUILD_MAVEN_CUSTOM_OPTS": "MAVEN_CUSTOM_OPTS",
"BUILD_MAVEN_CUSTOM_GOALS": "MAVEN_CUSTOM_GOALS",
"BUILD_MAVEN_JAVA_OPTS": "MAVEN_JAVA_OPTS",
"BUILD_MAVEN_MIRROR_DISABLE": "MAVEN_MIRROR_DISABLE",
"BUILD_MAVEN_MIRROR_OF": "MAVEN_MIRROR_OF",
"BUILD_MAVEN_MIRROR_URL": "MAVEN_MIRROR_URL",
"BUILD_GOPROXY": "GOPROXY",
"BUILD_GOPRIVATE": "GOPRIVATE",
"BUILD_GO_INSTALL_PACKAGE_SPEC": "GO_INSTALL_PACKAGE_SPEC",
"BUILD_PIP_INDEX_URL": "PIP_INDEX_URL",
"BUILD_PACKAGE_TOOL": "PACKAGE_TOOL",
"BUILD_NODE_ENV": "NODE_ENV",
"BUILD_NODE_MODULES_CACHE": "NODE_MODULES_CACHE",
"BUILD_NODE_BUILD_CMD": "NODE_BUILD_CMD",
"BUILD_NPMRC_CONTENT": "NPMRC_CONTENT",
"BUILD_NPM_REGISTRY": "NPM_REGISTRY",
"BUILD_YARNRC_CONTENT": "YARNRC_CONTENT",
"BUILD_YARN_REGISTRY": "YARN_REGISTRY",
"BUILD_PROCFILE": "PROCFILE",
"BUILD_RUNTIMES": "RUNTIMES",
"BUILD_RUNTIMES_MAVEN": "RUNTIMES_MAVEN",
"BUILD_RUNTIMES_SERVER": "RUNTIMES_SERVER",
"BUILD_GOVERSION": "GOVERSION",
}
for buildKey, legacyKey := range legacyAliases {
if value, exists := expanded[legacyKey]; exists && strings.TrimSpace(value) != "" {
continue
}
if value, ok := expanded[buildKey]; ok && strings.TrimSpace(value) != "" {
expanded[legacyKey] = value
}
}
backfillLegacyAlias(expanded, "DIST_DIR", "BUILD_DIST_DIR", "BUILD_OUTPUT_DIR")
backfillLegacyAlias(expanded, "NODE_BUILD_CMD", "BUILD_NODE_BUILD_CMD", "BUILD_BUILD_CMD")
return expanded
}
func backfillLegacyAlias(envs map[string]string, legacyKey string, buildKeys ...string) {
if envs == nil {
return
}
if value, exists := envs[legacyKey]; exists && strings.TrimSpace(value) != "" {
return
}
for _, buildKey := range buildKeys {
if value, ok := envs[buildKey]; ok && strings.TrimSpace(value) != "" {
envs[legacyKey] = value
return
}
}
}
func (s *slugBuild) writeRunDockerfile(sourceDir, packageName string, envs map[string]string) error {
runDockerfile := `
FROM %s
ARG CODE_COMMIT_HASH
ARG CODE_COMMIT_USER
ARG CODE_COMMIT_MESSAGE
COPY %s /tmp/slug/slug.tgz
RUN chown rain:rain /tmp/slug/slug.tgz
ENV CODE_COMMIT_HASH=${CODE_COMMIT_HASH}
ENV CODE_COMMIT_USER=${CODE_COMMIT_USER}
ENV CODE_COMMIT_MESSAGE=${CODE_COMMIT_MESSAGE}
ENV VERSION=%s
`
logrus.Debugf("cacheDir:%v, from:%v, packageName:%v, Dir(slugPackage):%v", sourceDir, builder.RUNNERIMAGENAME, packageName, path.Dir(packageName))
result := util.ParseVariable(fmt.Sprintf(runDockerfile, builder.RUNNERIMAGENAME, packageName, s.re.DeployVersion), envs)
return ioutil.WriteFile(path.Join(sourceDir, "Dockerfile"), []byte(result), 0755)
}
// buildRunnerImage Wrap slug in the runner image
func (s *slugBuild) buildRunnerImage(slugPackage string) (string, error) {
imageName := CreateImageName(s.re.ServiceID, s.re.DeployVersion)
cacheDir := path.Join(path.Dir(slugPackage), "."+s.re.DeployVersion)
if err := util.CheckAndCreateDir(cacheDir); err != nil {
return "", fmt.Errorf("create cache package dir failure %s", err.Error())
}
defer func() {
if err := os.RemoveAll(cacheDir); err != nil {
logrus.Errorf("remove cache dir %s failure %s", cacheDir, err.Error())
}
}()
packageName := path.Base(slugPackage)
if err := util.Rename(slugPackage, path.Join(cacheDir, packageName)); err != nil {
return "", fmt.Errorf("move code package failure %s", err.Error())
}
//write default runtime dockerfile
if err := s.writeRunDockerfile(cacheDir, packageName, s.re.BuildEnvs); err != nil {
return "", fmt.Errorf("write default runtime dockerfile error:%s", err.Error())
}
//build runtime image
if err := s.re.ImageClient.ImagesPullAndPush(builder.RUNNERIMAGENAME, builder.GetRunnerImage(s.re.BRVersion), "", "", s.re.Logger); err != nil {
failMsg := fmt.Sprintf("%s: %s", util.Translation("Pull runner image failed, please check if the image is accessible"), builder.RUNNERIMAGENAME)
s.re.Logger.Error(failMsg, map[string]string{"step": "builder-exector", "status": "failure"})
return "", fmt.Errorf("pull image %s: %v", builder.RUNNERIMAGENAME, err)
}
logrus.Infof("pull image %s successfully.", builder.RUNNERIMAGENAME)
err := sources.ImageBuild(s.re.Arch, cacheDir, s.re.RbdNamespace, s.re.ServiceID, s.re.DeployVersion, s.re.Logger, "run-build", "", s.re.BuildKitImage, s.re.BuildKitArgs, s.re.BuildKitCache, s.re.KubeClient)
if err != nil {
failMsg := util.Translation("Build image failed, please check build logs")
s.re.Logger.Error(failMsg, map[string]string{"step": "builder-exector", "status": "failure"})
logrus.Errorf("build image error: %s", err.Error())
return "", err
}
return imageName, nil
}
func (s *slugBuild) getSourceCodeTarFile(re *Request) (string, error) {
var cmd []string
sourceTarFile := fmt.Sprintf("%s/%s-%s.tar", util.GetParentDirectory(re.SourceDir), re.ServiceID, re.DeployVersion)
// 验证并处理支持的ServerType
switch re.ServerType {
case "svn":
cmd = append(cmd, "tar", "-cf", sourceTarFile, "./")
case "git":
cmd = append(cmd, "tar", "-cf", sourceTarFile, "./")
default:
return "", fmt.Errorf("unsupported server type '%s' for source code tar operation, only 'git' and 'svn' are supported", re.ServerType)
}
// 防御性检查：确保cmd不为空
if len(cmd) == 0 {
return "", fmt.Errorf("no tar command generated for server type '%s'", re.ServerType)
}
source := exec.Command(cmd[0], cmd[1:]...)
source.Dir = re.SourceDir
logrus.Debugf("tar source code to file %s", sourceTarFile)
if err := source.Run(); err != nil && err.Error() != "exit status 1" {
return "", fmt.Errorf("command %s: %v", source.String(), err)
}
return sourceTarFile, nil
}
// stopPreBuildJob Stops previous build tasks for the same component
// The same component retains only one build task to perform
func (s *slugBuild) stopPreBuildJob(re *Request) error {
jobList, err := jobc.GetJobController().GetServiceJobs(re.ServiceID)
if err != nil {
logrus.Errorf("get pre build job for service %s failure ,%s", re.ServiceID, err.Error())
}
if len(jobList) > 0 {
for _, job := range jobList {
jobc.GetJobController().DeleteJob(job.Name)
}
}
return nil
}
func (s *slugBuild) createVolumeAndMount(re *Request, sourceTarFileName string, buildNoCache bool) (volumes []corev1.Volume, volumeMounts []corev1.VolumeMount) {
hostPathType := corev1.HostPathDirectoryOrCreate
volumeMounts = []corev1.VolumeMount{
{
Name: "slug",
MountPath: "/tmp/slug",
},
{
Name: "app",
MountPath: "/tmp/app",
},
}
volumes = []corev1.Volume{
{
Name: "app",
VolumeSource: corev1.VolumeSource{
HostPath: &corev1.HostPathVolumeSource{
Path: path.Join("/opt/rainbond/", re.SourceDir),
Type: &hostPathType,
},
},
},
{
Name: "slug",
VolumeSource: corev1.VolumeSource{
HostPath: &corev1.HostPathVolumeSource{
Path: path.Join("/opt/rainbond/", re.TGZDir),
Type: &hostPathType,
},
},
},
}
if !buildNoCache {
volumes = append(volumes, corev1.Volume{
Name: "cache",
VolumeSource: corev1.VolumeSource{
HostPath: &corev1.HostPathVolumeSource{
Path: path.Join("/opt/rainbond/", re.CacheDir),
Type: &hostPathType,
},
},
})
volumeMounts = append(volumeMounts, corev1.VolumeMount{
Name: "cache",
MountPath: "/tmp/cache",
})
}
return volumes, volumeMounts
}
func newSlugBuildPodSpec(arch, hostIP, cacheMode string) corev1.PodSpec {
podSpec := corev1.PodSpec{
RestartPolicy: corev1.RestartPolicyOnFailure,
Affinity: &corev1.Affinity{
NodeAffinity: &corev1.NodeAffinity{
RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{
NodeSelectorTerms: []corev1.NodeSelectorTerm{{
MatchExpressions: []corev1.NodeSelectorRequirement{
{
Key: "kubernetes.io/arch",
Operator: corev1.NodeSelectorOpIn,
Values: []string{arch},
},
{
Key: "kubernetes.io/hostname",
Operator: corev1.NodeSelectorOpIn,
Values: []string{hostIP},
},
},
},
},
},
},
},
}
if hostIP != "" {
// All cache modes use the current chaos node, including dedicated or cordoned nodes.
podSpec.Tolerations = []corev1.Toleration{{Operator: corev1.TolerationOpExists}}
if cacheMode == "hostpath" {
logrus.Debugf("builder cache mode using hostpath, schedule job into current node")
podSpec.NodeSelector = map[string]string{
"kubernetes.io/hostname": hostIP,
}
}
}
return podSpec
}
func (s *slugBuild) runBuildJob(re *Request) error {
//prepare build code dir
re.Logger.Info(util.Translation("Start make code package"), map[string]string{"step": "build-exector"})
start := time.Now()
var sourceTarFileName string
// 只有 git 和 svn 类型需要创建源码 tar 文件
if re.ServerType == "git" || re.ServerType == "svn" {
var err error
// handle nodejs or static dir
if err := s.HandleNodeJsDir(re); err != nil {
logrus.Error("handle nodejs code error:", err)
re.Logger.Error(util.Translation("Handle nodejs code error"), map[string]string{"step": "builder-exector", "status": "failure"})
return err
}
sourceTarFileName, err = s.getSourceCodeTarFile(re)
if err != nil {
return fmt.Errorf("create source code tar file error:%s", err.Error())
}
// remove source cache tar file
defer func() {
os.Remove(sourceTarFileName)
}()
}
re.Logger.Info(util.Translation("make code package success"), map[string]string{"step": "build-exector"})
logrus.Infof("package code for building service %s version %s successful, take time %s", re.ServiceID, re.DeployVersion, time.Now().Sub(start))
name := fmt.Sprintf("%s-%s", re.ServiceID, re.DeployVersion)
namespace := re.RbdNamespace
job := corev1.Pod{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: namespace,
Labels: map[string]string{
"service": re.ServiceID,
"job": "codebuild",
},
},
}
envs := []corev1.EnvVar{
{Name: "SLUG_VERSION", Value: re.DeployVersion},
{Name: "SERVICE_ID", Value: re.ServiceID},
{Name: "TENANT_ID", Value: re.TenantID},
{Name: "CODE_COMMIT_HASH", Value: re.Commit.Hash},
{Name: "CODE_COMMIT_USER", Value: re.Commit.User},
{Name: "CODE_COMMIT_MESSAGE", Value: re.Commit.Message},
{Name: "LANGUAGE", Value: re.Lang.String()},
}
// Add LANG_GOODRAIN_ME from environment variable if set
if langGoodRainMe := os.Getenv("LANG_GOODRAIN_ME"); langGoodRainMe != "" {
envs = append(envs, corev1.EnvVar{Name: "LANG_GOODRAIN_ME", Value: langGoodRainMe})
}
if re.ServerType == "oss" {
envs = append(envs, corev1.EnvVar{Name: "PACKAGE_DOWNLOAD_URL", Value: re.RepositoryURL})
envs = append(envs, corev1.EnvVar{Name: "PACKAGE_DOWNLOAD_USER", Value: re.CodeSouceInfo.User})
envs = append(envs, corev1.EnvVar{Name: "PACKAGE_DOWNLOAD_PASS", Value: re.CodeSouceInfo.Password})
}
var mavenSettingName string
var buildNoCache bool
for k, v := range re.BuildEnvs {
if k == "MAVEN_SETTING_NAME" {
mavenSettingName = v
continue
}
if k == "PROCFILE" {
if !strings.HasPrefix(v, "web:") {
v = "web: " + v
} else if v[4] != ' ' {
v = "web: " + v[4:]
}
}
if k == "RUNTIMES" || k == "GOVERSION" {
var lang string
switch re.Lang {
case code.Python:
lang = "python"
case code.Golang:
lang = "golang"
case code.JavaJar, code.JavaMaven, code.JaveWar, code.Gradle:
lang = "openJDK"
case code.PHP:
lang = "php"
case code.Nodejs, code.NodeJSStatic:
lang = "node"
default:
// Handle combined language types (e.g., "Node.js,static")
if strings.Contains(string(re.Lang), string(code.Nodejs)) {
lang = "node"
}
}
version, err := db.GetManager().LongVersionDao().GetVersionByLanguageAndVersion(lang, v)
if err != nil {
return err
}
if !version.System {
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES", Value: "true"})
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES_URL", Value: fmt.Sprintf("rbd-api-websocket:6060/lg_pack_operate/download/%v/%v", lang, v)})
}
}
if k == "RUNTIMES_MAVEN" {
version, err := db.GetManager().LongVersionDao().GetVersionByLanguageAndVersion("maven", v)
if err != nil {
return err
}
if !version.System {
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES_MAVEN", Value: "true"})
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES_MAVEN_URL", Value: fmt.Sprintf("rbd-api-websocket:6060/lg_pack_operate/download/maven/%v", v)})
}
}
if k == "RUNTIMES_SERVER" {
language := "java_server"
if re.Lang == code.Static || re.Lang == code.PHP {
language = "web_runtime"
}
version, err := db.GetManager().LongVersionDao().GetVersionByLanguageAndVersion(language, v)
if err != nil {
return err
}
if !version.System {
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES_SERVER", Value: "true"})
envs = append(envs, corev1.EnvVar{Name: "CUSTOMIZE_RUNTIMES_SERVER_URL", Value: fmt.Sprintf("rbd-api-websocket:6060/lg_pack_operate/download/%v/%v", language, v)})
}
}
envs = append(envs, corev1.EnvVar{Name: k, Value: v})
if k == "PROC_ENV" {
var mapdata = make(map[string]interface{})
if err := json.Unmarshal([]byte(v), &mapdata); err == nil {
if runtime, ok := mapdata["runtimes"]; ok {
envs = append(envs, corev1.EnvVar{Name: "RUNTIME", Value: runtime.(string)})
}
}
}
if k == "NO_CACHE" && strings.EqualFold(strings.TrimSpace(v), "true") {
buildNoCache = true
}
}
podSpec := newSlugBuildPodSpec(re.Arch, os.Getenv("HOST_IP"), re.CacheMode)
logrus.Debugf("request is: %+v", re)
volumes, mounts := s.createVolumeAndMount(re, sourceTarFileName, buildNoCache)
podSpec.Volumes = volumes
container := corev1.Container{
Name: name,
Image: builder.BUILDERIMAGENAME,
Stdin: true,
StdinOnce: true,
Env: envs,
Args: []string{"local"},
}
container.VolumeMounts = mounts
//set maven setting
var mavenSettingConfigName string
if mavenSettingName != "" && re.Lang.String() == code.JavaMaven.String() {
if setting := jobc.GetJobController().GetLanguageBuildSetting(re.Ctx, code.JavaMaven, mavenSettingName); setting != "" {
mavenSettingConfigName = setting
}
}
if mavenSettingConfigName == "" {
if settingName := jobc.GetJobController().GetDefaultLanguageBuildSetting(re.Ctx, code.JavaMaven); settingName != "" {
mavenSettingConfigName = settingName
} else {
logrus.Warnf("maven setting config %s not found", mavenSettingName)
}
}
if mavenSettingConfigName != "" {
podSpec.Volumes = append(podSpec.Volumes, corev1.Volume{
Name: "mavensetting",
VolumeSource: corev1.VolumeSource{
ConfigMap: &corev1.ConfigMapVolumeSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: mavenSettingConfigName,
},
},
},
})
mountPath := "/etc/maven/setting.xml"
container.VolumeMounts = append(container.VolumeMounts, corev1.VolumeMount{
MountPath: mountPath,
SubPath: "mavensetting",
Name: "mavensetting",
})
container.Env = append(container.Env, corev1.EnvVar{
Name: "MAVEN_SETTINGS_PATH",
Value: mountPath,
})
container.Env = append(container.Env, corev1.EnvVar{
Name: "MAVEN_MIRROR_DISABLE",
Value: "true",
})
logrus.Infof("set maven setting config %s success", mavenSettingName)
}
podSpec.Containers = append(podSpec.Containers, container)
podSpec.HostAliases = append(podSpec.HostAliases, NormalizeHostAliases(re.HostAlias)...)
job.Spec = podSpec
s.setImagePullSecretsForPod(&job)
writer := re.Logger.GetWriter("builder", "info")
reChan := channels.NewRingChannel(10)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Get builder image at build time
if err := s.re.ImageClient.ImagesPullAndPush(builder.BUILDERIMAGENAME, builder.GetBuilderImage(s.re.BRVersion), "", "", re.Logger); err != nil {
failMsg := fmt.Sprintf("%s: %s", util.Translation("Pull builder image failed"), builder.BUILDERIMAGENAME)
re.Logger.Error(failMsg, map[string]string{"step": "builder-exector", "status": "failure"})
return err
}
logrus.Debugf("create job[name: %s; namespace: %s]", job.Name, job.Namespace)
err := jobc.GetJobController().ExecJob(ctx, &job, writer, reChan)
if err != nil {
logrus.Errorf("create new job:%s failed: %s", name, err.Error())
re.Logger.Error(util.Translation("Create build job failed"), map[string]string{"step": "builder-exector", "status": "failure"})
return err
}
re.Logger.Info(util.Translation("create build code job success"), map[string]string{"step": "build-exector"})
logrus.Infof("create build job %s for service %s build version %s", job.Name, re.ServiceID, re.DeployVersion)
// delete job after complete
defer jobc.GetJobController().DeleteJob(job.Name)
return s.waitingComplete(re, reChan)
}
func (s *slugBuild) waitingComplete(re *Request, reChan *channels.RingChannel) (err error) {
var logComplete = false
var jobComplete = false
timeout := time.NewTimer(time.Minute * 60)
for {
select {
case <-timeout.C:
return fmt.Errorf("build time out (more than 60 minute)")
case jobStatus := <-reChan.Out():
status := jobStatus.(string)
switch status {
case "complete":
jobComplete = true
if logComplete {
return nil
}
re.Logger.Info(util.Translation("build code job exec completed"), map[string]string{"step": "build-exector"})
case "failed":
jobComplete = true
err = fmt.Errorf("build code job exec failure")
if logComplete {
return err
}
re.Logger.Info(util.Translation("build code job exec failed"), map[string]string{"step": "build-exector"})
case "cancel":
jobComplete = true
err = fmt.Errorf("build code job is canceled")
if logComplete {
return err
}
case "logcomplete":
logComplete = true
if jobComplete {
return err
}
}
}
}
}
func (s *slugBuild) setImagePullSecretsForPod(pod *corev1.Pod) {
imagePullSecretName := os.Getenv("IMAGE_PULL_SECRET")
if imagePullSecretName == "" {
return
}
pod.Spec.ImagePullSecrets = []corev1.LocalObjectReference{
{Name: imagePullSecretName},
}
}
// ErrorBuild build error
type ErrorBuild struct {
Code int
}
func (e *ErrorBuild) Error() string {
return fmt.Sprintf("Run build return %d", e.Code)
}
func (s *slugBuild) HandleNodeJsDir(re *Request) error {
// For slug builds, use language type to determine if static file handling is needed.
// RUNTIME_TYPE is set by framework detection for CNB builds and should not be used here.
if re.Lang == code.NodeJSStatic {
if ok, _ := util.FileExists(path.Join(re.SourceDir, "nodestatic.json")); ok {
if err := os.RemoveAll(path.Join(re.SourceDir, "nodestatic.json")); err != nil {
logrus.Error("remove nodestatic json error:", err)
return err
}
}
filePtr, err := os.Create(path.Join(re.SourceDir, "nodestatic.json"))
if err != nil {
logrus.Error("create nodestatic json error:", err)
return err
}
defer filePtr.Close()
if dir, ok := re.BuildEnvs["DIST_DIR"]; !ok || dir == "" {
re.BuildEnvs["DIST_DIR"] = "dist"
}
_, err = io.WriteString(filePtr, fmt.Sprintf("{\"path\":\"%v\"}", re.BuildEnvs["DIST_DIR"]))
if err != nil {
logrus.Error("write nodestatic json error:", err)
return err
}
}
// Handle pnpm package manager
if re.BuildEnvs["PACKAGE_TOOL"] == "pnpm" {
// Ensure pnpm-lock.yaml exists
if ok, _ := util.FileExists(path.Join(re.SourceDir, "pnpm-lock.yaml")); !ok {
filePtr, err := os.Create(path.Join(re.SourceDir, "pnpm-lock.yaml"))
if err != nil {
logrus.Error("create pnpm-lock.yaml error:", err)
return err
}
defer filePtr.Close()
}
// Remove conflicting lock files
if ok, _ := util.FileExists(path.Join(re.SourceDir, "package-lock.json")); ok {
if err := os.RemoveAll(path.Join(re.SourceDir, "package-lock.json")); err != nil {
logrus.Error("remove package-lock.json error:", err)
return err
}
}
if ok, _ := util.FileExists(path.Join(re.SourceDir, "yarn.lock")); ok {
if err := os.RemoveAll(path.Join(re.SourceDir, "yarn.lock")); err != nil {
logrus.Error("remove yarn.lock error:", err)
return err
}
}
}
if re.BuildEnvs["PACKAGE_TOOL"] == "yarn" {
if ok, _ := util.FileExists(path.Join(re.SourceDir, "yarn.lock")); !ok {
filePtr, err := os.Create(path.Join(re.SourceDir, "yarn.lock"))
if err != nil {
logrus.Error("create nodestatic json error:", err)
return err
}
defer filePtr.Close()
}
if ok, _ := util.FileExists(path.Join(re.SourceDir, "package-lock.json")); ok {
if err := os.RemoveAll(path.Join(re.SourceDir, "package-lock.json")); err != nil {
logrus.Error("remove package-lock json error:", err)
return err
}
}
}
if re.BuildEnvs["PACKAGE_TOOL"] == "npm" {
if ok, _ := util.FileExists(path.Join(re.SourceDir, "package-lock.json")); !ok {
filePtr, err := os.Create(path.Join(re.SourceDir, "package-lock.json"))
if err != nil {
logrus.Error("create package-lock json error:", err)
return err
}
defer filePtr.Close()
}
if ok, _ := util.FileExists(path.Join(re.SourceDir, "yarn.lock")); ok {
if err := os.RemoveAll(path.Join(re.SourceDir, "yarn.lock")); err != nil {
logrus.Error("remove yarn.lock error:", err)
return err
}
}
}
// Inject .npmrc from UI configuration
if npmrcContent := re.BuildEnvs["NPMRC_CONTENT"]; npmrcContent != "" {
npmrcPath := path.Join(re.SourceDir, ".npmrc")
// Backup existing file
if ok, _ := util.FileExists(npmrcPath); ok {
if err := os.Rename(npmrcPath, npmrcPath+".bak"); err != nil {
logrus.Warn("backup .npmrc error:", err)
}
}
if err := os.WriteFile(npmrcPath, []byte(npmrcContent), 0644); err != nil {
logrus.Error("write .npmrc error:", err)
return err
}
}
// Inject .yarnrc.yml from UI configuration
if yarnrcContent := re.BuildEnvs["YARNRC_CONTENT"]; yarnrcContent != "" {
yarnrcPath := path.Join(re.SourceDir, ".yarnrc.yml")
if err := os.WriteFile(yarnrcPath, []byte(yarnrcContent), 0644); err != nil {
logrus.Error("write .yarnrc.yml error:", err)
return err
}
}
return nil
}