// parseIdentifiersList parses a (possibly empty) list of // of comma separated (possibly empty) identifiers func (p *Parser) parseIdentifiersList() (util.StringSet, error) { s := util.NewStringSet() for { tok, lit := p.consume(Values) switch tok { case IdentifierToken: s.Insert(lit) tok2, lit2 := p.lookahead(Values) switch tok2 { case CommaToken: continue case ClosedParToken: return s, nil default: return nil, fmt.Errorf("found '%s', expected: ',' or ')'", lit2) } case CommaToken: // handled here since we can have "(," if s.Len() == 0 { s.Insert("") // to handle (, } tok2, _ := p.lookahead(Values) if tok2 == ClosedParToken { s.Insert("") // to handle ,) Double "" removed by StringSet return s, nil } if tok2 == CommaToken { p.consume(Values) s.Insert("") // to handle ,, Double "" removed by StringSet } default: // it can be operator return s, fmt.Errorf("found '%s', expected: ',', or identifier", lit) } } }
func init() { // Use the first API version in the list of registered versions as the latest. Version = registered.RegisteredVersions[0] OldestVersion = registered.RegisteredVersions[len(registered.RegisteredVersions)-1] Codec = runtime.CodecFor(api.Scheme, Version) // Put the registered versions in Versions in reverse order. versions := registered.RegisteredVersions Versions = []string{} for i := len(versions) - 1; i >= 0; i-- { Versions = append(Versions, versions[i]) } mapper := meta.NewDefaultRESTMapper( versions, func(version string) (*meta.VersionInterfaces, bool) { interfaces, err := InterfacesFor(version) if err != nil { return nil, false } return interfaces, true }, ) // the list of kinds that are scoped at the root of the api hierarchy // if a kind is not enumerated here, it is assumed to have a namespace scope kindToRootScope := map[string]bool{ "Node": true, "Minion": true, "Namespace": true, "PersistentVolume": true, } // setup aliases for groups of resources mapper.AddResourceAlias("all", userResources...) // these kinds should be excluded from the list of resources ignoredKinds := util.NewStringSet( "ListOptions", "DeleteOptions", "Status", "PodLogOptions", "PodExecOptions", "PodProxyOptions") // enumerate all supported versions, get the kinds, and register with the mapper how to address our resources. for _, version := range versions { for kind := range api.Scheme.KnownTypes(version) { if ignoredKinds.Has(kind) { continue } scope := meta.RESTScopeNamespace if kindToRootScope[kind] { scope = meta.RESTScopeRoot } mapper.Add(scope, kind, version, false) } } RESTMapper = mapper }
// parseExactValue parses the only value for exact match style func (p *Parser) parseExactValue() (util.StringSet, error) { s := util.NewStringSet() tok, lit := p.consume(Values) if tok == IdentifierToken { s.Insert(lit) return s, nil } return nil, fmt.Errorf("found '%s', expected: identifier", lit) }
// Add adds a requirement to the selector. It copies the current selector returning a new one func (lsel LabelSelector) Add(key string, operator Operator, values []string) Selector { var reqs []Requirement for _, item := range lsel { reqs = append(reqs, item) } if r, err := NewRequirement(key, operator, util.NewStringSet(values...)); err == nil { reqs = append(reqs, *r) } return LabelSelector(reqs) }
// Executes the rule check without using the "-C" flag, instead parsing iptables-save. // Present for compatibility with <1.4.11 versions of iptables. This is full // of hack and half-measures. We should nix this ASAP. func (runner *runner) checkRuleWithoutCheck(table Table, chain Chain, args ...string) (bool, error) { glog.V(1).Infof("running iptables-save -t %s", string(table)) out, err := runner.exec.Command("iptables-save", "-t", string(table)).CombinedOutput() if err != nil { return false, fmt.Errorf("error checking rule: %v", err) } // Sadly, iptables has inconsistent quoting rules for comments. // Just unquote any arg that is wrapped in quotes. argsCopy := make([]string, len(args)) copy(argsCopy, args) for i := range argsCopy { unquote(&argsCopy[i]) } argset := util.NewStringSet(argsCopy...) for _, line := range strings.Split(string(out), "\n") { var fields = strings.Fields(line) // Check that this is a rule for the correct chain, and that it has // the correct number of argument (+2 for "-A <chain name>") if !strings.HasPrefix(line, fmt.Sprintf("-A %s", string(chain))) || len(fields) != len(args)+2 { continue } // Sadly, iptables has inconsistent quoting rules for comments. // Just unquote any arg that is wrapped in quotes. for i := range fields { unquote(&fields[i]) } // TODO: This misses reorderings e.g. "-x foo ! -y bar" will match "! -x foo -y bar" if util.NewStringSet(fields...).IsSuperset(argset) { return true, nil } glog.V(5).Infof("DBG: fields is not a superset of args: fields=%v args=%v", fields, args) } return false, nil }
// SelectorFromSet returns a Selector which will match exactly the given Set. A // nil and empty Sets are considered equivalent to Everything(). func SelectorFromSet(ls Set) Selector { if ls == nil { return LabelSelector{} } var requirements []Requirement for label, value := range ls { if r, err := NewRequirement(label, EqualsOperator, util.NewStringSet(value)); err != nil { //TODO: double check errors when input comes from serialization? return LabelSelector{} } else { requirements = append(requirements, *r) } } return LabelSelector(requirements) }
// parseValues parses the values for set based matching (x,y,z) func (p *Parser) parseValues() (util.StringSet, error) { tok, lit := p.consume(Values) if tok != OpenParToken { return nil, fmt.Errorf("found '%s' expected: '('", lit) } tok, lit = p.lookahead(Values) switch tok { case IdentifierToken, CommaToken: s, err := p.parseIdentifiersList() // handles general cases if err != nil { return s, err } if tok, _ = p.consume(Values); tok != ClosedParToken { return nil, fmt.Errorf("found '%s', expected: ')'", lit) } return s, nil case ClosedParToken: // handles "()" p.consume(Values) return util.NewStringSet(""), nil default: return nil, fmt.Errorf("found '%s', expected: ',', ')' or identifier", lit) } return util.NewStringSet(), nil }
"net/url" "path" "strings" "github.com/golang/glog" "golang.org/x/net/html" "golang.org/x/net/html/atom" "vulcan/kubernetes/pkg/util" ) // atomsToAttrs states which attributes of which tags require URL substitution. // Sources: http://www.w3.org/TR/REC-html40/index/attributes.html // http://www.w3.org/html/wg/drafts/html/master/index.html#attributes-1 var atomsToAttrs = map[atom.Atom]util.StringSet{ atom.A: util.NewStringSet("href"), atom.Applet: util.NewStringSet("codebase"), atom.Area: util.NewStringSet("href"), atom.Audio: util.NewStringSet("src"), atom.Base: util.NewStringSet("href"), atom.Blockquote: util.NewStringSet("cite"), atom.Body: util.NewStringSet("background"), atom.Button: util.NewStringSet("formaction"), atom.Command: util.NewStringSet("icon"), atom.Del: util.NewStringSet("cite"), atom.Embed: util.NewStringSet("src"), atom.Form: util.NewStringSet("action"), atom.Frame: util.NewStringSet("longdesc", "src"), atom.Head: util.NewStringSet("profile"), atom.Html: util.NewStringSet("manifest"), atom.Iframe: util.NewStringSet("longdesc", "src"),
func(a, b util.Time) bool { return a.UTC() == b.UTC() }, func(a, b labels.Selector) bool { return a.String() == b.String() }, func(a, b fields.Selector) bool { return a.String() == b.String() }, ) var standardResources = util.NewStringSet( string(ResourceMemory), string(ResourceCPU), string(ResourcePods), string(ResourceQuotas), string(ResourceServices), string(ResourceReplicationControllers), string(ResourceSecrets), string(ResourcePersistentVolumeClaims), string(ResourceStorage)) func IsStandardResourceName(str string) bool { return standardResources.Has(str) } // NewDeleteOptions returns a DeleteOptions indicating the resource should // be deleted within the specified grace period. Use zero to indicate // immediate deletion. If you would prefer to use the default grace period, // use &api.DeleteOptions{} directly. func NewDeleteOptions(grace int64) *DeleteOptions { return &DeleteOptions{GracePeriodSeconds: &grace}