// ValidateLabelName validates that the label name is correctly defined. func ValidateLabelName(labelName string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} for _, msg := range validation.IsQualifiedName(labelName) { allErrs = append(allErrs, field.Invalid(fldPath, labelName, msg)) } return allErrs }
// InitPlugins initializes each plugin. All plugins must have unique names. // This must be called exactly once before any New* methods are called on any // plugins. func (pm *VolumePluginMgr) InitPlugins(plugins []VolumePlugin, host VolumeHost) error { pm.mutex.Lock() defer pm.mutex.Unlock() if pm.plugins == nil { pm.plugins = map[string]VolumePlugin{} } allErrs := []error{} for _, plugin := range plugins { name := plugin.GetPluginName() if errs := validation.IsQualifiedName(name); len(errs) != 0 { allErrs = append(allErrs, fmt.Errorf("volume plugin has invalid name: %q: %s", name, strings.Join(errs, ";"))) continue } if _, found := pm.plugins[name]; found { allErrs = append(allErrs, fmt.Errorf("volume plugin %q was registered more than once", name)) continue } err := plugin.Init(host) if err != nil { glog.Errorf("Failed to load volume plugin %s, error: %s", plugin, err.Error()) allErrs = append(allErrs, err) continue } pm.plugins[name] = plugin glog.V(1).Infof("Loaded volume plugin %q", name) } return utilerrors.NewAggregate(allErrs) }
// ParseTaint parses a taint from a string. Taint must be off the format '<key>=<value>:<effect>'. func ParseTaint(st string) (v1.Taint, error) { var taint v1.Taint parts := strings.Split(st, "=") if len(parts) != 2 || len(parts[1]) == 0 || len(validation.IsQualifiedName(parts[0])) > 0 { return taint, fmt.Errorf("invalid taint spec: %v", st) } parts2 := strings.Split(parts[1], ":") effect := v1.TaintEffect(parts2[1]) errs := validation.IsValidLabelValue(parts2[0]) if len(parts2) != 2 || len(errs) != 0 { return taint, fmt.Errorf("invalid taint spec: %v, %s", st, strings.Join(errs, "; ")) } if effect != v1.TaintEffectNoSchedule && effect != v1.TaintEffectPreferNoSchedule { return taint, fmt.Errorf("invalid taint spec: %v, unsupported taint effect", st) } taint.Key = parts[0] taint.Value = parts2[0] taint.Effect = effect return taint, nil }
// validateProvisioner tests if provisioner is a valid qualified name. func validateProvisioner(provisioner string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} if len(provisioner) == 0 { allErrs = append(allErrs, field.Required(fldPath, provisioner)) } if len(provisioner) > 0 { for _, msg := range validation.IsQualifiedName(strings.ToLower(provisioner)) { allErrs = append(allErrs, field.Invalid(fldPath, provisioner, msg)) } } return allErrs }
// ValidateAnnotations validates that a set of annotations are correctly defined. func ValidateAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} var totalSize int64 for k, v := range annotations { for _, msg := range validation.IsQualifiedName(strings.ToLower(k)) { allErrs = append(allErrs, field.Invalid(fldPath, k, msg)) } totalSize += (int64)(len(k)) + (int64)(len(v)) } if totalSize > (int64)(totalAnnotationSizeLimitB) { allErrs = append(allErrs, field.TooLong(fldPath, "", totalAnnotationSizeLimitB)) } return allErrs }
// Validate compute resource typename. // Refer to docs/design/resources.md for more details. func validateResourceName(value string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} for _, msg := range validation.IsQualifiedName(value) { allErrs = append(allErrs, field.Invalid(fldPath, value, msg)) } if len(allErrs) != 0 { return allErrs } if len(strings.Split(value, "/")) == 1 { if !api.IsStandardResourceName(value) { return append(allErrs, field.Invalid(fldPath, value, "must be a standard resource type or fully qualified")) } } return field.ErrorList{} }
// Validate finalizer names func ValidateFinalizerName(stringValue string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} for _, msg := range validation.IsQualifiedName(stringValue) { allErrs = append(allErrs, field.Invalid(fldPath, stringValue, msg)) } if len(allErrs) != 0 { return allErrs } if len(strings.Split(stringValue, "/")) == 1 { if !api.IsStandardFinalizerName(stringValue) { return append(allErrs, field.Invalid(fldPath, stringValue, "name is neither a standard finalizer name nor is it fully qualified")) } } return field.ErrorList{} }
// InitNetworkPlugin inits the plugin that matches networkPluginName. Plugins must have unique names. func InitNetworkPlugin(plugins []NetworkPlugin, networkPluginName string, host Host, hairpinMode componentconfig.HairpinMode, nonMasqueradeCIDR string, mtu int) (NetworkPlugin, error) { if networkPluginName == "" { // default to the no_op plugin plug := &NoopNetworkPlugin{} if err := plug.Init(host, hairpinMode, nonMasqueradeCIDR, mtu); err != nil { return nil, err } return plug, nil } pluginMap := map[string]NetworkPlugin{} allErrs := []error{} for _, plugin := range plugins { name := plugin.Name() if errs := validation.IsQualifiedName(name); len(errs) != 0 { allErrs = append(allErrs, fmt.Errorf("network plugin has invalid name: %q: %s", name, strings.Join(errs, ";"))) continue } if _, found := pluginMap[name]; found { allErrs = append(allErrs, fmt.Errorf("network plugin %q was registered more than once", name)) continue } pluginMap[name] = plugin } chosenPlugin := pluginMap[networkPluginName] if chosenPlugin != nil { err := chosenPlugin.Init(host, hairpinMode, nonMasqueradeCIDR, mtu) if err != nil { allErrs = append(allErrs, fmt.Errorf("Network plugin %q failed init: %v", networkPluginName, err)) } else { glog.V(1).Infof("Loaded network plugin %q", networkPluginName) } } else { allErrs = append(allErrs, fmt.Errorf("Network plugin %q not found.", networkPluginName)) } return chosenPlugin, utilerrors.NewAggregate(allErrs) }
func (f *ConfigFactory) getPluginArgs() (*PluginFactoryArgs, error) { for _, failureDomain := range f.failureDomains { if errs := utilvalidation.IsQualifiedName(failureDomain); len(errs) != 0 { return nil, fmt.Errorf("invalid failure domain: %q: %s", failureDomain, strings.Join(errs, ";")) } } return &PluginFactoryArgs{ PodLister: f.podLister, ServiceLister: f.serviceLister, ControllerLister: f.controllerLister, ReplicaSetLister: f.replicaSetLister, // All fit predicates only need to consider schedulable nodes. NodeLister: f.nodeLister.NodeCondition(getNodeConditionPredicate()), NodeInfo: &predicates.CachedNodeInfo{StoreToNodeLister: f.nodeLister}, PVInfo: f.pVLister, PVCInfo: &predicates.CachedPersistentVolumeClaimInfo{StoreToPersistentVolumeClaimLister: f.pVCLister}, HardPodAffinitySymmetricWeight: f.hardPodAffinitySymmetricWeight, FailureDomains: sets.NewString(f.failureDomains...).List(), }, nil }
func validateLabelKey(k string) error { if errs := validation.IsQualifiedName(k); len(errs) != 0 { return fmt.Errorf("invalid label key %q: %s", k, strings.Join(errs, "; ")) } return nil }