BASIS/decort-golang-sdk
9
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test git

Browse Source
This commit is contained in:
Алексей Фетисов
2026-06-19 17:34:28 +03:00
parent cd5d1c9d0b
commit b897b3447a
1513 changed files with 1 additions and 107093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
internal/constants/constants.go
View File

@@ -1,39 +0,0 @@
package constants
const (
RESTMACHINE = "/restmachine"
)
const (
MIMEJSON = "application/json"
MIMEHTML = "text/html"
MIMEXML = "application/xml"
MIMEXML2 = "text/xml"
MIMEPlain = "text/plain"
MIMEPOSTForm = "application/x-www-form-urlencoded"
MIMEMultipartPOSTForm = "multipart/form-data"
MIMEPROTOBUF = "application/x-protobuf"
MIMEMSGPACK = "application/x-msgpack"
MIMEMSGPACK2 = "application/msgpack"
MIMEYAML = "application/x-yaml"
MIMEYAML2 = "application/yaml"
MIMETOML = "application/toml"
MIMESTREAM = "application/octet-stream"
)
var FileName = map[string]string{
"OidcCertificate": "ca.crt",
}
var K8sValues = []string{"labels", "taints", "annotations, additionalSANs"}
var VersionMap = map[string]string{
"4.7.0": "-",
"4.6.0": "-",
"4.5.0": "-",
"4.4.0": "-",
"4.3.0": "-",
"4.2.0": "-",
"4.1.1": "-",
"4.1.0": "-",
}

41
internal/multierror/join.go
View File

@@ -1,41 +0,0 @@
package multierror
func Join(errs ...error) error {
n := 0
for _, err := range errs {
if err != nil {
n++
}
}
if n == 0 {
return nil
}
e := &joinError{
errs: make([]error, 0, n),
}
for _, err := range errs {
if err != nil {
e.errs = append(e.errs, err)
}
}
return e
}
type joinError struct {
errs []error
}
func (e *joinError) Error() string {
var b []byte
for i, err := range e.errs {
if i > 0 {
b = append(b, '\n')
}
b = append(b, err.Error()...)
}
return string(b)
}
func (e *joinError) Unwrap() []error {
return e.errs
}

18
internal/serialization/serialize.go
View File

@@ -1,18 +0,0 @@
package serialization
import (
"os"
)
type Writable interface {
WriteToFile(string) error
}
type Serialized []byte
// WriteToFile writes serialized data to specified file.
//
// Make sure to use .json extension for best compatibility.
func (s Serialized) WriteToFile(path string) error {
return os.WriteFile(path, s, 0600)
}

486
internal/validators/custom.go
View File

