// Create attempts to create each item generically, gathering all errors in the // event a failure occurs. The contents of list will be updated to include the // version from the server. func (b *Bulk) Create(list *kapi.List, namespace string) []error { resourceMapper := &resource.Mapper{b.Typer, b.Mapper, resource.ClientMapperFunc(b.RESTClientFactory)} after := b.After if after == nil { after = func(*resource.Info, error) {} } errs := []error{} for i, item := range list.Items { info, err := resourceMapper.InfoForObject(item) if err != nil { errs = append(errs, err) after(info, err) continue } data, err := info.Mapping.Codec.Encode(item) if err != nil { errs = append(errs, err) after(info, err) continue } obj, err := resource.NewHelper(info.Client, info.Mapping).Create(namespace, false, data) if err != nil { errs = append(errs, err) after(info, err) continue } info.Refresh(obj, true) list.Items[i] = obj after(info, nil) } return errs }
func (n *NodeOptions) GetNodes() ([]*kapi.Node, error) { nameArgs := []string{"nodes"} if len(n.NodeNames) != 0 { nameArgs = append(nameArgs, n.NodeNames...) } r := resource.NewBuilder(n.Mapper, n.Typer, resource.ClientMapperFunc(n.RESTClientFactory)). ContinueOnError(). NamespaceParam(n.DefaultNamespace). SelectorParam(n.Selector). ResourceTypeOrNameArgs(true, nameArgs...). Flatten(). Do() if r.Err() != nil { return nil, r.Err() } errList := []error{} nodeList := []*kapi.Node{} _ = r.Visit(func(info *resource.Info) error { node, ok := info.Object.(*kapi.Node) if !ok { err := fmt.Errorf("cannot convert input to Node: ", reflect.TypeOf(info.Object)) errList = append(errList, err) // Don't bail out if one node fails return nil } nodeList = append(nodeList, node) return nil }) if len(errList) != 0 { return nodeList, kerrors.NewAggregate(errList) } if len(nodeList) == 0 { return nodeList, fmt.Errorf("No nodes found") } else { givenNodeNames := util.NewStringSet(n.NodeNames...) foundNodeNames := util.StringSet{} for _, node := range nodeList { foundNodeNames.Insert(node.ObjectMeta.Name) } skippedNodeNames := givenNodeNames.Difference(foundNodeNames) if skippedNodeNames.Len() > 0 { return nodeList, fmt.Errorf("Nodes %v not found", strings.Join(skippedNodeNames.List(), ", ")) } } return nodeList, nil }
func BuildGraph(path string) (osgraph.Graph, []runtime.Object, error) { g := osgraph.New() objs := []runtime.Object{} abspath, err := filepath.Abs(path) if err != nil { return g, objs, err } mapper := latest.RESTMapper typer := kapi.Scheme clientMapper := resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) { return nil, nil }) r := resource.NewBuilder(mapper, typer, clientMapper). FilenameParam(abspath). Flatten(). Do() if r.Err() != nil { return g, objs, r.Err() } infos, err := r.Infos() if err != nil { return g, objs, err } for _, info := range infos { objs = append(objs, info.Object) if err := EnsureNode(g, info.Object); err != nil { return g, objs, err } } return g, objs, nil }
// ClientMapperForCommand returns a ClientMapper for the factory. func (f *Factory) ClientMapperForCommand() resource.ClientMapper { return resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) { return f.RESTClient(mapping) }) }
func (v *VolumeOptions) RunVolume(args []string) error { b := resource.NewBuilder(v.Mapper, v.Typer, resource.ClientMapperFunc(v.RESTClientFactory)). ContinueOnError(). NamespaceParam(v.DefaultNamespace).DefaultNamespace(). FilenameParam(v.Filenames...). SelectorParam(v.Selector). ResourceTypeOrNameArgs(v.All, args...). Flatten() one := false infos, err := b.Do().IntoSingular(&one).Infos() if err != nil { return err } skipped := 0 for _, info := range infos { ok, err := v.UpdatePodSpecForObject(info.Object, func(spec *kapi.PodSpec) error { var e error switch { case v.Add: e = v.addVolumeToSpec(spec) case v.Remove: e = v.removeVolumeFromSpec(spec) case v.List: e = v.listVolumeForSpec(spec, info) } return e }) if !ok { skipped++ continue } if err != nil { fmt.Fprintf(v.Writer, "error: %s/%s %v\n", info.Mapping.Resource, info.Name, err) continue } } if one && skipped == len(infos) { return fmt.Errorf("the %s %s is not a pod or does not have a pod template", infos[0].Mapping.Resource, infos[0].Name) } if v.List { return nil } objects, err := resource.AsVersionedObject(infos, false, v.OutputVersion) if err != nil { return err } if len(v.Output) != 0 { p, _, err := kubectl.GetPrinter(v.Output, "") if err != nil { return err } return p.PrintObj(objects, v.Writer) } failed := false for _, info := range infos { data, err := info.Mapping.Codec.Encode(info.Object) if err != nil { fmt.Fprintf(v.Writer, "Error: %v\n", err) failed = true continue } obj, err := resource.NewHelper(info.Client, info.Mapping).Update(info.Namespace, info.Name, true, data) if err != nil { handlePodUpdateError(v.Writer, err, "volume") failed = true continue } info.Refresh(obj, true) fmt.Fprintf(v.Writer, "%s/%s\n", info.Mapping.Resource, info.Name) } if failed { return errExit } return nil }
// ClientMapperForCommand returns a ClientMapper for the given command and factory. func ClientMapperForCommand(cmd *cobra.Command, f *Factory) resource.ClientMapper { return resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) { return f.RESTClient(cmd, mapping) }) }
func OverwriteBootstrapPolicy(storage storage.Interface, policyFile, createBootstrapPolicyCommand string, change bool, out io.Writer) error { if !change { fmt.Fprintf(out, "Performing a dry run of policy overwrite:\n\n") } mapper := cmdclientcmd.ShortcutExpander{kubectl.ShortcutExpander{latest.RESTMapper}} typer := kapi.Scheme clientMapper := resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) { return nil, nil }) r := resource.NewBuilder(mapper, typer, clientMapper). FilenameParam(false, policyFile). Flatten(). Do() if r.Err() != nil { return r.Err() } policyRegistry := policyregistry.NewRegistry(policyetcd.NewStorage(storage)) policyBindingRegistry := policybindingregistry.NewRegistry(policybindingetcd.NewStorage(storage)) clusterPolicyRegistry := clusterpolicyregistry.NewRegistry(clusterpolicyetcd.NewStorage(storage)) clusterPolicyBindingRegistry := clusterpolicybindingregistry.NewRegistry(clusterpolicybindingetcd.NewStorage(storage)) roleRegistry := roleregistry.NewRegistry(rolestorage.NewVirtualStorage(policyRegistry)) roleBindingStorage := rolebindingstorage.NewVirtualStorage(policyRegistry, policyBindingRegistry, clusterPolicyRegistry, clusterPolicyBindingRegistry) clusterRoleStorage := clusterrolestorage.NewClusterRoleStorage(clusterPolicyRegistry) clusterRoleRegistry := clusterroleregistry.NewRegistry(clusterRoleStorage) clusterRoleBindingStorage := clusterrolebindingstorage.NewClusterRoleBindingStorage(clusterPolicyRegistry, clusterPolicyBindingRegistry) return r.Visit(func(info *resource.Info) error { template, ok := info.Object.(*templateapi.Template) if !ok { return errors.New("policy must be contained in a template. One can be created with '" + createBootstrapPolicyCommand + "'.") } runtime.DecodeList(template.Objects, kapi.Scheme) for _, item := range template.Objects { switch t := item.(type) { case *authorizationapi.Role: ctx := kapi.WithNamespace(kapi.NewContext(), t.Namespace) if change { roleRegistry.DeleteRole(ctx, t.Name) if _, err := roleRegistry.CreateRole(ctx, t); err != nil { return err } } else { fmt.Fprintf(out, "Overwrite role %s/%s\n", t.Namespace, t.Name) if s, err := describe.DescribeRole(t); err == nil { fmt.Fprintf(out, "%s\n", s) } } case *authorizationapi.RoleBinding: ctx := kapi.WithNamespace(kapi.NewContext(), t.Namespace) if change { roleBindingStorage.Delete(ctx, t.Name, nil) if _, err := roleBindingStorage.CreateRoleBindingWithEscalation(ctx, t); err != nil { return err } } else { fmt.Fprintf(out, "Overwrite role binding %s/%s\n", t.Namespace, t.Name) if s, err := describe.DescribeRoleBinding(t, nil, nil); err == nil { fmt.Fprintf(out, "%s\n", s) } } case *authorizationapi.ClusterRole: ctx := kapi.WithNamespace(kapi.NewContext(), t.Namespace) if change { clusterRoleRegistry.DeleteClusterRole(ctx, t.Name) if _, err := clusterRoleRegistry.CreateClusterRole(ctx, t); err != nil { return err } } else { fmt.Fprintf(out, "Overwrite role %s/%s\n", t.Namespace, t.Name) if s, err := describe.DescribeRole(authorizationapi.ToRole(t)); err == nil { fmt.Fprintf(out, "%s\n", s) } } case *authorizationapi.ClusterRoleBinding: ctx := kapi.WithNamespace(kapi.NewContext(), t.Namespace) if change { clusterRoleBindingStorage.Delete(ctx, t.Name, nil) if _, err := clusterRoleBindingStorage.CreateClusterRoleBindingWithEscalation(ctx, t); err != nil { return err } } else { fmt.Fprintf(out, "Overwrite role binding %s/%s\n", t.Namespace, t.Name) if s, err := describe.DescribeRoleBinding(authorizationapi.ToRoleBinding(t), nil, nil); err == nil { fmt.Fprintf(out, "%s\n", s) } } default: return errors.New("only roles and rolebindings may be created in this mode") } } if !change { fmt.Fprintf(out, "To make the changes described above, pass --force\n") } return nil }) }