github.com/aclisp/heapster@v0.19.2-0.20160613100040-51756f899a96/Godeps/_workspace/src/k8s.io/kubernetes/pkg/api/unversioned/helpers.go (about)

     1  /*
     2  Copyright 2016 The Kubernetes Authors All rights reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package unversioned
    18  
    19  import (
    20  	"fmt"
    21  
    22  	"k8s.io/kubernetes/pkg/labels"
    23  	"k8s.io/kubernetes/pkg/util/sets"
    24  )
    25  
    26  // LabelSelectorAsSelector converts the LabelSelector api type into a struct that implements
    27  // labels.Selector
    28  // Note: This function should be kept in sync with the selector methods in pkg/labels/selector.go
    29  func LabelSelectorAsSelector(ps *LabelSelector) (labels.Selector, error) {
    30  	if ps == nil {
    31  		return labels.Nothing(), nil
    32  	}
    33  	if len(ps.MatchLabels)+len(ps.MatchExpressions) == 0 {
    34  		return labels.Everything(), nil
    35  	}
    36  	selector := labels.NewSelector()
    37  	for k, v := range ps.MatchLabels {
    38  		r, err := labels.NewRequirement(k, labels.EqualsOperator, sets.NewString(v))
    39  		if err != nil {
    40  			return nil, err
    41  		}
    42  		selector = selector.Add(*r)
    43  	}
    44  	for _, expr := range ps.MatchExpressions {
    45  		var op labels.Operator
    46  		switch expr.Operator {
    47  		case LabelSelectorOpIn:
    48  			op = labels.InOperator
    49  		case LabelSelectorOpNotIn:
    50  			op = labels.NotInOperator
    51  		case LabelSelectorOpExists:
    52  			op = labels.ExistsOperator
    53  		case LabelSelectorOpDoesNotExist:
    54  			op = labels.DoesNotExistOperator
    55  		default:
    56  			return nil, fmt.Errorf("%q is not a valid pod selector operator", expr.Operator)
    57  		}
    58  		r, err := labels.NewRequirement(expr.Key, op, sets.NewString(expr.Values...))
    59  		if err != nil {
    60  			return nil, err
    61  		}
    62  		selector = selector.Add(*r)
    63  	}
    64  	return selector, nil
    65  }
    66  
    67  // ParseToLabelSelector parses a string representing a selector into a LabelSelector object.
    68  // Note: This function should be kept in sync with the parser in pkg/labels/selector.go
    69  func ParseToLabelSelector(selector string) (*LabelSelector, error) {
    70  	reqs, err := labels.ParseToRequirements(selector)
    71  	if err != nil {
    72  		return nil, fmt.Errorf("couldn't parse the selector string \"%s\": %v", selector, err)
    73  	}
    74  
    75  	labelSelector := &LabelSelector{
    76  		MatchLabels:      map[string]string{},
    77  		MatchExpressions: []LabelSelectorRequirement{},
    78  	}
    79  	for _, req := range reqs {
    80  		var op LabelSelectorOperator
    81  		switch req.Operator() {
    82  		case labels.EqualsOperator, labels.DoubleEqualsOperator:
    83  			vals := req.Values()
    84  			if vals.Len() != 1 {
    85  				return nil, fmt.Errorf("equals operator must have exactly one value")
    86  			}
    87  			val, ok := vals.PopAny()
    88  			if !ok {
    89  				return nil, fmt.Errorf("equals operator has exactly one value but it cannot be retrieved")
    90  			}
    91  			labelSelector.MatchLabels[req.Key()] = val
    92  			continue
    93  		case labels.InOperator:
    94  			op = LabelSelectorOpIn
    95  		case labels.NotInOperator:
    96  			op = LabelSelectorOpNotIn
    97  		case labels.ExistsOperator:
    98  			op = LabelSelectorOpExists
    99  		case labels.DoesNotExistOperator:
   100  			op = LabelSelectorOpDoesNotExist
   101  		case labels.GreaterThanOperator, labels.LessThanOperator:
   102  			// Adding a separate case for these operators to indicate that this is deliberate
   103  			return nil, fmt.Errorf("%q isn't supported in label selectors", req.Operator())
   104  		default:
   105  			return nil, fmt.Errorf("%q is not a valid label selector operator", req.Operator())
   106  		}
   107  		labelSelector.MatchExpressions = append(labelSelector.MatchExpressions, LabelSelectorRequirement{
   108  			Key:      req.Key(),
   109  			Operator: op,
   110  			Values:   req.Values().List(),
   111  		})
   112  	}
   113  	return labelSelector, nil
   114  }
   115  
   116  // SetAsLabelSelector converts the labels.Set object into a LabelSelector api object.
   117  func SetAsLabelSelector(ls labels.Set) *LabelSelector {
   118  	if ls == nil {
   119  		return nil
   120  	}
   121  
   122  	selector := &LabelSelector{
   123  		MatchLabels: make(map[string]string),
   124  	}
   125  	for label, value := range ls {
   126  		selector.MatchLabels[label] = value
   127  	}
   128  
   129  	return selector
   130  }
   131  
   132  // FormatLabelSelector convert labelSelector into plain string
   133  func FormatLabelSelector(labelSelector *LabelSelector) string {
   134  	selector, err := LabelSelectorAsSelector(labelSelector)
   135  	if err != nil {
   136  		return "<error>"
   137  	}
   138  
   139  	l := selector.String()
   140  	if len(l) == 0 {
   141  		l = "<none>"
   142  	}
   143  	return l
   144  }
   145  
   146  func ExtractGroupVersions(l *APIGroupList) []string {
   147  	var groupVersions []string
   148  	for _, g := range l.Groups {
   149  		for _, gv := range g.Versions {
   150  			groupVersions = append(groupVersions, gv.GroupVersion)
   151  		}
   152  	}
   153  	return groupVersions
   154  }