v1.0.0

pkg/cloudbroker/compute/affinity_group_check_start.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+)
+
+// Request struct for check all computes with current affinity label can start
+type AffinityGroupCheckStartRequest struct {
+	// ID of the resource group
+	// Required: true
+	RGID uint64 `url:"rgId"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel"`
+}
+
+func (crq AffinityGroupCheckStartRequest) validate() error {
+	if crq.RGID == 0 {
+		return errors.New("validation-error: field RGID must be set")
+	}
+	if crq.AffinityLabel == "" {
+		return errors.New("validation-error: field AffinityLabel must be set")
+	}
+
+	return nil
+}
+
+// AffinityGroupCheckStart check all computes with current affinity label can start
+func (c Compute) AffinityGroupCheckStart(ctx context.Context, req AffinityGroupCheckStartRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	url := "/cloudbroker/compute/affinityGroupCheckStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/affinity_label_remove.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for clear affinity label for compute
+type AffinityLabelRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+}
+
+func (crq AffinityLabelRemoveRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// AffinityLabelRemove clear affinity label for compute
+func (c Compute) AffinityLabelRemove(ctx context.Context, req AffinityLabelRemoveRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/affinity_label_set.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for set affinity label for compute
+type AffinityLabelSetRequest struct {
+	// IDs of the compute instances
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel"`
+}
+
+func (crq AffinityLabelSetRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.AffinityLabel == "" {
+		return errors.New("validation-error: field AffinityLabel must be set")
+	}
+
+	return nil
+}
+
+// AffinityLabelSet set affinity label for compute
+func (c Compute) AffinityLabelSet(ctx context.Context, req AffinityLabelSetRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/affinity_relations.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get dict of computes
+type AffinityRelationsRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Affinity group label
+	// Required: false
+	AffinityLabel string `url:"affinityLabel,omitempty"`
+}
+
+func (crq AffinityRelationsRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID can not be empty or equal to 0")
+	}
+
+	return nil
+}
+
+// AffinityRelations gets dict of computes divided by affinity and anti affinity rules
+func (c Compute) AffinityRelations(ctx context.Context, req AffinityRelationsRequest) (*RecordAffinityRelations, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/affinity_rule_add.go

@@ -0,0 +1,103 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for add affinity rule
+type AffinityRuleAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Should be one of:
+	//	- node
+	//	- compute
+	// Required: true
+	Topology string `url:"topology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: true
+	Value string `url:"value"`
+}
+
+func (crq AffinityRuleAddRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Topology == "" {
+		return errors.New("validation-error: field Topology must be set")
+	}
+	validator := validators.StringInSlice(crq.Topology, []string{"compute", "node"})
+	if !validator {
+		return errors.New("validation-error: field Topology can be only compute or node")
+	}
+	if crq.Policy == "" {
+		return errors.New("validation-error: field Policy must be set")
+	}
+	validator = validators.StringInSlice(crq.Policy, []string{"RECOMMENDED", "REQUIRED"})
+	if !validator {
+		return errors.New("validation-error: field Policy can be only RECOMMENDED or REQUIRED")
+	}
+	if crq.Mode == "" {
+		return errors.New("validation-error: field Mode must be set")
+	}
+	validator = validators.StringInSlice(crq.Mode, []string{"EQ", "NE", "ANY"})
+	if !validator {
+		return errors.New("validation-error: field Mode can be only EQ, NE or ANY")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+	if crq.Value == "" {
+		return errors.New("validation-error: field Value must be set")
+	}
+
+	return nil
+}
+
+// AffinityRuleAdd add affinity rule
+func (c Compute) AffinityRuleAdd(ctx context.Context, req AffinityRuleAddRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/affinity_rule_remove.go

@@ -0,0 +1,101 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for remove affinity rule
+type AffinityRuleRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: true
+	Value string `url:"value"`
+}
+
+func (crq AffinityRuleRemoveRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Topology == "" {
+		return errors.New("validation-error: field Topology must be set")
+	}
+	validator := validators.StringInSlice(crq.Topology, []string{"compute", "node"})
+	if !validator {
+		return errors.New("validation-error: field Topology can be only compute or node")
+	}
+	if crq.Policy == "" {
+		return errors.New("validation-error: field Policy must be set")
+	}
+	validator = validators.StringInSlice(crq.Policy, []string{"RECOMMENDED", "REQUIRED"})
+	if !validator {
+		return errors.New("validation-error: field Policy can be only RECOMMENDED or REQUIRED")
+	}
+	if crq.Mode == "" {
+		return errors.New("validation-error: field Mode must be set")
+	}
+	validator = validators.StringInSlice(crq.Mode, []string{"EQ", "NE", "ANY"})
+	if !validator {
+		return errors.New("validation-error: field Mode can be only EQ, NE or ANY")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+	if crq.Value == "" {
+		return errors.New("validation-error: field Value must be set")
+	}
+
+	return nil
+}
+
+// AffinityRuleRemove remove affinity rule
+func (c Compute) AffinityRuleRemove(ctx context.Context, req AffinityRuleRemoveRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/affinity_rules_clear.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for clear affinity rules
+type AffinityRulesClearRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+}
+
+func (crq AffinityRulesClearRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// AffinityRulesClear clear affinity rules
+func (c Compute) AffinityRulesClear(ctx context.Context, req AffinityRulesClearRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/anti_affinity_rule_add.go

@@ -0,0 +1,101 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for add anti affinity rule
+type AntiAffinityRuleAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: true
+	Value string `url:"value"`
+}
+
+func (crq AntiAffinityRuleAddRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Topology == "" {
+		return errors.New("validation-error: field Topology must be set")
+	}
+	validator := validators.StringInSlice(crq.Topology, []string{"compute", "node"})
+	if !validator {
+		return errors.New("validation-error: field Topology can be only compute or node")
+	}
+	if crq.Policy == "" {
+		return errors.New("validation-error: field Policy must be set")
+	}
+	validator = validators.StringInSlice(crq.Policy, []string{"RECOMMENDED", "REQUIRED"})
+	if !validator {
+		return errors.New("validation-error: field Policy can be only RECOMMENDED or REQUIRED")
+	}
+	if crq.Mode == "" {
+		return errors.New("validation-error: field Mode must be set")
+	}
+	validator = validators.StringInSlice(crq.Mode, []string{"EQ", "NE", "ANY"})
+	if !validator {
+		return errors.New("validation-error: field Mode can be only EQ, NE or ANY")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+	if crq.Value == "" {
+		return errors.New("validation-error: field Value must be set")
+	}
+
+	return nil
+}
+
+// AntiAffinityRuleAdd add anti affinity rule
+func (c Compute) AntiAffinityRuleAdd(ctx context.Context, req AntiAffinityRuleAddRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/anti_affinity_rule_clear.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for clear anti affinity rules
+type AntiAffinityRulesClearRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+}
+
+func (crq AntiAffinityRulesClearRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// AntiAffinityRulesClear clear anti affinity rules
+func (c Compute) AntiAffinityRulesClear(ctx context.Context, req AntiAffinityRulesClearRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/anti_affinity_rule_remove.go

@@ -0,0 +1,101 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for remove anti affinity rule
+type AntiAffinityRuleRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: true
+	Value string `url:"value"`
+}
+
+func (crq AntiAffinityRuleRemoveRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Topology == "" {
+		return errors.New("validation-error: field Topology must be set")
+	}
+	validator := validators.StringInSlice(crq.Topology, []string{"compute", "node"})
+	if !validator {
+		return errors.New("validation-error: field Topology can be only compute or node")
+	}
+	if crq.Policy == "" {
+		return errors.New("validation-error: field Policy must be set")
+	}
+	validator = validators.StringInSlice(crq.Policy, []string{"RECOMMENDED", "REQUIRED"})
+	if !validator {
+		return errors.New("validation-error: field Policy can be only RECOMMENDED or REQUIRED")
+	}
+	if crq.Mode == "" {
+		return errors.New("validation-error: field Mode must be set")
+	}
+	validator = validators.StringInSlice(crq.Mode, []string{"EQ", "NE", "ANY"})
+	if !validator {
+		return errors.New("validation-error: field Mode can be only EQ, NE or ANY")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+	if crq.Value == "" {
+		return errors.New("validation-error: field Value must be set")
+	}
+
+	return nil
+}
+
+// AntiAffinityRuleRemove remove anti affinity rule
+func (c Compute) AntiAffinityRuleRemove(ctx context.Context, req AntiAffinityRuleRemoveRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/attach_gpu.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for attach GPU for compute
+type AttachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Identifier vGPU
+	// Required: true
+	VGPUID uint64 `url:"vgpuId"`
+}
+
+func (crq AttachGPURequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.VGPUID == 0 {
+		return errors.New("validation-error: field VGPUID must be set")
+	}
+
+	return nil
+}
+
+// AttachGPU attach GPU for compute, returns vGPU ID on success
+func (c Compute) AttachGPU(ctx context.Context, req AttachGPURequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, 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
+}

pkg/cloudbroker/compute/attach_pci_device.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for atttach PCI device
+type AttachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// PCI device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId"`
+}
+
+func (crq AttachPCIDeviceRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DeviceID == 0 {
+		return errors.New("validation-error: field DeviceID must be set")
+	}
+
+	return nil
+}
+
+// AttachPCIDevice attach PCI device
+func (c Compute) AttachPCIDevice(ctx context.Context, req AttachPCIDeviceRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/audits.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get audit records
+type AuditsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq AuditsRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Audits gets audit records for the specified compute object
+func (c Compute) Audits(ctx context.Context, req AuditsRequest) (ListDetailedAudits, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/audits"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListDetailedAudits{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/boot_order_get.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get boot order
+type BootOrderGetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq BootOrderGetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// BootOrderGet gets actual compute boot order information
+func (c Compute) BootOrderGet(ctx context.Context, req BootOrderGetRequest) ([]string, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/boot_order_set.go

@@ -0,0 +1,65 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for set boot order
+type BootOrderSetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// List of boot devices
+	// Should be one of:
+	//	- cdrom
+	//	- network
+	//	- hd
+	// Required: true
+	Order []string `url:"order"`
+}
+
+func (crq BootOrderSetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if len(crq.Order) == 0 {
+		return errors.New("validation-error: field Order must be set")
+	}
+	for _, value := range crq.Order {
+		if validate := validators.StringInSlice(value, []string{"cdrom", "network", "hd"}); !validate {
+			return errors.New("validation-error: field ImageType can be cdrom, network, hd")
+		}
+	}
+
+	return nil
+}
+
+// BootOrderSet sets compute boot order
+func (c Compute) BootOrderSet(ctx context.Context, req BootOrderSetRequest) ([]string, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/cd_eject.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for eject CD image
+type CDEjectRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason to eject
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq CDEjectRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must ve set")
+	}
+
+	return nil
+}
+
+// CDEject eject CD image to compute's CD-ROM
+func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/cdEject"
+
+	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, err
+}

pkg/cloudbroker/compute/cd_insert.go

@@ -0,0 +1,50 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+)
+
+// Request struct for insert new CD image
+type CDInsertRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of CD-ROM image
+	// Required: true
+	CDROMID uint64 `url:"cdromId"`
+
+	// Reason to insert
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq CDInsertRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.CDROMID == 0 {
+		return errors.New("validation-error: field CDROMID must be set")
+	}
+
+	return nil
+}
+
+// CDInsert insert new CD image to compute's CD-ROM
+func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/cdInsert"
+
+	_, err = c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}

