exec.Command with cp exits with status 1

util.ExecuteCommandWithOuput(exec.Command("cp", "-r", "./*.json", artifact.dir))

func ExecuteCommandWithOuput(cmd *exec.Cmd) {
	output, err := cmd.Output()
	if err != nil {
		log.Print("Error executing ", cmd.Args, err)
	}
	fmt.Print(string(output))
}

Output

2017/01/16 13:26:35 Error executing [cp -r ./*.json myartifact] exit status 1

Questions

1. How do i get details of complete error message on failure of cp
   command ? I did have err != nill and Print err
2. Does exec.Command not support copy of files and recursive copy of directories ?
3. Any suggestions how i implement copy of files and recursive copy of
   directories ?

I have just started adopting Go and hence a new comer with Go.

You can't do wild cards in exec.Command. I'd iterate through the files in the directory and check if the extension ends in .json and then copy that file.

The problem

To explain: the so-called "wildcards" are expanded by the shell in which you typically execute command-line commands. That is, when you invoke cp -r ./*.json dir/, the shell kicks in, expands *.json by itself—producing a list of names of the files matching that pattern and located in the current directory and pass the cp command a list of such names.

So if you have, say, 10 matching files, the actuall call to cp will end up looking like

cp -r file1.json file2.json ... dir/

When you pass call cp ... directly—without the shell kicking in and expanding that *.json "fileglob" for you, the cp command receives the name of a file "*.json" verbatim and attempts to open it. Since the file named exactly "*.json" supposedly does not exist, cp fails and exits.

The solutions

The first (admittedly lame) solution is to pass a call to cp "through" a shell. That is, turn your call to cp into a shell script and pass it to a shell.

The simplest way to do this is to use something like

exec.Command(`/bin/sh -c 'cp -r ./*.json manifest'`)

This will call a shell /bin/sh and pass it the script to execute via its -c command-line option.

Another solution is to roll copying yourself using the standard Go library: the functions of the path/filepath package provide support for both expanding fileglobs as the shell would do it and iterating over the entries of a given directory. Using either of these approaches you can build the list of files to copy and/or iterate over them.

Then you can use the function os.OpenFile() to open the source and destination files, and io.Copy() to copy the contents between them.

Using https://github.com/juju/utils/blob/master/fs/copy.go that internally uses io, os packages

I found that the arguments to bash needed to be split into separate parameters, but the cp command and its parameters need to be put into a single param of exec.Command, like so::

out, err := exec.Command("/bin/bash", "-c", "cp -r ./*.json manifest").CombinedOutput()