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