github.com/vmware/govmomi@v0.51.0/cli/kms/key/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 key
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  	"io"
    12  	"strconv"
    13  	"text/tabwriter"
    14  
    15  	"github.com/vmware/govmomi/cli"
    16  	"github.com/vmware/govmomi/cli/flags"
    17  	"github.com/vmware/govmomi/crypto"
    18  	"github.com/vmware/govmomi/find"
    19  	"github.com/vmware/govmomi/vim25"
    20  	"github.com/vmware/govmomi/vim25/types"
    21  )
    22  
    23  type info struct {
    24  	*flags.ClientFlag
    25  	*flags.OutputFlag
    26  
    27  	provider string
    28  
    29  	avail, vms, hosts, other bool
    30  }
    31  
    32  func init() {
    33  	cli.Register("kms.key.info", &info{}, true)
    34  }
    35  
    36  func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
    37  	cmd.ClientFlag, ctx = flags.NewClientFlag(ctx)
    38  	cmd.ClientFlag.Register(ctx, f)
    39  	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
    40  	cmd.OutputFlag.Register(ctx, f)
    41  
    42  	f.StringVar(&cmd.provider, "p", "", "Provider ID")
    43  	f.BoolVar(&cmd.avail, "a", true, "Show key availability")
    44  	f.BoolVar(&cmd.vms, "vms", false, "Show VMs using keys")
    45  	f.BoolVar(&cmd.hosts, "hosts", false, "Show hosts using keys")
    46  	f.BoolVar(&cmd.other, "other", false, "Show 3rd party using keys")
    47  }
    48  
    49  func (cmd *info) Process(ctx context.Context) error {
    50  	if err := cmd.ClientFlag.Process(ctx); err != nil {
    51  		return err
    52  	}
    53  	return cmd.OutputFlag.Process(ctx)
    54  }
    55  
    56  func (cmd *info) Usage() string {
    57  	return "ID..."
    58  }
    59  
    60  func (cmd *info) Description() string {
    61  	return `Crypto key info.
    62  
    63  Examples:
    64    govc kms.key.info -p my-kp ID
    65    govc kms.key.info -p my-kp -vms ID`
    66  }
    67  
    68  type infoResult struct {
    69  	Status []types.CryptoManagerKmipCryptoKeyStatus `json:"status"`
    70  	ctx    context.Context
    71  	c      *vim25.Client
    72  }
    73  
    74  func (r *infoResult) writeObj(w io.Writer, refs []types.ManagedObjectReference) {
    75  	for _, ref := range refs {
    76  		p, err := find.InventoryPath(r.ctx, r.c, ref)
    77  		if err != nil {
    78  			p = ref.String()
    79  		}
    80  		fmt.Fprintf(w, "  %s\t%s\n", ref.Value, p)
    81  	}
    82  }
    83  
    84  func (r *infoResult) Write(w io.Writer) error {
    85  	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
    86  
    87  	for _, s := range r.Status {
    88  		avail := "-"
    89  		reason := s.Reason
    90  		if s.KeyAvailable != nil {
    91  			avail = strconv.FormatBool(*s.KeyAvailable)
    92  			if *s.KeyAvailable && reason == "" {
    93  				reason = "KeyStateAvailable"
    94  			}
    95  		}
    96  		pid := ""
    97  		if p := s.KeyId.ProviderId; p != nil {
    98  			pid = p.Id
    99  		}
   100  		fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n",
   101  			pid, s.KeyId.KeyId, avail, reason)
   102  		r.writeObj(tw, s.EncryptedVMs)
   103  		r.writeObj(tw, s.AffectedHosts)
   104  	}
   105  
   106  	return tw.Flush()
   107  }
   108  
   109  func argsToKeys(p string, args []string) []types.CryptoKeyId {
   110  	ids := make([]types.CryptoKeyId, len(args))
   111  
   112  	var provider *types.KeyProviderId
   113  
   114  	if p != "" {
   115  		provider = &types.KeyProviderId{Id: p}
   116  	}
   117  
   118  	for i, id := range args {
   119  		ids[i] = types.CryptoKeyId{
   120  			KeyId:      id,
   121  			ProviderId: provider,
   122  		}
   123  	}
   124  
   125  	return ids
   126  }
   127  
   128  func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
   129  	n := f.NArg()
   130  	if n == 0 {
   131  		return flag.ErrHelp
   132  	}
   133  
   134  	ids := argsToKeys(cmd.provider, f.Args())
   135  
   136  	c, err := cmd.Client()
   137  	if err != nil {
   138  		return err
   139  	}
   140  
   141  	m, err := crypto.GetManagerKmip(c)
   142  	if err != nil {
   143  		return err
   144  	}
   145  
   146  	check := int32(0)
   147  
   148  	opts := []struct {
   149  		enabled bool
   150  		val     int32
   151  	}{
   152  		{cmd.avail, crypto.CheckKeyAvailable},
   153  		{cmd.vms, crypto.CheckKeyUsedByVms},
   154  		{cmd.hosts, crypto.CheckKeyUsedByHosts},
   155  		{cmd.other, crypto.CheckKeyUsedByOther},
   156  	}
   157  
   158  	for _, opt := range opts {
   159  		if opt.enabled {
   160  			check = check | opt.val
   161  		}
   162  	}
   163  
   164  	res, err := m.QueryCryptoKeyStatus(ctx, ids, check)
   165  	if err != nil {
   166  		return err
   167  	}
   168  
   169  	return cmd.WriteResult(&infoResult{res, ctx, c})
   170  }