docker_cli_by_digest_test.go 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515
  1. package main
  2. import (
  3. "fmt"
  4. "os/exec"
  5. "regexp"
  6. "strings"
  7. "github.com/docker/docker/utils"
  8. "github.com/go-check/check"
  9. )
  10. var (
  11. repoName = fmt.Sprintf("%v/dockercli/busybox-by-dgst", privateRegistryURL)
  12. digestRegex = regexp.MustCompile("Digest: ([^\n]+)")
  13. )
  14. func setupImage() (string, error) {
  15. return setupImageWithTag("latest")
  16. }
  17. func setupImageWithTag(tag string) (string, error) {
  18. containerName := "busyboxbydigest"
  19. cmd := exec.Command(dockerBinary, "run", "-d", "-e", "digest=1", "--name", containerName, "busybox")
  20. if _, err := runCommand(cmd); err != nil {
  21. return "", err
  22. }
  23. // tag the image to upload it to the private registry
  24. repoAndTag := utils.ImageReference(repoName, tag)
  25. cmd = exec.Command(dockerBinary, "commit", containerName, repoAndTag)
  26. if out, _, err := runCommandWithOutput(cmd); err != nil {
  27. return "", fmt.Errorf("image tagging failed: %s, %v", out, err)
  28. }
  29. // delete the container as we don't need it any more
  30. if err := deleteContainer(containerName); err != nil {
  31. return "", err
  32. }
  33. // push the image
  34. cmd = exec.Command(dockerBinary, "push", repoAndTag)
  35. out, _, err := runCommandWithOutput(cmd)
  36. if err != nil {
  37. return "", fmt.Errorf("pushing the image to the private registry has failed: %s, %v", out, err)
  38. }
  39. // delete our local repo that we previously tagged
  40. cmd = exec.Command(dockerBinary, "rmi", repoAndTag)
  41. if out, _, err := runCommandWithOutput(cmd); err != nil {
  42. return "", fmt.Errorf("error deleting images prior to real test: %s, %v", out, err)
  43. }
  44. // the push output includes "Digest: <digest>", so find that
  45. matches := digestRegex.FindStringSubmatch(out)
  46. if len(matches) != 2 {
  47. return "", fmt.Errorf("unable to parse digest from push output: %s", out)
  48. }
  49. pushDigest := matches[1]
  50. return pushDigest, nil
  51. }
  52. func (s *DockerSuite) TestPullByTagDisplaysDigest(c *check.C) {
  53. defer setupRegistry(c)()
  54. pushDigest, err := setupImage()
  55. if err != nil {
  56. c.Fatalf("error setting up image: %v", err)
  57. }
  58. // pull from the registry using the tag
  59. cmd := exec.Command(dockerBinary, "pull", repoName)
  60. out, _, err := runCommandWithOutput(cmd)
  61. if err != nil {
  62. c.Fatalf("error pulling by tag: %s, %v", out, err)
  63. }
  64. // the pull output includes "Digest: <digest>", so find that
  65. matches := digestRegex.FindStringSubmatch(out)
  66. if len(matches) != 2 {
  67. c.Fatalf("unable to parse digest from pull output: %s", out)
  68. }
  69. pullDigest := matches[1]
  70. // make sure the pushed and pull digests match
  71. if pushDigest != pullDigest {
  72. c.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
  73. }
  74. }
  75. func (s *DockerSuite) TestPullByDigest(c *check.C) {
  76. defer setupRegistry(c)()
  77. pushDigest, err := setupImage()
  78. if err != nil {
  79. c.Fatalf("error setting up image: %v", err)
  80. }
  81. // pull from the registry using the <name>@<digest> reference
  82. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  83. cmd := exec.Command(dockerBinary, "pull", imageReference)
  84. out, _, err := runCommandWithOutput(cmd)
  85. if err != nil {
  86. c.Fatalf("error pulling by digest: %s, %v", out, err)
  87. }
  88. // the pull output includes "Digest: <digest>", so find that
  89. matches := digestRegex.FindStringSubmatch(out)
  90. if len(matches) != 2 {
  91. c.Fatalf("unable to parse digest from pull output: %s", out)
  92. }
  93. pullDigest := matches[1]
  94. // make sure the pushed and pull digests match
  95. if pushDigest != pullDigest {
  96. c.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
  97. }
  98. }
  99. func (s *DockerSuite) TestCreateByDigest(c *check.C) {
  100. defer setupRegistry(c)()
  101. pushDigest, err := setupImage()
  102. if err != nil {
  103. c.Fatalf("error setting up image: %v", err)
  104. }
  105. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  106. containerName := "createByDigest"
  107. cmd := exec.Command(dockerBinary, "create", "--name", containerName, imageReference)
  108. out, _, err := runCommandWithOutput(cmd)
  109. if err != nil {
  110. c.Fatalf("error creating by digest: %s, %v", out, err)
  111. }
  112. res, err := inspectField(containerName, "Config.Image")
  113. if err != nil {
  114. c.Fatalf("failed to get Config.Image: %s, %v", out, err)
  115. }
  116. if res != imageReference {
  117. c.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
  118. }
  119. }
  120. func (s *DockerSuite) TestRunByDigest(c *check.C) {
  121. defer setupRegistry(c)()
  122. pushDigest, err := setupImage()
  123. if err != nil {
  124. c.Fatalf("error setting up image: %v", err)
  125. }
  126. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  127. containerName := "runByDigest"
  128. cmd := exec.Command(dockerBinary, "run", "--name", containerName, imageReference, "sh", "-c", "echo found=$digest")
  129. out, _, err := runCommandWithOutput(cmd)
  130. if err != nil {
  131. c.Fatalf("error run by digest: %s, %v", out, err)
  132. }
  133. foundRegex := regexp.MustCompile("found=([^\n]+)")
  134. matches := foundRegex.FindStringSubmatch(out)
  135. if len(matches) != 2 {
  136. c.Fatalf("error locating expected 'found=1' output: %s", out)
  137. }
  138. if matches[1] != "1" {
  139. c.Fatalf("Expected %q, got %q", "1", matches[1])
  140. }
  141. res, err := inspectField(containerName, "Config.Image")
  142. if err != nil {
  143. c.Fatalf("failed to get Config.Image: %s, %v", out, err)
  144. }
  145. if res != imageReference {
  146. c.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
  147. }
  148. }
  149. func (s *DockerSuite) TestRemoveImageByDigest(c *check.C) {
  150. defer setupRegistry(c)()
  151. digest, err := setupImage()
  152. if err != nil {
  153. c.Fatalf("error setting up image: %v", err)
  154. }
  155. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  156. // pull from the registry using the <name>@<digest> reference
  157. cmd := exec.Command(dockerBinary, "pull", imageReference)
  158. out, _, err := runCommandWithOutput(cmd)
  159. if err != nil {
  160. c.Fatalf("error pulling by digest: %s, %v", out, err)
  161. }
  162. // make sure inspect runs ok
  163. if _, err := inspectField(imageReference, "Id"); err != nil {
  164. c.Fatalf("failed to inspect image: %v", err)
  165. }
  166. // do the delete
  167. if err := deleteImages(imageReference); err != nil {
  168. c.Fatalf("unexpected error deleting image: %v", err)
  169. }
  170. // try to inspect again - it should error this time
  171. if _, err := inspectField(imageReference, "Id"); err == nil {
  172. c.Fatalf("unexpected nil err trying to inspect what should be a non-existent image")
  173. } else if !strings.Contains(err.Error(), "No such image") {
  174. c.Fatalf("expected 'No such image' output, got %v", err)
  175. }
  176. }
  177. func (s *DockerSuite) TestBuildByDigest(c *check.C) {
  178. defer setupRegistry(c)()
  179. digest, err := setupImage()
  180. if err != nil {
  181. c.Fatalf("error setting up image: %v", err)
  182. }
  183. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  184. // pull from the registry using the <name>@<digest> reference
  185. cmd := exec.Command(dockerBinary, "pull", imageReference)
  186. out, _, err := runCommandWithOutput(cmd)
  187. if err != nil {
  188. c.Fatalf("error pulling by digest: %s, %v", out, err)
  189. }
  190. // get the image id
  191. imageID, err := inspectField(imageReference, "Id")
  192. if err != nil {
  193. c.Fatalf("error getting image id: %v", err)
  194. }
  195. // do the build
  196. name := "buildbydigest"
  197. _, err = buildImage(name, fmt.Sprintf(
  198. `FROM %s
  199. CMD ["/bin/echo", "Hello World"]`, imageReference),
  200. true)
  201. if err != nil {
  202. c.Fatal(err)
  203. }
  204. // get the build's image id
  205. res, err := inspectField(name, "Config.Image")
  206. if err != nil {
  207. c.Fatal(err)
  208. }
  209. // make sure they match
  210. if res != imageID {
  211. c.Fatalf("Image %s, expected %s", res, imageID)
  212. }
  213. }
  214. func (s *DockerSuite) TestTagByDigest(c *check.C) {
  215. defer setupRegistry(c)()
  216. digest, err := setupImage()
  217. if err != nil {
  218. c.Fatalf("error setting up image: %v", err)
  219. }
  220. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  221. // pull from the registry using the <name>@<digest> reference
  222. cmd := exec.Command(dockerBinary, "pull", imageReference)
  223. out, _, err := runCommandWithOutput(cmd)
  224. if err != nil {
  225. c.Fatalf("error pulling by digest: %s, %v", out, err)
  226. }
  227. // tag it
  228. tag := "tagbydigest"
  229. cmd = exec.Command(dockerBinary, "tag", imageReference, tag)
  230. if _, err := runCommand(cmd); err != nil {
  231. c.Fatalf("unexpected error tagging: %v", err)
  232. }
  233. expectedID, err := inspectField(imageReference, "Id")
  234. if err != nil {
  235. c.Fatalf("error getting original image id: %v", err)
  236. }
  237. tagID, err := inspectField(tag, "Id")
  238. if err != nil {
  239. c.Fatalf("error getting tagged image id: %v", err)
  240. }
  241. if tagID != expectedID {
  242. c.Fatalf("expected image id %q, got %q", expectedID, tagID)
  243. }
  244. }
  245. func (s *DockerSuite) TestListImagesWithoutDigests(c *check.C) {
  246. defer setupRegistry(c)()
  247. digest, err := setupImage()
  248. if err != nil {
  249. c.Fatalf("error setting up image: %v", err)
  250. }
  251. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  252. // pull from the registry using the <name>@<digest> reference
  253. cmd := exec.Command(dockerBinary, "pull", imageReference)
  254. out, _, err := runCommandWithOutput(cmd)
  255. if err != nil {
  256. c.Fatalf("error pulling by digest: %s, %v", out, err)
  257. }
  258. cmd = exec.Command(dockerBinary, "images")
  259. out, _, err = runCommandWithOutput(cmd)
  260. if err != nil {
  261. c.Fatalf("error listing images: %s, %v", out, err)
  262. }
  263. if strings.Contains(out, "DIGEST") {
  264. c.Fatalf("list output should not have contained DIGEST header: %s", out)
  265. }
  266. }
  267. func (s *DockerSuite) TestListImagesWithDigests(c *check.C) {
  268. defer setupRegistry(c)()
  269. // setup image1
  270. digest1, err := setupImageWithTag("tag1")
  271. if err != nil {
  272. c.Fatalf("error setting up image: %v", err)
  273. }
  274. imageReference1 := fmt.Sprintf("%s@%s", repoName, digest1)
  275. c.Logf("imageReference1 = %s", imageReference1)
  276. // pull image1 by digest
  277. cmd := exec.Command(dockerBinary, "pull", imageReference1)
  278. out, _, err := runCommandWithOutput(cmd)
  279. if err != nil {
  280. c.Fatalf("error pulling by digest: %s, %v", out, err)
  281. }
  282. // list images
  283. cmd = exec.Command(dockerBinary, "images", "--digests")
  284. out, _, err = runCommandWithOutput(cmd)
  285. if err != nil {
  286. c.Fatalf("error listing images: %s, %v", out, err)
  287. }
  288. // make sure repo shown, tag=<none>, digest = $digest1
  289. re1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1 + `\s`)
  290. if !re1.MatchString(out) {
  291. c.Fatalf("expected %q: %s", re1.String(), out)
  292. }
  293. // setup image2
  294. digest2, err := setupImageWithTag("tag2")
  295. if err != nil {
  296. c.Fatalf("error setting up image: %v", err)
  297. }
  298. imageReference2 := fmt.Sprintf("%s@%s", repoName, digest2)
  299. c.Logf("imageReference2 = %s", imageReference2)
  300. // pull image1 by digest
  301. cmd = exec.Command(dockerBinary, "pull", imageReference1)
  302. out, _, err = runCommandWithOutput(cmd)
  303. if err != nil {
  304. c.Fatalf("error pulling by digest: %s, %v", out, err)
  305. }
  306. // pull image2 by digest
  307. cmd = exec.Command(dockerBinary, "pull", imageReference2)
  308. out, _, err = runCommandWithOutput(cmd)
  309. if err != nil {
  310. c.Fatalf("error pulling by digest: %s, %v", out, err)
  311. }
  312. // list images
  313. cmd = exec.Command(dockerBinary, "images", "--digests")
  314. out, _, err = runCommandWithOutput(cmd)
  315. if err != nil {
  316. c.Fatalf("error listing images: %s, %v", out, err)
  317. }
  318. // make sure repo shown, tag=<none>, digest = $digest1
  319. if !re1.MatchString(out) {
  320. c.Fatalf("expected %q: %s", re1.String(), out)
  321. }
  322. // make sure repo shown, tag=<none>, digest = $digest2
  323. re2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2 + `\s`)
  324. if !re2.MatchString(out) {
  325. c.Fatalf("expected %q: %s", re2.String(), out)
  326. }
  327. // pull tag1
  328. cmd = exec.Command(dockerBinary, "pull", repoName+":tag1")
  329. out, _, err = runCommandWithOutput(cmd)
  330. if err != nil {
  331. c.Fatalf("error pulling tag1: %s, %v", out, err)
  332. }
  333. // list images
  334. cmd = exec.Command(dockerBinary, "images", "--digests")
  335. out, _, err = runCommandWithOutput(cmd)
  336. if err != nil {
  337. c.Fatalf("error listing images: %s, %v", out, err)
  338. }
  339. // make sure image 1 has repo, tag, <none> AND repo, <none>, digest
  340. reWithTag1 := regexp.MustCompile(`\s*` + repoName + `\s*tag1\s*<none>\s`)
  341. reWithDigest1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1 + `\s`)
  342. if !reWithTag1.MatchString(out) {
  343. c.Fatalf("expected %q: %s", reWithTag1.String(), out)
  344. }
  345. if !reWithDigest1.MatchString(out) {
  346. c.Fatalf("expected %q: %s", reWithDigest1.String(), out)
  347. }
  348. // make sure image 2 has repo, <none>, digest
  349. if !re2.MatchString(out) {
  350. c.Fatalf("expected %q: %s", re2.String(), out)
  351. }
  352. // pull tag 2
  353. cmd = exec.Command(dockerBinary, "pull", repoName+":tag2")
  354. out, _, err = runCommandWithOutput(cmd)
  355. if err != nil {
  356. c.Fatalf("error pulling tag2: %s, %v", out, err)
  357. }
  358. // list images
  359. cmd = exec.Command(dockerBinary, "images", "--digests")
  360. out, _, err = runCommandWithOutput(cmd)
  361. if err != nil {
  362. c.Fatalf("error listing images: %s, %v", out, err)
  363. }
  364. // make sure image 1 has repo, tag, digest
  365. if !reWithTag1.MatchString(out) {
  366. c.Fatalf("expected %q: %s", re1.String(), out)
  367. }
  368. // make sure image 2 has repo, tag, digest
  369. reWithTag2 := regexp.MustCompile(`\s*` + repoName + `\s*tag2\s*<none>\s`)
  370. reWithDigest2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2 + `\s`)
  371. if !reWithTag2.MatchString(out) {
  372. c.Fatalf("expected %q: %s", reWithTag2.String(), out)
  373. }
  374. if !reWithDigest2.MatchString(out) {
  375. c.Fatalf("expected %q: %s", reWithDigest2.String(), out)
  376. }
  377. // list images
  378. cmd = exec.Command(dockerBinary, "images", "--digests")
  379. out, _, err = runCommandWithOutput(cmd)
  380. if err != nil {
  381. c.Fatalf("error listing images: %s, %v", out, err)
  382. }
  383. // make sure image 1 has repo, tag, digest
  384. if !reWithTag1.MatchString(out) {
  385. c.Fatalf("expected %q: %s", re1.String(), out)
  386. }
  387. // make sure image 2 has repo, tag, digest
  388. if !reWithTag2.MatchString(out) {
  389. c.Fatalf("expected %q: %s", re2.String(), out)
  390. }
  391. // make sure busybox has tag, but not digest
  392. busyboxRe := regexp.MustCompile(`\s*busybox\s*latest\s*<none>\s`)
  393. if !busyboxRe.MatchString(out) {
  394. c.Fatalf("expected %q: %s", busyboxRe.String(), out)
  395. }
  396. }
  397. func (s *DockerSuite) TestDeleteImageByIDOnlyPulledByDigest(c *check.C) {
  398. defer setupRegistry(c)()
  399. pushDigest, err := setupImage()
  400. if err != nil {
  401. c.Fatalf("error setting up image: %v", err)
  402. }
  403. // pull from the registry using the <name>@<digest> reference
  404. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  405. cmd := exec.Command(dockerBinary, "pull", imageReference)
  406. out, _, err := runCommandWithOutput(cmd)
  407. if err != nil {
  408. c.Fatalf("error pulling by digest: %s, %v", out, err)
  409. }
  410. // just in case...
  411. imageID, err := inspectField(imageReference, ".Id")
  412. if err != nil {
  413. c.Fatalf("error inspecting image id: %v", err)
  414. }
  415. cmd = exec.Command(dockerBinary, "rmi", imageID)
  416. if _, err := runCommand(cmd); err != nil {
  417. c.Fatalf("error deleting image by id: %v", err)
  418. }
  419. }