pkg/cloudbroker/compute/clone.go

@@ -0,0 +1,64 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for clone compute instance
+type CloneRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name of the clone
+	// Required: true
+	Name string `url:"name"`
+
+	// Timestamp of the parent's snapshot to create clone from
+	// Required: false
+	SnapshotTimestamp uint64 `url:"snapshotTimestamp"`
+
+	// Name of the parent's snapshot to create clone from
+	// Required: false
+	SnapshotName string `url:"snapshotName"`
+
+	// Reason to clone
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq CloneRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Name == "" {
+		return errors.New("validation-error: field Name must be set")
+	}
+
+	return nil
+}
+
+// Clone clones compute instance
+func (c Compute) Clone(ctx context.Context, req CloneRequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, err
+	}
+
+	url := "/cloudbroker/compute/clone"
+
+	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
+}

pkg/cloudbroker/compute/compute.go

@@ -0,0 +1,16 @@
+// API Actor for managing Compute. This actor is a final API for admin to manage Compute
+package compute
+
+import "github.com/rudecs/decort-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,
+	}
+}

pkg/cloudbroker/compute/computeci_set.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for set compute CI
+type ComputeCISetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the Compute CI
+	// Required: true
+	ComputeCIID uint64 `url:"computeciId"`
+}
+
+func (crq ComputeCISetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.ComputeCIID == 0 {
+		return errors.New("validation-error: field ComputeCIID must be set")
+	}
+
+	return nil
+}
+
+// ComputeCISet sets compute CI ID for compute
+func (c Compute) ComputeCISet(ctx context.Context, req ComputeCISetRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/computeci_unset.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for unset compite CI
+type ComputeCIUnsetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq ComputeCIUnsetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// ComputeCIUnset unsets compute CI ID from compute
+func (c Compute) ComputeCIUnset(ctx context.Context, req ComputeCIUnsetRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/create_template.go

@@ -0,0 +1,86 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// Request struct for create template
+type CreateTemplateRequest struct {
+	// ID of the compute to create template from
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name to assign to the template being created
+	// Required: true
+	Name string `url:"name"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+
+	// Async API call
+	// For async call use CreateTemplateAsync
+	// For sync call use CreateTemplate
+	// Required: true
+	async bool `url:"async"`
+}
+
+func (crq CreateTemplateRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Name == "" {
+		return errors.New("validation-error: field Name must be set")
+	}
+
+	return nil
+}
+
+// CreateTemplateAsync create template from compute instance
+func (c Compute) CreateTemplateAsync(ctx context.Context, req CreateTemplateRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	req.async = true
+
+	url := "/cloudbroker/compute/createTemplate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}
+
+// CreateTemplate create template from compute instance
+func (c Compute) CreateTemplate(ctx context.Context, req CreateTemplateRequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, err
+	}
+
+	req.async = false
+
+	url := "/cloudbroker/compute/createTemplate"
+
+	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
+}

pkg/cloudbroker/compute/delete.go

@@ -0,0 +1,57 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for delete compute
+type DeleteRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Delete permanently
+	// Required: false
+	Permanently bool `url:"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"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DeleteRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Delete deletes compute
+func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/delete"
+
+	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
+}

pkg/cloudbroker/compute/detach_gpu.go

@@ -0,0 +1,50 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for detach VGPU for compute
+type DetachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Identifier virtual GPU
+	// Required: false
+	VGPUID int64 `url:"vgpuId,omitempty"`
+}
+
+func (crq DetachGPURequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// DetachGPU detach 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 := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/detach_pci_device.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for detach PCI device
+type DetachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// PCI device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId"`
+}
+
+func (crq DetachPCIDeviceRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DeviceID == 0 {
+		return errors.New("validation-error: field DeviceID must be set")
+	}
+
+	return nil
+}
+
+// DetachPCIDevice detach PCI device
+func (c Compute) DetachPciDevice(ctx context.Context, req DetachPCIDeviceRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/disable.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for disable compute
+type DisableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DisableRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Disable disables compute
+func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_add.go

@@ -0,0 +1,84 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for create and attach disk to compute
+type DiskAddRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name for disk
+	// Required: true
+	DiskName string `url:"diskName"`
+
+	// Disk size in GB
+	// Required: true
+	Size uint64 `url:"size"`
+
+	// Type of the disk
+	// Should be one of:
+	//	- D
+	//	- B
+	// Required: false
+	DiskType string `url:"diskType,omitempty"`
+
+	// Storage endpoint provider ID
+	// By default the same with boot disk
+	// Required: false
+	SepID uint64 `url:"sepId,omitempty"`
+
+	// Pool name
+	// By default will be chosen automatically
+	// Required: false
+	Pool string `url:"pool,omitempty"`
+
+	// Optional description
+	// Required: false
+	Description string `url:"desc,omitempty"`
+
+	// Specify image id for create disk from template
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty"`
+}
+
+func (crq DiskAddRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskName == "" {
+		return errors.New("validation-error: field DiskName must be set")
+	}
+	if crq.Size == 0 {
+		return errors.New("validation-error: field Size must be set")
+	}
+
+	return nil
+}
+
+// DiskAdd creates new disk and attach to compute
+func (c Compute) DiskAdd(ctx context.Context, req DiskAddRequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, err
+	}
+
+	url := "/cloudbroker/compute/diskAdd"
+
+	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
+}

