| package graph |
| |
| import ( |
| "fmt" |
| "io" |
| |
| "github.com/Sirupsen/logrus" |
| "github.com/docker/docker/cliconfig" |
| "github.com/docker/docker/pkg/streamformatter" |
| "github.com/docker/docker/registry" |
| "github.com/docker/docker/utils" |
| ) |
| |
| type ImagePullConfig struct { |
| MetaHeaders map[string][]string |
| AuthConfig *cliconfig.AuthConfig |
| OutStream io.Writer |
| } |
| |
| type Puller interface { |
| // Pull tries to pull the image referenced by `tag` |
| // Pull returns an error if any, as well as a boolean that determines whether to retry Pull on the next configured endpoint. |
| // |
| // TODO(tiborvass): have Pull() take a reference to repository + tag, so that the puller itself is repository-agnostic. |
| Pull(tag string) (fallback bool, err error) |
| } |
| |
| func NewPuller(s *TagStore, endpoint registry.APIEndpoint, repoInfo *registry.RepositoryInfo, imagePullConfig *ImagePullConfig, sf *streamformatter.StreamFormatter) (Puller, error) { |
| switch endpoint.Version { |
| case registry.APIVersion2: |
| return &v2Puller{ |
| TagStore: s, |
| endpoint: endpoint, |
| config: imagePullConfig, |
| sf: sf, |
| repoInfo: repoInfo, |
| }, nil |
| case registry.APIVersion1: |
| return &v1Puller{ |
| TagStore: s, |
| endpoint: endpoint, |
| config: imagePullConfig, |
| sf: sf, |
| repoInfo: repoInfo, |
| }, nil |
| } |
| return nil, fmt.Errorf("unknown version %d for registry %s", endpoint.Version, endpoint.URL) |
| } |
| |
| func (s *TagStore) Pull(image string, tag string, imagePullConfig *ImagePullConfig) error { |
| var sf = streamformatter.NewJSONStreamFormatter() |
| |
| // Resolve the Repository name from fqn to RepositoryInfo |
| repoInfo, err := s.registryService.ResolveRepository(image) |
| if err != nil { |
| return err |
| } |
| |
| // makes sure name is not empty or `scratch` |
| if err := validateRepoName(repoInfo.LocalName); err != nil { |
| return err |
| } |
| |
| endpoints, err := s.registryService.LookupPullEndpoints(repoInfo.CanonicalName) |
| if err != nil { |
| return err |
| } |
| |
| logName := repoInfo.LocalName |
| if tag != "" { |
| logName = utils.ImageReference(logName, tag) |
| } |
| |
| var ( |
| lastErr error |
| |
| // discardNoSupportErrors is used to track whether an endpoint encountered an error of type registry.ErrNoSupport |
| // By default it is false, which means that if a ErrNoSupport error is encountered, it will be saved in lastErr. |
| // As soon as another kind of error is encountered, discardNoSupportErrors is set to true, avoiding the saving of |
| // any subsequent ErrNoSupport errors in lastErr. |
| // It's needed for pull-by-digest on v1 endpoints: if there are only v1 endpoints configured, the error should be |
| // returned and displayed, but if there was a v2 endpoint which supports pull-by-digest, then the last relevant |
| // error is the ones from v2 endpoints not v1. |
| discardNoSupportErrors bool |
| ) |
| for _, endpoint := range endpoints { |
| logrus.Debugf("Trying to pull %s from %s %s", repoInfo.LocalName, endpoint.URL, endpoint.Version) |
| |
| if !endpoint.Mirror && (endpoint.Official || endpoint.Version == registry.APIVersion2) { |
| if repoInfo.Official { |
| s.trustService.UpdateBase() |
| } |
| } |
| |
| puller, err := NewPuller(s, endpoint, repoInfo, imagePullConfig, sf) |
| if err != nil { |
| lastErr = err |
| continue |
| } |
| if fallback, err := puller.Pull(tag); err != nil { |
| if fallback { |
| if _, ok := err.(registry.ErrNoSupport); !ok { |
| // Because we found an error that's not ErrNoSupport, discard all subsequent ErrNoSupport errors. |
| discardNoSupportErrors = true |
| // save the current error |
| lastErr = err |
| } else if !discardNoSupportErrors { |
| // Save the ErrNoSupport error, because it's either the first error or all encountered errors |
| // were also ErrNoSupport errors. |
| lastErr = err |
| } |
| continue |
| } |
| logrus.Debugf("Not continuing with error: %v", err) |
| return err |
| |
| } |
| |
| s.eventsService.Log("pull", logName, "") |
| return nil |
| } |
| |
| if lastErr == nil { |
| lastErr = fmt.Errorf("no endpoints found for %s", image) |
| } |
| return lastErr |
| } |
| |
| func WriteStatus(requestedTag string, out io.Writer, sf *streamformatter.StreamFormatter, layersDownloaded bool) { |
| if layersDownloaded { |
| out.Write(sf.FormatStatus("", "Status: Downloaded newer image for %s", requestedTag)) |
| } else { |
| out.Write(sf.FormatStatus("", "Status: Image is up to date for %s", requestedTag)) |
| } |
| } |