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

test git

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

68
pkg/cloudbroker/compute/abort_shared_snapshot_merge.go
View File

@@ -1,68 +0,0 @@
package compute
import (
"context"
"net/http"
"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"`
}
type wrapperAbortSharedSnapshotMergeRequest struct {
AbortSharedSnapshotMergeRequest
AsyncMode bool `url:"asyncMode"`
}
// AbortSharedSnapshotMerge shared snapshots merge abort
func (c Compute) AbortSharedSnapshotMerge(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
AbortSharedSnapshotMergeRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/abort_shared_snapshot_merge"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}
// AbortSharedSnapshotMergeAsync shared snapshots merge abort in async mode
func (c Compute) AbortSharedSnapshotMergeAsync(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
AbortSharedSnapshotMergeRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/abort_shared_snapshot_merge"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

36
pkg/cloudbroker/compute/affinity_group_check_start.go
View File

@@ -1,36 +0,0 @@
package compute
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityGroupCheckStartRequest struct to check all computes with current affinity label can start
type AffinityGroupCheckStartRequest struct {
// ID of the resource group
// Required: true
RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
// Affinity group label
// Required: true
AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
}
// AffinityGroupCheckStart check all computes with current affinity label can start
func (c Compute) AffinityGroupCheckStart(ctx context.Context, req AffinityGroupCheckStartRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityGroupCheckStart"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return "", err
}
return string(res), nil
}

38
pkg/cloudbroker/compute/affinity_label_remove.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityLabelRemoveRequest struct for clear affinity label for compute
type AffinityLabelRemoveRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
}
// AffinityLabelRemove clear affinity label for compute
func (c Compute) AffinityLabelRemove(ctx context.Context, req AffinityLabelRemoveRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityLabelRemove"
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
}

41
pkg/cloudbroker/compute/affinity_label_set.go
View File

@@ -1,41 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityLabelSetRequest struct to set affinity label for compute
type AffinityLabelSetRequest struct {
// IDs of the compute instances
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Affinity group label
// Required: true
AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
}
// AffinityLabelSet sets affinity label for compute
func (c Compute) AffinityLabelSet(ctx context.Context, req AffinityLabelSetRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityLabelSet"
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
}

40
pkg/cloudbroker/compute/affinity_relations.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityRelationsRequest struct to get dict of computes
type AffinityRelationsRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// AffinityRelations gets dict of computes divided by affinity and anti affinity rules
func (c Compute) AffinityRelations(ctx context.Context, req AffinityRelationsRequest) (*RecordAffinityRelations, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityRelations"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
info := RecordAffinityRelations{}
err = json.Unmarshal(res, &info)
if err != nil {
return nil, err
}
return &info, nil
}

67
pkg/cloudbroker/compute/affinity_rule_add.go
View File

@@ -1,67 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityRuleAddRequest struct to add affinity rule
type AffinityRuleAddRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Should be one of:
// - node
// - compute
// Required: true
Topology string `url:"topology" json:"topology" validate:"computeTopology"`
// The degree of 'strictness' of this rule
// Should be one of:
// - RECOMMENDED
// - REQUIRED
// Required: true
Policy string `url:"policy" json:"policy" validate:"computePolicy"`
// The comparison mode is 'value', recorded by the specified 'key'
// Should be one of:
// - EQ
// - EN
// - ANY
// Required: true
Mode string `url:"mode" json:"mode" validate:"computeMode"`
// Key that are taken into account when analyzing this rule will be identified
// Required: true
Key string `url:"key" json:"key" validate:"required"`
// Value that must match the key to be taken into account when analyzing this rule
// Required: true
Value string `url:"value" json:"value" validate:"required"`
}
// AffinityRuleAdd adds affinity rule
func (c Compute) AffinityRuleAdd(ctx context.Context, req AffinityRuleAddRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityRuleAdd"
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
}

65
pkg/cloudbroker/compute/affinity_rule_remove.go
View File

@@ -1,65 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityRuleRemoveRequest struct to remove affinity rule
type AffinityRuleRemoveRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Compute or node, for whom rule applies
// Required: true
Topology string `url:"topology" json:"topology" validate:"computeTopology"`
// The degree of 'strictness' of this rule
// Should be one of:
// - RECOMMENDED
// - REQUIRED
// Required: true
Policy string `url:"policy" json:"policy" validate:"computePolicy"`
// The comparison mode is 'value', recorded by the specified 'key'
// Should be one of:
// - EQ
// - EN
// - ANY
// Required: true
Mode string `url:"mode" json:"mode" validate:"computeMode"`
// Key that are taken into account when analyzing this rule will be identified
// Required: true
Key string `url:"key" json:"key" validate:"required"`
// Value that must match the key to be taken into account when analyzing this rule
// Required: true
Value string `url:"value" json:"value" validate:"required"`
}
// AffinityRuleRemove remove affinity rule
func (c Compute) AffinityRuleRemove(ctx context.Context, req AffinityRuleRemoveRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityRuleRemove"
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
}

38
pkg/cloudbroker/compute/affinity_rules_clear.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AffinityRulesClearRequest struct to clear affinity rules
type AffinityRulesClearRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
}
// AffinityRulesClear clears affinity rules
func (c Compute) AffinityRulesClear(ctx context.Context, req AffinityRulesClearRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/affinityRulesClear"
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
}

65
pkg/cloudbroker/compute/anti_affinity_rule_add.go
View File

@@ -1,65 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AntiAffinityRuleAddRequest struct to add anti affinity rule
type AntiAffinityRuleAddRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Compute or node, for whom rule applies
// Required: true
Topology string `url:"topology" json:"topology" validate:"computeTopology"`
// The degree of 'strictness' of this rule
// Should be one of:
// - RECOMMENDED
// - REQUIRED
// Required: true
Policy string `url:"policy" json:"policy" validate:"computePolicy"`
// The comparison mode is 'value', recorded by the specified 'key'
// Should be one of:
// - EQ
// - EN
// - ANY
// Required: true
Mode string `url:"mode" json:"mode" validate:"computeMode"`
// Key that are taken into account when analyzing this rule will be identified
// Required: true
Key string `url:"key" json:"key" validate:"required"`
// Value that must match the key to be taken into account when analyzing this rule
// Required: true
Value string `url:"value" json:"value" validate:"required"`
}
// AntiAffinityRuleAdd adds anti affinity rule
func (c Compute) AntiAffinityRuleAdd(ctx context.Context, req AntiAffinityRuleAddRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/antiAffinityRuleAdd"
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
}

38
pkg/cloudbroker/compute/anti_affinity_rule_clear.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AntiAffinityRulesClearRequest struct to clear anti affinity rules
type AntiAffinityRulesClearRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
}
// AntiAffinityRulesClear clear anti affinity rules
func (c Compute) AntiAffinityRulesClear(ctx context.Context, req AntiAffinityRulesClearRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/antiAffinityRulesClear"
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
}

65
pkg/cloudbroker/compute/anti_affinity_rule_remove.go
View File

@@ -1,65 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AntiAffinityRuleRemoveRequest struct to remove anti affinity rule
type AntiAffinityRuleRemoveRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Compute or node, for whom rule applies
// Required: true
Topology string `url:"topology" json:"topology" validate:"computeTopology"`
// The degree of 'strictness' of this rule
// Should be one of:
// - RECOMMENDED
// - REQUIRED
// Required: true
Policy string `url:"policy" json:"policy" validate:"computePolicy"`
// The comparison mode is 'value', recorded by the specified 'key'
// Should be one of:
// - EQ
// - EN
// - ANY
// Required: true
Mode string `url:"mode" json:"mode" validate:"computeMode"`
// Key that are taken into account when analyzing this rule will be identified
// Required: true
Key string `url:"key" json:"key" validate:"required"`
// Value that must match the key to be taken into account when analyzing this rule
// Required: true
Value string `url:"value" json:"value" validate:"required"`
}
// AntiAffinityRuleRemove removes anti affinity rule
func (c Compute) AntiAffinityRuleRemove(ctx context.Context, req AntiAffinityRuleRemoveRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/antiAffinityRuleRemove"
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
}

42
pkg/cloudbroker/compute/attach_gpu.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AttachGPURequest struct to attach GPU for compute
type AttachGPURequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Identifier vGPU
// Required: true
VGPUID uint64 `url:"vgpuId" json:"vgpuId" validate:"required"`
}
// AttachGPU attaches GPU for compute, returns vGPU ID on success
func (c Compute) AttachGPU(ctx context.Context, req AttachGPURequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/attachGpu"
res, err := c.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
}

42
pkg/cloudbroker/compute/attach_pci_device.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AttachPCIDeviceRequest struct to attach PCI device
type AttachPCIDeviceRequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// PCI device ID
// Required: true
DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
}
// AttachPCIDevice attaches PCI device
func (c Compute) AttachPCIDevice(ctx context.Context, req AttachPCIDeviceRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/attachPciDevice"
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
}

76
pkg/cloudbroker/compute/audits.go
View File

@@ -1,76 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// AuditsRequest struct to get audit records
type AuditsRequest struct {
// ID of the compute
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" 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
func (c Compute) Audits(ctx context.Context, req AuditsRequest) (*ListDetailedAudits, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/audits"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return nil, err
}
list := ListDetailedAudits{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

42
pkg/cloudbroker/compute/boot_disk_set.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// BootDiskSetRequest struct to set boot disk for compute
type BootDiskSetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to set as boot
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
}
// BootDiskSet sets boot disk for compute
func (c Compute) BootDiskSet(ctx context.Context, req BootDiskSetRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/bootDiskSet"
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
}

40
pkg/cloudbroker/compute/boot_order_get.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// BootOrderGetRequest struct to get boot order
type BootOrderGetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// BootOrderGet gets actual compute boot order information
func (c Compute) BootOrderGet(ctx context.Context, req BootOrderGetRequest) ([]string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/bootOrderGet"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
orders := make([]string, 0)
err = json.Unmarshal(res, &orders)
if err != nil {
return nil, err
}
return orders, nil
}

48
pkg/cloudbroker/compute/boot_order_set.go
View File

@@ -1,48 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// BootOrderSetRequest struct to set boot order
type BootOrderSetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// List of boot devices
// Should be one of:
// - cdrom
// - network
// - hd
// Required: true
Order []string `url:"order" json:"order" validate:"min=1,computeOrder"`
}
// BootOrderSet sets compute boot order
func (c Compute) BootOrderSet(ctx context.Context, req BootOrderSetRequest) ([]string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/bootOrderSet"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
orders := make([]string, 0)
err = json.Unmarshal(res, &orders)
if err != nil {
return nil, err
}
return orders, nil
}

71
pkg/cloudbroker/compute/cd_eject.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CDEjectRequest struct to eject CD image
type CDEjectRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperCDEjectRequest struct {
CDEjectRequest
AsyncMode bool `url:"asyncMode"`
}
// CDEject ejects CD image to compute's CD-ROM
func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCDEjectRequest{
CDEjectRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/cdEject"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, err
}
// CDEjectAsync ejects CD image to compute's CD-ROM with AsyncMode
func (c Compute) CDEjectAsync(ctx context.Context, req CDEjectRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCDEjectRequest{
CDEjectRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/cdEject"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

69
pkg/cloudbroker/compute/cd_insert.go
View File

@@ -1,69 +0,0 @@
package compute
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CDInsertRequest struct to insert new CD image
type CDInsertRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of CD-ROM image
// Required: true
CDROMID uint64 `url:"cdromId" json:"cdromId" validate:"required"`
}
type wrapperCDInsertRequest struct {
CDInsertRequest
AsyncMode bool `url:"asyncMode"`
}
// CDInsert inserts new CD image to compute's CD-ROM
func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCDInsertRequest{
CDInsertRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/cdInsert"
_, err = c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
return true, nil
}
// CDInsertAsync inserts new CD image to compute's CD-ROM with AsyncMode
func (c Compute) CDInsertAsync(ctx context.Context, req CDInsertRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCDInsertRequest{
CDInsertRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/cdInsert"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

87
pkg/cloudbroker/compute/change_ip.go
View File

@@ -1,87 +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"`
}
type wrapperChangeIPRequest struct {
ChangeIPRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperChangeIPRequest{
ChangeIPRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/changeIp"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ChangeIPAsync change reserved IP for compute instance with AsyncMode
func (c Compute) ChangeIPAsync(ctx context.Context, req ChangeIPRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperChangeIPRequest{
ChangeIPRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/changeIp"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

80
pkg/cloudbroker/compute/change_link_state.go
View File

@@ -1,80 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeLinkStateRequest struct for changing link state
type ChangeLinkStateRequest struct {
// Compute ID
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Interface name or MAC address
// Required: true
Interface string `url:"interface" json:"interface" validate:"required"`
// Interface state
// Must be either "on" or "off"
// Required: true
State string `url:"state" json:"state" validate:"required,interfaceState"`
}
type wrapperChangeLinkStateRequest struct {
ChangeLinkStateRequest
AsyncMode bool `url:"asyncMode"`
}
// ChangeLinkState changes the status link virtual of compute
func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperChangeLinkStateRequest{
ChangeLinkStateRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/changeLinkState"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ChangeLinkStateAsync changes the status link virtual of compute with AsyncMode
func (c Compute) ChangeLinkStateAsync(ctx context.Context, req ChangeLinkStateRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperChangeLinkStateRequest{
ChangeLinkStateRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/changeLinkState"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

46
pkg/cloudbroker/compute/change_mac.go
View File

@@ -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 := "/cloudbroker/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
}

79
pkg/cloudbroker/compute/change_mtu.go
View File

@@ -1,79 +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"`
}
type wrapperChangeMTURequest struct {
ChangeMTURequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperChangeMTURequest{
ChangeMTURequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/change_mtu"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ChangeMTUAsync change MTU for compute instance with AsyncMode
func (c Compute) ChangeMTUAsync(ctx context.Context, req ChangeMTURequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperChangeMTURequest{
ChangeMTURequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/change_mtu"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

41
pkg/cloudbroker/compute/change_read_only.go
View File

@@ -1,41 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ChangeReadOnlyRequest defines parameters for toggling read-only mode.
type ChangeReadOnlyRequest struct {
// Compute ID
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
// ReadOnly indicates whether the read-only mode is enabled
// Required: true
ReadOnly bool `url:"read_only" json:"read_only" validate:"required"`
}
// ChangeReadOnly toggles compute read-only mode.
func (c Compute) ChangeReadOnly(ctx context.Context, req ChangeReadOnlyRequest) (bool, error) {
if err := validators.ValidateRequest(req); err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/change_read_only"
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
}

83
pkg/cloudbroker/compute/change_secutity_group.go
View File

@@ -1,83 +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 interface{} `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty" validate:"omitempty,isBool"`
}
type wrapperChangeSecGroupsRequest struct {
ChangeSecGroupsRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperChangeSecGroupsRequest{
ChangeSecGroupsRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/change_security_groups"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ChangeSecGroupsAsync changes security groups for compute with AsyncMode
func (c Compute) ChangeSecGroupsAsync(ctx context.Context, req ChangeSecGroupsRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperChangeSecGroupsRequest{
ChangeSecGroupsRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/change_security_groups"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

47
pkg/cloudbroker/compute/check_compute_placement.go
View File

@@ -1,47 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CheckComputePlacementRequest struct for check compute placement
type CheckComputePlacementRequest struct {
// IDs of compute instances to check
// Required: true
ComputeIDs []uint64 `url:"compute_ids" json:"compute_ids" validate:"required"`
// Filter by CPU and RAM when checking placement
// Required: false
// Default: true
FilterByCPURAM interface{} `url:"filter_by_cpu_ram,omitempty" json:"filter_by_cpu_ram,omitempty" validate:"omitempty,isBool"`
}
// CheckComputePlacement checks compute placement and returns structured result
func (c Compute) CheckComputePlacement(ctx context.Context, req CheckComputePlacementRequest) (CheckComputePlacementResult, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/check_compute_placement"
if req.FilterByCPURAM == nil {
req.FilterByCPURAM = true
}
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
result := make(CheckComputePlacementResult)
if err := json.Unmarshal(res, &result); err != nil {
return nil, err
}
return result, nil
}

95
pkg/cloudbroker/compute/clone.go
View File

@@ -1,95 +0,0 @@
package compute
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CloneRequest struct to clone compute instance
type CloneRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Name of the clone
// Required: true
Name string `url:"name" json:"name" validate:"required"`
// ID of the Storage Policy
// Required: true
StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
// Timestamp of the parent's snapshot to create clone from
// Required: false
SnapshotTimestamp uint64 `url:"snapshotTimestamp" json:"snapshotTimestamp"`
// Name of the parent's snapshot to create clone from
// Required: false
SnapshotName string `url:"snapshotName" json:"snapshotName"`
// true ignore that the compute is running
// Default: false
// Required: false
Force bool `url:"force" json:"force"`
// The name of the pool to migrate disks to
// Required: false
PoolName string `url:"pool_name" json:"pool_name"`
// The ID of the SEP to migrate disks to
// Required: false
SEPID uint64 `url:"sep_id" json:"sep_id"`
}
type wrapperCloneRequest struct {
CloneRequest
AsyncMode bool `url:"asyncMode" json:"asyncMode"`
}
// Clone clones compute instance
func (c Compute) Clone(ctx context.Context, req CloneRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCloneRequest{
CloneRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/clone"
res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}
// CloneAsync clones compute instance with AsyncMode
func (c Compute) CloneAsync(ctx context.Context, req CloneRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCloneRequest{
CloneRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/clone"
res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

41
pkg/cloudbroker/compute/clone_abort.go
View File

@@ -1,41 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CloneAbortRequest struct to abort a compute clone
type CloneAbortRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// CloneAbort aborts a compute clone
func (c Compute) CloneAbort(ctx context.Context, req CloneAbortRequest) ([]RecordCloneAbort, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/clone_abort"
res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
if err != nil {
return nil, err
}
result := make([]RecordCloneAbort, 0)
err = json.Unmarshal(res, &result)
if err != nil {
return nil, err
}
return result, nil
}

40
pkg/cloudbroker/compute/clone_status.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetCloneStatusRequest struct to get information about compute clone status
type GetCloneStatusRequest struct {
// ID of compute instance
// Required: true
ComputeID string `url:"compute_id" json:"compute_id" validate:"required"`
}
// GetCloneStatus gets information about compute clone status as a RecordCloneStatus struct
func (c Compute) GetCloneStatus(ctx context.Context, req GetCloneStatusRequest) ([]RecordCloneStatus, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/clone_status"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return nil, err
}
cloneStatus := make([]RecordCloneStatus, 0)
err = json.Unmarshal(res, &cloneStatus)
if err != nil {
return nil, err
}
return cloneStatus, nil
}

16
pkg/cloudbroker/compute/compute.go
View File

@@ -1,16 +0,0 @@
// API Actor for managing Compute. This actor is a final API for admin to manage Compute
package compute
import "repository.basistech.ru/BASIS/decort-golang-sdk/interfaces"
// Structure for creating request to compute
type Compute struct {
client interfaces.Caller
}
// Builder for compute endpoints
func New(client interfaces.Caller) *Compute {
return &Compute{
client: client,
}
}

42
pkg/cloudbroker/compute/computeci_set.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ComputeCISetRequest struct to set compute CI
type ComputeCISetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the Compute CI
// Required: true
ComputeCIID uint64 `url:"computeciId" json:"computeciId" validate:"required"`
}
// ComputeCISet sets compute CI ID for compute
func (c Compute) ComputeCISet(ctx context.Context, req ComputeCISetRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/computeciSet"
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
}

38
pkg/cloudbroker/compute/computeci_unset.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ComputeCIUnsetRequest struct to unset compute CI
type ComputeCIUnsetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// ComputeCIUnset unsets compute CI ID from compute
func (c Compute) ComputeCIUnset(ctx context.Context, req ComputeCIUnsetRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/computeciUnset"
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
}

72
pkg/cloudbroker/compute/create_template.go
View File

@@ -1,72 +0,0 @@
package compute
import (
"context"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// CreateTemplateRequest struct to create template
type CreateTemplateRequest struct {
// ID of the compute to create template from
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Name to assign to the template being created
// Required: true
Name string `url:"name" json:"name" validate:"required"`
}
type wrapperCreateTemplateRequest struct {
CreateTemplateRequest
AsyncMode bool `url:"asyncMode"`
}
// CreateTemplate create template from compute instance
func (c Compute) CreateTemplate(ctx context.Context, req CreateTemplateRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCreateTemplateRequest{
CreateTemplateRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/createTemplate"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}
// CreateTemplateAsync create template from compute instance with AsyncMode
func (c Compute) CreateTemplateAsync(ctx context.Context, req CreateTemplateRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperCreateTemplateRequest{
CreateTemplateRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/createTemplate"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

112
pkg/cloudbroker/compute/create_template_from_blank.go
View File

@@ -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 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"`
// 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 := "/cloudbroker/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 := "/cloudbroker/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
}

79
pkg/cloudbroker/compute/delete.go
View File

@@ -1,79 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DeleteRequest struct to delete compute
type DeleteRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Delete permanently
// Required: false
Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
// Set True if you want to detach data disks (if any) from the compute before its deletion
// Required: false
DetachDisks bool `url:"detachDisks,omitempty" json:"detachDisks,omitempty"`
}
type wrapperDeleteRequest struct {
DeleteRequest
AsyncMode bool `url:"asyncMode"`
}
// Delete deletes compute
func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDeleteRequest{
DeleteRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/delete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DeleteAsync deletes compute with AsyncMode
func (c Compute) DeleteAsync(ctx context.Context, req DeleteRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDeleteRequest{
DeleteRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/delete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

39
pkg/cloudbroker/compute/delete_cpu_alignment_profile.go
View File

@@ -1,39 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DeleteCPUAlignmentProfileRequest struct to delete CPU alignment profile for computes
type DeleteCPUAlignmentProfileRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []uint64 `url:"compute_ids" json:"compute_ids" validate:"min=1"`
}
// DeleteCPUAlignmentProfile deletes CPU alignment profile for computes
func (c Compute) DeleteCPUAlignmentProfile(ctx context.Context, req DeleteCPUAlignmentProfileRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/delete_cpu_alignment_profile"
res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

38
pkg/cloudbroker/compute/delete_custom_fields.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DeleteCustomFieldsRequest struct to delete compute's custom fields
type DeleteCustomFieldsRequest struct {
// ID of the compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// DeleteCustomFields deletes computes custom fields
func (c Compute) DeleteCustomFields(ctx context.Context, req DeleteCustomFieldsRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/deleteCustomFields"
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
}

43
pkg/cloudbroker/compute/detach_gpu.go
View File

@@ -1,43 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DetachGPURequest struct to detach VGPU for compute
type DetachGPURequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Identifier virtual GPU
// Required: false
VGPUID int64 `url:"vgpuId,omitempty" json:"vgpuId,omitempty"`
}
// DetachGPU detaches VGPU for compute.
// If param VGPU ID is equivalent -1, then detach all VGPU for compute
func (c Compute) DetachGPU(ctx context.Context, req DetachGPURequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/detachGpu"
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
}

42
pkg/cloudbroker/compute/detach_pci_device.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DetachPCIDeviceRequest struct to detach PCI device
type DetachPCIDeviceRequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// PCI device ID
// Required: true
DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
}
// DetachPciDevice detaches PCI device
func (c Compute) DetachPciDevice(ctx context.Context, req DetachPCIDeviceRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/detachPciDevice"
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
}

71
pkg/cloudbroker/compute/disable.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DisableRequest struct to disable compute
type DisableRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperDisableRequest struct {
DisableRequest
AsyncMode bool `url:"asyncMode"`
}
// Disable disables compute
func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDisableRequest{
DisableRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/disable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DisableAsync disables compute with AsyncMode
func (c Compute) DisableAsync(ctx context.Context, req DisableRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDisableRequest{
DisableRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/disable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

121
pkg/cloudbroker/compute/disk_add.go
View File

@@ -1,121 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskAddRequest struct to create and attach disk to compute
type DiskAddRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Name for disk
// Required: true
DiskName string `url:"diskName" json:"diskName" validate:"required"`
// Disk size in GB
// Required: true
Size uint64 `url:"size" json:"size" validate:"required"`
// Storage endpoint provider ID
// By default the same with boot disk
// Required: false
SepID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
// 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"`
// Pool name
// By default will be chosen automatically
// Required: false
Pool string `url:"pool,omitempty" json:"pool,omitempty"`
// Optional description
// Required: false
Description string `url:"desc,omitempty" json:"desc,omitempty"`
// Specify image id for create disk from template
// Required: false
ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
// Desired PCI slot (hex string, e.g. "0x1A")
// Required: false
PCISlot string `url:"pci_slot,omitempty" json:"pci_slot,omitempty"`
// Desired bus number (hex string, e.g. "0x03")
// Required: false
BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
// Disk cache mode
// Required: false
Cache string `url:"cache,omitempty" json:"cache,omitempty"`
// Discard
// Required: false
Discard string `url:"discard,omitempty" json:"discard,omitempty"`
// Mount disk in read-only mode
// Required: false
ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
}
type wrapperDiskAddRequest struct {
DiskAddRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskAdd creates new disk and attach to compute
func (c Compute) DiskAdd(ctx context.Context, req DiskAddRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskAddRequest{
DiskAddRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskAdd"
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
}
// DiskAddAsync creates new disk and attach to compute with AsyncMode
func (c Compute) DiskAddAsync(ctx context.Context, req DiskAddRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskAddRequest{
DiskAddRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskAdd"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

87
pkg/cloudbroker/compute/disk_attach.go
View File

@@ -1,87 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskAttachRequest struct to attach disk to compute
type DiskAttachRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to attach
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// Desired PCI slot (hex string, e.g. "0x1A")
// Required: false
PCISlot string `url:"pci_slot,omitempty" json:"pci_slot,omitempty"`
// Desired bus number (hex string, e.g. "0x03")
// Required: false
BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
// Mount disk in read-only mode
// Required: false
ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
}
type wrapperDiskAttachRequest struct {
DiskAttachRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskAttach attach disk to compute
func (c Compute) DiskAttach(ctx context.Context, req DiskAttachRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskAttachRequest{
DiskAttachRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskAttach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskAttachAsync attach disk to compute with AsyncMode
func (c Compute) DiskAttachAsync(ctx context.Context, req DiskAttachRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskAttachRequest{
DiskAttachRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskAttach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

79
pkg/cloudbroker/compute/disk_del.go
View File

@@ -1,79 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskDelRequest struct to detach and delete disk from compute
type DiskDelRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of disk instance
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// False if disk is to be deleted to recycle bin
// Required: true
Permanently bool `url:"permanently" json:"permanently"`
}
type wrapperDiskDelRequest struct {
DiskDelRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskDel deletes disk and detaches it from compute
func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskDelRequest{
DiskDelRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskDel"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskDelAsync deletes disk and detaches it from compute with AsyncMode
func (c Compute) DiskDelAsync(ctx context.Context, req DiskDelRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskDelRequest{
DiskDelRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskDel"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

75
pkg/cloudbroker/compute/disk_detach.go
View File

@@ -1,75 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskDetachRequest struct to detach disk from compute
type DiskDetachRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to detach
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
}
type wrapperDiskDetachRequest struct {
DiskDetachRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskDetach detaches disk from compute
func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskDetachRequest{
DiskDetachRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskDetach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskDetachAsync detaches disk from compute with AsyncMode
func (c Compute) DiskDetachAsync(ctx context.Context, req DiskDetachRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskDetachRequest{
DiskDetachRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskDetach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

53
pkg/cloudbroker/compute/disk_migrate.go
View File

@@ -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 := "/cloudbroker/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
}

79
pkg/cloudbroker/compute/disk_qos.go
View File

@@ -1,79 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskQOSRequest struct to change QOS of the disk
type DiskQOSRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to apply limits
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// Limit IO for a certain disk total and read/write options are not allowed to be combined
// Required: true
Limits string `url:"limits" json:"limits" validate:"required"`
}
type wrapperDiskQOSRequest struct {
DiskQOSRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskQOS changes QOS of the disk
func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskQOSRequest{
DiskQOSRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskQos"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskQOSAsync changes QOS of the disk with AsyncMode
func (c Compute) DiskQOSAsync(ctx context.Context, req DiskQOSRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskQOSRequest{
DiskQOSRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskQos"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

79
pkg/cloudbroker/compute/disk_resize.go
View File

@@ -1,79 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// DiskResizeRequest struct to change disk size
type DiskResizeRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the disk to resize
// Required: true
DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
// New disk size
// Required: true
Size uint64 `url:"size" json:"size" validate:"required"`
}
type wrapperDiskResizeRequest struct {
DiskResizeRequest
AsyncMode bool `url:"asyncMode"`
}
// DiskResize changes disk size
func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskResizeRequest{
DiskResizeRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskResize"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskResizeAsync changes disk size with AsyncMode
func (c Compute) DiskResizeAsync(ctx context.Context, req DiskResizeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskResizeRequest{
DiskResizeRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskResize"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

79
pkg/cloudbroker/compute/disk_switch_to_replication.go
View File

@@ -1,79 +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"`
}
type wrapperDiskSwitchToReplicationRequest struct {
DiskSwitchToReplicationRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperDiskSwitchToReplicationRequest{
DiskSwitchToReplicationRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/diskSwitchToReplication"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// DiskSwitchToReplicationAsync switches disk to it's replication with AsyncMode
func (c Compute) DiskSwitchToReplicationAsync(ctx context.Context, req DiskSwitchToReplicationRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperDiskSwitchToReplicationRequest{
DiskSwitchToReplicationRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/diskSwitchToReplication"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

38
pkg/cloudbroker/compute/enable.go
View File

@@ -1,38 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// EnableRequest struct to enable compute
type EnableRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// Enable enables compute
func (c Compute) Enable(ctx context.Context, req EnableRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/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
}

331
pkg/cloudbroker/compute/filter.go
View File

@@ -1,331 +0,0 @@
package compute
import (
"context"
"repository.basistech.ru/BASIS/decort-golang-sdk/interfaces"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/lb"
)
// FilterByID returns ListComputes with specified ID.
func (lc ListComputes) FilterByID(id uint64) ListComputes {
predicate := func(ic ItemCompute) bool {
return ic.ID == id
}
return lc.FilterFunc(predicate)
}
// FilterByName returns ListComputes with specified Name.
func (lc ListComputes) FilterByName(name string) ListComputes {
predicate := func(ic ItemCompute) bool {
return ic.Name == name
}
return lc.FilterFunc(predicate)
}
// FilterByStatus returns ListComputes with specified Status.
func (lc ListComputes) FilterByStatus(status string) ListComputes {
predicate := func(ic ItemCompute) bool {
return ic.Status == status
}
return lc.FilterFunc(predicate)
}
// FilterByTechStatus returns ListComputes with specified TechStatus.
func (lc ListComputes) FilterByTechStatus(techStatus string) ListComputes {
predicate := func(ic ItemCompute) bool {
return ic.TechStatus == techStatus
}
return lc.FilterFunc(predicate)
}
// FilterByDiskID return ListComputes with specified DiskID.
func (lc ListComputes) FilterByDiskID(diskID uint64) ListComputes {
predicate := func(ic ItemCompute) bool {
for _, disk := range ic.Disks {
if disk.ID == diskID {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// FilterByK8SID returns master and worker nodes (ListComputes) inside specified K8S cluster.
func (lc ListComputes) FilterByK8SID(ctx context.Context, k8sID uint64, decortClient interfaces.Caller) (*ListComputes, error) {
caller := k8s.New(decortClient)
req := k8s.GetRequest{
K8SID: k8sID,
}
cluster, err := caller.Get(ctx, req)
if err != nil {
return nil, err
}
predicate := func(ic ItemCompute) bool {
for _, info := range cluster.K8SGroups.Masters.DetailedInfo {
if info.ID == ic.ID {
return true
}
}
for _, worker := range cluster.K8SGroups.Workers {
for _, info := range worker.DetailedInfo {
if info.ID == ic.ID {
return true
}
}
}
return false
}
result := lc.FilterFunc(predicate)
return &result, nil
}
// K8SMasters is used to filter master nodes. Best used after FilterByK8SID function.
func (lc ListComputes) FilterByK8SMasters() ListComputes {
predicate := func(ic ItemCompute) bool {
for _, rule := range ic.AntiAffinityRules {
if rule.Value == "master" {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// K8SMasters is used to filter worker nodes. Best used after FilterByK8SID function.
func (lc ListComputes) FilterByK8SWorkers() ListComputes {
predicate := func(ic ItemCompute) bool {
for _, rule := range ic.AntiAffinityRules {
if rule.Value == "worker" {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// FilterByLBID is used to filter ListComputes used by specified Load Balancer.
func (lc ListComputes) FilterByLBID(ctx context.Context, lbID uint64, decortClient interfaces.Caller) (*ListComputes, error) {
caller := lb.New(decortClient)
req := lb.GetRequest{
LBID: lbID,
}
foundLB, err := caller.Get(ctx, req)
if err != nil {
return nil, err
}
predicate := func(ic ItemCompute) bool {
return ic.ID == foundLB.PrimaryNode.ComputeID || ic.ID == foundLB.SecondaryNode.ComputeID
}
result := lc.FilterFunc(predicate)
return &result, nil
}
// FilterFunc allows filtering ListComputes based on a user-specified predicate.
func (lc ListComputes) FilterFunc(predicate func(ItemCompute) bool) ListComputes {
var result ListComputes
for _, item := range lc.Data {
if predicate(item) {
result.Data = append(result.Data, item)
}
}
result.EntryCount = uint64(len(result.Data))
return result
}
// FindOne returns first found ItemCompute
// If none was found, returns an empty struct.
func (lc ListComputes) FindOne() ItemCompute {
if len(lc.Data) == 0 {
return ItemCompute{}
}
return lc.Data[0]
}
// FilterByID returns ListDeletedComputes with specified ID.
func (lc ListDeletedComputes) FilterByID(id uint64) ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
return ic.ID == id
}
return lc.FilterFunc(predicate)
}
// FilterByName returns ListDeletedComputes with specified Name.
func (lc ListDeletedComputes) FilterByName(name string) ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
return ic.Name == name
}
return lc.FilterFunc(predicate)
}
// FilterByStatus returns ListDeletedComputes with specified Status.
func (lc ListDeletedComputes) FilterByStatus(status string) ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
return ic.Status == status
}
return lc.FilterFunc(predicate)
}
// FilterByTechStatus returns ListDeletedComputes with specified TechStatus.
func (lc ListDeletedComputes) FilterByTechStatus(techStatus string) ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
return ic.TechStatus == techStatus
}
return lc.FilterFunc(predicate)
}
// FilterByDiskID return ListDeletedComputes with specified DiskID.
func (lc ListDeletedComputes) FilterByDiskID(diskID uint64) ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
for _, disk := range ic.Disks {
if disk.ID == diskID {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// FilterByK8SID returns master and worker nodes (ListDeletedComputes) inside specified K8S cluster.
func (lc ListDeletedComputes) FilterByK8SID(ctx context.Context, k8sID uint64, decortClient interfaces.Caller) (*ListDeletedComputes, error) {
caller := k8s.New(decortClient)
req := k8s.GetRequest{
K8SID: k8sID,
}
cluster, err := caller.Get(ctx, req)
if err != nil {
return nil, err
}
predicate := func(ic ItemDeletedCompute) bool {
for _, info := range cluster.K8SGroups.Masters.DetailedInfo {
if info.ID == ic.ID {
return true
}
}
for _, worker := range cluster.K8SGroups.Workers {
for _, info := range worker.DetailedInfo {
if info.ID == ic.ID {
return true
}
}
}
return false
}
result := lc.FilterFunc(predicate)
return &result, nil
}
// K8SMasters is used to filter master nodes. Best used after FilterByK8SID function.
func (lc ListDeletedComputes) FilterByK8SMasters() ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
for _, rule := range ic.AntiAffinityRules {
if rule.Value == "master" {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// K8SMasters is used to filter worker nodes. Best used after FilterByK8SID function.
func (lc ListDeletedComputes) FilterByK8SWorkers() ListDeletedComputes {
predicate := func(ic ItemDeletedCompute) bool {
for _, rule := range ic.AntiAffinityRules {
if rule.Value == "worker" {
return true
}
}
return false
}
return lc.FilterFunc(predicate)
}
// FilterByLBID is used to filter ListDeletedComputes used by specified Load Balancer.
func (lc ListDeletedComputes) FilterByLBID(ctx context.Context, lbID uint64, decortClient interfaces.Caller) (*ListDeletedComputes, error) {
caller := lb.New(decortClient)
req := lb.GetRequest{
LBID: lbID,
}
foundLB, err := caller.Get(ctx, req)
if err != nil {
return nil, err
}
predicate := func(ic ItemDeletedCompute) bool {
return ic.ID == foundLB.PrimaryNode.ComputeID || ic.ID == foundLB.SecondaryNode.ComputeID
}
result := lc.FilterFunc(predicate)
return &result, nil
}
// FilterFunc allows filtering ListDeletedComputes based on a user-specified predicate.
func (lc ListDeletedComputes) FilterFunc(predicate func(ItemDeletedCompute) bool) ListDeletedComputes {
var result ListDeletedComputes
for _, item := range lc.Data {
if predicate(item) {
result.Data = append(result.Data, item)
}
}
result.EntryCount = uint64(len(result.Data))
return result
}
// FindOne returns first found ItemDeletedCompute
// If none was found, returns an empty struct.
func (lc ListDeletedComputes) FindOne() ItemDeletedCompute {
if len(lc.Data) == 0 {
return ItemDeletedCompute{}
}
return lc.Data[0]
}

481
pkg/cloudbroker/compute/filter_test.go
View File

@@ -1,481 +0,0 @@
package compute
import (
"testing"
)
var computes = ListComputes{
Data: []ItemCompute{
{
Disks: []InfoDisk{
{
ID: 65191,
},
},
InfoCompute: InfoCompute{
ACL: []interface{}{},
AccountID: 132847,
AccountName: "std_2",
AffinityLabel: "",
AffinityRules: []ItemRule{
{
GUID: "",
Key: "aff_key",
Mode: "ANY",
Policy: "RECOMMENDED",
Topology: "compute",
Value: "aff_val",
},
},
AffinityWeight: 0,
AntiAffinityRules: []ItemRule{
{
GUID: "",
Key: "antiaff_key",
Mode: "ANY",
Policy: "RECOMMENDED",
Topology: "compute",
Value: "antiaff_val",
},
},
Arch: "X86_64",
BootOrder: []string{
"hd", "cdrom",
},
BootDiskSize: 0,
CloneReference: 0,
Clones: []uint64{},
ComputeCIID: 0,
CPUs: 4,
CreatedBy: "timofey_tkachev_1@decs3o",
CreatedTime: 1676975175,
CustomFields: map[string]interface{}{},
DeletedBy: "",
DeletedTime: 0,
Description: "",
Devices: nil,
Driver: "KVM_X86",
GID: 212,
GUID: 48500,
ID: 48500,
Interfaces: ListInterfaces{},
LockStatus: "UNLOCKED",
ManagerID: 0,
ManagerType: "",
MigrationJob: 0,
Milestones: 363500,
Name: "test",
PinnedToNode: 1,
RAM: 4096,
ReferenceID: "c7cb19ac-af4a-4067-852f-c5572949207e",
Registered: true,
ResName: "compute-48500",
RGID: 79724,
RGName: "std_broker2",
SnapSets: ListSnapshots{},
StatelessSEPID: 0,
StatelessSEPType: "",
Status: "ENABLED",
Tags: map[string]interface{}{},
TechStatus: "STOPPED",
TotalDiskSize: 2,
UpdatedBy: "",
UpdatedTime: 1677058904,
UserManaged: true,
VGPUs: []uint64{},
VINSConnected: 0,
},
},
{
Disks: []InfoDisk{
{
ID: 65248,
},
},
InfoCompute: InfoCompute{
ACL: []interface{}{},
AccountID: 132848,
AccountName: "std_broker",
AffinityLabel: "",
AffinityRules: []ItemRule{},
AffinityWeight: 0,
AntiAffinityRules: []ItemRule{},
Arch: "X86_64",
BootOrder: []string{
"hd", "cdrom",
},
BootDiskSize: 0,
CloneReference: 0,
Clones: []uint64{},
ComputeCIID: 0,
CPUs: 6,
CreatedBy: "timofey_tkachev_1@decs3o",
CreatedTime: 1677579436,
CustomFields: map[string]interface{}{},
DeletedBy: "",
DeletedTime: 0,
Description: "",
Devices: nil,
Driver: "KVM_X86",
GID: 212,
GUID: 48556,
ID: 48556,
Interfaces: ListInterfaces{},
LockStatus: "UNLOCKED",
ManagerID: 0,
ManagerType: "",
MigrationJob: 0,
Milestones: 363853,
Name: "compute_2",
PinnedToNode: 1,
RAM: 4096,
ReferenceID: "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff",
Registered: true,
ResName: "compute-48556",
RGID: 79727,
RGName: "sdk_negative_fields_test",
SnapSets: ListSnapshots{},
StatelessSEPID: 0,
StatelessSEPType: "",
Status: "ENABLED",
Tags: map[string]interface{}{},
TechStatus: "STARTED",
TotalDiskSize: 1,
UpdatedBy: "",
UpdatedTime: 1677579436,
UserManaged: true,
VGPUs: []uint64{},
VINSConnected: 0,
},
},
},
EntryCount: 2,
}
func TestFilterByID(t *testing.T) {
actual := computes.FilterByID(48500).FindOne()
if actual.ID != 48500 {
t.Fatal("expected ID 48500, found: ", actual.ID)
}
actualEmpty := computes.FilterByID(0)
if len(actualEmpty.Data) != 0 {
t.Fatal("expected empty, actual: ", len(actualEmpty.Data))
}
}
func TestFilterByName(t *testing.T) {
actual := computes.FilterByName("compute_2").FindOne()
if actual.Name != "compute_2" {
t.Fatal("expected compute with name 'test', found: ", actual.Name)
}
}
func TestFilterByStatus(t *testing.T) {
actual := computes.FilterByStatus("ENABLED")
for _, item := range actual.Data {
if item.Status != "ENABLED" {
t.Fatal("expected ENABLED status, found: ", item.Status)
}
}
}
func TestFilterByTechStatus(t *testing.T) {
actual := computes.FilterByTechStatus("STARTED").FindOne()
if actual.ID != 48556 {
t.Fatal("expected 48556 with STARTED techStatus, found: ", actual.ID)
}
}
func TestFilterByDiskID(t *testing.T) {
actual := computes.FilterByDiskID(65248).FindOne()
if actual.ID != 48556 {
t.Fatal("expected 48556 with DiskID 65248, found: ", actual.ID)
}
}
func TestFilterFunc(t *testing.T) {
actual := computes.FilterFunc(func(ic ItemCompute) bool {
return ic.Registered == true
})
if len(actual.Data) != 2 {
t.Fatal("expected 2 elements found, actual: ", len(actual.Data))
}
for _, item := range actual.Data {
if item.Registered != true {
t.Fatal("expected Registered to be true, actual: ", item.Registered)
}
}
}
func TestSortingByCreatedTime(t *testing.T) {
actual := computes.SortByCreatedTime(false)
if actual.Data[0].Name != "test" {
t.Fatal("expected 'test', found: ", actual.Data[0].Name)
}
actual = computes.SortByCreatedTime(true)
if actual.Data[0].Name != "compute_2" {
t.Fatal("expected 'compute_2', found: ", actual.Data[0].Name)
}
}
func TestSortingByCPU(t *testing.T) {
actual := computes.SortByCPU(false)
if actual.Data[0].CPUs != 4 {
t.Fatal("expected 4 CPU cores, found: ", actual.Data[0].CPUs)
}
actual = computes.SortByCPU(true)
if actual.Data[0].CPUs != 6 {
t.Fatal("expected 6 CPU cores, found: ", actual.Data[0].CPUs)
}
}
var deleteComputes = ListDeletedComputes{
Data: []ItemDeletedCompute{
{
Disks: []InfoDisk{
{
ID: 65191,
},
},
InfoCompute: InfoCompute{
ACL: []interface{}{},
AccountID: 132847,
AccountName: "std_2",
AffinityLabel: "",
AffinityRules: []ItemRule{
{
GUID: "",
Key: "aff_key",
Mode: "ANY",
Policy: "RECOMMENDED",
Topology: "compute",
Value: "aff_val",
},
},
AffinityWeight: 0,
AntiAffinityRules: []ItemRule{
{
GUID: "",
Key: "antiaff_key",
Mode: "ANY",
Policy: "RECOMMENDED",
Topology: "compute",
Value: "antiaff_val",
},
},
Arch: "X86_64",
BootOrder: []string{
"hd", "cdrom",
},
BootDiskSize: 0,
CloneReference: 0,
Clones: []uint64{},
ComputeCIID: 0,
CPUs: 4,
CreatedBy: "timofey_tkachev_1@decs3o",
CreatedTime: 1676975175,
CustomFields: map[string]interface{}{},
DeletedBy: "",
DeletedTime: 0,
Description: "",
Devices: nil,
Driver: "KVM_X86",
GID: 212,
GUID: 48500,
ID: 48500,
Interfaces: ListInterfaces{},
LockStatus: "UNLOCKED",
ManagerID: 0,
ManagerType: "",
MigrationJob: 0,
Milestones: 363500,
Name: "test",
RAM: 4096,
ReferenceID: "c7cb19ac-af4a-4067-852f-c5572949207e",
Registered: true,
ResName: "compute-48500",
RGID: 79724,
RGName: "std_broker2",
SnapSets: ListSnapshots{},
StatelessSEPID: 0,
StatelessSEPType: "",
Status: "ENABLED",
Tags: map[string]interface{}{},
TechStatus: "STOPPED",
TotalDiskSize: 2,
UpdatedBy: "",
UpdatedTime: 1677058904,
UserManaged: true,
VGPUs: []uint64{},
VINSConnected: 0,
},
},
{
Disks: []InfoDisk{
{
ID: 65248,
},
},
InfoCompute: InfoCompute{
ACL: []interface{}{},
AccountID: 132848,
AccountName: "std_broker",
AffinityLabel: "",
AffinityRules: []ItemRule{},
AffinityWeight: 0,
AntiAffinityRules: []ItemRule{},
Arch: "X86_64",
BootOrder: []string{
"hd", "cdrom",
},
BootDiskSize: 0,
CloneReference: 0,
Clones: []uint64{},
ComputeCIID: 0,
CPUs: 6,
CreatedBy: "timofey_tkachev_1@decs3o",
CreatedTime: 1677579436,
CustomFields: map[string]interface{}{},
DeletedBy: "",
DeletedTime: 0,
Description: "",
Devices: nil,
Driver: "KVM_X86",
GID: 212,
GUID: 48556,
ID: 48556,
Interfaces: ListInterfaces{},
LockStatus: "UNLOCKED",
ManagerID: 0,
ManagerType: "",
MigrationJob: 0,
Milestones: 363853,
Name: "compute_2",
RAM: 4096,
ReferenceID: "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff",
Registered: true,
ResName: "compute-48556",
RGID: 79727,
RGName: "sdk_negative_fields_test",
SnapSets: ListSnapshots{},
StatelessSEPID: 0,
StatelessSEPType: "",
Status: "ENABLED",
Tags: map[string]interface{}{},
TechStatus: "STARTED",
TotalDiskSize: 1,
UpdatedBy: "",
UpdatedTime: 1677579436,
UserManaged: true,
VGPUs: []uint64{},
VINSConnected: 0,
},
},
},
EntryCount: 2,
}
func TestFilterDeleteByID(t *testing.T) {
actual := deleteComputes.FilterByID(48500).FindOne()
if actual.ID != 48500 {
t.Fatal("expected ID 48500, found: ", actual.ID)
}
actualEmpty := deleteComputes.FilterByID(0)
if len(actualEmpty.Data) != 0 {
t.Fatal("expected empty, actual: ", len(actualEmpty.Data))
}
}
func TestFilterDeleteByName(t *testing.T) {
actual := deleteComputes.FilterByName("compute_2").FindOne()
if actual.Name != "compute_2" {
t.Fatal("expected compute with name 'test', found: ", actual.Name)
}
}
func TestFilterDeleteByStatus(t *testing.T) {
actual := deleteComputes.FilterByStatus("ENABLED")
for _, item := range actual.Data {
if item.Status != "ENABLED" {
t.Fatal("expected ENABLED status, found: ", item.Status)
}
}
}
func TestFilterDeleteByTechStatus(t *testing.T) {
actual := deleteComputes.FilterByTechStatus("STARTED").FindOne()
if actual.ID != 48556 {
t.Fatal("expected 48556 with STARTED techStatus, found: ", actual.ID)
}
}
func TestFilterDeleteByDiskID(t *testing.T) {
actual := deleteComputes.FilterByDiskID(65248).FindOne()
if actual.ID != 48556 {
t.Fatal("expected 48556 with DiskID 65248, found: ", actual.ID)
}
}
func TestFilterDeleteFunc(t *testing.T) {
actual := deleteComputes.FilterFunc(func(ic ItemDeletedCompute) bool {
return ic.Registered == true
})
if len(actual.Data) != 2 {
t.Fatal("expected 2 elements found, actual: ", len(actual.Data))
}
for _, item := range actual.Data {
if item.Registered != true {
t.Fatal("expected Registered to be true, actual: ", item.Registered)
}
}
}
func TestDeleteSortingByCreatedTime(t *testing.T) {
actual := deleteComputes.SortByCreatedTime(false)
if actual.Data[0].Name != "test" {
t.Fatal("expected 'test', found: ", actual.Data[0].Name)
}
actual = deleteComputes.SortByCreatedTime(true)
if actual.Data[0].Name != "compute_2" {
t.Fatal("expected 'compute_2', found: ", actual.Data[0].Name)
}
}
func TestDeleteSortingByCPU(t *testing.T) {
actual := deleteComputes.SortByCPU(false)
if actual.Data[0].CPUs != 4 {
t.Fatal("expected 4 CPU cores, found: ", actual.Data[0].CPUs)
}
actual = deleteComputes.SortByCPU(true)
if actual.Data[0].CPUs != 6 {
t.Fatal("expected 6 CPU cores, found: ", actual.Data[0].CPUs)
}
}

46
pkg/cloudbroker/compute/get.go
View File

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

40
pkg/cloudbroker/compute/get_audits.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetAuditsRequest struct to get compute audits
type GetAuditsRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// GetAudits gets compute audits
func (c Compute) GetAudits(ctx context.Context, req GetAuditsRequest) (ListAudits, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/getAudits"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
list := ListAudits{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return list, nil
}

37
pkg/cloudbroker/compute/get_console_url.go
View File

@@ -1,37 +0,0 @@
package compute
import (
"context"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetConsoleURLRequest struct to get console URL
type GetConsoleURLRequest struct {
// ID of compute instance to get console for
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// GetConsoleURL gets computes console URL
func (c Compute) GetConsoleURL(ctx context.Context, req GetConsoleURLRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/getConsoleUrl"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
result = strings.ReplaceAll(result, "\\", "")
return result, nil
}

46
pkg/cloudbroker/compute/get_cpu_alignment_profile.go
View File

@@ -1,46 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetCPUAlignmentProfileRequest struct to get CPU alignment profile for compute
type GetCPUAlignmentProfileRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
// GetCPUAlignmentProfile gets CPU alignment profile for compute
func (c Compute) GetCPUAlignmentProfile(ctx context.Context, req GetCPUAlignmentProfileRequest) (*CPUAlignmentProfile, error) {
res, err := c.GetCPUAlignmentProfileRaw(ctx, req)
if err != nil {
return nil, err
}
info := CPUAlignmentProfile{}
err = json.Unmarshal(res, &info)
if err != nil {
return nil, err
}
return &info, nil
}
// GetCPUAlignmentProfileRaw gets CPU alignment profile for compute as an array of bytes
func (c Compute) GetCPUAlignmentProfileRaw(ctx context.Context, req GetCPUAlignmentProfileRequest) ([]byte, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/get_cpu_alignment_profile"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
return res, err
}

40
pkg/cloudbroker/compute/get_custom_fields.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetCustomFieldsRequest struct to get Compute's customFields
type GetCustomFieldsRequest struct {
// Compute ID
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// GetCustomFields gets Compute's customFields
func (c Compute) GetCustomFields(ctx context.Context, req GetCustomFieldsRequest) (interface{}, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/getCustomFields"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
var info interface{}
err = json.Unmarshal(res, &info)
if err != nil {
return nil, err
}
return &info, nil
}

36
pkg/cloudbroker/compute/get_log.go
View File

@@ -1,36 +0,0 @@
package compute
import (
"context"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// GetLogRequest struct to get compute logs
type GetLogRequest struct {
// ID of compute instance to get log for
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Path to log file
// Required: true
Path string `url:"path" json:"path" validate:"required"`
}
// GetLog gets compute's log file by path
func (c Compute) GetLog(ctx context.Context, req GetLogRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/getLog"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/guest_agent_disable.go
View File

@@ -1,71 +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"`
}
type wrapperGuestAgentDisableRequest struct {
GuestAgentDisableRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperGuestAgentDisableRequest{
GuestAgentDisableRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/guest_agent_disable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// GuestAgentDisableAsync disables guest agent at a specific compute with AsyncMode
func (c Compute) GuestAgentDisableAsync(ctx context.Context, req GuestAgentDisableRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperGuestAgentDisableRequest{
GuestAgentDisableRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/guest_agent_disable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/guest_agent_enable.go
View File

@@ -1,71 +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"`
}
type wrapperGuestAgentEnableRequest struct {
GuestAgentEnableRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperGuestAgentEnableRequest{
GuestAgentEnableRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/guest_agent_enable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// GuestAgentEnableAsync enables guest agent at a specific compute with AsyncMode
func (c Compute) GuestAgentEnableAsync(ctx context.Context, req GuestAgentEnableRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperGuestAgentEnableRequest{
GuestAgentEnableRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/guest_agent_enable"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

81
pkg/cloudbroker/compute/guest_agent_execute.go
View File

@@ -1,81 +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"`
}
type wrapperGuestAgentExecuteRequest struct {
GuestAgentExecuteRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperGuestAgentExecuteRequest{
GuestAgentExecuteRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/guest_agent_execute"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
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
}
// GuestAgentExecuteRequestAsync executes guest agent command with AsyncMode
func (c Compute) GuestAgentExecuteRequestAsync(ctx context.Context, req GuestAgentExecuteRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperGuestAgentExecuteRequest{
GuestAgentExecuteRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/guest_agent_execute"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

40
pkg/cloudbroker/compute/guest_agent_feature_get.go
View File

@@ -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 := "/cloudbroker/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
}

71
pkg/cloudbroker/compute/guest_agent_feature_update.go
View File

@@ -1,71 +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"`
}
type wrapperGuestAgentFeatureUpdateRequest struct {
GuestAgentFeatureUpdateRequest
AsyncMode bool `url:"asyncMode"`
}
// 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))
}
reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
GuestAgentFeatureUpdateRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/guest_agent_feature_update"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// GuestAgentFeatureUpdateAsync feature updates guest agent with AsyncMode
func (c Compute) GuestAgentFeatureUpdateAsync(ctx context.Context, req GuestAgentFeatureUpdateRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
GuestAgentFeatureUpdateRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/guest_agent_feature_update"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

46
pkg/cloudbroker/compute/ids.go
View File

@@ -1,46 +0,0 @@
package compute
// IDs gets array of ComputeIDs from ListComputes struct
func (lc ListComputes) IDs() []uint64 {
res := make([]uint64, 0, len(lc.Data))
for _, c := range lc.Data {
res = append(res, c.ID)
}
return res
}
// IDs gets array of DiskIDs from ListInfoDisks struct
func (lid ListInfoDisks) IDs() []uint64 {
res := make([]uint64, 0, len(lid))
for _, d := range lid {
res = append(res, d.ID)
}
return res
}
// IDs gets array of PFWsIDs from ListPFW struct
func (lp ListPFW) IDs() []uint64 {
res := make([]uint64, 0, len(lp.Data))
for _, p := range lp.Data {
res = append(res, p.ID)
}
return res
}
// IDs gets array of DiskIDs from ListDisks struct
func (ld ListDisks) IDs() []uint64 {
res := make([]uint64, 0, len(ld))
for _, d := range ld {
res = append(res, d.ID)
}
return res
}
// IDs gets array of PCIDeviceIDs from ListPCIDevices struct
func (lpd ListPCIDevices) IDs() []uint64 {
res := make([]uint64, 0, len(lpd.Data))
for _, pd := range lpd.Data {
res = append(res, pd.ID)
}
return res
}

117
pkg/cloudbroker/compute/list.go
View File

@@ -1,117 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ListRequest struct to get list of available computes
type ListRequest struct {
// Find by ID
// Required: false
ByID uint64 `url:"by_id,omitempty" json:"by_id,omitempty"`
// Find by name
// Required: false
Name string `url:"name,omitempty" json:"name,omitempty"`
// Find by account ID
// Required: false
AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
// Find by resource group name
// Required: false
RGName string `url:"rgName,omitempty" json:"rgName,omitempty"`
// Find by resource group ID
// Required: false
RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
// Find by tech status
// Required: false
TechStatus string `url:"techStatus,omitempty" json:"techStatus,omitempty"`
// Find by status
// Required: false
Status string `url:"status,omitempty" json:"status,omitempty"`
// Find by IP address
// Required: false
IPAddress string `url:"ipAddress,omitempty" json:"ipAddress,omitempty"`
// Find by node ID
// Required: false
NodeID uint64 `url:"node_id,omitempty" json:"node_id,omitempty"`
// Find by CD image ID
// Required: false
CDImageID uint64 `url:"cdImageId,omitempty" json:"cdImageId,omitempty"`
// Find by node name
// Required: false
NodeName string `url:"nodeName,omitempty" json:"nodeName,omitempty"`
// Find by external network name
// Required: false
ExtNetName string `url:"extNetName,omitempty" json:"extNetName,omitempty"`
// Find by external network ID
// Required: false
ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"`
// Include deleted computes
// Required: false
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
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
}
// List gets list of the available computes as a ListComputes struct.
// Filtering based on status is possible
func (c Compute) List(ctx context.Context, req ListRequest) (*ListComputes, error) {
res, err := c.ListRaw(ctx, req)
if err != nil {
return nil, err
}
list := ListComputes{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}
// ListRaw gets list of the available computes as an array of bytes
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 := "/cloudbroker/compute/list"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
return res, err
}

84
pkg/cloudbroker/compute/list_deleted.go
View File

@@ -1,84 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ListDeletedRequest struct to get deleted computes list
type ListDeletedRequest struct {
// Find by ID
// Required: false
ByID uint64 `url:"by_id,omitempty" json:"by_id,omitempty"`
// Find by name
// Required: false
Name string `url:"name,omitempty" json:"name,omitempty"`
// Find by account ID
// Required: false
AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
// Find by resource group name
// Required: false
RGName string `url:"rgName,omitempty" json:"rgName,omitempty"`
// Find by resource group ID
// Required: false
RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
// Find by tech status
// Required: false
TechStatus string `url:"techStatus,omitempty" json:"techStatus,omitempty"`
// Find by IP address
// Required: false
IPAddress string `url:"ipAddress,omitempty" json:"ipAddress,omitempty"`
// Find by external network name
// Required: false
ExtNetName string `url:"extNetName,omitempty" json:"extNetName,omitempty"`
// Find by external network ID
// Required: false
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
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
}
// ListDeleted gets list all deleted computes
func (c Compute) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListDeletedComputes, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/listDeleted"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
list := ListDeletedComputes{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

69
pkg/cloudbroker/compute/list_pci_device.go
View File

@@ -1,69 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ListPCIDeviceRequest struct to get list of PCI devices
type ListPCIDeviceRequest struct {
// Identifier compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Find by resource group ID
// Required: false
RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
// Find by device id
// Required: false
DevID uint64 `url:"devId,omitempty" json:"devId,omitempty"`
// Find by name
// Required: false
Name string `url:"name,omitempty" json:"name,omitempty"`
// Find by status
// Required: false
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
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
}
// ListPCIDevice gets list of PCI device
func (c Compute) ListPCIDevice(ctx context.Context, req ListPCIDeviceRequest) (*ListPCIDevices, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/listPciDevice"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
list := ListPCIDevices{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

69
pkg/cloudbroker/compute/list_vgpu.go
View File

@@ -1,69 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ListVGPURequest struct to get list of GPU for compute
type ListVGPURequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Find by GPU id
// Required: false
GPUID uint64 `url:"gpuId,omitempty" json:"gpuId,omitempty"`
// Find by type
// Required: false
Type string `url:"type,omitempty" json:"type,omitempty"`
// Find by status
// Required: false
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
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
// Include deleted computes. If using field 'status', then includedeleted will be ignored
// Required: false
IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"`
}
// ListVGPU gets list of GPU for compute
func (c Compute) ListVGPU(ctx context.Context, req ListVGPURequest) (*ListVGPUs, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/listVGpu"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
list := ListVGPUs{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

75
pkg/cloudbroker/compute/mass_delete.go
View File

@@ -1,75 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MassDeleteRequest struct to delete several computes
type MassDeleteRequest struct {
// IDs of compute instances to delete
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Delete computes permanently
// Required: false
Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
}
type wrapperMassDeleteRequest struct {
MassDeleteRequest
AsyncMode bool `url:"asyncMode"`
}
// MassDelete starts jobs to delete several computes
func (c Compute) MassDelete(ctx context.Context, req MassDeleteRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassDeleteRequest{
MassDeleteRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/massDelete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MassDeleteAsync starts jobs to delete several computes with AsyncMode
func (c Compute) MassDeleteAsync(ctx context.Context, req MassDeleteRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassDeleteRequest{
MassDeleteRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/massDelete"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/mass_reboot.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MassRebootRequest struct to reboot several computes
type MassRebootRequest struct {
// IDs of compute instances to reboot
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
}
type wrapperMassRebootRequest struct {
MassRebootRequest
AsyncMode bool `url:"asyncMode"`
}
// MassReboot starts jobs to reboot several computes
func (c Compute) MassReboot(ctx context.Context, req MassRebootRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassRebootRequest{
MassRebootRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/massReboot"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MassRebootAsync starts jobs to reboot several computes with AsyncMode
func (c Compute) MassRebootAsync(ctx context.Context, req MassRebootRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassRebootRequest{
MassRebootRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/massReboot"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/mass_start.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MassStartRequest struct to start several computes
type MassStartRequest struct {
// IDs of compute instances to start
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
}
type wrapperMassStartRequest struct {
MassStartRequest
AsyncMode bool `url:"asyncMode"`
}
// MassStart starts jobs to start several computes
func (c Compute) MassStart(ctx context.Context, req MassStartRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassStartRequest{
MassStartRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/massStart"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MassStartAsync starts jobs to start several computes with AsyncMode
func (c Compute) MassStartAsync(ctx context.Context, req MassStartRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassStartRequest{
MassStartRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/massStart"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

75
pkg/cloudbroker/compute/mass_stop.go
View File

@@ -1,75 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MassStopRequest struct to stop several computes
type MassStopRequest struct {
// IDs of compute instances to stop
// Required: true
ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
// Force stop compute
// Required: false
Force bool `url:"force,omitempty" json:"force,omitempty"`
}
type wrapperMassStopRequest struct {
MassStopRequest
AsyncMode bool `url:"asyncMode"`
}
// MassStop starts jobs to stop several computes
func (c Compute) MassStop(ctx context.Context, req MassStopRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassStopRequest{
MassStopRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/massStop"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MassStopAsync starts jobs to stop several computes with AsyncMode
func (c Compute) MassStopAsync(ctx context.Context, req MassStopRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMassStopRequest{
MassStopRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/massStop"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

76
pkg/cloudbroker/compute/migrate.go
View File

@@ -1,76 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateRequest struct to migrate compute
type MigrateRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Particular Node ID to migrate this compute to
// Required: false
TargetNodeID uint64 `url:"targetNodeId,omitempty" json:"targetNodeId,omitempty"`
}
type AsyncWrapperMigrateRequest struct {
MigrateRequest
SyncMode bool `url:"sync"`
}
// Migrate migrates compute to another node
func (c Compute) Migrate(ctx context.Context, req MigrateRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/migrate"
syncReq := AsyncWrapperMigrateRequest{MigrateRequest: req, SyncMode: true}
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, syncReq)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// AsyncMigrate migrates compute to another node in async mode
func (c Compute) AsyncMigrate(ctx context.Context, req MigrateRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/migrate"
asyncReq := AsyncWrapperMigrateRequest{MigrateRequest: req, SyncMode: false}
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, asyncReq)
if err != nil {
return " ", err
}
var taskID string
err = json.Unmarshal(res, &taskID)
if err != nil {
return "", err
}
return taskID, nil
}

68
pkg/cloudbroker/compute/migrate_abort.go
View File

@@ -1,68 +0,0 @@
package compute
import (
"context"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateAbortRequest struct to abort migration
type MigrateAbortRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
}
type wrapperMigrateAbortRequest struct {
MigrateAbortRequest
AsyncMode bool `url:"asyncMode"`
}
// MigrateAbort aborts compute migration
func (c Compute) MigrateAbort(ctx context.Context, req MigrateAbortRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateAbortRequest{
MigrateAbortRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/migrate_abort"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}
// MigrateAbortAsync aborts compute migration with AsyncMode
func (c Compute) MigrateAbortAsync(ctx context.Context, req MigrateAbortRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateAbortRequest{
MigrateAbortRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/migrate_abort"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

54
pkg/cloudbroker/compute/migrate_storage.go
View File

@@ -1,54 +0,0 @@
package compute
import (
"context"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateStorageRequest struct for migration
type MigrateStorageRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// SEP ID to migrate disks
// Required: true
SEPID uint64 `url:"sepId" json:"sepId" validate:"required"`
// SEP pool name to migrate disks
// Required: true
PoolName string `url:"poolName" json:"poolName" validate:"required"`
// Target node ID
// Required: true
NodeID uint64 `url:"node_id" json:"node_id" validate:"required"`
// Async API call
// Required: true
Sync bool `url:"sync" json:"sync" validate:"required"`
}
// MigrateStorage gets complex compute migration
// Compute will be migrated to specified node, and compute disks will
// be migrated to specified SEP to specified pool.
// This action can take up to 84 hours
func (c Compute) MigrateStorage(ctx context.Context, req MigrateStorageRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/migrateStorage"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}

76
pkg/cloudbroker/compute/migrate_storage_abort.go
View File

@@ -1,76 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateStorageAbortRequest struct to abort migration
type MigrateStorageAbortRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Status check
// Default: false
// Required: false
StatusCheck bool `url:"statusCheck" json:"statusCheck"`
}
type wrapperMigrateStorageAbortRequest struct {
MigrateStorageAbortRequest
AsyncMode bool `url:"asyncMode"`
}
// MigrateStorageAbort aborts complex compute migration job
func (c Compute) MigrateStorageAbort(ctx context.Context, req MigrateStorageAbortRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateStorageAbortRequest{
MigrateStorageAbortRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/migrateStorageAbort"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MigrateStorageAbortAsync aborts complex compute migration job with AsyncMode
func (c Compute) MigrateStorageAbortAsync(ctx context.Context, req MigrateStorageAbortRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateStorageAbortRequest{
MigrateStorageAbortRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/migrateStorageAbort"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

73
pkg/cloudbroker/compute/migrate_storage_clean_up.go
View File

@@ -1,73 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateStorageCleanUpRequest struct to cleanup resources after finished migration
type MigrateStorageCleanUpRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperMigrateStorageCleanUpRequest struct {
MigrateStorageCleanUpRequest
AsyncMode bool `url:"asyncMode"`
}
// MigrateStorageCleanUp cleanup resources after finished (success of failed) complex compute migration.
// If the migration was successful, then old disks will be removed, else new (target) disks will be removed.
// Do it wisely!
func (c Compute) MigrateStorageCleanUp(ctx context.Context, req MigrateStorageCleanUpRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateStorageCleanUpRequest{
MigrateStorageCleanUpRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/migrateStorageCleanup"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MigrateStorageCleanUpAsync cleanup resources after finished migration with AsyncMode
func (c Compute) MigrateStorageCleanUpAsync(ctx context.Context, req MigrateStorageCleanUpRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateStorageCleanUpRequest{
MigrateStorageCleanUpRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/migrateStorageCleanup"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

35
pkg/cloudbroker/compute/migrate_storage_info.go
View File

@@ -1,35 +0,0 @@
package compute
import (
"context"
"net/http"
"strings"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateStorageInfoRequest struct to get info about migration
type MigrateStorageInfoRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// MigrateStorageInfo gets info about last (include ongoing) storage migration
func (c Compute) MigrateStorageInfo(ctx context.Context, req MigrateStorageInfoRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/migrateStorageInfo"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return "", err
}
result := strings.ReplaceAll(string(res), "\"", "")
return result, nil
}

55
pkg/cloudbroker/compute/migrate_storage_list.go
View File

@@ -1,55 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateStorageListRequest struct to get list of jobs
type MigrateStorageListRequest struct {
// Find by job ID
// Required: false
MigrationJobID uint64 `url:"migration_job_id,omitempty" json:"migration_job_id,omitempty"`
// If True then return completed jobs
// Required: false
Completed interface{} `url:"completed,omitempty" json:"completed,omitempty" validate:"omitempty,isBool"`
// Sort by one of supported fields, format +|-(field)
// Required: false
SortBy string `url:"sort_by,omitempty" json:"sort_by,omitempty" validate:"omitempty,sortBy"`
// Page number
// Required: false
Page uint64 `url:"page,omitempty" json:"page,omitempty"`
// Page size
// Required: false
Size uint64 `url:"size,omitempty" json:"size,omitempty"`
}
// MigrateStorageList gets list of the jobs.
func (c Compute) MigrateStorageList(ctx context.Context, req MigrateStorageListRequest) (*ListMigrateStorage, error) {
if err := validators.ValidateRequest(req); err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/migrate_storage_list"
res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
if err != nil {
return nil, err
}
list := ListMigrateStorage{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

75
pkg/cloudbroker/compute/migrate_to_zone.go
View File

@@ -1,75 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MigrateToZone 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"`
}
type wrapperMigrateToZoneRequest struct {
MigrateToZoneRequest
AsyncMode bool `url:"asyncMode"`
}
// MigrateToZone moves compute to new zone
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))
}
reqWrapped := wrapperMigrateToZoneRequest{
MigrateToZoneRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/migrateToZone"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MigrateToZoneAsync moves compute to new zone with AsyncMode
func (c Compute) MigrateToZoneAsync(ctx context.Context, req MigrateToZoneRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMigrateToZoneRequest{
MigrateToZoneRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/migrateToZone"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

1568
pkg/cloudbroker/compute/models.go
View File

File diff suppressed because it is too large Load Diff

90
pkg/cloudbroker/compute/move_to_rg.go
View File

@@ -1,90 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// MoveToRGRequest struct to move compute to new resource group
type MoveToRGRequest struct {
// ID of the compute instance to move
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the target resource group
// Required: true
RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
// New name for the compute upon successful move,
// if name change required.
// Pass empty string if no name change necessary
// Required: false
Name string `url:"name,omitempty" json:"name,omitempty"`
// Should the compute be restarted upon successful move
// Required: false
Autostart bool `url:"autostart,omitempty" json:"autostart,omitempty"`
// By default moving compute in a running state is not allowed.
// Set this flag to True to force stop running compute instance prior to move.
// Required: false
ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
}
type wrapperMoveToRGRequest struct {
MoveToRGRequest
AsyncMode bool `url:"asyncMode"`
}
// MoveToRG moves compute instance to new resource group
func (c Compute) MoveToRG(ctx context.Context, req MoveToRGRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMoveToRGRequest{
MoveToRGRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/moveToRg"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// MoveToRGAsync moves compute instance to new resource group with AsyncMode
func (c Compute) MoveToRGAsync(ctx context.Context, req MoveToRGRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperMoveToRGRequest{
MoveToRGRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/moveToRg"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

141
pkg/cloudbroker/compute/net_attach.go
View File

@@ -1,141 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// NetAttachRequest struct to attach network
type NetAttachRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Network type
// 'EXTNET' for connect to external network directly
// 'VINS' for connect to ViNS
// 'VFNIC' for connect to vfpool
// 'DPDK' for connect to DPDK
// `EMPTY` for connect empty network
// `SDN` for connect to SDN
// `TRUNK` for connect to TRUNK
// Required: true
NetType string `url:"netType" json:"netType" validate:"computex86NetType"`
// Network ID for connect to
// For EXTNET - external network ID
// For VINS - VINS ID
// Required: true
NetID uint64 `url:"netId" json:"netId" validate:"required"`
// Directly required IP address for new network interface
// Required: true
IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"`
// MAC address
// Required: false
MACAddr string `url:"mac_addr,omitempty" json:"mac_addr,omitempty"`
// Used for EXTNET, TRUNK and DPDK
// Must be 1500-9216
// Required: false
MTU uint64 `url:"mtu,omitempty" json:"mtu,omitempty" validate:"omitempty,mtu"`
// Net mask
// Used only to DPDK or VFNIC net type
// Required: false
NetMask uint64 `url:"netMask,omitempty" json:"netMask,omitempty"`
// SDN Segment ID
// Required: false
SDNSegmentID string `url:"sdn_segment_id,omitempty" json:"sdn_segment_id,omitempty"`
// SDN Object Group IDs
// Required: false
SDNObjectGroupIDs []string `url:"sdn_object_group_ids,omitempty" json:"sdn_object_group_ids,omitempty"`
// SDN Logical Port Display Name
// Required: false
SDNLogicalPortDisplayName string `url:"sdn_logical_port_display_name,omitempty" json:"sdn_logical_port_display_name,omitempty"`
// SDN Logical Port Description
// Required: false
SDNLogicalPortDescription string `url:"sdn_logical_port_description,omitempty" json:"sdn_logical_port_description,omitempty"`
// 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
// Not applicable to netType VFNIC, TRUNK, or SDN
// 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"`
}
type wrapperNetAttachRequest struct {
NetAttachRequest
AsyncMode bool `url:"asyncMode"`
}
// NetAttach attaches network to compute and gets info about network
func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNetAttach, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetAttachRequest{
NetAttachRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/netAttach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return nil, err
}
info := RecordNetAttach{}
err = json.Unmarshal(res, &info)
if err != nil {
return nil, err
}
return &info, nil
}
// NetAttachAsync attaches network to compute with AsyncMode
func (c Compute) NetAttachAsync(ctx context.Context, req NetAttachRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetAttachRequest{
NetAttachRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/netAttach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

79
pkg/cloudbroker/compute/net_detach.go
View File

@@ -1,79 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// NetDetachRequest struct to detach network from compute
type NetDetachRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// IP of the network interface
// Required: false
IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"`
// MAC of the network interface
// Required: false
MAC string `url:"mac,omitempty" json:"mac,omitempty"`
}
type wrapperNetDetachRequest struct {
NetDetachRequest
AsyncMode bool `url:"asyncMode"`
}
// NetDetach detaches network from compute
func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetDetachRequest{
NetDetachRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/netDetach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// NetDetachAsync detaches network from compute with AsyncMode
func (c Compute) NetDetachAsync(ctx context.Context, req NetDetachRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetDetachRequest{
NetDetachRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/netDetach"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

94
pkg/cloudbroker/compute/net_qos.go
View File

@@ -1,94 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// NetQOSRequest struct for update QOS
type NetQOSRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Network ID
// Required: true
NetID uint64 `url:"netId" json:"netId" validate:"required"`
// Network type
// Should be one of:
// - VINS
// - EXTNET
// Required: true
NetType string `url:"netType" json:"netType" validate:"computeNetType"`
// Internal traffic, kbit
// Required: false
IngressRate uint64 `url:"ingress_rate,omitempty" json:"ingress_rate,omitempty"`
// Internal traffic burst, kbit
// Required: false
IngressBurst uint64 `url:"ingress_burst,omitempty" json:"ingress_burst,omitempty"`
// External traffic rate, kbit
// Required: false
EgressRate uint64 `url:"egress_rate,omitempty" json:"egress_rate,omitempty"`
}
type wrapperNetQOSRequest struct {
NetQOSRequest
AsyncMode bool `url:"asyncMode"`
}
// NetQOS updates compute interfaces QOS
func (c Compute) NetQOS(ctx context.Context, req NetQOSRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetQOSRequest{
NetQOSRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/netQos"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// NetQOSAsync updates compute interfaces QOS with AsyncMode
func (c Compute) NetQOSAsync(ctx context.Context, req NetQOSRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperNetQOSRequest{
NetQOSRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/netQos"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/pause.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PauseRequest struct to pause compute
type PauseRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperPauseRequest struct {
PauseRequest
AsyncMode bool `url:"asyncMode"`
}
// Pause pause compute
func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPauseRequest{
PauseRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/pause"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// PauseAsync pauses compute with AsyncMode
func (c Compute) PauseAsync(ctx context.Context, req PauseRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPauseRequest{
PauseRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/pause"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

91
pkg/cloudbroker/compute/pfw_add.go
View File

@@ -1,91 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PFWAddRequest struct to add port forward rule
type PFWAddRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// External start port number for the rule
// Required: true
PublicPortStart uint64 `url:"publicPortStart" json:"publicPortStart" validate:"required"`
// End port number (inclusive) for the ranged rule
// Default value: -1
// Required: false
PublicPortEnd int64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"`
// Internal base port number
// Required: false
LocalBasePort uint64 `url:"localBasePort,omitempty" json:"localBasePort,omitempty"`
// Network protocol
// Should be one of:
// - tcp
// - udp
// Required: true
Proto string `url:"proto" json:"proto" validate:"proto"`
}
type wrapperPFWAddRequest struct {
PFWAddRequest
AsyncMode bool `url:"asyncMode"`
}
// PFWAdd adds port forward rule
func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPFWAddRequest{
PFWAddRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/pfwAdd"
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
}
// PFWAddAsync adds port forward rule with AsyncMode
func (c Compute) PFWAddAsync(ctx context.Context, req PFWAddRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPFWAddRequest{
PFWAddRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/pfwAdd"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

94
pkg/cloudbroker/compute/pfw_del.go
View File

@@ -1,94 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PFWDelRequest struct to delete port forward rule
type PFWDelRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the rule to delete. If specified, all other arguments will be ignored
// Required: false
RuleID uint64 `url:"ruleId,omitempty" json:"ruleId,omitempty"`
// External start port number for the rule
// Required: false
PublicPortStart uint64 `url:"publicPortStart,omitempty" json:"publicPortStart,omitempty"`
// End port number (inclusive) for the ranged rule
// Required: false
PublicPortEnd uint64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"`
// Internal base port number
// Required: false
LocalBasePort uint64 `url:"localBasePort,omitempty" json:"localBasePort,omitempty"`
// Network protocol
// Should be one of:
// - tcp
// - udp
// Required: false
Proto string `url:"proto,omitempty" json:"proto,omitempty" validate:"omitempty,proto"`
}
type wrapperPFWDelRequest struct {
PFWDelRequest
AsyncMode bool `url:"asyncMode"`
}
// PFWDel deletes port forward rule
func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPFWDelRequest{
PFWDelRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/pfwDel"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// PFWDelAsync deletes port forward rule with AsyncMode
func (c Compute) PFWDelAsync(ctx context.Context, req PFWDelRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPFWDelRequest{
PFWDelRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/pfwDel"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

40
pkg/cloudbroker/compute/pfw_list.go
View File

@@ -1,40 +0,0 @@
package compute
import (
"context"
"encoding/json"
"net/http"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PFWListRequest struct to get list of port forwards
type PFWListRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
// PFWList gets compute port forwards list
func (c Compute) PFWList(ctx context.Context, req PFWListRequest) (*ListPFW, error) {
err := validators.ValidateRequest(req)
if err != nil {
return nil, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/pfwList"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
if err != nil {
return nil, err
}
list := ListPFW{}
err = json.Unmarshal(res, &list)
if err != nil {
return nil, err
}
return &list, nil
}

84
pkg/cloudbroker/compute/pin_to_node.go
View File

@@ -1,84 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PinToNodeRequest struct to pin compute to node
type PinToNodeRequest struct {
// ID of the compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Node ID to pin to
// Required: false
TargetNodeID uint64 `url:"targetNodeId" json:"targetNodeId"`
// Try to migrate or not if compute in running states
// Required: false
Force bool `url:"force" json:"force"`
// Auto start when node restarted
// Required: false
// Default: false
AutoStart bool `url:"autoStart" json:"autoStart"`
}
type wrapperPinToNodeRequest struct {
PinToNodeRequest
AsyncMode bool `url:"asyncMode"`
}
// PinToNode pins compute to current node
func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (uint64, error) {
err := validators.ValidateRequest(req)
if err != nil {
return 0, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPinToNodeRequest{
PinToNodeRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/pin_to_node"
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
}
// PinToNodeAsync pins compute to current node with AsyncMode
func (c Compute) PinToNodeAsync(ctx context.Context, req PinToNodeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPinToNodeRequest{
PinToNodeRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/pin_to_node"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/power_cycle.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// PowerCycleRequest struct to force stop and start compute
type PowerCycleRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperPowerCycleRequest struct {
PowerCycleRequest
AsyncMode bool `url:"asyncMode"`
}
// PowerCycle makes force stop and start compute
func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPowerCycleRequest{
PowerCycleRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/powerCycle"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// PowerCycleAsync makes force stop and start compute with AsyncMode
func (c Compute) PowerCycleAsync(ctx context.Context, req PowerCycleRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperPowerCycleRequest{
PowerCycleRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/powerCycle"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

44
pkg/cloudbroker/compute/raise_down.go
View File

@@ -1,44 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
)
type wrapperRaiseDownRequest struct {
AsyncMode bool `url:"asyncMode"`
}
// RaiseDown starting all computes in "DOWN" tech status
func (c Compute) RaiseDown(ctx context.Context) (bool, error) {
reqWrapped := wrapperRaiseDownRequest{AsyncMode: false}
url := "/cloudbroker/compute/raiseDown"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// RaiseDownAsync starting all computes in "DOWN" tech status with AsyncMode
func (c Compute) RaiseDownAsync(ctx context.Context) (string, error) {
reqWrapped := wrapperRaiseDownRequest{AsyncMode: true}
url := "/cloudbroker/compute/raiseDown"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/reboot.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// RebootRequest struct to reboot compute
type RebootRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperRebootRequest struct {
RebootRequest
AsyncMode bool `url:"asyncMode"`
}
// Reboot reboots compute
func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRebootRequest{
RebootRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/reboot"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// RebootAsync reboots compute with AsyncMode
func (c Compute) RebootAsync(ctx context.Context, req RebootRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRebootRequest{
RebootRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/reboot"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

103
pkg/cloudbroker/compute/redeploy.go
View File

@@ -1,103 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// RedeployRequest struct for redeploy
type RedeployRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// ID of the new OS image, if image change is required
// Required: false
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"`
// Storage policy id of compute. The rules of the specified storage policy will be used.
// Required: false
StoragePolicyID uint64 `url:"storage_policy_id,omitempty" json:"storage_policy_id,omitempty"`
// New size for the boot disk in GB, if boot disk size change is required
// Required: false
DiskSize uint64 `url:"diskSize,omitempty" json:"diskSize,omitempty"`
// How to handle data disks connected to this compute instance
// Should be one of:
// - KEEP
// - DETACH
// - DESTROY
// Required: false
DataDisks string `url:"dataDisks,omitempty" json:"dataDisks,omitempty" validate:"omitempty,computeDataDisks"`
// Should the compute be restarted upon successful redeploy
// Required: false
AutoStart bool `url:"autoStart,omitempty" json:"autoStart,omitempty"`
// Set this flag to True to force stop running compute instance and redeploy next
// Required: false
ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
}
type wrapperRedeployRequest struct {
RedeployRequest
AsyncMode bool `url:"asyncMode"`
}
// Redeploy redeploys compute
func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRedeployRequest{
RedeployRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/redeploy"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// RedeployAsync redeploys compute with AsyncMode
func (c Compute) RedeployAsync(ctx context.Context, req RedeployRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRedeployRequest{
RedeployRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/redeploy"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/reset.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ResetRequest struct to reset compute
type ResetRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperResetRequest struct {
ResetRequest
AsyncMode bool `url:"asyncMode"`
}
// Reset resets compute
func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResetRequest{
ResetRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/reset"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ResetAsync resets compute with AsyncMode
func (c Compute) ResetAsync(ctx context.Context, req ResetRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResetRequest{
ResetRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/reset"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

99
pkg/cloudbroker/compute/resize.go
View File

@@ -1,99 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ResizeRequest struct to resize compute
type ResizeRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// New CPU count.
// Pass 0 if no change to CPU count is required
// Required: false
CPU uint64 `url:"cpu,omitempty" json:"cpu,omitempty"`
// New RAM volume in MB.
// Pass 0 if no change to RAM volume is required
// Required: false
RAM uint64 `url:"ram,omitempty" json:"ram,omitempty"`
// Force compute resize
// Required: false
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
}
type wrapperResizeRequest struct {
ResizeRequest
AsyncMode bool `url:"asyncMode"`
}
// Resize resizes compute instance
func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResizeRequest{
ResizeRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/resize"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ResizeAsync resizes compute instance with AsyncMode
func (c Compute) ResizeAsync(ctx context.Context, req ResizeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResizeRequest{
ResizeRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/resize"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/restore.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// RestoreRequest struct to restore compute
type RestoreRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperRestoreRequest struct {
RestoreRequest
AsyncMode bool `url:"asyncMode"`
}
// Restore restores compute from recycle bin
func (c Compute) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRestoreRequest{
RestoreRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/restore"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// RestoreAsync restores compute from recycle bin with AsyncMode
func (c Compute) RestoreAsync(ctx context.Context, req RestoreRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperRestoreRequest{
RestoreRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/restore"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

71
pkg/cloudbroker/compute/resume.go
View File

@@ -1,71 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// ResumeRequest struct to resume compute
type ResumeRequest struct {
// ID of compute instance
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
}
type wrapperResumeRequest struct {
ResumeRequest
AsyncMode bool `url:"asyncMode"`
}
// Resume resumes Compute from paused state
func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResumeRequest{
ResumeRequest: req,
AsyncMode: false,
}
url := "/cloudbroker/compute/resume"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}
// ResumeAsync resumes Compute from paused state with AsyncMode
func (c Compute) ResumeAsync(ctx context.Context, req ResumeRequest) (string, error) {
err := validators.ValidateRequest(req)
if err != nil {
return "", validators.ValidationErrors(validators.GetErrors(err))
}
reqWrapped := wrapperResumeRequest{
ResumeRequest: req,
AsyncMode: true,
}
url := "/cloudbroker/compute/resume"
res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
if err != nil {
return "", err
}
return string(res), nil
}

43
pkg/cloudbroker/compute/serialize.go
View File

@@ -1,43 +0,0 @@
package compute
import (
"encoding/json"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/serialization"
)
// Serialize returns JSON-serialized []byte. Used as a wrapper over json.Marshal and json.MarshalIndent functions.
//
// In order to serialize with indent make sure to follow these guidelines:
// - First argument -> prefix
// - Second argument -> indent
func (lc ListComputes) Serialize(params ...string) (serialization.Serialized, error) {
if len(lc.Data) == 0 {
return []byte{}, nil
}
if len(params) > 1 {
prefix := params[0]
indent := params[1]
return json.MarshalIndent(lc, prefix, indent)
}
return json.Marshal(lc)
}
// Serialize returns JSON-serialized []byte. Used as a wrapper over json.Marshal and json.MarshalIndent functions.
//
// In order to serialize with indent make sure to follow these guidelines:
// - First argument -> prefix
// - Second argument -> indent
func (ic ItemCompute) Serialize(params ...string) (serialization.Serialized, error) {
if len(params) > 1 {
prefix := params[0]
indent := params[1]
return json.MarshalIndent(ic, prefix, indent)
}
return json.Marshal(ic)
}

43
pkg/cloudbroker/compute/set_cpu_alignment_profile.go
View File

@@ -1,43 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// SetCPUAlignmentProfileRequest struct to set CPU alignment profile for computes
type SetCPUAlignmentProfileRequest struct {
// IDs of the compute instances
// Required: true
ComputeIDs []int64 `url:"compute_ids" json:"compute_ids" validate:"min=1"`
// CPU alignment profile name
// Required: true
CPUAlignmentProfile string `url:"cpu_alignment_profile" json:"cpu_alignment_profile" validate:"required"`
}
// SetCPUAlignmentProfile sets CPU alignment profile for computes
func (c Compute) SetCPUAlignmentProfile(ctx context.Context, req SetCPUAlignmentProfileRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/set_cpu_alignment_profile"
res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
if err != nil {
return false, err
}
result, err := strconv.ParseBool(string(res))
if err != nil {
return false, err
}
return result, nil
}

42
pkg/cloudbroker/compute/set_custom_fields.go
View File

@@ -1,42 +0,0 @@
package compute
import (
"context"
"net/http"
"strconv"
"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
)
// SetCustomFieldsRequest struct for setting customFields values for the Compute
type SetCustomFieldsRequest struct {
// ID of the compute
// Required: true
ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
// Custom fields for Compute. Must be dict.
// Required: true
CustomFields string `url:"customFields" json:"customFields" validate:"required"`
}
// SetCustomFields sets customFields values for the Compute
func (c Compute) SetCustomFields(ctx context.Context, req SetCustomFieldsRequest) (bool, error) {
err := validators.ValidateRequest(req)
if err != nil {
return false, validators.ValidationErrors(validators.GetErrors(err))
}
url := "/cloudbroker/compute/setCustomFields"
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
}

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