func autoConvert_v1_DockerImageReference_To_api_DockerImageReference(in *DockerImageReference, out *api.DockerImageReference, s conversion.Scope) error { out.Registry = in.Registry out.Namespace = in.Namespace out.Name = in.Name out.Tag = in.Tag out.ID = in.ID return nil }
func autoConvert_v1_DockerImageReference_To_api_DockerImageReference(in *DockerImageReference, out *image_api.DockerImageReference, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*DockerImageReference))(in) } out.Registry = in.Registry out.Namespace = in.Namespace out.Name = in.Name out.Tag = in.Tag out.ID = in.ID return nil }
// Search will attempt to find imagestreams with names that match the passed in value func (r ImageStreamSearcher) Search(precise bool, terms ...string) (ComponentMatches, []error) { componentMatches := ComponentMatches{} var errs []error for _, term := range terms { var ( ref imageapi.DockerImageReference err error ) switch term { case "__imagestream_fail": errs = append(errs, fmt.Errorf("unable to find the specified image: %s", term)) continue case "*": ref = imageapi.DockerImageReference{Name: term} default: ref, err = imageapi.ParseDockerImageReference(term) if err != nil || len(ref.Registry) != 0 { glog.V(2).Infof("image streams must be of the form [<namespace>/]<name>[:<tag>|@<digest>], term %q did not qualify", term) continue } } namespaces := r.Namespaces if len(ref.Namespace) != 0 { namespaces = []string{ref.Namespace} } followTag := false searchTag := ref.Tag if len(searchTag) == 0 { searchTag = imageapi.DefaultImageTag followTag = true } for _, namespace := range namespaces { glog.V(4).Infof("checking ImageStreams %s/%s with ref %q", namespace, ref.Name, searchTag) exact := false streams, err := r.Client.ImageStreams(namespace).List(kapi.ListOptions{}) if err != nil { if errors.IsNotFound(err) || errors.IsForbidden(err) { continue } errs = append(errs, err) continue } original := ref ref.Namespace = namespace for i := range streams.Items { stream := &streams.Items[i] score, scored := imageStreamScorer(*stream, ref.Name) if !scored { glog.V(2).Infof("unscored %s: %v", stream.Name, score) continue } // indicate the server knows how to directly import image stream tags var meta map[string]string if stream.Generation > 0 { meta = map[string]string{"direct-tag": "1"} } imageref := original imageref.Name = stream.Name imageref.Registry = "" matchName := fmt.Sprintf("%s/%s", stream.Namespace, stream.Name) addMatch := func(tag string, matchScore float32, image *imageapi.DockerImage, notFound bool) { name := matchName var description, argument string if len(tag) > 0 { name = fmt.Sprintf("%s:%s", name, tag) argument = fmt.Sprintf("--image-stream=%q", name) description = fmt.Sprintf("Image stream %q (tag %q) in project %q", stream.Name, tag, stream.Namespace) } else { argument = fmt.Sprintf("--image-stream=%q --allow-missing-imagestream-tags", name) description = fmt.Sprintf("Image stream %q in project %q", stream.Name, stream.Namespace) } match := &ComponentMatch{ Value: term, Argument: argument, Name: name, Description: description, Score: matchScore, ImageStream: stream, Image: image, ImageTag: tag, Meta: meta, NoTagsFound: notFound, } glog.V(2).Infof("Adding %s as component match for %q with score %v", match.Description, term, matchScore) componentMatches = append(componentMatches, match) } // When an image stream contains a tag that references another local tag, and the user has not // provided a tag themselves (i.e. they asked for mysql and we defaulted to mysql:latest), walk // the chain of references to the end. This ensures that applications can default to using a "stable" // branch by giving the control over version to the image stream author. finalTag := searchTag if specTag, ok := stream.Spec.Tags[searchTag]; ok && followTag { if specTag.From != nil && specTag.From.Kind == "ImageStreamTag" && !strings.Contains(specTag.From.Name, ":") { if imageapi.LatestTaggedImage(stream, specTag.From.Name) != nil { finalTag = specTag.From.Name } } } latest := imageapi.LatestTaggedImage(stream, finalTag) if latest == nil || len(latest.Image) == 0 { glog.V(2).Infof("no image recorded for %s/%s:%s", stream.Namespace, stream.Name, finalTag) if r.AllowMissingTags { addMatch(finalTag, score, nil, false) continue } // Find tags that do exist and return those as partial matches foundOtherTags := false for tag := range stream.Status.Tags { latest := imageapi.LatestTaggedImage(stream, tag) if latest == nil || len(latest.Image) == 0 { continue } foundOtherTags = true // If the user specified a tag in their search string (followTag == false), // then score this match lower. tagScore := score if !followTag { tagScore += 0.5 } addMatch(tag, tagScore, nil, false) } if !foundOtherTags { addMatch("", 0.5+score, nil, true) } continue } imageStreamImage, err := r.ImageStreamImages.ImageStreamImages(namespace).Get(stream.Name, latest.Image) if err != nil { if errors.IsNotFound(err) { // continue searching glog.V(2).Infof("tag %q is set, but image %q has been removed", finalTag, latest.Image) continue } errs = append(errs, err) continue } addMatch(finalTag, score, &imageStreamImage.Image.DockerImageMetadata, false) if score == 0.0 { exact = true } } // If we found one or more exact matches in this namespace, do not continue looking at // other namespaces if exact && precise { break } } } return componentMatches, errs }