func (this *RepoAPIV1Controller) GetRepositoryTags() {
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repo_name")
repo := new(models.Repository)
if has, _, err := repo.Has(namespace, repository); err != nil {
this.JSONOut(http.StatusBadRequest, "Read repository json error", nil)
return
} else if has == false {
this.JSONOut(http.StatusBadRequest, "Read repository no found", nil)
return
}
tag := map[string]string{}
for _, value := range repo.Tags {
t := new(models.Tag)
if err := t.GetById(value); err != nil {
this.JSONOut(http.StatusBadRequest, "", map[string]string{"message": fmt.Sprintf("%s/%s Tags is not exist", namespace, repository)})
return
}
tag[t.Name] = t.ImageId
}
this.JSONOut(http.StatusOK, "", tag)
return
}
func (this *RepoAPIV1Controller) PutRepository() {
username, _, _ := utils.DecodeBasicAuth(this.Ctx.Input.Header("Authorization"))
namespace := string(this.Ctx.Input.Param(":namespace"))
repository := string(this.Ctx.Input.Param(":repo_name"))
repo := new(models.Repository)
if err := repo.Put(namespace, repository, string(this.Ctx.Input.CopyBody()), this.Ctx.Input.Header("User-Agent"), models.APIVERSION_V1); err != nil {
this.JSONOut(http.StatusForbidden, err.Error(), nil)
return
}
if this.Ctx.Input.Header("X-Docker-Token") == "true" {
token := string(utils.GeneralKey(username))
this.SetSession("token", token)
this.Ctx.Output.Context.ResponseWriter.Header().Set("X-Docker-Token", token)
this.Ctx.Output.Context.ResponseWriter.Header().Set("WWW-Authenticate", token)
}
user := new(models.User)
if _, _, err := user.Has(username); err != nil {
this.JSONOut(http.StatusForbidden, err.Error(), nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
user.Log(models.ACTION_UPDATE_REPO, models.LEVELINFORMATIONAL, models.TYPE_APIV1, repo.Id, memo)
repo.Log(models.ACTION_UPDATE_REPO, models.LEVELINFORMATIONAL, models.TYPE_APIV1, repo.Id, memo)
this.Ctx.Output.Context.ResponseWriter.Header().Set("X-Docker-Endpoints", beego.AppConfig.String("docker::Endpoints"))
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func (this *ManifestsAPIV2Controller) GetTags() {
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repo_name")
repo := new(models.Repository)
if has, _, err := repo.Has(namespace, repository); err != nil || has == false {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeNameInvalid]}})
return
}
data := map[string]interface{}{}
tags := []string{}
data["name"] = fmt.Sprintf("%s/%s", namespace, repository)
for _, value := range repo.Tags {
t := new(models.Tag)
if err := t.GetById(value); err != nil {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeTagInvalid]}})
return
}
tags = append(tags, t.Name)
}
data["tags"] = tags
this.JSONOut(http.StatusOK, "", data)
return
}
func (this *OrganizationWebV1Controller) GetPrivateRepos() {
org := new(models.Organization)
repos := make([]models.Repository, 0)
if exist, _, err := org.Has(this.Ctx.Input.Param(":org")); err != nil {
this.JSONOut(http.StatusBadRequest, err.Error(), nil)
return
} else if exist == false {
this.JSONOut(http.StatusBadRequest, "Organization not exist", nil)
return
}
for _, v := range org.Repositories {
repo := new(models.Repository)
if err := repo.Get(v); err != nil {
this.JSONOut(http.StatusBadRequest, "Repository invalid", nil)
return
}
if repo.Privated == true {
repos = append(repos, *repo)
}
}
this.JSONOut(http.StatusOK, "", repos)
return
}
func (this *WebController) GetRepository() {
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repository")
repo := new(models.Repository)
if exist, _, _ := repo.Has(namespace, repository); exist {
user, exist := this.Ctx.Input.CruSession.Get("user").(models.User)
if repo.Privated {
if !exist == true {
this.Abort("404")
return
} else {
if user.Username != namespace {
this.Abort("404")
return
}
this.Data["username"] = user.Username
this.Data["privated"] = repo.Privated
this.Data["namespace"] = repo.Namespace
this.Data["repository"] = repo.Repository
this.Data["created"] = repo.Created
this.Data["short"] = repo.Short
this.Data["description"] = string(github_flavored_markdown.Markdown([]byte(repo.Description)))
this.Data["download"] = repo.Download
this.Data["comments"] = len(repo.Comments)
this.Data["starts"] = len(repo.Starts)
this.TplNames = "repository.html"
this.Render()
return
}
} else {
this.Data["username"] = user.Username
this.Data["privated"] = repo.Privated
this.Data["namespace"] = repo.Namespace
this.Data["repository"] = repo.Repository
this.Data["created"] = repo.Created
this.Data["short"] = repo.Short
this.Data["description"] = string(github_flavored_markdown.Markdown([]byte(repo.Description)))
this.Data["download"] = repo.Download
this.Data["comments"] = len(repo.Comments)
this.Data["starts"] = len(repo.Starts)
this.TplNames = "repository.html"
this.Render()
return
}
} else {
this.Abort("404")
return
}
return
}
func (this *RepoAPIV1Controller) GetRepositoryImages() {
namespace := string(this.Ctx.Input.Param(":namespace"))
repository := string(this.Ctx.Input.Param(":repo_name"))
repo := new(models.Repository)
if has, _, err := repo.Has(namespace, repository); err != nil {
this.JSONOut(http.StatusBadRequest, "Read repository json error", nil)
return
} else if has == false {
this.JSONOut(http.StatusBadRequest, "Read repository no found", nil)
return
}
repo.Download += 1
if err := repo.Save(); err != nil {
this.JSONOut(http.StatusBadRequest, err.Error(), nil)
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
repo.Log(models.ACTION_GET_REPO, models.LEVELINFORMATIONAL, models.TYPE_APIV1, repo.Id, memo)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(repo.JSON))
return
}
func (this *RepoAPIV1Controller) PutRepositoryImages() {
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repo_name")
repo := new(models.Repository)
if err := repo.PutImages(namespace, repository); err != nil {
this.JSONOut(http.StatusBadRequest, "Update Uploaded flag error", nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
repo.Log(models.ACTION_PUT_REPO_IMAGES, models.LEVELINFORMATIONAL, models.TYPE_APIV1, repo.Id, memo)
org := new(models.Organization)
isOrg, _, err := org.Has(namespace)
if err != nil {
this.JSONOut(http.StatusBadRequest, "Search Organization Error", nil)
return
}
user := new(models.User)
authUsername, _, _ := utils.DecodeBasicAuth(this.Ctx.Input.Header("Authorization"))
isUser, _, err := user.Has(authUsername)
if err != nil {
this.JSONOut(http.StatusBadRequest, err.Error(), nil)
return
}
if !isUser && !isOrg {
this.JSONOut(http.StatusBadRequest, "Search Namespace Error", nil)
return
}
if isUser {
user.Repositories = append(user.Repositories, repo.Id)
user.Save()
}
if isOrg {
org.Repositories = append(org.Repositories, repo.Id)
org.Save()
}
this.Ctx.Output.Context.Output.SetStatus(http.StatusNoContent)
this.Ctx.Output.Context.Output.Body([]byte(""))
this.ServeJson()
return
}
func checkRepositoriesPrivate(namespace, repository string) bool {
repo := new(models.Repository)
if has, _, err := repo.Has(namespace, repository); err != nil || has == false {
return false
} else if has == true {
if repo.Privated == true {
return false
} else {
return true
}
}
return false
}
func checkOrgRepositoryPermission(user *models.User, namespace, repository string, permission int) bool {
owner := false
//Check Org exists
org := new(models.Organization)
if has, _, _ := org.Has(namespace); has == false {
return false
}
//Check Owner, don't care Join team
for _, k := range user.Organizations {
if org.Id == k {
owner = true
}
}
//Check Repository
repo := new(models.Repository)
if has, _, _ := repo.Has(namespace, repository); has == false {
if owner == true {
return true
} else {
return false
}
}
if repo.Privated == false && permission == PERMISSION_READ {
return true
}
//Loop Team
for _, k := range user.JoinTeams {
team := new(models.Team)
if err := team.GetById(k); err != nil {
return false
}
//TODO Check Team Perimssion
}
return false
}
func (this *ManifestsAPIV2Controller) PutManifests() {
manifest, _ := ioutil.ReadAll(this.Ctx.Request.Body)
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repo_name")
repo := new(models.Repository)
if err := repo.Put(namespace, repository, "", this.Ctx.Input.Header("User-Agent"), models.APIVERSION_V2); err != nil {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeManifestInvalid]}})
return
}
manifestsConvertV1(manifest)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func (this *RepoAPIV1Controller) PutTag() {
namespace := this.Ctx.Input.Param(":namespace")
repository := this.Ctx.Input.Param(":repo_name")
tag := this.Ctx.Input.Param(":tag")
r, _ := regexp.Compile(`"([[:alnum:]]+)"`)
imageIds := r.FindStringSubmatch(string(this.Ctx.Input.CopyBody()))
repo := new(models.Repository)
if err := repo.PutTag(imageIds[1], namespace, repository, tag); err != nil {
this.JSONOut(http.StatusBadRequest, err.Error(), nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
repo.Log(models.ACTION_PUT_TAG, models.LEVELINFORMATIONAL, models.TYPE_APIV1, repo.Id, memo)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func manifestsConvertV1(data []byte) error {
var manifest map[string]interface{}
if err := json.Unmarshal(data, &manifest); err != nil {
return err
}
tag := manifest["tag"]
namespace, repository := strings.Split(manifest["name"].(string), "/")[0], strings.Split(manifest["name"].(string), "/")[1]
for k := len(manifest["history"].([]interface{})) - 1; k >= 0; k-- {
v := manifest["history"].([]interface{})[k]
compatibility := v.(map[string]interface{})["v1Compatibility"].(string)
var image map[string]interface{}
if err := json.Unmarshal([]byte(compatibility), &image); err != nil {
return err
}
i := map[string]string{}
r := new(models.Repository)
if k == 0 {
i["Tag"] = tag.(string)
}
i["id"] = image["id"].(string)
//Put V1 JSON
if err := r.PutJSONFromManifests(i, namespace, repository); err != nil {
return err
}
if k == 0 {
//Put V1 Tag
if err := r.PutTagFromManifests(image["id"].(string), namespace, repository, tag.(string), string(data)); err != nil {
return err
}
}
img := new(models.Image)
tarsum := manifest["fsLayers"].([]interface{})[k].(map[string]interface{})["blobSum"].(string)
sha256 := strings.Split(tarsum, ":")[1]
//Put Image Json
if err := img.PutJSON(image["id"].(string), v.(map[string]interface{})["v1Compatibility"].(string), models.APIVERSION_V2); err != nil {
return err
}
//Put Image Layer
basePath := beego.AppConfig.String("docker::BasePath")
layerfile := fmt.Sprintf("%v/uuid/%v/layer", basePath, sha256)
if err := img.PutLayer(image["id"].(string), layerfile, true, int64(image["Size"].(float64))); err != nil {
return err
}
//Put Checksum
if err := img.PutChecksum(image["id"].(string), sha256, true, ""); err != nil {
return err
}
//Put Ancestry
if err := img.PutAncestry(image["id"].(string)); err != nil {
return err
}
}
return nil
}