github.com/vmware/govmomi@v0.51.0/license/manager.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 license
     6  
     7  import (
     8  	"context"
     9  	"strconv"
    10  	"strings"
    11  
    12  	"github.com/vmware/govmomi/object"
    13  	"github.com/vmware/govmomi/vim25"
    14  	"github.com/vmware/govmomi/vim25/methods"
    15  	"github.com/vmware/govmomi/vim25/mo"
    16  	"github.com/vmware/govmomi/vim25/types"
    17  )
    18  
    19  type Manager struct {
    20  	object.Common
    21  }
    22  
    23  func NewManager(c *vim25.Client) *Manager {
    24  	m := Manager{
    25  		object.NewCommon(c, *c.ServiceContent.LicenseManager),
    26  	}
    27  
    28  	return &m
    29  }
    30  
    31  func mapToKeyValueSlice(m map[string]string) []types.KeyValue {
    32  	var r []types.KeyValue
    33  	for k, v := range m {
    34  		r = append(r, types.KeyValue{Key: k, Value: v})
    35  	}
    36  	return r
    37  }
    38  
    39  func (m Manager) Add(ctx context.Context, key string, labels map[string]string) (types.LicenseManagerLicenseInfo, error) {
    40  	req := types.AddLicense{
    41  		This:       m.Reference(),
    42  		LicenseKey: key,
    43  		Labels:     mapToKeyValueSlice(labels),
    44  	}
    45  
    46  	res, err := methods.AddLicense(ctx, m.Client(), &req)
    47  	if err != nil {
    48  		return types.LicenseManagerLicenseInfo{}, err
    49  	}
    50  
    51  	return res.Returnval, nil
    52  }
    53  
    54  func (m Manager) Decode(ctx context.Context, key string) (types.LicenseManagerLicenseInfo, error) {
    55  	req := types.DecodeLicense{
    56  		This:       m.Reference(),
    57  		LicenseKey: key,
    58  	}
    59  
    60  	res, err := methods.DecodeLicense(ctx, m.Client(), &req)
    61  	if err != nil {
    62  		return types.LicenseManagerLicenseInfo{}, err
    63  	}
    64  
    65  	return res.Returnval, nil
    66  }
    67  
    68  func (m Manager) Remove(ctx context.Context, key string) error {
    69  	req := types.RemoveLicense{
    70  		This:       m.Reference(),
    71  		LicenseKey: key,
    72  	}
    73  
    74  	_, err := methods.RemoveLicense(ctx, m.Client(), &req)
    75  	return err
    76  }
    77  
    78  func (m Manager) Update(ctx context.Context, key string, labels map[string]string) (types.LicenseManagerLicenseInfo, error) {
    79  	req := types.UpdateLicense{
    80  		This:       m.Reference(),
    81  		LicenseKey: key,
    82  		Labels:     mapToKeyValueSlice(labels),
    83  	}
    84  
    85  	res, err := methods.UpdateLicense(ctx, m.Client(), &req)
    86  	if err != nil {
    87  		return types.LicenseManagerLicenseInfo{}, err
    88  	}
    89  
    90  	return res.Returnval, nil
    91  }
    92  
    93  func (m Manager) List(ctx context.Context) (InfoList, error) {
    94  	var mlm mo.LicenseManager
    95  
    96  	err := m.Properties(ctx, m.Reference(), []string{"licenses"}, &mlm)
    97  	if err != nil {
    98  		return nil, err
    99  	}
   100  
   101  	return InfoList(mlm.Licenses), nil
   102  }
   103  
   104  func (m Manager) AssignmentManager(ctx context.Context) (*AssignmentManager, error) {
   105  	var mlm mo.LicenseManager
   106  
   107  	err := m.Properties(ctx, m.Reference(), []string{"licenseAssignmentManager"}, &mlm)
   108  	if err != nil {
   109  		return nil, err
   110  	}
   111  
   112  	if mlm.LicenseAssignmentManager == nil {
   113  		return nil, object.ErrNotSupported
   114  	}
   115  
   116  	am := AssignmentManager{
   117  		object.NewCommon(m.Client(), *mlm.LicenseAssignmentManager),
   118  	}
   119  
   120  	return &am, nil
   121  }
   122  
   123  type licenseFeature struct {
   124  	name  string
   125  	level int
   126  }
   127  
   128  func parseLicenseFeature(feature string) *licenseFeature {
   129  	lf := new(licenseFeature)
   130  
   131  	f := strings.Split(feature, ":")
   132  
   133  	lf.name = f[0]
   134  
   135  	if len(f) > 1 {
   136  		var err error
   137  		lf.level, err = strconv.Atoi(f[1])
   138  		if err != nil {
   139  			lf.name = feature
   140  		}
   141  	}
   142  
   143  	return lf
   144  }
   145  
   146  func HasFeature(license types.LicenseManagerLicenseInfo, key string) bool {
   147  	feature := parseLicenseFeature(key)
   148  
   149  	for _, p := range license.Properties {
   150  		if p.Key != "feature" {
   151  			continue
   152  		}
   153  
   154  		kv, ok := p.Value.(types.KeyValue)
   155  
   156  		if !ok {
   157  			continue
   158  		}
   159  
   160  		lf := parseLicenseFeature(kv.Key)
   161  
   162  		if lf.name == feature.name && lf.level >= feature.level {
   163  			return true
   164  		}
   165  	}
   166  
   167  	return false
   168  }
   169  
   170  // InfoList provides helper methods for []types.LicenseManagerLicenseInfo
   171  type InfoList []types.LicenseManagerLicenseInfo
   172  
   173  func (l InfoList) WithFeature(key string) InfoList {
   174  	var result InfoList
   175  
   176  	for _, license := range l {
   177  		if HasFeature(license, key) {
   178  			result = append(result, license)
   179  		}
   180  	}
   181  
   182  	return result
   183  }