// GetImageLabels retrieves Docker labels from image from image repository name and
// image reference
func GetImageLabels(c client.ImageStreamImageInterface, imageRepoName, imageRef string) (map[string]string, error) {
_, imageID, err := imagestreamimage.ParseNameAndID(imageRef)
image, err := c.Get(imageRepoName, imageID)
if err != nil {
return map[string]string{}, err
}
return image.Image.DockerImageMetadata.Config.Labels, nil
}
// addBuildStrategyImageReferencesToGraph ads references from the build strategy's parent node to the image
// the build strategy references.
//
// Edges are added to the graph from each predecessor (build or build config)
// to the image specified by strategy.from, as long as the image is managed by
// OpenShift.
func addBuildStrategyImageReferencesToGraph(g graph.Graph, strategy buildapi.BuildStrategy, predecessor gonum.Node) {
glog.V(4).Infof("Examining build strategy with type %q", strategy.Type)
from := buildutil.GetImageStreamForStrategy(strategy)
if from == nil {
glog.V(4).Infof("Unable to determine 'from' reference - skipping")
return
}
glog.V(4).Infof("Examining build strategy with from: %#v", from)
var imageID string
switch from.Kind {
case "ImageStreamImage":
_, id, err := imagestreamimage.ParseNameAndID(from.Name)
if err != nil {
glog.V(2).Infof("Error parsing ImageStreamImage name %q: %v - skipping", from.Name, err)
return
}
imageID = id
case "DockerImage":
ref, err := imageapi.ParseDockerImageReference(from.Name)
if err != nil {
glog.V(2).Infof("Error parsing DockerImage name %q: %v - skipping", from.Name, err)
return
}
imageID = ref.ID
default:
return
}
glog.V(4).Infof("Looking for image %q in graph", imageID)
imageNode := imagegraph.FindImage(g, imageID)
if imageNode == nil {
glog.V(4).Infof("Unable to find image %q in graph - skipping", imageID)
return
}
glog.V(4).Infof("Adding edge from %v to %v", predecessor, imageNode)
g.AddEdge(predecessor, imageNode, ReferencedImageEdgeKind)
}
// RunTag contains all the necessary functionality for the OpenShift cli tag command.
func RunTag(f *clientcmd.Factory, out io.Writer, cmd *cobra.Command, args []string, sourceKind string) error {
if len(args) < 2 {
return cmdutil.UsageError(cmd, "you must specify a source and at least one destination")
}
original := sourceKind
if len(sourceKind) > 0 {
sourceKind = determineSourceKind(f, sourceKind)
}
if len(sourceKind) > 0 {
validSources := util.NewStringSet("imagestreamtag", "istag", "imagestreamimage", "isimage", "docker", "dockerimage")
if !validSources.Has(strings.ToLower(sourceKind)) {
cmdutil.CheckErr(cmdutil.UsageError(cmd, "invalid source %q; valid values are %v", original, strings.Join(validSources.List(), ", ")))
}
}
namespace, err := f.DefaultNamespace()
if err != nil {
return err
}
sourceNamespace, sourceNameAndRef, err := parseStreamName(args[0], namespace)
if err != nil {
return err
}
osClient, _, err := f.Clients()
if err != nil {
return err
}
if len(sourceKind) == 0 {
if sourceName, sourceTag, ok := imageapi.SplitImageStreamTag(sourceNameAndRef); ok {
if _, err := osClient.ImageStreamTags(sourceNamespace).Get(sourceName, sourceTag); err == nil {
sourceKind = "ImageStreamTag"
}
}
}
if len(sourceKind) == 0 {
if sourceName, sourceID, err := imagestreamimage.ParseNameAndID(sourceNameAndRef); err == nil {
if _, err := osClient.ImageStreamImages(sourceNamespace).Get(sourceName, sourceID); err == nil {
sourceKind = "ImageStreamImage"
}
}
}
if len(sourceKind) == 0 {
sourceKind = "DockerImage"
}
for _, arg := range args[1:] {
destNamespace, destNameAndTag, err := parseStreamName(arg, namespace)
if err != nil {
return err
}
destName, destTag, ok := imageapi.SplitImageStreamTag(destNameAndTag)
if !ok {
return fmt.Errorf("%q must be of the form <namespace>/<stream name>:<tag>", arg)
}
isc := osClient.ImageStreams(destNamespace)
target, err := isc.Get(destName)
if err != nil {
if !kerrors.IsNotFound(err) {
return err
}
// try to create the target if it doesn't exist
target = &imageapi.ImageStream{
ObjectMeta: kapi.ObjectMeta{
Name: destName,
},
}
target, err = isc.Create(target)
if err != nil {
return nil
}
}
if target.Spec.Tags == nil {
target.Spec.Tags = make(map[string]imageapi.TagReference)
}
targetRef, ok := target.Spec.Tags[destTag]
if !ok {
targetRef = imageapi.TagReference{}
}
targetRef.From = &kapi.ObjectReference{
Kind: sourceKind,
}
switch sourceKind {
case "DockerImage":
targetRef.From.Name = args[0]
default:
targetRef.From.Namespace = sourceNamespace
targetRef.From.Name = sourceNameAndRef
}
target.Spec.Tags[destTag] = targetRef
if _, err = isc.Update(target); err != nil {
return err
}
}
return nil
}