func untarLocal(tar tar.Tar, destinationDir string, r io.Reader, quiet bool, logger io.Writer) error { glog.V(4).Infof("Extracting tar locally to %s", destinationDir) if quiet { return tar.ExtractTarStream(destinationDir, r) } return tar.ExtractTarStreamWithLogging(destinationDir, r, logger) }
func copyImageSource(dockerClient DockerClient, containerID, sourceDir, destDir string, tarHelper tar.Tar) error { // Setup destination directory fi, err := os.Stat(destDir) if err != nil { if !os.IsNotExist(err) { return err } glog.V(4).Infof("Creating image destination directory: %s", destDir) err := os.MkdirAll(destDir, 0644) if err != nil { return err } } else { if !fi.IsDir() { return fmt.Errorf("destination %s must be a directory", destDir) } } tempFile, err := ioutil.TempFile("", "imgsrc") if err != nil { return err } glog.V(4).Infof("Downloading source from path %s in container %s to temporary archive %s", sourceDir, containerID, tempFile.Name()) err = dockerClient.DownloadFromContainer(containerID, docker.DownloadFromContainerOptions{ OutputStream: tempFile, Path: sourceDir, }) if err != nil { tempFile.Close() return err } if err := tempFile.Close(); err != nil { return err } // Extract the created tar file to the destination directory file, err := os.Open(tempFile.Name()) if err != nil { return err } defer file.Close() glog.V(4).Infof("Extracting temporary tar %s to directory %s", tempFile.Name(), destDir) var tarOutput io.Writer if glog.Is(4) { tarOutput = os.Stdout } return tarHelper.ExtractTarStreamWithLogging(destDir, file, tarOutput) }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, dockerfilePath string, noCache bool, tag string, tar tar.Tar, pullAuth *docker.AuthConfigurations, forcePull bool, cgLimits *s2iapi.CGroupLimits) error { // TODO: be able to pass a stream directly to the Docker build to avoid the double temp hit r, w := io.Pipe() go func() { defer utilruntime.HandleCrash() defer w.Close() if err := tar.CreateTarStream(dir, false, w); err != nil { w.CloseWithError(err) } }() defer w.Close() glog.V(5).Infof("Invoking Docker build to create %q", tag) opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, InputStream: r, Dockerfile: dockerfilePath, NoCache: noCache, Pull: forcePull, } if cgLimits != nil { opts.Memory = cgLimits.MemoryLimitBytes opts.Memswap = cgLimits.MemorySwap opts.CPUShares = cgLimits.CPUShares opts.CPUPeriod = cgLimits.CPUPeriod opts.CPUQuota = cgLimits.CPUQuota } if pullAuth != nil { opts.AuthConfigs = *pullAuth } return client.BuildImage(opts) }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, noCache bool, tag string, tar tar.Tar, pullAuth *docker.AuthConfigurations, forcePull bool) error { // TODO: be able to pass a stream directly to the Docker build to avoid the double temp hit r, w := io.Pipe() go func() { defer util.HandleCrash() defer w.Close() if err := tar.CreateTarStream(dir, false, w); err != nil { w.CloseWithError(err) } }() defer w.Close() glog.V(5).Infof("Invoking Docker build to create %q", tag) opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, InputStream: r, NoCache: noCache, Pull: forcePull, } if pullAuth != nil { opts.AuthConfigs = *pullAuth } return client.BuildImage(opts) }
func tarLocal(tar tar.Tar, sourceDir string, w io.Writer) error { glog.V(4).Infof("Tarring %s locally", sourceDir) // includeParent mimics rsync's behavior. When the source path ends in a path // separator, then only the contents of the directory are copied. Otherwise, // the directory itself is copied. includeParent := true if strings.HasSuffix(sourceDir, string(filepath.Separator)) { includeParent = false sourceDir = sourceDir[:len(sourceDir)-1] } return tar.CreateTarStream(sourceDir, includeParent, w) }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, tar tar.Tar, opts *docker.BuildImageOptions) error { // TODO: be able to pass a stream directly to the Docker build to avoid the double temp hit if opts == nil { return fmt.Errorf("%s", "build image options nil") } r, w := io.Pipe() go func() { defer utilruntime.HandleCrash() defer w.Close() if err := tar.CreateTarStream(dir, false, w); err != nil { w.CloseWithError(err) } }() defer w.Close() opts.InputStream = r glog.V(5).Infof("Invoking Docker build to create %q", opts.Name) return client.BuildImage(*opts) }
// buildImage invokes a docker build on a particular directory func buildImage(client DockerClient, dir string, noCache bool, tag string, tar tar.Tar, pullAuth *docker.AuthConfigurations, forcePull bool) error { tarFile, err := tar.CreateTarFile("", dir) if err != nil { return err } tarStream, err := os.Open(tarFile) if err != nil { return err } defer tarStream.Close() opts := docker.BuildImageOptions{ Name: tag, RmTmpContainer: true, OutputStream: os.Stdout, InputStream: tarStream, NoCache: noCache, Pull: forcePull, } if pullAuth != nil { opts.AuthConfigs = *pullAuth } return client.BuildImage(opts) }
func untarLocal(tar tar.Tar, destinationDir string, r io.Reader) error { glog.V(4).Infof("Extracting tar locally to %s", destinationDir) return tar.ExtractTarStream(destinationDir, r) }