github.com/containers/libpod@v1.9.4-0.20220419124438-4284fd425507/test/e2e/cp_test.go (about)

     1  // +build !remoteclient
     2  
     3  package integration
     4  
     5  import (
     6  	"io/ioutil"
     7  	"os"
     8  	"os/exec"
     9  	"path/filepath"
    10  	"strings"
    11  
    12  	. "github.com/containers/libpod/test/utils"
    13  	. "github.com/onsi/ginkgo"
    14  	. "github.com/onsi/gomega"
    15  )
    16  
    17  var _ = Describe("Podman cp", func() {
    18  	var (
    19  		tempdir    string
    20  		err        error
    21  		podmanTest *PodmanTestIntegration
    22  	)
    23  
    24  	BeforeEach(func() {
    25  		tempdir, err = CreateTempDirInTempDir()
    26  		if err != nil {
    27  			os.Exit(1)
    28  		}
    29  		podmanTest = PodmanTestCreate(tempdir)
    30  		podmanTest.Setup()
    31  		podmanTest.SeedImages()
    32  	})
    33  
    34  	AfterEach(func() {
    35  		podmanTest.Cleanup()
    36  		f := CurrentGinkgoTestDescription()
    37  		processTestResult(f)
    38  
    39  	})
    40  
    41  	It("podman cp file", func() {
    42  		srcPath := filepath.Join(podmanTest.RunRoot, "cp_test.txt")
    43  		dstPath := filepath.Join(podmanTest.RunRoot, "cp_from_container")
    44  		fromHostToContainer := []byte("copy from host to container")
    45  
    46  		session := podmanTest.Podman([]string{"create", ALPINE, "cat", "foo"})
    47  		session.WaitWithDefaultTimeout()
    48  		Expect(session.ExitCode()).To(Equal(0))
    49  		name := session.OutputToString()
    50  
    51  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
    52  		Expect(err).To(BeNil())
    53  
    54  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foo/"})
    55  		session.WaitWithDefaultTimeout()
    56  		Expect(session).To(ExitWithError())
    57  
    58  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foo"})
    59  		session.WaitWithDefaultTimeout()
    60  		Expect(session.ExitCode()).To(Equal(0))
    61  
    62  		session = podmanTest.Podman([]string{"cp", name + ":foo", dstPath})
    63  		session.WaitWithDefaultTimeout()
    64  		Expect(session.ExitCode()).To(Equal(0))
    65  
    66  		session = podmanTest.Podman([]string{"start", name})
    67  		session.WaitWithDefaultTimeout()
    68  		Expect(session.ExitCode()).To(Equal(0))
    69  	})
    70  
    71  	It("podman cp file to dir", func() {
    72  		name := "testctr"
    73  		setup := podmanTest.RunTopContainer(name)
    74  		setup.WaitWithDefaultTimeout()
    75  		Expect(setup.ExitCode()).To(Equal(0))
    76  
    77  		srcPath := "/tmp/cp_test.txt"
    78  		fromHostToContainer := []byte("copy from host to container directory")
    79  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
    80  		Expect(err).To(BeNil())
    81  
    82  		session := podmanTest.Podman([]string{"exec", name, "mkdir", "foodir"})
    83  		session.WaitWithDefaultTimeout()
    84  		Expect(session.ExitCode()).To(Equal(0))
    85  
    86  		session = podmanTest.Podman([]string{"cp", srcPath, name + ":foodir/"})
    87  		session.WaitWithDefaultTimeout()
    88  		Expect(session.ExitCode()).To(Equal(0))
    89  
    90  		session = podmanTest.Podman([]string{"exec", name, "ls", "foodir/cp_test.txt"})
    91  		session.WaitWithDefaultTimeout()
    92  		Expect(session.ExitCode()).To(Equal(0))
    93  
    94  		os.Remove("/tmp/cp_test.txt")
    95  	})
    96  
    97  	It("podman cp dir to dir", func() {
    98  		testDirPath := filepath.Join(podmanTest.RunRoot, "TestDir")
    99  
   100  		session := podmanTest.Podman([]string{"create", ALPINE, "ls", "/foodir"})
   101  		session.WaitWithDefaultTimeout()
   102  		Expect(session.ExitCode()).To(Equal(0))
   103  		name := session.OutputToString()
   104  
   105  		err := os.Mkdir(testDirPath, 0755)
   106  		Expect(err).To(BeNil())
   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  		os.RemoveAll(testDirPath)
   142  	})
   143  
   144  	It("podman cp stdin/stdout", func() {
   145  		session := podmanTest.Podman([]string{"create", ALPINE, "ls", "foo"})
   146  		session.WaitWithDefaultTimeout()
   147  		Expect(session.ExitCode()).To(Equal(0))
   148  		name := session.OutputToString()
   149  
   150  		testDirPath := filepath.Join(podmanTest.RunRoot, "TestDir")
   151  		err := os.Mkdir(testDirPath, 0755)
   152  		Expect(err).To(BeNil())
   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.RemoveAll(testDirPath)
   172  		os.Remove("file.tar.gz")
   173  	})
   174  
   175  	It("podman cp tar", func() {
   176  		testctr := "testctr"
   177  		setup := podmanTest.RunTopContainer(testctr)
   178  		setup.WaitWithDefaultTimeout()
   179  		Expect(setup.ExitCode()).To(Equal(0))
   180  
   181  		session := podmanTest.Podman([]string{"exec", testctr, "mkdir", "foo"})
   182  		session.WaitWithDefaultTimeout()
   183  		Expect(session.ExitCode()).To(Equal(0))
   184  
   185  		path, err := os.Getwd()
   186  		Expect(err).To(BeNil())
   187  		testDirPath := filepath.Join(path, "TestDir")
   188  		err = os.Mkdir(testDirPath, 0777)
   189  		Expect(err).To(BeNil())
   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  		os.RemoveAll(testDirPath)
   205  	})
   206  
   207  	It("podman cp symlink", func() {
   208  		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "top"})
   209  		session.WaitWithDefaultTimeout()
   210  		Expect(session.ExitCode()).To(Equal(0))
   211  		name := session.OutputToString()
   212  
   213  		srcPath := filepath.Join(podmanTest.RunRoot, "cp_test.txt")
   214  		fromHostToContainer := []byte("copy from host to container")
   215  		err := ioutil.WriteFile(srcPath, fromHostToContainer, 0644)
   216  		Expect(err).To(BeNil())
   217  
   218  		session = podmanTest.Podman([]string{"exec", name, "ln", "-s", "/tmp", "/test"})
   219  		session.WaitWithDefaultTimeout()
   220  		Expect(session.ExitCode()).To(Equal(0))
   221  
   222  		session = podmanTest.Podman([]string{"cp", "--pause=false", srcPath, name + ":/test"})
   223  		session.WaitWithDefaultTimeout()
   224  		Expect(session.ExitCode()).To(Equal(0))
   225  
   226  		_, err = os.Stat("/tmp/cp_test.txt")
   227  		Expect(err).To(Not(BeNil()))
   228  
   229  		session = podmanTest.Podman([]string{"exec", name, "ln", "-s", "/tmp/nonesuch", "/test1"})
   230  		session.WaitWithDefaultTimeout()
   231  		Expect(session.ExitCode()).To(Equal(0))
   232  
   233  		session = podmanTest.Podman([]string{"cp", "--pause=false", srcPath, name + ":/test1/"})
   234  		session.WaitWithDefaultTimeout()
   235  		Expect(session).To(ExitWithError())
   236  
   237  	})
   238  	It("podman cp volume", func() {
   239  		session := podmanTest.Podman([]string{"volume", "create", "data"})
   240  		session.WaitWithDefaultTimeout()
   241  		Expect(session.ExitCode()).To(Equal(0))
   242  
   243  		session = podmanTest.Podman([]string{"create", "-v", "data:/data", "--name", "container1", ALPINE})
   244  		session.WaitWithDefaultTimeout()
   245  		Expect(session.ExitCode()).To(Equal(0))
   246  
   247  		err = ioutil.WriteFile("cp_vol", []byte("copy to the volume"), 0644)
   248  		if err != nil {
   249  			os.Exit(1)
   250  		}
   251  		session = podmanTest.Podman([]string{"cp", "cp_vol", "container1" + ":/data/cp_vol1"})
   252  		session.WaitWithDefaultTimeout()
   253  		Expect(session.ExitCode()).To(Equal(0))
   254  
   255  		session = podmanTest.Podman([]string{"cp", "container1" + ":/data/cp_vol1", "cp_vol2"})
   256  		session.WaitWithDefaultTimeout()
   257  		Expect(session.ExitCode()).To(Equal(0))
   258  
   259  		os.Remove("cp_vol")
   260  		os.Remove("cp_vol2")
   261  	})
   262  
   263  	It("podman cp from ctr chown ", func() {
   264  		setup := podmanTest.RunTopContainer("testctr")
   265  		setup.WaitWithDefaultTimeout()
   266  		Expect(setup.ExitCode()).To(Equal(0))
   267  
   268  		session := podmanTest.Podman([]string{"exec", "testctr", "adduser", "-S", "testuser"})
   269  		session.WaitWithDefaultTimeout()
   270  		Expect(session.ExitCode()).To(Equal(0))
   271  
   272  		session = podmanTest.Podman([]string{"exec", "-u", "testuser", "testctr", "touch", "testfile"})
   273  		session.WaitWithDefaultTimeout()
   274  		Expect(session.ExitCode()).To(Equal(0))
   275  
   276  		session = podmanTest.Podman([]string{"cp", "--pause=false", "testctr:testfile", "testfile1"})
   277  		session.WaitWithDefaultTimeout()
   278  		Expect(session.ExitCode()).To(Equal(0))
   279  
   280  		// owner of the file copied to local machine is not testuser
   281  		cmd := exec.Command("ls", "-l", "testfile1")
   282  		cmdRet, err := cmd.Output()
   283  		Expect(err).To(BeNil())
   284  		Expect(strings.Contains(string(cmdRet), "testuser")).To(BeFalse())
   285  
   286  		session = podmanTest.Podman([]string{"cp", "--pause=false", "testfile1", "testctr:testfile2"})
   287  		session.WaitWithDefaultTimeout()
   288  		Expect(session.ExitCode()).To(Equal(0))
   289  
   290  		// owner of the file copied to a container is the root user
   291  		session = podmanTest.Podman([]string{"exec", "-it", "testctr", "ls", "-l", "testfile2"})
   292  		session.WaitWithDefaultTimeout()
   293  		Expect(session.ExitCode()).To(Equal(0))
   294  		Expect(session.OutputToString()).To(ContainSubstring("root"))
   295  
   296  		os.Remove("testfile1")
   297  	})
   298  })