func GetTagsListV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
r := new(models.Repository)
if has, _, err := r.Has(namespace, repository); err != nil || has == false {
log.Error("[REGISTRY API V2] Repository not found: %v", repository)
result, _ := json.Marshal(map[string]string{"message": "Repository not found"})
return http.StatusNotFound, result
}
data := map[string]interface{}{}
tags := []string{}
data["name"] = fmt.Sprintf("%s/%s", namespace, repository)
for _, value := range r.Tags {
t := new(models.Tag)
if err := t.GetByKey(value); err != nil {
log.Error("[REGISTRY API V2] Tag not found: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Tag not found"})
return http.StatusNotFound, result
}
tags = append(tags, t.Name)
}
data["tags"] = tags
result, _ := json.Marshal(data)
return http.StatusOK, 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 docs(ctx *macaron.Context, locale i18n.Locale, name string) {
docRoot := models.GetDocByLocale(name, locale.Lang)
if docRoot == nil {
docRoot = models.GetDocByLocale(name, "en-US")
}
link := strings.TrimPrefix(ctx.Params("*"), "/")
link = strings.TrimSuffix(link, ".html")
link = strings.TrimSuffix(link, ".md")
ctx.Data["Link"] = "/docs/" + link
var doc *models.DocNode
if len(link) == 0 {
ctx.Redirect("/docs/intro/")
return
}
doc, _ = docRoot.GetNodeByLink(link)
if doc == nil {
doc, _ = docRoot.GetNodeByLink(link + "/")
}
if doc == nil {
ctx.Error(404)
return
}
ctx.Data["DocRoot"] = docRoot
ctx.Data["Doc"] = doc
ctx.Data["Title"] = doc.Name
ctx.Data["Data"] = doc.GetContent()
ctx.HTML(200, "document_"+name, ctx.Data)
}
func PutImageLayerv1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
imageId := ctx.Params(":imageId")
basePath := setting.ImagePath
imagePath := fmt.Sprintf("%v/images/%v", basePath, imageId)
layerfile := fmt.Sprintf("%v/images/%v/layer", basePath, imageId)
if !utils.IsDirExist(imagePath) {
os.MkdirAll(imagePath, os.ModePerm)
}
if _, err := os.Stat(layerfile); err == nil {
os.Remove(layerfile)
}
data, _ := ioutil.ReadAll(ctx.Req.Request.Body)
if err := ioutil.WriteFile(layerfile, data, 0777); err != nil {
log.Error("[REGISTRY API V1] Put Image Layer File Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put Image Layer File Error"})
return http.StatusBadRequest, result
}
i := new(models.Image)
if err := i.PutLayer(imageId, layerfile, true, int64(len(data))); err != nil {
log.Error("[REGISTRY API V1] Put Image Layer File Data Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put Image Layer File Data Error"})
return http.StatusBadRequest, result
}
result, _ := json.Marshal(map[string]string{})
return http.StatusOK, result
}
func Static(ctx *macaron.Context) {
if len(ctx.Params(":all")) > 0 {
f, err := os.Open(
path.Join(
"docs",
"gitea",
"images",
ctx.Params(":all")))
defer f.Close()
if err != nil {
ctx.JSON(500, map[string]interface{}{
"error": err.Error(),
})
return
}
if _, err = io.Copy(ctx.RW(), f); err != nil {
ctx.JSON(500, map[string]interface{}{
"error": err.Error(),
})
return
}
return
}
ctx.Error(404)
}
func PutImageChecksumV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
imageId := ctx.Params(":imageId")
checksum := strings.Split(ctx.Req.Header.Get("X-Docker-Checksum"), ":")[1]
payload := strings.Split(ctx.Req.Header.Get("X-Docker-Checksum-Payload"), ":")[1]
log.Debug("[REGISTRY API V1] Image Checksum : %v", checksum)
log.Debug("[REGISTRY API V1] Image Payload: %v", payload)
i := new(models.Image)
if err := i.PutChecksum(imageId, checksum, true, payload); err != nil {
log.Error("[REGISTRY API V1] Put Image Checksum & Payload Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put Image Checksum & Payload Error"})
return http.StatusBadRequest, result
}
if err := i.PutAncestry(imageId); err != nil {
log.Error("[REGISTRY API V1] Put Image Ancestry Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put Image Ancestry Error"})
return http.StatusBadRequest, result
}
result, _ := json.Marshal(map[string]string{})
return http.StatusOK, result
}
func GetImageJSONV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
var jsonInfo string
var payload string
var err error
imageId := ctx.Params(":imageId")
i := new(models.Image)
if jsonInfo, err = i.GetJSON(imageId); err != nil {
log.Error("[REGISTRY API V1] Search Image JSON Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Search Image JSON Error"})
return http.StatusNotFound, result
}
if payload, err = i.GetChecksumPayload(imageId); err != nil {
log.Error("[REGISTRY API V1] Search Image Checksum Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Search Image Checksum Error"})
return http.StatusNotFound, result
}
ctx.Resp.Header().Set("X-Docker-Checksum-Payload", fmt.Sprintf("sha256:%v", payload))
ctx.Resp.Header().Set("X-Docker-Size", fmt.Sprint(i.Size))
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(jsonInfo)))
return http.StatusOK, []byte(jsonInfo)
}
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 GetTagV1Handler(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 tag 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 tag failed,read repository no found"})
return http.StatusNotFound, result
}
tag := map[string]string{}
for _, value := range repo.Tags {
t := new(models.Tag)
if err := db.Get(t, value); err != nil {
log.Error(fmt.Sprintf("[REGISTRY API V1] %s/%s Tags is not exist", namespace, repository))
result, _ := json.Marshal(map[string]string{"message": fmt.Sprintf("%s/%s Tags is not exist", namespace, repository)})
return http.StatusNotFound, result
}
tag[t.Name] = t.ImageId
}
result, _ := json.Marshal(tag)
return http.StatusOK, result
}
func myCacheReadHandler(ctx *macaron.Context, c cache.Cache) interface{} {
val := c.Get(ctx.Params(":key"))
if val != nil {
return val
} else {
return fmt.Sprintf("no cache with \"%s\" set", ctx.Params(":key"))
}
}
func DownloadStats(ctx *macaron.Context, r *http.Request) {
org := ctx.Params(":org")
name := ctx.Params(":name")
branch := ctx.Params(":branch")
_ = branch
repo := org + "/" + name
osarch := ctx.Params(":os") + "-" + ctx.Params(":arch")
rdx.Incr("downloads:" + repo)
rdx.Incr("downloads:" + repo + ":" + osarch)
ctx.JSON(200, "update success")
}
func PutManifestsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
agent := ctx.Req.Header.Get("User-Agent")
repo := new(models.Repository)
if err := repo.Put(namespace, repository, "", agent, setting.APIVERSION_V2); err != nil {
log.Error("[REGISTRY API V2] Save repository failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": err.Error()})
return http.StatusBadRequest, result
}
manifest, _ := ioutil.ReadAll(ctx.Req.Request.Body)
if err := modules.ParseManifest(manifest); err != nil {
log.Error("[REGISTRY API V2] Decode Manifest Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Manifest converted failed"})
return http.StatusBadRequest, result
}
digest, err := utils.DigestManifest(manifest)
if err != nil {
log.Error("[REGISTRY API V2] Get manifest digest failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Get manifest digest failed"})
return http.StatusBadRequest, result
}
random := fmt.Sprintf("%s://%s/v2/%s/%s/manifests/%s",
setting.ListenMode,
setting.Domains,
namespace,
repository,
digest)
ctx.Resp.Header().Set("Docker-Content-Digest", digest)
ctx.Resp.Header().Set("Location", random)
result, _ := json.Marshal(map[string]string{})
return http.StatusAccepted, result
}
func HeadBlobsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
digest := ctx.Params(":digest")
tarsum := strings.Split(digest, ":")[1]
i := new(models.Image)
if has, _ := i.HasTarsum(tarsum); has == false {
log.Info("[REGISTRY API V2] Tarsum not found: %v", tarsum)
result, _ := json.Marshal(map[string]string{"message": "Tarsum not found"})
return http.StatusNotFound, result
}
ctx.Resp.Header().Set("Content-Type", "application/x-gzip")
ctx.Resp.Header().Set("Docker-Content-Digest", digest)
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(i.Size))
result, _ := json.Marshal(map[string]string{})
return http.StatusOK, result
}
func Docs(ctx *macaron.Context, locale i18n.Locale) {
docRoot := models.GetDocByLocale(
"gitea",
locale.Lang)
if docRoot == nil {
ctx.Error(404)
return
}
link := strings.TrimSuffix(
strings.TrimSuffix(
strings.TrimPrefix(
ctx.Params("*"),
"/"),
".html"),
".md")
ctx.Data["Link"] = "/docs/" + link
if len(link) == 0 {
ctx.Redirect("/docs/intro/")
return
}
doc, _ := docRoot.GetNodeByLink(link)
if doc == nil {
doc, _ = docRoot.GetNodeByLink(link + "/")
}
if doc == nil {
ctx.Error(404)
return
}
ctx.Data["DocRoot"] = docRoot
ctx.Data["Doc"] = doc
ctx.Data["Title"] = doc.Name
ctx.Data["Data"] = doc.GetContent()
ctx.HTML(200, "gitea", ctx.Data)
}
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 PostOrder(ctx *macaron.Context, x *xorm.Engine, o Order) {
alipaytype := ctx.Params("alipaytype")
_, err := x.Insert(o)
if err != nil {
glog.V(1).Infof("Insert order %#v fail:%s", o, err.Error())
ctx.JSON(http.StatusBadRequest, map[string]string{"message": err.Error()})
}
//after saved to db,we call alipay and submit to alipay
outhtml, outscript := alipay.Form(o, alipaytype)
ob := map[string]string{"html": outhtml, "script": outscript}
ctx.Resp.Header().Set("Content-Type", "application/json")
js, _ := json.Marshal(ob)
ctx.Resp.WriteHeader(http.StatusOK)
ctx.Resp.Write([]byte(js))
return
}
func GetImageAncestryV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
imageId := ctx.Params(":imageId")
i := new(models.Image)
if has, _, err := i.Has(imageId); err != nil {
log.Error("[REGISTRY API V1] Read Image Ancestry Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read Image Ancestry Error"})
return http.StatusBadRequest, result
} else if has == false {
log.Error("[REGISTRY API V1] Read Image None: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read Image None"})
return http.StatusNotFound, result
}
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(i.Ancestry)))
return http.StatusOK, []byte(i.Ancestry)
}
func PutImageJSONV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
imageId := ctx.Params(":imageId")
info, 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 image JSON failed,request body is empty"})
return http.StatusBadRequest, result
}
i := new(models.Image)
if err := i.PutJSON(imageId, info, setting.APIVERSION_V1); err != nil {
log.Error("[REGISTRY API V1] Put Image JSON Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Put Image JSON Error"})
return http.StatusBadRequest, result
}
result, _ := json.Marshal(map[string]string{})
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 GetImageLayerV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
imageId := ctx.Params(":imageId")
i := new(models.Image)
if has, _, err := i.Has(imageId); err != nil {
log.Error("[REGISTRY API V1] Read Image Layer File Status Error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read Image Layer file Error"})
return http.StatusBadRequest, result
} else if has == false {
log.Error("[REGISTRY API V1] Read Image None Error")
result, _ := json.Marshal(map[string]string{"message": "Read Image None"})
return http.StatusNotFound, result
}
layerfile := i.Path
if _, err := os.Stat(layerfile); err != nil {
log.Error("[REGISTRY API V1] Read Image file state error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read Image file state error"})
return http.StatusBadRequest, result
}
file, err := ioutil.ReadFile(layerfile)
if err != nil {
log.Error("[REGISTRY API V1] Read Image file error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read Image file error"})
return http.StatusBadRequest, result
}
ctx.Resp.Header().Set("Content-Type", "application/octet-stream")
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(file)))
return http.StatusOK, file
}
func GetBlobsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
digest := ctx.Params(":digest")
tarsum := strings.Split(digest, ":")[1]
i := new(models.Image)
has, _ := i.HasTarsum(tarsum)
if has == false {
log.Error("[REGISTRY API V2] Digest not found: %v", tarsum)
result, _ := json.Marshal(map[string]string{"message": "Digest not found"})
return http.StatusNotFound, result
}
layerfile := i.Path
if _, err := os.Stat(layerfile); err != nil {
log.Error("[REGISTRY API V2] File path is invalid: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "File path is invalid"})
return http.StatusBadRequest, result
}
file, err := ioutil.ReadFile(layerfile)
if err != nil {
log.Error("[REGISTRY API V2] Read file failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Read file failed"})
return http.StatusBadRequest, result
}
ctx.Resp.Header().Set("Content-Type", "application/x-gzip")
ctx.Resp.Header().Set("Docker-Content-Digest", digest)
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(file)))
return http.StatusOK, file
}
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, _ := ioutil.ReadAll(ctx.Req.Request.Body)
if err := ioutil.WriteFile(layerfileTmp, data, 0777); err != nil {
log.Error("[REGISTRY API V2] Save layerfile failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Save layerfile failed"})
return http.StatusBadRequest, 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
}
func PutBlobsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
desc := ctx.Params(":uuid")
uuid := strings.Split(desc, "?")[0]
digest := ctx.Query("digest")
tarsum := strings.Split(digest, ":")[1]
imagePathTmp := fmt.Sprintf("%v/%v", setting.ImagePath, uuid)
layerfileTmp := fmt.Sprintf("%v/%v/layer", setting.ImagePath, uuid)
imagePath := fmt.Sprintf("%v/tarsum/%v", setting.ImagePath, tarsum)
layerfile := fmt.Sprintf("%v/tarsum/%v/layer", setting.ImagePath, tarsum)
layerlen, err := modules.CopyImgLayer(imagePathTmp, layerfileTmp, imagePath, layerfile, ctx.Req.Request.Body)
if err != nil {
log.Error("[REGISTRY API V2] Save layerfile failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Save layerfile failed"})
return http.StatusBadRequest, result
}
//saving specific tarsum every times is in order to split the same tarsum in HEAD handler
i := new(models.Image)
i.Path, i.Size = layerfile, int64(layerlen)
if err := i.PutTarsum(tarsum); err != nil {
log.Error("[REGISTRY API V2] Save tarsum failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Save tarsum failed"})
return http.StatusBadRequest, result
}
random := fmt.Sprintf("%s://%s/v2/%s/%s/blobs/%s",
setting.ListenMode,
setting.Domains,
ctx.Params(":namespace"),
ctx.Params(":repository"),
digest)
ctx.Resp.Header().Set("Docker-Content-Digest", digest)
ctx.Resp.Header().Set("Location", random)
result, _ := json.Marshal(map[string]string{})
return http.StatusCreated, result
}
func PutTagV1Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
namespace := ctx.Params(":namespace")
repository := ctx.Params(":repository")
tag := ctx.Params(":tag")
bodystr, _ := ctx.Req.Body().String()
log.Debug("[REGISTRY API V1] Repository Tag : %v", bodystr)
r, _ := regexp.Compile(`"([[:alnum:]]+)"`)
imageIds := r.FindStringSubmatch(bodystr)
repo := new(models.Repository)
if err := repo.PutTag(imageIds[1], namespace, repository, tag); err != nil {
log.Error("[REGISTRY API V1] Put repository tag error: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": err.Error()})
return http.StatusBadRequest, result
}
result, _ := json.Marshal(map[string]string{})
return http.StatusOK, result
}
func GetManifestsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) {
t := new(models.Tag)
if err := t.Get(ctx.Params(":namespace"), ctx.Params(":repository"), ctx.Params(":tag")); err != nil {
log.Error("[REGISTRY API V2] Manifest not found: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Manifest not found"})
return http.StatusNotFound, result
}
digest, err := utils.DigestManifest([]byte(t.Manifest))
if err != nil {
log.Error("[REGISTRY API V2] Get manifest digest failed: %v", err.Error())
result, _ := json.Marshal(map[string]string{"message": "Get manifest digest failed"})
return http.StatusBadRequest, result
}
ctx.Resp.Header().Set("Content-Type", "application/json; charset=utf-8")
ctx.Resp.Header().Set("Docker-Content-Digest", digest)
ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(t.Manifest)))
return http.StatusOK, []byte(t.Manifest)
}
func AssetsHandler(r *http.Request, w http.ResponseWriter, ctx *macaron.Context) {
http.ServeFile(w, r, filepath.Join("public", ctx.Params("*")))
}
func myCacheWriteHandler(ctx *macaron.Context, c cache.Cache) string {
c.Put(ctx.Params(":key"), ctx.Params(":value"), 300)
return "cached for 5 minutes"
}
func mySetCookieHandler(ctx *macaron.Context) string {
// set the cookie for 5 minutes
ctx.SetCookie("user", ctx.Params(":value"), 300)
return "cookie set for 5 minutes"
}
func macaronHandlerWrite(c *macaron.Context) string {
return c.Params("name")
}