@@ -1,486 +0,0 @@
package validators
import (
"errors"
"fmt"
"net/url"
"reflect"
"regexp"
"strconv"
"strings"
"github.com/go-playground/validator/v10"
"repository.basistech.ru/BASIS/decort-golang-sdk/interfaces"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/multierror"
)
// protoValidator is used to validate Proto fields.
func protoValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, protoValues)
}
// apiGroupValidator is used to validate APIGroup fields
func apiGroupValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, apiGroupValues)
}
// accessTypeValidator is used to validate AccessType fields.
func accessTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, accessTypeValues)
}
// resTypesValidator is used to validate ResTypes fields.
func resTypesValidator(fe validator.FieldLevel) bool {
fieldSlice, ok := fe.Field().Interface().([]string)
if !ok {
return false
}
for _, value := range fieldSlice {
if !IsInSlice(value, resTypesValues) {
return false
}
}
return true
}
// accountCUTypeValidator is used to validate CUType field.
func accountCUTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, accountCUTypeValues)
}
// bserviceModeValidator is used to validate Mode field.
func bserviceModeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, bserviceModeValues)
}
// computeTopologyValidator is used to validate Topology field.
func computeTopologyValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeTopologyValues)
}
// computePolicyValidator is used to validate Policy field.
func computePolicyValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computePolicyValues)
}
// computeModeValidator is used to validate Mode field.
func computeModeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeModeValues)
}
// computeNetTypeValidator is used to validate NetType field.
func computeNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeNetTypeValues)
}
// computex86NetTypeValidator is used to validate NetType field.
func computex86NetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computex86NetTypeValues)
}
// securityGroupDirectionValidator is used to validate Direction field
func securityGroupDirectionValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, securityGroupDirectionValues)
}
// securityGroupEthertypeValidator is used to validate Ethertype field
func securityGroupEthertypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, securityGroupEthertypeValues)
}
// securityGroupProtocolValidator is used to validate Protocol field
func securityGroupProtocolValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, securityGroupProtocolValues)
}
// computeOrderValidator is used to validate Order field.
func computeOrderValidator(fe validator.FieldLevel) bool {
fieldSlice, ok := fe.Field().Interface().([]string)
if !ok {
return false
}
for _, value := range fieldSlice {
if !IsInSlice(value, computeOrderValues) {
return false
}
}
return true
}
// computeDataDisksValidator is used to validate DataDisks field.
func computeDataDisksValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeDataDisksValues)
}
// flipgroupClientTypeValidator is used to validate ClientType field.
func flipgroupClientTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, flipgroupClientTypeValues)
}
// massCreateTypeValidator is used to validate net type field when mass creating kvm
func massCreateTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, massCreateNetTypeValues)
}
// lbAlgorithmValidator is used to validate Algorithm field.
func lbAlgorithmValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, lbAlgorithmValues)
}
// rgDefNetValidator is used to validate DefNet field.
func rgDefNetValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, rgDefNetValues)
}
// rgNetTypeValidator is used to validate NetType field.
func rgNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, rgNetTypeValues)
}
// vinsTypeValidator is used to validate Type field.
func vinsTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, vinsTypeValues)
}
// imageBootTypeValidator is used to validate BootType field.
func imageBootTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageBootTypeValues)
}
// imageTypeValidator is used to validate ImageType field.
func imageTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageTypeValues)
}
// imageArchitectureValidator is used to validate Architecture field.
func imageArchitectureValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageArchitectureValues)
}
// sepFieldTypeValidator is used to validate FieldType field.
func sepFieldTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, sepFieldTypeValues)
}
// hwPathValidator is used to validate HWPath field.
func hwPathValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
ok, _ := regexp.MatchString(`^\b[0-9a-f]{4}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}.\d{1}$`, fieldValue)
return ok
}
// networkPluginValidator is used to validate NetworkPlugin field
func networkPluginValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, networkPluginValues)
}
// networkPluginsValidator is used to validate NetworkPlugins field
func networkPluginsValidator(fe validator.FieldLevel) bool {
fieldSlice, ok := fe.Field().Interface().([]string)
if !ok {
return false
}
for _, item := range fieldSlice {
item = strings.ToLower(item)
if !IsInSlice(item, networkPluginValues) {
return false
}
}
return true
}
func interfaceStateValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, interfaceStateValues)
}
func interfaceTXModelValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, txModelValues)
}
func interfaceIOEventFDValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, ioEventFDValues)
}
func interfaceEventIDxValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, eventIDxValues)
}
func strictLooseValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, strictLooseValues)
}
// name workerGroup must be more 3 symbol
func workerGroupNameValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
fieldValue = strings.Trim(fieldValue, " ")
return len(fieldValue) >= 3
}
func sortByValidator(fe validator.FieldLevel) bool {
sortByRegexp := regexp.MustCompile(`^[+-][a-zA-Z_]+`)
return sortByRegexp.MatchString(fe.Field().String())
}
func actionValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, actionValues)
}
func vmActionValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, vmActionValues)
}
func mtuValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().Uint()
return fieldValue >= uint64(mtuMin) && fieldValue <= uint64(mtuMax)
}
func computeFeaturesValidator(fe validator.FieldLevel) bool {
field := fe.Field()
slice, ok := field.Interface().([]string)
if !ok {
return false
}
return IsSubSlice(slice, computeFeaturesValues)
}
func networkInterfaceNamingValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, networkInterfaceNamingValues)
}
func numaAffinityValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, numaAffinityValues)
}
// kvmx86NetTypeValidator is used to validate NetType field for x86 compute.
func kvmx86NetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, kvmx86NetTypeValues)
}
func isBoolTypeValidator(fe validator.FieldLevel) bool {
return fe.Field().CanConvert(reflect.TypeOf(true))
}
func urlValidartor(fl validator.FieldLevel) bool {
fieldValues := fl.Field().String()
_, err := url.ParseRequestURI(fieldValues)
return err == nil
}
func chipsetValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, chipsetValues)
}
func preferredCPUValidator(fe validator.FieldLevel) bool {
fieldSlice, ok := fe.Field().Interface().([]int64)
if !ok {
return false
}
for _, value := range fieldSlice {
if value < -1 {
return false
}
}
return true
}
// loaderTypeValidator is used to validate loaderType fields
func loaderTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, loaderTypeValues)
}
// languageValidator is used to validate language fields
func languageValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, languageValues)
}
func userProviderValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, userProviders)
}
// sepTypeValidator is used to validate sepType fields
func sepTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, sepTypeValues)
}
// deviceValidator is used to validate extnet device fields
func deviceValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, deviceValues)
}
// ipTypesValidator is used to validate ip types version fields
func ipTypesValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, ipTypeValues)
}
// ValidateRAM checks if request contains RAM value that is positive integer divisible by divisibility passed.
// It is recommended to pass constants.RAM_DIVISIBILITY as divisility arguement
func ValidateRAM(r interfaces.RequestWithRAM, divisibility uint64) error {
if divisibility == 0 {
return errors.New("second argument of ValidateRAM should be greater than 0")
}
mapRAM := r.GetRAM()
errs := make([]error, 0, len(mapRAM))
for k, v := range mapRAM {
if v%divisibility != 0 {
errs = append(errs, fmt.Errorf("expected value of %s: \"%d\" should be divisible by %d", k, v, divisibility))
}
}
return multierror.Join(errs...)
}
// trunkTagsValidator checks if trunk_tags is in range from 1 to 4095
func trunkTagsValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
numFieldValue, err := strconv.ParseInt(fieldValue, 10, 64)
if err != nil {
return false
}
return uint64(numFieldValue) >= uint64(trunkTagsMin) && uint64(numFieldValue) <= uint64(trunkTagsMax)
}
// addressPoolNetTypeValidator is used to validate NetAddressType fields
func addressPoolNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, addressPoolNetTypeValues)
}
// sepTechStatusValidator is used to validate SepTechStatus fields
func sepTechStatusValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return IsInSlice(fieldValue, sepTechStatusValues)
}
// pciDeviceHWPathValidator is used to validate PCI device hardware path fields (e.g. 0000:81:00.0)
func pciDeviceHWPathValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
ok, _ := regexp.MatchString(`^[0-9a-fA-F]{4}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}\.[0-7]$`, fieldValue)
return ok
}
// sepNameValidator is used to validate SEP name fields
func sepNameValidator(fe validator.FieldLevel) bool {
ok, _ := regexp.MatchString(`^[a-zA-Zа-яА-ЯёЁ0-9][a-zA-Zа-яА-ЯёЁ0-9_.\[\]()\-]*$`, fe.Field().String())
return ok
}
// sepDescriptionValidator is used to validate SEP description fields
func sepDescriptionValidator(fe validator.FieldLevel) bool {
ok, _ := regexp.MatchString(`^[a-zA-Zа-яА-ЯёЁ0-9_.\[\]()\-]*$`, fe.Field().String())
return ok
}

