コード例 #1
0
ファイル: pod-push.go プロジェクト: PrFalken/cnt
func (p *Pod) Push() {
	log.Get().Info("Push POD", p.manifest.Name)

	p.Build()

	for _, e := range p.manifest.Pod.Apps {
		aci, err := NewAciWithManifest(p.path+"/"+e.Name, p.args, p.toAciManifest(e))
		if err != nil {
			log.Get().Panic(err)
		}
		aci.PodName = &p.manifest.Name
		aci.Push()
	}

	utils.ExecCmd("curl", "-i",
		"-F", "r=releases",
		"-F", "hasPom=false",
		"-F", "e=pod",
		"-F", "g=com.blablacar.aci.linux.amd64",
		"-F", "p=pod",
		"-F", "v="+p.manifest.Name.Version(),
		"-F", "a="+p.manifest.Name.ShortName(),
		"-F", "file=@"+p.target+POD_TARGET_MANIFEST,
		"-u", config.GetConfig().Push.Username+":"+config.GetConfig().Push.Password,
		config.GetConfig().Push.Url+"/service/local/artifact/maven/content")

}
コード例 #2
0
ファイル: aci-test.go プロジェクト: PrFalken/cnt
func (cnt *Img) Test() {
	log.Get().Info("Testing " + cnt.manifest.NameAndVersion)
	if _, err := os.Stat(cnt.target + "/image.aci"); os.IsNotExist(err) {
		if err := cnt.Build(); err != nil {
			log.Get().Panic("Cannot Install since build failed")
		}
	}

	// prepare runner in target
	// run contauner with mout mpoint
	// run real service in background
	// run tests
	//

	// BATS
	os.MkdirAll(cnt.target+"/test", 0777)
	bats.WriteBats(cnt.target + "/test")

	//	if err := utils.ExecCmd("systemd-nspawn", "--directory=" + cnt.rootfs, "--capability=all",
	//		"--bind=" + cnt.target + "/:/target", "--share-system", "target/build.sh"); err != nil {
	//		log.Get().Panic("Build step did not succeed", err)
	//
	//
	//		utils.ExecCmd("rkt", "--insecure-skip-verify=true", "run", cnt.target + "/image.aci") // TODO missing command override that will arrive in next RKT version
	//	}
}
コード例 #3
0
ファイル: cnt.go プロジェクト: PrFalken/cnt
func discoverAndRunUpdateType(path string, args builder.BuildArgs) {
	if cnt, err := builder.NewAci(path, args); err == nil {
		cnt.UpdateConf()
	} else if _, err := builder.OpenPod(path, args); err == nil {
		log.Get().Panic("Not Yet implemented for pods")
	} else {
		log.Get().Panic("Cannot find cnt-manifest.yml")
	}
}
コード例 #4
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) copyRunlevelsPrestart() {
	if err := os.MkdirAll(cnt.rootfs+"/etc/prestart/late-prestart.d", 0755); err != nil {
		log.Get().Panic(err)
	}
	if err := os.MkdirAll(cnt.rootfs+"/etc/prestart/early-prestart.d", 0755); err != nil {
		log.Get().Panic(err)
	}
	utils.CopyDir(cnt.path+RUNLEVELS_PRESTART, cnt.rootfs+"/etc/prestart/early-prestart.d")
	utils.CopyDir(cnt.path+RUNLEVELS_LATESTART, cnt.rootfs+"/etc/prestart/late-prestart.d")
}
コード例 #5
0
ファイル: pod-manifest.go プロジェクト: PrFalken/cnt
func WritePodManifest(im *schema.PodManifest, targetFile string) {
	buff, err := im.MarshalJSON()
	if err != nil {
		log.Get().Panic(err)
	}
	err = ioutil.WriteFile(targetFile, []byte(buff), 0644)
	if err != nil {
		log.Get().Panic(err)
	}
}
コード例 #6
0
ファイル: pod-test.go プロジェクト: PrFalken/cnt
func (p *Pod) Test() {
	log.Get().Info("Testing POD", p.manifest.Name)

	for _, e := range p.manifest.Pod.Apps {
		aci, err := NewAciWithManifest(p.path+"/"+e.Name, p.args, p.toAciManifest(e))
		if err != nil {
			log.Get().Panic(err)
		}
		aci.PodName = &p.manifest.Name
		aci.Test()
	}
}
コード例 #7
0
ファイル: ac-fullname.go プロジェクト: PrFalken/cnt
func (n *ACFullname) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		log.Get().Panic(err)
		return err
	}
	nn, err := NewACFullName(s)
	if err != nil {
		log.Get().Panic(err)
		return err
	}
	*n = *nn
	return nil
}
コード例 #8
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) copyConfd() {
	if err := os.MkdirAll(cnt.rootfs+"/etc/prestart/", 0755); err != nil {
		log.Get().Panic(err)
	}
	utils.CopyDir(cnt.path+CONFD_CONFIG, cnt.rootfs+"/etc/prestart/conf.d")
	utils.CopyDir(cnt.path+CONFD_TEMPLATE, cnt.rootfs+"/etc/prestart/templates")
}
コード例 #9
0
ファイル: pod-clean.go プロジェクト: PrFalken/cnt
func (p *Pod) Clean() {
	log.Get().Info("Cleaning POD", p.manifest.Name)

	if err := os.RemoveAll(p.target + "/"); err != nil {
		log.Get().Panic("Cannot clean", p.manifest.Name, err)
	}

	for _, e := range p.manifest.Pod.Apps {
		aci, err := NewAciWithManifest(p.path+"/"+e.Name, p.args, p.toAciManifest(e))
		if err != nil {
			log.Get().Panic(err)
		}
		aci.PodName = &p.manifest.Name
		aci.Clean()
	}
}
コード例 #10
0
ファイル: utils.go プロジェクト: PrFalken/cnt
func ExecCmd(head string, parts ...string) error {
	log.Get().Debug("Exec > ", head, " ", strings.Join(parts, " "))
	cmd := exec.Command(head, parts...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}
コード例 #11
0
ファイル: utils.go プロジェクト: PrFalken/cnt
func UserHomeOrFatal() string {
	usr, err := homedir.Dir()
	if err != nil {
		log.Get().Panic(err)
	}
	return usr
}
コード例 #12
0
ファイル: aci.go プロジェクト: PrFalken/cnt
func (i *Img) checkBuilt() {
	if _, err := os.Stat(i.target + "/image.aci"); os.IsNotExist(err) {
		if err := i.Build(); err != nil {
			log.Get().Panic("Cannot Install since build failed")
		}
	}
}
コード例 #13
0
ファイル: aci.go プロジェクト: PrFalken/cnt
func NewAci(path string, args BuildArgs) (*Img, error) {
	manifest, err := readManifest(path + IMG_MANIFEST)
	if err != nil {
		log.Get().Debug(path, IMG_MANIFEST+" does not exists")
		return nil, err
	}
	return NewAciWithManifest(path, args, *manifest)
}
コード例 #14
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) writeImgManifest() {
	log.Get().Debug("Writing aci manifest")
	version := cnt.manifest.NameAndVersion.Version()
	if version == "" {
		version = utils.GenerateVersion()
	}
	utils.WriteImageManifest(&cnt.manifest, cnt.target+"/manifest", cnt.manifest.NameAndVersion.Name(), version)
}
コード例 #15
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) runlevelBuildSetup() {
	files, err := ioutil.ReadDir(cnt.path + RUNLEVELS_BUILD_SETUP)
	if err != nil {
		return
	}

	os.Setenv("BASEDIR", cnt.path)
	os.Setenv("TARGET", cnt.target)
	for _, f := range files {
		if !f.IsDir() {
			log.Get().Info("Running Build setup level : ", f.Name())
			if err := utils.ExecCmd(cnt.path + RUNLEVELS_BUILD_SETUP + "/" + f.Name()); err != nil {
				log.Get().Panic(err)
			}
		}
	}
}
コード例 #16
0
ファイル: aci.go プロジェクト: PrFalken/cnt
func NewAciWithManifest(path string, args BuildArgs, manifest spec.AciManifest) (*Img, error) {
	log.Get().Debug("New aci", path, args, manifest)
	cnt, err := PrepAci(path, args)
	if err != nil {
		return nil, err
	}
	cnt.manifest = manifest
	return cnt, nil
}
コード例 #17
0
ファイル: cnt.go プロジェクト: PrFalken/cnt
func Execute() {
	log.Set(logger.NewLogger())
	currentAbsDir, err := filepath.Abs("")
	if err != nil {
		log.Get().Panic("Cannot find current absolute directory")
	}
	var rootCmd = &cobra.Command{Use: "cnt"}
	buildCmd.Flags().BoolVarP(&buildArgs.Zip, "nozip", "z", false, "Zip final image or not")
	rootCmd.PersistentFlags().BoolVarP(&buildArgs.Clean, "clean", "c", false, "Clean before doing anything")
	rootCmd.PersistentFlags().StringVarP(&buildArgs.TargetPath, "target-path", "t", currentAbsDir, "Set target path")

	rootCmd.AddCommand(buildCmd, cleanCmd, pushCmd, installCmd, testCmd, versionCmd, initCmd, updateCmd)

	config.GetConfig().Load()
	rootCmd.Execute()

	log.Get().Info("Victory !")
}
コード例 #18
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) tarAci() {
	dir, _ := os.Getwd()
	log.Get().Debug("chdir to", cnt.target)
	os.Chdir(cnt.target)

	args := []string{"manifest", "rootfs/"}

	if _, err := os.Stat(cnt.path + RUNLEVELS_BUILD_INHERIT_EARLY); err == nil {
		args = append(args, strings.TrimPrefix(RUNLEVELS_BUILD_INHERIT_EARLY, "/"))
	}
	if _, err := os.Stat(cnt.path + RUNLEVELS_BUILD_INHERIT_LATE); err == nil {
		args = append(args, strings.TrimPrefix(RUNLEVELS_BUILD_INHERIT_LATE, "/"))
	}

	utils.Tar(cnt.args.Zip, "image.aci", args...)
	log.Get().Debug("chdir to", dir)
	os.Chdir(dir)
}
コード例 #19
0
ファイル: cnt.go プロジェクト: PrFalken/cnt
func discoverAndRunTestType(path string, args builder.BuildArgs) {
	if cnt, err := builder.NewAci(path, args); err == nil {
		cnt.Test()
	} else if pod, err := builder.OpenPod(path, args); err == nil {
		pod.Test()
	} else {
		log.Get().Panic("Cannot find cnt-manifest.yml")
	}
}
コード例 #20
0
ファイル: pod-build.go プロジェクト: PrFalken/cnt
func (p *Pod) Build() {
	log.Get().Info("Building POD : ", p.manifest.Name)

	os.MkdirAll(p.target, 0777)
	os.Remove(p.target + POD_TARGET_MANIFEST)

	apps := p.processAci()

	p.writePodManifest(apps)
}
コード例 #21
0
ファイル: utils.go プロジェクト: PrFalken/cnt
func ExecCmdGetOutput(head string, parts ...string) (string, error) {
	var stdout bytes.Buffer

	log.Get().Debug("Exec > ", head, " ", strings.Join(parts, " "))
	cmd := exec.Command(head, parts...)
	cmd.Stdout = &stdout
	cmd.Stderr = os.Stderr
	cmd.Start()
	err := cmd.Wait()
	return strings.TrimSpace(stdout.String()), err
}
コード例 #22
0
ファイル: pod.go プロジェクト: PrFalken/cnt
func (p *Pod) readManifest(manifestPath string) {
	source, err := ioutil.ReadFile(manifestPath)
	if err != nil {
		log.Get().Panic(err)
	}

	err = yaml.Unmarshal([]byte(source), &p.manifest)
	if err != nil {
		log.Get().Panic(err)
	}

	for i, app := range p.manifest.Pod.Apps {
		if app.Name == "" {
			p.manifest.Pod.Apps[i].Name = app.Dependencies[0].ShortName()
		}
	}

	//TODO check that there is no app name conflict

	log.Get().Trace("Pod manifest : ", p.manifest.Name, p.manifest)
}
コード例 #23
0
ファイル: pod-build.go プロジェクト: PrFalken/cnt
func (p *Pod) buildAciIfNeeded(e spec.RuntimeApp) *spec.ACFullname {
	if dir, err := os.Stat(p.path + "/" + e.Name); err == nil && dir.IsDir() {
		aci, err := NewAciWithManifest(p.path+"/"+e.Name, p.args, p.toAciManifest(e))
		if err != nil {
			log.Get().Panic(err)
		}
		aci.PodName = &p.manifest.Name
		aci.Build()
		return &aci.manifest.NameAndVersion
	}
	return nil
}
コード例 #24
0
ファイル: aci-init.go プロジェクト: PrFalken/cnt
func (cnt *Img) Init() {
	initPath := cnt.path
	if cnt.args.Path != "" {
		initPath = cnt.args.Path
	}
	log.Get().Info("Setting up files three")
	uid := "0"
	gid := "0"

	if os.Getenv("SUDO_UID") != "" {
		uid = os.Getenv("SUDO_UID")
		gid = os.Getenv("SUDO_GID")
	}

	uidInt, err := strconv.Atoi(uid)
	gidInt, err := strconv.Atoi(gid)

	if err != nil {
		log.Get().Panic(err)
	}
	folderList := []string{
		RUNLEVELS,
		RUNLEVELS_PRESTART,
		RUNLEVELS_LATESTART,
		RUNLEVELS_BUILD,
		RUNLEVELS_BUILD_SETUP,
		RUNLEVELS_BUILD_INHERIT_EARLY,
		RUNLEVELS_BUILD_INHERIT_LATE,
		CONFD,
		CONFD_TEMPLATE,
		CONFD_CONFIG,
		ATTRIBUTES,
		FILES_PATH,
	}
	for _, folder := range folderList {
		fpath := initPath + "/" + folder
		os.MkdirAll(fpath, 0777)
		os.Lchown(fpath, uidInt, gidInt)
	}
}
コード例 #25
0
ファイル: aci-build.go プロジェクト: PrFalken/cnt
func (cnt *Img) processFrom() {
	if cnt.manifest.From != "" {
		log.Get().Info("Prepare rootfs from " + cnt.manifest.From)

		app, err := discovery.NewAppFromString(string(cnt.manifest.From))
		if app.Labels["os"] == "" {
			app.Labels["os"] = "linux"
		}
		if app.Labels["arch"] == "" {
			app.Labels["arch"] = "amd64"
		}

		endpoint, _, err := discovery.DiscoverEndpoints(*app, false)
		if err != nil {
			panic(err)
		}

		url := endpoint.ACIEndpoints[0].ACI

		aciPath := config.GetConfig().AciPath + "/" + string(cnt.manifest.From)
		if _, err := os.Stat(aciPath + "/image.aci"); cnt.args.ForceUpdate || os.IsNotExist(err) {
			if err := os.MkdirAll(aciPath, 0755); err != nil {
				log.Get().Panic(err)
			}
			if err = utils.ExecCmd("wget", "-O", aciPath+"/image.aci", url); err != nil {
				os.Remove(aciPath + "/image.aci")
				log.Get().Panic("Cannot download from image", err)
			}
		} else {
			log.Get().Info("Image " + cnt.manifest.From + " Already exists locally, will not be downloaded")
		}

		utils.ExecCmd("tar", "xpf", aciPath+"/image.aci", "-C", cnt.target)

		//		utils.ExecCmd("rkt", "--insecure-skip-verify=true", "fetch", cnt.manifest.From)
		//		utils.ExecCmd("rkt", "image", "export", "--overwrite", cnt.manifest.From, cnt.target + "/from.aci")
		//		utils.ExecCmd("tar", "xf", cnt.target + "/from.aci", "-C", cnt.target)
		//		os.Remove(cnt.target + "/from.aci")
	}
}
コード例 #26
0
ファイル: pod-build.go プロジェクト: PrFalken/cnt
func (p *Pod) processAci() []schema.RuntimeApp {
	apps := []schema.RuntimeApp{}
	for _, e := range p.manifest.Pod.Apps {

		aciName := p.buildAciIfNeeded(e)
		// TODO: support not FS override by only storing info pod manifest
		//		if aciName == nil {
		//			aciName = &e.Image
		//		}

		name, _ := types.NewACName(e.Name)

		sum, err := utils.Sha512sum(p.path + "/" + e.Name + "/target/image.aci")
		if err != nil {
			log.Get().Panic(err)
		}

		tmp, _ := types.NewHash("sha512-" + sum)

		labels := types.Labels{}
		labels = append(labels, types.Label{Name: "version", Value: aciName.Version()})
		identifier, _ := types.NewACIdentifier(aciName.Name())
		ttmp := schema.RuntimeImage{Name: identifier, ID: *tmp, Labels: labels}

		if e.App.User == "" {
			e.App.User = "******"
		}
		if e.App.Group == "" {
			e.App.Group = "0"
		}

		apps = append(apps, schema.RuntimeApp{
			Name:  *name,
			Image: ttmp,
			App: &types.App{
				Exec:             e.App.Exec,
				EventHandlers:    e.App.EventHandlers,
				User:             e.App.User,
				Group:            e.App.Group,
				WorkingDirectory: e.App.WorkingDirectory,
				Environment:      e.App.Environment,
				MountPoints:      e.App.MountPoints,
				Ports:            e.App.Ports,
				Isolators:        e.App.Isolators,
			},
			Mounts:      e.Mounts,
			Annotations: e.Annotations})

	}

	return apps
}
コード例 #27
0
ファイル: image-manifest.go プロジェクト: PrFalken/cnt
func WriteImageManifest(m *spec.AciManifest, targetFile string, projectName string, version string) {
	name, _ := types.NewACIdentifier(m.NameAndVersion.Name())

	labels := types.Labels{}
	labels = append(labels, types.Label{Name: "version", Value: m.NameAndVersion.Version()})

	if m.Aci.App.User == "" {
		m.Aci.App.User = "******"
	}
	if m.Aci.App.Group == "" {
		m.Aci.App.Group = "0"
	}

	im := schema.BlankImageManifest()
	im.Annotations = m.Aci.Annotations
	im.Dependencies = toAppcDependencies(m.Aci.Dependencies)
	im.Name = *name
	im.Labels = labels
	im.App = &types.App{
		Exec:             m.Aci.App.Exec,
		EventHandlers:    m.Aci.App.EventHandlers,
		User:             m.Aci.App.User,
		Group:            m.Aci.App.Group,
		WorkingDirectory: m.Aci.App.WorkingDirectory,
		Environment:      m.Aci.App.Environment,
		MountPoints:      m.Aci.App.MountPoints,
		Ports:            m.Aci.App.Ports,
		Isolators:        m.Aci.App.Isolators,
	}

	buff, err := im.MarshalJSON()
	if err != nil {
		log.Get().Panic(err)
	}
	err = ioutil.WriteFile(targetFile, buff, 0644)
	if err != nil {
		log.Get().Panic(err)
	}
}
コード例 #28
0
ファイル: aci.go プロジェクト: PrFalken/cnt
func PrepAci(aciPath string, args BuildArgs) (*Img, error) {
	cnt := new(Img)
	cnt.args = args

	if fullPath, err := filepath.Abs(aciPath); err != nil {
		log.Get().Panic("Cannot get fullpath of project", err)
	} else {
		cnt.path = fullPath
		cnt.target = path.Join(args.TargetPath, "target")
		cnt.rootfs = cnt.target + "/rootfs"
	}
	return cnt, nil
}
コード例 #29
0
ファイル: pod.go プロジェクト: PrFalken/cnt
func OpenPod(path string, args BuildArgs) (*Pod, error) {
	pod := new(Pod)

	if fullPath, err := filepath.Abs(path); err != nil {
		log.Get().Panic("Cannot get fullpath of project", err)
	} else {
		pod.path = fullPath
	}
	pod.args = args
	pod.target = pod.path + "/target"
	pod.readManifest(pod.path + POD_MANIFEST)
	return pod, nil
}
コード例 #30
0
ファイル: aci.go プロジェクト: PrFalken/cnt
func readManifest(manifestPath string) (*spec.AciManifest, error) {
	manifest := spec.AciManifest{Aci: spec.AciDefinition{}}

	source, err := ioutil.ReadFile(manifestPath)
	if err != nil {
		return nil, err
	}
	err = yaml.Unmarshal([]byte(source), &manifest)
	if err != nil {
		log.Get().Panic(err)
	}

	return &manifest, nil
}