func (rktCfg *RktConfig) prepareGlobalArgs(insecureOptions []string) []string {
args := []string{}
cmd := "rkt"
if rktCfg.Path != "" {
cmd = rktCfg.Path
}
args = append(args, cmd)
if logs.IsDebugEnabled() {
args = append(args, "--debug")
}
if rktCfg.TrustKeysFromHttps {
args = append(args, "--trust-keys-from-https")
}
if rktCfg.UserConfig != "" {
args = append(args, "--user-config="+rktCfg.UserConfig)
}
if rktCfg.LocalConfig != "" {
args = append(args, "--local-config="+rktCfg.LocalConfig)
}
if rktCfg.SystemConfig != "" {
args = append(args, "--system-config="+rktCfg.SystemConfig)
}
if rktCfg.dir != "" {
args = append(args, "--rkt.dir="+rktCfg.dir)
}
args = append(args, "--insecure-options="+strings.Join(insecureOptions, ","))
return args
}
func (aci *Aci) prepareRktRunArguments(command common.BuilderCommand, builderHash string, stage1Hash string) []string {
var args []string
if logs.IsDebugEnabled() {
args = append(args, "--debug")
}
args = append(args, "--set-env="+common.EnvDgrVersion+"="+BuildVersion)
args = append(args, "--set-env="+common.EnvLogLevel+"="+logs.GetLevel().String())
args = append(args, "--set-env="+common.EnvAciPath+"="+aci.path)
args = append(args, "--set-env="+common.EnvAciTarget+"="+aci.target)
args = append(args, "--set-env="+common.EnvBuilderCommand+"="+string(command))
args = append(args, "--set-env="+common.EnvCatchOnError+"="+strconv.FormatBool(aci.args.CatchOnError))
args = append(args, "--set-env="+common.EnvCatchOnStep+"="+strconv.FormatBool(aci.args.CatchOnStep))
args = append(args, "--net=host")
args = append(args, "--insecure-options=image")
args = append(args, "--uuid-file-save="+aci.target+pathBuilderUuid)
args = append(args, "--interactive")
if stage1Hash != "" {
args = append(args, "--stage1-hash="+stage1Hash)
} else {
args = append(args, "--stage1-name="+aci.manifest.Builder.Image.String())
}
for _, v := range aci.args.SetEnv.Strings() {
args = append(args, "--set-env="+v)
}
args = append(args, builderHash)
return args
}
func (b *Builder) runBuild() error {
command, err := b.getCommandPath()
if err != nil {
return err
}
logs.WithF(b.fields).Debug("Running build command")
args, env, err := b.prepareNspawnArgsAndEnv(command)
if err != nil {
return err
}
os.Remove(b.stage1Rootfs + "/etc/machine-id")
if logs.IsDebugEnabled() {
logs.WithField("command", strings.Join([]string{args[0], " ", strings.Join(args[1:], " ")}, " ")).Debug("Running external command")
}
// var stderr bytes.Buffer
cmd := exec.Command(args[0], args[1:]...)
cmd.Env = env
cmd.Stdout = os.Stdout
cmd.Stdin = os.Stdin
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
return errs.WithEF(err, b.fields, "Builder run failed")
}
return nil
}
func (s *Service) processCheckResult(check Check) {
s.typedCheckersWithStatus[check.Checker] = &check.Status
var combinedStatus error
for _, status := range s.typedCheckersWithStatus {
if status == nil {
logs.WithF(s.fields).Debug("One check have no value, cannot report yet")
return
}
if combinedStatus == nil {
combinedStatus = *status
}
}
if logs.IsDebugEnabled() {
logs.WithF(s.fields.WithField("status", check).WithField("combined", combinedStatus)).Debug("combined status process")
}
if s.currentStatus == nil ||
(*s.currentStatus == nil && combinedStatus != nil) ||
(*s.currentStatus != nil && combinedStatus == nil) {
s.currentStatus = &combinedStatus
s.runNotify()
} else {
logs.WithF(s.fields).Debug("Combined status is same as previous, no report required")
}
}
func Logger() macaron.Handler {
var reqCounter int64
return func(ctx *macaron.Context, log *log.Logger) {
start := time.Now()
fields := data.WithField("method", ctx.Req.Method).
WithField("uri", ctx.Req.RequestURI).
WithField("ip", ctx.RemoteAddr()).
WithField("id", atomic.AddInt64(&reqCounter, 1))
if logs.IsDebugEnabled() {
logs.WithF(fields).Trace("Request received")
}
rw := ctx.Resp.(macaron.ResponseWriter)
ctx.Next()
if logs.IsInfoEnabled() {
fields = fields.WithField("duration", time.Since(start)).WithField("status", rw.Status())
var lvl logs.Level
if rw.Status() >= 500 && rw.Status() < 600 {
lvl = logs.ERROR
} else {
lvl = logs.DEBUG
}
logs.LogEntry(&logs.Entry{
Fields: fields,
Level: lvl,
Message: "Request completed",
})
}
}
}
func ExecCmd(head string, parts ...string) error {
if logs.IsDebugEnabled() {
logs.WithField("command", strings.Join([]string{head, " ", strings.Join(parts, " ")}, " ")).Debug("Running external command")
}
cmd := exec.Command(head, parts...)
cmd.Stdout = os.Stdout
cmd.Stdin = os.Stdin
cmd.Stderr = os.Stderr
return cmd.Run()
}
func ExecCmdGetStderr(head string, parts ...string) (string, error) {
var stderr bytes.Buffer
if logs.IsDebugEnabled() {
logs.WithField("command", strings.Join([]string{head, " ", strings.Join(parts, " ")}, " ")).Debug("Running external command")
}
cmd := exec.Command(head, parts...)
cmd.Stdout = os.Stdout
cmd.Stderr = &stderr
cmd.Start()
err := cmd.Wait()
return strings.TrimSpace(stderr.String()), err
}
func templateAttribute(text string, attributes interface{}) (string, error) {
tmpl, err := template.New("").Funcs(tpl.TemplateFunctions).Funcs(map[string]interface{}(gtf.GtfFuncMap)).Parse(text)
if err != nil {
return "", errs.WithEF(err, data.WithField("attribute", text), "Failed to parse template for attribute")
}
var b bytes.Buffer
if err := tmpl.Execute(&b, attributes); err != nil {
return "", errs.WithEF(err, data.WithField("attribute", text), "Failed to template attribute")
}
res := b.String()
if logs.IsDebugEnabled() {
logs.WithField("from", text).WithField("to", res).Debug("attribute templated")
}
return res, nil
}
func ProcessManifestTemplate(manifestContent string, data2 interface{}, checkNoValue bool) (*AciManifest, error) {
manifest := AciManifest{Aci: AciDefinition{}}
fields := data.WithField("source", manifestContent)
template, err := template.NewTemplating(nil, "", manifestContent)
if err != nil {
return nil, errs.WithEF(err, fields, "Failed to load templating of manifest")
}
var b bytes.Buffer
writer := bufio.NewWriter(&b)
if err := template.Execute(writer, data2); err != nil {
return nil, errs.WithEF(err, fields, "Failed to template manifest")
}
if err := writer.Flush(); err != nil {
return nil, errs.WithEF(err, fields, "Failed to flush buffer")
}
templated := b.Bytes()
if logs.IsDebugEnabled() {
logs.WithField("content", string(templated)).Debug("Templated manifest")
}
if checkNoValue {
scanner := bufio.NewScanner(bytes.NewReader(templated))
scanner.Split(bufio.ScanLines)
for i := 1; scanner.Scan(); i++ {
text := scanner.Text()
if bytes.Contains([]byte(text), []byte("<no value>")) {
return nil, errs.WithF(fields.WithField("line", i).WithField("text", text), "Templating result of manifest have <no value>")
}
}
}
err = yaml.Unmarshal(templated, &manifest)
if err != nil {
return nil, errs.WithEF(err, fields, "Cannot unmarshall manifest")
}
return &manifest, nil
}
func (b *Builder) prepareNspawnArgsAndEnv(commandPath string) ([]string, []string, error) {
var args []string
env := os.Environ()
args = append(args, b.stage1Rootfs+"/dgr/usr/lib/ld-linux-x86-64.so.2")
args = append(args, b.stage1Rootfs+"/dgr/usr/bin/systemd-nspawn")
if context := os.Getenv(rktcommon.EnvSELinuxContext); context != "" {
args = append(args, fmt.Sprintf("-Z%s", context))
}
args = append(args, "--register=no")
args = append(args, "-q")
args = append(args, "--link-journal=auto")
env = append(env, "LD_LIBRARY_PATH="+b.stage1Rootfs+"/dgr/usr/lib")
if !logs.IsDebugEnabled() {
args = append(args, "--quiet")
}
lvl := "info"
switch logs.GetLevel() {
case logs.FATAL:
lvl = "crit"
case logs.PANIC:
lvl = "alert"
case logs.ERROR:
lvl = "err"
case logs.WARN:
lvl = "warning"
case logs.INFO:
lvl = "info"
case logs.DEBUG | logs.TRACE:
lvl = "debug"
}
args = append(args, "--uuid="+b.pod.UUID.String())
args = append(args, "--machine=dgr"+b.pod.UUID.String())
env = append(env, "SYSTEMD_LOG_LEVEL="+lvl)
for _, e := range manifestApp(b.pod).App.Environment {
if e.Name != common.EnvBuilderCommand && e.Name != common.EnvAciTarget {
args = append(args, "--setenv="+e.Name+"="+e.Value)
}
}
catchError, _ := manifestApp(b.pod).App.Environment.Get(common.EnvCatchOnError)
catchStep, _ := manifestApp(b.pod).App.Environment.Get(common.EnvCatchOnStep)
args = append(args, "--setenv="+common.EnvCatchOnError+"="+string(catchError))
args = append(args, "--setenv="+common.EnvCatchOnStep+"="+string(catchStep))
version, ok := manifestApp(b.pod).Image.Labels.Get("version")
if ok {
args = append(args, "--setenv=ACI_VERSION="+version)
}
args = append(args, "--setenv=ACI_NAME="+manifestApp(b.pod).Name.String())
args = append(args, "--setenv=ACI_EXEC="+"'"+strings.Join(manifestApp(b.pod).App.Exec, "' '")+"'")
args = append(args, "--setenv=ROOTFS="+PATH_OPT+PATH_STAGE2+"/"+manifestApp(b.pod).Name.String()+common.PathRootfs)
args = append(args, "--capability=all")
args = append(args, "--directory="+b.stage1Rootfs)
args = append(args, "--bind="+b.aciHomePath+"/:/dgr/aci-home")
args = append(args, "--bind="+b.aciTargetPath+"/:/dgr/aci-target")
//
content, err := ioutil.ReadFile(b.aciTargetPath + common.PathManifestYmlTmpl)
if err != nil {
return args, env, errs.WithEF(err, b.fields.WithField("file", b.aciTargetPath+common.PathManifestYmlTmpl), "Failed to read manifest template")
}
aciManifest, err := common.ProcessManifestTemplate(string(content), nil, false)
if err != nil {
return args, env, errs.WithEF(err, b.fields.WithField("content", string(content)), "Failed to process manifest template")
}
for _, mount := range aciManifest.Builder.MountPoints {
if strings.HasPrefix(mount.From, "~/") {
user, err := user.Current()
if err != nil {
return args, env, errs.WithEF(err, b.fields, "Cannot found current user")
}
mount.From = user.HomeDir + mount.From[1:]
}
from := mount.From
if from[0] != '/' {
from = b.aciHomePath + "/" + from
}
if _, err := os.Stat(from); err != nil {
os.MkdirAll(from, 0755)
}
args = append(args, "--bind="+from+":"+mount.To)
}
for _, mount := range aciManifest.Build.MountPoints {
if strings.HasPrefix(mount.From, "~/") {
user, err := user.Current()
if err != nil {
return args, env, errs.WithEF(err, b.fields, "Cannot found current user")
}
mount.From = user.HomeDir + mount.From[1:]
}
from := mount.From
if from[0] != '/' {
from = b.aciHomePath + "/" + from
}
if _, err := os.Stat(from); err != nil {
os.MkdirAll(from, 0755)
}
args = append(args, "--bind="+from+":"+PATH_OPT+PATH_STAGE2+"/"+manifestApp(b.pod).Name.String()+common.PathRootfs+"/"+mount.To)
}
args = append(args, commandPath)
return args, env, nil
}