github.com/containers/podman/v2@v2.2.2-0.20210501105131-c1e07d070c4c/test/e2e/cp_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"os/exec"
     7  	"path/filepath"
     8  	"strings"
     9  
    10  	. "github.com/containers/podman/v2/test/utils"
    11  	. "github.com/onsi/ginkgo"
    12  	. "github.com/onsi/gomega"
    13  )
    14  
    15  var _ = Describe("Podman cp", func() {
    16  	var (
    17  		tempdir    string
    18  		err        error
    19  		podmanTest *PodmanTestIntegration
    20  	)
    21  
    22  	BeforeEach(func() {
    23  		SkipIfRemote("FIXME: Podman-remote cp needs to work")
    24  		tempdir, err = CreateTempDirInTempDir()
    25  		if err != nil {
    26  			os.Exit(1)
    27  		}
    28  		podmanTest = PodmanTestCreate(tempdir)
    29  		podmanTest.Setup()
    30  		podmanTest.SeedImages()
    31  	})
    32  
    33  	AfterEach(func() {
    34  		podmanTest.Cleanup()
    35  		f := CurrentGinkgoTestDescription()
    36  		processTestResult(f)
    37  
    38  	})
    39  
    40  	It("podman cp file", func() {
    41  		srcPath := filepath.Join(podmanTest.RunRoot, "cp_test.txt")
    42  		dstPath := filepath.Join(podmanTest.RunRoot, "cp_from_container")
    43  		fromHostToContainer := []byte("copy from host to container")
    44  
    45  		session := podmanTest.Podman([]string{"create", ALPINE, "cat", "foo"})
    46  		session.WaitWithDefaultTimeout()
    47  		Expect(session.ExitCode()).To(Equal(0))
    48  		name := session.OutputToString()
    49  
    50  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
    51  		Expect(err).To(BeNil())
    52  
    53  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foo/"})
    54  		session.WaitWithDefaultTimeout()
    55  		Expect(session).To(ExitWithError())
    56  
    57  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foo"})
    58  		session.WaitWithDefaultTimeout()
    59  		Expect(session.ExitCode()).To(Equal(0))
    60  
    61  		session = podmanTest.Podman([]string{"cp", name + ":foo", dstPath})
    62  		session.WaitWithDefaultTimeout()
    63  		Expect(session.ExitCode()).To(Equal(0))
    64  
    65  		session = podmanTest.Podman([]string{"start", name})
    66  		session.WaitWithDefaultTimeout()
    67  		Expect(session.ExitCode()).To(Equal(0))
    68  	})
    69  
    70  	It("podman cp file to dir", func() {
    71  		name := "testctr"
    72  		setup := podmanTest.RunTopContainer(name)
    73  		setup.WaitWithDefaultTimeout()
    74  		Expect(setup.ExitCode()).To(Equal(0))
    75  
    76  		srcPath := "/tmp/cp_test.txt"
    77  		fromHostToContainer := []byte("copy from host to container directory")
    78  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
    79  		Expect(err).To(BeNil())
    80  
    81  		session := podmanTest.Podman([]string{"exec", name, "mkdir", "foodir"})
    82  		session.WaitWithDefaultTimeout()
    83  		Expect(session.ExitCode()).To(Equal(0))
    84  
    85  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foodir/"})
    86  		session.WaitWithDefaultTimeout()
    87  		Expect(session.ExitCode()).To(Equal(0))
    88  
    89  		session = podmanTest.Podman([]string{"exec", name, "ls", "foodir/cp_test.txt"})
    90  		session.WaitWithDefaultTimeout()
    91  		Expect(session.ExitCode()).To(Equal(0))
    92  
    93  		os.Remove("/tmp/cp_test.txt")
    94  	})
    95  
    96  	It("podman cp dir to dir", func() {
    97  		testDirPath := filepath.Join(podmanTest.RunRoot, "TestDir1")
    98  
    99  		session := podmanTest.Podman([]string{"create", ALPINE, "ls", "/foodir"})
   100  		session.WaitWithDefaultTimeout()
   101  		Expect(session.ExitCode()).To(Equal(0))
   102  		name := session.OutputToString()
   103  
   104  		err := os.Mkdir(testDirPath, 0755)
   105  		Expect(err).To(BeNil())
   106  		defer os.RemoveAll(testDirPath)
   107  
   108  		session = podmanTest.Podman([]string{"cp", testDirPath, name + ":/foodir"})
   109  		session.WaitWithDefaultTimeout()
   110  		Expect(session.ExitCode()).To(Equal(0))
   111  
   112  		session = podmanTest.Podman([]string{"cp", testDirPath, name + ":/foodir"})
   113  		session.WaitWithDefaultTimeout()
   114  		Expect(session.ExitCode()).To(Equal(0))
   115  
   116  		testctr := "testctr"
   117  		setup := podmanTest.RunTopContainer(testctr)
   118  		setup.WaitWithDefaultTimeout()
   119  		Expect(setup.ExitCode()).To(Equal(0))
   120  
   121  		session = podmanTest.Podman([]string{"exec", testctr, "mkdir", "foo"})
   122  		session.WaitWithDefaultTimeout()
   123  		Expect(session.ExitCode()).To(Equal(0))
   124  
   125  		session = podmanTest.Podman([]string{"cp", testDirPath + "/.", testctr + ":/foo"})
   126  		session.WaitWithDefaultTimeout()
   127  		Expect(session.ExitCode()).To(Equal(0))
   128  		session = podmanTest.Podman([]string{"exec", testctr, "ls", "foo"})
   129  		session.WaitWithDefaultTimeout()
   130  		Expect(session.ExitCode()).To(Equal(0))
   131  		Expect(len(session.OutputToString())).To(Equal(0))
   132  
   133  		session = podmanTest.Podman([]string{"cp", testctr + ":/foo/.", testDirPath})
   134  		session.WaitWithDefaultTimeout()
   135  		Expect(session.ExitCode()).To(Equal(0))
   136  		cmd := exec.Command("ls", testDirPath)
   137  		res, err := cmd.Output()
   138  		Expect(err).To(BeNil())
   139  		Expect(len(res)).To(Equal(0))
   140  	})
   141  
   142  	It("podman cp stdin/stdout", func() {
   143  		SkipIfRemote("FIXME: podman-remote cp not implemented yet")
   144  		session := podmanTest.Podman([]string{"create", ALPINE, "ls", "foo"})
   145  		session.WaitWithDefaultTimeout()
   146  		Expect(session.ExitCode()).To(Equal(0))
   147  		name := session.OutputToString()
   148  
   149  		testDirPath := filepath.Join(podmanTest.RunRoot, "TestDir2")
   150  		err := os.Mkdir(testDirPath, 0755)
   151  		Expect(err).To(BeNil())
   152  		defer os.RemoveAll(testDirPath)
   153  		cmd := exec.Command("tar", "-zcvf", "file.tar.gz", testDirPath)
   154  		_, err = cmd.Output()
   155  		Expect(err).To(BeNil())
   156  
   157  		data, err := ioutil.ReadFile("foo.tar.gz")
   158  		reader := strings.NewReader(string(data))
   159  		cmd.Stdin = reader
   160  		session = podmanTest.Podman([]string{"cp", "-", name + ":/foo"})
   161  		session.WaitWithDefaultTimeout()
   162  		Expect(session.ExitCode()).To(Equal(0))
   163  
   164  		session = podmanTest.Podman([]string{"cp", "file.tar.gz", name + ":/foo.tar.gz"})
   165  		session.WaitWithDefaultTimeout()
   166  		Expect(session.ExitCode()).To(Equal(0))
   167  		session = podmanTest.Podman([]string{"cp", name + ":/foo.tar.gz", "-"})
   168  		session.WaitWithDefaultTimeout()
   169  		Expect(session.ExitCode()).To(Equal(0))
   170  
   171  		os.Remove("file.tar.gz")
   172  	})
   173  
   174  	It("podman cp tar", func() {
   175  		testctr := "testctr"
   176  		setup := podmanTest.RunTopContainer(testctr)
   177  		setup.WaitWithDefaultTimeout()
   178  		Expect(setup.ExitCode()).To(Equal(0))
   179  
   180  		session := podmanTest.Podman([]string{"exec", testctr, "mkdir", "foo"})
   181  		session.WaitWithDefaultTimeout()
   182  		Expect(session.ExitCode()).To(Equal(0))
   183  
   184  		path, err := os.Getwd()
   185  		Expect(err).To(BeNil())
   186  		testDirPath := filepath.Join(path, "TestDir3")
   187  		err = os.Mkdir(testDirPath, 0777)
   188  		Expect(err).To(BeNil())
   189  		defer os.RemoveAll(testDirPath)
   190  		cmd := exec.Command("tar", "-cvf", "file.tar", testDirPath)
   191  		_, err = cmd.Output()
   192  		Expect(err).To(BeNil())
   193  
   194  		session = podmanTest.Podman([]string{"cp", "file.tar", "testctr:/foo/"})
   195  		session.WaitWithDefaultTimeout()
   196  		Expect(session.ExitCode()).To(Equal(0))
   197  
   198  		session = podmanTest.Podman([]string{"exec", testctr, "ls", "-l", "foo"})
   199  		session.WaitWithDefaultTimeout()
   200  		Expect(session.ExitCode()).To(Equal(0))
   201  		Expect(session.OutputToString()).To(ContainSubstring("file.tar"))
   202  
   203  		os.Remove("file.tar")
   204  	})
   205  
   206  	It("podman cp tar --extract", func() {
   207  		testctr := "testctr"
   208  		setup := podmanTest.RunTopContainer(testctr)
   209  		setup.WaitWithDefaultTimeout()
   210  		Expect(setup.ExitCode()).To(Equal(0))
   211  
   212  		session := podmanTest.Podman([]string{"exec", testctr, "mkdir", "/foo"})
   213  		session.WaitWithDefaultTimeout()
   214  		Expect(session.ExitCode()).To(Equal(0))
   215  
   216  		path, err := os.Getwd()
   217  		Expect(err).To(BeNil())
   218  		testDirPath := filepath.Join(path, "TestDir4")
   219  		err = os.Mkdir(testDirPath, 0777)
   220  		Expect(err).To(BeNil())
   221  		defer os.RemoveAll(testDirPath)
   222  		f, err := os.Create(filepath.Join(testDirPath, "a.txt"))
   223  		Expect(err).To(BeNil())
   224  		_, err = f.Write([]byte("Hello World!!!\n"))
   225  		f.Close()
   226  		cmd := exec.Command("tar", "-cvf", "file.tar", "TestDir4")
   227  		exec.Command("tar", "-cvf", "/home/mvasek/file.tar", testDirPath)
   228  		_, err = cmd.Output()
   229  		Expect(err).To(BeNil())
   230  		defer os.Remove("file.tar")
   231  
   232  		session = podmanTest.Podman([]string{"cp", "--extract", "file.tar", "testctr:/foo/"})
   233  		session.WaitWithDefaultTimeout()
   234  		Expect(session.ExitCode()).To(Equal(0))
   235  
   236  		session = podmanTest.Podman([]string{"exec", testctr, "cat", "/foo/TestDir4/a.txt"})
   237  		session.WaitWithDefaultTimeout()
   238  		Expect(session.ExitCode()).To(Equal(0))
   239  		Expect(session.OutputToString()).To(ContainSubstring("Hello World!!!"))
   240  	})
   241  
   242  	It("podman cp symlink", func() {
   243  		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "top"})
   244  		session.WaitWithDefaultTimeout()
   245  		Expect(session.ExitCode()).To(Equal(0))
   246  		name := session.OutputToString()
   247  
   248  		srcPath := filepath.Join(podmanTest.RunRoot, "cp_test.txt")
   249  		fromHostToContainer := []byte("copy from host to container")
   250  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
   251  		Expect(err).To(BeNil())
   252  
   253  		session = podmanTest.Podman([]string{"exec", name, "ln", "-s", "/tmp", "/test"})
   254  		session.WaitWithDefaultTimeout()
   255  		Expect(session.ExitCode()).To(Equal(0))
   256  
   257  		session = podmanTest.Podman([]string{"cp", "--pause=false", srcPath, name + ":/test"})
   258  		session.WaitWithDefaultTimeout()
   259  		Expect(session.ExitCode()).To(Equal(0))
   260  
   261  		_, err = os.Stat("/tmp/cp_test.txt")
   262  		Expect(err).To(Not(BeNil()))
   263  
   264  		session = podmanTest.Podman([]string{"exec", name, "ln", "-s", "/tmp/nonesuch", "/test1"})
   265  		session.WaitWithDefaultTimeout()
   266  		Expect(session.ExitCode()).To(Equal(0))
   267  
   268  		session = podmanTest.Podman([]string{"cp", "--pause=false", srcPath, name + ":/test1/"})
   269  		session.WaitWithDefaultTimeout()
   270  		Expect(session).To(ExitWithError())
   271  
   272  	})
   273  	It("podman cp volume", func() {
   274  		session := podmanTest.Podman([]string{"volume", "create", "data"})
   275  		session.WaitWithDefaultTimeout()
   276  		Expect(session.ExitCode()).To(Equal(0))
   277  
   278  		session = podmanTest.Podman([]string{"create", "-v", "data:/data", "--name", "container1", ALPINE})
   279  		session.WaitWithDefaultTimeout()
   280  		Expect(session.ExitCode()).To(Equal(0))
   281  
   282  		err = ioutil.WriteFile("cp_vol", []byte("copy to the volume"), 0644)
   283  		if err != nil {
   284  			os.Exit(1)
   285  		}
   286  		session = podmanTest.Podman([]string{"cp", "cp_vol", "container1" + ":/data/cp_vol1"})
   287  		session.WaitWithDefaultTimeout()
   288  		Expect(session.ExitCode()).To(Equal(0))
   289  
   290  		session = podmanTest.Podman([]string{"cp", "container1" + ":/data/cp_vol1", "cp_vol2"})
   291  		session.WaitWithDefaultTimeout()
   292  		Expect(session.ExitCode()).To(Equal(0))
   293  
   294  		os.Remove("cp_vol")
   295  		os.Remove("cp_vol2")
   296  	})
   297  
   298  	It("podman cp from ctr chown ", func() {
   299  		setup := podmanTest.RunTopContainer("testctr")
   300  		setup.WaitWithDefaultTimeout()
   301  		Expect(setup.ExitCode()).To(Equal(0))
   302  
   303  		session := podmanTest.Podman([]string{"exec", "testctr", "adduser", "-S", "testuser"})
   304  		session.WaitWithDefaultTimeout()
   305  		Expect(session.ExitCode()).To(Equal(0))
   306  
   307  		session = podmanTest.Podman([]string{"exec", "-u", "testuser", "testctr", "touch", "/tmp/testfile"})
   308  		session.WaitWithDefaultTimeout()
   309  		Expect(session.ExitCode()).To(Equal(0))
   310  
   311  		session = podmanTest.Podman([]string{"cp", "--pause=false", "testctr:/tmp/testfile", "testfile1"})
   312  		session.WaitWithDefaultTimeout()
   313  		Expect(session.ExitCode()).To(Equal(0))
   314  
   315  		// owner of the file copied to local machine is not testuser
   316  		cmd := exec.Command("ls", "-l", "testfile1")
   317  		cmdRet, err := cmd.Output()
   318  		Expect(err).To(BeNil())
   319  		Expect(strings.Contains(string(cmdRet), "testuser")).To(BeFalse())
   320  
   321  		session = podmanTest.Podman([]string{"cp", "--pause=false", "testfile1", "testctr:testfile2"})
   322  		session.WaitWithDefaultTimeout()
   323  		Expect(session.ExitCode()).To(Equal(0))
   324  
   325  		// owner of the file copied to a container is the root user
   326  		session = podmanTest.Podman([]string{"exec", "-it", "testctr", "ls", "-l", "testfile2"})
   327  		session.WaitWithDefaultTimeout()
   328  		Expect(session.ExitCode()).To(Equal(0))
   329  		Expect(session.OutputToString()).To(ContainSubstring("root"))
   330  
   331  		os.Remove("testfile1")
   332  	})
   333  	It("podman cp the root directory from the ctr to an existing directory on the host ", func() {
   334  		imgName := "test-cp-root-dir:latest"
   335  		DockerfileName := "Dockerfile.test-cp-root-dir"
   336  		ctrName := "test-container-cp-root"
   337  
   338  		session := podmanTest.Podman([]string{"build", "-f", "build/" + DockerfileName, "-t", imgName, "build/"})
   339  		session.WaitWithDefaultTimeout()
   340  		Expect(session.ExitCode()).To(Equal(0))
   341  
   342  		testDirPath := filepath.Join(podmanTest.RunRoot, "TestDirForCp")
   343  
   344  		session = podmanTest.Podman([]string{"create", "--name", ctrName, imgName, "dummy"})
   345  		session.WaitWithDefaultTimeout()
   346  		Expect(session.ExitCode()).To(Equal(0))
   347  
   348  		err := os.Mkdir(testDirPath, 0755)
   349  		Expect(err).To(BeNil())
   350  		defer os.RemoveAll(testDirPath)
   351  
   352  		// Copy the root directory of the container to an existing directory
   353  		session = podmanTest.Podman([]string{"cp", ctrName + ":/", testDirPath})
   354  		session.WaitWithDefaultTimeout()
   355  		Expect(session.ExitCode()).To(Equal(0))
   356  
   357  		// The file should be in the directory,
   358  		// not one layer too much of the directory called merged
   359  		checkFile := filepath.Join(testDirPath, DockerfileName)
   360  		_, err = os.Stat(checkFile)
   361  		Expect(err).To(BeNil())
   362  
   363  		session = podmanTest.Podman([]string{"container", "rm", ctrName})
   364  		session.WaitWithDefaultTimeout()
   365  		Expect(session.ExitCode()).To(Equal(0))
   366  
   367  		session = podmanTest.Podman([]string{"rmi", "-f", imgName})
   368  		session.WaitWithDefaultTimeout()
   369  		Expect(session.ExitCode()).To(Equal(0))
   370  	})
   371  })