forked from openshift/origin
-
Notifications
You must be signed in to change notification settings - Fork 0
/
admin.go
142 lines (113 loc) · 3.61 KB
/
admin.go
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
132
133
134
135
136
137
138
139
140
141
142
package server
import (
"fmt"
"net/http"
ctxu "github.com/docker/distribution/context"
"github.com/docker/distribution/digest"
"github.com/docker/distribution/registry/api/v2"
"github.com/docker/distribution/registry/handlers"
gorillahandlers "github.com/gorilla/handlers"
)
// BlobDispatcher takes the request context and builds the appropriate handler
// for handling blob requests.
func BlobDispatcher(ctx *handlers.Context, r *http.Request) http.Handler {
reference := ctxu.GetStringValue(ctx, "vars.digest")
dgst, _ := digest.ParseDigest(reference)
blobHandler := &blobHandler{
Context: ctx,
Digest: dgst,
}
return gorillahandlers.MethodHandler{
"DELETE": http.HandlerFunc(blobHandler.Delete),
}
}
// blobHandler handles http operations on blobs.
type blobHandler struct {
*handlers.Context
Digest digest.Digest
}
// Delete deletes the blob from the storage backend.
func (bh *blobHandler) Delete(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
if len(bh.Digest) == 0 {
bh.Errors.Push(v2.ErrorCodeBlobUnknown)
w.WriteHeader(http.StatusNotFound)
return
}
err := bh.Registry().Blobs().Delete(bh.Digest)
if err != nil {
bh.Errors.PushErr(fmt.Errorf("error deleting blob %q: %v", bh.Digest, err))
w.WriteHeader(http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusNoContent)
}
// LayerDispatcher takes the request context and builds the appropriate handler
// for handling layer requests.
func LayerDispatcher(ctx *handlers.Context, r *http.Request) http.Handler {
reference := ctxu.GetStringValue(ctx, "vars.digest")
dgst, _ := digest.ParseDigest(reference)
layerHandler := &layerHandler{
Context: ctx,
Digest: dgst,
}
return gorillahandlers.MethodHandler{
"DELETE": http.HandlerFunc(layerHandler.Delete),
}
}
// layerHandler handles http operations on layers.
type layerHandler struct {
*handlers.Context
Digest digest.Digest
}
// Delete deletes the layer link from the repository from the storage backend.
func (lh *layerHandler) Delete(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
if len(lh.Digest) == 0 {
lh.Errors.Push(v2.ErrorCodeBlobUnknown)
w.WriteHeader(http.StatusNotFound)
return
}
err := lh.Repository.Layers().Delete(lh.Digest)
if err != nil {
lh.Errors.PushErr(fmt.Errorf("error unlinking layer %q from repo %q: %v", lh.Digest, lh.Repository.Name(), err))
w.WriteHeader(http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusNoContent)
}
// ManifestDispatcher takes the request context and builds the appropriate
// handler for handling manifest requests.
func ManifestDispatcher(ctx *handlers.Context, r *http.Request) http.Handler {
reference := ctxu.GetStringValue(ctx, "vars.digest")
dgst, _ := digest.ParseDigest(reference)
manifestHandler := &manifestHandler{
Context: ctx,
Digest: dgst,
}
return gorillahandlers.MethodHandler{
"DELETE": http.HandlerFunc(manifestHandler.Delete),
}
}
// manifestHandler handles http operations on mainfests.
type manifestHandler struct {
*handlers.Context
Digest digest.Digest
}
// Delete deletes the manifest information from the repository from the storage
// backend.
func (mh *manifestHandler) Delete(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
if len(mh.Digest) == 0 {
mh.Errors.Push(v2.ErrorCodeManifestUnknown)
w.WriteHeader(http.StatusNotFound)
return
}
err := mh.Repository.Manifests().Delete(mh.Context, mh.Digest)
if err != nil {
mh.Errors.PushErr(fmt.Errorf("error deleting repo %q, manifest %q: %v", mh.Repository.Name(), mh.Digest, err))
w.WriteHeader(http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusNoContent)
}