// 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 }