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
}
