// RunConvert implements the generic Convert command
func (o *ConvertOptions) RunConvert() error {
infos, err := o.builder.Do().Infos()
if err != nil {
return err
}
objects, err := resource.AsVersionedObject(infos, false, o.outputVersion)
if err != nil {
return err
}
return o.printer.PrintObj(objects, o.out)
}
func (d *Deployer) listHandler(request *restful.Request, response *restful.Response) {
var list runtime.Object
start := time.Now()
defer func() {
WriteAccessLog(start, request, response)
}()
mapper, typer := d.Factory.Object()
// request parameters
// namespace string # whether query between all-spaces
// outFormat string # format as json, yaml, etc.
// template string # whether use template to show result.
// kind string # resource kind for request.
// name string # resources name, multiple can separate by ,
// selector string # info selectors saved in etcd.
selector := request.QueryParameter("selector")
namespace := request.QueryParameter("namespace")
name := request.QueryParameter("name")
kind := request.PathParameter("kind")
template := request.QueryParameter("template")
if namespace == "" {
cmdNamespace, _, err := d.Factory.DefaultNamespace()
if err != nil {
message := fmt.Sprintf("get defaule namespace error %#v", err)
response.WriteAsJson(ApiResult{message, list, false})
return
}
namespace = cmdNamespace
}
var args = []string{kind}
if len(name) > 0 {
args = append(args, strings.Split(name, ",")...)
}
if len(kind) == 0 {
message := fmt.Sprintf("get resource kind unspecified")
response.WriteAsJson(ApiResult{message, list, false})
return
}
builder := resource.NewBuilder(mapper, typer, d.Factory.ClientMapperForCommand()).
NamespaceParam(namespace).DefaultNamespace().AllNamespaces(namespace == "all").
SelectorParam(selector).
ResourceTypeOrNameArgs(true, args...).
ContinueOnError().
Latest()
_, generic, err := PrinterForCommand("json", template)
if err != nil {
message := fmt.Sprintf("get resource kind unspecified: %#v", err)
response.WriteAsJson(ApiResult{message, list, false})
return
}
if generic {
clientConfig, err := d.Factory.ClientConfig()
if err != nil {
message := fmt.Sprintf("connect to API server failed: %#v", err)
response.WriteAsJson(ApiResult{message, list, false})
return
}
version := clientConfig.Version
singular := false
r := builder.Flatten().Do()
infos, err := r.IntoSingular(&singular).Infos()
if err != nil {
message := fmt.Sprintf("change into Singular failed: %#v", err)
response.WriteAsJson(ApiResult{message, list, false})
return
}
// the outermost object will be converted to the output-version, but inner
// objects can use their mappings
obj, err := resource.AsVersionedObject(infos, !singular, version)
if err != nil {
message := fmt.Sprintf("conversion object version failed: %#v", err)
response.WriteAsJson(ApiResult{message, list, false})
return
}
response.WriteAsJson(ApiResult{"", obj, true})
return
}
// use the default printer for each object
builder.Do().Visit(func(r *resource.Info) error {
_, err := d.PrinterForMapping("json", template, r.Mapping, namespace == "all")
if err != nil {
response.WriteAsJson(ApiResult{err.Error(), r.Object, false})
return err
}
response.WriteAsJson(ApiResult{"", r.Object, true})
return nil
})
}
// RunGet implements the generic Get command
// TODO: convert all direct flag accessors to a struct and pass that instead of cmd
func RunGet(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, options *GetOptions) error {
selector := cmdutil.GetFlagString(cmd, "selector")
allNamespaces := cmdutil.GetFlagBool(cmd, "all-namespaces")
mapper, typer := f.Object()
cmdNamespace, enforceNamespace, err := f.DefaultNamespace()
if err != nil {
return err
}
if len(args) == 0 && len(options.Filenames) == 0 {
fmt.Fprint(out, "You must specify the type of resource to get. ", valid_resources, ` * componentstatuses (aka 'cs')
* endpoints (aka 'ep')
`)
return cmdutil.UsageError(cmd, "Required resource not specified.")
}
// handle watch separately since we cannot watch multiple resource types
isWatch, isWatchOnly := cmdutil.GetFlagBool(cmd, "watch"), cmdutil.GetFlagBool(cmd, "watch-only")
if isWatch || isWatchOnly {
r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()).
NamespaceParam(cmdNamespace).DefaultNamespace().AllNamespaces(allNamespaces).
FilenameParam(enforceNamespace, options.Filenames...).
SelectorParam(selector).
ResourceTypeOrNameArgs(true, args...).
SingleResourceType().
Latest().
Do()
err := r.Err()
if err != nil {
return err
}
infos, err := r.Infos()
if err != nil {
return err
}
if len(infos) != 1 {
return fmt.Errorf("watch is only supported on individual resources and resource collections - %d resources were found", len(infos))
}
info := infos[0]
mapping := info.ResourceMapping()
printer, err := f.PrinterForMapping(cmd, mapping, allNamespaces)
if err != nil {
return err
}
obj, err := r.Object()
if err != nil {
return err
}
rv, err := mapping.MetadataAccessor.ResourceVersion(obj)
if err != nil {
return err
}
// print the current object
if !isWatchOnly {
if err := printer.PrintObj(obj, out); err != nil {
return fmt.Errorf("unable to output the provided object: %v", err)
}
}
// print watched changes
w, err := r.Watch(rv)
if err != nil {
return err
}
kubectl.WatchLoop(w, func(e watch.Event) error {
return printer.PrintObj(e.Object, out)
})
return nil
}
b := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()).
NamespaceParam(cmdNamespace).DefaultNamespace().AllNamespaces(allNamespaces).
FilenameParam(enforceNamespace, options.Filenames...).
SelectorParam(selector).
ResourceTypeOrNameArgs(true, args...).
ContinueOnError().
Latest()
printer, generic, err := cmdutil.PrinterForCommand(cmd)
if err != nil {
return err
}
if generic {
clientConfig, err := f.ClientConfig()
if err != nil {
return err
}
defaultVersion := clientConfig.Version
singular := false
r := b.Flatten().Do()
infos, err := r.IntoSingular(&singular).Infos()
if err != nil {
return err
}
// the outermost object will be converted to the output-version, but inner
// objects can use their mappings
version := cmdutil.OutputVersion(cmd, defaultVersion)
obj, err := resource.AsVersionedObject(infos, !singular, version)
if err != nil {
return err
}
return printer.PrintObj(obj, out)
}
// use the default printer for each object
printer = nil
var lastMapping *meta.RESTMapping
w := kubectl.GetNewTabWriter(out)
defer w.Flush()
return b.Flatten().Do().Visit(func(r *resource.Info, err error) error {
if err != nil {
return err
}
if printer == nil || lastMapping == nil || r.Mapping == nil || r.Mapping.Resource != lastMapping.Resource {
printer, err = f.PrinterForMapping(cmd, r.Mapping, allNamespaces)
if err != nil {
return err
}
lastMapping = r.Mapping
}
if _, found := printer.(*kubectl.HumanReadablePrinter); found {
return printer.PrintObj(r.Object, w)
}
return printer.PrintObj(r.Object, out)
})
}