Files
sdk/api_compute.go

3476 lines
121 KiB
Go

/*
Hanzo Cloud API
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
API version: v1
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package hanzoai
import (
"bytes"
"context"
"io"
"net/http"
"net/url"
"strings"
)
// ComputeAPIService ComputeAPI service
type ComputeAPIService service
type ComputeAPIAttachClusterRequest struct {
ctx context.Context
ApiService *ComputeAPIService
computeClusterAttach *ComputeClusterAttach
}
func (r ComputeAPIAttachClusterRequest) ComputeClusterAttach(computeClusterAttach ComputeClusterAttach) ComputeAPIAttachClusterRequest {
r.computeClusterAttach = &computeClusterAttach
return r
}
func (r ComputeAPIAttachClusterRequest) Execute() (*ComputeClusterView, *http.Response, error) {
return r.ApiService.AttachClusterExecute(r)
}
/*
AttachCluster Attaches a BYO cluster to the caller's org — the kubeconfig is validated, KMS-sealed and added to the fleet — and answers 201 with the cluster as it now appears on GET /v1/compute/clusters.
Attaches a BYO cluster to the caller's org — the kubeconfig is
validated, KMS-sealed and added to the fleet — and answers 201 with the cluster
as it now appears on GET /v1/compute/clusters. Billed the nominal management fee: the
customer brings the compute, Hanzo meters the management plane.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIAttachClusterRequest
*/
func (a *ComputeAPIService) AttachCluster(ctx context.Context) ComputeAPIAttachClusterRequest {
return ComputeAPIAttachClusterRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeClusterView
func (a *ComputeAPIService) AttachClusterExecute(r ComputeAPIAttachClusterRequest) (*ComputeClusterView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.AttachCluster")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computeClusterAttach == nil {
return localVarReturnValue, nil, reportError("computeClusterAttach is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computeClusterAttach
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIBindMachineAgentRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
computeBindAgentReq *ComputeBindAgentReq
}
func (r ComputeAPIBindMachineAgentRequest) ComputeBindAgentReq(computeBindAgentReq ComputeBindAgentReq) ComputeAPIBindMachineAgentRequest {
r.computeBindAgentReq = &computeBindAgentReq
return r
}
func (r ComputeAPIBindMachineAgentRequest) Execute() (*ComputeAgentBinding, *http.Response, error) {
return r.ApiService.BindMachineAgentExecute(r)
}
/*
BindMachineAgent Binds a cloud Agent to one of the caller org's machines: the machine is recorded as running that Agent's @hanzo/bot runtime.
Binds a cloud Agent to one of the caller org's machines: the
machine is recorded as running that Agent's @hanzo/bot runtime. The owning org is
the validated tenant, never a client field.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the machine to bind, from the URL path.
@return ComputeAPIBindMachineAgentRequest
*/
func (a *ComputeAPIService) BindMachineAgent(ctx context.Context, id string) ComputeAPIBindMachineAgentRequest {
return ComputeAPIBindMachineAgentRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeAgentBinding
func (a *ComputeAPIService) BindMachineAgentExecute(r ComputeAPIBindMachineAgentRequest) (*ComputeAgentBinding, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPut
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeAgentBinding
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.BindMachineAgent")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}/agent"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computeBindAgentReq == nil {
return localVarReturnValue, nil, reportError("computeBindAgentReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computeBindAgentReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPICancelFleetJobRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
computeJobCancel *ComputeJobCancel
}
func (r ComputeAPICancelFleetJobRequest) ComputeJobCancel(computeJobCancel ComputeJobCancel) ComputeAPICancelFleetJobRequest {
r.computeJobCancel = &computeJobCancel
return r
}
func (r ComputeAPICancelFleetJobRequest) Execute() (*ComputeJobCanceled, *http.Response, error) {
return r.ApiService.CancelFleetJobExecute(r)
}
/*
CancelFleetJob Cancels a queued or running render in the caller's org.
Cancels a queued or running render in the caller's org. The engine
cancel is org-scoped, so a tenant can only ever cancel its OWN job: a job in
another tenant's shard is 404, exactly like one that never existed. An
already-finished job is 409.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the job (activity) id, from the URL path.
@return ComputeAPICancelFleetJobRequest
*/
func (a *ComputeAPIService) CancelFleetJob(ctx context.Context, id string) ComputeAPICancelFleetJobRequest {
return ComputeAPICancelFleetJobRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeJobCanceled
func (a *ComputeAPIService) CancelFleetJobExecute(r ComputeAPICancelFleetJobRequest) (*ComputeJobCanceled, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeJobCanceled
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.CancelFleetJob")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet/jobs/{id}/cancel"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computeJobCancel == nil {
return localVarReturnValue, nil, reportError("computeJobCancel is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computeJobCancel
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPICreateKubernetesClusterRequest struct {
ctx context.Context
ApiService *ComputeAPIService
computeCreateClusterReq *ComputeCreateClusterReq
}
func (r ComputeAPICreateKubernetesClusterRequest) ComputeCreateClusterReq(computeCreateClusterReq ComputeCreateClusterReq) ComputeAPICreateKubernetesClusterRequest {
r.computeCreateClusterReq = &computeCreateClusterReq
return r
}
func (r ComputeAPICreateKubernetesClusterRequest) Execute() (*ComputeClusterView, *http.Response, error) {
return r.ApiService.CreateKubernetesClusterExecute(r)
}
/*
CreateKubernetesCluster Provisions a DOKS cluster for the caller's org and answers 201.
Provisions a DOKS cluster for the caller's org and answers 201.
ADMIN-GATED — a SuperAdmin, or an OrgAdmin of the caller's own org — because
provisioning spends real infrastructure on the house account. The request is
validated at this boundary, then Visor owns provisioning and the hanzo-org
ownership tag.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPICreateKubernetesClusterRequest
*/
func (a *ComputeAPIService) CreateKubernetesCluster(ctx context.Context) ComputeAPICreateKubernetesClusterRequest {
return ComputeAPICreateKubernetesClusterRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeClusterView
func (a *ComputeAPIService) CreateKubernetesClusterExecute(r ComputeAPICreateKubernetesClusterRequest) (*ComputeClusterView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.CreateKubernetesCluster")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/k8s/clusters"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computeCreateClusterReq == nil {
return localVarReturnValue, nil, reportError("computeCreateClusterReq is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computeCreateClusterReq
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPICreateNodePoolRequest struct {
ctx context.Context
ApiService *ComputeAPIService
clusterId string
computePoolCreate *ComputePoolCreate
}
func (r ComputeAPICreateNodePoolRequest) ComputePoolCreate(computePoolCreate ComputePoolCreate) ComputeAPICreateNodePoolRequest {
r.computePoolCreate = &computePoolCreate
return r
}
func (r ComputeAPICreateNodePoolRequest) Execute() (*ComputeNodePoolView, *http.Response, error) {
return r.ApiService.CreateNodePoolExecute(r)
}
/*
CreateNodePool Adds a node pool to one of the caller org's clusters and answers 201 with the created pool.
Adds a node pool to one of the caller org's clusters and answers 201
with the created pool. Only the CreateNodePoolSpec fields are forwarded;
owner/provider/clusterId ride in the query exactly as Visor expects them.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param clusterId ClusterID is the cluster to add the pool to, from the URL path.
@return ComputeAPICreateNodePoolRequest
*/
func (a *ComputeAPIService) CreateNodePool(ctx context.Context, clusterId string) ComputeAPICreateNodePoolRequest {
return ComputeAPICreateNodePoolRequest{
ApiService: a,
ctx: ctx,
clusterId: clusterId,
}
}
// Execute executes the request
//
// @return ComputeNodePoolView
func (a *ComputeAPIService) CreateNodePoolExecute(r ComputeAPICreateNodePoolRequest) (*ComputeNodePoolView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeNodePoolView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.CreateNodePool")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters/{clusterId}/pools"
localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", url.PathEscape(parameterValueToString(r.clusterId, "clusterId")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computePoolCreate == nil {
return localVarReturnValue, nil, reportError("computePoolCreate is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computePoolCreate
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIDeleteKubernetesClusterRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIDeleteKubernetesClusterRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteKubernetesClusterExecute(r)
}
/*
DeleteKubernetesCluster Destroys a DOKS cluster by id and answers 204.
Destroys a DOKS cluster by id and answers 204. ADMIN-GATED, like
create. Visor scopes the delete to the org (refuses a foreign id), so this can
only ever remove the caller org's own cluster.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the provider's DOKS cluster id. Visor scopes the lookup to the caller's org, so another tenant's id resolves to not-found rather than their cluster.
@return ComputeAPIDeleteKubernetesClusterRequest
*/
func (a *ComputeAPIService) DeleteKubernetesCluster(ctx context.Context, id string) ComputeAPIDeleteKubernetesClusterRequest {
return ComputeAPIDeleteKubernetesClusterRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *ComputeAPIService) DeleteKubernetesClusterExecute(r ComputeAPIDeleteKubernetesClusterRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.DeleteKubernetesCluster")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/k8s/clusters/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ComputeAPIDeleteMachineRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIDeleteMachineRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteMachineExecute(r)
}
/*
DeleteMachine Terminates one of the caller org's machines.
Terminates one of the caller org's machines. Visor takes the
machine identity as owner+name, and the owner is the validated principal, so a
caller can only ever terminate its own tenant's machine. Answers 204.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the machine's org-scoped NAME — the stable key Visor addresses a machine by (owner/name), not the ephemeral provider id.
@return ComputeAPIDeleteMachineRequest
*/
func (a *ComputeAPIService) DeleteMachine(ctx context.Context, id string) ComputeAPIDeleteMachineRequest {
return ComputeAPIDeleteMachineRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *ComputeAPIService) DeleteMachineExecute(r ComputeAPIDeleteMachineRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.DeleteMachine")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ComputeAPIDeleteNodePoolRequest struct {
ctx context.Context
ApiService *ComputeAPIService
clusterId string
poolId string
provider *string
}
// Provider is the cloud the cluster lives on, from ?provider=. Required.
func (r ComputeAPIDeleteNodePoolRequest) Provider(provider string) ComputeAPIDeleteNodePoolRequest {
r.provider = &provider
return r
}
func (r ComputeAPIDeleteNodePoolRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteNodePoolExecute(r)
}
/*
DeleteNodePool Removes a node pool from one of the caller org's clusters.
Removes a node pool from one of the caller org's clusters. The owner
scopes the delete to the caller's tenant; provider+clusterId drive the
provider-side removal. Answers 204.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param clusterId ClusterID and PoolID address the pool, from the URL path.
@param poolId
@return ComputeAPIDeleteNodePoolRequest
*/
func (a *ComputeAPIService) DeleteNodePool(ctx context.Context, clusterId string, poolId string) ComputeAPIDeleteNodePoolRequest {
return ComputeAPIDeleteNodePoolRequest{
ApiService: a,
ctx: ctx,
clusterId: clusterId,
poolId: poolId,
}
}
// Execute executes the request
func (a *ComputeAPIService) DeleteNodePoolExecute(r ComputeAPIDeleteNodePoolRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.DeleteNodePool")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters/{clusterId}/pools/{poolId}"
localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", url.PathEscape(parameterValueToString(r.clusterId, "clusterId")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"poolId"+"}", url.PathEscape(parameterValueToString(r.poolId, "poolId")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.provider != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "provider", r.provider, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ComputeAPIDetachClusterRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIDetachClusterRequest) Execute() (*ComputeClusterDetached, *http.Response, error) {
return r.ApiService.DetachClusterExecute(r)
}
/*
DetachCluster Removes a BYO cluster from the caller org's fleet.
Removes a BYO cluster from the caller org's fleet. It only ever
touches BYO clusters — a managed cluster's nodes are removed through the node-pool
routes — and answers 404 when the name is not in this org's fleet.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the cluster's fleet name (the `name` it was attached under), matched lower-cased.
@return ComputeAPIDetachClusterRequest
*/
func (a *ComputeAPIService) DetachCluster(ctx context.Context, id string) ComputeAPIDetachClusterRequest {
return ComputeAPIDetachClusterRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeClusterDetached
func (a *ComputeAPIService) DetachClusterExecute(r ComputeAPIDetachClusterRequest) (*ComputeClusterDetached, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterDetached
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.DetachCluster")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIGetComputeRegionsRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIGetComputeRegionsRequest) Execute() (interface{}, *http.Response, error) {
return r.ApiService.GetComputeRegionsExecute(r)
}
/*
GetComputeRegions Lists the regions a machine can be launched in.
Lists the regions a machine can be launched in.
The catalog is GLOBAL — identical for every tenant — so no owner is forwarded
upstream. It is still org-gated, because a catalog is a map of what this
deployment can spend money in and an anonymous caller has no business reading it.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIGetComputeRegionsRequest
*/
func (a *ComputeAPIService) GetComputeRegions(ctx context.Context) ComputeAPIGetComputeRegionsRequest {
return ComputeAPIGetComputeRegionsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return interface{}
func (a *ComputeAPIService) GetComputeRegionsExecute(r ComputeAPIGetComputeRegionsRequest) (interface{}, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue interface{}
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.GetComputeRegions")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/regions"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIGetComputeSizesRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIGetComputeSizesRequest) Execute() (interface{}, *http.Response, error) {
return r.ApiService.GetComputeSizesExecute(r)
}
/*
GetComputeSizes Lists the machine sizes available to launch, with their specifications.
Lists the machine sizes available to launch, with their specifications.
Global and org-gated, exactly as the region catalog is, and for the same reasons.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIGetComputeSizesRequest
*/
func (a *ComputeAPIService) GetComputeSizes(ctx context.Context) ComputeAPIGetComputeSizesRequest {
return ComputeAPIGetComputeSizesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return interface{}
func (a *ComputeAPIService) GetComputeSizesExecute(r ComputeAPIGetComputeSizesRequest) (interface{}, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue interface{}
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.GetComputeSizes")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/sizes"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIGetKubernetesClusterRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIGetKubernetesClusterRequest) Execute() (*ComputeClusterDetailView, *http.Response, error) {
return r.ApiService.GetKubernetesClusterExecute(r)
}
/*
GetKubernetesCluster Returns one cluster's detail: node pools + worker nodes.
Returns one cluster's detail: node pools + worker nodes. Visor scopes
the lookup to the org (a foreign or missing id resolves to not-found), so a tenant
can never read another tenant's cluster by guessing an id.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the provider's DOKS cluster id. Visor scopes the lookup to the caller's org, so another tenant's id resolves to not-found rather than their cluster.
@return ComputeAPIGetKubernetesClusterRequest
*/
func (a *ComputeAPIService) GetKubernetesCluster(ctx context.Context, id string) ComputeAPIGetKubernetesClusterRequest {
return ComputeAPIGetKubernetesClusterRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeClusterDetailView
func (a *ComputeAPIService) GetKubernetesClusterExecute(r ComputeAPIGetKubernetesClusterRequest) (*ComputeClusterDetailView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterDetailView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.GetKubernetesCluster")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/k8s/clusters/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIGetMachineRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIGetMachineRequest) Execute() (*ComputeMachineView, *http.Response, error) {
return r.ApiService.GetMachineExecute(r)
}
/*
GetMachine Returns one of the caller org's machines by its org-scoped name.
Returns one of the caller org's machines by its org-scoped name.
Visor keys the lookup by owner/name, so an id belonging to another tenant
resolves to not-found rather than another org's machine.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the machine's org-scoped NAME — the stable key Visor addresses a machine by (owner/name), not the ephemeral provider id.
@return ComputeAPIGetMachineRequest
*/
func (a *ComputeAPIService) GetMachine(ctx context.Context, id string) ComputeAPIGetMachineRequest {
return ComputeAPIGetMachineRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeMachineView
func (a *ComputeAPIService) GetMachineExecute(r ComputeAPIGetMachineRequest) (*ComputeMachineView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeMachineView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.GetMachine")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIGetMachineAgentRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIGetMachineAgentRequest) Execute() (*ComputeAgentBinding, *http.Response, error) {
return r.ApiService.GetMachineAgentExecute(r)
}
/*
GetMachineAgent Returns the agent binding of one of the caller org's machines, or 404 when the machine runs no bot runtime.
Returns the agent binding of one of the caller org's
machines, or 404 when the machine runs no bot runtime.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the machine's org-scoped NAME — the stable key Visor addresses a machine by (owner/name), not the ephemeral provider id.
@return ComputeAPIGetMachineAgentRequest
*/
func (a *ComputeAPIService) GetMachineAgent(ctx context.Context, id string) ComputeAPIGetMachineAgentRequest {
return ComputeAPIGetMachineAgentRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return ComputeAgentBinding
func (a *ComputeAPIService) GetMachineAgentExecute(r ComputeAPIGetMachineAgentRequest) (*ComputeAgentBinding, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeAgentBinding
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.GetMachineAgent")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}/agent"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListClustersRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListClustersRequest) Execute() (*ComputeClusterList, *http.Response, error) {
return r.ApiService.ListClustersExecute(r)
}
/*
ListClusters Returns the caller org's clusters from both sources: the managed clusters projected from Visor's node pools, and the BYO clusters attached to the caller's project.
Returns the caller org's clusters from both sources: the managed
clusters projected from Visor's node pools, and the BYO clusters attached to the
caller's project. A Visor outage costs the managed half only — the BYO half
still lists, because a page that 502s on an optional provider is worse than a
page that shows what it can.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListClustersRequest
*/
func (a *ComputeAPIService) ListClusters(ctx context.Context) ComputeAPIListClustersRequest {
return ComputeAPIListClustersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeClusterList
func (a *ComputeAPIService) ListClustersExecute(r ComputeAPIListClustersRequest) (*ComputeClusterList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListClusters")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListFleetRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListFleetRequest) Execute() (*ComputeFleetBoard, *http.Response, error) {
return r.ApiService.ListFleetExecute(r)
}
/*
ListFleet Returns every compute unit the caller's org has, from every source, each carrying its latest utilization: agent run-targets, the BYO machines that dialed in, attached BYO clusters and Visor-provisioned machines.
Returns every compute unit the caller's org has, from every source, each
carrying its latest utilization: agent run-targets, the BYO machines that dialed
in, attached BYO clusters and Visor-provisioned machines.
A unit with a live snapshot of its own keeps it; the rest are overlaid from the
utilization series, and only when the sample agrees about the SOURCE — two planes
could mint the same unit id, and a board must never show one machine's load on
another's row. BYO GPU units also carry their gpu-jobs queue depth. Every source
is folded in independently: a broken one costs its own rows and nothing else.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListFleetRequest
*/
func (a *ComputeAPIService) ListFleet(ctx context.Context) ComputeAPIListFleetRequest {
return ComputeAPIListFleetRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeFleetBoard
func (a *ComputeAPIService) ListFleetExecute(r ComputeAPIListFleetRequest) (*ComputeFleetBoard, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeFleetBoard
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListFleet")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListFleetJobsRequest struct {
ctx context.Context
ApiService *ComputeAPIService
gpu *string
status *string
}
// GPU selects one node's lane: jobs TARGETED at it (gpu:<node>) or CLAIMED by it. The literal \"shared\" selects the any-GPU lane — no target, no claimant. Matched case-insensitively.
func (r ComputeAPIListFleetJobsRequest) Gpu(gpu string) ComputeAPIListFleetJobsRequest {
r.gpu = &gpu
return r
}
// Status selects one lifecycle state: queued, running, stalled, completed, failed or canceled.
func (r ComputeAPIListFleetJobsRequest) Status(status string) ComputeAPIListFleetJobsRequest {
r.status = &status
return r
}
func (r ComputeAPIListFleetJobsRequest) Execute() (*ComputeJobList, *http.Response, error) {
return r.ApiService.ListFleetJobsExecute(r)
}
/*
ListFleetJobs Returns the caller org's gpu-jobs render queue, each row tagged with the GPU it targets (empty = the shared any-GPU lane) and the node claiming it, optionally narrowed to one GPU's queue and/or one status.
Returns the caller org's gpu-jobs render queue, each row tagged with
the GPU it targets (empty = the shared any-GPU lane) and the node claiming it,
optionally narrowed to one GPU's queue and/or one status.
A job whose worker died — STARTED with an elapsed lease and not yet reclaimed —
reads "stalled", not "running". Fail-soft: an unavailable tasks engine yields an
empty queue rather than an error.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListFleetJobsRequest
*/
func (a *ComputeAPIService) ListFleetJobs(ctx context.Context) ComputeAPIListFleetJobsRequest {
return ComputeAPIListFleetJobsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeJobList
func (a *ComputeAPIService) ListFleetJobsExecute(r ComputeAPIListFleetJobsRequest) (*ComputeJobList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeJobList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListFleetJobs")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet/jobs"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.gpu != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "gpu", r.gpu, "form", "")
}
if r.status != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "status", r.status, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListFleetSamplesRequest struct {
ctx context.Context
ApiService *ComputeAPIService
unit *string
source *string
range_ *string
}
// Unit selects one compute unit's series by its source-local id.
func (r ComputeAPIListFleetSamplesRequest) Unit(unit string) ComputeAPIListFleetSamplesRequest {
r.unit = &unit
return r
}
// Source selects one plane: \"agent\", \"byo\" or \"visor\".
func (r ComputeAPIListFleetSamplesRequest) Source(source string) ComputeAPIListFleetSamplesRequest {
r.source = &source
return r
}
// Range is the lookback window (e.g. \"1h\", \"24h\", \"7d\"); empty takes the warehouse default.
func (r ComputeAPIListFleetSamplesRequest) Range_(range_ string) ComputeAPIListFleetSamplesRequest {
r.range_ = &range_
return r
}
func (r ComputeAPIListFleetSamplesRequest) Execute() (*ComputeSampleList, *http.Response, error) {
return r.ApiService.ListFleetSamplesExecute(r)
}
/*
ListFleetSamples Returns the caller org's utilization series, oldest first.
Returns the caller org's utilization series, oldest first.
A rejected narrower is a 400 carrying its own reason (the vocabulary is ours and
safe to echo); a warehouse failure is logged and answered 503 "unavailable",
because a chart that silently reads "no load" when the truth is "we cannot tell"
is worse than one that says so. An ABSENT warehouse is different again: it returns
an empty series, which renders honestly as "no samples yet".
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListFleetSamplesRequest
*/
func (a *ComputeAPIService) ListFleetSamples(ctx context.Context) ComputeAPIListFleetSamplesRequest {
return ComputeAPIListFleetSamplesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeSampleList
func (a *ComputeAPIService) ListFleetSamplesExecute(r ComputeAPIListFleetSamplesRequest) (*ComputeSampleList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeSampleList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListFleetSamples")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet/samples"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.unit != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "unit", r.unit, "form", "")
}
if r.source != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "source", r.source, "form", "")
}
if r.range_ != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "range", r.range_, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListFleetWorkersRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListFleetWorkersRequest) Execute() (*ComputeWorkerList, *http.Response, error) {
return r.ApiService.ListFleetWorkersExecute(r)
}
/*
ListFleetWorkers Returns the caller org's BYO machines — the ones that dialed in via `hanzo link` — with everything each host reported about itself.
Returns the caller org's BYO machines — the ones that dialed in
via `hanzo link` — with everything each host reported about itself. The Machines
and GPUs pages fold the same data into their normalized shapes; this is the
canonical raw list a fleet view (or the CLI's `status`) reads.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListFleetWorkersRequest
*/
func (a *ComputeAPIService) ListFleetWorkers(ctx context.Context) ComputeAPIListFleetWorkersRequest {
return ComputeAPIListFleetWorkersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeWorkerList
func (a *ComputeAPIService) ListFleetWorkersExecute(r ComputeAPIListFleetWorkersRequest) (*ComputeWorkerList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeWorkerList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListFleetWorkers")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet/workers"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListGpuAlertsRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListGpuAlertsRequest) Execute() (*ComputeGpuAlertList, *http.Response, error) {
return r.ApiService.ListGpuAlertsExecute(r)
}
/*
ListGpuAlerts Is an HONEST empty surface: Visor exposes no GPU alert inventory, so this returns [] rather than fabricating alerts.
Is an HONEST empty surface: Visor exposes no GPU alert inventory, so
this returns [] rather than fabricating alerts. It stays a real, tenant-gated
route so the console's alerts fetch resolves (200 [], not a 404) — an honest
"no alerts", the same discipline the rest of the surface follows.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListGpuAlertsRequest
*/
func (a *ComputeAPIService) ListGpuAlerts(ctx context.Context) ComputeAPIListGpuAlertsRequest {
return ComputeAPIListGpuAlertsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeGpuAlertList
func (a *ComputeAPIService) ListGpuAlertsExecute(r ComputeAPIListGpuAlertsRequest) (*ComputeGpuAlertList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeGpuAlertList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListGpuAlerts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/gpus/alerts"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListGpusRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListGpusRequest) Execute() (*ComputeGpuList, *http.Response, error) {
return r.ApiService.ListGpusExecute(r)
}
/*
ListGpus Returns one row per physical accelerator the caller's org has, derived from its real GPU machines (the size slug says how many cards a node holds) and from the accelerators BYO workers report through nvidia-smi.
Returns one row per physical accelerator the caller's org has, derived
from its real GPU machines (the size slug says how many cards a node holds) and
from the accelerators BYO workers report through nvidia-smi.
Live telemetry is absent on Visor rows because Visor's machine object carries
none — an honest omission the console renders as "—", never a fabricated 0.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListGpusRequest
*/
func (a *ComputeAPIService) ListGpus(ctx context.Context) ComputeAPIListGpusRequest {
return ComputeAPIListGpusRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeGpuList
func (a *ComputeAPIService) ListGpusExecute(r ComputeAPIListGpusRequest) (*ComputeGpuList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeGpuList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListGpus")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/gpus"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListKubernetesClustersRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListKubernetesClustersRequest) Execute() (*ComputeClusterList, *http.Response, error) {
return r.ApiService.ListKubernetesClustersExecute(r)
}
/*
ListKubernetesClusters Lists the org's DOKS clusters (Visor, house account) folded with the org's BYO clusters — ONE fleet cluster view under the unified k8s noun.
Lists the org's DOKS clusters (Visor, house account) folded with
the org's BYO clusters — ONE fleet cluster view under the unified k8s noun. A Visor
outage is logged and skipped so a down optional provider never hides the BYO list.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListKubernetesClustersRequest
*/
func (a *ComputeAPIService) ListKubernetesClusters(ctx context.Context) ComputeAPIListKubernetesClustersRequest {
return ComputeAPIListKubernetesClustersRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeClusterList
func (a *ComputeAPIService) ListKubernetesClustersExecute(r ComputeAPIListKubernetesClustersRequest) (*ComputeClusterList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeClusterList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListKubernetesClusters")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/k8s/clusters"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListKubernetesNodesRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListKubernetesNodesRequest) Execute() (*ComputeNodeList, *http.Response, error) {
return r.ApiService.ListKubernetesNodesExecute(r)
}
/*
ListKubernetesNodes Returns every DOKS worker node in the org's clusters as a machine — the SAME set the fleet folds in (managedMachines), exposed directly under the k8s noun.
Returns every DOKS worker node in the org's clusters as a machine —
the SAME set the fleet folds in (managedMachines), exposed directly under the k8s
noun. House account (hanzo-org cluster tag) + BYOC, deduped by Visor.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListKubernetesNodesRequest
*/
func (a *ComputeAPIService) ListKubernetesNodes(ctx context.Context) ComputeAPIListKubernetesNodesRequest {
return ComputeAPIListKubernetesNodesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeNodeList
func (a *ComputeAPIService) ListKubernetesNodesExecute(r ComputeAPIListKubernetesNodesRequest) (*ComputeNodeList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeNodeList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListKubernetesNodes")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/k8s/nodes"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListMachineAgentsRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIListMachineAgentsRequest) Execute() (*ComputeBindingList, *http.Response, error) {
return r.ApiService.ListMachineAgentsExecute(r)
}
/*
ListMachineAgents Returns every agent↔machine binding in the caller's org — which machines are running which cloud Agent, with vm's own reconciled status.
Returns every agent↔machine binding in the caller's org — which
machines are running which cloud Agent, with vm's own reconciled status.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListMachineAgentsRequest
*/
func (a *ComputeAPIService) ListMachineAgents(ctx context.Context) ComputeAPIListMachineAgentsRequest {
return ComputeAPIListMachineAgentsRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeBindingList
func (a *ComputeAPIService) ListMachineAgentsExecute(r ComputeAPIListMachineAgentsRequest) (*ComputeBindingList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeBindingList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListMachineAgents")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/agents"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIListMachinesRequest struct {
ctx context.Context
ApiService *ComputeAPIService
kind *string
}
func (r ComputeAPIListMachinesRequest) Kind(kind string) ComputeAPIListMachinesRequest {
r.kind = &kind
return r
}
func (r ComputeAPIListMachinesRequest) Execute() (*ComputeMachineList, *http.Response, error) {
return r.ApiService.ListMachinesExecute(r)
}
/*
ListMachines Returns every machine the caller's org has — Visor's registry, the live DigitalOcean droplets and the DOKS worker nodes (deduped into one union), plus the BYO machines that dialed in via `hanzo link` (provider \"byo\").
Returns every machine the caller's org has — Visor's registry, the
live DigitalOcean droplets and the DOKS worker nodes (deduped into one union),
plus the BYO machines that dialed in via `hanzo link` (provider "byo").
A source Visor cannot answer for is logged and skipped, never an error: one
wedged upstream must not hide the machines the other sources can see.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIListMachinesRequest
*/
func (a *ComputeAPIService) ListMachines(ctx context.Context) ComputeAPIListMachinesRequest {
return ComputeAPIListMachinesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeMachineList
func (a *ComputeAPIService) ListMachinesExecute(r ComputeAPIListMachinesRequest) (*ComputeMachineList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeMachineList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ListMachines")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.kind != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "kind", r.kind, "form", "")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIPostComputeMachinesRequest struct {
ctx context.Context
ApiService *ComputeAPIService
}
func (r ComputeAPIPostComputeMachinesRequest) Execute() (*http.Response, error) {
return r.ApiService.PostComputeMachinesExecute(r)
}
/*
PostComputeMachines Launch a metered machine for your org, or price one first with dryRun
Provisions a machine owned by the caller's org and answers 201 with the machine. Send `dryRun: true` to get a PRICE QUOTE instead: 200 with the upstream quote passed through verbatim, nothing launched and nothing spent. Two response shapes on one address is the rule to know, and it is why this is not a typed op.
Metering is not this plane's: the launch fronts the compute provider's resell endpoint, which owns the balance gate and the per-hour meter, and cloud only forwards the tenant. Ownership is the validated principal's org and is never read from the body, so a launch always lands in the caller's OWN tenant and the machine it creates is only ever visible to that tenant. Fails closed: a validated principal is required (401 without one) and `size` (or its `instanceType` alias) is required (400).
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIPostComputeMachinesRequest
*/
func (a *ComputeAPIService) PostComputeMachines(ctx context.Context) ComputeAPIPostComputeMachinesRequest {
return ComputeAPIPostComputeMachinesRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *ComputeAPIService) PostComputeMachinesExecute(r ComputeAPIPostComputeMachinesRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.PostComputeMachines")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ComputeAPIPostComputeMachinesByIdByActionRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
action string
}
func (r ComputeAPIPostComputeMachinesByIdByActionRequest) Execute() (*http.Response, error) {
return r.ApiService.PostComputeMachinesByIdByActionExecute(r)
}
/*
PostComputeMachinesByIdByAction Message a bot, or stop it, by naming the action in the path
Dispatches one verb against a bot the caller's org owns. `message` runs the bot's bound agent with the request body as the message and streams the agent's answer back VERBATIM — the upstream body, its content type and its status — so a message is a real agent run, recorded, billed and traced exactly like any other, under the caller's own identity rather than a fabricated one. `stop` and `pause` are the same single honest capability: they halt the runtime by unbinding the agent while LEAVING THE MACHINE UP, so the bot stops answering but keeps costing — rebind to resume, or delete the bot to tear it down. Stopping is idempotent; a bot with no binding still reports stopped.
Org-scoped and fails closed: a validated principal is required (401 without one) and the bot is addressed under the caller's OWN org, so another tenant's id is not reachable. An unknown action is a clean 400 naming the three it accepts, never a silent no-op, and messaging a bot with no bound agent is a 400.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@param action
@return ComputeAPIPostComputeMachinesByIdByActionRequest
*/
func (a *ComputeAPIService) PostComputeMachinesByIdByAction(ctx context.Context, id string, action string) ComputeAPIPostComputeMachinesByIdByActionRequest {
return ComputeAPIPostComputeMachinesByIdByActionRequest{
ApiService: a,
ctx: ctx,
id: id,
action: action,
}
}
// Execute executes the request
func (a *ComputeAPIService) PostComputeMachinesByIdByActionExecute(r ComputeAPIPostComputeMachinesByIdByActionRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.PostComputeMachinesByIdByAction")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}/{action}"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"action"+"}", url.PathEscape(parameterValueToString(r.action, "action")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}
type ComputeAPIRecordFleetSampleRequest struct {
ctx context.Context
ApiService *ComputeAPIService
computeSampleIngest *ComputeSampleIngest
}
func (r ComputeAPIRecordFleetSampleRequest) ComputeSampleIngest(computeSampleIngest ComputeSampleIngest) ComputeAPIRecordFleetSampleRequest {
r.computeSampleIngest = &computeSampleIngest
return r
}
func (r ComputeAPIRecordFleetSampleRequest) Execute() (*ComputeSampleAccepted, *http.Response, error) {
return r.ApiService.RecordFleetSampleExecute(r)
}
/*
RecordFleetSample Records a BYO worker's live GPU utilization into the SAME series the fleet board overlays.
Records a BYO worker's live GPU utilization into the SAME series the
fleet board overlays. The org is the validated principal and source/kind are fixed
server-side, so a worker names only its own metrics — never another tenant or
another source. Answers 202: the warehouse write is DETACHED (its own bounded
context, never in the response path), so a slow or absent warehouse cannot stall a
heartbeat.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return ComputeAPIRecordFleetSampleRequest
*/
func (a *ComputeAPIService) RecordFleetSample(ctx context.Context) ComputeAPIRecordFleetSampleRequest {
return ComputeAPIRecordFleetSampleRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return ComputeSampleAccepted
func (a *ComputeAPIService) RecordFleetSampleExecute(r ComputeAPIRecordFleetSampleRequest) (*ComputeSampleAccepted, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeSampleAccepted
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.RecordFleetSample")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/fleet/samples"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computeSampleIngest == nil {
return localVarReturnValue, nil, reportError("computeSampleIngest is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computeSampleIngest
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIScaleNodePoolRequest struct {
ctx context.Context
ApiService *ComputeAPIService
clusterId string
poolId string
computePoolScale *ComputePoolScale
}
func (r ComputeAPIScaleNodePoolRequest) ComputePoolScale(computePoolScale ComputePoolScale) ComputeAPIScaleNodePoolRequest {
r.computePoolScale = &computePoolScale
return r
}
func (r ComputeAPIScaleNodePoolRequest) Execute() (*ComputeNodePoolView, *http.Response, error) {
return r.ApiService.ScaleNodePoolExecute(r)
}
/*
ScaleNodePool Resizes a node pool to an absolute node count and returns the pool as Visor reports it after the change.
Resizes a node pool to an absolute node count and returns the pool as
Visor reports it after the change.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param clusterId ClusterID is the cluster holding the pool, from the URL path.
@param poolId PoolID is the pool to resize, from the URL path — the `poolId` a cluster read reports for it. Required.
@return ComputeAPIScaleNodePoolRequest
*/
func (a *ComputeAPIService) ScaleNodePool(ctx context.Context, clusterId string, poolId string) ComputeAPIScaleNodePoolRequest {
return ComputeAPIScaleNodePoolRequest{
ApiService: a,
ctx: ctx,
clusterId: clusterId,
poolId: poolId,
}
}
// Execute executes the request
//
// @return ComputeNodePoolView
func (a *ComputeAPIService) ScaleNodePoolExecute(r ComputeAPIScaleNodePoolRequest) (*ComputeNodePoolView, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ComputeNodePoolView
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.ScaleNodePool")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/clusters/{clusterId}/pools/{poolId}/scale"
localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", url.PathEscape(parameterValueToString(r.clusterId, "clusterId")), -1)
localVarPath = strings.Replace(localVarPath, "{"+"poolId"+"}", url.PathEscape(parameterValueToString(r.poolId, "poolId")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.computePoolScale == nil {
return localVarReturnValue, nil, reportError("computePoolScale is required and must be specified")
}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{"application/json"}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.computePoolScale
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarReturnValue, localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarReturnValue, localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarReturnValue, localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarReturnValue, localVarHTTPResponse, newErr
}
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: err.Error(),
}
return localVarReturnValue, localVarHTTPResponse, newErr
}
return localVarReturnValue, localVarHTTPResponse, nil
}
type ComputeAPIUnbindMachineAgentRequest struct {
ctx context.Context
ApiService *ComputeAPIService
id string
}
func (r ComputeAPIUnbindMachineAgentRequest) Execute() (*http.Response, error) {
return r.ApiService.UnbindMachineAgentExecute(r)
}
/*
UnbindMachineAgent Detaches the agent runtime from one of the caller org's machines.
Detaches the agent runtime from one of the caller org's
machines. The machine stays — this halts the bot, it does not terminate the
compute. Answers 204.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the machine's org-scoped NAME — the stable key Visor addresses a machine by (owner/name), not the ephemeral provider id.
@return ComputeAPIUnbindMachineAgentRequest
*/
func (a *ComputeAPIService) UnbindMachineAgent(ctx context.Context, id string) ComputeAPIUnbindMachineAgentRequest {
return ComputeAPIUnbindMachineAgentRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *ComputeAPIService) UnbindMachineAgentExecute(r ComputeAPIUnbindMachineAgentRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ComputeAPIService.UnbindMachineAgent")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/compute/machines/{id}/agent"
localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the Content-Type header
localVarHTTPContentTypes := []string{}
// set Content-Type header
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
if localVarHTTPContentType != "" {
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
}
// to determine the Accept header
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
if err != nil {
return nil, err
}
localVarHTTPResponse, err := a.client.callAPI(req)
if err != nil || localVarHTTPResponse == nil {
return localVarHTTPResponse, err
}
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
localVarHTTPResponse.Body.Close()
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
if err != nil {
return localVarHTTPResponse, err
}
if localVarHTTPResponse.StatusCode >= 300 {
newErr := &GenericOpenAPIError{
body: localVarBody,
error: localVarHTTPResponse.Status,
}
var v ProblemDetails
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
if err != nil {
newErr.error = err.Error()
return localVarHTTPResponse, newErr
}
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
newErr.model = v
return localVarHTTPResponse, newErr
}
return localVarHTTPResponse, nil
}