53
internal/validators/helper.go
View File

@@ -1,53 +0,0 @@
package validators
import (
"errors"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/multierror"
"github.com/go-playground/validator/v10"
)
func ValidateRequest(req interface{}) error {
validate := getDecortValidator()
return validate.Struct(req)
}
func ValidateConfig(cfg interface{}) error {
validate := getDecortValidator()
return validate.Struct(cfg)
}
func ValidationError(fe validator.FieldError) error {
return errors.New(errorMessage(fe))
}
func ValidationErrors(fes []validator.FieldError) error {
errs := make([]error, 0, len(fes))
for _, fe := range fes {
errs = append(errs, ValidationError(fe))
}
return multierror.Join(errs...)
}
//nolint:errorlint
func GetErrors(err error) validator.ValidationErrors {
return err.(validator.ValidationErrors)
}
func IsInSlice(str string, target []string) bool {
for _, v := range target {
if v == str {
return true
}
}
return false
}
func IsSubSlice(source []string, target []string) bool {
for _, s := range source {
if !IsInSlice(s, target) {
return false
}
}
return true
}

369
internal/validators/messages.go
View File

@@ -1,369 +0,0 @@
package validators
import (
"fmt"
"strings"
"github.com/go-playground/validator/v10"
)
func errorMessage(fe validator.FieldError) string {
prefix := "validation-error:"
switch fe.Tag() {
// Common Validators
case "required":
return fmt.Sprintf("%s %s is required", prefix, fe.Field())
case "gt":
return fmt.Sprintf("%s %s can't be less or equal to zero", prefix, fe.Field())
case "min":
return fmt.Sprintf("%s %s: not enough elements", prefix, fe.Field())
case "max":
return fmt.Sprintf("%s %s: too many elements", prefix, fe.Field())
case "url":
return fmt.Sprintf("%s %s: unexpected URL format", prefix, fe.Field())
case "email":
return fmt.Sprintf("%s %s: unexpected E-Mail format", prefix, fe.Field())
case "isBool":
return fmt.Sprintf("%s %s: must be bool type", prefix, fe.Field())
case "accessType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(accessTypeValues))
case "resTypes":
return fmt.Sprintf("%s %s can contain only the following values: %s",
prefix,
fe.Field(),
joinValues(resTypesValues))
case "proto":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(protoValues))
// apiGroup Validators
case "apiGroup":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(apiGroupValues))
// Account Validators
case "accountCUType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(accountCUTypeValues))
// BService Validators
case "bserviceMode":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(bserviceModeValues))
// Compute Validators
case "computeTopology":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeTopologyValues))
case "computePolicy":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computePolicyValues))
case "computeMode":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeModeValues))
case "mtu":
return fmt.Sprint(prefix, fe.Field(), "must be ", mtuMin, "-", mtuMax)
case "preferredCPU":
return fmt.Sprint(prefix, fe.Field(), "must be equal to or greater than", -1)
case "computex86NetType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computex86NetTypeValues))
case "computeNetType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeNetTypeValues))
case "computeOrder":
return fmt.Sprintf("%s %s can contain only the following values: %s",
prefix,
fe.Field(),
joinValues(computeOrderValues))
case "computeDataDisks":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeDataDisksValues))
// Flipgroup Validators
case "flipgroupClientType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(flipgroupClientTypeValues))
// k8s Validators
case "workerGroupName":
return fmt.Sprintf("%s %s must be more 3 symbol",
prefix,
fe.Field())
// KVM_X86 Mass create validators
case "massCreateNetType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(massCreateNetTypeValues))
// LB Validators
case "lbAlgorithm":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(lbAlgorithmValues))
// RG Validators
case "rgDefNet":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(rgDefNetValues))
case "rgNetType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(rgNetTypeValues))
// ViNS Validators
case "vinsType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(vinsTypeValues))
// Image Validators
case "imageBootType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(imageBootTypeValues))
case "imageType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(imageTypeValues))
case "imageArchitecture":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(imageArchitectureValues))
// SEP Validators
case "sepFieldType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(sepFieldTypeValues))
// HWPath Validators
case "hwPath":
return fmt.Sprintf("%s %s must be in format 0000:1f:2b.0",
prefix,
fe.Field())
// Network plugin Validators
case "networkPlugin":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(networkPluginValues))
case "networkPlugins":
return fmt.Sprintf("%s %s must contain only the following: %s",
prefix,
fe.Field(),
joinValues(networkPluginValues))
case "strict_loose":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(strictLooseValues))
case "interfaceState":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(interfaceStateValues))
case "interfaceTXModel":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(txModelValues))
case "interfaceIOEventFD":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(ioEventFDValues))
case "interfaceEventIDx":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(eventIDxValues))
case "sortBy":
return fmt.Sprintf("%s %s must be in format +|-(field)",
prefix,
fe.Field())
case "action":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(actionValues))
case "vmaction":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(vmActionValues))
case "computeFeatures":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeFeaturesValues))
case "networkInterfaceNaming":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(networkInterfaceNamingValues))
case "numaAffinity":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(numaAffinityValues))
case "kvmx86NetType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(kvmx86NetTypeValues))
case "chipset":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(chipsetValues))
case "loaderType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(loaderTypeValues))
case "language":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(languageValues))
case "sepType":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(sepTypeValues))
// user validators
case "userProvider":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(userProviders))
// security group validators
case "securityGroupDirection":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(securityGroupDirectionValues))
case "securityGroupEthertype":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(securityGroupEthertypeValues))
case "securityGroupProtocol":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(securityGroupProtocolValues))
// trunk tags validator
case "trunkTags":
return fmt.Sprintf("%s %s must be in range from 1 to 4095",
prefix,
fe.Field())
// addressPoolNetTypeValidator validator
case "addressPoolNetTypeValidator":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(addressPoolNetTypeValues))
case "device":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(deviceValues))
case "ipTypes":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(ipTypeValues))
case "sepTechStatus":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(sepTechStatusValues))
}
return fe.Error()
}
func joinValues(values []string) string {
return strings.Join(values, ", ")
}

