1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
package main
import (
"archive/tar"
"bytes"
"compress/gzip"
"crypto/sha256"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
)
type Layer struct {
MediaType string `json:"mediaType"`
Size int `json:"size"`
Digest string `json:"digest"`
}
type Manifest struct {
SchemaVersion int `json:"schemaVersion"`
MediaType string `json:"mediaType"`
Config map[string]string `json:"config"`
Layers []Layer `json:"layers"`
}
// A really "dumb" representation of an image, with a data blob (tar.gz image) and its hash as the type expected
// in the manifest.
type Image struct {
Layer Layer
Data []byte
}
const ManifestContentType string = "application/vnd.docker.distribution.manifest.v2+json"
const LayerContentType string = "application/vnd.docker.image.rootfs.diff.tar.gzip"
func main() {
img := getImage()
manifest := Manifest{
SchemaVersion: 2,
MediaType: "application/vnd.docker.distribution.manifest.v2+json",
Config: map[string]string{},
Layers: []Layer{
img.Layer,
},
}
log.Fatal(http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Acknowledge that we speak V2
if r.RequestURI == "/v2/" {
log.Println("Acknowleding V2 API")
fmt.Fprintln(w)
return
}
// Serve manifest
if r.RequestURI == "/v2/quinistry/manifests/latest" {
log.Printf("Serving manifest for %v\n", *r)
w.Header().Add("Content-Type", ManifestContentType)
resp, _ := json.Marshal(manifest)
w.Header().Add("Docker-Content-Digest", digest(resp))
log.Println(digest(resp))
fmt.Fprintln(w, string(resp))
return
}
// Serve actual image layer
if r.RequestURI == fmt.Sprintf("/v2/quinistry/blob/%s", img.Layer.Digest) {
fmt.Printf("Serving layer for %v\n", *r)
fmt.Fprint(w, img.Data)
return
}
fmt.Printf("Unhandled: %v\n", *r)
})))
}
func digest(b []byte) string {
hash := sha256.New()
hash.Write(b)
return fmt.Sprintf("sha256:%x", hash.Sum(nil))
}
// Creates an image of the currently running binary (spooky!)
func getImage() *Image {
// Current binary, imagine this is some other output or whatever
path, _ := os.Executable()
// don't care about error! :O
file, _ := ioutil.ReadFile(path)
// First create tar archive
tarBuf := new(bytes.Buffer)
tarW := tar.NewWriter(tarBuf)
hdr := &tar.Header{
Name: "main",
Mode: 0755,
Size: int64(len(file)),
}
tarW.WriteHeader(hdr)
tarW.Write(file)
if err := tarW.Close(); err != nil {
log.Fatalln(err)
os.Exit(1)
}
// Then GZIP it
zBuf := new(bytes.Buffer)
zw := gzip.NewWriter(zBuf)
zw.Name = "Docker registry fake test"
zw.Write(tarBuf.Bytes())
if err := zw.Close(); err != nil {
log.Fatal(err)
os.Exit(1)
}
return &Image{
Layer: Layer{
MediaType: LayerContentType,
Size: zBuf.Len(),
Digest: digest(zBuf.Bytes()),
},
Data: zBuf.Bytes(),
}
}
|
