func PutRepositoryImagesV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
r := new(models.Repository)
if err := r.PutImages(namespace, repository); err != nil {
log.Error("[REGISTRY API V1] Put images error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put V1 images error"})
return http.StatusBadRequest, result
}
if ctx.Req.Header.Get("X-Docker-Token") == "true" {
username, _, _ := utils.DecodeBasicAuth(ctx.Req.Header.Get("Authorization"))
token := fmt.Sprintf("Token signature=%v,repository=\"%v/%v\",access=%v",
utils.MD5(username),
namespace,
repository,
"write")
ctx.Resp.Header().Set("X-Docker-Token", token)
ctx.Resp.Header().Set("WWW-Authenticate", token)
}
result, _ := json.Marshal(map[string]string{})
return http.StatusNoContent, result
}
func PutRepositoryV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
username, _, _ := utils.DecodeBasicAuth(ctx.Req.Header.Get("Authorization"))
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
body, err := ctx.Req.Body().String()
if err != nil {
log.Error("[REGISTRY API V1] Get request body error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put V1 repository failed,request body is empty"})
return http.StatusBadRequest, result
}
r := new(models.Repository)
if err := r.Put(namespace, repository, body, ctx.Req.Header.Get("User-Agent"), setting.APIVERSION_V1); err != nil {
log.Error("[REGISTRY API V1] Put repository error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": err.Error()})
return http.StatusBadRequest, result
}
if ctx.Req.Header.Get("X-Docker-Token") == "true" {
token := fmt.Sprintf("Token signature=%v,repository=\"%v/%v\",access=%v",
utils.MD5(username),
namespace,
repository,
"write")
ctx.Resp.Header().Set("X-Docker-Token", token)
ctx.Resp.Header().Set("WWW-Authenticate", token)
}
result, _ := json.Marshal(map[string]string{})
return http.StatusOK, result
}
func geneGuid() string {
guidBuff := make([]byte, 48)
if _, err := io.ReadFull(rand.Reader, guidBuff); err != nil {
log.Println("[ErrorInfo]", err.Error())
}
return utils.MD5(base64.URLEncoding.EncodeToString(guidBuff))
}
func PostBlobsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
uuid := utils.MD5(uuid.NewV4().String())
state := utils.MD5(fmt.Sprintf("%s/%s/%s", namespace, repository, time.Now().UnixNano()/int64(time.Millisecond)))
random := fmt.Sprintf("https://%s/v2/%s/%s/blobs/uploads/%s?_state=%s",
setting.Domains,
namespace,
repository,
uuid,
state)
ctx.Resp.Header().Set("Docker-Upload-Uuid", uuid)
ctx.Resp.Header().Set("Location", random)
ctx.Resp.Header().Set("Range", "0-0")
result, _ := json.Marshal(map[string]string{})
return http.StatusAccepted, result
}
func (b *bridge) createEvent(action string) *Event {
event := &Event{
ID: utils.MD5(uuid.NewV4().String()),
Timestamp: time.Now(),
Action: action,
}
//event.Source = b.source
event.Actor = b.Actor
event.Req = b.Req
return event
}
func PatchBlobsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
desc := ctx.Params(":uuid")
uuid := strings.Split(desc, "?")[0]
imagePathTmp := fmt.Sprintf("%v/%v", setting.ImagePath, uuid)
layerfileTmp := fmt.Sprintf("%v/%v/layer", setting.ImagePath, uuid)
//saving specific tarsum every times is in order to split the same tarsum in HEAD handler
if !utils.IsDirExist(imagePathTmp) {
os.MkdirAll(imagePathTmp, os.ModePerm)
}
if _, err := os.Stat(layerfileTmp); err == nil {
os.Remove(layerfileTmp)
}
data, _ := ctx.Req.Body().Bytes()
if err := ioutil.WriteFile(layerfileTmp, data, 0777); err != nil {
log.Error("[REGISTRY API V2] Failed to save layer file %v: %v", layerfileTmp, err.Error())
result, _ := json.Marshal(map[string]string{"message": "Failed to save layer file"})
return http.StatusInternalServerError, result
}
state := utils.MD5(fmt.Sprintf("%s/%s/%s", namespace, repository, time.Now().UnixNano()/int64(time.Millisecond)))
random := fmt.Sprintf("%s://%s/v2/%s/%s/blobs/uploads/%s?_state=%s",
setting.ListenMode,
setting.Domains,
namespace,
repository,
uuid,
state)
ctx.Resp.Header().Set("Docker-Upload-Uuid", uuid)
ctx.Resp.Header().Set("Location", random)
ctx.Resp.Header().Set("Range", fmt.Sprintf("0-%v", len(data)-1))
result, _ := json.Marshal(map[string]string{})
return http.StatusAccepted, result
}
//Support to push acis
func PostUploadHandler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
acifile := ctx.Params(":acifile")
signfile := fmt.Sprintf("%v%v", acifile, ".asc")
//TODO: only for testing,pubkey will be read and saved via user management module
pubkeyspath := module.GetPubkeysPath(namespace, repository)
if _, err := os.Stat(pubkeyspath); err != nil {
if err := os.MkdirAll(pubkeyspath, os.ModePerm); err != nil {
log.Error("[ACI API] Create pubkeys path failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Create pubkeys path failed"})
return http.StatusInternalServerError, result
}
}
imageId := utils.MD5(uuid.NewV4().String())
imagepath := module.GetImagePath(imageId)
if err := os.MkdirAll(imagepath, os.ModePerm); err != nil {
log.Error("[ACI API] Create aci path failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Create aci path failed"})
return http.StatusInternalServerError, result
}
prefix := fmt.Sprintf("%v://%v/ac/push/%v/%v/", setting.ListenMode, setting.Domains, namespace, repository)
endpoint := models.UploadDetails{
ACIPushVersion: "0.0.1", //TODO: follow ACI push spec
Multipart: false,
ManifestURL: prefix + imageId + "/manifest",
SignatureURL: prefix + imageId + "/signature/" + signfile,
ACIURL: prefix + imageId + "/aci/" + acifile,
CompletedURL: prefix + imageId + "/complete/" + acifile + "/" + signfile,
}
result, _ := json.Marshal(endpoint)
return http.StatusOK, result
}
func GetRepositoryImagesV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
repo := new(models.Repository)
if has, _, err := repo.Has(namespace, repository); err != nil {
log.Error("[REGISTRY API V1] Read repository json error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Get V1 repository images failed,wrong name or repository"})
return http.StatusBadRequest, result
} else if has == false {
log.Error("[REGISTRY API V1] Read repository no found, %v/%v", namespace, repository)
result, _ := json.Marshal(map[string]string{"message": "Get V1 repository images failed,repository no found"})
return http.StatusNotFound, result
}
repo.Download += 1
if err := repo.Save(); err != nil {
log.Error("[REGISTRY API V1] Update download count error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Save V1 repository failed"})
return http.StatusBadRequest, result
}
username, _, _ := utils.DecodeBasicAuth(ctx.Req.Header.Get("Authorization"))
token := fmt.Sprintf("Token signature=%v,repository=\"%v/%v\",access=%v",
utils.MD5(username),
namespace,
repository,
"read")
ctx.Resp.Header().Set("X-Docker-Token", token)
ctx.Resp.Header().Set("WWW-Authenticate", token)
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(repo.JSON)))
return http.StatusOK, []byte(repo.JSON)
}
func GetRepositoryImagesV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
r := new(models.Repository)
if exists, err := r.Get(namespace, repository); err != nil {
log.Error("[REGISTRY API V1] Failed to get repository %v/%v context: %v", namespace, repository, err.Error())
result, _ := json.Marshal(map[string]string{"message": "Failed to get repository context"})
return http.StatusBadRequest, result
} else if exists == false {
log.Error("[REGISTRY API V1] Not found repository %v/%v", namespace, repository)
result, _ := json.Marshal(map[string]string{"message": "Not found repository"})
return http.StatusNotFound, result
}
r.Download += 1
if err := r.Save(namespace, repository); err != nil {
log.Error("[REGISTRY API V1] Failed to save repository %v/%v context: %v", namespace, repository, err.Error())
result, _ := json.Marshal(map[string]string{"message": "Failed to save repository context"})
return http.StatusBadRequest, result
}
username, _, _ := utils.DecodeBasicAuth(ctx.Req.Header.Get("Authorization"))
token := fmt.Sprintf("Token signature=%v,repository=\"%v/%v\",access=%v",
utils.MD5(username),
namespace,
repository,
"read")
ctx.Resp.Header().Set("X-Docker-Token", token)
ctx.Resp.Header().Set("WWW-Authenticate", token)
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(r.JSON)))
return http.StatusOK, []byte(r.JSON)
}