pkg/cloudbroker/compute/disk_attach.go

@@ -0,0 +1,56 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for attach disk to compute
+type DiskAttachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the disk to attach
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DiskAttachRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+
+	return nil
+}
+
+// DiskAttach attach disk to compute
+func (c Compute) DiskAttach(ctx context.Context, req DiskAttachRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/diskAttach"
+
+	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
+}

pkg/cloudbroker/compute/disk_del.go

@@ -0,0 +1,60 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for detach and delete disk from compute
+type DiskDelRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of disk instance
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+
+	// False if disk is to be deleted to recycle bin
+	// Required: true
+	Permanently bool `url:"permanently"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DiskDelRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+
+	return nil
+}
+
+// DiskDel delete disk and detach from compute
+func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/diskDel"
+
+	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
+}

pkg/cloudbroker/compute/disk_detach.go

@@ -0,0 +1,56 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for detach disk from compute
+type DiskDetachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the disk to detach
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DiskDetachRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+
+	return nil
+}
+
+// DiskDetach detach disk from compute
+func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/diskDetach"
+
+	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
+}

pkg/cloudbroker/compute/disk_qos.go

@@ -0,0 +1,59 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for change QOS of the disk
+type DiskQOSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the disk to apply limits
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+
+	// Limit IO for a certain disk total and read/write options are not allowed to be combined
+	// Required: true
+	Limits string `url:"limits"`
+}
+
+func (crq DiskQOSRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+	if crq.Limits == "" {
+		return errors.New("validation-error: field Limits must be set")
+	}
+
+	return nil
+}
+
+// DiskQOS change QOS of the disk
+func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/diskQos"
+
+	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
+}

pkg/cloudbroker/compute/disk_resize.go

@@ -0,0 +1,63 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for change disk size
+type DiskResizeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the disk to resize
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+
+	// New disk size
+	// Required: true
+	Size uint64 `url:"size"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq DiskResizeRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+	if crq.Size == 0 {
+		return errors.New("validation-error: field Size must be set")
+	}
+
+	return nil
+}
+
+// DiskResize change disk size
+func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/diskResize"
+
+	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
+}

pkg/cloudbroker/compute/enable.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for enable compute
+type EnableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq EnableRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Enable enables compute
+func (c Compute) Enable(ctx context.Context, req EnableRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, 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
+}

