func (j roleBuildJob) Run() {
select {
case <-j.abort:
j.resultsCh <- nil
return
default:
}
roleImageName := GetRoleDevImageName(j.repository, j.role, j.role.GetRoleDevVersion())
if !j.force {
if hasImage, err := j.dockerManager.HasImage(roleImageName); err != nil {
j.resultsCh <- err
return
} else if hasImage {
j.ui.Printf("Skipping build of role image %s because it exists\n", color.YellowString(j.role.Name))
j.resultsCh <- nil
return
}
}
if j.builder.metricsPath != "" {
seriesName := fmt.Sprintf("create-role-images::%s", roleImageName)
stampy.Stamp(j.builder.metricsPath, "fissile", seriesName, "start")
defer stampy.Stamp(j.builder.metricsPath, "fissile", seriesName, "done")
}
j.ui.Printf("Creating Dockerfile for role %s ...\n", color.YellowString(j.role.Name))
dockerfileDir, err := j.builder.CreateDockerfileDir(j.role, j.baseImageName)
if err != nil {
j.resultsCh <- fmt.Errorf("Error creating Dockerfile and/or assets for role %s: %s", j.role.Name, err.Error())
return
}
if j.noBuild {
j.ui.Printf("Skipping build of role image %s because of flag\n", color.YellowString(j.role.Name))
j.resultsCh <- nil
return
}
if !strings.HasSuffix(dockerfileDir, string(os.PathSeparator)) {
dockerfileDir = fmt.Sprintf("%s%c", dockerfileDir, os.PathSeparator)
}
j.ui.Printf("Building docker image of %s in %s ...\n", color.YellowString(j.role.Name), color.YellowString(dockerfileDir))
log := new(bytes.Buffer)
stdoutWriter := docker.NewFormattingWriter(
log,
docker.ColoredBuildStringFunc(roleImageName),
)
err = j.dockerManager.BuildImage(dockerfileDir, roleImageName, stdoutWriter)
if err != nil {
log.WriteTo(j.ui)
j.resultsCh <- fmt.Errorf("Error building image: %s", err.Error())
return
}
j.resultsCh <- nil
}
// GenerateBaseDockerImage generates a base docker image to be used as a FROM for role images
func (f *Fissile) GenerateBaseDockerImage(targetPath, baseImage, metricsPath string, noBuild bool, repository string) error {
if metricsPath != "" {
stampy.Stamp(metricsPath, "fissile", "create-role-base", "start")
defer stampy.Stamp(metricsPath, "fissile", "create-role-base", "done")
}
dockerManager, err := docker.NewImageManager()
if err != nil {
return fmt.Errorf("Error connecting to docker: %s", err.Error())
}
baseImageName := builder.GetBaseImageName(repository, f.Version)
image, err := dockerManager.FindImage(baseImageName)
if err == docker.ErrImageNotFound {
f.UI.Println("Image doesn't exist, it will be created ...")
} else if err != nil {
return fmt.Errorf("Error looking up image: %s", err.Error())
} else {
f.UI.Println(color.GreenString(
"Base role image %s with ID %s already exists. Doing nothing.",
color.YellowString(baseImageName),
color.YellowString(image.ID),
))
return nil
}
if !strings.HasSuffix(targetPath, string(os.PathSeparator)) {
targetPath = fmt.Sprintf("%s%c", targetPath, os.PathSeparator)
}
baseImageBuilder := builder.NewBaseImageBuilder(baseImage)
if noBuild {
f.UI.Println("Skipping image build because of flag.")
return nil
}
f.UI.Println("Building base docker image ...")
log := new(bytes.Buffer)
stdoutWriter := docker.NewFormattingWriter(
log,
docker.ColoredBuildStringFunc(baseImageName),
)
tarPopulator := baseImageBuilder.NewDockerPopulator()
err = dockerManager.BuildImageFromCallback(baseImageName, stdoutWriter, tarPopulator)
if err != nil {
log.WriteTo(f.UI)
return fmt.Errorf("Error building base image: %s", err)
}
f.UI.Println(color.GreenString("Done."))
return nil
}
// GeneratePackagesRoleImage builds the docker image for the packages layer
// where all packages are included
func (f *Fissile) GeneratePackagesRoleImage(repository string, roleManifest *model.RoleManifest, noBuild, force bool, packagesImageBuilder *builder.PackagesImageBuilder) error {
if len(f.releases) == 0 {
return fmt.Errorf("Releases not loaded")
}
dockerManager, err := docker.NewImageManager()
if err != nil {
return fmt.Errorf("Error connecting to docker: %s", err.Error())
}
packagesLayerImageName := packagesImageBuilder.GetRolePackageImageName(roleManifest)
if !force {
if hasImage, err := dockerManager.HasImage(packagesLayerImageName); err == nil && hasImage {
f.UI.Printf("Packages layer %s already exists. Skipping ...\n", color.YellowString(packagesLayerImageName))
return nil
}
}
baseImageName := builder.GetBaseImageName(repository, f.Version)
if hasImage, err := dockerManager.HasImage(baseImageName); err != nil {
return fmt.Errorf("Error getting base image: %s", err)
} else if !hasImage {
return fmt.Errorf("Failed to find role base %s, did you build it first?", baseImageName)
}
if noBuild {
f.UI.Println("Skipping packages layer docker image build because of --no-build flag.")
return nil
}
f.UI.Printf("Building packages layer docker image %s ...\n",
color.YellowString(packagesLayerImageName))
log := new(bytes.Buffer)
stdoutWriter := docker.NewFormattingWriter(
log,
docker.ColoredBuildStringFunc(packagesLayerImageName),
)
tarPopulator := packagesImageBuilder.NewDockerPopulator(roleManifest, force)
err = dockerManager.BuildImageFromCallback(packagesLayerImageName, stdoutWriter, tarPopulator)
if err != nil {
log.WriteTo(f.UI)
return fmt.Errorf("Error building packages layer docker image: %s", err.Error())
}
f.UI.Println(color.GreenString("Done."))
return nil
}