func (this *ImageAPIV1Controller) GetImageLayer() {
imageId := string(this.Ctx.Input.Param(":image_id"))
image := new(models.Image)
if has, _, err := image.Has(imageId); err != nil {
this.JSONOut(http.StatusBadRequest, "Read Image Layer file Error", nil)
return
} else if has == false {
this.JSONOut(http.StatusBadRequest, "Read Image None", nil)
return
}
layerfile := image.Path
if _, err := os.Stat(layerfile); err != nil {
this.JSONOut(http.StatusBadRequest, "Read Image file state error", nil)
return
}
file, err := ioutil.ReadFile(layerfile)
if err != nil {
this.JSONOut(http.StatusBadRequest, "Read Image file error", nil)
return
}
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Type", "application/octet-stream")
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Transfer-Encoding", "binary")
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Length", string(int64(len(file))))
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body(file)
return
}
func (this *BlobAPIV2Controller) GetBlobs() {
image := new(models.Image)
digest := strings.Split(this.Ctx.Input.Param(":digest"), ":")[1]
if has, _, _ := image.HasTarsum(digest); has == false {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeUnauthorized]}})
return
}
layerfile := image.Path
if _, err := os.Stat(layerfile); err != nil {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeBlobUnknown]}})
return
}
file, err := ioutil.ReadFile(layerfile)
if err != nil {
this.JSONOut(http.StatusBadRequest, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeBlobUnknown]}})
return
}
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Type", "application/octet-stream")
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Transfer-Encoding", "binary")
this.Ctx.Output.Context.ResponseWriter.Header().Set("Content-Length", string(int64(len(file))))
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body(file)
return
}
func (this *BlobAPIV2Controller) HeadDigest() {
image := new(models.Image)
digest := strings.Split(this.Ctx.Input.Param(":digest"), ":")[1]
if has, _, _ := image.HasTarsum(digest); has == false {
this.JSONOut(http.StatusNotFound, "", map[string][]modules.ErrorDescriptor{"errors": []modules.ErrorDescriptor{modules.ErrorDescriptors[modules.APIErrorCodeUnauthorized]}})
return
}
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.ServeJson()
return
}
func (this *ImageAPIV1Controller) GetImageAncestry() {
imageId := string(this.Ctx.Input.Param(":image_id"))
image := new(models.Image)
if has, _, err := image.Has(imageId); err != nil {
this.JSONOut(http.StatusBadRequest, "Read Image Ancestry Error", nil)
return
} else if has == false {
this.JSONOut(http.StatusBadRequest, "Read Image None", nil)
return
}
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(image.Ancestry))
return
}
func (this *ImageAPIV1Controller) PutChecksum() {
imageId := string(this.Ctx.Input.Param(":image_id"))
image := new(models.Image)
checksum := strings.Split(this.Ctx.Input.Header("X-Docker-Checksum"), ":")[1]
payload := strings.Split(this.Ctx.Input.Header("X-Docker-Checksum-Payload"), ":")[1]
if err := image.PutChecksum(imageId, checksum, true, payload); err != nil {
this.JSONOut(http.StatusBadRequest, "Put Image Checksum & Payload Error", nil)
return
}
if err := image.PutAncestry(imageId); err != nil {
this.JSONOut(http.StatusBadRequest, "Put Image Ancestry Error", nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
image.Log(models.ACTION_PUT_IMAGES_CHECKSUM, models.LEVELINFORMATIONAL, models.TYPE_APIV1, image.Id, memo)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func (this *ImageAPIV1Controller) PutImageJSON() {
imageId := this.Ctx.Input.Param(":image_id")
image := new(models.Image)
j := string(this.Ctx.Input.CopyBody())
if err := image.PutJSON(imageId, j, models.APIVERSION_V1); err != nil {
this.JSONOut(http.StatusBadRequest, "Put Image JSON Error", nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
image.Log(models.ACTION_PUT_IMAGES_JSON, models.LEVELINFORMATIONAL, models.TYPE_APIV1, image.Id, memo)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func (this *ImageAPIV1Controller) PutImageLayer() {
imageId := string(this.Ctx.Input.Param(":image_id"))
image := new(models.Image)
basePath := beego.AppConfig.String("docker::BasePath")
imagePath := fmt.Sprintf("%v/images/%v", basePath, imageId)
layerfile := fmt.Sprintf("%v/images/%v/layer", basePath, imageId)
if !utils.IsDirExists(imagePath) {
os.MkdirAll(imagePath, os.ModePerm)
}
if _, err := os.Stat(layerfile); err == nil {
os.Remove(layerfile)
}
data, _ := ioutil.ReadAll(this.Ctx.Request.Body)
if err := ioutil.WriteFile(layerfile, data, 0777); err != nil {
this.JSONOut(http.StatusBadRequest, "Put Image Layer File Error", nil)
return
}
if err := image.PutLayer(imageId, layerfile, true, int64(len(data))); err != nil {
this.JSONOut(http.StatusBadRequest, "Put Image Layer File Data Error", nil)
return
}
memo, _ := json.Marshal(this.Ctx.Input.Header)
image.Log(models.ACTION_PUT_IMAGES_LAYER, models.LEVELINFORMATIONAL, models.TYPE_APIV1, image.Id, memo)
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body([]byte(""))
return
}
func (this *ImageAPIV1Controller) GetImageJSON() {
imageId := string(this.Ctx.Input.Param(":image_id"))
image := new(models.Image)
var json []byte
var checksum []byte
var err error
if json, err = image.GetJSON(imageId); err != nil {
this.JSONOut(http.StatusBadRequest, "Search Image JSON Error", nil)
return
}
if checksum, err = image.GetChecksum(imageId); err != nil {
this.JSONOut(http.StatusBadRequest, "Search Image Checksum Error", nil)
return
} else {
this.Ctx.Output.Context.ResponseWriter.Header().Set("X-Docker-Checksum", string(checksum))
}
this.Ctx.Output.Context.Output.SetStatus(http.StatusOK)
this.Ctx.Output.Context.Output.Body(json)
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
}
