func Run(overrideEnvVarName string, target string, templaterDir string, continueOnError bool) {
attrMerger, err := merger.NewAttributesMerger(templaterDir + pathAttributes)
if err != nil {
logs.WithE(err).Warn("Failed to prepare attributes")
}
attributes := attrMerger.Merge()
attributes = overrideWithJsonIfNeeded(overrideEnvVarName, attributes)
tt, err := merger.ProcessAttributesTemplating(attributes, attributes)
attributes = tt.(map[string]interface{})
if err != nil {
logs.WithField("dir", templaterDir+pathTemplates).Fatal("Failed to template attributes")
}
logs.WithField("content", attributes).Debug("Final attributes resolution")
info, _ := os.Stat(templaterDir + pathTemplates)
if info == nil {
logs.WithField("dir", templaterDir+pathTemplates).Debug("Template dir is empty. Nothing to template")
return
}
tmpl, err := template.NewTemplateDir(templaterDir+pathTemplates, target, continueOnError)
if err != nil {
logs.WithE(err).WithField("dir", templaterDir+pathTemplates).Fatal("Failed to load template dir")
}
err = tmpl.Process(attributes)
if err != nil {
logs.WithE(err).WithField("dir", templaterDir+pathTemplates).Fatal("Failed to process template dir")
}
}
func NewHome(path string) HomeStruct {
logs.WithField("path", path).Debug("Loading home")
var config Config
if source, err := ioutil.ReadFile(path + "/config.yml"); err == nil {
err = yaml.Unmarshal([]byte(source), &config)
if err != nil {
logs.WithEF(err, data.WithField("path", path+"/config.yml")).Fatal("Failed to process configuration file")
}
} else if source, err := ioutil.ReadFile(DefaultHomeFolder("cnt") + "/config.yml"); err == nil {
logs.WithField("old", DefaultHomeFolder("cnt")+"/config.yml").WithField("new", DefaultHomeFolder("")).Warn("You are using old home folder")
err = yaml.Unmarshal([]byte(source), &config)
if err != nil {
logs.WithEF(err, data.WithField("path", path+"/config.yml")).Fatal("Failed to process configuration file")
}
}
if Args.NoStore {
config.Rkt.NoStore = true
}
if Args.StoreOnly {
config.Rkt.StoreOnly = true
}
rkt, err := common.NewRktClient(config.Rkt)
if err != nil {
logs.WithEF(err, data.WithField("config", config.Rkt)).Fatal("Rkt access failed")
}
return HomeStruct{
path: path,
Config: config,
Rkt: rkt,
}
}
func overrideWithJsonIfNeeded(overrideEnvVarName string, attributes map[string]interface{}) map[string]interface{} {
if overrideEnvVarName != "" {
if envjson := os.Getenv(overrideEnvVarName); envjson != "" {
if len(envjson) > 8 && envjson[0:7] == "base64," {
logs.WithField("EnvVar", overrideEnvVarName).Debug("Environment variable is base64 encoded")
b64EnvJson := envjson[7:len(envjson)]
envjsonBase64Decoded, err := base64.StdEncoding.DecodeString(b64EnvJson)
if err != nil {
logs.WithE(err).WithField("base64", b64EnvJson).Fatal("Failed to base64 decode")
}
envjson = string(envjsonBase64Decoded)
}
logs.WithField("content", envjson).Debug("Override var content")
var envattr map[string]interface{}
err := json.Unmarshal([]byte(envjson), &envattr)
if err != nil {
logs.WithE(err).
WithField("varName", overrideEnvVarName).
WithField("content", envjson).
Fatal("Invalid format for environment override content")
}
attributes = mergemap.Merge(attributes, envattr)
}
}
return attributes
}
func (aci *Aci) tarAci(zip bool) {
target := PATH_IMAGE_ACI[1:]
if zip {
target = PATH_IMAGE_ACI_ZIP[1:]
}
dir, _ := os.Getwd()
logs.WithField("path", aci.target).Debug("chdir")
os.Chdir(aci.target)
utils.Tar(zip, target, PATH_MANIFEST[1:], PATH_ROOTFS[1:])
logs.WithField("path", dir).Debug("chdir")
os.Chdir(dir)
}
func (b *Builder) runBuildSetup() error { //TODO REMOVE
if empty, err := common.IsDirEmpty(b.aciHomePath + PATH_RUNLEVELS + PATH_BUILD_SETUP); empty || err != nil {
return nil
}
logs.WithF(b.fields).Info("Running build setup")
for _, e := range manifestApp(b.pod).App.Environment {
logs.WithField("name", e.Name).WithField("value", e.Value).Debug("Adding environment var")
os.Setenv(e.Name, e.Value)
}
logs.WithF(b.fields).Warn("Build setup is deprecated and will be removed. it create unreproductible builds and run as root directly on the host. Please use builder dependencies and builder runlevels instead")
time.Sleep(5 * time.Second)
os.Setenv("BASEDIR", b.aciHomePath)
os.Setenv("TARGET", b.stage2Rootfs+"/..")
os.Setenv("ROOTFS", b.stage2Rootfs+"/../rootfs")
os.Setenv(common.EnvLogLevel, logs.GetLevel().String())
if err := common.ExecCmd(b.stage1Rootfs + PATH_DGR + PATH_BUILDER + "/stage2/build-setup.sh"); err != nil {
return errs.WithEF(err, b.fields, "Build setup failed")
}
return nil
}
// list input files
func (in *inputs) listFiles() error {
list_l1, err := ioutil.ReadDir(in.Directory)
if err != nil {
return err
}
for _, f_l1 := range list_l1 {
if f_l1.Mode()&os.ModeSymlink == os.ModeSymlink {
followed_file, err := os.Readlink(in.Directory + "/" + f_l1.Name())
if err != nil {
return err
}
if followed_file[0] != '/' {
followed_file = in.Directory + "/" + followed_file
}
f_l1, err = os.Lstat(followed_file)
if err != nil {
return err
}
logs.WithField("followed_link", f_l1.Name()).Trace("Followed Link")
}
if f_l1.IsDir() {
list_l2, err := ioutil.ReadDir(in.Directory + "/" + f_l1.Name())
if err != nil {
return err
}
for _, f_l2 := range list_l2 {
in.Files = append(in.Files, f_l1.Name()+"/"+f_l2.Name())
}
} else {
in.Files = append(in.Files, f_l1.Name())
}
}
return nil
}
func (b *Builder) tarAci() error {
upperId, err := b.upperTreeStoreId()
if err != nil {
return err
}
upperPath := b.pod.Root + PATH_OVERLAY + "/" + upperId + PATH_UPPER
upperNamedRootfs := upperPath + "/" + manifestApp(b.pod).Name.String()
upperRootfs := upperPath + common.PathRootfs
if err := os.Rename(upperNamedRootfs, upperRootfs); err != nil { // TODO this is dirty and can probably be renamed during tar
return errs.WithEF(err, b.fields.WithField("path", upperNamedRootfs), "Failed to rename rootfs")
}
defer os.Rename(upperRootfs, upperNamedRootfs)
dir, err := os.Getwd()
if err != nil {
return errs.WithEF(err, b.fields, "Failed to get current working directory")
}
defer func() {
if err := os.Chdir(dir); err != nil {
logs.WithEF(err, b.fields.WithField("path", dir)).Warn("Failed to chdir back")
}
}()
if err := os.Chdir(upperPath); err != nil {
return errs.WithEF(err, b.fields.WithField("path", upperPath), "Failed to chdir to upper base path")
}
if err := common.Tar(b.aciTargetPath+common.PathImageAci, common.PathManifest[1:], common.PathRootfs[1:]+"/"); err != nil {
return errs.WithEF(err, b.fields, "Failed to tar aci")
}
logs.WithField("path", dir).Debug("chdir")
return nil
}
func NewAciWithManifest(path string, args BuildArgs, manifest spec.AciManifest, checked *chan bool) (*Aci, error) {
if manifest.NameAndVersion == "" {
logs.WithField("path", path).Fatal("name is mandatory in manifest")
}
fields := data.WithField("aci", manifest.NameAndVersion.String())
logs.WithF(fields).WithFields(data.Fields{"args": args, "path": path, "manifest": manifest}).Debug("New aci")
fullPath, err := filepath.Abs(path)
if err != nil {
return nil, errs.WithEF(err, fields, "Cannot get fullpath of project")
}
target := fullPath + PATH_TARGET
if cnt.Home.Config.TargetWorkDir != "" {
currentAbsDir, err := filepath.Abs(cnt.Home.Config.TargetWorkDir + "/" + manifest.NameAndVersion.ShortName())
if err != nil {
return nil, errs.WithEF(err, fields.WithField("path", path), "Invalid target path")
}
target = currentAbsDir
}
aci := &Aci{
fields: fields,
args: args,
path: fullPath,
manifest: manifest,
target: target,
rootfs: target + PATH_ROOTFS,
FullyResolveDep: true,
}
go aci.checkLatestVersions(checked)
return aci, nil
}
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 (w Work) ListEnvs() []string {
path := ggn.Home.Config.WorkPath + PATH_ENV
if _, err := os.Stat(path); os.IsNotExist(err) {
logs.WithEF(err, w.fields).WithField("path", path).Fatal("env directory not found")
}
files, err := ioutil.ReadDir(path)
if err != nil {
logs.WithEF(err, w.fields).WithField("path", path).Fatal("Cannot read env directory")
}
var envs []string
for _, file := range files {
if file.Mode()&os.ModeSymlink == os.ModeSymlink {
followed_file, err := os.Readlink(path + "/" + file.Name())
if err != nil {
continue
}
if followed_file[0] != '/' {
followed_file = path + "/" + followed_file
}
file, err = os.Lstat(followed_file)
if err != nil {
continue
}
logs.WithField("followed_link", file.Name()).Trace("Followed Link")
}
if !file.IsDir() {
continue
}
envs = append(envs, file.Name())
}
return envs
}
func ExecCommandFull(cmd []string, env []string, timeoutInMilli int) error {
command := exec.Command(cmd[0], cmd[1:]...)
var b bytes.Buffer
command.Stdout = &b
command.Stderr = &b
command.Env = env
if err := command.Start(); err != nil {
return errs.WithEF(err, data.WithField("cmd", cmd), "Failed to start command")
}
var after *errs.EntryError
timer := time.AfterFunc(time.Duration(timeoutInMilli)*time.Millisecond, func() {
data := data.WithField("command", strings.Join(cmd, " ")).WithField("timeout", timeoutInMilli)
logs.WithF(data).Debug("Command timeout")
after = errs.WithF(data, "Exec command timeout")
command.Process.Kill()
})
err := command.Wait()
timer.Stop()
if logs.IsTraceEnabled() {
logs.WithField("cmd", cmd).WithField("output", string(b.Bytes())).Trace("Command output")
}
if err != nil {
return errs.WithEF(err, data.WithField("cmd", cmd).
WithField("output", string(b.Bytes())), "Command failed").
WithErr(after)
}
return nil
}
func loadEnvCommandsReturnNewRoot(osArgs []string, rootCmd *cobra.Command) *cobra.Command {
logs.WithField("path", ggn.Home.Config.WorkPath).Debug("Loading envs")
work := work.NewWork(ggn.Home.Config.WorkPath)
newRootCmd := &cobra.Command{
Use: "ggn",
}
for _, envNames := range work.ListEnvs() {
env := work.LoadEnv(envNames)
envCmd := &cobra.Command{
Use: env.GetName(),
Short: "Run command for " + env.GetName(),
Run: func(cmd *cobra.Command, args []string) {
newRootCmd.AddCommand(prepareEnvCommands(env))
newRootCmd.SetArgs(osArgs[1:])
newRootCmd.Execute()
},
}
rootCmd.AddCommand(envCmd)
}
return newRootCmd
}
func (n ACFullname) LatestVersion() (string, error) {
app, err := discovery.NewAppFromString(n.Name() + ":latest")
if app.Labels["os"] == "" {
app.Labels["os"] = "linux"
}
if app.Labels["arch"] == "" {
app.Labels["arch"] = "amd64"
}
endpoints, _, err := discovery.DiscoverACIEndpoints(*app, nil, discovery.InsecureTLS|discovery.InsecureHTTP) //TODO support security
if err != nil {
return "", errors.Annotate(err, "Latest discovery fail")
}
r, _ := regexp.Compile(`^\d+(.\d+){0,2}(-[\.\-\dA-Za-z]+){0,1}$`) // TODO this is nexus specific
if len(endpoints) == 0 {
return "", errs.WithF(data.WithField("aci", string(n)), "Discovery does not give an endpoint to check latest version")
}
url := getRedirectForLatest(endpoints[0].ACI)
logs.WithField("url", url).Debug("latest verion url")
for _, part := range strings.Split(url, "/") {
if r.Match([]byte(part)) {
return part, nil
}
}
return "", errors.New("No latest version found")
}
func (n ACFullname) LatestVersion() (string, error) {
app, err := discovery.NewAppFromString(n.Name() + ":latest")
if app.Labels["os"] == "" {
app.Labels["os"] = "linux"
}
if app.Labels["arch"] == "" {
app.Labels["arch"] = "amd64"
}
endpoint, _, err := discovery.DiscoverEndpoints(*app, nil, false)
if err != nil {
return "", errors.Annotate(err, "Latest discovery fail")
}
r, _ := regexp.Compile(`^(\d+\.)?(\d+\.)?(\*|\d+)(\-[\dA-Za-z]+){0,1}$`)
url := getRedirectForLatest(endpoint.ACIEndpoints[0].ACI)
logs.WithField("url", url).Debug("latest verion url")
for _, part := range strings.Split(url, "/") {
if r.Match([]byte(part)) {
return part, nil
}
}
return "", errors.New("No latest version found")
}
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 buildAciOrPod(path string, args builder.BuildArgs) spec.CntCommand {
if aci, err := builder.NewAci(path, args); err == nil {
return aci
} else if pod, err2 := builder.NewPod(path, args); err2 == nil {
return pod
} else {
logs.WithField("path", path).WithField("err", err).WithField("err2", err2).Fatal("Cannot construct aci or pod")
}
return nil
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
sigQuitThreadDump()
var logLevel string
var version bool
rootCmd := &cobra.Command{
Use: "nerve config.yml",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
if version {
fmt.Println("Nerve")
fmt.Println("Version :", Version)
fmt.Println("Build Time :", BuildTime)
os.Exit(0)
}
if logLevel != "" {
level, err := logs.ParseLevel(logLevel)
if err != nil {
logs.WithField("value", logLevel).Fatal("Unknown log level")
}
logs.SetLevel(level)
}
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) != 1 {
logs.Fatal("Nerve require a configuration file as argument")
}
nerve, err := LoadConfig(args[0])
if err != nil {
logs.WithE(err).Fatal("Cannot start, failed to load configuration")
}
if err := nerve.Init(Version, BuildTime, logLevel != ""); err != nil {
logs.WithE(err).Fatal("Failed to init nerve")
}
startStatus := make(chan error)
go nerve.Start(startStatus)
if status := <-startStatus; status != nil {
logs.WithE(status).Fatal("Failed to start nerve")
}
waitForSignal()
nerve.Stop()
},
}
rootCmd.PersistentFlags().StringVarP(&logLevel, "log-level", "L", "", "Set log level")
rootCmd.PersistentFlags().BoolVarP(&version, "version", "V", false, "Display version")
if err := rootCmd.Execute(); err != nil {
logs.WithE(err).Fatal("Failed to process args")
}
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
sigQuitThreadDump()
var logLevel string
var version bool
var oneshot bool
rootCmd := &cobra.Command{
Use: "synapse config.yml",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
if version {
fmt.Println("Synapse")
fmt.Println("Version :", Version)
fmt.Println("Build Time :", BuildTime)
os.Exit(0)
}
if logLevel != "" {
level, err := logs.ParseLevel(logLevel)
if err != nil {
logs.WithField("value", logLevel).Fatal("Unknown log level")
}
logs.SetLevel(level)
}
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) != 1 {
logs.Fatal("Synapse require a configuration file as argument")
}
synapse, err := LoadConfig(args[0])
if err != nil {
logs.WithE(err).Fatal("Cannot start, failed to load configuration")
}
if err := synapse.Init(Version, BuildTime, logLevel != ""); err != nil {
logs.WithE(err).Fatal("Failed to init synapse")
}
if err := synapse.Start(oneshot); err != nil {
logs.WithE(err).Fatal("Failed to start synapse")
}
waitForSignal()
synapse.Stop()
},
}
rootCmd.PersistentFlags().StringVarP(&logLevel, "log-level", "L", "", "Set log level")
rootCmd.PersistentFlags().BoolVarP(&version, "version", "V", false, "Display version")
//rootCmd.PersistentFlags().BoolVarP(&oneshot, "oneshot", "O", false, "run watchers/router only once and exit")
if err := rootCmd.Execute(); err != nil {
logs.WithE(err).Fatal("Failed to process args")
}
}
func NewAciWithManifest(path string, args BuildArgs, manifestTmpl string, checkWg *sync.WaitGroup) (*Aci, error) {
manifest, err := common.ProcessManifestTemplate(manifestTmpl, nil, false)
if err != nil {
return nil, errs.WithEF(err, data.WithField("content", manifestTmpl), "Failed to process manifest")
}
if manifest.NameAndVersion == "" {
logs.WithField("path", path).Fatal("name is mandatory in manifest")
}
fields := data.WithField("aci", manifest.NameAndVersion.String())
logs.WithF(fields).WithFields(data.Fields{"args": args, "path": path, "manifest": manifest}).Debug("New aci")
fullPath, err := filepath.Abs(path)
if err != nil {
return nil, errs.WithEF(err, fields, "Cannot get fullpath of project")
}
target := fullPath + pathTarget
if Home.Config.TargetWorkDir != "" {
currentAbsDir, err := filepath.Abs(Home.Config.TargetWorkDir + "/" + manifest.NameAndVersion.ShortName())
if err != nil {
return nil, errs.WithEF(err, fields.WithField("path", path), "Invalid target path")
}
target = currentAbsDir
}
aci := &Aci{
fields: fields,
args: args,
path: fullPath,
manifestTmpl: manifestTmpl,
manifest: manifest,
target: target,
FullyResolveDep: true,
checkWg: checkWg,
}
froms, err := manifest.GetFroms()
if err != nil {
logs.WithEF(err, aci.fields).Fatal("Invalid from data")
}
if len(froms) != 0 {
if froms[0].String() == "" {
logs.WithF(aci.fields).Warn("From is deprecated and empty, remove it")
} else {
logs.WithF(aci.fields).Warn("From is deprecated and processed as dependency. move from to dependencies")
aci.manifest.Aci.Dependencies = append(froms, aci.manifest.Aci.Dependencies...)
}
}
return aci, nil
}
func CheckLatestVersion(deps []common.ACFullname, warnText string) {
for _, dep := range deps {
if dep.Version() == "" {
continue
}
version, _ := dep.LatestVersion()
if version != "" && common.Version(dep.Version()).LessThan(common.Version(version)) {
logs.WithField("newer", dep.Name()+":"+version).
WithField("current", dep.String()).
Warn("Newer " + warnText + " version")
}
}
}
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 (aci *Aci) RunBuilderCommand(command common.BuilderCommand) error {
defer aci.giveBackUserRightsToTarget()
logs.WithF(aci.fields).Info("Building")
if err := os.MkdirAll(aci.target, 0777); err != nil {
return errs.WithEF(err, aci.fields, "Cannot create target directory")
}
if err := ioutil.WriteFile(aci.target+common.PathManifestYmlTmpl, []byte(aci.manifestTmpl), 0644); err != nil {
return errs.WithEF(err, aci.fields.WithField("file", aci.target+common.PathManifestYmlTmpl), "Failed to write manifest template")
}
stage1Hash, err := aci.prepareStage1aci()
if err != nil {
return errs.WithEF(err, aci.fields, "Failed to prepare stage1 image")
}
builderHash, err := aci.prepareBuildAci()
if err != nil {
return errs.WithEF(err, aci.fields, "Failed to prepare build image")
}
logs.WithF(aci.fields).Info("Calling rkt to start build")
defer aci.cleanupRun(builderHash, stage1Hash)
if err := Home.Rkt.Run(aci.prepareRktRunArguments(command, builderHash, stage1Hash)); err != nil {
return errs.WithEF(err, aci.fields, "Builder container return with failed status")
}
content, err := common.ExtractManifestContentFromAci(aci.target + pathImageAci)
if err != nil {
logs.WithEF(err, aci.fields).Warn("Failed to write manifest.json")
}
if err := ioutil.WriteFile(aci.target+pathManifestJson, content, 0644); err != nil {
logs.WithEF(err, aci.fields).Warn("Failed to write manifest.json")
}
im := &schema.ImageManifest{}
if err = im.UnmarshalJSON(content); err != nil {
return errs.WithEF(err, aci.fields.WithField("content", string(content)), "Cannot unmarshall json content")
}
fullname := common.ExtractNameVersionFromManifest(im)
logs.WithField("fullname", *fullname).Info("Finished building aci")
if err := ioutil.WriteFile(aci.target+pathVersion, []byte(*fullname), 0644); err != nil {
return errs.WithEF(err, aci.fields, "Failed to write version file in target")
}
return nil
}
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 NewHome(path string) HomeStruct {
logs.WithField("path", path).Debug("Loading home")
var config Config
if source, err := ioutil.ReadFile(path + "/config.yml"); err == nil {
err = yaml.Unmarshal([]byte(source), &config)
if err != nil {
panic(err)
}
}
return HomeStruct{
path: path,
Config: config,
}
}
func overrideWithJsonIfNeeded(overrideEnvVarName string, attributes map[string]interface{}) map[string]interface{} {
if overrideEnvVarName != "" {
if envjson := os.Getenv(overrideEnvVarName); envjson != "" {
logs.WithField("content", envjson).Debug("Override var content")
var envattr map[string]interface{}
err := json.Unmarshal([]byte(envjson), &envattr)
if err != nil {
logs.WithE(err).
WithField("varName", overrideEnvVarName).
WithField("content", envjson).
Fatal("Invalid format for environment override content")
}
attributes = mergemap.Merge(attributes, envattr)
}
}
return attributes
}
func (u *Unit) Check(command string) {
if err := u.Service.Generate(); err != nil {
logs.WithEF(err, u.Fields).Fatal("Generate failed")
}
logs.WithFields(u.Fields).Debug("Check")
info := HookInfo{
Service: u.Service,
Unit: u,
Action: "check",
Command: command,
}
u.Service.GetEnv().RunEarlyHook(info)
defer u.Service.GetEnv().RunLateHook(info)
statuses := u.Service.GetEnv().ListUnits()
var status UnitStatus
if _, ok := statuses[u.Filename]; !ok {
logs.WithFields(u.Fields).Warn("cannot find unit on fleet")
return
}
status = statuses[u.Filename]
logs.WithField("status", status).Debug("status")
if status.Active != ACTIVE_ACTIVE {
logs.WithFields(u.Fields).WithField("active", status.Active).Warn("unit status is not active")
return
}
if status.Sub != SUB_RUNNING {
logs.WithFields(u.Fields).WithField("sub", status.Sub).Warn("unit sub is not running")
return
}
same, err := u.IsLocalContentSameAsRemote()
if err != nil {
logs.WithFields(u.Fields).Error("Cannot read unit")
return
}
if !same {
logs.WithFields(u.Fields).Warn("Unit is not up to date")
return
}
}
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 NewPod(path string, args BuildArgs, checkWg *sync.WaitGroup) (*Pod, error) {
if (args.CatchOnError || args.CatchOnStep) && !args.SerialBuild {
args.SerialBuild = true
}
fullPath, err := filepath.Abs(path)
if err != nil {
logs.WithE(err).WithField("path", path).Fatal("Cannot get fullpath")
}
manifest, err := readPodManifest(fullPath + pathPodManifestYml)
if err != nil {
manifest2, err2 := readPodManifest(fullPath + "/cnt-pod-manifest.yml")
if err2 != nil {
return nil, errs.WithEF(err, data.WithField("path", fullPath+pathPodManifestYml).WithField("err2", err2), "Failed to read pod manifest")
}
logs.WithField("old", "cnt-pod-manifest.yml").WithField("new", "pod-manifest.yml").Warn("You are using the old aci configuration file")
manifest = manifest2
}
fields := data.WithField("pod", manifest.Name.String())
target := path + pathTarget
if Home.Config.TargetWorkDir != "" {
currentAbsDir, err := filepath.Abs(Home.Config.TargetWorkDir + "/" + manifest.Name.ShortName())
if err != nil {
logs.WithEF(err, fields).Panic("invalid target path")
}
target = currentAbsDir
}
pod := &Pod{
checkWg: checkWg,
fields: fields,
path: fullPath,
args: args,
target: target,
manifest: *manifest,
}
return pod, nil
}
func (e *Env) addIncludeFiles(files []string) ([]string, error) {
type includeFiles struct {
Include []string
}
for _, file := range files {
var f includeFiles
yml, err := ioutil.ReadFile(file)
if err != nil {
return nil, err
}
err = yaml.Unmarshal(yml, &f)
for _, inclusion := range f.Include {
sepCount := strings.Count(inclusion, ":")
if sepCount == 2 {
fields := strings.Split(inclusion, ":")
includeFile := strings.Replace(fields[2], ".", "/", -1) + ".yml"
if fields[1] == "" {
logs.WithField("include", inclusion).Fatal("Trying to include environment attributes from itself")
} else { // env:prod-dc1:some.include
includeFile = fmt.Sprintf("%v%v/%v%v/%v",
ggn.Home.Config.WorkPath,
PATH_ENV,
fields[1],
PATH_COMMON_ATTRIBUTES,
includeFile,
)
files = append(files, includeFile)
}
} else { // some.global.include
includeFile := strings.Replace(inclusion, ".", "/", -1) + ".yml"
includeFile = fmt.Sprintf("%v%v/%v", ggn.Home.Config.WorkPath, PATH_COMMON_ATTRIBUTES, includeFile)
files = append(files, includeFile)
}
}
}
return files, nil
}
func NewRktClient(config RktConfig) (*RktClient, error) {
if len(config.InsecureOptions) == 0 {
config.InsecureOptions = []string{"ondisk", "image"}
}
rkt := &RktClient{
fields: data.WithField("config", config),
config: config,
globalArgs: config.prepareGlobalArgs(config.InsecureOptions),
}
v, err := rkt.Version()
if err != nil {
return nil, err
}
if v.LessThan(rktSupportedVersion) {
return nil, errs.WithF(rkt.fields.WithField("current", v).WithField("required", ">="+rktSupportedVersion), "Unsupported version of rkt")
}
logs.WithField("version", v).WithField("args", rkt.globalArgs).Debug("New rkt client")
return rkt, nil
}