pkg/cloudbroker/compute/get.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request for get information about compute
+type GetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason to action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq GetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Get gets information about compute
+func (c Compute) Get(ctx context.Context, req GetRequest) (*RecordCompute, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/get"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordCompute{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudbroker/compute/get_audits.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get compute audits
+type GetAuditsRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason to action
+	// Required: true
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq GetAuditsRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// GetAudits gets compute audits
+func (c Compute) GetAudits(ctx context.Context, req GetAuditsRequest) (ListAudits, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/get_console_url.go

@@ -0,0 +1,44 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for get console URL
+type GetConsoleURLRequest struct {
+	// ID of compute instance to get console for
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq GetConsoleURLRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// GetConsoleURL gets computes console URL
+func (c Compute) GetConsoleURL(ctx context.Context, req GetConsoleURLRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", 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
+}

pkg/cloudbroker/compute/get_log.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get compute logs
+type GetLogRequest struct {
+	// ID of compute instance to get log for
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Path to log file
+	// Required: true
+	Path string `url:"path"`
+}
+
+func (crq GetLogRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Path == "" {
+		return errors.New("validation-error: field Path must be set")
+	}
+
+	return nil
+}
+
+// GetLog gets compute's log file by path
+func (c Compute) GetLog(ctx context.Context, req GetLogRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	url := "/cloudbroker/compute/getLog"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/list.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+)
+
+// Request struct for get list available computes
+type ListRequest struct {
+	// Include deleted computes
+	// Required: false
+	IncludeDeleted bool `url:"includedeleted,omitempty"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty"`
+}
+
+// List gets list of the available computes.
+// Filtering based on status is possible
+func (c Compute) List(ctx context.Context, req ListRequest) (ListComputes, error) {
+	url := "/cloudbroker/compute/list"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListComputes{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/list_deleted.go

@@ -0,0 +1,37 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+)
+
+// Request struct for get deleted computes list
+type ListDeletedRequest struct {
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty"`
+}
+
+// ListDeleted gets list all deleted computes
+func (c Compute) ListDeleted(ctx context.Context, req ListDeletedRequest) (ListComputes, error) {
+	url := "/cloudbroker/compute/listDeleted"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListComputes{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/list_gpu.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get list GPU for compute
+type ListGPURequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Also list destroyed
+	// Required: false
+	ListDestroyed bool `url:"list_destroyed,omitempty"`
+}
+
+func (crq ListGPURequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// ListVGPU gets list GPU for compute
+func (c Compute) ListVGPU(ctx context.Context, req ListGPURequest) ([]interface{}, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/listGpu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := make([]interface{}, 0)
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/list_pci_device.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get list PCI devices
+type ListPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq ListPCIDeviceRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// ListPCIDevice gets list PCI device
+func (c Compute) ListPCIDevice(ctx context.Context, req ListPCIDeviceRequest) (ListPCIDevices, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/mass_delete.go

@@ -0,0 +1,53 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for delete several computes
+type MassDeleteRequest struct {
+	// IDs of compute instances to delete
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Delete computes permanently
+	// Required: false
+	Permanently bool `url:"permanently,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MassDeleteRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// MassDelete starts jobs to delete several computes
+func (c Compute) MassDelete(ctx context.Context, req MassDeleteRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/massDelete"
+
+	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
+}

pkg/cloudbroker/compute/mass_reboot.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for reboot several computes
+type MassRebootRequest struct {
+	// IDs of compute instances to reboot
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MassRebootRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// MassReboot starts jobs to reboot several computes
+func (c Compute) MassReboot(ctx context.Context, req MassRebootRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/massReboot"
+
+	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
+}

pkg/cloudbroker/compute/mass_repair_boot_fs.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for repair boot disk filesystem on several computes
+type MassRepairBootFSRequest struct {
+	// IDs of compute instances which boot file systems will be repaired
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MassRepairBootFSRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// MassRepairBootFS repair boot disk filesystem on several computes
+func (c Compute) MassRepairBootFS(ctx context.Context, req MassRepairBootFSRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/massRepairBootFs"
+
+	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
+}

pkg/cloudbroker/compute/mass_start.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for start several computes
+type MassStartRequest struct {
+	// IDs of compute instances to start
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MassStartRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// MassStart starts jobs to start several computes
+func (c Compute) MassStart(ctx context.Context, req MassStartRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/massStart"
+
+	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
+}

pkg/cloudbroker/compute/mass_stop.go

@@ -0,0 +1,53 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for several stop computes
+type MassStopRequest struct {
+	// IDs of compute instances to stop
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Force stop compute
+	// Required: false
+	Force bool `url:"force,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MassStopRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+
+	return nil
+}
+
+// MassStop starts jobs to stop several computes
+func (c Compute) MassStop(ctx context.Context, req MassStopRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/massStop"
+
+	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
+}

pkg/cloudbroker/compute/migrate.go

@@ -0,0 +1,58 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for migrate compute
+type MigrateRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Particular Stack ID to migrate this compute to
+	// Required: false
+	TargetStackID uint64 `url:"targetStackId,omitempty"`
+
+	// If live migration fails, destroy compute
+	// on source node and recreate on the target
+	// Required: false
+	Force bool `url:"force,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq MigrateRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Migrate migrates compute to another stack
+func (c Compute) Migrate(ctx context.Context, req MigrateRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/migrate"
+
+	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
+}

pkg/cloudbroker/compute/migrate_storage.go

@@ -0,0 +1,70 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for migration
+type MigrateStorageRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// SEP ID to migrate disks
+	// Required: true
+	SEPID uint64 `url:"sepId"`
+
+	// SEP pool name to migrate disks
+	// Required: true
+	PoolName string `url:"poolName"`
+
+	// Target stack ID
+	// Required: true
+	StackID uint64 `url:"stackId"`
+
+	// Async API call
+	// Required: true
+	Sync bool `url:"sync"`
+}
+
+func (crq MigrateStorageRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.SEPID == 0 {
+		return errors.New("validation-error: field SEPID must be set")
+	}
+	if crq.PoolName == "" {
+		return errors.New("validation-error: field PoolName must be set")
+	}
+	if crq.StackID == 0 {
+		return errors.New("validation-error: field StackID must be set")
+	}
+
+	return nil
+}
+
+// MigrateStorage gets complex compute migration
+// Compute will be migrated to specified stack, 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 := req.validate()
+	if err != nil {
+		return "", 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
+}

pkg/cloudbroker/compute/migrate_storage_abort.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for abort migration
+type MigrateStorageAbortRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq MigrateStorageAbortRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// MigrateStorageAbort abort complex compute migration job
+func (c Compute) MigrateStorageAbort(ctx context.Context, req MigrateStorageAbortRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	url := "/cloudbroker/compute/migrateStorageAbort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage_clean_up.go

@@ -0,0 +1,44 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for cleanup resources after finished migration
+type MigrateStorageCleanUpRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq MigrateStorageCleanUpRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// 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) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	url := "/cloudbroker/compute/migrateStorageCleanup"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage_info.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for get info about migration
+type MigrateStorageInfoRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq MigrateStorageInfoRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// MigrateStorageInfo gets info about last (include ongoing) storage migration
+func (c Compute) MigrateStorageInfo(ctx context.Context, req MigrateStorageInfoRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", 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
+}

pkg/cloudbroker/compute/models.go

@@ -0,0 +1,778 @@
+package compute
+
+// Access Control List
+type RecordACL struct {
+	// Account ACL list
+	AccountACL ListACL `json:"accountACL"`
+
+	// Compute ACL list
+	ComputeACL []ItemComputeACL `json:"computeACL"`
+
+	// Resource group ACL list
+	RGACL ListACL `json:"rgACL"`
+}
+
+// ACL information
+type ItemACL struct {
+	// Explicit
+	Explicit bool `json:"explicit"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// Right
+	Right string `json:"right"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Type
+	Type string `json:"type"`
+
+	// User group ID
+	UserGroupID string `json:"userGroupId"`
+}
+
+// ACL compute information
+type ItemComputeACL struct {
+	// Explicit
+	Explicit string `json:"explicit"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// Right
+	Right string `json:"right"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Type
+	Type string `json:"type"`
+
+	// User group ID
+	UserGroupID string `json:"userGroupId"`
+}
+
+// List ACL
+type ListACL []ItemACL
+
+// Main information about snapshot
+type ItemSnapshot struct {
+	// List of disk IDs
+	Disks []uint64 `json:"disks"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// Label
+	Label string `json:"label"`
+
+	// Timestamp
+	Timestamp uint64 `json:"timestamp"`
+}
+
+// List of snapshots
+type ListSnapshots []ItemSnapshot
+
+// Main information about snapshot usage
+type ItemSnapshotUsage struct {
+	// Count
+	Count uint64 `json:"count,omitempty"`
+
+	// Stored
+	Stored float64 `json:"stored"`
+
+	// Label
+	Label string `json:"label,omitempty"`
+
+	// Timestamp
+	Timestamp uint64 `json:"timestamp,omitempty"`
+}
+
+// List of snapshot usage
+type ListSnapshotUsage []ItemSnapshotUsage
+
+// QOS
+type QOS struct {
+	// ERate
+	ERate uint64 `json:"eRate"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// InBurst
+	InBurst uint64 `json:"inBurst"`
+
+	// InRate
+	InRate uint64 `json:"inRate"`
+}
+
+// Main information about attached network
+type RecordNetAttach struct {
+	// Connection ID
+	ConnID uint64 `json:"connId"`
+
+	// Connection type
+	ConnType string `json:"connType"`
+
+	// Default GW
+	DefGW string `json:"defGw"`
+
+	// FLIPGroup ID
+	FLIPGroupID uint64 `json:"flipgroupId"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// IP address
+	IPAddress string `json:"ipAddress"`
+
+	// Listen SSH
+	ListenSSH bool `json:"listenSsh"`
+
+	// MAC
+	MAC string `json:"mac"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Network ID
+	NetID uint64 `json:"netId"`
+
+	// Network mask
+	NetMask uint64 `json:"netMask"`
+
+	// Network type
+	NetType string `json:"netType"`
+
+	// PCI slot
+	PCISlot uint64 `json:"pciSlot"`
+
+	// QOS
+	QOS QOS `json:"qos"`
+
+	// Target
+	Target string `json:"target"`
+
+	// Type
+	Type string `json:"type"`
+
+	// List VNF IDs
+	VNFs []uint64 `json:"vnfs"`
+}
+
+// Main information about affinity relations
+type RecordAffinityRelations struct {
+	// Other node
+	OtherNode []interface{} `json:"otherNode"`
+
+	// Other node indirect
+	OtherNodeIndirect []interface{} `json:"otherNodeIndirect"`
+
+	// Other node indirect soft
+	OtherNodeIndirectSoft []interface{} `json:"otherNodeIndirectSoft"`
+
+	// Other node soft
+	OtherNodeSoft []interface{} `json:"otherNodeSoft"`
+
+	// Same node
+	SameNode []interface{} `json:"sameNode"`
+
+	// Same node soft
+	SameNodeSoft []interface{} `json:"sameNodeSoft"`
+}
+
+// Detailed information about audit
+type ItemDetailedAudit struct {
+	// Call
+	Call string `json:"call"`
+
+	// Response time
+	ResponseTime float64 `json:"responsetime"`
+
+	// Status code
+	StatusCode uint64 `json:"statuscode"`
+
+	// Timestamp
+	Timestamp float64 `json:"timestamp"`
+
+	// User
+	User string `json:"user"`
+}
+
+// List of detailed audit
+type ListDetailedAudits []ItemDetailedAudit
+
+// Main information about port forward
+type ItemPFW struct {
+	// ID
+	ID uint64 `json:"id"`
+
+	// Local IP
+	LocalIP string `json:"localIp"`
+
+	// Local port
+	LocalPort uint64 `json:"localPort"`
+
+	// Protocol
+	Protocol string `json:"protocol"`
+
+	// Public port end
+	PublicPortEnd uint64 `json:"publicPortEnd"`
+
+	// Public port start
+	PublicPortStart uint64 `json:"publicPortStart"`
+
+	// Virtuel machine ID
+	VMID uint64 `json:"vmId"`
+}
+
+// List port forwards
+type ListPFW []ItemPFW
+
+// Main information about rule
+type ItemRule struct {
+	// GUID
+	GUID string `json:"guid"`
+
+	// Key
+	Key string `json:"key"`
+
+	// Mode
+	Mode string `json:"mode"`
+
+	// Policy
+	Policy string `json:"policy"`
+
+	// Topology
+	Topology string `json:"topology"`
+
+	// Value
+	Value string `json:"value"`
+}
+
+// List rules
+type ListRules []ItemRule
+
+// Main information about IO tune
+type IOTune struct {
+	// ReadBytesSec
+	ReadBytesSec uint64 `json:"read_bytes_sec"`
+
+	// ReadBytesSecMax
+	ReadBytesSecMax uint64 `json:"read_bytes_sec_max"`
+
+	// ReadIOPSSec
+	ReadIOPSSec uint64 `json:"read_iops_sec"`
+
+	// ReadIOPSSecMax
+	ReadIOPSSecMax uint64 `json:"read_iops_sec_max"`
+
+	// SizeIOPSSec
+	SizeIOPSSec uint64 `json:"size_iops_sec"`
+
+	// TotalBytesSec
+	TotalBytesSec uint64 `json:"total_bytes_sec"`
+
+	// TotalBytesSecMax
+	TotalBytesSecMax uint64 `json:"total_bytes_sec_max"`
+
+	// TotalIOPSSec
+	TotalIOPSSec uint64 `json:"total_iops_sec"`
+
+	// TotalIOPSSecMax
+	TotalIOPSSecMax uint64 `json:"total_iops_sec_max"`
+
+	// WriteBytesSec
+	WriteBytesSec uint64 `json:"write_bytes_sec"`
+
+	// WriteBytesSecMax
+	WriteBytesSecMax uint64 `json:"write_bytes_sec_max"`
+
+	// WriteIOPSSec
+	WriteIOPSSec uint64 `json:"write_iops_sec"`
+
+	// WriteIOPSSecMax
+	WriteIOPSSecMax uint64 `json:"write_iops_sec_max"`
+}
+
+// Detailed information about snapshot
+type ItemSnapshotDetailed struct {
+	// GUID
+	GUID string `json:"guid"`
+
+	// Label
+	Label string `json:"label"`
+
+	// Resource ID
+	ResID string `json:"resId"`
+
+	// SnapSetGUID
+	SnapSetGUID string `json:"snapSetGuid"`
+
+	// SnapSetTime
+	SnapSetTime uint64 `json:"snapSetTime"`
+
+	// TimeStamp
+	TimeStamp uint64 `json:"timestamp"`
+}
+
+// List detailed snapshots
+type ListDetailedSnapshots []ItemSnapshotDetailed
+
+// Main information about disk
+type ItemDisk struct {
+	// CKey
+	CKey string `json:"_ckey"`
+
+	// Meta
+	Meta []interface{} `json:"_meta"`
+
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Access Control List
+	ACL ItemACL `json:"acl"`
+
+	// Boot partition
+	BootPartition uint64 `json:"bootPartition"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Description
+	Description string `json:"desc"`
+
+	// Destruction time
+	DestructionTime uint64 `json:"destructionTime"`
+
+	// Disk path
+	DiskPath string `json:"diskPath"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Image ID
+	ImageID uint64 `json:"imageId"`
+
+	// List image IDs
+	Images []uint64 `json:"images"`
+
+	// IOTune
+	IOTune IOTune `json:"iotune"`
+
+	// IQN
+	IQN string `json:"iqn"`
+
+	// Login
+	Login string `json:"login"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Order
+	Order uint64 `json:"order"`
+
+	// Params
+	Params string `json:"params"`
+
+	// Parent ID
+	ParentID uint64 `json:"parentId"`
+
+	// Password
+	Password string `json:"passwd"`
+
+	// PCI slot
+	PCISlot uint64 `json:"pciSlot"`
+
+	// Pool
+	Pool string `json:"pool"`
+
+	// Purge attempts
+	PurgeAttempts uint64 `json:"purgeAttempts"`
+
+	// Purge time
+	PurgeTime uint64 `json:"purgeTime"`
+
+	// Reality device number
+	RealityDeviceNumber uint64 `json:"realityDeviceNumber"`
+
+	// Reference ID
+	ReferenceID string `json:"referenceId"`
+
+	// Resource ID
+	ResID string `json:"resId"`
+
+	// Resource name
+	ResName string `json:"resName"`
+
+	// Role
+	Role string `json:"role"`
+
+	// SEP ID
+	SEPID uint64 `json:"sepId"`
+
+	// Size max
+	SizeMax uint64 `json:"sizeMax"`
+
+	// Size used
+	SizeUsed uint64 `json:"sizeUsed"`
+
+	// List detailed snapshots
+	Snapshots ListDetailedSnapshots `json:"snapshots"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Tech status
+	TechStatus string `json:"techStatus"`
+
+	// Type
+	Type string `json:"type"`
+
+	// Updated by
+	UpdatedBy uint64 `json:"updatedBy,omitempty"`
+
+	// Virtual machine ID
+	VMID uint64 `json:"vmid"`
+}
+
+// List disks
+type ListDisks []ItemDisk
+
+// Main information about interface
+type ItemInterface struct {
+	// Connection ID
+	ConnID uint64 `json:"connId"`
+
+	// Connection type
+	ConnType string `json:"connType"`
+
+	// Default GW
+	DefGW string `json:"defGw"`
+
+	// FLIPGroup ID
+	FLIPGroupID uint64 `json:"flipgroupId"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// IP address
+	IPAddress string `json:"ipAddress"`
+
+	// Listen SSH or not
+	ListenSSH bool `json:"listenSsh"`
+
+	// MAC
+	MAC string `json:"mac"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Network ID
+	NetID uint64 `json:"netId"`
+
+	// Network mask
+	NetMask uint64 `json:"netMask"`
+
+	// Network type
+	NetType string `json:"netType"`
+
+	// PCI slot
+	PCISlot uint64 `json:"pciSlot"`
+
+	// QOS
+	QOS QOS `json:"qos"`
+
+	// Target
+	Target string `json:"target"`
+
+	// Type
+	Type string `json:"type"`
+
+	// List VNF IDs
+	VNFs []uint64 `json:"vnfs"`
+}
+
+// List interfaces
+type ListInterfaces []ItemInterface
+
+// Main information about OS user
+type ItemOSUser struct {
+	// GUID
+	GUID string `json:"guid"`
+
+	// Login
+	Login string `json:"login"`
+
+	// Password
+	Password string `json:"password"`
+
+	// Public key
+	PubKey string `json:"pubkey"`
+}
+
+// List OS users
+type ListOSUsers []ItemOSUser
+
+// Information about compute
+type InfoCompute struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Account name
+	AccountName string `json:"accountName"`
+
+	// Access Control List
+	ACL []interface{} `json:"acl"`
+
+	// Affinity label
+	AffinityLabel string `json:"affinityLabel"`
+
+	// Affinity rules
+	AffinityRules ListRules `json:"affinityRules"`
+
+	// Affinity weight
+	AffinityWeight uint64 `json:"affinityWeight"`
+
+	// Anti affinity rules
+	AntiAffinityRules ListRules `json:"antiAffinityRules"`
+
+	// Architecture
+	Arch string `json:"arch"`
+
+	// Boot order
+	BootOrder []string `json:"bootOrder"`
+
+	// Boot disk size
+	BootDiskSize uint64 `json:"bootdiskSize"`
+
+	// Clone reference
+	CloneReference uint64 `json:"cloneReference"`
+
+	// List clone IDs
+	Clones []uint64 `json:"clones"`
+
+	// Compute CI ID
+	ComputeCIID uint64 `json:"computeciId"`
+
+	// Number of CPU
+	CPUs uint64 `json:"cpus"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Custom fields
+	CustomFields map[string]interface{} `json:"customFields"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Description
+	Description string `json:"desc"`
+
+	// Devices
+	Devices interface{} `json:"devices"`
+
+	// Driver
+	Driver string `json:"driver"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Image ID
+	ImageID uint64 `json:"imageId"`
+
+	// List interfaces
+	Interfaces ListInterfaces `json:"interfaces"`
+
+	// Lock status
+	LockStatus string `json:"lockStatus"`
+
+	// Manager ID
+	ManagerID uint64 `json:"managerId"`
+
+	// Manager type
+	ManagerType string `json:"managerType"`
+
+	// Migration job
+	MigrationJob uint64 `json:"migrationjob"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Name
+	Name string `json:"name"`
+
+	// List OS users
+	OSUsers ListOSUsers `json:"osUsers"`
+
+	// Pinned
+	Pinned bool `json:"pinned"`
+
+	// Number of RAM
+	RAM uint64 `json:"ram"`
+
+	// Reference ID
+	ReferenceID string `json:"referenceId"`
+
+	// Registered
+	Registered bool `json:"registered"`
+
+	// Resource name
+	ResName string `json:"resName"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group name
+	RGName string `json:"rgName"`
+
+	// SnapSets
+	SnapSets ListSnapshots `json:"snapSets"`
+
+	// Stack ID
+	StackID uint64 `json:"stackId"`
+
+	// Stack name
+	StackName string `json:"stackName"`
+
+	// Stateless SEP ID
+	StatelessSEPID uint64 `json:"statelessSepId"`
+
+	// Stateless SEP Type
+	StatelessSEPType string `json:"statelessSepType"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Tags
+	Tags map[string]interface{} `json:"tags"`
+
+	// Tech status
+	TechStatus string `json:"techStatus"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// User managed
+	UserManaged bool `json:"userManaged"`
+
+	// Userdata
+	Userdata interface{} `json:"userdata"`
+
+	// List VGPU IDs
+	VGPUs []uint64 `json:"vgpus"`
+
+	// Virtual image ID
+	VirtualImageID uint64 `json:"virtualImageId"`
+}
+
+// Detailed information about compute
+type RecordCompute struct {
+	// List disks
+	Disks ListDisks `json:"disks"`
+
+	// Main information about compute
+	InfoCompute
+}
+
+// Main information about compute for list
+type ItemCompute struct {
+	// List of disk IDs
+	Disks []uint64 `json:"disks"`
+
+	// Main information about compute
+	InfoCompute
+
+	// Total disk size
+	TotalDiskSize uint64 `json:"totalDiskSize"`
+
+	// VINS connected
+	VINSConnected uint64 `json:"vinsConnected"`
+}
+
+// List computes
+type ListComputes []ItemCompute
+
+// Short information about audir
+type ItemAudit struct {
+	// Epoch
+	Epoch float64 `json:"epoch"`
+
+	// Message
+	Message string `json:"message"`
+}
+
+// List audits
+type ListAudits []ItemAudit
+
+// Main information about PCI device
+type ItemPCIDevice struct {
+	// CKey
+	CKey string `json:"_ckey"`
+
+	// Meta
+	Meta []interface{} `json:"_meta"`
+
+	// Compute ID
+	ComputeID uint64 `json:"computeId"`
+
+	// Description
+	Description string `json:"description"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// HwPath
+	HwPath string `json:"hwPath"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Stack ID
+	StackID uint64 `json:"stackId"`
+
+	// Status
+	Status string `json:"status"`
+
+	// System name
+	SystemName string `json:"systemName"`
+}
+
+// List PCI devices
+type ListPCIDevices []ItemPCIDevice

pkg/cloudbroker/compute/move_to_rg.go

@@ -0,0 +1,67 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for move compute new resource group
+type MoveToRGRequest struct {
+	// ID of the compute instance to move
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the target resource group
+	// Required: true
+	RGID uint64 `url:"rgId"`
+
+	// 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"`
+
+	// Should the compute be restarted upon successful move
+	// Required: false
+	Autostart bool `url:"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"`
+}
+
+func (crq MoveToRGRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.RGID == 0 {
+		return errors.New("validation-error: field RGID must be set")
+	}
+
+	return nil
+}
+
+// MoveToRG moves compute instance to new resource group
+func (c Compute) Validate(ctx context.Context, req MoveToRGRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/moveToRg"
+
+	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
+}

pkg/cloudbroker/compute/net_attach.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for attach network
+type NetAttachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Network type
+	// 'EXTNET' for connect to external network directly
+	// and 'VINS' for connect to ViNS
+	// Required: true
+	NetType string `url:"netType"`
+
+	// Network ID for connect to
+	// For EXTNET - external network ID
+	// For VINS - VINS ID
+	// Required: true
+	NetID uint64 `url:"netId"`
+
+	// Directly required IP address for new network interface
+	// Required: true
+	IPAddr string `url:"ipAddr,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq NetAttachRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.NetType == "" {
+		return errors.New("validation-error: field NetType must be set")
+	}
+	validator := validators.StringInSlice(crq.NetType, []string{"EXTNET", "VINS"})
+	if !validator {
+		return errors.New("validation-error: field NetType can be only EXTNET or VINS")
+	}
+	if crq.NetID == 0 {
+		return errors.New("validation-error: field NetID must be set")
+	}
+
+	return nil
+}
+
+// NetAttach attach network to compute and gets info about network
+func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNetAttach, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordNetAttach{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudbroker/compute/net_detach.go

@@ -0,0 +1,57 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for detach networ to compute
+type NetDetachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// IP of the network interface
+	// Required: false
+	IPAddr string `url:"ipAddr,omitempty"`
+
+	// MAC of the network interface
+	// Required: false
+	MAC string `url:"mac,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq NetDetachRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// NetDetach detach network to compute
+func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/netDetach"
+
+	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
+}

pkg/cloudbroker/compute/net_qos.go

@@ -0,0 +1,80 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for update QOS
+type NetQOSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Network ID
+	// Required: true
+	NetID uint64 `url:"netId"`
+
+	// Network type
+	// Should be one of:
+	//	- VINS
+	//	- EXTNET
+	// Required: true
+	NetType string `url:"netType"`
+
+	// Internal traffic, kbit
+	// Required: false
+	IngressRate uint64 `url:"ingress_rate,omitempty"`
+
+	// Internal traffic burst, kbit
+	// Required: false
+	IngressBurst uint64 `url:"ingress_burst,omitempty"`
+
+	// External traffic rate, kbit
+	// Required: false
+	EgressRate uint64 `url:"egress_rate,omitempty"`
+}
+
+func (crq NetQOSRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.NetType == "" {
+		return errors.New("validation-error: field NetType must be set")
+	}
+	validator := validators.StringInSlice(crq.NetType, []string{"EXTNET", "VINS"})
+	if !validator {
+		return errors.New("validation-error: field NetType can be only EXTNET or VINS")
+	}
+	if crq.NetID == 0 {
+		return errors.New("validation-error: field NetID must be set")
+	}
+
+	return nil
+}
+
+// NetQOS update compute interfaces QOS
+func (c Compute) NetQOS(ctx context.Context, req NetQOSRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/netQos"
+
+	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
+}

pkg/cloudbroker/compute/pause.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for pause compute
+type PauseRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq PauseRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Pause pause compute
+func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/pause"
+
+	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
+}

pkg/cloudbroker/compute/pfw_add.go

@@ -0,0 +1,83 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for add port forward rule
+type PFWAddRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// External start port number for the rule
+	// Required: true
+	PublicPortStart uint64 `url:"publicPortStart"`
+
+	// End port number (inclusive) for the ranged rule
+	// Required: false
+	PublicPortEnd uint64 `url:"publicPortEnd,omitempty"`
+
+	// Internal base port number
+	// Required: true
+	LocalBasePort uint64 `url:"localBasePort"`
+
+	// Network protocol
+	// Should be one of:
+	//	- tcp
+	//	- udp
+	// Required: true
+	Proto string `url:"proto"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq PFWAddRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.PublicPortStart == 0 {
+		return errors.New("validation-error: field PublicPortStart must be set")
+	}
+	if crq.LocalBasePort == 0 {
+		return errors.New("validation-error: field LocalBasePort must be set")
+	}
+	if crq.Proto == "" {
+		return errors.New("validation-error: field Proto must be set")
+	}
+	validate := validators.StringInSlice(crq.Proto, []string{"tcp", "udp"})
+	if !validate {
+		return errors.New("validation-error: field Proto must be tcp or udp")
+	}
+
+	return nil
+}
+
+// PFWAdd add port forward rule
+func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, err
+	}
+
+	url := "/cloudbroker/compute/pfwAdd"
+
+	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
+}

pkg/cloudbroker/compute/pfw_del.go

@@ -0,0 +1,72 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for delete port forward rule
+type PFWDelRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the rule to delete. If specified, all other arguments will be ignored
+	// Required: false
+	RuleID uint64 `url:"ruleId,omitempty"`
+
+	// External start port number for the rule
+	// Required: false
+	PublicPortStart uint64 `url:"publicPortStart,omitempty"`
+
+	// End port number (inclusive) for the ranged rule
+	// Required: false
+	PublicPortEnd uint64 `url:"publicPortEnd,omitempty"`
+
+	// Internal base port number
+	// Required: false
+	LocalBasePort uint64 `url:"localBasePort,omitempty"`
+
+	// Network protocol
+	// Should be one of:
+	//	- tcp
+	//	- udp
+	// Required: false
+	Proto string `url:"proto,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq PFWDelRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// PFWDel delete port forward rule
+func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/pfwDel"
+
+	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
+}

pkg/cloudbroker/compute/pfw_list.go

@@ -0,0 +1,51 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get list port forwards
+type PFWListRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq PFWListRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// PFWList gets compute port forwards list
+func (c Compute) PFWList(ctx context.Context, req PFWListRequest) (ListPFW, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, 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
+}

pkg/cloudbroker/compute/pin_to_stack.go

@@ -0,0 +1,56 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for pin comptute to stack
+type PinToStackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Stack ID to pin to
+	// Required: true
+	TargetStackID uint64 `url:"targetStackId"`
+
+	// Try to migrate or not if compute in running states
+	// Required: false
+	Force bool `url:"force"`
+}
+
+func (crq PinToStackRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.TargetStackID == 0 {
+		return errors.New("validation-error: field TargetStackID must be set")
+	}
+
+	return nil
+}
+
+// PinToStack pin compute to current stack
+func (c Compute) PinToStack(ctx context.Context, req PinToStackRequest) (uint64, error) {
+	err := req.validate()
+	if err != nil {
+		return 0, err
+	}
+
+	url := "/cloudbroker/compute/pinToStack"
+
+	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
+}

pkg/cloudbroker/compute/power_cycle.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for force stop and start compute
+type PowerCycleRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq PowerCycleRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// PowerCycle makes force stop and start compute
+func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/powerCycle"
+
+	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
+}

pkg/cloudbroker/compute/raise_down.go

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

pkg/cloudbroker/compute/reboot.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for reboot compute
+type RebootRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq RebootRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Reboot reboot compute
+func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/reboot"
+
+	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
+}

