github.com/vmware/govmomi@v0.51.0/vim25/types/esxi_version.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 types
     6  
     7  import (
     8  	"fmt"
     9  	"regexp"
    10  	"strconv"
    11  )
    12  
    13  // ESXiVersion is an ESXi version.
    14  type ESXiVersion uint8
    15  
    16  const (
    17  	esxiVersionBegin ESXiVersion = iota
    18  
    19  	ESXi2000
    20  	ESXi3000
    21  	ESXi4000
    22  	ESXi5000
    23  	ESXi5100
    24  	ESXi5500
    25  	ESXi6000
    26  	ESXi6500
    27  	ESXi6700
    28  	ESXi6720
    29  	ESXi7000
    30  	ESXi7010
    31  	ESXi7020
    32  	ESXi8000
    33  	ESXi8010
    34  	ESXi8020
    35  
    36  	esxiVersionEnd
    37  )
    38  
    39  // HardwareVersion returns the maximum hardware version supported by this
    40  // version of ESXi, per https://knowledge.broadcom.com/external/article?articleNumber=315655.
    41  func (ev ESXiVersion) HardwareVersion() HardwareVersion {
    42  	switch ev {
    43  	case ESXi2000:
    44  		return VMX3
    45  	case ESXi3000:
    46  		return VMX4
    47  	case ESXi4000:
    48  		return VMX7
    49  	case ESXi5000:
    50  		return VMX8
    51  	case ESXi5100:
    52  		return VMX9
    53  	case ESXi5500:
    54  		return VMX10
    55  	case ESXi6000:
    56  		return VMX11
    57  	case ESXi6500:
    58  		return VMX13
    59  	case ESXi6700:
    60  		return VMX14
    61  	case ESXi6720:
    62  		return VMX15
    63  	case ESXi7000:
    64  		return VMX17
    65  	case ESXi7010:
    66  		return VMX18
    67  	case ESXi7020:
    68  		return VMX19
    69  	case ESXi8000, ESXi8010:
    70  		return VMX20
    71  	case ESXi8020:
    72  		return VMX21
    73  	}
    74  	return 0
    75  }
    76  
    77  // IsHardwareVersionSupported returns true if the provided hardware version is
    78  // supported by the given version of ESXi.
    79  func (ev ESXiVersion) IsHardwareVersionSupported(hv HardwareVersion) bool {
    80  	return hv <= ev.HardwareVersion()
    81  }
    82  
    83  func (ev ESXiVersion) IsValid() bool {
    84  	return ev.String() != ""
    85  }
    86  
    87  func (ev ESXiVersion) String() string {
    88  	switch ev {
    89  	case ESXi2000:
    90  		return "2"
    91  	case ESXi3000:
    92  		return "3"
    93  	case ESXi4000:
    94  		return "4"
    95  	case ESXi5000:
    96  		return "5.0"
    97  	case ESXi5100:
    98  		return "5.1"
    99  	case ESXi5500:
   100  		return "5.5"
   101  	case ESXi6000:
   102  		return "6.0"
   103  	case ESXi6500:
   104  		return "6.5"
   105  	case ESXi6700:
   106  		return "6.7"
   107  	case ESXi6720:
   108  		return "6.7.2"
   109  	case ESXi7000:
   110  		return "7.0"
   111  	case ESXi7010:
   112  		return "7.0.1"
   113  	case ESXi7020:
   114  		return "7.0.2"
   115  	case ESXi8000:
   116  		return "8.0"
   117  	case ESXi8010:
   118  		return "8.0.1"
   119  	case ESXi8020:
   120  		return "8.0.2"
   121  	}
   122  	return ""
   123  }
   124  
   125  func (ev ESXiVersion) MarshalText() ([]byte, error) {
   126  	return []byte(ev.String()), nil
   127  }
   128  
   129  func (ev *ESXiVersion) UnmarshalText(text []byte) error {
   130  	v, err := ParseESXiVersion(string(text))
   131  	if err != nil {
   132  		return err
   133  	}
   134  	*ev = v
   135  	return nil
   136  }
   137  
   138  // MustParseESXiVersion parses the provided string into an ESXi version.
   139  func MustParseESXiVersion(s string) ESXiVersion {
   140  	v, err := ParseESXiVersion(s)
   141  	if err != nil {
   142  		panic(err)
   143  	}
   144  	return v
   145  }
   146  
   147  var esxiRe = regexp.MustCompile(`(?i)^v?(\d)(?:\.(\d))?(?:\.(\d))?(?:\s*u(\d))?$`)
   148  
   149  // ParseESXiVersion parses the provided string into an ESXi version.
   150  func ParseESXiVersion(s string) (ESXiVersion, error) {
   151  	if m := esxiRe.FindStringSubmatch(s); len(m) > 0 {
   152  		var (
   153  			major  int64
   154  			minor  int64
   155  			patch  int64
   156  			update int64
   157  		)
   158  
   159  		major, _ = strconv.ParseInt(m[1], 0, 0)
   160  		if len(m) > 2 {
   161  			minor, _ = strconv.ParseInt(m[2], 0, 0)
   162  		}
   163  		if len(m) > 3 {
   164  			patch, _ = strconv.ParseInt(m[3], 0, 0)
   165  		}
   166  		if len(m) > 4 {
   167  			update, _ = strconv.ParseInt(m[4], 0, 0)
   168  		}
   169  
   170  		switch {
   171  		case major == 2 && minor == 0 && patch == 0 && update == 0:
   172  			return ESXi2000, nil
   173  		case major == 3 && minor == 0 && patch == 0 && update == 0:
   174  			return ESXi3000, nil
   175  		case major == 4 && minor == 0 && patch == 0 && update == 0:
   176  			return ESXi4000, nil
   177  		case major == 5 && minor == 0 && patch == 0 && update == 0:
   178  			return ESXi5000, nil
   179  		case major == 5 && minor == 1 && patch == 0 && update == 0:
   180  			return ESXi5100, nil
   181  		case major == 5 && minor == 5 && patch == 0 && update == 0:
   182  			return ESXi5500, nil
   183  		case major == 6 && minor == 0 && patch == 0 && update == 0:
   184  			return ESXi6000, nil
   185  		case major == 6 && minor == 5 && patch == 0 && update == 0:
   186  			return ESXi6500, nil
   187  		case major == 6 && minor == 7 && patch == 0 && update == 0:
   188  			return ESXi6700, nil
   189  		case major == 6 && minor == 7 && patch == 2 && update == 0,
   190  			major == 6 && minor == 7 && patch == 0 && update == 2:
   191  			return ESXi6720, nil
   192  		case major == 7 && minor == 0 && patch == 0 && update == 0:
   193  			return ESXi7000, nil
   194  		case major == 7 && minor == 0 && patch == 1 && update == 0,
   195  			major == 7 && minor == 0 && patch == 0 && update == 1:
   196  			return ESXi7010, nil
   197  		case major == 7 && minor == 0 && patch == 2 && update == 0,
   198  			major == 7 && minor == 0 && patch == 0 && update == 2:
   199  			return ESXi7020, nil
   200  		case major == 8 && minor == 0 && patch == 0 && update == 0:
   201  			return ESXi8000, nil
   202  		case major == 8 && minor == 0 && patch == 1 && update == 0,
   203  			major == 8 && minor == 0 && patch == 0 && update == 1:
   204  			return ESXi8010, nil
   205  		case major == 8 && minor == 0 && patch == 2 && update == 0,
   206  			major == 8 && minor == 0 && patch == 0 && update == 2:
   207  			return ESXi8020, nil
   208  		}
   209  	}
   210  
   211  	return 0, fmt.Errorf("invalid version: %q", s)
   212  }
   213  
   214  // GetESXiVersions returns a list of ESXi versions.
   215  func GetESXiVersions() []ESXiVersion {
   216  	dst := make([]ESXiVersion, esxiVersionEnd-1)
   217  	for i := esxiVersionBegin + 1; i < esxiVersionEnd; i++ {
   218  		dst[i-1] = i
   219  	}
   220  	return dst
   221  }