github.com/vmware/govmomi@v0.51.0/cli/cluster/rule/info_flag.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 rule
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  
    12  	"github.com/vmware/govmomi/cli/flags"
    13  	"github.com/vmware/govmomi/vim25/types"
    14  )
    15  
    16  type InfoFlag struct {
    17  	*flags.ClusterFlag
    18  
    19  	rules []types.BaseClusterRuleInfo
    20  
    21  	name string
    22  	Long bool
    23  }
    24  
    25  func NewInfoFlag(ctx context.Context) (*InfoFlag, context.Context) {
    26  	f := &InfoFlag{}
    27  	f.ClusterFlag, ctx = flags.NewClusterFlag(ctx)
    28  	return f, ctx
    29  }
    30  
    31  func (f *InfoFlag) Register(ctx context.Context, fs *flag.FlagSet) {
    32  	f.ClusterFlag.Register(ctx, fs)
    33  
    34  	fs.StringVar(&f.name, "name", "", "Cluster rule name")
    35  	fs.BoolVar(&f.Long, "l", false, "Long listing format")
    36  }
    37  
    38  func (f *InfoFlag) Process(ctx context.Context) error {
    39  	return f.ClusterFlag.Process(ctx)
    40  }
    41  
    42  func (f *InfoFlag) Rules(ctx context.Context) ([]types.BaseClusterRuleInfo, error) {
    43  	if f.rules != nil {
    44  		return f.rules, nil
    45  	}
    46  
    47  	cluster, err := f.Cluster()
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  
    52  	config, err := cluster.Configuration(ctx)
    53  	if err != nil {
    54  		return nil, err
    55  	}
    56  
    57  	f.rules = config.Rule
    58  
    59  	return f.rules, nil
    60  }
    61  
    62  type ClusterRuleInfo struct {
    63  	info types.BaseClusterRuleInfo
    64  
    65  	ruleType string
    66  
    67  	// only ClusterAffinityRuleSpec and ClusterAntiAffinityRuleSpec
    68  	refs *[]types.ManagedObjectReference
    69  
    70  	kind string
    71  
    72  	// only ClusterVmHostRuleInfo
    73  	vmGroupName             string
    74  	affineHostGroupName     string
    75  	antiAffineHostGroupName string
    76  
    77  	// only ClusterDependencyRuleInfo
    78  	VmGroup          string
    79  	DependsOnVmGroup string
    80  }
    81  
    82  func (f *InfoFlag) Rule(ctx context.Context) (*ClusterRuleInfo, error) {
    83  	rules, err := f.Rules(ctx)
    84  	if err != nil {
    85  		return nil, err
    86  	}
    87  
    88  	for _, rule := range rules {
    89  		if rule.GetClusterRuleInfo().Name != f.name {
    90  			continue
    91  		}
    92  
    93  		r := GetExtendedClusterRuleInfo(rule)
    94  		return &r, nil
    95  	}
    96  
    97  	return nil, fmt.Errorf("rule %q not found", f.name)
    98  }
    99  
   100  func GetExtendedClusterRuleInfo(rule types.BaseClusterRuleInfo) ClusterRuleInfo {
   101  	r := ClusterRuleInfo{info: rule}
   102  
   103  	switch info := rule.(type) {
   104  	case *types.ClusterAffinityRuleSpec:
   105  		r.ruleType = "ClusterAffinityRuleSpec"
   106  		r.refs = &info.Vm
   107  		r.kind = "VirtualMachine"
   108  	case *types.ClusterAntiAffinityRuleSpec:
   109  		r.ruleType = "ClusterAntiAffinityRuleSpec"
   110  		r.refs = &info.Vm
   111  		r.kind = "VirtualMachine"
   112  	case *types.ClusterVmHostRuleInfo:
   113  		r.ruleType = "ClusterVmHostRuleInfo"
   114  		r.vmGroupName = info.VmGroupName
   115  		r.affineHostGroupName = info.AffineHostGroupName
   116  		r.antiAffineHostGroupName = info.AntiAffineHostGroupName
   117  	case *types.ClusterDependencyRuleInfo:
   118  		r.ruleType = "ClusterDependencyRuleInfo"
   119  		r.VmGroup = info.VmGroup
   120  		r.DependsOnVmGroup = info.DependsOnVmGroup
   121  	}
   122  	return r
   123  }
   124  
   125  func (f *InfoFlag) Apply(ctx context.Context, update types.ArrayUpdateSpec, info types.BaseClusterRuleInfo) error {
   126  	spec := &types.ClusterConfigSpecEx{
   127  		RulesSpec: []types.ClusterRuleSpec{
   128  			{
   129  				ArrayUpdateSpec: update,
   130  				Info:            info,
   131  			},
   132  		},
   133  	}
   134  
   135  	return f.Reconfigure(ctx, spec)
   136  }
   137  
   138  type SpecFlag struct {
   139  	types.ClusterRuleInfo
   140  	types.ClusterVmHostRuleInfo
   141  	types.ClusterAffinityRuleSpec     //nolint:govet
   142  	types.ClusterAntiAffinityRuleSpec //nolint:govet
   143  }
   144  
   145  func (s *SpecFlag) Register(ctx context.Context, f *flag.FlagSet) {
   146  	f.Var(flags.NewOptionalBool(&s.Enabled), "enable", "Enable rule")
   147  	f.Var(flags.NewOptionalBool(&s.Mandatory), "mandatory", "Enforce rule compliance")
   148  
   149  	f.StringVar(&s.VmGroupName, "vm-group", "", "VM group name")
   150  	f.StringVar(&s.AffineHostGroupName, "host-affine-group", "", "Host affine group name")
   151  	f.StringVar(&s.AntiAffineHostGroupName, "host-anti-affine-group", "", "Host anti-affine group name")
   152  }