github.com/vmware/govmomi@v0.51.0/cli/folder/info.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package folder
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  	"io"
    12  	"strings"
    13  	"text/tabwriter"
    14  
    15  	"github.com/vmware/govmomi/cli"
    16  	"github.com/vmware/govmomi/cli/flags"
    17  	"github.com/vmware/govmomi/object"
    18  	"github.com/vmware/govmomi/property"
    19  	"github.com/vmware/govmomi/vim25/mo"
    20  	"github.com/vmware/govmomi/vim25/types"
    21  )
    22  
    23  type info struct {
    24  	*flags.ClientFlag
    25  	*flags.OutputFlag
    26  	*flags.DatacenterFlag
    27  }
    28  
    29  func init() {
    30  	cli.Register("folder.info", &info{})
    31  }
    32  
    33  func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
    34  	cmd.ClientFlag, ctx = flags.NewClientFlag(ctx)
    35  	cmd.ClientFlag.Register(ctx, f)
    36  
    37  	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
    38  	cmd.OutputFlag.Register(ctx, f)
    39  
    40  	cmd.DatacenterFlag, ctx = flags.NewDatacenterFlag(ctx)
    41  	cmd.DatacenterFlag.Register(ctx, f)
    42  }
    43  
    44  func (cmd *info) Process(ctx context.Context) error {
    45  	if err := cmd.ClientFlag.Process(ctx); err != nil {
    46  		return err
    47  	}
    48  	if err := cmd.OutputFlag.Process(ctx); err != nil {
    49  		return err
    50  	}
    51  	if err := cmd.DatacenterFlag.Process(ctx); err != nil {
    52  		return err
    53  	}
    54  	return nil
    55  }
    56  
    57  func (cmd *info) Usage() string {
    58  	return "[PATH]..."
    59  }
    60  
    61  func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
    62  	c, err := cmd.Client()
    63  	if err != nil {
    64  		return err
    65  	}
    66  
    67  	finder, err := cmd.Finder()
    68  	if err != nil {
    69  		return err
    70  	}
    71  
    72  	args := f.Args()
    73  	if len(args) == 0 {
    74  		args = []string{"/"}
    75  	}
    76  
    77  	var props []string
    78  	var res infoResult
    79  
    80  	if !cmd.OutputFlag.All() {
    81  		props = []string{
    82  			"name",
    83  			"childEntity",
    84  			"childType",
    85  		}
    86  	}
    87  
    88  	for _, arg := range args {
    89  		object, err := finder.FolderList(ctx, arg)
    90  		if err != nil {
    91  			return err
    92  		}
    93  		res.objects = append(res.objects, object...)
    94  	}
    95  
    96  	if len(res.objects) != 0 {
    97  		refs := make([]types.ManagedObjectReference, 0, len(res.objects))
    98  		for _, o := range res.objects {
    99  			refs = append(refs, o.Reference())
   100  		}
   101  
   102  		pc := property.DefaultCollector(c)
   103  		err = pc.Retrieve(ctx, refs, props, &res.Folders)
   104  		if err != nil {
   105  			return err
   106  		}
   107  	}
   108  
   109  	return cmd.WriteResult(&res)
   110  }
   111  
   112  type infoResult struct {
   113  	Folders []mo.Folder `json:"folders"`
   114  	objects []*object.Folder
   115  }
   116  
   117  func (r *infoResult) Write(w io.Writer) error {
   118  	// Maintain order via r.objects as Property collector does not always return results in order.
   119  	objects := make(map[types.ManagedObjectReference]mo.Folder, len(r.Folders))
   120  	for _, o := range r.Folders {
   121  		objects[o.Reference()] = o
   122  	}
   123  
   124  	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
   125  
   126  	for _, o := range r.objects {
   127  		info := objects[o.Reference()]
   128  		fmt.Fprintf(tw, "Name:\t%s\n", info.Name)
   129  		fmt.Fprintf(tw, "  Path:\t%s\n", o.InventoryPath)
   130  		fmt.Fprintf(tw, "  Types:\t%v\n", strings.Join(info.ChildType, ","))
   131  		fmt.Fprintf(tw, "  Children:\t%d\n", len(info.ChildEntity))
   132  	}
   133  
   134  	return tw.Flush()
   135  }