ro_layer.go 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  1. package layer
  2. import (
  3. "fmt"
  4. "io"
  5. "github.com/docker/distribution"
  6. "github.com/docker/distribution/digest"
  7. )
  8. type roLayer struct {
  9. chainID ChainID
  10. diffID DiffID
  11. parent *roLayer
  12. cacheID string
  13. size int64
  14. layerStore *layerStore
  15. descriptor distribution.Descriptor
  16. referenceCount int
  17. references map[Layer]struct{}
  18. }
  19. // TarStream for roLayer guarantees that the data that is produced is the exact
  20. // data that the layer was registered with.
  21. func (rl *roLayer) TarStream() (io.ReadCloser, error) {
  22. r, err := rl.layerStore.store.TarSplitReader(rl.chainID)
  23. if err != nil {
  24. return nil, err
  25. }
  26. pr, pw := io.Pipe()
  27. go func() {
  28. err := rl.layerStore.assembleTarTo(rl.cacheID, r, nil, pw)
  29. if err != nil {
  30. pw.CloseWithError(err)
  31. } else {
  32. pw.Close()
  33. }
  34. }()
  35. rc, err := newVerifiedReadCloser(pr, digest.Digest(rl.diffID))
  36. if err != nil {
  37. return nil, err
  38. }
  39. return rc, nil
  40. }
  41. // TarStreamFrom does not make any guarantees to the correctness of the produced
  42. // data. As such it should not be used when the layer content must be verified
  43. // to be an exact match to the registered layer.
  44. func (rl *roLayer) TarStreamFrom(parent ChainID) (io.ReadCloser, error) {
  45. var parentCacheID string
  46. for pl := rl.parent; pl != nil; pl = pl.parent {
  47. if pl.chainID == parent {
  48. parentCacheID = pl.cacheID
  49. break
  50. }
  51. }
  52. if parent != ChainID("") && parentCacheID == "" {
  53. return nil, fmt.Errorf("layer ID '%s' is not a parent of the specified layer: cannot provide diff to non-parent", parent)
  54. }
  55. return rl.layerStore.driver.Diff(rl.cacheID, parentCacheID)
  56. }
  57. func (rl *roLayer) ChainID() ChainID {
  58. return rl.chainID
  59. }
  60. func (rl *roLayer) DiffID() DiffID {
  61. return rl.diffID
  62. }
  63. func (rl *roLayer) Parent() Layer {
  64. if rl.parent == nil {
  65. return nil
  66. }
  67. return rl.parent
  68. }
  69. func (rl *roLayer) Size() (size int64, err error) {
  70. if rl.parent != nil {
  71. size, err = rl.parent.Size()
  72. if err != nil {
  73. return
  74. }
  75. }
  76. return size + rl.size, nil
  77. }
  78. func (rl *roLayer) DiffSize() (size int64, err error) {
  79. return rl.size, nil
  80. }
  81. func (rl *roLayer) Metadata() (map[string]string, error) {
  82. return rl.layerStore.driver.GetMetadata(rl.cacheID)
  83. }
  84. type referencedCacheLayer struct {
  85. *roLayer
  86. }
  87. func (rl *roLayer) getReference() Layer {
  88. ref := &referencedCacheLayer{
  89. roLayer: rl,
  90. }
  91. rl.references[ref] = struct{}{}
  92. return ref
  93. }
  94. func (rl *roLayer) hasReference(ref Layer) bool {
  95. _, ok := rl.references[ref]
  96. return ok
  97. }
  98. func (rl *roLayer) hasReferences() bool {
  99. return len(rl.references) > 0
  100. }
  101. func (rl *roLayer) deleteReference(ref Layer) {
  102. delete(rl.references, ref)
  103. }
  104. func (rl *roLayer) depth() int {
  105. if rl.parent == nil {
  106. return 1
  107. }
  108. return rl.parent.depth() + 1
  109. }
  110. func storeLayer(tx MetadataTransaction, layer *roLayer) error {
  111. if err := tx.SetDiffID(layer.diffID); err != nil {
  112. return err
  113. }
  114. if err := tx.SetSize(layer.size); err != nil {
  115. return err
  116. }
  117. if err := tx.SetCacheID(layer.cacheID); err != nil {
  118. return err
  119. }
  120. // Do not store empty descriptors
  121. if layer.descriptor.Digest != "" {
  122. if err := tx.SetDescriptor(layer.descriptor); err != nil {
  123. return err
  124. }
  125. }
  126. if layer.parent != nil {
  127. if err := tx.SetParent(layer.parent.chainID); err != nil {
  128. return err
  129. }
  130. }
  131. return nil
  132. }
  133. func newVerifiedReadCloser(rc io.ReadCloser, dgst digest.Digest) (io.ReadCloser, error) {
  134. verifier, err := digest.NewDigestVerifier(dgst)
  135. if err != nil {
  136. return nil, err
  137. }
  138. return &verifiedReadCloser{
  139. rc: rc,
  140. dgst: dgst,
  141. verifier: verifier,
  142. }, nil
  143. }
  144. type verifiedReadCloser struct {
  145. rc io.ReadCloser
  146. dgst digest.Digest
  147. verifier digest.Verifier
  148. }
  149. func (vrc *verifiedReadCloser) Read(p []byte) (n int, err error) {
  150. n, err = vrc.rc.Read(p)
  151. if n > 0 {
  152. if n, err := vrc.verifier.Write(p[:n]); err != nil {
  153. return n, err
  154. }
  155. }
  156. if err == io.EOF {
  157. if !vrc.verifier.Verified() {
  158. err = fmt.Errorf("could not verify layer data for: %s. This may be because internal files in the layer store were modified. Re-pulling or rebuilding this image may resolve the issue", vrc.dgst)
  159. }
  160. }
  161. return
  162. }
  163. func (vrc *verifiedReadCloser) Close() error {
  164. return vrc.rc.Close()
  165. }