@@ -11,7 +11,7 @@ import (

 )

 // copyStrategies is an ordered list of copyStrategy objects that behaves as a single

-// strategy.

+// strategy. If a strategy fails with a setup error, it continues on to the next strategy.

 type copyStrategies []copyStrategy

 // ensure copyStrategies implements the copyStrategy interface

@@ -1,6 +1,7 @@

 package rsync

 import (

+	"bytes"

 	"errors"

 	"io"

 	"strings"

@@ -12,10 +13,10 @@ import (

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

 )

-var (

-	testRsyncCommand = []string{"rsync", "--version"}

-)

-

+// rsyncStrategy implements the rsync copy strategy

+// The rsync strategy calls the local rsync command directly and passes the OpenShift

+// CLI rsh command as the remote shell command for rsync. It requires that rsync be

+// present in both the client machine and the remote container.

 type rsyncStrategy struct {

 	Flags          []string

 	RshCommand     string

@@ -64,15 +65,16 @@ func (r *rsyncStrategy) Copy(source, destination *pathSpec, out, errOut io.Write

 	glog.V(3).Infof("Copying files with rsync")

 	cmd := append([]string{"rsync"}, r.Flags...)

 	cmd = append(cmd, "-e", r.RshCommand, source.RsyncPath(), destination.RsyncPath())

-	err := r.LocalExecutor.Execute(cmd, nil, out, errOut)

+	errBuf := &bytes.Buffer{}

+	err := r.LocalExecutor.Execute(cmd, nil, out, errBuf)

 	if isExitError(err) {

 		// Determine whether rsync is present in the pod container

-		testRsyncErr := executeWithLogging(r.RemoteExecutor, testRsyncCommand)

+		testRsyncErr := checkRsync(r.RemoteExecutor)

 		if testRsyncErr != nil {

-			glog.V(4).Infof("error testing whether rsync is available: %v", testRsyncErr)

 			return strategySetupError("rsync not available in container")

 		}

 	}

+	io.Copy(errOut, errBuf)

 	return err

 }

@@ -44,6 +44,16 @@ var (

 	random = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))

 )

+// rsyncDaemonStrategy implements the rsync-daemon strategy.

+// The rsync-daemon strategy uses the rsync command on the container to

+// to start rsync in daemon mode. It listens on a randomly selected port.

+// The container's port is then forwarded to the client machine so it's

+// accessible by the local rsync command. The local rsync command is invoked

+// to copy to (or from) an rsync URL using the local port. Once the copy

+// is finished, the port-forward is terminated, and the daemon on the

+// container is killed. This strategy requires thar rsync be present in

+// both the remote container and the local machine. It also requires that

