Compare commits

..

4 Commits

5
.gitignore vendored

@ -3,8 +3,3 @@ cmd/
.vscode/ .vscode/
.fleet/ .fleet/
.DS_Store .DS_Store
tests/platform_upgrade/.env
tests/platform_upgrade/input.json
tests/platform_upgrade/*.txt
tests/platform_upgrade/*.log
*.env

@ -1,75 +1,5 @@
## Version 1.12.3 ## Version 1.6.14
### Добавлено ### Bugfix
- Delete tag required from DeleteRequest field Permanently in cloudapi/k8s
#### account - Delete tag omitempty from DeleteDisksRequest and DisksDeleteRequest field Permanently in cloudapi/disks and cloudbroker/disks
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-606 | Поле `policies` в структуру ответа `Resource` в cloudapi/account и в cloudbroker/account |
#### compute
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-603 | Поле `OSVersion` в структуры ответа `RecordCompute` и `ItemCompute` в cloudapi/compute и `RecordCompute` и `InfoCompute` в cloudbroker/compute |
| BGOS-603 | Опциональное поле `OSVersion` в структуры запроса `RedeployRequest` и `UpdateRequest` в cloudapi/compute и cloudbroker/compute |
| BGOS-611 | Методы `StartMigrationIN`, `StopMigrationIN`, `MigrateStorageList` и структуры запросов `StartMigrationINRequest`, `StopMigrationINRequest` и `MigrateStorageListRequest` в cloudbroker/compute |
#### disks
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-609 | Опциональное поле `StoragePolicyID` в структуры запроса `ListUnattachedRequest` и `ListRequest` в cloudapi/disk и cloudbroker/disk |
#### kvmx86
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-603 | Опциональное поле `OSVersion` в структуры запроса `CreateRequest` и `CreateBlankRequest` в cloudapi/compute и cloudbroker/compute |
| BGOS-603 | Опциональное поле `OSVersion` в структуру запроса `MassCreateRequest` в cloudbroker/compute |
#### node
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-608 | Методы `AddSSHIdentity`, `GetSSHIdentity` и структуры запросов `AddSSHIdentityRequest` и `GetSSHIdentityRequest` в cloudbroker/node |
#### security group
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-601 | Добавлены комментарии к структурам ответов |
#### storage policy
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-598 | Поле `sep_name` в структуре ответа `AccessSEPPool` в cloudapi/stpolicy и в cloudbroker/stpolicy |
| BGOS-600 | Добавлены комментарии к структурам ответов |
### Исправлено
#### account
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-607 | Поле `StoragePolicies` в структуре запроса `CreateRequest` стало опциональным в cloudbroker/account |
| BGOS-607 | Изменен тип поля `ID` в структуре запроса `StoragePolicy` с int64 на uint64 в cloudbroker/account |
#### rg
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-607 | Изменен тип поля `ID` в структуре запроса `StoragePolicy` с int64 на uint64 в cloudapi/rg и в cloudbroker/rg |
| BGOS-607 | Поле `StoragePolicies` в структуре запроса `CreateRequest` стало опциональным в cloudbroker/account |
### Удалено
#### account
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-605 | Поле `CKey` из структуры ответа `RecordAccount` в cloudapi/account и поля `CKey` из структуры ответа `InfoAccount` и `Meta` из структуры ответа `ItemAccount` в cloudbroker/account |
#### compute
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-603 | Поля `VirtualImageID`, `VirtualImageName` из структуры ответа `RecordCompute` и `ItemCompute` в cloudapi/compute и `RecordCompute` и `InfoCompute` в cloudbroker/compute |
| BGOS-603 | Поля `ImageID` из структуры ответа `ItemCompute` в cloudapi/compute и `InfoCompute` в cloudbroker/compute |
| BGOS-612 | Поле `ImageID` из структуры запроса `ListRequest` в cloudbroker/compute |
#### image
| Идентификатор<br>задачи | Описание |
| --- | --- |
| BGOS-604 | Метод `UpdateNodes` и структура запроса `UpdateNodesRequest` в cloudbroker/image |

@ -186,7 +186,7 @@ APPENDIX: How to apply the Apache License to your work.
same "printed page" as the copyright notice for easier same "printed page" as the copyright notice for easier
identification within third-party archives. identification within third-party archives.
Copyright 2022 Basis LTD Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.

File diff suppressed because it is too large Load Diff

@ -0,0 +1,62 @@
# Decort SDK
Decort SDK is a library, written in GO (Golang) for interact with the **DECORT** API.
The library contents structures and methods for requesting to an user (cloudapi) and admin (cloudbroker) groups of API.
Also the library have structures for responses.
## Contents
- [Install](#install)
- [API List](#api-list)
- [Examples](#examples)
- [Examples2](#examples2)
## Install
```bash
go get -u repository.basistech.ru/BASIS/decort-golang-sdk
```
## API List
## Examples
```go
package main
import (
"context"
"fmt"
"log"
"repository.basistech.ru/BASIS/decort-golang-sdk/config"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/kvmx86"
)
func main() {
cfg := config.Config{
AppID: "<APPID>",
AppSecret: "<APPSECRET>",
SSOURL: "https://sso.digitalenergy.online",
DecortURL: "https://mr4.digitalenergy.online",
Retries: 5,
}
client := decort.New(cfg)
req := kvmx86.CreateRequest{
RGID: 123,
Name: "compute",
CPU: 4,
RAM: 4096,
ImageID: 321,
}
res, err := client.KVMX86().Create(context.Background(), req)
if err != nil {
log.Fatal(err)
}
fmt.Println(res)
}
```
## Examples2

@ -1,88 +0,0 @@
package decortsdk
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
)
type CheckInfo struct {
Version string `json:"version"`
Build uint64 `json:"build"`
}
const versionURL = "/system/info/version"
func (de DecortClient) Check() (*CheckInfo, error) {
res, err := de.DecortApiCall(context.Background(), http.MethodGet, versionURL, nil)
if err != nil {
return nil, err
}
info := CheckInfo{}
err = json.Unmarshal([]byte(strings.Replace(strings.Trim(string(res), `"`), "\\", "", -1)), &info)
if err != nil {
return nil, err
}
if v, ok := constants.VersionMap[info.Version]; ok {
if v == "-" {
return &info, nil
}
return nil, errors.New(fmt.Sprintf("SDK don't support platform version %s, please use %s SDK version", info.Version, v))
}
return nil, errors.New(fmt.Sprintf("platform version %s isn't supported", info.Version))
}
func (bvs BVSDecortClient) Check() (*CheckInfo, error) {
res, err := bvs.DecortApiCall(context.Background(), http.MethodGet, versionURL, nil)
if err != nil {
return nil, err
}
info := CheckInfo{}
err = json.Unmarshal([]byte(strings.Replace(strings.Trim(string(res), `"`), "\\", "", -1)), &info)
if err != nil {
return nil, err
}
if v, ok := constants.VersionMap[info.Version]; ok {
if v == "-" {
return &info, nil
}
return nil, errors.New(fmt.Sprintf("SDK don't support platform version %s, please use %s SDK version", info.Version, v))
}
return nil, errors.New(fmt.Sprintf("platform version %s isn't supported", info.Version))
}
func (ldc LegacyDecortClient) Check() (*CheckInfo, error) {
res, err := ldc.DecortApiCall(context.Background(), http.MethodGet, versionURL, nil)
if err != nil {
return nil, err
}
info := CheckInfo{}
err = json.Unmarshal([]byte(strings.Replace(strings.Trim(string(res), `"`), "\\", "", -1)), &info)
if err != nil {
return nil, err
}
if v, ok := constants.VersionMap[info.Version]; ok {
if v == "-" {
return &info, nil
}
return nil, errors.New(fmt.Sprintf("SDK don't support platform version %s, please use %s SDK version", info.Version, v))
}
return nil, errors.New(fmt.Sprintf("platform version %s isn't supported", info.Version))
}

@ -4,13 +4,10 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/tls" "crypto/tls"
"encoding/base64"
"encoding/json"
"fmt" "fmt"
"io" "io"
"mime/multipart" "mime/multipart"
"net/http" "net/http"
"reflect"
"strconv" "strconv"
"strings" "strings"
"sync" "sync"
@ -18,14 +15,13 @@ import (
"github.com/google/go-querystring/query" "github.com/google/go-querystring/query"
"repository.basistech.ru/BASIS/decort-golang-sdk/config" "repository.basistech.ru/BASIS/decort-golang-sdk/config"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi" "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi"
k8s_ca "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/k8s"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker" "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn" k8s_cb "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
) )
// DecortClient is HTTP-client for platform // HTTP-client for platform
type DecortClient struct { type DecortClient struct {
decortURL string decortURL string
client *http.Client client *http.Client
@ -40,6 +36,12 @@ func New(cfg config.Config) *DecortClient {
cfg.Retries = 5 cfg.Retries = 5
} }
var expiryTime time.Time
if cfg.Token != "" {
expiryTime = time.Now().AddDate(0, 0, 1)
}
return &DecortClient{ return &DecortClient{
decortURL: cfg.DecortURL, decortURL: cfg.DecortURL,
client: &http.Client{ client: &http.Client{
@ -50,8 +52,9 @@ func New(cfg config.Config) *DecortClient {
}, },
}, },
}, },
cfg: trimConfig(&cfg), cfg: cfg,
mutex: &sync.Mutex{}, expiryTime: expiryTime,
mutex: &sync.Mutex{},
} }
} }
@ -65,22 +68,17 @@ func (dc *DecortClient) CloudBroker() *cloudbroker.CloudBroker {
return cloudbroker.New(dc) return cloudbroker.New(dc)
} }
// SDN builder
func (dc *DecortClient) SDN() *sdn.SDN {
return sdn.New(dc)
}
// DecortApiCall method for sending requests to the platform // DecortApiCall method for sending requests to the platform
func (dc *DecortClient) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) { func (dc *DecortClient) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) {
k8sCaCreateReq, okCa := params.(k8s_ca.CreateRequest)
k8sCbCreateReq, okCb := params.(k8s_cb.CreateRequest)
var body *bytes.Buffer var body *bytes.Buffer
var ctype string var ctype string
byteSlice, ok := params.([]byte) if okCa {
if ok { body, ctype = createK8sCloudApi(k8sCaCreateReq)
body = bytes.NewBuffer(byteSlice) } else if okCb {
// ctype = "application/x-iso9660-image" body, ctype = createK8sCloudBroker(k8sCbCreateReq)
ctype = "application/octet-stream"
} else { } else {
values, err := query.Values(params) values, err := query.Values(params)
if err != nil { if err != nil {
@ -89,87 +87,18 @@ func (dc *DecortClient) DecortApiCall(ctx context.Context, method, url string, p
body = bytes.NewBufferString(values.Encode()) body = bytes.NewBufferString(values.Encode())
} }
req, err := http.NewRequestWithContext(ctx, method, dc.decortURL+constants.RESTMACHINE+url, body) req, err := http.NewRequestWithContext(ctx, method, dc.decortURL+"/restmachine"+url, body)
if err != nil {
return nil, err
}
// get token
if err = dc.getToken(ctx); err != nil {
return nil, err
}
// perform request
respBytes, err := dc.do(req, ctype)
if err != nil {
return nil, err
}
return respBytes, err
}
// DecortApiCallCtype method for sending requests to the platform with content type
func (dc *DecortClient) DecortApiCallCtype(ctx context.Context, method, url, ctype string, params interface{}) ([]byte, error) {
var body *bytes.Buffer
switch ctype {
case constants.MIMESTREAM:
body = bytes.NewBuffer(params.([]byte))
case constants.MIMEJSON:
jsonBody, err := json.Marshal(params)
if err != nil {
return nil, err
}
body = bytes.NewBuffer(jsonBody)
default:
ctype = constants.MIMEPOSTForm
values, err := query.Values(params)
if err != nil {
return nil, err
}
body = bytes.NewBufferString(values.Encode())
}
req, err := http.NewRequestWithContext(ctx, method, dc.decortURL+constants.RESTMACHINE+url, body)
if err != nil {
return nil, err
}
// get token
if err = dc.getToken(ctx); err != nil {
return nil, err
}
// perform request
respBytes, err := dc.do(req, ctype)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return respBytes, err
}
// DecortApiCallMP method for sending requests to the platform
func (dc *DecortClient) DecortApiCallMP(ctx context.Context, method, url string, params interface{}) ([]byte, error) {
body, ctype, err := multiPartReq(params)
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, method, dc.decortURL+constants.RESTMACHINE+url, body)
if err != nil {
return nil, err
}
// get token
if err = dc.getToken(ctx); err != nil { if err = dc.getToken(ctx); err != nil {
return nil, err return nil, err
} }
// perform request // perform request
respBytes, err := dc.do(req, ctype) var respBytes []byte
if err != nil { respBytes, err = dc.do(req, ctype)
return nil, err
}
return respBytes, err return respBytes, err
} }
@ -178,58 +107,41 @@ func (dc *DecortClient) getToken(ctx context.Context) error {
dc.mutex.Lock() dc.mutex.Lock()
defer dc.mutex.Unlock() defer dc.mutex.Unlock()
// new token is not needed if dc.cfg.Token == "" || time.Now().After(dc.expiryTime) {
if dc.cfg.Token != "" && !time.Now().After(dc.expiryTime) { body := fmt.Sprintf("grant_type=client_credentials&client_id=%s&client_secret=%s&response_type=id_token", dc.cfg.AppID, dc.cfg.AppSecret)
return nil bodyReader := strings.NewReader(body)
}
// set up request headers and body dc.cfg.SSOURL = strings.TrimSuffix(dc.cfg.SSOURL, "/")
body := fmt.Sprintf("grant_type=client_credentials&client_id=%s&client_secret=%s&response_type=id_token", dc.cfg.AppID, dc.cfg.AppSecret)
bodyReader := strings.NewReader(body)
dc.cfg.SSOURL = strings.TrimSuffix(dc.cfg.SSOURL, "/") req, _ := http.NewRequestWithContext(ctx, "POST", dc.cfg.SSOURL+"/v1/oauth/access_token", bodyReader)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
req, _ := http.NewRequestWithContext(ctx, "POST", dc.cfg.SSOURL+"/v1/oauth/access_token", bodyReader) resp, err := dc.client.Do(req)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded") if err != nil {
return fmt.Errorf("cannot get token: %w", err)
}
// request token tokenBytes, _ := io.ReadAll(resp.Body)
resp, err := dc.client.Do(req) resp.Body.Close()
if err != nil || resp == nil {
return fmt.Errorf("cannot get token: %w", err)
}
defer resp.Body.Close()
var tokenBytes []byte if resp.StatusCode != 200 {
tokenBytes, err = io.ReadAll(resp.Body) return fmt.Errorf("cannot get token: %s", tokenBytes)
if err != nil { }
return fmt.Errorf("cannot get token: %w", err)
}
if resp.StatusCode != 200 { token := string(tokenBytes)
return fmt.Errorf("cannot get token: %s", tokenBytes)
}
// save token in config dc.cfg.Token = token
token := string(tokenBytes) dc.expiryTime = time.Now().AddDate(0, 0, 1)
expiryTime, err := getTokenExp(token)
if err != nil {
return fmt.Errorf("cannot get expiry time: %w", err)
} }
dc.cfg.Token = token
dc.expiryTime = expiryTime
return nil return nil
} }
// do method performs request and returns response as an array of bytes and nil error in case of response status code 200.
// In any other cases do returns nil response and error.
// Retries are implemented in case of connection reset errors.
func (dc *DecortClient) do(req *http.Request, ctype string) ([]byte, error) { func (dc *DecortClient) do(req *http.Request, ctype string) ([]byte, error) {
// set up request headers and body
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
if ctype != "" { if ctype != "" {
req.Header.Set("Content-Type", ctype) req.Header.Add("Content-Type", ctype)
} else {
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
} }
req.Header.Add("Authorization", "bearer "+dc.cfg.Token) req.Header.Add("Authorization", "bearer "+dc.cfg.Token)
@ -240,52 +152,14 @@ func (dc *DecortClient) do(req *http.Request, ctype string) ([]byte, error) {
return nil, err return nil, err
} }
req.Body.Close()
req.Body = io.NopCloser(bytes.NewBuffer(buf)) req.Body = io.NopCloser(bytes.NewBuffer(buf))
resp, err := dc.client.Do(req) resp, err := dc.client.Do(req)
if resp != nil { if err != nil || resp == nil {
defer resp.Body.Close()
}
// retries logic GOES HERE
// get http response
//var resp *http.Response
//for i := uint64(0); i < dc.cfg.Retries; i++ {
// req := req.Clone(req.Context())
// req.Body = io.NopCloser(bytes.NewBuffer(buf))
//
// if i > 0 {
// time.Sleep(5 * time.Second) // no time sleep for the first request
// }
//
// resp, err = dc.client.Do(req)
//
// // stop retries on success and close response body
// if resp != nil {
// defer resp.Body.Close()
// }
// if err == nil {
// break
// }
//
// // retries in case of connection errors with time sleep
// if isConnectionError(err) {
// continue
// }
//
// // return error in case of non-connection error
// return nil, err
//}
// handle http request errors
if err != nil {
return nil, err return nil, err
} }
if resp == nil { defer resp.Body.Close()
return nil, fmt.Errorf("got empty response without error")
}
// handle successful request // handle successful request
respBytes, _ := io.ReadAll(resp.Body) respBytes, _ := io.ReadAll(resp.Body)
if resp.StatusCode == 200 { if resp.StatusCode == 200 {
@ -297,153 +171,230 @@ func (dc *DecortClient) do(req *http.Request, ctype string) ([]byte, error) {
return nil, fmt.Errorf("could not execute request: %w", err) return nil, fmt.Errorf("could not execute request: %w", err)
} }
// isConnectionError checks if given error falls within specific and associated connection errors func createK8sCloudApi(req k8s_ca.CreateRequest) (*bytes.Buffer, string) {
//func isConnectionError(err error) bool {
// if strings.Contains(err.Error(), "connection reset by peer") {
// return true
// }
// if errors.Is(err, io.EOF) {
// return true
// }
//
// return false
//}
// multiPartReq writes the request structure to the request body, and also returns string of the content-type
func multiPartReq(params interface{}) (*bytes.Buffer, string, error) {
reqBody := &bytes.Buffer{} reqBody := &bytes.Buffer{}
writer := multipart.NewWriter(reqBody) writer := multipart.NewWriter(reqBody)
values := reflect.ValueOf(params) if req.OidcCertificate != "" {
types := values.Type() part, _ := writer.CreateFormFile("oidcCertificate", "ca.crt")
defer writer.Close() _, _ = io.Copy(part, strings.NewReader(req.OidcCertificate))
for i := 0; i < values.NumField(); i++ { }
if !values.Field(i).IsValid() {
continue
}
if values.Field(i).IsZero() { _ = writer.WriteField("name", req.Name)
continue _ = writer.WriteField("rgId", strconv.FormatUint(req.RGID, 10))
} _ = writer.WriteField("k8ciId", strconv.FormatUint(req.K8SCIID, 10))
_ = writer.WriteField("workerGroupName", req.WorkerGroupName)
_ = writer.WriteField("networkPlugin", req.NetworkPlugin)
if file, ok := constants.FileName[types.Field(i).Name]; ok { if req.MasterSEPID != 0 {
part, err := writer.CreateFormFile(trimString(types.Field(i)), file) _ = writer.WriteField("masterSepId", strconv.FormatUint(req.MasterSEPID, 10))
if err != nil { }
return &bytes.Buffer{}, "", err if req.MasterSEPPool != "" {
} _ = writer.WriteField("masterSepPool", req.MasterSEPPool)
_, err = io.Copy(part, strings.NewReader(valueToString(values.Field(i).Interface()))) }
if err != nil { if req.WorkerSEPID != 0 {
return &bytes.Buffer{}, "", err _ = writer.WriteField("workerSepId", strconv.FormatUint(req.WorkerSEPID, 10))
} }
continue if req.WorkerSEPPool != "" {
} _ = writer.WriteField("workerSepPool", req.WorkerSEPPool)
}
if values.Field(i).Type().Kind() == reflect.Slice { if req.Labels != nil {
switch slice := values.Field(i).Interface().(type) { for _, v := range req.Labels {
case []string: _ = writer.WriteField("labels", v)
if validators.IsInSlice(trimString(types.Field(i)), constants.K8sValues) {
code, err := json.Marshal(slice)
if err != nil {
return &bytes.Buffer{}, "", err
}
err = writer.WriteField(trimString(types.Field(i)), string(code))
if err != nil {
return &bytes.Buffer{}, "", err
}
} else {
for _, val := range slice {
err := writer.WriteField(trimString(types.Field(i)), val)
if err != nil {
return &bytes.Buffer{}, "", err
}
}
}
case []uint:
for _, val := range slice {
err := writer.WriteField(trimString(types.Field(i)), strconv.FormatUint(uint64(val), 10))
if err != nil {
return &bytes.Buffer{}, "", err
}
}
case []uint64:
for _, val := range slice {
err := writer.WriteField(trimString(types.Field(i)), strconv.FormatUint(val, 10))
if err != nil {
return &bytes.Buffer{}, "", err
}
}
case []map[string]interface{}:
for _, val := range slice {
encodeStr, err := json.Marshal(val)
if err != nil {
return &bytes.Buffer{}, "", err
}
err = writer.WriteField(trimString(types.Field(i)), string(encodeStr))
if err != nil {
return &bytes.Buffer{}, "", err
}
}
default:
return &bytes.Buffer{}, "", fmt.Errorf("unsupported slice type:%T", slice)
}
continue
} }
}
if req.Taints != nil {
for _, v := range req.Taints {
_ = writer.WriteField("taints", v)
}
}
if req.Annotations != nil {
for _, v := range req.Annotations {
_ = writer.WriteField("annotations", v)
}
}
err := writer.WriteField(trimString(types.Field(i)), valueToString(values.Field(i).Interface())) if req.MasterCPU != 0 {
if err != nil { _ = writer.WriteField("masterCpu", strconv.FormatUint(uint64(req.MasterCPU), 10))
return &bytes.Buffer{}, "", err }
if req.MasterNum != 0 {
_ = writer.WriteField("masterNum", strconv.FormatUint(uint64(req.MasterNum), 10))
}
if req.MasterRAM != 0 {
_ = writer.WriteField("masterRam", strconv.FormatUint(uint64(req.MasterRAM), 10))
}
if req.MasterDisk != 0 {
_ = writer.WriteField("masterDisk", strconv.FormatUint(uint64(req.MasterDisk), 10))
}
if req.WorkerCPU != 0 {
_ = writer.WriteField("workerCpu", strconv.FormatUint(uint64(req.WorkerCPU), 10))
}
if req.WorkerNum != 0 {
_ = writer.WriteField("workerNum", strconv.FormatUint(uint64(req.WorkerNum), 10))
}
if req.WorkerRAM != 0 {
_ = writer.WriteField("workerRam", strconv.FormatUint(uint64(req.WorkerRAM), 10))
}
if req.WorkerDisk != 0 {
_ = writer.WriteField("workerDisk", strconv.FormatUint(uint64(req.WorkerDisk), 10))
}
if req.ExtNetID != 0 {
_ = writer.WriteField("extnetId", strconv.FormatUint(req.ExtNetID, 10))
}
if req.VinsId != 0 {
_ = writer.WriteField("vinsId", strconv.FormatUint(req.VinsId, 10))
}
if !req.WithLB {
_ = writer.WriteField("withLB", strconv.FormatBool(req.WithLB))
}
_ = writer.WriteField("highlyAvailableLB", strconv.FormatBool(req.HighlyAvailable))
if req.AdditionalSANs != nil {
for _, v := range req.AdditionalSANs {
_ = writer.WriteField("additionalSANs", v)
} }
} }
if req.InitConfiguration != "" {
_ = writer.WriteField("initConfiguration", req.InitConfiguration)
}
if req.ClusterConfiguration != "" {
_ = writer.WriteField("clusterConfiguration", req.ClusterConfiguration)
}
if req.KubeletConfiguration != "" {
_ = writer.WriteField("kubeletConfiguration", req.KubeletConfiguration)
}
if req.KubeProxyConfiguration != "" {
_ = writer.WriteField("kubeProxyConfiguration", req.KubeProxyConfiguration)
}
if req.JoinConfiguration != "" {
_ = writer.WriteField("joinConfiguration", req.JoinConfiguration)
}
if req.Description != "" {
_ = writer.WriteField("desc", req.Description)
}
if req.UserData != "" {
_ = writer.WriteField("userData", req.UserData)
}
_ = writer.WriteField("extnetOnly", strconv.FormatBool(req.ExtNetOnly))
ct := writer.FormDataContentType() ct := writer.FormDataContentType()
return reqBody, ct, nil writer.Close()
}
func valueToString(a any) string { return reqBody, ct
switch str := a.(type) {
case string:
return str
case uint:
return strconv.FormatUint(uint64(str), 10)
case uint64:
return strconv.FormatUint(str, 10)
case bool:
return strconv.FormatBool(str)
default:
return ""
}
} }
func trimString(el reflect.StructField) string { func createK8sCloudBroker(req k8s_cb.CreateRequest) (*bytes.Buffer, string) {
return strings.TrimSuffix(el.Tag.Get("url"), ",omitempty") reqBody := &bytes.Buffer{}
} writer := multipart.NewWriter(reqBody)
if req.OidcCertificate != "" {
part, _ := writer.CreateFormFile("oidcCertificate", "ca.crt")
_, _ = io.Copy(part, strings.NewReader(req.OidcCertificate))
}
func trimConfig(cfg *config.Config) config.Config { _ = writer.WriteField("name", req.Name)
cfg.SSOURL = strings.TrimSuffix(cfg.SSOURL, "/") _ = writer.WriteField("rgId", strconv.FormatUint(req.RGID, 10))
cfg.DecortURL = strings.TrimSuffix(cfg.DecortURL, "/") _ = writer.WriteField("k8ciId", strconv.FormatUint(req.K8CIID, 10))
return *cfg _ = writer.WriteField("workerGroupName", req.WorkerGroupName)
} _ = writer.WriteField("networkPlugin", req.NetworkPlugin)
func getTokenExp(token string) (time.Time, error) { if req.MasterSEPID != 0 {
parts := strings.Split(token, ".") _ = writer.WriteField("masterSepId", strconv.FormatUint(req.MasterSEPID, 10))
if len(parts) != 3 { }
return time.Time{}, fmt.Errorf("invalid token format") if req.MasterSEPPool != "" {
_ = writer.WriteField("masterSepPool", req.MasterSEPPool)
}
if req.WorkerSEPID != 0 {
_ = writer.WriteField("workerSepId", strconv.FormatUint(req.WorkerSEPID, 10))
}
if req.WorkerSEPPool != "" {
_ = writer.WriteField("workerSepPool", req.WorkerSEPPool)
} }
payload, err := base64.RawURLEncoding.DecodeString(parts[1]) if req.Labels != nil {
if err != nil { for _, v := range req.Labels {
return time.Time{}, fmt.Errorf("error decode payload from token: %w", err) _ = writer.WriteField("labels", v)
}
}
if req.Taints != nil {
for _, v := range req.Taints {
_ = writer.WriteField("taints", v)
}
}
if req.Annotations != nil {
for _, v := range req.Annotations {
_ = writer.WriteField("annotations", v)
}
} }
var claims map[string]interface{} if req.MasterCPU != 0 {
if err := json.Unmarshal(payload, &claims); err != nil { _ = writer.WriteField("masterCpu", strconv.FormatUint(req.MasterCPU, 10))
return time.Time{}, err }
if req.MasterNum != 0 {
_ = writer.WriteField("masterNum", strconv.FormatUint(req.MasterNum, 10))
}
if req.MasterRAM != 0 {
_ = writer.WriteField("masterRam", strconv.FormatUint(req.MasterRAM, 10))
}
if req.MasterDisk != 0 {
_ = writer.WriteField("masterDisk", strconv.FormatUint(req.MasterDisk, 10))
}
if req.WorkerCPU != 0 {
_ = writer.WriteField("workerCpu", strconv.FormatUint(req.WorkerCPU, 10))
}
if req.WorkerNum != 0 {
_ = writer.WriteField("workerNum", strconv.FormatUint(req.WorkerNum, 10))
}
if req.WorkerRAM != 0 {
_ = writer.WriteField("workerRam", strconv.FormatUint(req.WorkerRAM, 10))
}
if req.WorkerDisk != 0 {
_ = writer.WriteField("workerDisk", strconv.FormatUint(req.WorkerDisk, 10))
}
if req.ExtNetID != 0 {
_ = writer.WriteField("extnetId", strconv.FormatUint(req.ExtNetID, 10))
}
if req.VinsId != 0 {
_ = writer.WriteField("vinsId", strconv.FormatUint(req.VinsId, 10))
}
if !req.WithLB {
_ = writer.WriteField("withLB", strconv.FormatBool(req.WithLB))
} }
exp, ok := claims["exp"] _ = writer.WriteField("highlyAvailableLB", strconv.FormatBool(req.HighlyAvailable))
if !ok {
return time.Time{}, fmt.Errorf("exp time bot found") if req.AdditionalSANs != nil {
for _, v := range req.AdditionalSANs {
_ = writer.WriteField("additionalSANs", v)
}
}
if req.InitConfiguration != "" {
_ = writer.WriteField("initConfiguration", req.InitConfiguration)
}
if req.ClusterConfiguration != "" {
_ = writer.WriteField("clusterConfiguration", req.ClusterConfiguration)
}
if req.KubeletConfiguration != "" {
_ = writer.WriteField("kubeletConfiguration", req.KubeletConfiguration)
}
if req.KubeProxyConfiguration != "" {
_ = writer.WriteField("kubeProxyConfiguration", req.KubeProxyConfiguration)
}
if req.JoinConfiguration != "" {
_ = writer.WriteField("joinConfiguration", req.JoinConfiguration)
}
if req.Description != "" {
_ = writer.WriteField("desc", req.Description)
}
if req.UserData != "" {
_ = writer.WriteField("userData", req.UserData)
} }
expTime := time.Unix(int64(exp.(float64)), 0) _ = writer.WriteField("extnetOnly", strconv.FormatBool(req.ExtNetOnly))
ct := writer.FormDataContentType()
return expTime, nil writer.Close()
return reqBody, ct
} }

@ -1,461 +0,0 @@
package decortsdk
import (
"bytes"
"context"
"crypto/tls"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strings"
"sync"
"time"
"github.com/google/go-querystring/query"
"repository.basistech.ru/BASIS/decort-golang-sdk/config"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker"
)
// BVSDecortClient is HTTP-client for platform
type BVSDecortClient struct {
client *http.Client
cfg config.BVSConfig
mutex *sync.Mutex
decortURL string
}
type tokenJSON struct {
AccessToken string `json:"access_token"`
TokenType string `json:"token_type"`
RefreshToken string `json:"refresh_token"`
ExpiresIn uint64 `json:"expires_in"`
}
// Сlient builder
func NewBVS(cfg config.BVSConfig) *BVSDecortClient {
if cfg.Retries == 0 {
cfg.Retries = 5
}
if cfg.TimeToRefresh == 0 {
cfg.TimeToRefresh = 1
}
return &BVSDecortClient{
decortURL: cfg.DecortURL,
client: &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
//nolint:gosec
InsecureSkipVerify: cfg.SSLSkipVerify,
},
},
},
cfg: trimBVSConfig(&cfg),
mutex: &sync.Mutex{},
}
}
// CloudAPI builder
func (bdc *BVSDecortClient) CloudAPI() *cloudapi.CloudAPI {
return cloudapi.New(bdc)
}
// CloudBroker builder
func (bdc *BVSDecortClient) CloudBroker() *cloudbroker.CloudBroker {
return cloudbroker.New(bdc)
}
// DecortApiCall method for sending requests to the platform
func (bdc *BVSDecortClient) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) {
var body *bytes.Buffer
var ctype string
byteSlice, ok := params.([]byte)
if ok {
body = bytes.NewBuffer(byteSlice)
// ctype = "application/x-iso9660-image"
ctype = "application/octet-stream"
} else {
values, err := query.Values(params)
if err != nil {
return nil, err
}
body = bytes.NewBufferString(values.Encode())
}
req, err := http.NewRequestWithContext(ctx, method, bdc.decortURL+constants.RESTMACHINE+url, body)
if err != nil {
return nil, err
}
// get token
if bdc.cfg.Token.AccessToken == "" {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
// refresh token
if bdc.cfg.Token.RefreshToken != "" && bdc.cfg.Token.Expiry.Add(-time.Duration(bdc.cfg.TimeToRefresh)*time.Minute).Before(time.Now()) {
if _, err := bdc.RefreshToken(ctx); err != nil {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
}
// perform request
reqCopy := req.Clone(ctx)
respBytes, err := bdc.do(req, ctype)
if err == nil {
return respBytes, nil
}
// get token and retry in case of access denied
if err.Error() == "access is denied" {
_, err = bdc.GetToken(ctx)
if err != nil {
return nil, err
}
respBytes, err = bdc.do(reqCopy, "")
if err != nil {
return nil, err
}
}
return respBytes, err
}
// DecortApiCallCtype method for sending requests to the platform with content type
func (bdc *BVSDecortClient) DecortApiCallCtype(ctx context.Context, method, url, ctype string, params interface{}) ([]byte, error) {
var body *bytes.Buffer
switch ctype {
case constants.MIMESTREAM:
body = bytes.NewBuffer(params.([]byte))
case constants.MIMEJSON:
jsonBody, err := json.Marshal(params)
if err != nil {
return nil, err
}
body = bytes.NewBuffer(jsonBody)
default:
ctype = constants.MIMEPOSTForm
values, err := query.Values(params)
if err != nil {
return nil, err
}
body = bytes.NewBufferString(values.Encode())
}
req, err := http.NewRequestWithContext(ctx, method, bdc.decortURL+constants.RESTMACHINE+url, body)
if err != nil {
return nil, err
}
// get token
if bdc.cfg.Token.AccessToken == "" {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
// refresh token
if bdc.cfg.Token.RefreshToken != "" && bdc.cfg.Token.Expiry.Add(-time.Duration(bdc.cfg.TimeToRefresh)*time.Minute).Before(time.Now()) {
if _, err := bdc.RefreshToken(ctx); err != nil {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
}
// perform request
reqCopy := req.Clone(ctx)
respBytes, err := bdc.do(req, ctype)
if err == nil {
return respBytes, nil
}
// get token and retry in case of access denied
if err.Error() == "access is denied" {
_, err = bdc.GetToken(ctx)
if err != nil {
return nil, err
}
respBytes, err = bdc.do(reqCopy, "")
if err != nil {
return nil, err
}
}
return respBytes, err
}
func (bdc *BVSDecortClient) DecortApiCallMP(ctx context.Context, method, url string, params interface{}) ([]byte, error) {
body, ctype, err := multiPartReq(params)
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, method, bdc.decortURL+constants.RESTMACHINE+url, body)
if err != nil {
return nil, err
}
// get token
if bdc.cfg.Token.AccessToken == "" {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
// refresh token
if bdc.cfg.Token.RefreshToken != "" && bdc.cfg.Token.Expiry.Add(-time.Duration(bdc.cfg.TimeToRefresh)*time.Minute).Before(time.Now()) {
if _, err := bdc.RefreshToken(ctx); err != nil {
if _, err = bdc.GetToken(ctx); err != nil {
return nil, err
}
}
}
// perform request
reqCopy := req.Clone(ctx)
respBytes, err := bdc.do(req, ctype)
if err == nil {
return respBytes, nil
}
// get token and retry in case of access denied
if err.Error() == "access is denied" {
_, err = bdc.GetToken(ctx)
if err != nil {
return nil, err
}
respBytes, err = bdc.do(reqCopy, ctype)
if err != nil {
return nil, err
}
}
return respBytes, err
}
// GetToken allows you to get a token and returns the token structure. When specifying the PathCfg variable,
// the token and configuration will be written to a file.
// When specifying the PathToken variable, the token will be written to a file.
func (bdc *BVSDecortClient) GetToken(ctx context.Context) (config.Token, error) {
bdc.mutex.Lock()
defer bdc.mutex.Unlock()
// set up request headers and body
body := fmt.Sprintf("grant_type=password&client_id=%s&client_secret=%s&username=%s&password=%s&response_type=token&scope=openid", bdc.cfg.AppID, bdc.cfg.AppSecret, bdc.cfg.Username, bdc.cfg.Password)
bodyReader := strings.NewReader(body)
bdc.cfg.SSOURL = strings.TrimSuffix(bdc.cfg.SSOURL, "/")
req, _ := http.NewRequestWithContext(ctx, "POST", bdc.cfg.SSOURL+"/realms/"+bdc.cfg.Domain+"/protocol/openid-connect/token", bodyReader)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
// request token
resp, err := bdc.client.Do(req)
if err != nil || resp == nil {
return config.Token{}, fmt.Errorf("cannot get token: %w", err)
}
defer resp.Body.Close()
var tokenBytes []byte
tokenBytes, err = io.ReadAll(resp.Body)
if err != nil {
return config.Token{}, fmt.Errorf("cannot get token: %w", err)
}
if resp.StatusCode != 200 {
return config.Token{}, fmt.Errorf("cannot get token: %s", tokenBytes)
}
// save token in config
var tj tokenJSON
if err = json.Unmarshal(tokenBytes, &tj); err != nil {
return config.Token{}, fmt.Errorf("cannot unmarshal token: %w", err)
}
bdc.cfg.Token = config.Token{
AccessToken: tj.AccessToken,
TokenType: tj.TokenType,
RefreshToken: tj.RefreshToken,
Expiry: tj.expiry(),
}
if bdc.cfg.PathCfg != "" {
ser, _ := bdc.cfg.Serialize("", " ")
_ = ser.WriteToFile(bdc.cfg.PathCfg)
}
if bdc.cfg.PathToken != "" {
ser, _ := bdc.cfg.Token.Serialize("", " ")
_ = ser.WriteToFile(bdc.cfg.PathToken)
}
return bdc.cfg.Token, nil
}
// RefreshToken allows you to refresh a token and returns the token structure. When specifying the PathCfg variable,
// the token and configuration will be written to a file.
// When specifying the PathToken variable, the token will be written to a file
func (bdc *BVSDecortClient) RefreshToken(ctx context.Context) (config.Token, error) {
bdc.mutex.Lock()
defer bdc.mutex.Unlock()
// set up request headers and body
body := fmt.Sprintf("grant_type=refresh_token&client_id=%s&client_secret=%s&refresh_token=%s&scope=openid", bdc.cfg.AppID, bdc.cfg.AppSecret, bdc.cfg.Token.RefreshToken)
bodyReader := strings.NewReader(body)
bdc.cfg.SSOURL = strings.TrimSuffix(bdc.cfg.SSOURL, "/")
req, _ := http.NewRequestWithContext(ctx, "POST", bdc.cfg.SSOURL+"/realms/"+bdc.cfg.Domain+"/protocol/openid-connect/token", bodyReader)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
// refresh token
resp, err := bdc.client.Do(req)
if err != nil || resp == nil {
return config.Token{}, fmt.Errorf("cannot refresh token: %w", err)
}
defer resp.Body.Close()
var tokenBytes []byte
tokenBytes, err = io.ReadAll(resp.Body)
if err != nil {
return config.Token{}, fmt.Errorf("cannot refresh token: %w", err)
}
if resp.StatusCode != 200 {
return config.Token{}, fmt.Errorf("cannot refresh token: %s", tokenBytes)
}
// save token in config
var tj tokenJSON
if err = json.Unmarshal(tokenBytes, &tj); err != nil {
return config.Token{}, fmt.Errorf("cannot unmarshal after refresh token: %w", err)
}
bdc.cfg.Token = config.Token{
AccessToken: tj.AccessToken,
TokenType: tj.TokenType,
RefreshToken: tj.RefreshToken,
Expiry: tj.expiry(),
}
if bdc.cfg.PathCfg != "" {
ser, _ := bdc.cfg.Serialize("", " ")
_ = ser.WriteToFile(bdc.cfg.PathCfg)
}
if bdc.cfg.PathToken != "" {
ser, _ := bdc.cfg.Token.Serialize("", " ")
_ = ser.WriteToFile(bdc.cfg.PathToken)
}
return bdc.cfg.Token, nil
}
func (e *tokenJSON) expiry() (t time.Time) {
if v := e.ExpiresIn; v != 0 {
return time.Now().Add(time.Duration(v) * time.Second)
}
return
}
// do method performs request and returns response as an array of bytes and nil error in case of response status code 200.
// In any other cases do returns nil response and error.
// Retries are implemented in case of connection reset errors.
func (bdc *BVSDecortClient) do(req *http.Request, ctype string) ([]byte, error) {
// set up request headers and body
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
if ctype != "" {
req.Header.Set("Content-Type", ctype)
}
req.Header.Add("Authorization", "bearer "+bdc.cfg.Token.AccessToken)
req.Header.Set("Accept", "application/json")
buf, err := io.ReadAll(req.Body)
if err != nil {
return nil, err
}
req.Body.Close()
req.Body = io.NopCloser(bytes.NewBuffer(buf))
resp, err := bdc.client.Do(req)
if resp != nil {
defer resp.Body.Close()
}
// retries logic GOES HERE
// get http response
//var resp *http.Response
//for i := uint64(0); i < bdc.cfg.Retries; i++ {
// req := req.Clone(req.Context())
// req.Body = io.NopCloser(bytes.NewBuffer(buf))
//
// if i > 0 {
// time.Sleep(5 * time.Second) // no time sleep for the first request
// }
//
// resp, err = bdc.client.Do(req)
//
// // stop retries on success and close response body
// if resp != nil {
// defer resp.Body.Close()
// }
// if err == nil {
// break
// }
//
// // retries in case of connection errors with time sleep
// if isConnectionError(err) {
// continue
// }
//
// // return error in case of non-connection error
// return nil, err
//}
// handle http request errors
if err != nil {
return nil, err
}
if resp == nil {
return nil, fmt.Errorf("got empty response without error")
}
var respBytes []byte
respBytes, err = io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
// handle access denied and successful request
if resp.StatusCode == 401 {
return respBytes, errors.New("access is denied")
}
if resp.StatusCode == 200 {
return respBytes, nil
}
// handle errors with other status codes
err = fmt.Errorf("%s", respBytes)
return nil, fmt.Errorf("could not execute request: %w", err)
}
func trimBVSConfig(cfg *config.BVSConfig) config.BVSConfig {
cfg.SSOURL = strings.TrimSuffix(cfg.SSOURL, "/")
cfg.DecortURL = strings.TrimSuffix(cfg.DecortURL, "/")
return *cfg
}

@ -1,216 +0,0 @@
package config
import (
"encoding/json"
"os"
"time"
"gopkg.in/yaml.v3"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/serialization"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
type BVSConfig struct {
// ServiceAccount username
// Required: true
// Example : "osh_mikoev"
Username string `json:"username" yaml:"username" validate:"required"`
// ServiceAccount password
// Required: true
// Example: "[1o>hYkjnJr)HI78q7t&#%8Lm"
Password string `json:"password" yaml:"password" validate:"required"`
// Domain name
// Required: true
// Example: "dynamix"
Domain string `json:"domain" yaml:"domain" validate:"required"`
// Application (client) identifier for authorization
// in the cloud platform controller in oauth2 mode.
// Required: true
// Example: "ewqfrvea7s890avw804389qwguf234h0otfi3w4eiu"
AppID string `json:"appId" yaml:"appId" validate:"required"`
// Application (client) secret code for authorization
// in the cloud platform controller in oauth2 mode.
// Example: "frvet09rvesfis0c9erv9fsov0vsdfi09ovds0f"
AppSecret string `json:"appSecret" yaml:"appSecret" validate:"required"`
// Platform authentication service address
// Required: true
// Example: "https://sso.digitalenergy.online"
SSOURL string `json:"ssoUrl" yaml:"ssoUrl" validate:"url"`
// The address of the platform on which the actions are planned
// Required: true
// Example: "https://mr4.digitalenergy.online"
DecortURL string `json:"decortUrl" yaml:"decortUrl" validate:"url"`
// JWT platform token
// Required: false
// Example: "qwqwdfwv68979we0q9bfv7e9sbvd89798qrwv97ff"
Token Token `json:"token" yaml:"token"`
// Amount platform request attempts
// Default value: 5
// Required: false
Retries uint64 `json:"retries" yaml:"retries"`
// Skip verify
// Required: false
SSLSkipVerify bool `json:"sslSkipVerify" yaml:"sslSkipVerify"`
// HTTP client timeout, unlimited if left empty
// Required: false
Timeout Duration `json:"timeout" yaml:"timeout"`
// The path of the configuration file entry
// Required: false
PathCfg string `json:"path_cfg" yaml:"path_cfg"`
// The path of the token file entry
// Required: false
PathToken string `json:"path_token" yaml:"path_token"`
// The number of minutes before the expiration of the token, a refresh will be made
// Required: false
TimeToRefresh int64 `json:"timeToRefresh" yaml:"timeToRefresh"`
}
type Token struct {
// AccessToken is the token that authorizes and authenticates
// the requests.
// Required: false
AccessToken string `json:"access_token" yaml:"access_token"`
// TokenType is the type of token.
// The Type method returns either this or "Bearer", the default.
// Required: false
TokenType string `json:"token_type" yaml:"token_type"`
// RefreshToken is a token that's used by the application
// (as opposed to the user) to refresh the access token
// if it expires.
// Required: false
RefreshToken string `json:"refresh_token" yaml:"refresh_token"`
// Expiry is the optional expiration time of the access token.
// Required: false
Expiry time.Time `json:"expiry" yaml:"expiry"`
}
// SetTimeout is used to set HTTP client timeout.
func (c *BVSConfig) SetTimeout(dur time.Duration) {
c.Timeout = Duration(dur)
}
// ParseConfigJSON parses Config from specified JSON-formatted file.
func ParseConfigBVSJSON(path string) (BVSConfig, error) {
file, err := os.ReadFile(path)
if err != nil {
return BVSConfig{}, err
}
var config BVSConfig
err = json.Unmarshal(file, &config)
if err != nil {
return BVSConfig{}, err
}
err = validators.ValidateConfig(config)
if err != nil {
return BVSConfig{}, validators.ValidationErrors(validators.GetErrors(err))
}
return config, nil
}
// ParseConfigJSON parses Token from specified JSON-formatted file.
func ParseTokenBVSJSON(path string) (Token, error) {
file, err := os.ReadFile(path)
if err != nil {
return Token{}, err
}
var token Token
err = json.Unmarshal(file, &token)
if err != nil {
return Token{}, err
}
err = validators.ValidateConfig(token)
if err != nil {
return Token{}, validators.ValidationErrors(validators.GetErrors(err))
}
return token, nil
}
// ParseTokenBVSYAML parses Token from specified YAML-formatted file.
func ParseTokenBVSYAML(path string) (Token, error) {
file, err := os.ReadFile(path)
if err != nil {
return Token{}, err
}
var token Token
err = yaml.Unmarshal(file, &token)
if err != nil {
return Token{}, err
}
err = validators.ValidateConfig(token)
if err != nil {
return Token{}, validators.ValidationErrors(validators.GetErrors(err))
}
return token, nil
}
// ParseConfigYAML parses Config from specified YAML-formatted file.
func ParseConfigBVSYAML(path string) (BVSConfig, error) {
file, err := os.ReadFile(path)
if err != nil {
return BVSConfig{}, err
}
var config BVSConfig
err = yaml.Unmarshal(file, &config)
if err != nil {
return BVSConfig{}, err
}
err = validators.ValidateConfig(config)
if err != nil {
return BVSConfig{}, validators.ValidationErrors(validators.GetErrors(err))
}
return config, nil
}
func (t Token) Serialize(params ...string) (serialization.Serialized, error) {
if len(params) > 1 {
prefix := params[0]
indent := params[1]
return json.MarshalIndent(t, prefix, indent)
}
return json.Marshal(t)
}
func (c BVSConfig) Serialize(params ...string) (serialization.Serialized, error) {
if len(params) > 1 {
prefix := params[0]
indent := params[1]
return json.MarshalIndent(c, prefix, indent)
}
return json.Marshal(c)
}

@ -22,8 +22,6 @@ func (d *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {
} }
*d = Duration(tmp) *d = Duration(tmp)
return nil return nil
case float64:
return nil
default: default:
return fmt.Errorf("invalid duration %v", value) return fmt.Errorf("invalid duration %v", value)
} }
@ -42,8 +40,6 @@ func (d *Duration) UnmarshalJSON(b []byte) error {
} }
*d = Duration(tmp) *d = Duration(tmp)
return nil return nil
case float64:
return nil
default: default:
return fmt.Errorf("invalid duration %v", value) return fmt.Errorf("invalid duration %v", value)
} }

@ -1,8 +0,0 @@
package config
// UniversalConfig combines configurations for different types of clients
type UniversalConfig struct {
Decs3oConfig *Config `json:"decs3oConfig,omitempty" yaml:"decs3oConfig,omitempty"`
BVSConfig *BVSConfig `json:"bvsConfig,omitempty" yaml:"bvsConfig,omitempty"`
LegacyConfig *LegacyConfig `json:"legacyConfig,omitempty" yaml:"legacyConfig,omitempty"`
}

@ -5,17 +5,15 @@ go 1.20
require ( require (
github.com/go-playground/validator/v10 v10.11.2 github.com/go-playground/validator/v10 v10.11.2
github.com/google/go-querystring v1.1.0 github.com/google/go-querystring v1.1.0
github.com/joho/godotenv v1.5.1
gopkg.in/yaml.v3 v3.0.1 gopkg.in/yaml.v3 v3.0.1
) )
require ( require (
github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/google/go-cmp v0.5.9 // indirect
github.com/kr/text v0.2.0 // indirect github.com/kr/text v0.2.0 // indirect
github.com/leodido/go-urn v1.2.1 // indirect github.com/leodido/go-urn v1.2.1 // indirect
golang.org/x/crypto v0.15.0 // indirect golang.org/x/crypto v0.5.0 // indirect
golang.org/x/sys v0.14.0 // indirect golang.org/x/sys v0.4.0 // indirect
golang.org/x/text v0.14.0 // indirect golang.org/x/text v0.6.0 // indirect
) )

@ -8,13 +8,10 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.11.2 h1:q3SHpufmypg+erIExEKUmsgmhDTyhcJ38oeKGACXohU= github.com/go-playground/validator/v10 v10.11.2 h1:q3SHpufmypg+erIExEKUmsgmhDTyhcJ38oeKGACXohU=
github.com/go-playground/validator/v10 v10.11.2/go.mod h1:NieE624vt4SCTJtD87arVLvdmjPAeV8BQlHtMnw9D7s= github.com/go-playground/validator/v10 v10.11.2/go.mod h1:NieE624vt4SCTJtD87arVLvdmjPAeV8BQlHtMnw9D7s=
github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
@ -26,12 +23,12 @@ github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUA
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
golang.org/x/crypto v0.15.0 h1:frVn1TEaCEaZcn3Tmd7Y2b5KKPaZ+I32Q2OA3kYp5TA= golang.org/x/crypto v0.5.0 h1:U/0M97KRkSFvyD/3FSmdP5W5swImpNgle/EHFhOsQPE=
golang.org/x/crypto v0.15.0/go.mod h1:4ChreQoLWfG3xLDer1WdlH5NdlQ3+mwnQq1YTKY+72g= golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q= golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.6.0 h1:3XmdazWV+ubf7QgHSTWeykHOci5oeekaGJBLkrkaw4k=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

@ -6,10 +6,4 @@ import "context"
type Caller interface { type Caller interface {
// DecortApiCall method for sending requests to the platform // DecortApiCall method for sending requests to the platform
DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error)
// DecortApiCallCtype method for sending requests to the platform
DecortApiCallCtype(ctx context.Context, method, url, ctype string, params interface{}) ([]byte, error)
// DecortApiCallMP method for sending requests to the platform
DecortApiCallMP(ctx context.Context, method, url string, params interface{}) ([]byte, error)
} }

@ -1,7 +0,0 @@
package interfaces
// Interface to valiate RAM values
type RequestWithRAM interface {
// GetRAM returns RAM values
GetRAM() map[string]uint64
}

@ -1,32 +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.3.0": "-",
}

@ -1,38 +1,31 @@
package validators package validators
import ( import (
"errors"
"fmt"
"net/url"
"reflect"
"regexp" "regexp"
"strconv"
"strings" "strings"
"github.com/go-playground/validator/v10" "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. // computeDriverValidator is used to validate Driver field in kvmx86/kvmppc create.
func protoValidator(fe validator.FieldLevel) bool { func computeDriverValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, protoValues) return StringInSlice(fieldValue, computeDriverValues)
} }
// apiGroupValidator is used to validate APIGroup fields // protoValidator is used to validate Proto fields.
func apiGroupValidator(fe validator.FieldLevel) bool { func protoValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, apiGroupValues) return StringInSlice(fieldValue, protoValues)
} }
// accessTypeValidator is used to validate AccessType fields. // accessTypeValidator is used to validate AccessType fields.
func accessTypeValidator(fe validator.FieldLevel) bool { func accessTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, accessTypeValues) return StringInSlice(fieldValue, accessTypeValues)
} }
// resTypesValidator is used to validate ResTypes fields. // resTypesValidator is used to validate ResTypes fields.
@ -43,7 +36,7 @@ func resTypesValidator(fe validator.FieldLevel) bool {
} }
for _, value := range fieldSlice { for _, value := range fieldSlice {
if !IsInSlice(value, resTypesValues) { if !StringInSlice(value, resTypesValues) {
return false return false
} }
} }
@ -51,81 +44,60 @@ func resTypesValidator(fe validator.FieldLevel) bool {
return true return true
} }
// driverValidator is used to validate Driver fields.
func driverValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String()
return StringInSlice(fieldValue, driverValues)
}
// accountCUTypeValidator is used to validate CUType field. // accountCUTypeValidator is used to validate CUType field.
func accountCUTypeValidator(fe validator.FieldLevel) bool { func accountCUTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, accountCUTypeValues) return StringInSlice(fieldValue, accountCUTypeValues)
} }
// bserviceModeValidator is used to validate Mode field. // bserviceModeValidator is used to validate Mode field.
func bserviceModeValidator(fe validator.FieldLevel) bool { func bserviceModeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, bserviceModeValues) return StringInSlice(fieldValue, bserviceModeValues)
} }
// computeTopologyValidator is used to validate Topology field. // computeTopologyValidator is used to validate Topology field.
func computeTopologyValidator(fe validator.FieldLevel) bool { func computeTopologyValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeTopologyValues) return StringInSlice(fieldValue, computeTopologyValues)
} }
// computePolicyValidator is used to validate Policy field. // computePolicyValidator is used to validate Policy field.
func computePolicyValidator(fe validator.FieldLevel) bool { func computePolicyValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computePolicyValues) return StringInSlice(fieldValue, computePolicyValues)
} }
// computeModeValidator is used to validate Mode field. // computeModeValidator is used to validate Mode field.
func computeModeValidator(fe validator.FieldLevel) bool { func computeModeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeModeValues) return StringInSlice(fieldValue, computeModeValues)
} }
// computeDiskTypeValidator is used to validate DiskType field. // computeDiskTypeValidator is used to validate DiskType field.
func computeDiskTypeValidator(fe validator.FieldLevel) bool { func computeDiskTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeDiskTypeValues) return StringInSlice(fieldValue, computeDiskTypeValues)
} }
// computeNetTypeValidator is used to validate NetType field. // computeNetTypeValidator is used to validate NetType field.
func computeNetTypeValidator(fe validator.FieldLevel) bool { func computeNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeNetTypeValues) return StringInSlice(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. // computeOrderValidator is used to validate Order field.
@ -136,7 +108,7 @@ func computeOrderValidator(fe validator.FieldLevel) bool {
} }
for _, value := range fieldSlice { for _, value := range fieldSlice {
if !IsInSlice(value, computeOrderValues) { if !StringInSlice(value, computeOrderValues) {
return false return false
} }
} }
@ -148,84 +120,100 @@ func computeOrderValidator(fe validator.FieldLevel) bool {
func computeDataDisksValidator(fe validator.FieldLevel) bool { func computeDataDisksValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, computeDataDisksValues) return StringInSlice(fieldValue, computeDataDisksValues)
} }
// diskTypeValidator is used to validate Type field. // diskTypeValidator is used to validate Type field.
func diskTypeValidator(fe validator.FieldLevel) bool { func diskTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, diskTypeValues) return StringInSlice(fieldValue, diskTypeValues)
} }
// flipgroupClientTypeValidator is used to validate ClientType field. // flipgroupClientTypeValidator is used to validate ClientType field.
func flipgroupClientTypeValidator(fe validator.FieldLevel) bool { func flipgroupClientTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, flipgroupClientTypeValues) return StringInSlice(fieldValue, flipgroupClientTypeValues)
} }
// kvmNetTypeValidator is used to validate NetType field. // kvmNetTypeValidator is used to validate NetType field.
func kvmNetTypeValidator(fe validator.FieldLevel) bool { func kvmNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, kvmNetTypeValues) return StringInSlice(fieldValue, kvmNetTypeValues)
} }
// lbAlgorithmValidator is used to validate Algorithm field. // lbAlgorithmValidator is used to validate Algorithm field.
func lbAlgorithmValidator(fe validator.FieldLevel) bool { func lbAlgorithmValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, lbAlgorithmValues) return StringInSlice(fieldValue, lbAlgorithmValues)
} }
// rgDefNetValidator is used to validate DefNet field. // rgDefNetValidator is used to validate DefNet field.
func rgDefNetValidator(fe validator.FieldLevel) bool { func rgDefNetValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, rgDefNetValues) return StringInSlice(fieldValue, rgDefNetValues)
} }
// rgNetTypeValidator is used to validate NetType field. // rgNetTypeValidator is used to validate NetType field.
func rgNetTypeValidator(fe validator.FieldLevel) bool { func rgNetTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, rgNetTypeValues) return StringInSlice(fieldValue, rgNetTypeValues)
} }
// vinsTypeValidator is used to validate Type field. // vinsTypeValidator is used to validate Type field.
func vinsTypeValidator(fe validator.FieldLevel) bool { func vinsTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, vinsTypeValues) return StringInSlice(fieldValue, vinsTypeValues)
} }
// imageBootTypeValidator is used to validate BootType field. // imageBootTypeValidator is used to validate BootType field.
func imageBootTypeValidator(fe validator.FieldLevel) bool { func imageBootTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageBootTypeValues) return StringInSlice(fieldValue, imageBootTypeValues)
} }
// imageTypeValidator is used to validate ImageType field. // imageTypeValidator is used to validate ImageType field.
func imageTypeValidator(fe validator.FieldLevel) bool { func imageTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageTypeValues) return StringInSlice(fieldValue, imageTypeValues)
}
// imageDriversValidator is used to validate Drivers field.
func imageDriversValidator(fe validator.FieldLevel) bool {
fieldSlice, ok := fe.Field().Interface().([]string)
if !ok {
return false
}
for _, item := range fieldSlice {
if !StringInSlice(item, imageDriversValues) {
return false
}
}
return true
} }
// imageArchitectureValidator is used to validate Architecture field. // imageArchitectureValidator is used to validate Architecture field.
func imageArchitectureValidator(fe validator.FieldLevel) bool { func imageArchitectureValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, imageArchitectureValues) return StringInSlice(fieldValue, imageArchitectureValues)
} }
// sepFieldTypeValidator is used to validate FieldType field. // sepFieldTypeValidator is used to validate FieldType field.
func sepFieldTypeValidator(fe validator.FieldLevel) bool { func sepFieldTypeValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
return IsInSlice(fieldValue, sepFieldTypeValues) return StringInSlice(fieldValue, sepFieldTypeValues)
} }
// hwPathValidator is used to validate HWPath field. // hwPathValidator is used to validate HWPath field.
@ -242,7 +230,7 @@ func networkPluginValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue) fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, networkPluginValues) return StringInSlice(fieldValue, networkPluginValues)
} }
// networkPluginsValidator is used to validate NetworkPlugins field // networkPluginsValidator is used to validate NetworkPlugins field
@ -255,7 +243,7 @@ func networkPluginsValidator(fe validator.FieldLevel) bool {
for _, item := range fieldSlice { for _, item := range fieldSlice {
item = strings.ToLower(item) item = strings.ToLower(item)
if !IsInSlice(item, networkPluginValues) { if !StringInSlice(item, networkPluginValues) {
return false return false
} }
} }
@ -267,35 +255,14 @@ func interfaceStateValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue) fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, interfaceStateValues) return StringInSlice(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 { func strictLooseValidator(fe validator.FieldLevel) bool {
fieldValue := fe.Field().String() fieldValue := fe.Field().String()
fieldValue = strings.ToLower(fieldValue) fieldValue = strings.ToLower(fieldValue)
return IsInSlice(fieldValue, strictLooseValues) return StringInSlice(fieldValue, strictLooseValues)
} }
// name workerGroup must be more 3 symbol // name workerGroup must be more 3 symbol
@ -305,155 +272,3 @@ func workerGroupNameValidator(fe validator.FieldLevel) bool {
return len(fieldValue) >= 3 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)
}
// 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)
}

@ -34,7 +34,7 @@ func GetErrors(err error) validator.ValidationErrors {
return err.(validator.ValidationErrors) return err.(validator.ValidationErrors)
} }
func IsInSlice(str string, target []string) bool { func StringInSlice(str string, target []string) bool {
for _, v := range target { for _, v := range target {
if v == str { if v == str {
return true return true
@ -42,12 +42,3 @@ func IsInSlice(str string, target []string) bool {
} }
return false return false
} }
func IsSubSlice(source []string, target []string) bool {
for _, s := range source {
if !IsInSlice(s, target) {
return false
}
}
return true
}

@ -25,8 +25,12 @@ func errorMessage(fe validator.FieldError) string {
return fmt.Sprintf("%s %s: unexpected URL format", prefix, fe.Field()) return fmt.Sprintf("%s %s: unexpected URL format", prefix, fe.Field())
case "email": case "email":
return fmt.Sprintf("%s %s: unexpected E-Mail format", prefix, fe.Field()) 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 "driver":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(driverValues))
case "accessType": case "accessType":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
@ -46,13 +50,6 @@ func errorMessage(fe validator.FieldError) string {
fe.Field(), fe.Field(),
joinValues(protoValues)) 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 // Account Validators
case "accountCUType": case "accountCUType":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
@ -92,18 +89,6 @@ func errorMessage(fe validator.FieldError) string {
fe.Field(), fe.Field(),
joinValues(computeDiskTypeValues)) joinValues(computeDiskTypeValues))
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": case "computeNetType":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
prefix, prefix,
@ -122,6 +107,12 @@ func errorMessage(fe validator.FieldError) string {
fe.Field(), fe.Field(),
joinValues(computeDataDisksValues)) joinValues(computeDataDisksValues))
case "computeDriver":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(computeDriverValues))
// Disk Validators // Disk Validators
case "diskType": case "diskType":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
@ -142,7 +133,7 @@ func errorMessage(fe validator.FieldError) string {
prefix, prefix,
fe.Field()) fe.Field())
// KVM_X86 Validators // KVM_X86/KVM_PPC Validators
case "kvmNetType": case "kvmNetType":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
prefix, prefix,
@ -189,6 +180,12 @@ func errorMessage(fe validator.FieldError) string {
fe.Field(), fe.Field(),
joinValues(imageTypeValues)) joinValues(imageTypeValues))
case "imageDrivers":
return fmt.Sprintf("%s %s must contain only the following: %s",
prefix,
fe.Field(),
joinValues(imageDriversValues))
case "imageArchitecture": case "imageArchitecture":
return fmt.Sprintf("%s %s must be one of the following: %s", return fmt.Sprintf("%s %s must be one of the following: %s",
prefix, prefix,
@ -232,127 +229,6 @@ func errorMessage(fe validator.FieldError) string {
prefix, prefix,
fe.Field(), fe.Field(),
joinValues(interfaceStateValues)) 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())
case "device":
return fmt.Sprintf("%s %s must be one of the following: %s",
prefix,
fe.Field(),
joinValues(deviceValues))
} }
return fe.Error() return fe.Error()

@ -25,13 +25,12 @@ func getDecortValidator() *validator.Validate {
// registerAllValidators registers all custom validators in DecortValidator. // registerAllValidators registers all custom validators in DecortValidator.
func registerAllValidators(validate *validator.Validate) error { func registerAllValidators(validate *validator.Validate) error {
err := validate.RegisterValidation("proto", protoValidator) err := validate.RegisterValidation("proto", protoValidator)
if err != nil { if err != nil {
return err return err
} }
err = validate.RegisterValidation("apiGroup", apiGroupValidator) err = validate.RegisterValidation("computeDriver", computeDriverValidator)
if err != nil { if err != nil {
return err return err
} }
@ -46,6 +45,11 @@ func registerAllValidators(validate *validator.Validate) error {
return err return err
} }
err = validate.RegisterValidation("driver", driverValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("imageBootType", imageBootTypeValidator) err = validate.RegisterValidation("imageBootType", imageBootTypeValidator)
if err != nil { if err != nil {
return err return err
@ -56,6 +60,11 @@ func registerAllValidators(validate *validator.Validate) error {
return err return err
} }
err = validate.RegisterValidation("imageDrivers", imageDriversValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("imageArchitecture", imageArchitectureValidator) err = validate.RegisterValidation("imageArchitecture", imageArchitectureValidator)
if err != nil { if err != nil {
return err return err
@ -96,11 +105,6 @@ func registerAllValidators(validate *validator.Validate) error {
return err return err
} }
err = validate.RegisterValidation("computex86NetType", computex86NetTypeValidator)
if err != nil {
return err
}
err = validate.RegisterValidation("computeOrder", computeOrderValidator) err = validate.RegisterValidation("computeOrder", computeOrderValidator)
if err != nil { if err != nil {
return err return err
@ -176,130 +180,10 @@ func registerAllValidators(validate *validator.Validate) error {
return err 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) err = validate.RegisterValidation("workerGroupName", workerGroupNameValidator)
if err != nil { if err != nil {
return err 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
}
return nil return nil
} }

@ -1,8 +1,7 @@
package validators package validators
var ( var (
apiGroupValues = []string{"cloudapi", "cloudbroker", "system"} driverValues = []string{"KVM_X86", "KVM_PPC"}
accessTypeValues = []string{"R", "RCX", "ARCXDU"} accessTypeValues = []string{"R", "RCX", "ARCXDU"}
resTypesValues = []string{"compute", "vins", "k8s", "openshift", "lb", "flipgroup"} resTypesValues = []string{"compute", "vins", "k8s", "openshift", "lb", "flipgroup"}
protoValues = []string{"tcp", "udp"} protoValues = []string{"tcp", "udp"}
@ -11,32 +10,32 @@ var (
bserviceModeValues = []string{"ABSOLUTE", "RELATIVE"} bserviceModeValues = []string{"ABSOLUTE", "RELATIVE"}
computeTopologyValues = []string{"compute", "node"} computeTopologyValues = []string{"compute", "node"}
computePolicyValues = []string{"RECOMMENDED", "REQUIRED"} computePolicyValues = []string{"RECOMMENDED", "REQUIRED"}
computeModeValues = []string{"EQ", "EN", "ANY"} computeModeValues = []string{"EQ", "EN", "ANY"}
computeDiskTypeValues = []string{"D", "B"} computeDiskTypeValues = []string{"D", "B"}
computeNetTypeValues = []string{"EXTNET", "VINS"} computeNetTypeValues = []string{"EXTNET", "VINS"}
computex86NetTypeValues = []string{"EXTNET", "VINS", "VFNIC", "DPDK", "SDN", "EMPTY", "TRUNK"} computeOrderValues = []string{"cdrom", "network", "hd"}
computeOrderValues = []string{"cdrom", "network", "hd"} computeDataDisksValues = []string{"KEEP", "DETACH", "DESTROY"}
computeDataDisksValues = []string{"KEEP", "DETACH", "DESTROY"} computeDriverValues = []string{"KVM_X86", "SVA_KVM_X86"}
diskTypeValues = []string{"B", "T", "D"} diskTypeValues = []string{"B", "T", "D"}
flipgroupClientTypeValues = []string{"compute", "vins"} flipgroupClientTypeValues = []string{"compute", "vins"}
kvmNetTypeValues = []string{"EXTNET", "VINS", "NONE"} kvmNetTypeValues = []string{"EXTNET", "VINS", "NONE"}
kvmx86NetTypeValues = []string{"EXTNET", "VINS", "EMPTY", "VFNIC", "DPDK", "SDN", "TRUNK"}
lbAlgorithmValues = []string{"roundrobin", "static-rr", "leastconn"} lbAlgorithmValues = []string{"roundrobin", "static-rr", "leastconn"}
rgDefNetValues = []string{"PRIVATE", "PUBLIC", "NONE"} rgDefNetValues = []string{"PRIVATE", "PUBLIC", "NONE"}
rgNetTypeValues = []string{"PUBLIC", "PRIVATE"} rgNetTypeValues = []string{"PUBLIC", "PRIVATE"}
vinsTypeValues = []string{"DHCP", "VIP", "EXCLUDED"} vinsTypeValues = []string{"DHCP", "VIP", "EXCLUDE"}
imageBootTypeValues = []string{"uefi", "bios"} imageBootTypeValues = []string{"uefi", "bios"}
imageTypeValues = []string{"windows", "linux", "unknown"} imageTypeValues = []string{"windows", "linux", "other"}
imageArchitectureValues = []string{"X86_64"} imageDriversValues = []string{"KVM_X86"}
imageArchitectureValues = []string{"X86_64", "PPC64_LE"}
sepFieldTypeValues = []string{"int", "str", "bool", "list", "dict"} sepFieldTypeValues = []string{"int", "str", "bool", "list", "dict"}
@ -45,44 +44,4 @@ var (
strictLooseValues = []string{"strict", "loose"} strictLooseValues = []string{"strict", "loose"}
interfaceStateValues = []string{"on", "off"} 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"}
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"}
)
const (
mtuMin = 1
mtuMax = 9216
trunkTagsMin = 1
trunkTagsMax = 4095
) )

@ -4,23 +4,25 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/tls" "crypto/tls"
"encoding/json"
"fmt" "fmt"
"io" "io"
"mime/multipart"
"net/http" "net/http"
"net/url" "net/url"
"strconv"
"strings" "strings"
"sync" "sync"
"time" "time"
"github.com/google/go-querystring/query" "github.com/google/go-querystring/query"
"repository.basistech.ru/BASIS/decort-golang-sdk/config" "repository.basistech.ru/BASIS/decort-golang-sdk/config"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi" "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi"
k8s_ca "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/k8s"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker" "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker"
k8s_cb "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
) )
// LegacyDecortClient is Legacy HTTP-client for platform // Legacy HTTP-client for platform
type LegacyDecortClient struct { type LegacyDecortClient struct {
decortURL string decortURL string
client *http.Client client *http.Client
@ -51,7 +53,7 @@ func NewLegacy(cfg config.LegacyConfig) *LegacyDecortClient {
}, },
}, },
}, },
cfg: trimLegacyConfig(&cfg), cfg: cfg,
expiryTime: expiryTime, expiryTime: expiryTime,
mutex: &sync.Mutex{}, mutex: &sync.Mutex{},
} }
@ -69,18 +71,20 @@ func (ldc *LegacyDecortClient) CloudBroker() *cloudbroker.CloudBroker {
// DecortApiCall method for sending requests to the platform // DecortApiCall method for sending requests to the platform
func (ldc *LegacyDecortClient) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) { func (ldc *LegacyDecortClient) DecortApiCall(ctx context.Context, method, url string, params interface{}) ([]byte, error) {
// get token
if err := ldc.getToken(ctx); err != nil { if err := ldc.getToken(ctx); err != nil {
return nil, err return nil, err
} }
k8sCaCreateReq, okCa := params.(k8s_ca.CreateRequest)
k8sCbCreateReq, okCb := params.(k8s_cb.CreateRequest)
var body *bytes.Buffer var body *bytes.Buffer
var ctype string var ctype string
byteSlice, ok := params.([]byte) if okCa {
if ok { body, ctype = createK8sCloudApiLegacy(k8sCaCreateReq, ldc.cfg.Token)
body = bytes.NewBuffer(byteSlice) } else if okCb {
ctype = "application/octet-stream" body, ctype = createK8sCloudBrokerLegacy(k8sCbCreateReq, ldc.cfg.Token)
} else { } else {
values, err := query.Values(params) values, err := query.Values(params)
if err != nil { if err != nil {
@ -89,202 +93,313 @@ func (ldc *LegacyDecortClient) DecortApiCall(ctx context.Context, method, url st
body = bytes.NewBufferString(values.Encode() + fmt.Sprintf("&authkey=%s", ldc.cfg.Token)) body = bytes.NewBufferString(values.Encode() + fmt.Sprintf("&authkey=%s", ldc.cfg.Token))
} }
req, err := http.NewRequestWithContext(ctx, method, ldc.decortURL+constants.RESTMACHINE+url, body) req, err := http.NewRequestWithContext(ctx, method, ldc.decortURL+"/restmachine"+url, body)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// perform request // perform request
respBytes, err := ldc.do(req, ctype) var respBytes []byte
if err != nil { respBytes, err = ldc.do(req, ctype)
return nil, err
}
return respBytes, err return respBytes, err
} }
// DecortApiCallCtype method for sending requests to the platform with content type func (ldc *LegacyDecortClient) getToken(ctx context.Context) error {
func (ldc *LegacyDecortClient) DecortApiCallCtype(ctx context.Context, method, url, ctype string, params interface{}) ([]byte, error) { ldc.mutex.Lock()
// get token defer ldc.mutex.Unlock()
if err := ldc.getToken(ctx); err != nil {
return nil, err
}
var body *bytes.Buffer if ldc.cfg.Token == "" || time.Now().After(ldc.expiryTime) {
body := fmt.Sprintf("username=%s&password=%s", url.QueryEscape(ldc.cfg.Username), url.QueryEscape(ldc.cfg.Password))
bodyReader := strings.NewReader(body)
switch ctype { req, _ := http.NewRequestWithContext(ctx, "POST", ldc.cfg.DecortURL+"/restmachine/cloudapi/user/authenticate", bodyReader)
case constants.MIMESTREAM: req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
body = bytes.NewBuffer(params.([]byte))
case constants.MIMEJSON: resp, err := ldc.client.Do(req)
jsonBody, err := json.Marshal(params)
if err != nil {
return nil, err
}
body = bytes.NewBuffer(jsonBody)
default:
ctype = constants.MIMEPOSTForm
values, err := query.Values(params)
if err != nil { if err != nil {
return nil, err return fmt.Errorf("unable to get token: %w", err)
} }
body = bytes.NewBufferString(values.Encode() + fmt.Sprintf("&authkey=%s", ldc.cfg.Token))
}
req, err := http.NewRequestWithContext(ctx, method, ldc.decortURL+constants.RESTMACHINE+url, body) tokenBytes, _ := io.ReadAll(resp.Body)
if err != nil { resp.Body.Close()
return nil, err
}
// perform request if resp.StatusCode != 200 {
respBytes, err := ldc.do(req, ctype) return fmt.Errorf("unable to get token: %s", tokenBytes)
if err != nil { }
return nil, err
token := string(tokenBytes)
ldc.cfg.Token = token
ldc.expiryTime = time.Now().AddDate(0, 0, 1)
} }
return respBytes, err return nil
} }
func (ldc *LegacyDecortClient) DecortApiCallMP(ctx context.Context, method, url string, params interface{}) ([]byte, error) { func (ldc *LegacyDecortClient) do(req *http.Request, ctype string) ([]byte, error) {
body, ctype, err := multiPartReq(params) if ctype != "" {
if err != nil { req.Header.Add("Content-Type", ctype)
return nil, err } else {
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
} }
req.Header.Set("Accept", "application/json")
req, err := http.NewRequestWithContext(ctx, method, ldc.decortURL+constants.RESTMACHINE+url, body) buf, err := io.ReadAll(req.Body)
if err != nil { if err != nil {
return nil, err return nil, err
} }
req.Body.Close()
req.Body = io.NopCloser(bytes.NewBuffer(buf))
// get token resp, err := ldc.client.Do(req)
if err = ldc.getToken(ctx); err != nil { if err != nil || resp == nil {
return nil, err return nil, err
} }
defer resp.Body.Close()
// perform request // handle successful request
respBytes, err := ldc.do(req, ctype) respBytes, err := io.ReadAll(resp.Body)
if err != nil { if err!= nil {
return nil, err return nil, err
} }
if resp.StatusCode == 200 {
return respBytes, nil
}
return respBytes, err // handle errors with status code other than 200
err = fmt.Errorf("%s", respBytes)
return nil, fmt.Errorf("could not execute request: %w", err)
} }
func (ldc *LegacyDecortClient) getToken(ctx context.Context) error { func createK8sCloudApiLegacy(req k8s_ca.CreateRequest, token string) (*bytes.Buffer, string) {
ldc.mutex.Lock() reqBody := &bytes.Buffer{}
defer ldc.mutex.Unlock() writer := multipart.NewWriter(reqBody)
if req.OidcCertificate != "" {
// new token is not needed part, _ := writer.CreateFormFile("oidcCertificate", "ca.crt")
if ldc.cfg.Token != "" && !time.Now().After(ldc.expiryTime) { _, _ = io.Copy(part, strings.NewReader(req.OidcCertificate))
return nil
} }
// set up request headers and body _ = writer.WriteField("name", req.Name)
body := fmt.Sprintf("username=%s&password=%s", url.QueryEscape(ldc.cfg.Username), url.QueryEscape(ldc.cfg.Password)) _ = writer.WriteField("rgId", strconv.FormatUint(req.RGID, 10))
bodyReader := strings.NewReader(body) _ = writer.WriteField("k8ciId", strconv.FormatUint(req.K8SCIID, 10))
_ = writer.WriteField("workerGroupName", req.WorkerGroupName)
_ = writer.WriteField("networkPlugin", req.NetworkPlugin)
req, _ := http.NewRequestWithContext(ctx, "POST", ldc.cfg.DecortURL+constants.RESTMACHINE+"/cloudapi/user/authenticate", bodyReader) if req.MasterSEPID != 0 {
req.Header.Add("Content-Type", "application/x-www-form-urlencoded") _ = writer.WriteField("masterSepId", strconv.FormatUint(req.MasterSEPID, 10))
}
if req.MasterSEPPool != "" {
_ = writer.WriteField("masterSepPool", req.MasterSEPPool)
}
if req.WorkerSEPID != 0 {
_ = writer.WriteField("workerSepId", strconv.FormatUint(req.WorkerSEPID, 10))
}
if req.WorkerSEPPool != "" {
_ = writer.WriteField("workerSepPool", req.WorkerSEPPool)
}
// request token if req.Labels != nil {
resp, err := ldc.client.Do(req) for _, v := range req.Labels {
if err != nil || resp == nil { _ = writer.WriteField("labels", v)
return fmt.Errorf("cannot get token: %w", err) }
}
if req.Taints != nil {
for _, v := range req.Taints {
_ = writer.WriteField("taints", v)
}
}
if req.Annotations != nil {
for _, v := range req.Annotations {
_ = writer.WriteField("annotations", v)
}
} }
defer resp.Body.Close()
var tokenBytes []byte if req.MasterCPU != 0 {
tokenBytes, err = io.ReadAll(resp.Body) _ = writer.WriteField("masterCpu", strconv.FormatUint(uint64(req.MasterCPU), 10))
if err != nil { }
return fmt.Errorf("cannot get token: %w", err) if req.MasterNum != 0 {
_ = writer.WriteField("masterNum", strconv.FormatUint(uint64(req.MasterNum), 10))
}
if req.MasterRAM != 0 {
_ = writer.WriteField("masterRam", strconv.FormatUint(uint64(req.MasterRAM), 10))
}
if req.MasterDisk != 0 {
_ = writer.WriteField("masterDisk", strconv.FormatUint(uint64(req.MasterDisk), 10))
}
if req.WorkerCPU != 0 {
_ = writer.WriteField("workerCpu", strconv.FormatUint(uint64(req.WorkerCPU), 10))
}
if req.WorkerNum != 0 {
_ = writer.WriteField("workerNum", strconv.FormatUint(uint64(req.WorkerNum), 10))
}
if req.WorkerRAM != 0 {
_ = writer.WriteField("workerRam", strconv.FormatUint(uint64(req.WorkerRAM), 10))
}
if req.WorkerDisk != 0 {
_ = writer.WriteField("workerDisk", strconv.FormatUint(uint64(req.WorkerDisk), 10))
}
if req.ExtNetID != 0 {
_ = writer.WriteField("extnetId", strconv.FormatUint(req.ExtNetID, 10))
}
if req.VinsId != 0 {
_ = writer.WriteField("vinsId", strconv.FormatUint(req.VinsId, 10))
}
if !req.WithLB {
_ = writer.WriteField("withLB", strconv.FormatBool(req.WithLB))
} }
if resp.StatusCode != 200 { _ = writer.WriteField("highlyAvailableLB", strconv.FormatBool(req.HighlyAvailable))
return fmt.Errorf("cannot get token: %s", tokenBytes)
if req.AdditionalSANs != nil {
for _, v := range req.AdditionalSANs {
_ = writer.WriteField("additionalSANs", v)
}
}
if req.InitConfiguration != "" {
_ = writer.WriteField("initConfiguration", req.InitConfiguration)
}
if req.ClusterConfiguration != "" {
_ = writer.WriteField("clusterConfiguration", req.ClusterConfiguration)
}
if req.KubeletConfiguration != "" {
_ = writer.WriteField("kubeletConfiguration", req.KubeletConfiguration)
}
if req.KubeProxyConfiguration != "" {
_ = writer.WriteField("kubeProxyConfiguration", req.KubeProxyConfiguration)
}
if req.JoinConfiguration != "" {
_ = writer.WriteField("joinConfiguration", req.JoinConfiguration)
}
if req.Description != "" {
_ = writer.WriteField("desc", req.Description)
}
if req.UserData != "" {
_ = writer.WriteField("userData", req.UserData)
} }
// save token in config _ = writer.WriteField("extnetOnly", strconv.FormatBool(req.ExtNetOnly))
token := string(tokenBytes)
ldc.cfg.Token = token
ldc.expiryTime = time.Now().AddDate(0, 0, 1)
return nil _ = writer.WriteField("authkey", token)
ct := writer.FormDataContentType()
writer.Close()
return reqBody, ct
} }
// do method performs request and returns response as an array of bytes and nil error in case of response status code 200. func createK8sCloudBrokerLegacy(req k8s_cb.CreateRequest, token string) (*bytes.Buffer, string) {
// In any other cases do returns nil response and error. reqBody := &bytes.Buffer{}
// Retries are implemented in case of connection reset errors. writer := multipart.NewWriter(reqBody)
func (ldc *LegacyDecortClient) do(req *http.Request, ctype string) ([]byte, error) { if req.OidcCertificate != "" {
// set up request headers and body part, _ := writer.CreateFormFile("oidcCertificate", "ca.crt")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded") _, _ = io.Copy(part, strings.NewReader(req.OidcCertificate))
if ctype != "" {
req.Header.Set("Content-Type", ctype)
} }
req.Header.Set("Accept", "application/json") _ = writer.WriteField("name", req.Name)
_ = writer.WriteField("rgId", strconv.FormatUint(req.RGID, 10))
_ = writer.WriteField("k8ciId", strconv.FormatUint(req.K8CIID, 10))
_ = writer.WriteField("workerGroupName", req.WorkerGroupName)
_ = writer.WriteField("networkPlugin", req.NetworkPlugin)
buf, err := io.ReadAll(req.Body) if req.MasterSEPID != 0 {
if err != nil { _ = writer.WriteField("masterSepId", strconv.FormatUint(req.MasterSEPID, 10))
return nil, err }
if req.MasterSEPPool != "" {
_ = writer.WriteField("masterSepPool", req.MasterSEPPool)
}
if req.WorkerSEPID != 0 {
_ = writer.WriteField("workerSepId", strconv.FormatUint(req.WorkerSEPID, 10))
}
if req.WorkerSEPPool != "" {
_ = writer.WriteField("workerSepPool", req.WorkerSEPPool)
} }
req.Body.Close() if req.Labels != nil {
req.Body = io.NopCloser(bytes.NewBuffer(buf)) for _, v := range req.Labels {
_ = writer.WriteField("labels", v)
}
}
if req.Taints != nil {
for _, v := range req.Taints {
_ = writer.WriteField("taints", v)
}
}
if req.Annotations != nil {
for _, v := range req.Annotations {
_ = writer.WriteField("annotations", v)
}
}
resp, err := ldc.client.Do(req) if req.MasterCPU != 0 {
if resp != nil { _ = writer.WriteField("masterCpu", strconv.FormatUint(req.MasterCPU, 10))
defer resp.Body.Close() }
} if req.MasterNum != 0 {
_ = writer.WriteField("masterNum", strconv.FormatUint(req.MasterNum, 10))
// retries logic GOES HERE }
// get http response if req.MasterRAM != 0 {
//var resp *http.Response _ = writer.WriteField("masterRam", strconv.FormatUint(req.MasterRAM, 10))
//for i := uint64(0); i < ldc.cfg.Retries; i++ {
// req := req.Clone(req.Context())
// req.Body = io.NopCloser(bytes.NewBuffer(buf))
//
// if i > 0 {
// time.Sleep(5 * time.Second) // no time sleep for the first request
// }
//
// resp, err = ldc.client.Do(req)
//
// // stop retries on success and close response body
// if resp != nil {
// defer resp.Body.Close()
// }
// if err == nil {
// break
// }
//
// // retries in case of connection errors with time sleep
// if isConnectionError(err) {
// continue
// }
//
// // return error in case of non-connection error
// return nil, err
//}
// handle http request errors
if err != nil {
return nil, err
} }
if resp == nil { if req.MasterDisk != 0 {
return nil, fmt.Errorf("got empty response without error") _ = writer.WriteField("masterDisk", strconv.FormatUint(req.MasterDisk, 10))
}
if req.WorkerCPU != 0 {
_ = writer.WriteField("workerCpu", strconv.FormatUint(req.WorkerCPU, 10))
}
if req.WorkerNum != 0 {
_ = writer.WriteField("workerNum", strconv.FormatUint(req.WorkerNum, 10))
}
if req.WorkerRAM != 0 {
_ = writer.WriteField("workerRam", strconv.FormatUint(req.WorkerRAM, 10))
}
if req.WorkerDisk != 0 {
_ = writer.WriteField("workerDisk", strconv.FormatUint(req.WorkerDisk, 10))
}
if req.ExtNetID != 0 {
_ = writer.WriteField("extnetId", strconv.FormatUint(req.ExtNetID, 10))
}
if req.VinsId != 0 {
_ = writer.WriteField("vinsId", strconv.FormatUint(req.VinsId, 10))
}
if !req.WithLB {
_ = writer.WriteField("withLB", strconv.FormatBool(req.WithLB))
} }
// handle successful request _ = writer.WriteField("highlyAvailableLB", strconv.FormatBool(req.HighlyAvailable))
respBytes, _ := io.ReadAll(resp.Body)
if resp.StatusCode == 200 { if req.AdditionalSANs != nil {
return respBytes, nil for _, v := range req.AdditionalSANs {
_ = writer.WriteField("additionalSANs", v)
}
}
if req.InitConfiguration != "" {
_ = writer.WriteField("initConfiguration", req.InitConfiguration)
}
if req.ClusterConfiguration != "" {
_ = writer.WriteField("clusterConfiguration", req.ClusterConfiguration)
}
if req.KubeletConfiguration != "" {
_ = writer.WriteField("kubeletConfiguration", req.KubeletConfiguration)
}
if req.KubeProxyConfiguration != "" {
_ = writer.WriteField("kubeProxyConfiguration", req.KubeProxyConfiguration)
}
if req.JoinConfiguration != "" {
_ = writer.WriteField("joinConfiguration", req.JoinConfiguration)
}
if req.Description != "" {
_ = writer.WriteField("desc", req.Description)
}
if req.UserData != "" {
_ = writer.WriteField("userData", req.UserData)
} }
// handle errors with status code other than 200 _ = writer.WriteField("extnetOnly", strconv.FormatBool(req.ExtNetOnly))
err = fmt.Errorf("%s", respBytes)
return nil, fmt.Errorf("could not execute request: %w", err) _ = writer.WriteField("authkey", token)
}
ct := writer.FormDataContentType()
func trimLegacyConfig(cfg *config.LegacyConfig) config.LegacyConfig { writer.Close()
cfg.DecortURL = strings.TrimSuffix(cfg.DecortURL, "/") return reqBody, ct
return *cfg
} }

@ -0,0 +1,75 @@
package account
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CreateRequest struct for creating account
type CreateRequest struct {
// Display name
// Required: true
Name string `url:"name" json:"name" validate:"required"`
// Name of the account
// Required: true
Username string `url:"username" json:"username" validate:"required"`
// Email
// Required: false
EmailAddress string `url:"emailaddress,omitempty" json:"emailaddress,omitempty" validate:"omitempty,email"`
// Max size of memory in MB
// Required: false
MaxMemoryCapacity int64 `url:"maxMemoryCapacity,omitempty" json:"maxMemoryCapacity,omitempty"`
// Max size of aggregated vdisks in GB
// Required: false
MaxVDiskCapacity int64 `url:"maxVDiskCapacity,omitempty" json:"maxVDiskCapacity,omitempty"`
// Max number of CPU cores
// Required: false
MaxCPUCapacity int64 `url:"maxCPUCapacity,omitempty" json:"maxCPUCapacity,omitempty"`
// Max sent/received network transfer peering
// Required: false
MaxNetworkPeerTransfer int64 `url:"maxNetworkPeerTransfer,omitempty" json:"maxNetworkPeerTransfer,omitempty"`
// Max number of assigned public IPs
// Required: false
MaxNumPublicIP int64 `url:"maxNumPublicIP,omitempty" json:"maxNumPublicIP,omitempty"`
// If true send emails when a user is granted access to resources
// Required: false
SendAccessEmails bool `url:"sendAccessEmails" json:"sendAccessEmails"`
// Limit (positive) or disable (0) GPU resources
// Required: false
GPUUnits int64 `url:"gpu_units,omitempty" json:"gpu_units,omitempty"`
}
// Create creates account
// Setting a cloud unit maximum to -1 or empty will not put any restrictions on the resource
func (a Account) Create(ctx context.Context, req CreateRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/account/create"
res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return 0, err
}
result, err := strconv.ParseUint(string(res), 10, 64)
if err != nil {
return 0, err
}
return result, nil
}

@ -19,18 +19,18 @@ type DeleteRequest struct {
} }
// Delete completes delete an account from the system Returns true if account is deleted or was already deleted or never existed // Delete completes delete an account from the system Returns true if account is deleted or was already deleted or never existed
func (a Account) Delete(ctx context.Context, req DeleteRequest) (string, error) { func (a Account) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err)) return false, validators.ValidationErrors(validators.GetErrors(err))
} }
url := "/cloudapi/account/delete" url := "/cloudapi/account/delete"
result, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req) _, err = a.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return "", err return false, err
} }
return string(result), nil return true, nil
} }

@ -17,6 +17,10 @@ type DeleteUserRequest struct {
// ID or emailaddress of the user to remove // ID or emailaddress of the user to remove
// Required: true // Required: true
UserID string `url:"userId" json:"userId" validate:"required"` UserID string `url:"userId" json:"userId" validate:"required"`
// Recursively revoke access rights from owned cloudspaces and vmachines
// Required: false
RecursiveDelete bool `url:"recursivedelete" json:"recursivedelete"`
} }
// DeleteUser revokes user access from the account // DeleteUser revokes user access from the account

@ -7,7 +7,7 @@ import (
var accounts = ListAccounts{ var accounts = ListAccounts{
Data: []ItemAccount{ Data: []ItemAccount{
{ {
ACL: []ListRecordACL{ ACL: []RecordACL{
{ {
IsExplicit: true, IsExplicit: true,
GUID: "", GUID: "",
@ -25,7 +25,7 @@ var accounts = ListAccounts{
UpdatedTime: 1676645275, UpdatedTime: 1676645275,
}, },
{ {
ACL: []ListRecordACL{ ACL: []RecordACL{
{ {
IsExplicit: true, IsExplicit: true,
GUID: "", GUID: "",
@ -43,7 +43,7 @@ var accounts = ListAccounts{
UpdatedTime: 1676645275, UpdatedTime: 1676645275,
}, },
{ {
ACL: []ListRecordACL{ ACL: []RecordACL{
{ {
IsExplicit: true, IsExplicit: true,
GUID: "", GUID: "",

@ -0,0 +1,58 @@
package account
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetConsumptionRequest struct to download the resources tracking files for an account
type GetConsumptionRequest struct {
// ID an account
// Required: true
AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
// Epoch represents the start time
// Required: true
Start uint64 `url:"start" json:"start" validate:"required"`
// Epoch represents the end time
// Required: true
End uint64 `url:"end" json:"end" validate:"required"`
}
// GetConsumption downloads the resources tracking files for an account within a given period
func (a Account) GetConsumption(ctx context.Context, req GetConsumptionRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/account/getConsumption"
res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return "", err
}
return string(res), nil
}
// GetConsumptionGet downloads the resources tracking files for an account within a given period
func (a Account) GetConsumptionGet(ctx context.Context, req GetConsumptionRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/account/getConsumption"
res, err := a.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return "", err
}
return string(res), nil
}

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListRequest struct to get list of accounts // ListRequest struct to get list of accounts
@ -26,15 +24,6 @@ type ListRequest struct {
// Required: false // Required: false
Status string `url:"status,omitempty" json:"status,omitempty"` Status string `url:"status,omitempty" json:"status,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Sort by zone id
// Default value: 0
// Required: false
ZoneID uint64 `url:"zone_id,omitempty" json:"zone_id,omitempty"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -46,7 +35,6 @@ type ListRequest struct {
// List gets a list of all accounts the user has access to a ListAccounts struct // List gets a list of all accounts the user has access to a ListAccounts struct
func (a Account) List(ctx context.Context, req ListRequest) (*ListAccounts, error) { func (a Account) List(ctx context.Context, req ListRequest) (*ListAccounts, error) {
res, err := a.ListRaw(ctx, req) res, err := a.ListRaw(ctx, req)
if err != nil { if err != nil {
return nil, err return nil, err
@ -64,11 +52,6 @@ func (a Account) List(ctx context.Context, req ListRequest) (*ListAccounts, erro
// ListRaw gets a list of all accounts the user has access to as an array of bytes // ListRaw gets a list of all accounts the user has access to as an array of bytes
func (a Account) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) { func (a Account) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/account/list" url := "/cloudapi/account/list"
res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -46,10 +46,6 @@ type ListComputesRequest struct {
// Required: false // Required: false
ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"` ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -61,7 +57,6 @@ type ListComputesRequest struct {
// ListComputes gets list all compute instances under specified account, accessible by the user // ListComputes gets list all compute instances under specified account, accessible by the user
func (a Account) ListComputes(ctx context.Context, req ListComputesRequest) (*ListComputes, error) { func (a Account) ListComputes(ctx context.Context, req ListComputesRequest) (*ListComputes, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListDeletedRequest struct to get a list of deleted accounts // ListDeletedRequest struct to get a list of deleted accounts
@ -29,20 +27,10 @@ type ListDeletedRequest struct {
// Find by access control list // Find by access control list
// Required: false // Required: false
ACL string `url:"acl,omitempty" json:"acl,omitempty"` ACL string `url:"acl,omitempty" json:"acl,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
} }
// ListDeleted gets list of all deleted accounts the user has access to // ListDeleted gets list of all deleted accounts the user has access to
func (a Account) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListAccounts, error) { func (a Account) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListAccounts, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/account/listDeleted" url := "/cloudapi/account/listDeleted"
res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -30,10 +30,6 @@ type ListDisksRequest struct {
// Required: false // Required: false
Type string `url:"type,omitempty" json:"type,omitempty"` Type string `url:"type,omitempty" json:"type,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -45,7 +41,6 @@ type ListDisksRequest struct {
// ListDisks gets list all currently unattached disks under specified account // ListDisks gets list all currently unattached disks under specified account
func (a Account) ListDisks(ctx context.Context, req ListDisksRequest) (*ListDisks, error) { func (a Account) ListDisks(ctx context.Context, req ListDisksRequest) (*ListDisks, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -38,10 +38,6 @@ type ListFLIPGroupsRequest struct {
// Required: false // Required: false
FLIPGroupID uint64 `url:"flipGroupId,omitempty" json:"flipGroupId,omitempty"` FLIPGroupID uint64 `url:"flipGroupId,omitempty" json:"flipGroupId,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -53,7 +49,6 @@ type ListFLIPGroupsRequest struct {
// ListFLIPGroups gets list all FLIPGroups under specified account, accessible by the user // ListFLIPGroups gets list all FLIPGroups under specified account, accessible by the user
func (a Account) ListFLIPGroups(ctx context.Context, req ListFLIPGroupsRequest) (*ListFLIPGroups, error) { func (a Account) ListFLIPGroups(ctx context.Context, req ListFLIPGroupsRequest) (*ListFLIPGroups, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -41,15 +41,10 @@ type ListRGRequest struct {
// Find by status // Find by status
// Required: false // Required: false
Status string `url:"status,omitempty" json:"status,omitempty"` Status string `url:"status,omitempty" json:"status,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
} }
// ListRG gets list of all resource groups under specified account, accessible by the user // ListRG gets list of all resource groups under specified account, accessible by the user
func (a Account) ListRG(ctx context.Context, req ListRGRequest) (*ListRG, error) { func (a Account) ListRG(ctx context.Context, req ListRGRequest) (*ListRG, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -30,10 +30,6 @@ type ListTemplatesRequest struct {
// Required: false // Required: false
Type string `url:"type,omitempty" json:"type,omitempty"` Type string `url:"type,omitempty" json:"type,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -45,7 +41,6 @@ type ListTemplatesRequest struct {
// ListTemplates gets list of templates which can be managed by this account // ListTemplates gets list of templates which can be managed by this account
func (a Account) ListTemplates(ctx context.Context, req ListTemplatesRequest) (*ListTemplates, error) { func (a Account) ListTemplates(ctx context.Context, req ListTemplatesRequest) (*ListTemplates, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -30,10 +30,6 @@ type ListVINSRequest struct {
// Required: false // Required: false
ExtIP string `url:"extIp,omitempty" json:"extIp,omitempty"` ExtIP string `url:"extIp,omitempty" json:"extIp,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -45,7 +41,6 @@ type ListVINSRequest struct {
// ListVINS gets list of all ViNSes under specified account, accessible by the user // ListVINS gets list of all ViNSes under specified account, accessible by the user
func (a Account) ListVINS(ctx context.Context, req ListVINSRequest) (*ListVINS, error) { func (a Account) ListVINS(ctx context.Context, req ListVINSRequest) (*ListVINS, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -1,34 +1,7 @@
package account package account
// Access Control List
type ListRecordACL struct {
// Whether access is explicitly specified
IsExplicit bool `json:"explicit"`
// GUID
GUID string `json:"guid"`
// Access rights
Rights string `json:"right"`
// Status
Status string `json:"status"`
// Account Type
Type string `json:"type"`
// Account owner ID
UgroupID string `json:"userGroupId"`
// Is it possible to remove
CanBeDeleted bool `json:"canBeDeleted"`
}
// Access Control List // Access Control List
type RecordACL struct { type RecordACL struct {
// Emails
Emails []string `json:"emails"`
// Whether access is explicitly specified // Whether access is explicitly specified
IsExplicit bool `json:"explicit"` IsExplicit bool `json:"explicit"`
@ -73,24 +46,12 @@ type ResourceLimits struct {
// Number of graphics cores // Number of graphics cores
GPUUnits float64 `json:"gpu_units"` GPUUnits float64 `json:"gpu_units"`
// Storage policy
StoragePolicy []StoragePolicyItem `json:"storage_policy"`
}
type StoragePolicyItem struct {
ID uint64 `json:"id"`
Limit int `json:"limit"`
} }
// Main information in one of if the list of accounts // Main information in one of if the list of accounts
type ItemAccount struct { type ItemAccount struct {
// Access Control List // Access Control List
ACL []ListRecordACL `json:"acl"` ACL []RecordACL `json:"acl"`
// Compute Features
ComputeFeatures []string `json:"computeFeatures"`
// Created time // Created time
CreatedTime uint64 `json:"createdTime"` CreatedTime uint64 `json:"createdTime"`
@ -98,9 +59,6 @@ type ItemAccount struct {
// Deleted time // Deleted time
DeletedTime uint64 `json:"deletedTime"` DeletedTime uint64 `json:"deletedTime"`
// Description
Description string `json:"desc"`
// ID // ID
ID uint64 `json:"id"` ID uint64 `json:"id"`
@ -112,9 +70,6 @@ type ItemAccount struct {
// Updated time // Updated time
UpdatedTime uint64 `json:"updatedTime"` UpdatedTime uint64 `json:"updatedTime"`
// Zones
ZoneIDs []uint64 `json:"zoneIds"`
} }
// List of accounts // List of accounts
@ -124,18 +79,6 @@ type ListAccounts struct {
EntryCount uint64 `json:"entryCount"` EntryCount uint64 `json:"entryCount"`
} }
// Policy
type Policy struct {
// Size of the disk
DiskSize float64 `json:"disksize"`
// Max size of the disk
DiskSizeMax float64 `json:"disksizemax"`
// SEPs used
SEPs map[string]map[string]DiskUsage `json:"seps"`
}
// Resources used // Resources used
type Resource struct { type Resource struct {
// Number of cores // Number of cores
@ -156,9 +99,6 @@ type Resource struct {
// Number of grafic cores // Number of grafic cores
GPU int64 `json:"gpu"` GPU int64 `json:"gpu"`
// Policies
Policies map[string]Policy `json:"policies"`
// Number of RAM // Number of RAM
RAM int64 `json:"ram"` RAM int64 `json:"ram"`
@ -219,20 +159,14 @@ type Machines struct {
Halted uint64 `json:"halted"` Halted uint64 `json:"halted"`
} }
// Detailed information about the account zone
type ZoneID struct {
// ID of zone
ID int64 `json:"id"`
// Name of zone
Name string `json:"name"`
}
// Main information about account // Main information about account
type RecordAccount struct { type RecordAccount struct {
// DCLocation // DCLocation
DCLocation string `json:"DCLocation"` DCLocation string `json:"DCLocation"`
// CKey
CKey string `json:"_ckey"`
// Access control list // Access control list
ACL []RecordACL `json:"acl"` ACL []RecordACL `json:"acl"`
@ -242,9 +176,6 @@ type RecordAccount struct {
// Company URL // Company URL
CompanyURL string `json:"companyurl"` CompanyURL string `json:"companyurl"`
// Compute Features
ComputeFeatures []string `json:"computeFeatures"`
// Computes // Computes
Computes Computes `json:"computes"` Computes Computes `json:"computes"`
@ -260,9 +191,6 @@ type RecordAccount struct {
// Created time // Created time
CreatedTime uint64 `json:"createdTime"` CreatedTime uint64 `json:"createdTime"`
// Description
Description string `json:"desc"`
// Deactivation time // Deactivation time
DeactivationTime float64 `json:"deactivationTime"` DeactivationTime float64 `json:"deactivationTime"`
@ -299,9 +227,6 @@ type RecordAccount struct {
// Status // Status
Status string `json:"status"` Status string `json:"status"`
// Storage policy ids
StoragePolicyIDs []uint64 `json:"storage_policy_ids"`
// UniqPools // UniqPools
UniqPools []interface{} `json:"uniqPools"` UniqPools []interface{} `json:"uniqPools"`
@ -316,12 +241,6 @@ type RecordAccount struct {
// VINSes // VINSes
VINSes uint64 `json:"vinses"` VINSes uint64 `json:"vinses"`
// Zone
ZoneIDs []ZoneID `json:"zoneIds"`
// Zones
DefaultZoneID uint64 `json:"defaultZoneId"`
} }
// Main information about compute // Main information about compute
@ -455,12 +374,6 @@ type ItemVINS struct {
// External IP // External IP
ExternalIP string `json:"externalIP"` ExternalIP string `json:"externalIP"`
// Extnet ID
ExtnetId uint64 `json:"extnetId"`
// Free IPs
FreeIPs int64 `json:"freeIPs"`
// ID // ID
ID uint64 `json:"id"` ID uint64 `json:"id"`
@ -587,9 +500,6 @@ type ItemRG struct {
// Deleted time // Deleted time
DeletedTime uint64 `json:"deletedTime"` DeletedTime uint64 `json:"deletedTime"`
// Description
Description string `json:"desc"`
// Resource group ID // Resource group ID
RGID uint64 `json:"id"` RGID uint64 `json:"id"`

@ -3,7 +3,6 @@ package account
import ( import (
"context" "context"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators" "repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
@ -15,18 +14,18 @@ type RestoreRequest struct {
} }
// Restore restores a deleted account // Restore restores a deleted account
func (a Account) Restore(ctx context.Context, req RestoreRequest) (string, error) { func (a Account) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err)) return false, validators.ValidationErrors(validators.GetErrors(err))
} }
url := "/cloudapi/account/restore" url := "/cloudapi/account/restore"
result, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req) _, err = a.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return "", err return false, err
} }
return string(result), nil return true, nil
} }

@ -14,10 +14,6 @@ type UpdateRequest struct {
// Required: true // Required: true
AccountID uint64 `url:"accountId" json:"accountId" validate:"required"` AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
// Description
// Required: false
Description string `url:"desc,omitempty" json:"desc,omitempty"`
// Name of the account // Name of the account
// Required: false // Required: false
Name string `url:"name,omitempty" json:"name,omitempty"` Name string `url:"name,omitempty" json:"name,omitempty"`
@ -49,15 +45,6 @@ type UpdateRequest struct {
// Limit (positive) or disable (0) GPU resources // Limit (positive) or disable (0) GPU resources
// Required: false // Required: false
GPUUnits int64 `url:"gpu_units,omitempty" json:"gpu_units,omitempty"` GPUUnits int64 `url:"gpu_units,omitempty" json:"gpu_units,omitempty"`
// List of strings with pools
// i.e.: ["sep1_poolName1", "sep2_poolName2", etc]
// Required: false
UniqPools []string `url:"uniqPools,omitempty" json:"uniqPools,omitempty"`
// Default zone ID
// Required: false
DefaultZoneID uint64 `url:"defaultZoneId,omitempty" json:"defaultZoneId,omitempty"`
} }
// Update updates an account name and resource types and limits // Update updates an account name and resource types and limits

@ -1,10 +0,0 @@
package cloudapi
import (
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/audit"
)
// Accessing the Stack method group
func (ca *CloudAPI) Audit() *audit.Audit {
return audit.New(ca.client)
}

@ -1,15 +0,0 @@
package audit
import "repository.basistech.ru/BASIS/decort-golang-sdk/interfaces"
// Structure for creating request to audit
type Audit struct {
client interfaces.Caller
}
// Builder for audit endpoint
func New(client interfaces.Caller) *Audit{
return &Audit{
client: client,
}
}

@ -1,46 +0,0 @@
package audit
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetRequest struct to get information about account
type GetRequest struct {
// Audit GUID
// Required: true
AuditGuid string `url:"audit_guid" json:"audit_guid" validate:"required"`
}
// Get gets information about audit as a RecordAudit struct
func (a Audit) Get(ctx context.Context, req GetRequest) (*RecordAudit, error) {
res, err := a.GetRaw(ctx, req)
if err != nil {
return nil, err
}
info := RecordAudit{}
err = json.Unmarshal(res, &info)
if err != nil {
return nil, err
}
return &info, nil
}
// GetRaw gets information about audit as an array of bytes
func (a Audit) GetRaw(ctx context.Context, req GetRequest) ([]byte, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/audit/get"
res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
return res, err
}

@ -1,44 +0,0 @@
package audit
// Main info about audit
type RecordAudit struct {
// Arguments
Arguments string `json:"args"`
// Call
Call string `json:"call"`
// GUID
GUID string `json:"guid"`
// Correlation ID
CorrelationID string `json:"correlation_id"`
// Kwargs
Kwargs string `json:"kwargs"`
// RemoteAddr
RemoteAddr string `json:"remote_addr"`
// Response time
ResponseTime float64 `json:"responsetime"`
// Result
Result string `json:"result"`
// Status code
StatusCode uint64 `json:"statuscode"`
// Tags
Tags string `json:"tags"`
// Timestamp
Timestamp float64 `json:"timestamp"`
// TimestampEnd
TimestampEnd float64 `json:"timestampEnd"`
// User
User string `json:"user"`
}

@ -25,10 +25,6 @@ type CreateRequest struct {
// SSH key to deploy for the specified user. Same key will be deployed to all computes of the service // SSH key to deploy for the specified user. Same key will be deployed to all computes of the service
// Required: false // Required: false
SSHKey string `url:"sshKey,omitempty" json:"sshKey,omitempty"` SSHKey string `url:"sshKey,omitempty" json:"sshKey,omitempty"`
// Zone ID
// Required: false
ZoneID uint64 `url:"zoneId,omitempty" json:"zoneId,omitempty"`
} }
// Create creates blank BasicService instance // Create creates blank BasicService instance

@ -16,7 +16,6 @@ type DeleteRequest struct {
// If set to False, Basic service will be deleted to recycle bin. Otherwise destroyed immediately // If set to False, Basic service will be deleted to recycle bin. Otherwise destroyed immediately
// Required: false // Required: false
// Default: false
Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"` Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
} }

@ -38,9 +38,12 @@ type GroupAddRequest struct {
// Required: true // Required: true
ImageID uint64 `url:"imageId" json:"imageId" validate:"required"` ImageID uint64 `url:"imageId" json:"imageId" validate:"required"`
// Compute driver like a KVM_X86, etc. // Compute driver
// should be one of:
// - KVM_X86
// - KVM_PPC
// Required: true // Required: true
Driver string `url:"driver" json:"driver" validate:"required"` Driver string `url:"driver" json:"driver" validate:"driver"`
// Storage endpoint provider ID // Storage endpoint provider ID
// Required: false // Required: false
@ -69,24 +72,6 @@ type GroupAddRequest struct {
// Meta data for working group computes, format YAML "user_data": 1111 // Meta data for working group computes, format YAML "user_data": 1111
// Required: false // Required: false
UserData string `url:"userData,omitempty" json:"userData,omitempty"` UserData string `url:"userData,omitempty" json:"userData,omitempty"`
//Chipset "i440fx" or "Q35
//Required: false
Chipset string `url:"chipset,omitempty" json:"chipset,omitempty" validate:"chipset,omitempty"`
// ID of the chosen storage policy
// Required: false
StoragePolicyID uint64 `url:"storage_policy_id,omitempty" json:"storage_policy_id,omitempty"`
}
// GetRAM returns RAM field values
func (r GroupAddRequest) GetRAM() map[string]uint64 {
res := make(map[string]uint64, 1)
res["RAM"] = r.RAM
return res
} }
// GroupAdd creates new Compute Group within BasicService. // GroupAdd creates new Compute Group within BasicService.

@ -22,12 +22,6 @@ type GroupResizeRequest struct {
// Required: true // Required: true
Count int64 `url:"count" json:"count" validate:"required"` Count int64 `url:"count" json:"count" validate:"required"`
//Chipset for new computes, either i440fx or Q35 (i440fx by default)
//Available values : i440fx, Q35
//Default value : i440fx
//Required: true
Chipset string `url:"chipset" json:"chipset" validate:"required,chipset"`
// Either delta or absolute value of computes // Either delta or absolute value of computes
// Should be one of: // Should be one of:
// - ABSOLUTE // - ABSOLUTE

@ -43,16 +43,6 @@ type GroupUpdateRequest struct {
Force bool `url:"force,omitempty" json:"force,omitempty"` Force bool `url:"force,omitempty" json:"force,omitempty"`
} }
// GetRAM returns RAM field values
func (r GroupUpdateRequest) GetRAM() map[string]uint64 {
res := make(map[string]uint64, 1)
res["RAM"] = r.RAM
return res
}
// GroupUpdate updates existing Compute group within Basic Service and apply new settings to its computes as necessary // GroupUpdate updates existing Compute group within Basic Service and apply new settings to its computes as necessary
func (b BService) GroupUpdate(ctx context.Context, req GroupUpdateRequest) (bool, error) { func (b BService) GroupUpdate(ctx context.Context, req GroupUpdateRequest) (bool, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListRequest struct to get list of BasicService instances // ListRequest struct to get list of BasicService instances
@ -42,15 +40,6 @@ type ListRequest struct {
// Required: false // Required: false
AccountName string `url:"accountName,omitempty" json:"accountName,omitempty"` AccountName string `url:"accountName,omitempty" json:"accountName,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Sort by zone id
// Default value: 0
// Required: false
ZoneID uint64 `url:"zone_id,omitempty" json:"zone_id,omitempty"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -62,7 +51,6 @@ type ListRequest struct {
// List gets list of BasicService instances associated with the specified Resource Group as a ListBasicServices struct // List gets list of BasicService instances associated with the specified Resource Group as a ListBasicServices struct
func (b BService) List(ctx context.Context, req ListRequest) (*ListBasicServices, error) { func (b BService) List(ctx context.Context, req ListRequest) (*ListBasicServices, error) {
res, err := b.ListRaw(ctx, req) res, err := b.ListRaw(ctx, req)
if err != nil { if err != nil {
return nil, err return nil, err
@ -80,11 +68,6 @@ func (b BService) List(ctx context.Context, req ListRequest) (*ListBasicServices
// ListRaw gets list of BasicService instances associated with the specified Resource Group as an array of bytes // ListRaw gets list of BasicService instances associated with the specified Resource Group as an array of bytes
func (b BService) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) { func (b BService) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/bservice/list" url := "/cloudapi/bservice/list"
res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListDeletedRequest struct to get list of deleted BasicService instances // ListDeletedRequest struct to get list of deleted BasicService instances
@ -18,10 +16,6 @@ type ListDeletedRequest struct {
// Required: false // Required: false
RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"` RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -33,11 +27,6 @@ type ListDeletedRequest struct {
// ListDeleted gets list of deleted BasicService instances associated with the specified Resource Group // ListDeleted gets list of deleted BasicService instances associated with the specified Resource Group
func (b BService) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListBasicServices, error) { func (b BService) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListBasicServices, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/bservice/listDeleted" url := "/cloudapi/bservice/listDeleted"
res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -1,42 +0,0 @@
package bservice
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateToZone struct to move basic service to another zone
type MigrateToZoneRequest struct {
// ID of the BasicService to move
// Required: true
ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
// ID of the zone to move
// Required: true
ZoneID uint64 `url:"zoneId" json:"zoneId" validate:"required"`
}
// MigrateToZone moves basic service instance to new zone
func (b BService) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/bservice/migrateToZone"
res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -88,15 +88,12 @@ type RecordBasicService struct {
// Whether user controlled // Whether user controlled
UserManaged bool `json:"userManaged"` UserManaged bool `json:"userManaged"`
// Zone ID
ZoneID uint64 `json:"zoneId"`
} }
// Main information about Compute // Main information about Compute
type ItemCompute struct { type ItemCompute struct {
// Account ID // Account ID
AccountID uint64 `json:"accountId"` AccountID uint64
// Architecture // Architecture
Architecture string `json:"arch"` Architecture string `json:"arch"`
@ -171,9 +168,6 @@ type ItemSnapshot struct {
Valid bool `json:"valid"` Valid bool `json:"valid"`
} }
// List of Snapshot
type ListSnapshots []ItemSnapshot
// List of Snapshots // List of Snapshots
type ListInfoSnapshots struct { type ListInfoSnapshots struct {
// Data // Data
@ -183,6 +177,9 @@ type ListInfoSnapshots struct {
EntryCount uint64 `json:"entryCount"` EntryCount uint64 `json:"entryCount"`
} }
// List of Snapshots inside RecordBasicService
type ListSnapshots []ItemSnapshot
// Main information about Group // Main information about Group
type RecordGroup struct { type RecordGroup struct {
// Account ID // Account ID
@ -298,9 +295,6 @@ type ItemGroupCompute struct {
// List of information about OS Users // List of information about OS Users
OSUsers ListOSUsers `json:"osUsers"` OSUsers ListOSUsers `json:"osUsers"`
//Chipset
Chipset string `json:"chipset"`
} }
// List of Group Computes // List of Group Computes
@ -385,9 +379,6 @@ type ItemBasicService struct {
// User Managed or not // User Managed or not
UserManaged bool `json:"userManaged"` UserManaged bool `json:"userManaged"`
// Zone ID
ZoneID uint64 `json:"zoneId"`
} }
// List of BasicServices // List of BasicServices

@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AbortSharedSnapshotMergeRequest struct to abort shared snapshots merge
type AbortSharedSnapshotMergeRequest struct {
// ID of the compute
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Label of the snapshot
// Required: true
Label string `url:"label" json:"label" validate:"required"`
}
// AbortSharedSnapshotMerge shared snapshots merge abort
func (c Compute) AbortSharedSnapshotMerge(ctx context.Context, req AbortSharedSnapshotMergeRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/abort_shared_snapshot_merge"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -39,7 +39,6 @@ type AffinityRuleAddRequest struct {
// Value that must match the key to be taken into account when analyzing this rule // Value that must match the key to be taken into account when analyzing this rule
// Required: false // Required: false
// Not required on purpose: despite required tag on platform, empty string is allowed
Value string `url:"value" json:"value"` Value string `url:"value" json:"value"`
} }

@ -39,7 +39,6 @@ type AffinityRuleRemoveRequest struct {
// Value that must match the key to be taken into account when analyzing this rule // Value that must match the key to be taken into account when analyzing this rule
// Required: false // Required: false
// Not required on purpose: despite required tag on platform, empty string is allowed
Value string `url:"value" json:"value"` Value string `url:"value" json:"value"`
} }

@ -39,7 +39,6 @@ type AntiAffinityRuleAddRequest struct {
// Value that must match the key to be taken into account when analyzing this rule // Value that must match the key to be taken into account when analyzing this rule
// Required: false // Required: false
// Not required on purpose: despite required tag on platform, empty string is allowed
Value string `url:"value" json:"value"` Value string `url:"value" json:"value"`
} }

@ -39,7 +39,6 @@ type AntiAffinityRuleRemoveRequest struct {
// Value that must match the key to be taken into account when analyzing this rule // Value that must match the key to be taken into account when analyzing this rule
// Required: false // Required: false
// Not required on purpose: despite required tag on platform, empty string is allowed
Value string `url:"value" json:"value"` Value string `url:"value" json:"value"`
} }

@ -12,47 +12,11 @@ import (
type AuditsRequest struct { type AuditsRequest struct {
// ID of the compute // ID of the compute
// Required: true // Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"` ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Find all audits after point in time
// Required: false
TimestampAT uint64 `url:"timestamp_at,omitempty" json:"timestamp_at,omitempty"`
// Find all audits before point in time
// Required: false
TimestampTO uint64 `url:"timestamp_to,omitempty" json:"timestamp_to,omitempty"`
// Find by user
// Required: false
User string `url:"user,omitempty" json:"user,omitempty"`
// Find by api endpoints
// Required: false
Call string `url:"call,omitempty" json:"call,omitempty"`
// Sort by one of supported fields, format ±<field>
// Required: false
SortBy string `url:"sort_by,omitempty" json:"sort_by,omitempty"`
// Page number
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
// Find by HTTP min status code
// Required: false
MinStatusCode uint64 `url:"min_status_code,omitempty" json:"min_status_code,omitempty"`
// Find by HTTP max status code
// Required: false
MaxStatusCode uint64 `url:"max_status_code,omitempty" json:"max_status_code,omitempty"`
} }
// Audits gets audit records for the specified compute object // Audits gets audit records for the specified compute object
func (c Compute) Audits(ctx context.Context, req AuditsRequest) (*ListAudits, error) { func (c Compute) Audits(ctx context.Context, req AuditsRequest) (ListAudits, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))
@ -60,7 +24,7 @@ func (c Compute) Audits(ctx context.Context, req AuditsRequest) (*ListAudits, er
url := "/cloudapi/compute/audits" url := "/cloudapi/compute/audits"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -72,5 +36,5 @@ func (c Compute) Audits(ctx context.Context, req AuditsRequest) (*ListAudits, er
return nil, err return nil, err
} }
return &list, nil return list, nil
} }

@ -1,54 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeIPRequest struct to change IP for network
type ChangeIPRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Network type
// 'EXTNET' for connect to external network directly
// 'VINS' for connect to ViNS
// Required: true
NetType string `url:"net_type" json:"net_type" validate:"computeNetType"`
// Network ID for connect to
// For EXTNET - external network ID
// For VINS - VINS ID
// Required: true
NetID uint64 `url:"net_id" json:"net_id" validate:"required"`
// IP address to which we will change the existing one, it must be from the same subnet
// Required: true
IPAddr string `url:"ip_addr" json:"ip_addr" validate:"required"`
}
// ChangeIP change reserved IP for compute instance
func (c Compute) ChangeIP(ctx context.Context, req ChangeIPRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/changeIp"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,46 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeMACRequest struct to change MAC for network
type ChangeMACRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Current mac address
// Required: true
СurrentMAC string `url:"current_mac_address" json:"current_mac_address" validate:"required"`
// the MAC address to which we will change the existing one
// Required: true
NewMAC string `url:"new_mac_address" json:"new_mac_address" validate:"required"`
}
// ChangeMAC change MAC for compute instance
func (c Compute) ChangeMAC(ctx context.Context, req ChangeMACRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/changeMac"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,46 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeMTURequest struct to change MTU for a compute
type ChangeMTURequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Interface name or MAC address
// Required: true
Interface string `url:"interface" json:"interface" validate:"required"`
// Maximum transmission unit
// Required: true
MTU uint64 `url:"mtu" json:"mtu" validate:"required" validate:"omitempty,mtu"`
}
// ChangeMTU change MTU for compute instance
func (c Compute) ChangeMTU(ctx context.Context, req ChangeMTURequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/change_mtu"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,50 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeSecGroupsRequest struct to change security groups for compute
type ChangeSecGroupsRequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Interface name or MAC address
// Required: true
Interface string `url:"interface" json:"interface" validate:"required"`
// List of security group IDs to assign to this interface
// Required: false
SecGroups []uint64 `url:"security_groups,omitempty" json:"security_groups,omitempty"`
// Flag indicating whether security groups are enabled for this interface
// Required: false
EnableSecGroups bool `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty"`
}
// ChangeSecGroups changes security groups for compute
func (c Compute) ChangeSecGroups(ctx context.Context, req ChangeSecGroupsRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/change_security_groups"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -25,11 +25,6 @@ type CloneRequest struct {
// Name of the parent's snapshot to create clone from // Name of the parent's snapshot to create clone from
// Required: false // Required: false
SnapshotName string `url:"snapshotName,omitempty" json:"snapshotName,omitempty"` SnapshotName string `url:"snapshotName,omitempty" json:"snapshotName,omitempty"`
// true ignore that the compute is running
// Default: false
// Required: false
Force bool `url:"force" json:"force"`
} }
// Clone clones compute instance // Clone clones compute instance

@ -23,7 +23,7 @@ type CreateTemplateRequest struct {
type wrapperCreateTemplateRequest struct { type wrapperCreateTemplateRequest struct {
CreateTemplateRequest CreateTemplateRequest
AsyncMode bool `url:"asyncMode"` Async bool `url:"async"`
} }
// CreateTemplate create template from compute instance // CreateTemplate create template from compute instance
@ -35,7 +35,7 @@ func (c Compute) CreateTemplate(ctx context.Context, req CreateTemplateRequest)
reqWrapped := wrapperCreateTemplateRequest{ reqWrapped := wrapperCreateTemplateRequest{
CreateTemplateRequest: req, CreateTemplateRequest: req,
AsyncMode: false, Async: false,
} }
url := "/cloudapi/compute/createTemplate" url := "/cloudapi/compute/createTemplate"
@ -62,7 +62,7 @@ func (c Compute) CreateTemplateAsync(ctx context.Context, req CreateTemplateRequ
reqWrapped := wrapperCreateTemplateRequest{ reqWrapped := wrapperCreateTemplateRequest{
CreateTemplateRequest: req, CreateTemplateRequest: req,
AsyncMode: true, Async: true,
} }
url := "/cloudapi/compute/createTemplate" url := "/cloudapi/compute/createTemplate"

@ -1,112 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CreateTemplateFromBlankRequest struct to create template from boot disk of current compute
type CreateTemplateFromBlankRequest struct {
// ID of the compute to create template from
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Name of the rescue disk
// Required: true
Name string `url:"name" json:"name" validate:"required"`
// Boot type of image BIOS or UEFI
// Required: true
BootType string `url:"boottype" json:"boottype" validate:"imageBootType"`
// Image type linux, windows or other
// Required: true
ImageType string `url:"imagetype" json:"imagetype" validate:"imageType"`
// Storage policy id of disk. The rules of the specified storage policy will be used.
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
// Username for the image
// Required: false
Username string `url:"username,omitempty" json:"username,omitempty"`
// Password for the image
// Required: false
Password string `url:"password,omitempty" json:"password,omitempty"`
// Account ID to make the image exclusive
// Required: false
AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
// Pool for image create
// Required: false
PoolName string `url:"poolName,omitempty" json:"poolName,omitempty"`
// Does this machine supports hot resize
// Default: false
// Required: false
HotResize bool `url:"hotresize" json:"hotresize"`
}
type wrapperCreateTemplateFromBlankRequest struct {
CreateTemplateFromBlankRequest
AsyncMode bool `url:"asyncMode"`
}
// CreateTemplateFromBlank creates template from boot disk of current compute in sync mode.
// It returns id of created compute and error.
func (c Compute) CreateTemplateFromBlank(ctx context.Context, req CreateTemplateFromBlankRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCreateTemplateFromBlankRequest{
CreateTemplateFromBlankRequest: req,
AsyncMode: false,
}
url := "/cloudapi/compute/createTemplateFromBlank"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return 0, err
}
result, err := strconv.ParseUint(string(res), 10, 64)
if err != nil {
return 0, err
}
return result, nil
}
// CreateTemplateFromBlankAsync creates template from boot disk of current compute in async mode.
// It returns guid of task and error.
func (c Compute) CreateTemplateFromBlankAsync(ctx context.Context, req CreateTemplateFromBlankRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCreateTemplateFromBlankRequest{
CreateTemplateFromBlankRequest: req,
AsyncMode: true,
}
url := "/cloudapi/compute/createTemplateFromBlank"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}

@ -22,10 +22,6 @@ type DiskAddRequest struct {
// Required: true // Required: true
Size uint64 `url:"size" json:"size" validate:"required"` Size uint64 `url:"size" json:"size" validate:"required"`
// Storage policy id of disk. The rules of the specified storage policy will be used.
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
// Type of the disk // Type of the disk
// Should be one of: // Should be one of:
// - D // - D

@ -1,53 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskMigrateRequest struct to migrate compute's disk to target disk
type DiskMigrateRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID source disk
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// ID target disk
// Required: true
TargetDiskID uint64 `url:"targetDiskId" json:"targetDiskId" validate:"required"`
// Migration mode. 1 - Data migration and domain update were already completed by third-party software.
// Use this if target disk already connected to compute and you only need to save changes for next reboot.
// Required: false
Mode int64 `url:"mode,omitempty" json:"mode,omitempty"`
}
// DiskMigrate - migrate compute's disk to target disk. Source disk will be detached, target disk will be attached to the same PCI slot.
// (WARNING) Current realisation is limited. No actual data migration will be performed.
// Use this API if target disk already connected to compute and you only need to save changes for next reboot (mode: 1).
func (c Compute) DiskMigrate(ctx context.Context, req DiskMigrateRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/diskMigrate"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,46 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskSwitchToReplicationRequest struct to switch disk to it's replication
type DiskSwitchToReplicationRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to switch
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// Delete replication relationship
// Required: false
StopReplication bool `url:"stopReplication" json:"stopReplication"`
}
// DiskSwitchToReplication switches disk to it's replication
func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToReplicationRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/diskSwitchToReplication"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -48,13 +48,15 @@ var computes = ListComputes{
Devices: nil, Devices: nil,
Disks: []InfoDisk{ Disks: []InfoDisk{
{ {
ID: 65191, ID: 65191,
PCISlot: 6,
}, },
}, },
Driver: "KVM_X86", Driver: "KVM_X86",
GID: 212, GID: 212,
GUID: 48500, GUID: 48500,
ID: 48500, ID: 48500,
ImageID: 9884,
Interfaces: []ItemVNFInterface{}, Interfaces: []ItemVNFInterface{},
LockStatus: "UNLOCKED", LockStatus: "UNLOCKED",
ManagerID: 0, ManagerID: 0,
@ -62,7 +64,7 @@ var computes = ListComputes{
MigrationJob: 0, MigrationJob: 0,
Milestones: 363500, Milestones: 363500,
Name: "test", Name: "test",
PinnedToStack: true, Pinned: false,
RAM: 4096, RAM: 4096,
ReferenceID: "c7cb19ac-af4a-4067-852f-c5572949207e", ReferenceID: "c7cb19ac-af4a-4067-852f-c5572949207e",
Registered: true, Registered: true,
@ -81,7 +83,7 @@ var computes = ListComputes{
UserManaged: true, UserManaged: true,
VGPUs: []uint64{}, VGPUs: []uint64{},
VINSConnected: 0, VINSConnected: 0,
ZoneID: 1, VirtualImageID: 0,
}, },
{ {
ACL: ListACL{}, ACL: ListACL{},
@ -109,13 +111,15 @@ var computes = ListComputes{
Devices: nil, Devices: nil,
Disks: []InfoDisk{ Disks: []InfoDisk{
{ {
ID: 65248, ID: 65248,
PCISlot: 6,
}, },
}, },
Driver: "KVM_X86", Driver: "KVM_X86",
GID: 212, GID: 212,
GUID: 48556, GUID: 48556,
ID: 48556, ID: 48556,
ImageID: 9884,
Interfaces: []ItemVNFInterface{}, Interfaces: []ItemVNFInterface{},
LockStatus: "UNLOCKED", LockStatus: "UNLOCKED",
ManagerID: 0, ManagerID: 0,
@ -123,10 +127,10 @@ var computes = ListComputes{
MigrationJob: 0, MigrationJob: 0,
Milestones: 363853, Milestones: 363853,
Name: "compute_2", Name: "compute_2",
Pinned: false,
RAM: 4096, RAM: 4096,
ReferenceID: "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff", ReferenceID: "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff",
Registered: true, Registered: true,
PinnedToStack: true,
ResName: "compute-48556", ResName: "compute-48556",
RGID: 79727, RGID: 79727,
RGName: "sdk_negative_fields_test", RGName: "sdk_negative_fields_test",
@ -142,7 +146,7 @@ var computes = ListComputes{
UserManaged: true, UserManaged: true,
VGPUs: []uint64{}, VGPUs: []uint64{},
VINSConnected: 0, VINSConnected: 0,
ZoneID: 5, VirtualImageID: 0,
}, },
}, },
EntryCount: 2, EntryCount: 2,

@ -27,7 +27,7 @@ func (c Compute) GetLog(ctx context.Context, req GetLogRequest) (string, error)
url := "/cloudapi/compute/getLog" url := "/cloudapi/compute/getLog"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -42,7 +42,7 @@ func (c Compute) GetLogGet(ctx context.Context, req GetLogRequest) (string, erro
return "", validators.ValidationErrors(validators.GetErrors(err)) return "", validators.ValidationErrors(validators.GetErrors(err))
} }
url := "/cloudapi/compute/getLog" url := "/cloudapi//compute/getLog"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil { if err != nil {

@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GuestAgentDisableRequest struct to disable guest agent
type GuestAgentDisableRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// Disable guest agent at a specific compute
func (c Compute) GuestAgentDisable(ctx context.Context, req GuestAgentDisableRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/guest_agent_disable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GuestAgentEnableRequest struct to enable guest agent
type GuestAgentEnableRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// Enable guest agent at a specific compute
func (c Compute) GuestAgentEnable(ctx context.Context, req GuestAgentEnableRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/guest_agent_enable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -1,48 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GuestAgentExecuteRequest struct to execute command from user to agent
type GuestAgentExecuteRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// Custom command from user to agent
// Required: true
Command string `url:"command" json:"command" validate:"required"`
// Arguments to command
// Required: true
Arguments string `url:"arguments" json:"arguments" validate:"required"`
}
// Execute guest agent command
func (c Compute) GuestAgentExecuteRequest(ctx context.Context, req GuestAgentExecuteRequest) (map[string]interface{}, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/guest_agent_execute"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
var result map[string]interface{}
err = json.Unmarshal(res, &result)
if err != nil {
return nil, err
}
return result, nil
}

@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GuestAgentFeatureGetRequest struct to feature get guest agent
type GuestAgentFeatureGetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// List of features
func (c Compute) GuestAgentFeatureGet(ctx context.Context, req GuestAgentFeatureGetRequest) ([]string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/guest_agent_feature_get"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
features := make([]string, 0)
err = json.Unmarshal(res, &features)
if err != nil {
return nil, err
}
return features, nil
}

@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GuestAgentFeatureUpdateRequest struct to feature update guest agent
type GuestAgentFeatureUpdateRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// Feature update guest agent
func (c Compute) GuestAgentFeatureUpdate(ctx context.Context, req GuestAgentFeatureUpdateRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/guest_agent_feature_update"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListRequest struct to get list of available computes // ListRequest struct to get list of available computes
@ -54,15 +52,6 @@ type ListRequest struct {
// Required: false // Required: false
IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"` IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Sort by zone id
// Default value: 0
// Required: false
ZoneID uint64 `url:"zone_id,omitempty" json:"zone_id,omitempty"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -75,7 +64,6 @@ type ListRequest struct {
// List gets list of the available computes. // List gets list of the available computes.
// Filtering based on status is possible // Filtering based on status is possible
func (c Compute) List(ctx context.Context, req ListRequest) (*ListComputes, error) { func (c Compute) List(ctx context.Context, req ListRequest) (*ListComputes, error) {
res, err := c.ListRaw(ctx, req) res, err := c.ListRaw(ctx, req)
if err != nil { if err != nil {
return nil, err return nil, err
@ -93,11 +81,6 @@ func (c Compute) List(ctx context.Context, req ListRequest) (*ListComputes, erro
// ListRaw gets list of the available computes. // ListRaw gets list of the available computes.
func (c Compute) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) { func (c Compute) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/list" url := "/cloudapi/compute/list"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListDeletedRequest struct to get deleted computes list // ListDeletedRequest struct to get deleted computes list
@ -46,10 +44,6 @@ type ListDeletedRequest struct {
// Required: false // Required: false
ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"` ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -61,11 +55,6 @@ type ListDeletedRequest struct {
// ListDeleted gets list all deleted computes // ListDeleted gets list all deleted computes
func (c Compute) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListComputes, error) { func (c Compute) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListComputes, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/listDeleted" url := "/cloudapi/compute/listDeleted"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -30,10 +30,6 @@ type ListPCIDeviceRequest struct {
// Required: false // Required: false
Status string `url:"status,omitempty" json:"status,omitempty"` Status string `url:"status,omitempty" json:"status,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -45,7 +41,6 @@ type ListPCIDeviceRequest struct {
// ListPCIDevice gets list PCI device // ListPCIDevice gets list PCI device
func (c Compute) ListPCIDevice(ctx context.Context, req ListPCIDeviceRequest) (*ListPCIDevices, error) { func (c Compute) ListPCIDevice(ctx context.Context, req ListPCIDeviceRequest) (*ListPCIDevices, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -26,10 +26,6 @@ type ListVGPURequest struct {
// Required: false // Required: false
Status string `url:"status,omitempty" json:"status,omitempty"` Status string `url:"status,omitempty" json:"status,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -45,7 +41,6 @@ type ListVGPURequest struct {
// ListVGPU gets list vGPU // ListVGPU gets list vGPU
func (c Compute) ListVGPU(ctx context.Context, req ListVGPURequest) (*ListVGPUs, error) { func (c Compute) ListVGPU(ctx context.Context, req ListVGPURequest) (*ListVGPUs, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err)) return nil, validators.ValidationErrors(validators.GetErrors(err))

@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateToRGZone struct to move compute to another zone
type MigrateToZoneRequest struct {
// ID of the compute instance to move
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the zone to move
// Required: true
ZoneID uint64 `url:"zoneId" json:"zoneId " validate:"required"`
}
// MoveToRG moves compute instance to new resource group
func (c Compute) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/migrateToZone"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -5,13 +5,13 @@ import "strconv"
// Access Control List // Access Control List
type RecordACL struct { type RecordACL struct {
// Account ACL list // Account ACL list
AccountACL ListACL `json:"accountACL"` AccountACL ListACL `json:"accountAcl"`
// Compute ACL list // Compute ACL list
ComputeACL ListACL `json:"computeACL"` ComputeACL ListACL `json:"computeAcl"`
// Resource group ACL list // Resource group ACL list
RGACL ListACL `json:"rgACL"` RGACL ListACL `json:"rgAcl"`
} }
type ListUsers struct { type ListUsers struct {
@ -214,9 +214,6 @@ type RecordNetAttach struct {
// List VNF IDs // List VNF IDs
VNFs []uint64 `json:"vnfs"` VNFs []uint64 `json:"vnfs"`
// Maximum transmission unit
MTU uint64 `json:"mtu"`
} }
// Detailed information about audit // Detailed information about audit
@ -238,13 +235,7 @@ type ItemAudit struct {
} }
// List Detailed audits // List Detailed audits
type ListAudits struct { type ListAudits []ItemAudit
// Data
Data []ItemAudit `json:"data"`
// Entry count
EntryCount uint64 `json:"entryCount"`
}
// Short information about audit // Short information about audit
type ItemShortAudit struct { type ItemShortAudit struct {
@ -305,27 +296,15 @@ type RecordCompute struct {
// List anti affinity rules // List anti affinity rules
AntiAffinityRules ListRules `json:"antiAffinityRules"` AntiAffinityRules ListRules `json:"antiAffinityRules"`
// Auto start when node restarted
AutoStart bool `json:"autoStart"`
// Architecture // Architecture
Architecture string `json:"arch"` Architecture string `json:"arch"`
// Boot order // Boot order
BootOrder []string `json:"bootOrder"` BootOrder []string `json:"bootOrder"`
// Boot type
BootType string `json:"bootType"`
// Boot disk size // Boot disk size
BootDiskSize uint64 `json:"bootdiskSize"` BootDiskSize uint64 `json:"bootdiskSize"`
// CD Image Id
CdImageId uint64 `json:"cdImageId"`
// Chipset
Chipset string `json:"chipset"`
// Clone reference // Clone reference
CloneReference uint64 `json:"cloneReference"` CloneReference uint64 `json:"cloneReference"`
@ -335,9 +314,6 @@ type RecordCompute struct {
// Compute CI ID // Compute CI ID
ComputeCIID uint64 `json:"computeciId"` ComputeCIID uint64 `json:"computeciId"`
// CPU Pin
CPUPin bool `json:"cpupin"`
// Number of cores // Number of cores
CPU uint64 `json:"cpus"` CPU uint64 `json:"cpus"`
@ -374,12 +350,6 @@ type RecordCompute struct {
// GUID // GUID
GUID uint64 `json:"guid"` GUID uint64 `json:"guid"`
// HPBacked
HPBacked bool `json:"hpBacked"`
// Hot resize
HotResize bool `json:"hotResize"`
// ID // ID
ID uint64 `json:"id"` ID uint64 `json:"id"`
@ -392,12 +362,6 @@ type RecordCompute struct {
// List interfaces // List interfaces
Interfaces ListInterfaces `json:"interfaces"` Interfaces ListInterfaces `json:"interfaces"`
// Live migration job ID
LiveMigrationJobID uint64 `json:"live_migration_job_id"`
// Loader type
LoaderType string `json:"loaderType"`
// Lock status // Lock status
LockStatus string `json:"lockStatus"` LockStatus string `json:"lockStatus"`
@ -416,18 +380,6 @@ type RecordCompute struct {
// Name // Name
Name string `json:"name"` Name string `json:"name"`
// NeedReboot
NeedReboot bool `json:"needReboot"`
// Network interface naming
NetworkInterfaceNaming string `json:"networkInterfaceNaming"`
// Numa Affinity
NumaAffinity string `json:"numaAffinity"`
//NumaNodeId
NumaNodeId int64 `json:"numaNodeId"`
// Natable VINS ID // Natable VINS ID
NatableVINSID uint64 `json:"natableVinsId"` NatableVINSID uint64 `json:"natableVinsId"`
@ -443,20 +395,11 @@ type RecordCompute struct {
// Natable VINS network name // Natable VINS network name
NatableVINSNetworkName string `json:"natableVinsNetworkName"` NatableVINSNetworkName string `json:"natableVinsNetworkName"`
// Name of OS
OSVersion string `json:"os_version"`
// List OS Users // List OS Users
OSUsers ListOSUser `json:"osUsers"` OSUsers ListOSUser `json:"osUsers"`
// Pinned to stack // Pinned or not
PinnedToStack bool `json:"pinnedToStack"` Pinned bool `json:"pinned"`
// PreferredCPU
PreferredCPU []int64 `json:"preferredCpu"`
// Qemu_quest
QemuQuest QemuQuest `json:"qemu_guest"`
// Number of RAM // Number of RAM
RAM uint64 `json:"ram"` RAM uint64 `json:"ram"`
@ -470,9 +413,6 @@ type RecordCompute struct {
// Resource name // Resource name
ResName string `json:"resName"` ResName string `json:"resName"`
// Reserved Node Cpus
ReservedNodeCpus []uint64 `json:"reservedNodeCpus"`
// Resource group ID // Resource group ID
RGID uint64 `json:"rgId"` RGID uint64 `json:"rgId"`
@ -509,106 +449,14 @@ type RecordCompute struct {
// Userdata // Userdata
Userdata interface{} `json:"userdata"` Userdata interface{} `json:"userdata"`
// vGPUs list // vGPU IDs
VGPUs []VGPUItem `json:"vgpus"` VGPUs []uint64 `json:"vgpus"`
// VNC password
VNCPassword string `json:"vncPasswd"`
// Zone ID
// Required: false
ZoneID uint64 `json:"zoneId"`
}
type QemuQuest struct {
Enabled bool `json:"enabled"`
EnabledAgentFeatures []string `json:"enabled_agent_features"`
GUID string `json:"guid"`
LastUpdate uint64 `json:"last_update"`
User string `json:"user"`
}
type VGPUItem struct {
// ID
ID uint64 `json:"id"`
// GID
GID uint64 `json:"gid"`
// Type
Type string `json:"type"`
// Mode
Mode string `json:"mode"`
// Status
Status string `json:"status"`
// ProfileID
ProfileID uint64 `json:"profileId"`
// RAM
RAM uint64 `json:"ram"`
// LastUpdateTime
LastUpdateTime uint64 `json:"lastUpdateTime"`
// CreatedTime
CreatedTime uint64 `json:"createdTime"`
// DeletedTime
DeletedTime uint64 `json:"deletedTime"`
// VMID
VMID uint64 `json:"vmid"`
// PGPuid
PGPuid uint64 `json:"pgpuid"`
// ReferenceID
ReferenceID string `json:"referenceId"`
// AccountID
AccountID uint64 `json:"accountId"`
// RgID
RgID uint64 `json:"rgId"`
// LastClaimedBy
LastClaimedBy uint64 `json:"lastClaimedBy"`
// PCISlot
PCISlot uint64 `json:"pciSlot"`
// BusNumber
BusNumber uint64 `json:"bus_number"`
// GUID
GUID uint64 `json:"guid"`
}
// Information about libvirt settings
type LibvirtSettings struct {
// TX mode
TXMode string `json:"txmode"`
// IO event
IOEventFD string `json:"ioeventfd"`
// Event ID
EventIDx string `json:"event_idx"`
// Number of queues
Queues uint64 `json:"queues"`
// RX queue size
RXQueueSize uint64 `json:"rx_queue_size"`
// TX queue size // Virtual image ID
TXQueueSize uint64 `json:"tx_queue_size"` VirtualImageID uint64 `json:"virtualImageId"`
// GUID // Virtual image name
GUID string `json:"guid"` VirtualImageName string `json:"virtualImageName"`
} }
// Main information about OS user // Main information about OS user
@ -649,9 +497,6 @@ type ListSnapSets []ItemSnapSet
// Main information about VNF // Main information about VNF
type ItemVNFInterface struct { type ItemVNFInterface struct {
// Bus number
BusNumber uint64 `json:"bus_number"`
// Connection ID // Connection ID
ConnID uint64 `json:"connId"` ConnID uint64 `json:"connId"`
@ -664,9 +509,6 @@ type ItemVNFInterface struct {
// Enabled // Enabled
Enabled bool `json:"enabled"` Enabled bool `json:"enabled"`
// Enable security groups
EnableSecGroups bool `json:"enable_secgroups"`
// FLIPGroup ID // FLIPGroup ID
FLIPGroupID uint64 `json:"flipgroupId"` FLIPGroupID uint64 `json:"flipgroupId"`
@ -679,15 +521,9 @@ type ItemVNFInterface struct {
// Listen SSH or not // Listen SSH or not
ListenSSH bool `json:"listenSsh"` ListenSSH bool `json:"listenSsh"`
// Libvirt Settings
LibvirtSettings LibvirtSettings `json:"libvirtSettings"`
// MAC // MAC
MAC string `json:"mac"` MAC string `json:"mac"`
// Maximum transmission unit
MTU uint64 `json:"mtu"`
// Name // Name
Name string `json:"name"` Name string `json:"name"`
@ -700,27 +536,15 @@ type ItemVNFInterface struct {
// Network type // Network type
NetType string `json:"netType"` NetType string `json:"netType"`
// NodeID
NodeID int64 `json:"nodeId"`
// PCI slot // PCI slot
PCISlot int64 `json:"pciSlot"` PCISlot int64 `json:"pciSlot"`
// QOS // QOS
QOS QOS `json:"qos"` QOS QOS `json:"qos"`
// List of security groups
SecGroups []uint64 `json:"security_groups"`
// SDN interface ID
SDNInterfaceID string `json:"sdn_interface_id"`
// Target // Target
Target string `json:"target"` Target string `json:"target"`
// Trunk tags
TrunkTags string `json:"trunk_tags"`
// Type // Type
Type string `json:"type"` Type string `json:"type"`
@ -755,9 +579,6 @@ type ItemComputeDisk struct {
// Boot partition // Boot partition
BootPartition uint64 `json:"bootPartition"` BootPartition uint64 `json:"bootPartition"`
// Bus number
BusNumber uint64 `json:"bus_number"`
// Created time // Created time
CreatedTime uint64 `json:"createdTime"` CreatedTime uint64 `json:"createdTime"`
@ -803,6 +624,9 @@ type ItemComputeDisk struct {
// Name // Name
Name string `json:"name"` Name string `json:"name"`
// Order
Order uint64 `json:"order"`
// Params // Params
Params string `json:"params"` Params string `json:"params"`
@ -813,13 +637,13 @@ type ItemComputeDisk struct {
Passwd string `json:"passwd"` Passwd string `json:"passwd"`
// PCI slot // PCI slot
PCISlot int64 `json:"pci_slot"` PCISlot int64 `json:"pciSlot"`
// Pool // Pool
Pool string `json:"pool"` Pool string `json:"pool"`
// Present to // Present to
PresentTo map[string]uint64 `json:"presentTo"` PresentTo []uint64 `json:"presentTo"`
// Purge time // Purge time
PurgeTime uint64 `json:"purgeTime"` PurgeTime uint64 `json:"purgeTime"`
@ -827,9 +651,6 @@ type ItemComputeDisk struct {
// Reality device number // Reality device number
RealityDeviceNumber uint64 `json:"realityDeviceNumber"` RealityDeviceNumber uint64 `json:"realityDeviceNumber"`
// Replication
Replication ItemReplication `json:"replication"`
// Resource ID // Resource ID
ResID string `json:"resId"` ResID string `json:"resId"`
@ -842,9 +663,6 @@ type ItemComputeDisk struct {
// Shareable // Shareable
Shareable bool `json:"shareable"` Shareable bool `json:"shareable"`
// Size available
SizeAvailable float64 `json:"sizeAvailable"`
// Size max // Size max
SizeMax uint64 `json:"sizeMax"` SizeMax uint64 `json:"sizeMax"`
@ -857,40 +675,14 @@ type ItemComputeDisk struct {
// Status // Status
Status string `json:"status"` Status string `json:"status"`
// Storage policy id of compute.
StoragePolicyID uint64 `json:"storage_policy_id"`
// Tech status // Tech status
TechStatus string `json:"techStatus"` TechStatus string `json:"techStatus"`
// Need to clean before destroy
ToClean bool `json:"to_clean"`
// Type // Type
Type string `json:"type"` Type string `json:"type"`
// Updated by // Virtual machine ID
UpdatedBy string `json:"updatedBy"` VMID uint64 `json:"vmid"`
}
type ItemReplication struct {
// DiskID
DiskID uint64 `json:"diskId"`
// PoolID
PoolID string `json:"poolId"`
// Role
Role string `json:"role"`
// SelfVolumeID
SelfVolumeID string `json:"selfVolumeId"`
// StorageID
StorageID string `json:"storageId"`
// VolumeID
VolumeID string `json:"volumeId"`
} }
// Main information about snapshot extend // Main information about snapshot extend
@ -966,7 +758,6 @@ type IOTune struct {
type ItemCompute struct { type ItemCompute struct {
// Access Control List // Access Control List
ACL ListACL `json:"acl"` ACL ListACL `json:"acl"`
// Account ID // Account ID
AccountID uint64 `json:"accountId"` AccountID uint64 `json:"accountId"`
@ -985,27 +776,15 @@ type ItemCompute struct {
// List anti affinity rules // List anti affinity rules
AntiAffinityRules ListRules `json:"antiAffinityRules"` AntiAffinityRules ListRules `json:"antiAffinityRules"`
// Auto start when node restarted
AutoStart bool `json:"autoStart"`
// Architecture // Architecture
Architecture string `json:"arch"` Architecture string `json:"arch"`
// Boot order // Boot order
BootOrder []string `json:"bootOrder"` BootOrder []string `json:"bootOrder"`
// Boot type
BootType string `json:"bootType"`
// Boot disk size // Boot disk size
BootDiskSize uint64 `json:"bootdiskSize"` BootDiskSize uint64 `json:"bootdiskSize"`
// CD Image Id
CdImageId uint64 `json:"cdImageId"`
// Chipset
Chipset string `json:"chipset"`
// Clone reference // Clone reference
CloneReference uint64 `json:"cloneReference"` CloneReference uint64 `json:"cloneReference"`
@ -1015,9 +794,6 @@ type ItemCompute struct {
// Compute CI ID // Compute CI ID
ComputeCIID uint64 `json:"computeciId"` ComputeCIID uint64 `json:"computeciId"`
// CPU Pin
CPUPin bool `json:"cpupin"`
// Number of cores // Number of cores
CPU uint64 `json:"cpus"` CPU uint64 `json:"cpus"`
@ -1054,24 +830,15 @@ type ItemCompute struct {
// GUID // GUID
GUID uint64 `json:"guid"` GUID uint64 `json:"guid"`
// Hot resize
HotResize bool `json:"hotResize"`
// HPBacked
HPBacked bool `json:"hpBacked"`
// ID // ID
ID uint64 `json:"id"` ID uint64 `json:"id"`
// Image ID
ImageID uint64 `json:"imageId"`
// List interfaces // List interfaces
Interfaces ListInterfaces `json:"interfaces"` Interfaces ListInterfaces `json:"interfaces"`
// Live migration job ID
LiveMigrationJobID uint64 `json:"live_migration_job_id"`
// Loader type
LoaderType string `json:"loaderType"`
// Lock status // Lock status
LockStatus string `json:"lockStatus"` LockStatus string `json:"lockStatus"`
@ -1090,33 +857,12 @@ type ItemCompute struct {
// Name // Name
Name string `json:"name"` Name string `json:"name"`
// NeedReboot // Pinned or not
NeedReboot bool `json:"needReboot"` Pinned bool `json:"pinned"`
// network interface naming
NetworkInterfaceNaming string `json:"networkInterfaceNaming"`
// Numa Affinity
NumaAffinity string `json:"numaAffinity"`
//NumaNodeId
NumaNodeId int64 `json:"numaNodeId"`
// Pinned to stack
PinnedToStack bool `json:"pinnedToStack"`
// PreferredCPU
PreferredCPU []int64 `json:"preferredCpu"`
// Number of RAM // Number of RAM
RAM uint64 `json:"ram"` RAM uint64 `json:"ram"`
// Name of OS
OSVersion string `json:"os_version"`
// Qemu_quest
QemuQuest QemuQuest `json:"qemu_guest"`
// Reference ID // Reference ID
ReferenceID string `json:"referenceId"` ReferenceID string `json:"referenceId"`
@ -1126,9 +872,6 @@ type ItemCompute struct {
// Resource name // Resource name
ResName string `json:"resName"` ResName string `json:"resName"`
// Reserved Node Cpus
ReservedNodeCpus []uint64 `json:"reservedNodeCpus"`
// Resource group ID // Resource group ID
RGID uint64 `json:"rgId"` RGID uint64 `json:"rgId"`
@ -1171,8 +914,8 @@ type ItemCompute struct {
// VINS connected // VINS connected
VINSConnected uint64 `json:"vinsConnected"` VINSConnected uint64 `json:"vinsConnected"`
// Zone ID // Virtual image ID
ZoneID uint64 `json:"zoneId"` VirtualImageID uint64 `json:"virtualImageId"`
} }
// ListInfoDisks // ListInfoDisks
@ -1182,6 +925,9 @@ type ListInfoDisks []InfoDisk
type InfoDisk struct { type InfoDisk struct {
// ID // ID
ID uint64 `json:"id"` ID uint64 `json:"id"`
// PCISlot
PCISlot int64 `json:"pciSlot"`
} }
// List information about computes // List information about computes
@ -1196,106 +942,16 @@ type ListComputes struct {
// List VGPUs // List VGPUs
type ListVGPUs struct { type ListVGPUs struct {
// Data // Data
Data []ItemVGPU `json:"data"` Data []interface{} `json:"data"`
// Entry count // Entry count
EntryCount uint64 `json:"entryCount"` EntryCount uint64 `json:"entryCount"`
} }
// Main information about vgpu device
type ItemVGPU struct {
// Account ID
AccountID uint64 `json:"accountId"`
// Created Time
CreatedTime uint64 `json:"createdTime"`
// Deleted Time
DeletedTime uint64 `json:"deletedTime"`
// GID
GID uint64 `json:"gid"`
// GUID
GUID uint64 `json:"guid"`
// ID
ID uint64 `json:"id"`
// Last Claimed By
LastClaimedBy uint64 `json:"lastClaimedBy"`
// Last Update Time
LastUpdateTime uint64 `json:"lastUpdateTime"`
// Mode
Mode string `json:"mode"`
// PCI Slot
PCISlot uint64 `json:"pciSlot"`
// PGPUID
PGPUID uint64 `json:"pgpuid"`
// Profile ID
ProfileID uint64 `json:"profileId"`
// RAM
RAM uint64 `json:"ram"`
// Reference ID
ReferenceID string `json:"referenceId"`
// RG ID
RGID uint64 `json:"rgId"`
// Status
Status string `json:"status"`
// Type
Type string `json:"type"`
// VM ID
VMID uint64 `json:"vmid"`
}
// Main information about PCI device
type ItemPCIDevice struct {
// Compute ID
ComputeID uint64 `json:"computeId"`
// Description
Description string `json:"description"`
// GUID
GUID uint64 `json:"guid"`
// HwPath
HwPath string `json:"hwPath"`
// ID
ID uint64 `json:"id"`
// Name
Name string `json:"name"`
// Resource group ID
RGID uint64 `json:"rgId"`
// Stack ID
StackID uint64 `json:"stackId"`
// Status
Status string `json:"status"`
// System name
SystemName string `json:"systemName"`
}
// List PCI devices // List PCI devices
type ListPCIDevices struct { type ListPCIDevices struct {
// Data // Data
Data []ItemPCIDevice `json:"data"` Data []interface{} `json:"data"`
// Entry count // Entry count
EntryCount uint64 `json:"entryCount"` EntryCount uint64 `json:"entryCount"`

@ -16,14 +16,9 @@ type NetAttachRequest struct {
// Network type // Network type
// 'EXTNET' for connect to external network directly // 'EXTNET' for connect to external network directly
// 'VINS' for connect to ViNS // and 'VINS' for connect to ViNS
// 'VFNIC' for connect to vfpool
// 'DPDK' for connect to DPDK
// `EMPTY` for connect empty network
// `SDT` for connect to SDN
// `TRUNK` for connect to TRUNK
// Required: true // Required: true
NetType string `url:"netType" json:"netType" validate:"computex86NetType"` NetType string `url:"netType" json:"netType" validate:"computeNetType"`
// Network ID for connect to // Network ID for connect to
// For EXTNET - external network ID // For EXTNET - external network ID
@ -34,32 +29,6 @@ type NetAttachRequest struct {
// Directly required IP address for new network interface // Directly required IP address for new network interface
// Required: false // Required: false
IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"` IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"`
// MAC address
// Required: false
MACAddr string `url:"mac_addr,omitempty" json:"mac_addr,omitempty"`
// Used only for EXTNET and DPDK
// For DPDK must be 1-9216
// For EXTNET must be 1500-9216
// Required: false
MTU uint64 `url:"mtu,omitempty" json:"mtu,omitempty" validate:"omitempty,mtu"`
// Unique identifier of logical port on SDN side
// Required: false
SDNInterfaceID string `url:"sdn_interface_id,omitempty" json:"sdn_interface_id,omitempty" validate:"omitempty"`
// List of security group IDs to assign to this interface
// Required: false
SecGroups []uint64 `url:"security_groups,omitempty" json:"security_groups,omitempty"`
// Flag indicating whether security groups are enabled for this interface
// Required: false
EnableSecGroups bool `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty"`
// Flag indicating whether this interface is enabled (only for VINS, EXTNET, DPDK, SDN, TRUNK)
// Required: false
Enabled interface{} `url:"enabled,omitempty" json:"enabled,omitempty" validate:"omitempty,isBool"`
} }
// NetAttach attaches network to compute and gets info about network // NetAttach attaches network to compute and gets info about network

@ -24,8 +24,8 @@ type PFWAddRequest struct {
PublicPortEnd int64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"` PublicPortEnd int64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"`
// Internal base port number // Internal base port number
// Required: false // Required: true
LocalBasePort uint64 `url:"localBasePort,omitempty" json:"localBasePort,omitempty"` LocalBasePort uint64 `url:"localBasePort" json:"localBasePort" validate:"required"`
// Network protocol // Network protocol
// either "tcp" or "udp" // either "tcp" or "udp"

@ -13,30 +13,25 @@ type PinToStackRequest struct {
// ID of the compute instance // ID of the compute instance
// Required: true // Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"` ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Auto start when node restarted
// Required: false
// Default: false
AutoStart bool `url:"autoStart" json:"autoStart"`
} }
// PinToStack pin compute to current stack // PinToStack pin compute to current stack
func (c Compute) PinToStack(ctx context.Context, req PinToStackRequest) (bool, error) { func (c Compute) PinToStack(ctx context.Context, req PinToStackRequest) (uint64, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err)) return 0, validators.ValidationErrors(validators.GetErrors(err))
} }
url := "/cloudapi/compute/pinToStack" url := "/cloudapi/compute/pinToStack"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return false, err return 0, err
} }
result, err := strconv.ParseBool(string(res)) result, err := strconv.ParseUint(string(res), 10, 64)
if err != nil { if err != nil {
return false, err return 0, err
} }
return result, nil return result, nil

@ -14,17 +14,9 @@ type RedeployRequest struct {
// Required: true // Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"` ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Storage policy id of compute. The rules of the specified storage policy will be used.
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
// ID of the new OS image, if image change is required // ID of the new OS image, if image change is required
// Required: false // Required: false
ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"` ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
// The OS version that will be installed on the virtual machine
// Required: false
OSVersion string `url:"os_version,omitempty" json:"os_version,omitempty"`
// new size for the boot disk in GB, if boot disk size change is required // new size for the boot disk in GB, if boot disk size change is required
// Required: false // Required: false

@ -27,20 +27,6 @@ type ResizeRequest struct {
// Force compute resize // Force compute resize
// Required: false // Required: false
Force bool `url:"force,omitempty" json:"force,omitempty"` Force bool `url:"force,omitempty" json:"force,omitempty"`
// Recommended isolated CPUs. Field is ignored if compute.cpupin=False or compute.pinned=False
// Required: false
PreferredCPU []int64 `url:"preferredCpu,omitempty" json:"preferredCpu,omitempty" validate:"omitempty,preferredCPU"`
}
// GetRAM returns RAM field values
func (r ResizeRequest) GetRAM() map[string]uint64 {
res := make(map[string]uint64, 1)
res["RAM"] = r.RAM
return res
} }
// Resize resizes compute instance // Resize resizes compute instance

@ -1,33 +0,0 @@
package compute
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// SharedSnapshotMergeStatusRequest struct to get shared snapshot merge status
type SharedSnapshotMergeStatusRequest struct {
// ID of compute instance to get log for
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// SharedSnapshotMergeStatus shared snapshots merge status
// returns a string representing either the current status or the progress percentage
func (c Compute) SharedSnapshotMergeStatus(ctx context.Context, req SharedSnapshotMergeStatusRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/compute/shared_snapshot_merge_status"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return "", err
}
return string(res), nil
}

@ -3,6 +3,7 @@ package compute
import ( import (
"context" "context"
"net/http" "net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators" "repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
@ -18,52 +19,24 @@ type SnapshotDeleteRequest struct {
Label string `url:"label" json:"label" validate:"required"` Label string `url:"label" json:"label" validate:"required"`
} }
type wrapperSnapshotDeleteRequeststruct struct {
SnapshotDeleteRequest
AsyncMode bool `url:"asyncMode"`
}
// SnapshotDelete deletes specified compute snapshot // SnapshotDelete deletes specified compute snapshot
func (c Compute) SnapshotDelete(ctx context.Context, req SnapshotDeleteRequest) (string, error) { func (c Compute) SnapshotDelete(ctx context.Context, req SnapshotDeleteRequest) (bool, error) {
err := validators.ValidateRequest(req) err := validators.ValidateRequest(req)
if err != nil { if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err)) return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperSnapshotDeleteRequeststruct{
SnapshotDeleteRequest: req,
AsyncMode: false,
} }
url := "/cloudapi/compute/snapshotDelete" url := "/cloudapi/compute/snapshotDelete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped) res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil { if err != nil {
return "", err return false, err
} }
return string(res), nil result, err := strconv.ParseBool(string(res))
}
// SnapshotDeleteAsync deletes specified compute snapshot
func (c Compute) SnapshotDeleteAsync(ctx context.Context, req SnapshotDeleteRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperSnapshotDeleteRequeststruct{
SnapshotDeleteRequest: req,
AsyncMode: true,
}
url := "/cloudapi/compute/snapshotDelete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil { if err != nil {
return "", err return false, err
} }
return string(res), nil return result, nil
} }

@ -21,54 +21,6 @@ type UpdateRequest struct {
// New description // New description
// Required: false // Required: false
Description string `url:"desc,omitempty" json:"desc,omitempty"` Description string `url:"desc,omitempty" json:"desc,omitempty"`
// Rule for VM placement with NUMA affinity.
// Possible values - none (placement without NUMA affinity),
// strict (strictly with NUMA affinity, if not possible - do not start VM),
// loose (use NUMA affinity if possible)
// Required: false
// Default: none
NumaAffinity string `url:"numaAffinity,omitempty" json:"numaAffinity,omitempty" validate:"omitempty,numaAffinity"`
// Run VM on dedicated CPUs. To use this feature, the system must be pre-configured by allocating CPUs on the physical node, true or false
// Required: false
CPUPin interface{} `url:"cpupin,omitempty" json:"cpupin,omitempty" validate:"omitempty,isBool"`
// Type of the emulated system, Q35 or i440fx
// Required: false
Chipset string `url:"chipset,omitempty" json:"chipset,omitempty" validate:"omitempty,chipset"`
// Use Huge Pages to allocate RAM of the virtual machine. The system must be pre-configured by allocating Huge Pages on the physical node, true or false
// Required: false
HPBacked interface{} `url:"hpBacked,omitempty" json:"hpBacked,omitempty" validate:"omitempty,isBool"`
// Auto start when node restarted, true or false
// Required: false
AutoStart interface{} `url:"autoStart,omitempty" json:"autoStart,omitempty" validate:"omitempty,isBool"`
// Recommended isolated CPUs. Field is ignored if compute.cpupin=False or compute.pinned=False
// Required: false
PreferredCPU []int64 `url:"preferredCpu,omitempty" json:"preferredCpu,omitempty" validate:"omitempty,preferredCPU"`
// VM type linux, windows or unknown
// Required: false
LoaderType string `url:"loaderType,omitempty" json:"loaderType,omitempty" validate:"omitempty,loaderType"`
// Boot type of image bios or uefi
// Required: false
BootType string `url:"bootType,omitempty" json:"bootType,omitempty" validate:"omitempty,imageBootType"`
// Select a network interface naming pattern for your Linux machine. eth - onboard, ens - pci slot naming.
// Required: false
NetworkInterfaceNaming string `url:"networkInterfaceNaming,omitempty" json:"networkInterfaceNaming,omitempty" validate:"omitempty,networkInterfaceNaming"`
// Does this machine supports hot resize, true or false
// Required: false
HotResize interface{} `url:"hotResize,omitempty" json:"hotResize,omitempty" validate:"omitempty,isBool"`
// The OS version that will be installed on the virtual machine
// Required: false
OSVersion string `url:"os_version,omitempty" json:"os_version,omitempty"`
} }
// Update updates some properties of the compute // Update updates some properties of the compute

@ -1,42 +0,0 @@
package disks
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeDiskStoragePolicyRequest struct to change storage policy for disk
type ChangeDiskStoragePolicyRequest struct {
// ID of the disk
// Required: true
DiskID uint64 `url:"disk_id" json:"disk_id" validate:"required"`
// ID of the storage policy to which to connect for disk
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
}
// ChangeDiskStoragePolicy changes storage policy for disk
func (d Disks) ChangeDiskStoragePolicy(ctx context.Context, req ChangeDiskStoragePolicyRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/change_disk_storage_policy"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

@ -3,9 +3,8 @@ package disks
import ( import (
"context" "context"
"net/http" "net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators" "repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
"strconv"
) )
// CreateRequest struct to create disk // CreateRequest struct to create disk
@ -14,13 +13,13 @@ type CreateRequest struct {
// Required: true // Required: true
AccountID uint64 `url:"accountId" json:"accountId" validate:"required"` AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
// Name of disk // ID of the grid (platform)
// Required: true // Required: true
Name string `url:"name" json:"name" validate:"required"` GID uint64 `url:"gid" json:"gid" validate:"required"`
// ID of the storage policy under the disk will be created // Name of disk
// Required: true // Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"` Name string `url:"name" json:"name" validate:"required"`
// Description of disk // Description of disk
// Required: false // Required: false
@ -30,6 +29,17 @@ type CreateRequest struct {
// Required: false // Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"` Size uint64 `url:"size,omitempty" json:"size,omitempty"`
// Type of disk
// - B=Boot
// - D=Data
// - T=Temp
// Required: true
Type string `url:"type" json:"type" validate:"diskType"`
// Size in GB default is 0
// Required: false
SSDSize uint64 `url:"ssdSize,omitempty" json:"ssdSize,omitempty"`
// Max IOPS disk can perform defaults to 2000 // Max IOPS disk can perform defaults to 2000
// Required: false // Required: false
IOPS uint64 `url:"iops,omitempty" json:"iops,omitempty"` IOPS uint64 `url:"iops,omitempty" json:"iops,omitempty"`

@ -20,7 +20,11 @@ type DeleteRequest struct {
// Whether to completely delete the disk, works only with non attached disks // Whether to completely delete the disk, works only with non attached disks
// Required: false // Required: false
Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"` Permanently bool `url:"permanently" json:"permanently"`
// Reason to delete
// Required: false
Reason string `url:"reason,omitempty" json:"reason,omitempty"`
} }
// Delete deletes disk by ID // Delete deletes disk by ID

@ -14,9 +14,13 @@ type DisksDeleteRequest struct {
// Required: true // Required: true
DisksIDs []uint64 `url:"diskIds" json:"diskIds" validate:"required"` DisksIDs []uint64 `url:"diskIds" json:"diskIds" validate:"required"`
// Reason for deleting the disks
// Required: true
Reason string `url:"reason" json:"reason" validate:"required"`
// Whether to completely delete the disks, works only with non attached disks // Whether to completely delete the disks, works only with non attached disks
// Required: false // Required: false
Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"` Permanently bool `url:"permanently" json:"permanently"`
} }
// DeleteDisks deletes multiple disks permanently // DeleteDisks deletes multiple disks permanently

@ -35,9 +35,9 @@ var disks = ListDisks{
ParentID: 0, ParentID: 0,
PCISlot: 6, PCISlot: 6,
Pool: "vmstor", Pool: "vmstor",
//PresentTo: []uint64{ PresentTo: []uint64{
// 27, 27,
//}, },
PurgeTime: 0, PurgeTime: 0,
ResID: "sample", ResID: "sample",
ResName: "sample", ResName: "sample",
@ -78,10 +78,10 @@ var disks = ListDisks{
ParentID: 0, ParentID: 0,
PCISlot: 6, PCISlot: 6,
Pool: "vmstor", Pool: "vmstor",
//PresentTo: []uint64{ PresentTo: []uint64{
// 27, 27,
// 27, 27,
//}, },
PurgeTime: 0, PurgeTime: 0,
ResID: "sample", ResID: "sample",
ResName: "sample", ResName: "sample",
@ -211,9 +211,9 @@ var searchDisks = ListSearchDisks{
ParentID: 0, ParentID: 0,
PCISlot: 6, PCISlot: 6,
Pool: "vmstor", Pool: "vmstor",
//PresentTo: []uint64{ PresentTo: []uint64{
// 27, 27,
//}, },
PurgeTime: 0, PurgeTime: 0,
ResID: "sample", ResID: "sample",
ResName: "sample", ResName: "sample",
@ -254,10 +254,10 @@ var searchDisks = ListSearchDisks{
ParentID: 0, ParentID: 0,
PCISlot: 6, PCISlot: 6,
Pool: "vmstor", Pool: "vmstor",
//PresentTo: []uint64{ PresentTo: []uint64{
// 27, 27,
// 27, 27,
//}, },
PurgeTime: 0, PurgeTime: 0,
ResID: "sample", ResID: "sample",
ResName: "sample", ResName: "sample",
@ -393,7 +393,7 @@ var unattachedDisks = ListDisksUnattached{
Password: "", Password: "",
PCISlot: -1, PCISlot: -1,
Pool: "data05", Pool: "data05",
PresentTo: map[string]uint64{}, PresentTo: []uint64{},
PurgeAttempts: 0, PurgeAttempts: 0,
PurgeTime: 0, PurgeTime: 0,
RealityDeviceNumber: 0, RealityDeviceNumber: 0,
@ -445,10 +445,10 @@ var unattachedDisks = ListDisksUnattached{
Password: "", Password: "",
PCISlot: -1, PCISlot: -1,
Pool: "data05", Pool: "data05",
//PresentTo: []uint64{ PresentTo: []uint64{
// 27, 27,
// 27, 27,
//}, },
PurgeAttempts: 0, PurgeAttempts: 0,
PurgeTime: 0, PurgeTime: 0,
RealityDeviceNumber: 0, RealityDeviceNumber: 0,

@ -1,111 +0,0 @@
package disks
import (
"context"
"net/http"
"strconv"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// FromPlatformDiskRequest struct to create template from platform disk
type FromPlatformDiskRequest struct {
// ID of the disk
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// Name of the rescue disk
// Required: true
Name string `url:"name" json:"name" validate:"required"`
// Boot type of image BIOS or UEFI
// Required: true
BootType string `url:"boottype" json:"boottype" validate:"imageBootType"`
// Image type linux, windows or other
// Required: true
ImageType string `url:"imagetype" json:"imagetype" validate:"imageType"`
// Username for the image
// Required: false
Username string `url:"username,omitempty" json:"username,omitempty"`
// Password for the image
// Required: false
Password string `url:"password,omitempty" json:"password,omitempty"`
// Account ID to make the image exclusive
// Required: false
AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
// Pool for image create
// Required: false
PoolName string `url:"poolName,omitempty" json:"poolName,omitempty"`
// Does this machine supports hot resize
// Required: false
HotResize bool `url:"hotresize" json:"hotresize"`
// Bootable image
// Required: true
Bootable bool `url:"bootable" json:"bootable"`
}
type wrapperFromPlatformDiskRequest struct {
FromPlatformDiskRequest
AsyncMode bool `url:"asyncMode"`
}
// FromPlatformDisk creates template from platform disk in sync mode.
// It returns id of created disk and error.
func (d Disks) FromPlatformDisk(ctx context.Context, req FromPlatformDiskRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/fromPlatformDisk"
reqWrapped := wrapperFromPlatformDiskRequest{
FromPlatformDiskRequest: req,
AsyncMode: false,
}
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return 0, err
}
result, err := strconv.ParseUint(string(res), 10, 64)
if err != nil {
return 0, err
}
return result, nil
}
// FromPlatformDiskAsync creates template from platform disk in async mode.
// It returns guid of task and error.
func (d Disks) FromPlatformDiskAsync(ctx context.Context, req FromPlatformDiskRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/fromPlatformDisk"
reqWrapped := wrapperFromPlatformDiskRequest{
FromPlatformDiskRequest: req,
AsyncMode: true,
}
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListRequest struct to get list of disks // ListRequest struct to get list of disks
@ -32,7 +30,7 @@ type ListRequest struct {
// Find by shared, true or false // Find by shared, true or false
// Required: false // Required: false
Shared interface{} `url:"shared,omitempty" json:"shared,omitempty" validate:"omitempty,isBool"` Shared bool `url:"shared,omitempty" json:"shared,omitempty"`
// ID of the account the disks belong to // ID of the account the disks belong to
// Required: false // Required: false
@ -46,18 +44,10 @@ type ListRequest struct {
// Required: false // Required: false
SEPID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"` SEPID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
// Find by storage policy id
// Required: false
StoragePolicyID uint64 `url:"storage_policy_id,omitempty" json:"storage_policy_id,omitempty"`
// Find by pool name // Find by pool name
// Required: false // Required: false
Pool string `url:"pool,omitempty" json:"pool,omitempty"` Pool string `url:"pool,omitempty" json:"pool,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -69,7 +59,6 @@ type ListRequest struct {
// List gets list of the created disks belonging to an account as a ListDisks struct // List gets list of the created disks belonging to an account as a ListDisks struct
func (d Disks) List(ctx context.Context, req ListRequest) (*ListDisks, error) { func (d Disks) List(ctx context.Context, req ListRequest) (*ListDisks, error) {
res, err := d.ListRaw(ctx, req) res, err := d.ListRaw(ctx, req)
if err != nil { if err != nil {
return nil, err return nil, err
@ -87,11 +76,6 @@ func (d Disks) List(ctx context.Context, req ListRequest) (*ListDisks, error) {
// ListRaw gets list of the created disks belonging to an account as an array of bytes // ListRaw gets list of the created disks belonging to an account as an array of bytes
func (d Disks) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) { func (d Disks) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/list" url := "/cloudapi/disks/list"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListDeletedRequest struct to get list of deleted disks // ListDeletedRequest struct to get list of deleted disks
@ -28,7 +26,7 @@ type ListDeletedRequest struct {
// Find by shared, true or false // Find by shared, true or false
// Required: false // Required: false
Shared interface{} `url:"shared,omitempty" json:"shared,omitempty" validate:"omitempty,isBool"` Shared bool `url:"shared,omitempty" json:"shared,omitempty"`
// ID of the account the disks belong to // ID of the account the disks belong to
// Required: false // Required: false
@ -38,10 +36,6 @@ type ListDeletedRequest struct {
// Required: false // Required: false
Type string `url:"type,omitempty" json:"type,omitempty"` Type string `url:"type,omitempty" json:"type,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -53,11 +47,6 @@ type ListDeletedRequest struct {
// ListDeleted gets list the deleted disks belonging to an account // ListDeleted gets list the deleted disks belonging to an account
func (d Disks) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListDisks, error) { func (d Disks) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListDisks, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/listDeleted" url := "/cloudapi/disks/listDeleted"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -4,19 +4,13 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListTypesRequest struct to get list types of disks // ListTypesRequest struct to get list types of disks
type ListTypesRequest struct { type ListTypesRequest struct {
// Show detailed disk types by seps // Show detailed disk types by seps
// Required: true // Required: true
Detailed bool `url:"detailed" json:"detailed"` Detailed bool `url:"detailed" json:"detailed" validate:"required"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
@ -29,11 +23,6 @@ type ListTypesRequest struct {
// ListTypes gets list defined disk types // ListTypes gets list defined disk types
func (d Disks) ListTypes(ctx context.Context, req ListTypesRequest) (*ListTypes, error) { func (d Disks) ListTypes(ctx context.Context, req ListTypesRequest) (*ListTypes, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/listTypes" url := "/cloudapi/disks/listTypes"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -4,8 +4,6 @@ import (
"context" "context"
"encoding/json" "encoding/json"
"net/http" "net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
) )
// ListUnattachedRequest struct to get list of unattached disk // ListUnattachedRequest struct to get list of unattached disk
@ -38,18 +36,10 @@ type ListUnattachedRequest struct {
// Required: false // Required: false
SEPID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"` SEPID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
// Find by storage policy id
// Required: false
StoragePolicyID uint64 `url:"storage_policy_id,omitempty" json:"storage_policy_id,omitempty"`
// Find by pool name // Find by pool name
// Required: false // Required: false
Pool string `url:"pool,omitempty" json:"pool,omitempty"` Pool string `url:"pool,omitempty" json:"pool,omitempty"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
// Page number // Page number
// Required: false // Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"` Page uint64 `url:"page,omitempty" json:"page,omitempty"`
@ -61,11 +51,6 @@ type ListUnattachedRequest struct {
// ListUnattached gets list of unattached disks // ListUnattached gets list of unattached disks
func (d Disks) ListUnattached(ctx context.Context, req ListUnattachedRequest) (*ListDisksUnattached, error) { func (d Disks) ListUnattached(ctx context.Context, req ListUnattachedRequest) (*ListDisksUnattached, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/listUnattached" url := "/cloudapi/disks/listUnattached"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req) res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)

@ -14,15 +14,9 @@ type ItemDisk struct {
// Computes // Computes
Computes map[string]string `json:"computes"` Computes map[string]string `json:"computes"`
//Created by
CreatedBy string `json:"createdBy"`
// Created time // Created time
CreatedTime uint64 `json:"createdTime"` CreatedTime uint64 `json:"createdTime"`
// Deleted by
DeletedBy string `json:"deletedBy"`
// Deleted time // Deleted time
DeletedTime uint64 `json:"deletedTime"` DeletedTime uint64 `json:"deletedTime"`
@ -56,9 +50,6 @@ type ItemDisk struct {
// Machine name // Machine name
MachineName string `json:"machineName"` MachineName string `json:"machineName"`
// Milestones
Milestones uint64 `json:"milestones"`
// Name // Name
Name string `json:"name"` Name string `json:"name"`
@ -78,14 +69,11 @@ type ItemDisk struct {
Pool string `json:"pool"` Pool string `json:"pool"`
// Present to // Present to
PresentTo map[string]uint64 `json:"presentTo"` PresentTo []uint64 `json:"presentTo"`
// Purge time // Purge time
PurgeTime uint64 `json:"purgeTime"` PurgeTime uint64 `json:"purgeTime"`
// Replication
Replication ItemReplication `json:"replication"`
// Resource ID // Resource ID
ResID string `json:"resId"` ResID string `json:"resId"`
@ -104,9 +92,6 @@ type ItemDisk struct {
// SepID // SepID
SepID uint64 `json:"sepId"` SepID uint64 `json:"sepId"`
// Size available
SizeAvailable float64 `json:"sizeAvailable"`
// Size max // Size max
SizeMax uint64 `json:"sizeMax"` SizeMax uint64 `json:"sizeMax"`
@ -119,26 +104,14 @@ type ItemDisk struct {
// Status // Status
Status string `json:"status"` Status string `json:"status"`
// Storage policy ID
StoragePolicyID uint64 `json:"storage_policy_id"`
// Tech status // Tech status
TechStatus string `json:"techStatus"` TechStatus string `json:"techStatus"`
// Need to clean before destroy
ToClean bool `json:"to_clean"`
// Type // Type
Type string `json:"type"` Type string `json:"type"`
// Virtual machine ID // Virtual machine ID
VMID uint64 `json:"vmid"` VMID uint64 `json:"vmid"`
// Update time
UpdatedTime uint64 `json:"updatedTime"`
// Updated by
UpdatedBy string `json:"updatedBy"`
} }
type ItemDiskUnattached struct { type ItemDiskUnattached struct {
@ -224,7 +197,7 @@ type ItemDiskUnattached struct {
Pool string `json:"pool"` Pool string `json:"pool"`
// Present to // Present to
PresentTo map[string]uint64 `json:"presentTo"` PresentTo []uint64 `json:"presentTo"`
// Purge attempts // Purge attempts
PurgeAttempts uint64 `json:"purgeAttempts"` PurgeAttempts uint64 `json:"purgeAttempts"`
@ -289,10 +262,8 @@ type ListDisks struct {
// List of unattached disks // List of unattached disks
type ListDisksUnattached struct { type ListDisksUnattached struct {
// Data
Data []ItemDiskUnattached `json:"data"` Data []ItemDiskUnattached `json:"data"`
// Entry count
EntryCount uint64 `json:"entryCount"` EntryCount uint64 `json:"entryCount"`
} }
@ -378,15 +349,9 @@ type RecordDisk struct {
// Computes // Computes
Computes map[string]string `json:"computes"` Computes map[string]string `json:"computes"`
// Created by
CreatedBy string `json:"createdBy"`
// Created time // Created time
CreatedTime uint64 `json:"createdTime"` CreatedTime uint64 `json:"createdTime"`
// Deleted by
DeletedBy string `json:"deletedBy"`
// Deleted time // Deleted time
DeletedTime uint64 `json:"deletedTime"` DeletedTime uint64 `json:"deletedTime"`
@ -414,15 +379,6 @@ type RecordDisk struct {
// IOTune // IOTune
IOTune IOTune `json:"iotune"` IOTune IOTune `json:"iotune"`
// Machine ID
MachineID uint64 `json:"machineId"`
// Machine name
MachineName string `json:"machineName"`
// Milestones
Milestones uint64 `json:"milestones"`
// Name // Name
Name string `json:"name"` Name string `json:"name"`
@ -442,14 +398,11 @@ type RecordDisk struct {
Pool string `json:"pool"` Pool string `json:"pool"`
// Present to // Present to
PresentTo map[string]uint64 `json:"presentTo"` PresentTo []uint64 `json:"presentTo"`
// Purge time // Purge time
PurgeTime uint64 `json:"purgeTime"` PurgeTime uint64 `json:"purgeTime"`
// Replication
Replication ItemReplication `json:"replication"`
// Resource ID // Resource ID
ResID string `json:"resId"` ResID string `json:"resId"`
@ -468,9 +421,6 @@ type RecordDisk struct {
// Shareable // Shareable
Shareable bool `json:"shareable"` Shareable bool `json:"shareable"`
// Size available
SizeAvailable float64 `json:"sizeAvailable"`
// Size max // Size max
SizeMax uint64 `json:"sizeMax"` SizeMax uint64 `json:"sizeMax"`
@ -483,46 +433,14 @@ type RecordDisk struct {
// Status // Status
Status string `json:"status"` Status string `json:"status"`
// Storage policy ID
StoragePolicyID uint64 `json:"storage_policy_id"`
// Tech status // Tech status
TechStatus string `json:"techStatus"` TechStatus string `json:"techStatus"`
// Need to clean before destroy
ToClean bool `json:"to_clean"`
// Type // Type
Type string `json:"type"` Type string `json:"type"`
// Virtual machine ID // Virtual machine ID
VMID uint64 `json:"vmid"` VMID uint64 `json:"vmid"`
// Update time
UpdatedTime uint64 `json:"updatedTime"`
// Updated by
UpdatedBy string `json:"updatedBy"`
}
type ItemReplication struct {
// DiskID
DiskID uint64 `json:"diskId"`
// PoolID
PoolID string `json:"poolId"`
// Role
Role string `json:"role"`
// SelfVolumeID
SelfVolumeID string `json:"selfVolumeId"`
// StorageID
StorageID string `json:"storageId"`
// VolumeID
VolumeID string `json:"volumeId"`
} }
type ListTypes struct { type ListTypes struct {

@ -1,56 +0,0 @@
package disks
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ReplicateRequest struct to create an empty disk in chosen SEP and pool combination.
type ReplicateRequest struct {
// Id of the disk to replicate. This disk will become master in replication
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// Name of replica disk to create
// Required: true
Name string `url:"name" json:"name" validate:"required"`
// ID of SEP to create slave disk
// Required: true
SepID uint64 `url:"sepId" json:"sepId" validate:"required"`
// Pool name to create slave disk in
// Required: true
PoolName string `url:"poolName" json:"poolName" validate:"required"`
// ID of the storage policy under the disk will be created
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
}
// Replicate create an empty disk in chosen SEP and pool combination.
// Starts replication between chosen disk and newly created disk
// Note: only TATLIN type SEP are supported for replications between
func (d Disks) Replicate(ctx context.Context, req ReplicateRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudapi/disks/replicate"
res, err := d.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return 0, err
}
result, err := strconv.ParseUint(string(res), 10, 64)
if err != nil {
return 0, err
}
return result, nil
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save