pkg/cloudbroker/compute/redeploy.go

@@ -0,0 +1,73 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for redeploy
+type RedeployRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the new OS image, if image change is required
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty"`
+
+	// New size for the boot disk in GB, if boot disk size change is required
+	// Required: false
+	DiskSize uint64 `url:"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"`
+
+	// Should the compute be restarted upon successful redeploy
+	// Required: false
+	AutoStart bool `url:"autoStart,omitempty"`
+
+	// Set this flag to True to force stop running compute instance and redeploy next
+	// Required: false
+	ForceStop bool `url:"forceStop,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq RedeployRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Redeploy redeploy compute
+func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/redeploy"
+
+	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
+}

pkg/cloudbroker/compute/registration.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for set compute registered in RT
+type RegistrationRequest struct {
+	// ID of the Compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Unique compute registration key
+	// Required: true
+	RegistrationKey string `url:"registrationKey"`
+}
+
+func (crq RegistrationRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.RegistrationKey == "" {
+		return errors.New("validation-error: field RegistrationKey must be set")
+	}
+
+	return nil
+}
+
+// Registration sets compute registered in RT
+func (c Compute) Registration(ctx context.Context, req RegistrationRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/registration"
+
+	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
+}

pkg/cloudbroker/compute/repair_boot_fs.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for repair filesystem
+type RepairBootFSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq RepairBootFSRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// RepairBootFS repair compute boot disk filesystem
+func (c Compute) RepairBootFS(ctx context.Context, req RepairBootFSRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/repairBootFs"
+
+	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
+}

pkg/cloudbroker/compute/reset.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for reset compute
+type ResetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq ResetRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Reset reset compute
+func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/reset"
+
+	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
+}

pkg/cloudbroker/compute/resize.go

@@ -0,0 +1,63 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for resize compute
+type ResizeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// New CPU count.
+	// Pass 0 if no change to CPU count is required
+	// Required: false
+	Force bool `url:"force,omitempty"`
+
+	// New RAM volume in MB.
+	// Pass 0 if no change to RAM volume is required
+	// Required: false
+	CPU uint64 `url:"cpu,omitempty"`
+
+	// Force compute resize
+	// Required: false
+	RAM uint64 `url:"ram,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq ResizeRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Resize resize compute instance
+func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/resize"
+
+	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
+}