+// the container allow executing a shell 'sh', cat, printf, and kill commands.

 type rsyncDaemonStrategy struct {

 	Flags          []string

 	RemoteExecutor executor

@@ -146,6 +156,10 @@ func (s *rsyncDaemonStrategy) startRemoteDaemon() error {

 	err = s.RemoteExecutor.Execute([]string{"sh"}, cmdIn, cmdOut, cmdErr)

 	if err != nil {

 		glog.V(1).Infof("Error starting rsync daemon: %v. Out: %s, Err: %s\n", err, cmdOut.String(), cmdErr.String())

+		// Determine whether rsync is present in the container

+		if checkRsync(s.RemoteExecutor) != nil {

+			return strategySetupError("rsync not available in container")

+		}

 		return err

 	}

 	s.daemonPort = port

@@ -210,18 +224,16 @@ func (s *rsyncDaemonStrategy) Copy(source, destination *pathSpec, out, errOut io

 	if err != nil {

 		if isExitError(err) {

 			return strategySetupError(fmt.Sprintf("cannot start remote rsync daemon: %v", err))

-		} else {

-			return err

 		}

+		return err

 	}

 	defer s.killRemoteDaemon()

 	err = s.startPortForward()

 	if err != nil {

 		if isExitError(err) {

 			return strategySetupError(fmt.Sprintf("cannot start port-forward: %v", err))

-		} else {

-			return err

 		}

+		return err

 	}

 	defer s.stopPortForward()

@@ -1,11 +1,13 @@

 package rsync

 import (

+	"bytes"

 	"errors"

 	"fmt"

 	"io"

 	"io/ioutil"

 	"os"

+	"path"

 	"path/filepath"

 	"strings"

@@ -17,6 +19,12 @@ import (

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

 )

+// tarStrategy implements the tar copy strategy.

+// The tar strategy consists of creating a tar of the file contents to copy

+// and then streaming them to/from the container to the destination to a tar

+// command waiting for STDIN input. If the --delete flag is specified, the

+// contents of the destination directory are first cleared before the copy.

+// The tar strategy requires that the remote container contain the tar command.

 type tarStrategy struct {

 	Quiet          bool

 	Delete         bool

@@ -94,8 +102,13 @@ func (r *tarStrategy) Copy(source, destination *pathSpec, out, errOut io.Writer)

 		}

 	} else {

 		glog.V(4).Infof("Creating local tar file %s from remote path %s", tmp.Name(), source.Path)

-		err = tarRemote(r.RemoteExecutor, source.Path, tmp, errOut)

+		errBuf := &bytes.Buffer{}

+		err = tarRemote(r.RemoteExecutor, source.Path, tmp, errBuf)

 		if err != nil {

+			if checkTar(r.RemoteExecutor) != nil {

+				return strategySetupError("tar not available in container")

+			}

+			io.Copy(errOut, errBuf)

 			return fmt.Errorf("error creating remote tar of source directory: %v", err)

 		}

 	}

@@ -113,10 +126,17 @@ func (r *tarStrategy) Copy(source, destination *pathSpec, out, errOut io.Writer)

 	// Extract tar

 	if destination.Local() {

 		glog.V(4).Infof("Untarring temp file %s to local directory %s", tmp.Name(), destination.Path)

-		err = untarLocal(r.Tar, destination.Path, tmp)

+		err = untarLocal(r.Tar, destination.Path, tmp, r.Quiet, out)

 	} else {

 		glog.V(4).Infof("Untarring temp file %s to remote directory %s", tmp.Name(), destination.Path)

-		err = untarRemote(r.RemoteExecutor, destination.Path, r.Quiet, tmp, out, errOut)

+		errBuf := &bytes.Buffer{}

+		err = untarRemote(r.RemoteExecutor, destination.Path, r.Quiet, tmp, out, errBuf)

+		if err != nil {

+			if checkTar(r.RemoteExecutor) != nil {

+				return strategySetupError("tar not available in container")

+			}

+			io.Copy(errOut, errBuf)

+		}

 	}

 	if err != nil {

 		return fmt.Errorf("error extracting tar at destination directory: %v", err)

@@ -144,7 +164,12 @@ func (r *tarStrategy) String() string {

 func tarRemote(exec executor, sourceDir string, out, errOut io.Writer) error {

 	glog.V(4).Infof("Tarring %s remotely", sourceDir)

-	cmd := []string{"tar", "-C", sourceDir, "-c", "."}

+	var cmd []string

+	if strings.HasSuffix(sourceDir, "/") {

+		cmd = []string{"tar", "-C", sourceDir, "-c", "."}

+	} else {

+		cmd = []string{"tar", "-C", path.Dir(sourceDir), "-c", path.Base(sourceDir)}

+	}

 	glog.V(4).Infof("Remote tar command: %s", strings.Join(cmd, " "))

 	return exec.Execute(cmd, nil, out, errOut)

 }

@@ -162,9 +187,12 @@ func tarLocal(tar tar.Tar, sourceDir string, w io.Writer) error {

 	return tar.CreateTarStream(sourceDir, includeParent, w)

 }

-func untarLocal(tar tar.Tar, destinationDir string, r io.Reader) error {

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

-	return tar.ExtractTarStream(destinationDir, r)

+	if quiet {

+		return tar.ExtractTarStream(destinationDir, r)

+	}

+	return tar.ExtractTarStreamWithLogging(destinationDir, r, logger)

 }

 func untarRemote(exec executor, destinationDir string, quiet bool, in io.Reader, out, errOut io.Writer) error {

@@ -36,7 +36,7 @@ for the copy.`

   $ %[1]s POD:/remote/dir/ ./local/dir`

 	noRsyncUnixWarning    = "rsync command not found in path. Please use your package manager to install it."

-	noRsyncWindowsWarning = "rsync command not found in path. Download cwRsync for windows and add it to your path."

+	noRsyncWindowsWarning = "rsync command not found in path. Download cwRsync for Windows and add it to your PATH."

 )

 // copyStrategy

@@ -11,6 +11,11 @@ import (

 	"github.com/spf13/cobra"

 )

+var (

+	testRsyncCommand = []string{"rsync", "--version"}

+	testTarCommand   = []string{"tar", "--version"}

+)

+

 // executeWithLogging will execute a command and log its output

 func executeWithLogging(e executor, cmd []string) error {

 	w := &bytes.Buffer{}

@@ -62,3 +67,11 @@ func isExitError(err error) bool {

 	_, exitErr := err.(*exec.ExitError)

 	return exitErr

 }

+

+func checkRsync(e executor) error {

+	return executeWithLogging(e, testRsyncCommand)

+}

+

+func checkTar(e executor) error {

+	return executeWithLogging(e, testTarCommand)

+}