325
internal/validators/validator.go
View File

@@ -1,325 +0,0 @@
package validators
import (
"sync"
"github.com/go-playground/validator/v10"
)
var (
once sync.Once
decortValidator = validator.New()
)
// getDecortValidator returns singleton instance of DecortValidator.
func getDecortValidator() *validator.Validate {
once.Do(func() {
err := registerAllValidators(decortValidator)
if err != nil {
panic(err)
}
})
return decortValidator
}
// registerAllValidators registers all custom validators in DecortValidator.
func registerAllValidators(validate *validator.Validate) error {
err := validate.RegisterValidation("proto", protoValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("apiGroup", apiGroupValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("accessType", accessTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("resTypes", resTypesValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("imageBootType", imageBootTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("imageType", imageTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("imageArchitecture", imageArchitectureValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("accountCUType", accountCUTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("bserviceMode", bserviceModeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeTopology", computeTopologyValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computePolicy", computePolicyValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeMode", computeModeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeNetType", computeNetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computex86NetType", computex86NetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeOrder", computeOrderValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeDataDisks", computeDataDisksValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("flipgroupClientType", flipgroupClientTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("massCreateNetType", massCreateTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("lbAlgorithm", lbAlgorithmValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("rgDefNet", rgDefNetValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("rgNetType", rgNetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("vinsType", vinsTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sepFieldType", sepFieldTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("hwPath", hwPathValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("networkPlugin", networkPluginValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("networkPlugins", networkPluginsValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("strict_loose", strictLooseValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("interfaceState", interfaceStateValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("interfaceTXModel", interfaceTXModelValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("interfaceIOEventFD", interfaceIOEventFDValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("interfaceEventIDx", interfaceEventIDxValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("workerGroupName", workerGroupNameValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sortBy", sortByValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("action", actionValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("vmaction", vmActionValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("mtu", mtuValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeFeatures", computeFeaturesValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("networkInterfaceNaming", networkInterfaceNamingValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("numaAffinity", numaAffinityValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("kvmx86NetType", kvmx86NetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("isBool", isBoolTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("url", urlValidartor)
if err != nil {
return err
}
err = validate.RegisterValidation("chipset", chipsetValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("preferredCPU", preferredCPUValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("loaderType", loaderTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("language", languageValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("userProvider", userProviderValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sepType", sepTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("device", deviceValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("trunkTags", trunkTagsValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("securityGroupDirection", securityGroupDirectionValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("securityGroupEthertype", securityGroupEthertypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("securityGroupProtocol", securityGroupProtocolValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("addressPoolNetTypeValidator", addressPoolNetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("ipTypes", ipTypesValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sepTechStatus", sepTechStatusValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("pciDeviceHWPath", pciDeviceHWPathValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sepName", sepNameValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("sepDescription", sepDescriptionValidator)
if err != nil {
return err
}
return nil
}

91
internal/validators/values.go
View File

@@ -1,91 +0,0 @@
package validators
var (
apiGroupValues = []string{"cloudapi", "cloudbroker", "system"}
accessTypeValues = []string{"R", "RCX", "ARCXDU"}
resTypesValues = []string{"compute", "vins", "k8s", "openshift", "lb", "flipgroup"}
protoValues = []string{"tcp", "udp"}
accountCUTypeValues = []string{"CU_M", "CU_C", "CU_D", "CU_DM", "CU_I", "gpu_units"}
bserviceModeValues = []string{"ABSOLUTE", "RELATIVE"}
computeTopologyValues = []string{"compute", "node"}
computePolicyValues = []string{"RECOMMENDED", "REQUIRED"}
computeModeValues = []string{"EQ", "EN", "ANY"}
computeNetTypeValues = []string{"EXTNET", "VINS"}
computex86NetTypeValues = []string{"EXTNET", "VINS", "VFNIC", "DPDK", "SDN", "EMPTY", "TRUNK"}
computeOrderValues = []string{"cdrom", "network", "hd"}
computeDataDisksValues = []string{"KEEP", "DETACH", "DESTROY"}
flipgroupClientTypeValues = []string{"compute", "vins"}
massCreateNetTypeValues = []string{"EXTNET", "VINS", "TRUNK"}
kvmx86NetTypeValues = []string{"EXTNET", "VINS", "EMPTY", "VFNIC", "DPDK", "SDN", "TRUNK"}
lbAlgorithmValues = []string{"roundrobin", "static-rr", "leastconn"}
rgDefNetValues = []string{"PRIVATE", "PUBLIC", "NONE"}
rgNetTypeValues = []string{"PUBLIC", "PRIVATE"}
vinsTypeValues = []string{"DHCP", "VIP", "EXCLUDED"}
imageBootTypeValues = []string{"uefi", "bios"}
imageTypeValues = []string{"windows", "linux", "unknown"}
imageArchitectureValues = []string{"X86_64"}
sepFieldTypeValues = []string{"int", "str", "bool", "list", "dict"}
networkPluginValues = []string{"flannel", "weavenet", "calico"}
strictLooseValues = []string{"strict", "loose"}
interfaceStateValues = []string{"on", "off"}
actionValues = []string{"is_powered", "power_on", "shutdown", "force_shutdown", "reboot"}
vmActionValues = []string{"stop", "move"}
computeFeaturesValues = []string{"hugepages", "numa", "cpupin", "vfnic", "dpdk", "changemac", "trunk"}
networkInterfaceNamingValues = []string{"eth", "ens"}
numaAffinityValues = []string{"none", "strict", "loose"}
txModelValues = []string{"iothread", "timer", "selected by hypervisor"}
ioEventFDValues = []string{"on", "off", "selected by hypervisor"}
eventIDxValues = []string{"on", "off", "selected by hypervisor"}
chipsetValues = []string{"i440fx", "Q35"}
loaderTypeValues = []string{"linux", "windows", "unknown"}
sepTypeValues = []string{"hitachi", "dorado", "tatlin", "shared", "local", "des", "ustor"}
languageValues = []string{"ru", "en"}
userProviders = []string{"bvs", "decs3o"}
deviceValues = []string{"primary", "secondary"}
securityGroupDirectionValues = []string{"inbound", "outbound"}
securityGroupEthertypeValues = []string{"IPv4", "IPv6"}
securityGroupProtocolValues = []string{"icmp", "tcp", "udp"}
addressPoolNetTypeValues = []string{"IPv4", "IPv6", "MAC"}
ipTypeValues = []string{"v4, v6"}
sepTechStatusValues = []string{"ENABLED", "DISABLED"}
)
const (
mtuMin = 1500
mtuMax = 9216
trunkTagsMin = 1
trunkTagsMax = 4095
)