pkg/cloudbroker/compute/restore.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for restore compute
+type RestoreRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq RestoreRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Restore restore compute from recycle bin
+func (c Compute) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/restore"
+
+	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
+}

pkg/cloudbroker/compute/resume.go

@@ -0,0 +1,49 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for resume compute
+type ResumeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq ResumeRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Resume resume Compute from paused state
+func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/resume"
+
+	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
+}

pkg/cloudbroker/compute/snapshot_create.go

@@ -0,0 +1,50 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+)
+
+// Request struct for create snapshot
+type SnapshotCreateRequest struct {
+	// ID of the compute instance to create snapshot for
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Text label for snapshot.
+	// Must be unique among this compute snapshots
+	// Required: true
+	Label string `url:"label"`
+}
+
+func (crq SnapshotCreateRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Label == "" {
+		return errors.New("validation-error: field Label must be set")
+	}
+
+	return nil
+}
+
+// SnapshotCreate create compute snapshot
+func (c Compute) SnapshotCreate(ctx context.Context, req SnapshotCreateRequest) (string, error) {
+	err := req.validate()
+	if err != nil {
+		return "", err
+	}
+
+	url := "/cloudbroker/compute/snapshotCreate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/snapshot_delete.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for delete snapshot
+type SnapshotDeleteRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Text label of snapshot to delete
+	// Required: true
+	Label string `url:"label"`
+}
+
+func (crq SnapshotDeleteRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Label == "" {
+		return errors.New("validation-error: field Label must be set")
+	}
+
+	return nil
+}
+
+// SnapshotDelete delete specified compute snapshot
+func (c Compute) SnapshotDelete(ctx context.Context, req SnapshotDeleteRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/snapshotDelete"
+
+	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
+}

