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") }