// New returns a new instance of OnBuild builder
func New(config *api.Config, overrides build.Overrides) (*OnBuild, error) {
dockerHandler, err := docker.New(config.DockerConfig, config.PullAuthentication)
if err != nil {
return nil, err
}
b := &OnBuild{
docker: dockerHandler,
git: git.New(),
fs: util.NewFileSystem(),
tar: tar.New(),
}
// Use STI Prepare() and download the 'run' script optionally.
s, err := sti.New(config, overrides)
s.SetScripts([]string{}, []string{api.Assemble, api.Run})
downloader := overrides.Downloader
if downloader == nil {
d, sourceURL, err := scm.DownloaderForSource(config.Source)
if err != nil {
return nil, err
}
downloader = d
config.Source = sourceURL
}
b.source = onBuildSourceHandler{
Downloader: downloader,
Preparer: s,
Ignorer: &ignore.DockerIgnorer{},
}
b.garbage = &build.DefaultCleaner{b.fs, b.docker}
return b, nil
}
// Restore loads the arguments from disk and prefills the Request
func Restore(config *api.Config, cmd *cobra.Command) {
data, err := ioutil.ReadFile(DefaultConfigPath)
if err != nil {
data, err = ioutil.ReadFile(".stifile")
if err != nil {
glog.V(1).Infof("Unable to restore %s: %v", DefaultConfigPath, err)
return
}
glog.Infof("DEPRECATED: Use %s instead of .stifile", DefaultConfigPath)
}
c := Config{}
if err := json.Unmarshal(data, &c); err != nil {
glog.V(1).Infof("Unable to parse %s: %v", DefaultConfigPath, err)
return
}
config.BuilderImage = c.BuilderImage
config.Source = c.Source
config.Tag = c.Tag
for name, value := range c.Flags {
// Do not change flags that user sets. Allow overriding of stored flags.
if cmd.Flag(name).Changed {
continue
}
cmd.Flags().Set(name, value)
}
}
// New returns the instance of STI builder strategy for the given config.
// If the layeredBuilder parameter is specified, then the builder provided will
// be used for the case that the base Docker image does not have 'tar' or 'bash'
// installed.
func New(req *api.Config, overrides build.Overrides) (*STI, error) {
docker, err := dockerpkg.New(req.DockerConfig, req.PullAuthentication)
if err != nil {
return nil, err
}
var incrementalDocker dockerpkg.Docker
if req.Incremental {
incrementalDocker, err = dockerpkg.New(req.DockerConfig, req.IncrementalAuthentication)
if err != nil {
return nil, err
}
}
inst := scripts.NewInstaller(req.BuilderImage, req.ScriptsURL, docker, req.PullAuthentication)
b := &STI{
installer: inst,
config: req,
docker: docker,
incrementalDocker: incrementalDocker,
git: git.New(),
fs: util.NewFileSystem(),
tar: tar.New(),
callbackInvoker: util.NewCallbackInvoker(),
requiredScripts: []string{api.Assemble, api.Run},
optionalScripts: []string{api.SaveArtifacts},
externalScripts: map[string]bool{},
installedScripts: map[string]bool{},
scriptsURL: map[string]string{},
}
// The sources are downloaded using the GIT downloader.
// TODO: Add more SCM in future.
// TODO: explicit decision made to customize processing for usage specifically vs.
// leveraging overrides; also, we ultimately want to simplify s2i usage a good bit,
// which would lead to replacing this quick short circuit (so this change is tactical)
b.source = overrides.Downloader
if b.source == nil && !req.Usage {
downloader, sourceURL, err := scm.DownloaderForSource(req.Source, req.ForceCopy)
if err != nil {
return nil, err
}
b.source = downloader
req.Source = sourceURL
}
b.garbage = &build.DefaultCleaner{b.fs, b.docker}
b.layered, err = layered.New(req, b, overrides)
// Set interfaces
b.preparer = b
// later on, if we support say .gitignore func in addition to .dockerignore func, setting
// ignorer will be based on config setting
b.ignorer = &ignore.DockerIgnorer{}
b.artifacts = b
b.scripts = b
b.postExecutor = b
return b, err
}
// New returns the instance of STI builder strategy for the given config.
// If the layeredBuilder parameter is specified, then the builder provided will
// be used for the case that the base Docker image does not have 'tar' or 'bash'
// installed.
func New(req *api.Config, overrides build.Overrides) (*STI, error) {
docker, err := dockerpkg.New(req.DockerConfig, req.PullAuthentication)
if err != nil {
return nil, err
}
var incrementalDocker dockerpkg.Docker
if req.Incremental {
incrementalDocker, err = dockerpkg.New(req.DockerConfig, req.IncrementalAuthentication)
if err != nil {
return nil, err
}
}
inst := scripts.NewInstaller(req.BuilderImage, req.ScriptsURL, docker, req.PullAuthentication)
b := &STI{
installer: inst,
config: req,
docker: docker,
incrementalDocker: incrementalDocker,
git: git.New(),
fs: util.NewFileSystem(),
tar: tar.New(),
callbackInvoker: util.NewCallbackInvoker(),
requiredScripts: []string{api.Assemble, api.Run},
optionalScripts: []string{api.SaveArtifacts},
externalScripts: map[string]bool{},
installedScripts: map[string]bool{},
scriptsURL: map[string]string{},
}
// The sources are downloaded using the GIT downloader.
// TODO: Add more SCM in future.
b.source = overrides.Downloader
if b.source == nil {
downloader, sourceURL, err := scm.DownloaderForSource(req.Source)
if err != nil {
return nil, err
}
b.source = downloader
req.Source = sourceURL
}
b.garbage = &build.DefaultCleaner{b.fs, b.docker}
b.layered, err = layered.New(req, b, overrides)
// Set interfaces
b.preparer = b
// later on, if we support say .gitignore func in addition to .dockerignore func, setting
// ignorer will be based on config setting
b.ignorer = &ignore.DockerIgnorer{}
b.artifacts = b
b.scripts = b
b.postExecutor = b
return b, err
}
// GenerateConfigFromLabels generates the S2I Config struct from the Docker
// image labels.
func GenerateConfigFromLabels(image string, config *api.Config) error {
d, err := docker.New(config.DockerConfig, config.PullAuthentication)
if err != nil {
return err
}
var source *dockerclient.Image
if config.ForcePull {
source, err = d.PullImage(image)
} else {
source, err = d.CheckAndPullImage(image)
}
if err != nil {
return err
}
if builderVersion, ok := source.Config.Labels["io.openshift.builder-version"]; ok {
config.BuilderImageVersion = builderVersion
config.BuilderBaseImageVersion = source.Config.Labels["io.openshift.builder-base-version"]
}
config.ScriptsURL = source.Config.Labels[api.DefaultNamespace+"scripts-url"]
if len(config.ScriptsURL) == 0 {
// FIXME: Backward compatibility
config.ScriptsURL = source.Config.Labels["io.s2i.scripts-url"]
}
config.Description = source.Config.Labels[api.KubernetesNamespace+"description"]
config.DisplayName = source.Config.Labels[api.KubernetesNamespace+"display-name"]
if builder, ok := source.Config.Labels[api.DefaultNamespace+"build.image"]; ok {
config.BuilderImage = builder
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"build.image")
}
if repo, ok := source.Config.Labels[api.DefaultNamespace+"build.source-location"]; ok {
config.Source = repo
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"source-location")
}
config.ContextDir = source.Config.Labels[api.DefaultNamespace+"build.source-context-dir"]
config.Ref = source.Config.Labels[api.DefaultNamespace+"build.commit.ref"]
return nil
}
// GenerateConfigFromLabels generates the S2I Config struct from the Docker
// image labels.
func GenerateConfigFromLabels(config *api.Config, metadata *docker.PullResult) error {
if config == nil {
return errors.New("config must be provided to GenerateConfigFromLabels")
}
if metadata == nil {
return errors.New("image metadata must be provided to GenerateConfigFromLabels")
}
labels := metadata.Image.Config.Labels
if builderVersion, ok := labels["io.openshift.builder-version"]; ok {
config.BuilderImageVersion = builderVersion
config.BuilderBaseImageVersion = labels["io.openshift.builder-base-version"]
}
config.ScriptsURL = labels[api.DefaultNamespace+"scripts-url"]
if len(config.ScriptsURL) == 0 {
// FIXME: Backward compatibility
config.ScriptsURL = labels["io.s2i.scripts-url"]
}
config.Description = labels[api.KubernetesNamespace+"description"]
config.DisplayName = labels[api.KubernetesNamespace+"display-name"]
if builder, ok := labels[api.DefaultNamespace+"build.image"]; ok {
config.BuilderImage = builder
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"build.image")
}
if repo, ok := labels[api.DefaultNamespace+"build.source-location"]; ok {
config.Source = repo
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"source-location")
}
config.ContextDir = labels[api.DefaultNamespace+"build.source-context-dir"]
config.Ref = labels[api.DefaultNamespace+"build.commit.ref"]
return nil
}
// GenerateConfigFromLabels generates the S2I Config struct from the Docker
// image labels.
func GenerateConfigFromLabels(config *api.Config) error {
result, err := docker.GetBuilderImage(config)
if err != nil {
return err
}
labels := result.Image.Config.Labels
if builderVersion, ok := labels["io.openshift.builder-version"]; ok {
config.BuilderImageVersion = builderVersion
config.BuilderBaseImageVersion = labels["io.openshift.builder-base-version"]
}
config.ScriptsURL = labels[api.DefaultNamespace+"scripts-url"]
if len(config.ScriptsURL) == 0 {
// FIXME: Backward compatibility
config.ScriptsURL = labels["io.s2i.scripts-url"]
}
config.Description = labels[api.KubernetesNamespace+"description"]
config.DisplayName = labels[api.KubernetesNamespace+"display-name"]
if builder, ok := labels[api.DefaultNamespace+"build.image"]; ok {
config.BuilderImage = builder
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"build.image")
}
if repo, ok := labels[api.DefaultNamespace+"build.source-location"]; ok {
config.Source = repo
} else {
return fmt.Errorf("Required label %q not found in image", api.DefaultNamespace+"source-location")
}
config.ContextDir = labels[api.DefaultNamespace+"build.source-context-dir"]
config.Ref = labels[api.DefaultNamespace+"build.commit.ref"]
return nil
}
func newCmdBuild(cfg *api.Config) *cobra.Command {
useConfig := false
oldScriptsFlag := ""
oldDestination := ""
buildCmd := &cobra.Command{
Use: "build <source> <image> [<tag>]",
Short: "Build a new image",
Long: "Build a new Docker image named <tag> (if provided) from a source repository and base image.",
Example: `
# Build an application Docker image from a Git repository
$ s2i build git://github.com/openshift/ruby-hello-world centos/ruby-22-centos7 hello-world-app
# Build from a local directory
$ s2i build . centos/ruby-22-centos7 hello-world-app
`,
Run: func(cmd *cobra.Command, args []string) {
glog.V(1).Infof("Running S2I version %q\n", version.Get())
// Attempt to restore the build command from the configuration file
if useConfig {
config.Restore(cfg, cmd)
}
// If user specifies the arguments, then we override the stored ones
if len(args) >= 2 {
cfg.Source = args[0]
cfg.BuilderImage = args[1]
if len(args) >= 3 {
cfg.Tag = args[2]
}
}
if cfg.Incremental && len(cfg.RuntimeImage) > 0 {
fmt.Fprintln(os.Stderr, "ERROR: Incremental build with runtime image isn't supported")
os.Exit(1)
}
if cfg.ForcePull {
glog.Warning("DEPRECATED: The '--force-pull' option is deprecated. Use '--pull-policy' instead")
}
if len(cfg.BuilderPullPolicy) == 0 {
cfg.BuilderPullPolicy = api.DefaultBuilderPullPolicy
}
if len(cfg.PreviousImagePullPolicy) == 0 {
cfg.PreviousImagePullPolicy = api.DefaultPreviousImagePullPolicy
}
if errs := validation.ValidateConfig(cfg); len(errs) > 0 {
for _, e := range errs {
fmt.Fprintf(os.Stderr, "ERROR: %s\n", e)
}
fmt.Println()
cmd.Help()
os.Exit(1)
}
// Persists the current command line options and config into .s2ifile
if useConfig {
config.Save(cfg, cmd)
}
// Attempt to read the .dockercfg and extract the authentication for
// docker pull
if r, err := os.Open(cfg.DockerCfgPath); err == nil {
defer r.Close()
auths := docker.LoadImageRegistryAuth(r)
cfg.PullAuthentication = docker.GetImageRegistryAuth(auths, cfg.BuilderImage)
if cfg.Incremental {
cfg.IncrementalAuthentication = docker.GetImageRegistryAuth(auths, cfg.Tag)
}
if len(cfg.RuntimeImage) > 0 {
cfg.RuntimeAuthentication = docker.GetImageRegistryAuth(auths, cfg.RuntimeImage)
}
}
if len(cfg.EnvironmentFile) > 0 {
result, err := util.ReadEnvironmentFile(cfg.EnvironmentFile)
if err != nil {
glog.Warningf("Unable to read environment file %q: %v", cfg.EnvironmentFile, err)
} else {
for name, value := range result {
cfg.Environment = append(cfg.Environment, api.EnvironmentSpec{Name: name, Value: value})
}
}
}
if len(oldScriptsFlag) != 0 {
glog.Warning("DEPRECATED: Flag --scripts is deprecated, use --scripts-url instead")
cfg.ScriptsURL = oldScriptsFlag
}
if len(oldDestination) != 0 {
glog.Warning("DEPRECATED: Flag --location is deprecated, use --destination instead")
cfg.Destination = oldDestination
}
glog.V(2).Infof("\n%s\n", describe.Config(cfg))
err := docker.CheckReachable(cfg)
if err != nil {
glog.Fatal(err)
}
builder, _, err := strategies.GetStrategy(cfg)
checkErr(err)
result, err := builder.Build(cfg)
checkErr(err)
for _, message := range result.Messages {
glog.V(1).Infof(message)
}
if cfg.RunImage {
runner, err := run.New(cfg)
checkErr(err)
err = runner.Run(cfg)
checkErr(err)
}
},
}
cmdutil.AddCommonFlags(buildCmd, cfg)
buildCmd.Flags().BoolVar(&(cfg.RunImage), "run", false, "Run resulting image as part of invocation of this command")
buildCmd.Flags().BoolVar(&(cfg.IgnoreSubmodules), "ignore-submodules", false, "Ignore all git submodules when cloning application repository")
buildCmd.Flags().VarP(&(cfg.Environment), "env", "e", "Specify an single environment variable in NAME=VALUE format")
buildCmd.Flags().StringVarP(&(cfg.Ref), "ref", "r", "", "Specify a ref to check-out")
buildCmd.Flags().StringVarP(&(cfg.AssembleUser), "assemble-user", "", "", "Specify the user to run assemble with")
buildCmd.Flags().StringVarP(&(cfg.ContextDir), "context-dir", "", "", "Specify the sub-directory inside the repository with the application sources")
buildCmd.Flags().StringVarP(&(cfg.ExcludeRegExp), "exclude", "", tar.DefaultExclusionPattern.String(), "Regular expression for selecting files from the source tree to exclude from the build, where the default excludes the '.git' directory (see https://golang.org/pkg/regexp for syntax, but note that \"\" will be interpreted as allow all files and exclude no files)")
buildCmd.Flags().StringVarP(&(cfg.ScriptsURL), "scripts-url", "s", "", "Specify a URL for the assemble, assemble-runtime and run scripts")
buildCmd.Flags().StringVar(&(oldScriptsFlag), "scripts", "", "DEPRECATED: Specify a URL for the assemble and run scripts")
buildCmd.Flags().BoolVar(&(useConfig), "use-config", false, "Store command line options to .s2ifile")
buildCmd.Flags().StringVarP(&(cfg.EnvironmentFile), "environment-file", "E", "", "Specify the path to the file with environment")
buildCmd.Flags().StringVarP(&(cfg.DisplayName), "application-name", "n", "", "Specify the display name for the application (default: output image name)")
buildCmd.Flags().StringVarP(&(cfg.Description), "description", "", "", "Specify the description of the application")
buildCmd.Flags().VarP(&(cfg.AllowedUIDs), "allowed-uids", "u", "Specify a range of allowed user ids for the builder and runtime images")
buildCmd.Flags().VarP(&(cfg.Injections), "inject", "i", "Specify a directory to inject into the assemble container")
buildCmd.Flags().VarP(&(cfg.BuildVolumes), "volume", "v", "Specify a volume to mount into the assemble container")
buildCmd.Flags().StringSliceVar(&(cfg.DropCapabilities), "cap-drop", []string{}, "Specify a comma-separated list of capabilities to drop when running Docker containers")
buildCmd.Flags().StringVarP(&(oldDestination), "location", "l", "",
"DEPRECATED: Specify a destination location for untar operation")
buildCmd.Flags().BoolVarP(&(cfg.ForceCopy), "copy", "c", false, "Use local file system copy instead of git cloning the source url")
buildCmd.Flags().StringVar(&(cfg.RuntimeImage), "runtime-image", "", "Image that will be used as the base for the runtime image")
buildCmd.Flags().VarP(&(cfg.RuntimeArtifacts), "runtime-artifact", "a", "Specify a file or directory to be copied from the builder to the runtime image")
return buildCmd
}
// New returns the instance of STI builder strategy for the given config.
// If the layeredBuilder parameter is specified, then the builder provided will
// be used for the case that the base Docker image does not have 'tar' or 'bash'
// installed.
func New(config *api.Config, overrides build.Overrides) (*STI, error) {
docker, err := dockerpkg.New(config.DockerConfig, config.PullAuthentication)
if err != nil {
return nil, err
}
var incrementalDocker dockerpkg.Docker
if config.Incremental {
incrementalDocker, err = dockerpkg.New(config.DockerConfig, config.IncrementalAuthentication)
if err != nil {
return nil, err
}
}
inst := scripts.NewInstaller(config.BuilderImage, config.ScriptsURL, config.ScriptDownloadProxyConfig, docker, config.PullAuthentication)
tarHandler := tar.New()
tarHandler.SetExclusionPattern(regexp.MustCompile(config.ExcludeRegExp))
builder := &STI{
installer: inst,
config: config,
docker: docker,
incrementalDocker: incrementalDocker,
git: git.New(),
fs: util.NewFileSystem(),
tar: tarHandler,
callbackInvoker: util.NewCallbackInvoker(),
requiredScripts: []string{api.Assemble, api.Run},
optionalScripts: []string{api.SaveArtifacts},
optionalRuntimeScripts: []string{api.AssembleRuntime},
externalScripts: map[string]bool{},
installedScripts: map[string]bool{},
scriptsURL: map[string]string{},
}
if len(config.RuntimeImage) > 0 {
builder.runtimeInstaller = scripts.NewInstaller(config.RuntimeImage, config.ScriptsURL, config.ScriptDownloadProxyConfig, docker, config.PullAuthentication)
builder.runtimeDocker, err = dockerpkg.New(config.DockerConfig, config.RuntimeAuthentication)
if err != nil {
return builder, err
}
}
// The sources are downloaded using the Git downloader.
// TODO: Add more SCM in future.
// TODO: explicit decision made to customize processing for usage specifically vs.
// leveraging overrides; also, we ultimately want to simplify s2i usage a good bit,
// which would lead to replacing this quick short circuit (so this change is tactical)
builder.source = overrides.Downloader
if builder.source == nil && !config.Usage {
downloader, sourceURL, err := scm.DownloaderForSource(config.Source, config.ForceCopy)
if err != nil {
return nil, err
}
builder.source = downloader
config.Source = sourceURL
}
builder.garbage = build.NewDefaultCleaner(builder.fs, builder.docker)
builder.layered, err = layered.New(config, builder, overrides)
// Set interfaces
builder.preparer = builder
// later on, if we support say .gitignore func in addition to .dockerignore func, setting
// ignorer will be based on config setting
builder.ignorer = &ignore.DockerIgnorer{}
builder.artifacts = builder
builder.scripts = builder
builder.postExecutor = builder
builder.initPostExecutorSteps()
return builder, err
}
func newCmdBuild(cfg *api.Config) *cobra.Command {
useConfig := false
oldScriptsFlag := ""
oldDestination := ""
buildCmd := &cobra.Command{
Use: "build <source> <image> [<tag>]",
Short: "Build a new image",
Long: "Build a new Docker image named <tag> (if provided) from a source repository and base image.",
Example: `
# Build an application Docker image from a Git repository
$ s2i build git://github.com/openshift/ruby-hello-world centos/ruby-22-centos7 hello-world-app
# Build from a local directory
$ s2i build . centos/ruby-22-centos7 hello-world-app
`,
Run: func(cmd *cobra.Command, args []string) {
go cmdutil.InstallDumpOnSignal()
// Attempt to restore the build command from the configuration file
if useConfig {
config.Restore(cfg, cmd)
}
// If user specifies the arguments, then we override the stored ones
if len(args) >= 2 {
cfg.Source = args[0]
cfg.BuilderImage = args[1]
if len(args) >= 3 {
cfg.Tag = args[2]
}
}
if cfg.ForcePull {
glog.Warning("DEPRECATED: The '--force-pull' option is deprecated. Use '--pull-policy' instead")
}
if len(cfg.BuilderPullPolicy) == 0 {
cfg.BuilderPullPolicy = api.DefaultBuilderPullPolicy
}
if errs := validation.ValidateConfig(cfg); len(errs) > 0 {
for _, e := range errs {
fmt.Fprintf(os.Stderr, "ERROR: %s\n", e)
}
fmt.Println()
cmd.Help()
os.Exit(1)
}
// Persists the current command line options and config into .stifile
if useConfig {
config.Save(cfg, cmd)
}
// Attempt to read the .dockercfg and extract the authentication for
// docker pull
if r, err := os.Open(cfg.DockerCfgPath); err == nil {
auths := docker.LoadImageRegistryAuth(r)
cfg.PullAuthentication = docker.GetImageRegistryAuth(auths, cfg.BuilderImage)
if cfg.Incremental {
cfg.IncrementalAuthentication = docker.GetImageRegistryAuth(auths, cfg.Tag)
}
}
cfg.Environment = map[string]string{}
if len(cfg.EnvironmentFile) > 0 {
result, err := util.ReadEnvironmentFile(cfg.EnvironmentFile)
if err != nil {
glog.Warningf("Unable to read environment file %q: %v", cfg.EnvironmentFile, err)
} else {
cfg.Environment = result
}
}
envs, err := cmdutil.ParseEnvs(cmd, "env")
checkErr(err)
for k, v := range envs {
cfg.Environment[k] = v
}
if len(oldScriptsFlag) != 0 {
glog.Warning("DEPRECATED: Flag --scripts is deprecated, use --scripts-url instead")
cfg.ScriptsURL = oldScriptsFlag
}
if len(oldDestination) != 0 {
glog.Warning("DEPRECATED: Flag --location is deprecated, use --destination instead")
cfg.Destination = oldDestination
}
if glog.V(2) {
fmt.Printf("\n%s\n", describe.DescribeConfig(cfg))
}
if !docker.IsReachable(cfg) {
glog.Fatalf("Unable to connect to Docker daemon. Please set the DOCKER_HOST or make sure the Docker socket %q exists", cfg.DockerConfig.Endpoint)
}
builder, err := strategies.GetStrategy(cfg)
checkErr(err)
result, err := builder.Build(cfg)
checkErr(err)
for _, message := range result.Messages {
glog.V(1).Infof(message)
}
if cfg.RunImage {
runner, err := run.New(cfg)
checkErr(err)
err = runner.Run(cfg)
checkErr(err)
}
},
}
cmdutil.AddCommonFlags(buildCmd, cfg)
buildCmd.Flags().BoolVar(&(cfg.RunImage), "run", false, "Run resulting image as part of invocation of this command")
buildCmd.Flags().BoolVar(&(cfg.DisableRecursive), "recursive", true, "Fetch all git submodules when cloning application repository")
buildCmd.Flags().StringP("env", "e", "", "Specify an environment var NAME=VALUE,NAME2=VALUE2,...")
buildCmd.Flags().StringVarP(&(cfg.Ref), "ref", "r", "", "Specify a ref to check-out")
buildCmd.Flags().StringVarP(&(cfg.AssembleUser), "assemble-user", "", "", "Specify the user to run assemble with")
buildCmd.Flags().StringVarP(&(cfg.ContextDir), "context-dir", "", "", "Specify the sub-directory inside the repository with the application sources")
buildCmd.Flags().StringVarP(&(cfg.ScriptsURL), "scripts-url", "s", "", "Specify a URL for the assemble and run scripts")
buildCmd.Flags().StringVar(&(oldScriptsFlag), "scripts", "", "DEPRECATED: Specify a URL for the assemble and run scripts")
buildCmd.Flags().BoolVar(&(useConfig), "use-config", false, "Store command line options to .stifile")
buildCmd.Flags().StringVarP(&(cfg.EnvironmentFile), "environment-file", "E", "", "Specify the path to the file with environment")
buildCmd.Flags().StringVarP(&(cfg.DisplayName), "application-name", "n", "", "Specify the display name for the application (default: output image name)")
buildCmd.Flags().StringVarP(&(cfg.Description), "description", "", "", "Specify the description of the application")
buildCmd.Flags().VarP(&(cfg.AllowedUIDs), "allowed-uids", "u", "Specify a range of allowed user ids for the builder image")
buildCmd.Flags().StringVarP(&(oldDestination), "location", "l", "",
"DEPRECATED: Specify a destination location for untar operation")
return buildCmd
}
func newCmdBuild(cfg *api.Config) *cobra.Command {
useConfig := false
oldScriptsFlag := ""
oldDestination := ""
buildCmd := &cobra.Command{
Use: "build <source> <image> [<tag>]",
Short: "Build a new image",
Long: "Build a new Docker image named <tag> (if provided) from a source repository and base image.",
Run: func(cmd *cobra.Command, args []string) {
go func() {
for {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGQUIT)
buf := make([]byte, 1<<20)
for {
<-sigs
runtime.Stack(buf, true)
if file, err := ioutil.TempFile(os.TempDir(), "sti_dump"); err == nil {
defer file.Close()
file.Write(buf)
}
glog.Infof("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end\n", buf)
}
}
}()
// Attempt to restore the build command from the configuration file
if useConfig {
config.Restore(cfg, cmd)
}
// If user specifies the arguments, then we override the stored ones
if len(args) >= 2 {
cfg.Source = args[0]
cfg.BuilderImage = args[1]
if len(args) >= 3 {
cfg.Tag = args[2]
}
}
if len(validation.ValidateConfig(cfg)) != 0 {
cmd.Help()
os.Exit(1)
}
// Persists the current command line options and config into .stifile
if useConfig {
config.Save(cfg, cmd)
}
// Attempt to read the .dockercfg and extract the authentication for
// docker pull
if r, err := os.Open(cfg.DockerCfgPath); err == nil {
cfg.PullAuthentication = docker.GetImageRegistryAuth(r, cfg.BuilderImage)
}
cfg.Environment = map[string]string{}
if len(cfg.EnvironmentFile) > 0 {
result, err := util.ReadEnvironmentFile(cfg.EnvironmentFile)
if err != nil {
glog.Warningf("Unable to read %s: %v", cfg.EnvironmentFile, err)
} else {
cfg.Environment = result
}
}
envs, err := parseEnvs(cmd, "env")
checkErr(err)
for k, v := range envs {
cfg.Environment[k] = v
}
if len(oldScriptsFlag) != 0 {
glog.Warning("Flag --scripts is deprecated, use --scripts-url instead")
cfg.ScriptsURL = oldScriptsFlag
}
if len(oldDestination) != 0 {
glog.Warning("Flag --location is deprecated, use --destination instead")
cfg.Destination = oldDestination
}
if glog.V(2) {
fmt.Printf("\n%s\n", describe.DescribeConfig(cfg))
}
builder, err := strategies.GetStrategy(cfg)
checkErr(err)
result, err := builder.Build(cfg)
checkErr(err)
for _, message := range result.Messages {
glog.V(1).Infof(message)
}
},
}
buildCmd.Flags().BoolVarP(&(cfg.Quiet), "quiet", "q", false, "Operate quietly. Suppress all non-error output.")
buildCmd.Flags().BoolVar(&(cfg.Incremental), "incremental", false, "Perform an incremental build")
buildCmd.Flags().BoolVar(&(cfg.RemovePreviousImage), "rm", false, "Remove the previous image during incremental builds")
buildCmd.Flags().StringP("env", "e", "", "Specify an environment var NAME=VALUE,NAME2=VALUE2,...")
buildCmd.Flags().StringVarP(&(cfg.Ref), "ref", "r", "", "Specify a ref to check-out")
buildCmd.Flags().StringVar(&(cfg.CallbackURL), "callback-url", "", "Specify a URL to invoke via HTTP POST upon build completion")
buildCmd.Flags().StringVarP(&(cfg.ScriptsURL), "scripts-url", "s", "", "Specify a URL for the assemble and run scripts")
buildCmd.Flags().StringVar(&(oldScriptsFlag), "scripts", "", "Specify a URL for the assemble and run scripts")
buildCmd.Flags().StringVarP(&(oldDestination), "location", "l", "", "Specify a destination location for untar operation")
buildCmd.Flags().StringVarP(&(cfg.Destination), "destination", "d", "", "Specify a destination location for untar operation")
buildCmd.Flags().BoolVar(&(cfg.ForcePull), "force-pull", true, "Always pull the builder image even if it is present locally")
buildCmd.Flags().BoolVar(&(cfg.PreserveWorkingDir), "save-temp-dir", false, "Save the temporary directory used by STI instead of deleting it")
buildCmd.Flags().BoolVar(&(useConfig), "use-config", false, "Store command line options to .stifile")
buildCmd.Flags().StringVarP(&(cfg.ContextDir), "context-dir", "", "", "Specify the sub-directory inside the repository with the application sources")
buildCmd.Flags().StringVarP(&(cfg.DockerCfgPath), "dockercfg-path", "", filepath.Join(os.Getenv("HOME"), ".dockercfg"), "Specify the path to the Docker configuration file")
buildCmd.Flags().StringVarP(&(cfg.EnvironmentFile), "environment-file", "E", "", "Specify the path to the file with environment")
buildCmd.Flags().StringVarP(&(cfg.DisplayName), "application-name", "n", "", "Specify the display name for the application (default: output image name)")
buildCmd.Flags().StringVarP(&(cfg.Description), "description", "", "", "Specify the description of the application")
return buildCmd
}
// Download downloads the application source code from the Git repository
// and checkout the Ref specified in the config.
func (c *Clone) Download(config *api.Config) (*api.SourceInfo, error) {
targetSourceDir := filepath.Join(config.WorkingDir, api.Source)
config.WorkingSourceDir = targetSourceDir
ok, err := c.ValidCloneSpec(config.Source)
if err != nil {
return nil, err
}
if !ok {
glog.Errorf("Clone.Download was passed an invalid source %s", config.Source)
return nil, fmt.Errorf("invalid source %s", config.Source)
}
ref := "HEAD"
if config.Ref != "" {
ref = config.Ref
}
if strings.HasPrefix(config.Source, "file://") {
s := strings.TrimPrefix(config.Source, "file://")
if util.UsingCygwinGit {
var err error
s, err = util.ToSlashCygwin(s)
if err != nil {
glog.V(0).Infof("error: Cygwin path conversion failed: %v", err)
return nil, err
}
}
config.Source = "file://" + s
}
if len(config.ContextDir) > 0 {
targetSourceDir = filepath.Join(config.WorkingDir, api.ContextTmp)
glog.V(1).Infof("Downloading %q (%q) ...", config.Source, config.ContextDir)
} else {
glog.V(1).Infof("Downloading %q ...", config.Source)
}
if !config.IgnoreSubmodules {
glog.V(2).Infof("Cloning sources into %q", targetSourceDir)
} else {
glog.V(2).Infof("Cloning sources (ignoring submodules) into %q", targetSourceDir)
}
cloneConfig := api.CloneConfig{Quiet: true}
err = c.Clone(config.Source, targetSourceDir, cloneConfig)
if err != nil {
glog.V(0).Infof("error: git clone failed: %v", err)
return nil, err
}
err = c.Checkout(targetSourceDir, ref)
if err != nil {
return nil, err
}
glog.V(1).Infof("Checked out %q", ref)
if !config.IgnoreSubmodules {
err = c.SubmoduleUpdate(targetSourceDir, true, true)
if err != nil {
return nil, err
}
glog.V(1).Infof("Updated submodules for %q", ref)
}
// Record Git's knowledge about file permissions
if runtime.GOOS == "windows" {
filemodes, err := c.LsTree(filepath.Join(targetSourceDir, config.ContextDir), ref, true)
if err != nil {
return nil, err
}
for _, filemode := range filemodes {
c.Chmod(filepath.Join(targetSourceDir, config.ContextDir, filemode.Name()), os.FileMode(filemode.Mode())&os.ModePerm)
}
}
info := c.GetInfo(targetSourceDir)
if len(config.ContextDir) > 0 {
originalTargetDir := filepath.Join(config.WorkingDir, api.Source)
c.RemoveDirectory(originalTargetDir)
path := filepath.Join(targetSourceDir, config.ContextDir)
err := c.CopyContents(path, originalTargetDir)
if err != nil {
return nil, err
}
c.RemoveDirectory(targetSourceDir)
}
if len(config.ContextDir) > 0 {
info.ContextDir = config.ContextDir
}
return info, nil
}