pkg/cloudbroker/compute/snapshot_evict_disk.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for evict specified disk
+type SnapshotEvictDiskRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of the disk instance
+	// Required: true
+	DiskID uint64 `url:"diskId"`
+}
+
+func (crq SnapshotEvictDiskRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.DiskID == 0 {
+		return errors.New("validation-error: field DiskID must be set")
+	}
+
+	return nil
+}
+
+// SnapshotEvictDisk evict specified disk from all snapshots of a compute instance
+func (c Compute) SnapshotEvictDisk(ctx context.Context, req SnapshotEvictDiskRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/snapshotEvictDisk"
+
+	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
+}

pkg/cloudbroker/compute/snapshot_list.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get list snapshots
+type SnapshotListRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq SnapshotListRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// SnapshotList gets list compute snapshots
+func (c Compute) SnapshotList(ctx context.Context, req SnapshotListRequest) (ListSnapshots, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/snapshotList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListSnapshots{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/snapshot_rollback.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for rollback
+type SnapshotRollbackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Text label of snapshot to rollback
+	// Required: true
+	Label string `url:"label"`
+}
+
+func (crq SnapshotRollbackRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Label == "" {
+		return errors.New("validation-error: field Label must be set")
+	}
+
+	return nil
+}
+
+// SnapshotRollback rollback specified compute snapshot
+func (c Compute) SnapshotRollback(ctx context.Context, req SnapshotRollbackRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/snapshotRollback"
+
+	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
+}

pkg/cloudbroker/compute/snapshot_usage.go

@@ -0,0 +1,54 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get compute snapshot real size on storage
+type SnapshotUsageRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Specify to show usage exact for this snapshot.
+	// Leave empty for get usage for all compute snapshots
+	// Required: false
+	Label string `url:"label,omitempty"`
+}
+
+func (crq SnapshotUsageRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// SnapshotUsage Get compute snapshot real size on storage.
+// Always returns list of json objects, and first json object contains summary about all related
+// snapshots.
+func (c Compute) SnapshotUsage(ctx context.Context, req SnapshotUsageRequest) (ListSnapshotUsage, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/snapshotUsage"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListSnapshotUsage{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/start.go

@@ -0,0 +1,57 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for start compute
+type StartRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// ID of CD-ROM live image to boot
+	// Required: false
+	AltBootID uint64 `url:"altBootId,omitempty"`
+
+	// ID of stack to start compute
+	// Required: false
+	StackID uint64 `url:"stackId,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq StartRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Start starts compute
+func (c Compute) Start(ctx context.Context, req StartRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/start"
+
+	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
+}

pkg/cloudbroker/compute/stop.go

@@ -0,0 +1,53 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for stop compute
+type StopRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Force stop compute
+	// Required: false
+	Force bool `url:"force,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq StopRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field computeID must be set")
+	}
+
+	return nil
+}
+
+// Stop stops compute
+func (c Compute) Stop(ctx context.Context, req StopRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/stop"
+
+	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
+}

