github.com/vmware/govmomi@v0.51.0/cli/kms/ls.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 kms
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  	"io"
    12  	"os"
    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/vim25/types"
    19  )
    20  
    21  type ls struct {
    22  	*flags.ClientFlag
    23  	*flags.OutputFlag
    24  }
    25  
    26  func init() {
    27  	cli.Register("kms.ls", &ls{})
    28  }
    29  
    30  func (cmd *ls) Register(ctx context.Context, f *flag.FlagSet) {
    31  	cmd.ClientFlag, ctx = flags.NewClientFlag(ctx)
    32  	cmd.ClientFlag.Register(ctx, f)
    33  
    34  	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
    35  	cmd.OutputFlag.Register(ctx, f)
    36  }
    37  
    38  func (cmd *ls) Process(ctx context.Context) error {
    39  	if err := cmd.ClientFlag.Process(ctx); err != nil {
    40  		return err
    41  	}
    42  	return cmd.OutputFlag.Process(ctx)
    43  }
    44  
    45  func (cmd *ls) Usage() string {
    46  	return "NAME"
    47  }
    48  
    49  func (cmd *ls) Description() string {
    50  	return `Display KMS info.
    51  
    52  Examples:
    53    govc kms.ls
    54    govc kms.ls -json
    55    govc kms.ls - # default provider
    56    govc kms.ls ProviderName
    57    govc kms.ls -json ProviderName`
    58  }
    59  
    60  func (cmd *ls) Run(ctx context.Context, f *flag.FlagSet) error {
    61  	c, err := cmd.Client()
    62  	if err != nil {
    63  		return err
    64  	}
    65  
    66  	m, err := crypto.GetManagerKmip(c)
    67  	if err != nil {
    68  		return err
    69  	}
    70  
    71  	info, err := m.ListKmipServers(ctx, nil)
    72  	if err != nil {
    73  		return err
    74  	}
    75  
    76  	id := f.Arg(0)
    77  
    78  	if id == "" {
    79  		status, err := m.GetStatus(ctx, info...)
    80  		if err != nil {
    81  			return err
    82  		}
    83  		return cmd.WriteResult(&clusterResult{Info: info, Status: status})
    84  	}
    85  
    86  	if id == "-" {
    87  		for _, s := range info {
    88  			if s.UseAsDefault {
    89  				id = s.ClusterId.Id
    90  				break
    91  			}
    92  		}
    93  	}
    94  
    95  	status, err := m.GetClusterStatus(ctx, id)
    96  	if err != nil {
    97  		return err
    98  	}
    99  
   100  	format := &serverResult{Status: status}
   101  
   102  	for _, s := range info {
   103  		if s.ClusterId.Id == id {
   104  			format.Info = s
   105  		}
   106  	}
   107  
   108  	return cmd.WriteResult(format)
   109  }
   110  
   111  type serverResult struct {
   112  	Info   types.KmipClusterInfo                 `json:"info"`
   113  	Status *types.CryptoManagerKmipClusterStatus `json:"status"`
   114  }
   115  
   116  func (r *serverResult) status(name string) types.ManagedEntityStatus {
   117  	for _, server := range r.Status.Servers {
   118  		if server.Name == name {
   119  			return server.Status
   120  		}
   121  	}
   122  	return types.ManagedEntityStatusGray
   123  }
   124  
   125  func (r *serverResult) Write(w io.Writer) error {
   126  	tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
   127  
   128  	if r.Info.ManagementType == string(types.KmipClusterInfoKmsManagementTypeNativeProvider) {
   129  		boolVal := func(v *bool) bool {
   130  			if v == nil {
   131  				return false
   132  			}
   133  			return *v
   134  		}
   135  
   136  		fmt.Fprintf(tw, "Key ID: %s\tHas Backup: %t\tTPM Required: %t\n",
   137  			r.Info.KeyId, boolVal(r.Info.HasBackup), boolVal(r.Info.TpmRequired))
   138  	} else {
   139  		for _, s := range r.Info.Servers {
   140  			status := r.status(s.Name)
   141  			fmt.Fprintf(tw, "%s\t%s:%d\t%s\n", s.Name, s.Address, s.Port, status)
   142  		}
   143  	}
   144  
   145  	return tw.Flush()
   146  }
   147  
   148  type clusterResult struct {
   149  	Info   []types.KmipClusterInfo                `json:"info"`
   150  	Status []types.CryptoManagerKmipClusterStatus `json:"status"`
   151  }
   152  
   153  func (r *clusterResult) status(id types.KeyProviderId) types.ManagedEntityStatus {
   154  	for _, status := range r.Status {
   155  		if status.ClusterId == id {
   156  			return status.OverallStatus
   157  		}
   158  	}
   159  	return types.ManagedEntityStatusGray
   160  }
   161  
   162  func kmsType(kind string) string {
   163  	switch types.KmipClusterInfoKmsManagementType(kind) {
   164  	case types.KmipClusterInfoKmsManagementTypeVCenter:
   165  		return "Standard"
   166  	case types.KmipClusterInfoKmsManagementTypeNativeProvider:
   167  		return "Native"
   168  	default:
   169  		return kind
   170  	}
   171  }
   172  
   173  func (r *clusterResult) Write(w io.Writer) error {
   174  	tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
   175  
   176  	for _, info := range r.Info {
   177  		name := info.ClusterId.Id
   178  		kind := kmsType(info.ManagementType)
   179  		status := r.status(info.ClusterId)
   180  		use := ""
   181  		if info.UseAsDefault {
   182  			use = "default"
   183  		}
   184  		fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n", name, kind, status, use)
   185  	}
   186  
   187  	return tw.Flush()
   188  }