func main() { flag.Parse() if *image == "" { die("image name is empty or missing") } u, err := url.Parse(*baseURL) if err != nil { die("unable to parse baseURL:", err) } if *basicUser == "" || *basicPass == "" { *basicUser, *basicPass = userpass(u.Host) } c := registry.NewClient() c.BaseURL = u basic := registry.BasicAuth{ Username: *basicUser, Password: *basicPass, } token, err := c.Hub.GetReadTokenWithAuth(*image, basic) if err != nil { die("failed to obtain read token:", err) } tags, err := c.Repository.ListTags(*image, token) if err != nil { die("failed to obtain tag list:", err) } p, err := json.MarshalIndent(NewTags(tags), "", "\t") if err != nil { die("failed to JSON encode tags:", err) } fmt.Printf("%s\n", p) }
func NewRemoteRegistry() *registryApi { conn := &remoteConnection{ client: registry.NewClient(), layerCache: cache.New(cacheDuration, cacheCleanupInterval), tagCache: cache.New(cacheDuration, cacheCleanupInterval), } reg := newRegistryApi(conn) return reg }
func ExampleRepositoryService_Delete_dockerHub() { c := registry.NewClient() basicAuth := registry.BasicAuth{"user", "pass"} tokenAuth, err := c.Hub.GetDeleteToken("foo/bar", basicAuth) err = c.Repository.Delete("foo/bar", tokenAuth) if err != nil { panic(err) } }
func ExampleRepositoryService_Delete_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} err := c.Repository.Delete("foo/bar", auth) if err != nil { panic(err) } }
func ExampleRepositoryService_SetTag_dockerHub() { c := registry.NewClient() basicAuth := registry.BasicAuth{"user", "pass"} tokenAuth, err := c.Hub.GetWriteToken("foo/bar", basicAuth) imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" err = c.Repository.SetTag("foo/bar", imageID, "1.0", tokenAuth) if err != nil { panic(err) } }
func ExampleRepositoryService_SetTag_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" err := c.Repository.SetTag("foo/bar", imageID, "1.0", auth) if err != nil { panic(err) } }
func ExampleRepositoryService_GetImageID_dockerHub() { c := registry.NewClient() auth, err := c.Hub.GetReadToken("ubuntu") imageID, err := c.Repository.GetImageID("ubuntu", "latest", auth) if err != nil { panic(err) } fmt.Println(imageID) }
func ExampleRepositoryService_GetImageID_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} imageID, err := c.Repository.GetImageID("ubuntu", "latest", auth) if err != nil { panic(err) } fmt.Println(imageID) }
func ExampleSearchService_Query_dockerHub() { c := registry.NewClient() results, err := c.Search.Query("mysql", 1, 25) if err != nil { panic(err) } for _, result := range results.Results { fmt.Println(result.Name) } }
func ExampleImageService_GetMetadata_dockerHub() { c := registry.NewClient() auth, err := c.Hub.GetReadToken("ubuntu") imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" meta, err := c.Image.GetMetadata(imageID, auth) if err != nil { panic(err) } fmt.Printf("%#v", meta) }
func ExampleSearchService_Query_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") results, err := c.Search.Query("mysql", 1, 25) if err != nil { panic(err) } for _, result := range results.Results { fmt.Println(result.Name) } }
func ExampleImageService_GetMetadata_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" meta, err := c.Image.GetMetadata(imageID, auth) if err != nil { panic(err) } fmt.Printf("%#v", meta) }
func ExampleImageService_GetAncestry_dockerHub() { c := registry.NewClient() auth, err := c.Hub.GetReadToken("ubuntu") images, err := c.Image.GetAncestry("ubuntu", auth) if err != nil { panic(err) } for _, imageID := range images { fmt.Println(imageID) } }
func ExampleRepositoryService_ListTags_dockerHub() { c := registry.NewClient() auth, err := c.Hub.GetReadToken("ubuntu") tags, err := c.Repository.ListTags("ubuntu", auth) if err != nil { panic(err) } for tag, imageID := range tags { fmt.Printf("%s = %s", tag, imageID) } }
func ExampleImageService_GetLayer_dockerHub() { c := registry.NewClient() auth, err := c.Hub.GetReadToken("ubuntu") buffer := &bytes.Buffer{} imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" err = c.Image.GetLayer(imageID, buffer, auth) if err != nil { panic(err) } fmt.Println(buffer) }
func ExampleImageService_GetAncestry_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} images, err := c.Image.GetAncestry("ubuntu", auth) if err != nil { panic(err) } for _, imageID := range images { fmt.Println(imageID) } }
func ExampleImageService_GetLayer_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} buffer := &bytes.Buffer{} imageID := "2427658c75a1e3d0af0e7272317a8abfaee4c15729b6840e3c2fca342fe47bf1" err := c.Image.GetLayer(imageID, buffer, auth) if err != nil { panic(err) } fmt.Println(buffer) }
func ExampleRepositoryService_ListTags_privateRegistry() { c := registry.NewClient() c.BaseURL, _ = url.Parse("http://my.registry:8080/v1/") auth := registry.BasicAuth{"user", "pass"} tags, err := c.Repository.ListTags("ubuntu", auth) if err != nil { panic(err) } for tag, imageID := range tags { fmt.Printf("%s = %s", tag, imageID) } }
// CheckAccess checks whether a user can read or write an image // TODO(termie): this really uses the docker registry code rather than the // client so, maybe this is the wrong place func (c *DockerClient) CheckAccess(opts CheckAccessOptions) (bool, error) { logger := util.RootLogger().WithField("Logger", "Docker") logger.Debug("Checking access for ", opts.Repository) // Do the steps described here: https://gist.github.com/termie/bc0334b086697a162f67 name := normalizeRepo(opts.Repository) logger.Debug("Normalized repo ", name) auth := registry.BasicAuth{ Username: opts.Auth.Username, Password: opts.Auth.Password, } client := registry.NewClient() reg := normalizeRegistry(opts.Registry) logger.Debug("Normalized Registry ", reg) client.BaseURL, _ = url.Parse(reg) if opts.Access == "write" { if _, err := client.Hub.GetWriteToken(name, auth); err != nil { if err.Error() == "Server returned status 401" || err.Error() == "Server returned status 403" { return false, nil } return false, err } } else if opts.Access == "read" { if opts.Auth.Username != "" { if _, err := client.Hub.GetReadTokenWithAuth(name, auth); err != nil { if err.Error() == "Server returned status 401" || err.Error() == "Server returned status 403" { return false, nil } return false, err } } else { if _, err := client.Hub.GetReadToken(name); err != nil { if err.Error() == "Server returned status 401" || err.Error() == "Server returned status 403" { return false, nil } return false, err } } } else { return false, fmt.Errorf("Invalid access type requested: %s", opts.Access) } return true, nil }
func NewStorage(cli *docker.Client, repo string) (res *Storage, err error) { res = &Storage{ cli: cli, reg: registry.NewClient(), auth: registry.NilAuth{}, full: repo, } // Split repo split := strings.Split(repo, "/") res.index = split[0] if strings.Contains(res.index, ".") || strings.Contains(res.index, ":") { // registry present res.chunk = strings.Join(split[1:], "/") } else { // hub res.index = "" res.chunk = repo } res.reg.BaseURL, err = url.Parse(registryUrl(res.index)) return }
func main() { repo := "mysql" tag := "latest" // Check for image name as command line argument if len(os.Args) > 1 { // Separate repo and tag parts := strings.Split(os.Args[1], ":") repo = parts[0] if len(parts) > 1 { tag = parts[1] } } c := registry.NewClient() // First step is to retrieve a read-only token from the Hub auth, err := c.Hub.GetReadToken(repo) if err != nil { panic(err) } // Get image ID for tag imageID, err := c.Repository.GetImageID(repo, tag, auth) if err != nil { panic(err) } // Retrieve all ancestors of given layer ID layers, err := c.Image.GetAncestry(imageID, auth) if err != nil { panic(err) } var commands []string // Iterate over all ancestors for _, layerID := range layers { // Retrieve metadata for given layer ID m, err := c.Image.GetMetadata(layerID, auth) if err != nil { panic(err) } // Format the command string cmdParts := m.ContainerConfig.Cmd if len(cmdParts) == 3 { cmd := cmdParts[2] if strings.HasPrefix(cmd, NOP_PREFIX) { commands = append(commands, strings.Split(cmd, NOP_PREFIX)[1]) } else { commands = append(commands, fmt.Sprintf("RUN %s", cmd)) } } } // Iterate over commands in reverse order and print them for i := len(commands) - 1; i >= 0; i-- { fmt.Println(squeeze(commands[i])) } }