pkg/cloudbroker/compute/tag_add.go

@@ -0,0 +1,59 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for add tag to compute
+type TagAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Tag key
+	// Required: true
+	Key string `url:"key"`
+
+	// Tag value
+	// Required: true
+	Value string `url:"value"`
+}
+
+func (crq TagAddRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+	if crq.Value == "" {
+		return errors.New("validation-error: field Value must be set")
+	}
+
+	return nil
+}
+
+// TagAdd add tag to compute tags dict
+func (c Compute) TagAdd(ctx context.Context, req TagAddRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/tagAdd"
+
+	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
+}

pkg/cloudbroker/compute/tag_remove.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for remove tag from compute
+type TagRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds"`
+
+	// Tag key
+	// Required: true
+	Key string `url:"key"`
+}
+
+func (crq TagRemoveRequest) validate() error {
+	if len(crq.ComputeIDs) == 0 {
+		return errors.New("validation-error: field ComputeIDs must be set")
+	}
+	if crq.Key == "" {
+		return errors.New("validation-error: field Key must be set")
+	}
+
+	return nil
+}
+
+// TagRemove removes tag from compute tags dict
+func (c Compute) TagRemove(ctx context.Context, req TagRemoveRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/tagRemove"
+
+	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
+}

pkg/cloudbroker/compute/unpin_from_stack.go

@@ -0,0 +1,45 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for unpin from stack
+type UnpinFromStackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq UnpinFromStackRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// UnpinFromStack unpin compute from current stack
+func (c Compute) UnpinFromStack(ctx context.Context, req UnpinFromStackRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/unpinFromStack"
+
+	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
+}

pkg/cloudbroker/compute/update.go

@@ -0,0 +1,57 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for update compute
+type UpdateRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// New name
+	// Required: false
+	Name string `url:"name,omitempty"`
+
+	// New description
+	// Required: false
+	Description string `url:"desc,omitempty"`
+
+	// Reason for action
+	// Required: false
+	Reason string `url:"reason,omitempty"`
+}
+
+func (crq UpdateRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// Update updates some properties of the compute
+func (c Compute) Update(ctx context.Context, req UpdateRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/user_grant.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for grant access to compute
+type UserGrantRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name of the user to add
+	// Required: true
+	Username string `url:"userName"`
+
+	// Access type
+	// Should be one of:
+	//	- 'R' for Read only
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype"`
+}
+
+func (crq UserGrantRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Username == "" {
+		return errors.New("validation-error: field Username must be set")
+	}
+	if crq.AccessType == "" {
+		return errors.New("validation-error: field AccessType must be set")
+	}
+	validator := validators.StringInSlice(crq.AccessType, []string{"R", "RCX", "ARCXDU"})
+	if !validator {
+		return errors.New("validation-error: field AccessType can be only R, RCX or ARCXDU")
+	}
+
+	return nil
+}
+
+// UserGrant grant user access to the compute
+func (c Compute) UserGrant(ctx context.Context, req UserGrantRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/userGrant"
+
+	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
+}

pkg/cloudbroker/compute/user_list.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Request struct for get list users for compute
+type UserListRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+}
+
+func (crq UserListRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+
+	return nil
+}
+
+// UserList gets users list for compute
+func (c Compute) UserList(ctx context.Context, req UserListRequest) (*RecordACL, error) {
+	err := req.validate()
+	if err != nil {
+		return nil, err
+	}
+
+	url := "/cloudbroker/compute/userList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := RecordACL{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/user_revoke.go

@@ -0,0 +1,52 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+)
+
+// Request struct for revoke user access
+type UserRevokeRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name of the user to remove
+	// Required: true
+	Username string `url:"userName"`
+}
+
+func (crq UserRevokeRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Username == "" {
+		return errors.New("validation-error: field Username must be set")
+	}
+
+	return nil
+}
+
+// UserRevoke revokes user access to the compute
+func (c Compute) UserRevoke(ctx context.Context, req UserRevokeRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/userRevoke"
+
+	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
+}

pkg/cloudbroker/compute/user_update.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+
+	"github.com/rudecs/decort-sdk/internal/validators"
+)
+
+// Request struct for update user access
+type UserUpdateRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId"`
+
+	// Name of the user to update
+	// Required: true
+	Username string `url:"userName"`
+
+	// Access type
+	// Should be one of:
+	//	- 'R' for Read only
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype"`
+}
+
+func (crq UserUpdateRequest) validate() error {
+	if crq.ComputeID == 0 {
+		return errors.New("validation-error: field ComputeID must be set")
+	}
+	if crq.Username == "" {
+		return errors.New("validation-error: field UserName must be set")
+	}
+	if crq.AccessType == "" {
+		return errors.New("validation-error: field AccessType must be set")
+	}
+	validator := validators.StringInSlice(crq.AccessType, []string{"R", "RCX", "ARCXDU"})
+	if !validator {
+		return errors.New("validation-error: field AccessType can be only R, RCX or ARCXDU")
+	}
+
+	return nil
+}
+
+// UserUpdate updates user access to the compute
+func (c Compute) UserUpdate(ctx context.Context, req UserUpdateRequest) (bool, error) {
+	err := req.validate()
+	if err != nil {
+		return false, err
+	}
+
+	url := "/cloudbroker/compute/userUpdate"
+
+	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
+}