2013-03-21 17:10:14 +00:00
|
|
|
package docker
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2013-03-22 08:25:27 +00:00
|
|
|
"github.com/dotcloud/docker/auth"
|
2013-03-21 17:10:14 +00:00
|
|
|
"io"
|
|
|
|
"io/ioutil"
|
|
|
|
"net/http"
|
|
|
|
"path"
|
|
|
|
"strings"
|
|
|
|
)
|
|
|
|
|
|
|
|
//FIXME: Set the endpoint in a conf file or via commandline
|
|
|
|
//const REGISTRY_ENDPOINT = "http://registry-creack.dotcloud.com/v1"
|
2013-03-22 08:25:27 +00:00
|
|
|
const REGISTRY_ENDPOINT = auth.REGISTRY_SERVER + "/v1"
|
2013-03-21 17:10:14 +00:00
|
|
|
|
|
|
|
// Build an Image object from raw json data
|
|
|
|
func NewImgJson(src []byte) (*Image, error) {
|
|
|
|
ret := &Image{}
|
|
|
|
|
2013-03-22 20:21:44 +00:00
|
|
|
Debugf("Json string: {%s}\n", src)
|
2013-03-21 17:10:14 +00:00
|
|
|
// FIXME: Is there a cleaner way to "puryfy" the input json?
|
|
|
|
if err := json.Unmarshal(src, ret); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return ret, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build an Image object list from a raw json data
|
|
|
|
// FIXME: Do this in "stream" mode
|
|
|
|
func NewMultipleImgJson(src []byte) ([]*Image, error) {
|
|
|
|
ret := []*Image{}
|
|
|
|
|
2013-03-23 21:54:18 +00:00
|
|
|
dec := json.NewDecoder(strings.NewReader(string(src)))
|
2013-03-21 17:10:14 +00:00
|
|
|
for {
|
|
|
|
m := &Image{}
|
|
|
|
if err := dec.Decode(m); err == io.EOF {
|
|
|
|
break
|
|
|
|
} else if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
ret = append(ret, m)
|
|
|
|
}
|
|
|
|
return ret, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Retrieve the history of a given image from the Registry.
|
|
|
|
// Return a list of the parent's json (requested image included)
|
2013-03-22 09:57:28 +00:00
|
|
|
func (graph *Graph) getRemoteHistory(imgId string, authConfig *auth.AuthConfig) ([]*Image, error) {
|
|
|
|
client := &http.Client{}
|
|
|
|
|
|
|
|
req, err := http.NewRequest("GET", REGISTRY_ENDPOINT+"/images/"+imgId+"/history", nil)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
|
|
|
res, err := client.Do(req)
|
2013-03-22 11:44:07 +00:00
|
|
|
if err != nil || res.StatusCode != 200 {
|
|
|
|
if res != nil {
|
|
|
|
return nil, fmt.Errorf("Internal server error: %d trying to fetch remote history for %s", res.StatusCode, imgId)
|
|
|
|
}
|
2013-03-22 09:57:28 +00:00
|
|
|
return nil, err
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
|
|
|
|
|
|
jsonString, err := ioutil.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Error while reading the http response: %s\n", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
history, err := NewMultipleImgJson(jsonString)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Error while parsing the json: %s\n", err)
|
|
|
|
}
|
|
|
|
return history, nil
|
|
|
|
}
|
|
|
|
|
2013-03-22 08:25:27 +00:00
|
|
|
// Check if an image exists in the Registry
|
2013-03-22 09:57:28 +00:00
|
|
|
func (graph *Graph) LookupRemoteImage(imgId string, authConfig *auth.AuthConfig) bool {
|
2013-03-22 17:22:22 +00:00
|
|
|
rt := &http.Transport{Proxy: http.ProxyFromEnvironment}
|
2013-03-22 09:57:28 +00:00
|
|
|
|
|
|
|
req, err := http.NewRequest("GET", REGISTRY_ENDPOINT+"/images/"+imgId+"/json", nil)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-22 17:22:22 +00:00
|
|
|
res, err := rt.RoundTrip(req)
|
2013-03-22 11:44:07 +00:00
|
|
|
if err != nil || res.StatusCode != 307 {
|
2013-03-22 08:25:27 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
return res.StatusCode == 307
|
|
|
|
}
|
|
|
|
|
2013-03-21 17:10:14 +00:00
|
|
|
// Retrieve an image from the Registry.
|
|
|
|
// Returns the Image object as well as the layer as an Archive (io.Reader)
|
2013-03-26 01:48:57 +00:00
|
|
|
func (graph *Graph) getRemoteImage(stdout io.Writer, imgId string, authConfig *auth.AuthConfig) (*Image, Archive, error) {
|
2013-03-22 09:57:28 +00:00
|
|
|
client := &http.Client{}
|
|
|
|
|
2013-03-26 01:48:57 +00:00
|
|
|
fmt.Fprintf(stdout, "Pulling %s metadata\n", imgId)
|
2013-03-21 17:10:14 +00:00
|
|
|
// Get the Json
|
2013-03-22 09:57:28 +00:00
|
|
|
req, err := http.NewRequest("GET", REGISTRY_ENDPOINT+"/images/"+imgId+"/json", nil)
|
2013-03-21 17:10:14 +00:00
|
|
|
if err != nil {
|
2013-03-26 01:48:57 +00:00
|
|
|
return nil, nil, fmt.Errorf("Failed to download json: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
2013-03-22 09:57:28 +00:00
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
|
|
|
res, err := client.Do(req)
|
2013-03-26 01:48:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, fmt.Errorf("Failed to download json: %s", err)
|
|
|
|
}
|
|
|
|
if res.StatusCode != 200 {
|
|
|
|
return nil, nil, fmt.Errorf("HTTP code %d", res.StatusCode)
|
2013-03-22 09:57:28 +00:00
|
|
|
}
|
2013-03-21 17:10:14 +00:00
|
|
|
defer res.Body.Close()
|
|
|
|
|
|
|
|
jsonString, err := ioutil.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
2013-03-26 01:48:57 +00:00
|
|
|
return nil, nil, fmt.Errorf("Failed to download json: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
img, err := NewImgJson(jsonString)
|
|
|
|
if err != nil {
|
2013-03-26 01:48:57 +00:00
|
|
|
return nil, nil, fmt.Errorf("Failed to parse json: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
img.Id = imgId
|
|
|
|
|
|
|
|
// Get the layer
|
2013-03-26 01:48:57 +00:00
|
|
|
fmt.Fprintf(stdout, "Pulling %s fs layer\n", imgId)
|
2013-03-22 14:56:44 +00:00
|
|
|
req, err = http.NewRequest("GET", REGISTRY_ENDPOINT+"/images/"+imgId+"/layer", nil)
|
2013-03-21 17:10:14 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, fmt.Errorf("Error while getting from the server: %s\n", err)
|
|
|
|
}
|
2013-03-22 14:56:44 +00:00
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
|
|
|
res, err = client.Do(req)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
2013-03-31 20:04:41 +00:00
|
|
|
return img, ProgressReader(res.Body, int(res.ContentLength), stdout), nil
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
|
2013-03-26 01:48:57 +00:00
|
|
|
func (graph *Graph) PullImage(stdout io.Writer, imgId string, authConfig *auth.AuthConfig) error {
|
2013-03-22 09:57:28 +00:00
|
|
|
history, err := graph.getRemoteHistory(imgId, authConfig)
|
2013-03-21 17:10:14 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// FIXME: Try to stream the images?
|
|
|
|
// FIXME: Lunch the getRemoteImage() in goroutines
|
|
|
|
for _, j := range history {
|
|
|
|
if !graph.Exists(j.Id) {
|
2013-03-26 01:48:57 +00:00
|
|
|
img, layer, err := graph.getRemoteImage(stdout, j.Id, authConfig)
|
2013-03-21 17:10:14 +00:00
|
|
|
if err != nil {
|
|
|
|
// FIXME: Keep goging in case of error?
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err = graph.Register(layer, img); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-03-22 08:25:27 +00:00
|
|
|
// FIXME: Handle the askedTag parameter
|
2013-03-22 20:21:44 +00:00
|
|
|
func (graph *Graph) PullRepository(stdout io.Writer, remote, askedTag string, repositories *TagStore, authConfig *auth.AuthConfig) error {
|
2013-03-22 08:25:27 +00:00
|
|
|
client := &http.Client{}
|
|
|
|
|
2013-03-26 01:48:57 +00:00
|
|
|
fmt.Fprintf(stdout, "Pulling repository %s\n", remote)
|
2013-03-22 14:56:44 +00:00
|
|
|
|
2013-03-23 00:41:48 +00:00
|
|
|
var repositoryTarget string
|
|
|
|
// If we are asking for 'root' repository, lookup on the Library's registry
|
|
|
|
if strings.Index(remote, "/") == -1 {
|
|
|
|
repositoryTarget = REGISTRY_ENDPOINT + "/library/" + remote
|
|
|
|
} else {
|
|
|
|
repositoryTarget = REGISTRY_ENDPOINT + "/users/" + remote
|
|
|
|
}
|
|
|
|
|
|
|
|
req, err := http.NewRequest("GET", repositoryTarget, nil)
|
2013-03-22 08:25:27 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-03-22 09:19:39 +00:00
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-22 08:25:27 +00:00
|
|
|
res, err := client.Do(req)
|
2013-03-26 01:48:57 +00:00
|
|
|
if err != nil {
|
2013-03-22 08:25:27 +00:00
|
|
|
return err
|
|
|
|
}
|
2013-03-26 01:48:57 +00:00
|
|
|
if res.StatusCode != 200 {
|
|
|
|
return fmt.Errorf("HTTP code: %d", res.StatusCode)
|
|
|
|
}
|
2013-03-22 09:57:28 +00:00
|
|
|
defer res.Body.Close()
|
2013-03-22 08:25:27 +00:00
|
|
|
rawJson, err := ioutil.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
t := map[string]string{}
|
|
|
|
if err = json.Unmarshal(rawJson, &t); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for tag, rev := range t {
|
2013-03-26 01:48:57 +00:00
|
|
|
fmt.Fprintf(stdout, "Pulling tag %s:%s\n", remote, tag)
|
|
|
|
if err = graph.PullImage(stdout, rev, authConfig); err != nil {
|
2013-03-22 08:25:27 +00:00
|
|
|
return err
|
|
|
|
}
|
2013-03-22 14:56:44 +00:00
|
|
|
if err = repositories.Set(remote, tag, rev, true); err != nil {
|
2013-03-22 08:25:27 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if err = repositories.Save(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-03-21 17:10:14 +00:00
|
|
|
// Push a local image to the registry with its history if needed
|
2013-03-22 20:21:44 +00:00
|
|
|
func (graph *Graph) PushImage(stdout io.Writer, imgOrig *Image, authConfig *auth.AuthConfig) error {
|
2013-03-21 17:10:14 +00:00
|
|
|
client := &http.Client{}
|
|
|
|
|
|
|
|
// FIXME: Factorize the code
|
|
|
|
// FIXME: Do the puts in goroutines
|
|
|
|
if err := imgOrig.WalkHistory(func(img *Image) error {
|
|
|
|
|
|
|
|
jsonRaw, err := ioutil.ReadFile(path.Join(graph.Root, img.Id, "json"))
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error while retreiving the path for {%s}: %s", img.Id, err)
|
|
|
|
}
|
2013-03-22 18:44:12 +00:00
|
|
|
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Pushing %s metadata\n", img.Id)
|
2013-03-22 18:44:12 +00:00
|
|
|
|
2013-03-22 08:25:27 +00:00
|
|
|
// FIXME: try json with UTF8
|
2013-03-21 17:10:14 +00:00
|
|
|
jsonData := strings.NewReader(string(jsonRaw))
|
|
|
|
req, err := http.NewRequest("PUT", REGISTRY_ENDPOINT+"/images/"+img.Id+"/json", jsonData)
|
2013-03-22 08:25:27 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-03-22 10:22:36 +00:00
|
|
|
req.Header.Add("Content-type", "application/json")
|
2013-03-22 09:57:28 +00:00
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-21 17:10:14 +00:00
|
|
|
res, err := client.Do(req)
|
2013-03-26 00:20:55 +00:00
|
|
|
if err != nil {
|
2013-03-26 01:48:57 +00:00
|
|
|
return fmt.Errorf("Failed to upload metadata: %s", err)
|
2013-03-26 00:20:55 +00:00
|
|
|
}
|
|
|
|
if res.StatusCode != 200 {
|
2013-03-21 17:10:14 +00:00
|
|
|
switch res.StatusCode {
|
|
|
|
case 204:
|
|
|
|
// Case where the image is already on the Registry
|
|
|
|
// FIXME: Do not be silent?
|
|
|
|
return nil
|
|
|
|
default:
|
2013-03-26 01:50:02 +00:00
|
|
|
errBody, err := ioutil.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
|
|
|
errBody = []byte(err.Error())
|
|
|
|
}
|
|
|
|
return fmt.Errorf("HTTP code %d while uploading metadata: %s", res.StatusCode, errBody)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Pushing %s fs layer\n", img.Id)
|
2013-03-21 17:10:14 +00:00
|
|
|
req2, err := http.NewRequest("PUT", REGISTRY_ENDPOINT+"/images/"+img.Id+"/layer", nil)
|
2013-03-22 09:57:28 +00:00
|
|
|
req2.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-21 17:10:14 +00:00
|
|
|
res2, err := client.Do(req2)
|
|
|
|
if err != nil || res2.StatusCode != 307 {
|
2013-03-26 00:20:26 +00:00
|
|
|
return fmt.Errorf("Registry returned error: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
url, err := res2.Location()
|
|
|
|
if err != nil || url == nil {
|
2013-03-26 00:20:26 +00:00
|
|
|
return fmt.Errorf("Failed to retrieve layer upload location: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
2013-03-22 18:44:12 +00:00
|
|
|
|
2013-03-21 17:10:14 +00:00
|
|
|
// FIXME: Don't do this :D. Check the S3 requierement and implement chunks of 5MB
|
|
|
|
// FIXME2: I won't stress it enough, DON'T DO THIS! very high priority
|
|
|
|
layerData2, err := Tar(path.Join(graph.Root, img.Id, "layer"), Gzip)
|
|
|
|
layerData, err := Tar(path.Join(graph.Root, img.Id, "layer"), Gzip)
|
|
|
|
if err != nil {
|
2013-03-26 00:20:26 +00:00
|
|
|
return fmt.Errorf("Failed to generate layer archive: %s", err)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
req3, err := http.NewRequest("PUT", url.String(), layerData)
|
2013-03-22 09:57:28 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
tmp, err := ioutil.ReadAll(layerData2)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-03-21 17:10:14 +00:00
|
|
|
req3.ContentLength = int64(len(tmp))
|
|
|
|
|
|
|
|
req3.TransferEncoding = []string{"none"}
|
|
|
|
res3, err := client.Do(req3)
|
2013-03-26 00:20:55 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Failed to upload layer: %s", err)
|
|
|
|
}
|
|
|
|
if res3.StatusCode != 200 {
|
|
|
|
return fmt.Errorf("Received HTTP code %d while uploading layer", res3.StatusCode)
|
2013-03-21 17:10:14 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2013-03-22 08:25:27 +00:00
|
|
|
|
2013-03-22 13:38:54 +00:00
|
|
|
// push a tag on the registry.
|
|
|
|
// Remote has the format '<user>/<repo>
|
|
|
|
func (graph *Graph) pushTag(remote, revision, tag string, authConfig *auth.AuthConfig) error {
|
2013-03-22 08:25:27 +00:00
|
|
|
|
2013-03-22 13:38:54 +00:00
|
|
|
// Keep this for backward compatibility
|
2013-03-22 08:25:27 +00:00
|
|
|
if tag == "" {
|
|
|
|
tag = "lastest"
|
|
|
|
}
|
|
|
|
|
2013-03-22 13:38:54 +00:00
|
|
|
// "jsonify" the string
|
2013-03-22 08:25:27 +00:00
|
|
|
revision = "\"" + revision + "\""
|
|
|
|
|
2013-03-22 18:44:12 +00:00
|
|
|
Debugf("Pushing tags for rev [%s] on {%s}\n", revision, REGISTRY_ENDPOINT+"/users/"+remote+"/"+tag)
|
|
|
|
|
2013-03-22 08:25:27 +00:00
|
|
|
client := &http.Client{}
|
2013-03-22 13:38:54 +00:00
|
|
|
req, err := http.NewRequest("PUT", REGISTRY_ENDPOINT+"/users/"+remote+"/"+tag, strings.NewReader(revision))
|
2013-03-22 08:25:27 +00:00
|
|
|
req.Header.Add("Content-type", "application/json")
|
2013-03-22 09:57:28 +00:00
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-22 08:25:27 +00:00
|
|
|
res, err := client.Do(req)
|
2013-03-22 11:44:07 +00:00
|
|
|
if err != nil || (res.StatusCode != 200 && res.StatusCode != 201) {
|
|
|
|
if res != nil {
|
2013-03-22 13:38:54 +00:00
|
|
|
return fmt.Errorf("Internal server error: %d trying to push tag %s on %s", res.StatusCode, tag, remote)
|
2013-03-22 11:44:07 +00:00
|
|
|
}
|
2013-03-22 08:25:27 +00:00
|
|
|
return err
|
|
|
|
}
|
2013-03-22 20:21:44 +00:00
|
|
|
Debugf("Result of push tag: %d\n", res.StatusCode)
|
2013-03-22 08:25:27 +00:00
|
|
|
switch res.StatusCode {
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("Error %d\n", res.StatusCode)
|
|
|
|
case 200:
|
|
|
|
case 201:
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-03-22 17:42:13 +00:00
|
|
|
func (graph *Graph) LookupRemoteRepository(remote string, authConfig *auth.AuthConfig) bool {
|
|
|
|
rt := &http.Transport{Proxy: http.ProxyFromEnvironment}
|
|
|
|
|
2013-03-26 11:11:13 +00:00
|
|
|
var repositoryTarget string
|
|
|
|
// If we are asking for 'root' repository, lookup on the Library's registry
|
|
|
|
if strings.Index(remote, "/") == -1 {
|
|
|
|
repositoryTarget = REGISTRY_ENDPOINT + "/library/" + remote + "/lookup"
|
|
|
|
} else {
|
|
|
|
repositoryTarget = REGISTRY_ENDPOINT + "/users/" + remote + "/lookup"
|
|
|
|
}
|
|
|
|
Debugf("Checking for permissions on: %s", repositoryTarget)
|
|
|
|
req, err := http.NewRequest("PUT", repositoryTarget, strings.NewReader("\"\""))
|
2013-03-22 17:42:13 +00:00
|
|
|
if err != nil {
|
2013-03-26 11:11:13 +00:00
|
|
|
Debugf("%s\n", err)
|
2013-03-22 17:42:13 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
req.SetBasicAuth(authConfig.Username, authConfig.Password)
|
2013-03-26 11:11:13 +00:00
|
|
|
req.Header.Add("Content-type", "application/json")
|
2013-03-22 17:42:13 +00:00
|
|
|
res, err := rt.RoundTrip(req)
|
2013-03-26 11:11:13 +00:00
|
|
|
if err != nil || res.StatusCode != 404 {
|
|
|
|
errBody, err := ioutil.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
|
|
|
errBody = []byte(err.Error())
|
|
|
|
}
|
|
|
|
Debugf("Lookup status code: %d (body: %s)", res.StatusCode, errBody)
|
2013-03-22 17:42:13 +00:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2013-03-26 00:20:26 +00:00
|
|
|
// FIXME: this should really be PushTag
|
2013-03-22 20:21:44 +00:00
|
|
|
func (graph *Graph) pushPrimitive(stdout io.Writer, remote, tag, imgId string, authConfig *auth.AuthConfig) error {
|
2013-03-25 22:29:00 +00:00
|
|
|
// Check if the local impage exists
|
2013-03-22 17:42:13 +00:00
|
|
|
img, err := graph.Get(imgId)
|
|
|
|
if err != nil {
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Skipping tag %s:%s: %s does not exist\n", remote, tag, imgId)
|
2013-03-25 22:29:00 +00:00
|
|
|
return nil
|
2013-03-22 17:42:13 +00:00
|
|
|
}
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Pushing tag %s:%s\n", remote, tag)
|
2013-03-22 17:42:13 +00:00
|
|
|
// Push the image
|
2013-03-22 20:21:44 +00:00
|
|
|
if err = graph.PushImage(stdout, img, authConfig); err != nil {
|
2013-03-22 17:42:13 +00:00
|
|
|
return err
|
|
|
|
}
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Registering tag %s:%s\n", remote, tag)
|
2013-03-22 17:42:13 +00:00
|
|
|
// And then the tag
|
|
|
|
if err = graph.pushTag(remote, imgId, tag, authConfig); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-03-22 13:38:54 +00:00
|
|
|
// Push a repository to the registry.
|
|
|
|
// Remote has the format '<user>/<repo>
|
2013-03-22 20:21:44 +00:00
|
|
|
func (graph *Graph) PushRepository(stdout io.Writer, remote string, localRepo Repository, authConfig *auth.AuthConfig) error {
|
2013-03-26 04:01:42 +00:00
|
|
|
// Check if the remote repository exists/if we have the permission
|
|
|
|
if !graph.LookupRemoteRepository(remote, authConfig) {
|
|
|
|
return fmt.Errorf("Permission denied on repository %s\n", remote)
|
|
|
|
}
|
2013-03-22 17:42:13 +00:00
|
|
|
|
2013-03-26 00:20:26 +00:00
|
|
|
fmt.Fprintf(stdout, "Pushing repository %s (%d tags)\n", remote, len(localRepo))
|
2013-03-22 17:42:13 +00:00
|
|
|
// For each image within the repo, push them
|
2013-03-22 13:38:54 +00:00
|
|
|
for tag, imgId := range localRepo {
|
2013-03-22 20:21:44 +00:00
|
|
|
if err := graph.pushPrimitive(stdout, remote, tag, imgId, authConfig); err != nil {
|
2013-03-22 17:42:13 +00:00
|
|
|
// FIXME: Continue on error?
|
2013-03-22 08:25:27 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|