Files
sdk/api_sandbox.go

2867 lines
99 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"
)
// SandboxAPIService SandboxAPI service
type SandboxAPIService service
type SandboxAPIDeleteSandboxByIdRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
purge *string
}
func (r SandboxAPIDeleteSandboxByIdRequest) Purge(purge string) SandboxAPIDeleteSandboxByIdRequest {
r.purge = &purge
return r
}
func (r SandboxAPIDeleteSandboxByIdRequest) Execute() (*http.Response, error) {
return r.ApiService.DeleteSandboxByIdExecute(r)
}
/*
DeleteSandboxById Ends a sandbox and releases the compute behind it.
Ends a sandbox and releases the compute behind it. Answers 204.
ENDING IS NOT STOPPING. This releases the resource: the pod goes and anything
only inside it goes with it. To end what a sandbox is RUNNING while keeping
the sandbox — the checkout, the logs, the half-written file — the verb is
POST /v1/sandbox/stop.
`?purge=1` additionally removes the record, so the sandbox stops being listed
at all rather than being listed as ended.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to end, from the path.
@return SandboxAPIDeleteSandboxByIdRequest
*/
func (a *SandboxAPIService) DeleteSandboxById(ctx context.Context, id string) SandboxAPIDeleteSandboxByIdRequest {
return SandboxAPIDeleteSandboxByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) DeleteSandboxByIdExecute(r SandboxAPIDeleteSandboxByIdRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodDelete
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.DeleteSandboxById")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}"
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.purge != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "purge", r.purge, "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 SandboxAPIEndSandboxRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxEndIn *SandboxEndIn
}
func (r SandboxAPIEndSandboxRequest) SandboxEndIn(sandboxEndIn SandboxEndIn) SandboxAPIEndSandboxRequest {
r.sandboxEndIn = &sandboxEndIn
return r
}
func (r SandboxAPIEndSandboxRequest) Execute() (*http.Response, error) {
return r.ApiService.EndSandboxExecute(r)
}
/*
EndSandbox End a sandbox and release it
Ends the caller's sandbox lease: the pod goes, and the volume goes only
when the caller asked for that too.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIEndSandboxRequest
*/
func (a *SandboxAPIService) EndSandbox(ctx context.Context) SandboxAPIEndSandboxRequest {
return SandboxAPIEndSandboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
func (a *SandboxAPIService) EndSandboxExecute(r SandboxAPIEndSandboxRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.EndSandbox")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/end"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxEndIn == nil {
return nil, reportError("sandboxEndIn 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/problem+json"}
// set Accept header
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
if localVarHTTPHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
}
// body params
localVarPostBody = r.sandboxEndIn
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 SandboxAPIGetSandboxRequest struct {
ctx context.Context
ApiService *SandboxAPIService
project *string
status *string
}
func (r SandboxAPIGetSandboxRequest) Project(project string) SandboxAPIGetSandboxRequest {
r.project = &project
return r
}
func (r SandboxAPIGetSandboxRequest) Status(status string) SandboxAPIGetSandboxRequest {
r.status = &status
return r
}
func (r SandboxAPIGetSandboxRequest) Execute() (*SandboxSandboxList, *http.Response, error) {
return r.ApiService.GetSandboxExecute(r)
}
/*
GetSandbox Lists the sandboxes the caller holds, newest first.
Lists the sandboxes the caller holds, newest first.
A member holds the sandboxes they leased; an admin of the org, or a SuperAdmin,
holds every one in it. `?project=` and `?status=` narrow it. Only the caller's
org's: the store is keyed on the validated org, so another tenant's sandbox is
not something this operation can return.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIGetSandboxRequest
*/
func (a *SandboxAPIService) GetSandbox(ctx context.Context) SandboxAPIGetSandboxRequest {
return SandboxAPIGetSandboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxSandboxList
func (a *SandboxAPIService) GetSandboxExecute(r SandboxAPIGetSandboxRequest) (*SandboxSandboxList, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxSandboxList
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandbox")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.project != nil {
parameterAddToHeaderOrQuery(localVarQueryParams, "project", r.project, "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 SandboxAPIGetSandboxByIdRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdRequest) Execute() (*SandboxSandbox, *http.Response, error) {
return r.ApiService.GetSandboxByIdExecute(r)
}
/*
GetSandboxById Returns one sandbox: its class, project, image, the runtime it was given, its status and when its lease ends.
Returns one sandbox: its class, project, image, the runtime it was
given, its status and when its lease ends.
A sandbox is its lessee's and its org admins'. An id the caller does not hold —
another org's, or another member's — is the same 404 an unknown id gives.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to address, from the path.
@return SandboxAPIGetSandboxByIdRequest
*/
func (a *SandboxAPIService) GetSandboxById(ctx context.Context, id string) SandboxAPIGetSandboxByIdRequest {
return SandboxAPIGetSandboxByIdRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxSandbox
func (a *SandboxAPIService) GetSandboxByIdExecute(r SandboxAPIGetSandboxByIdRequest) (*SandboxSandbox, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxSandbox
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxById")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{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 SandboxAPIGetSandboxByIdFsRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdFsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetSandboxByIdFsExecute(r)
}
/*
GetSandboxByIdFs Read a file, or list a directory
Reads one file from the sandbox's project directory as text, or lists the entries when the path names a directory. Paths resolve under the project root and a path that climbs out is refused rather than rewritten.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIGetSandboxByIdFsRequest
*/
func (a *SandboxAPIService) GetSandboxByIdFs(ctx context.Context, id string) SandboxAPIGetSandboxByIdFsRequest {
return SandboxAPIGetSandboxByIdFsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) GetSandboxByIdFsExecute(r SandboxAPIGetSandboxByIdFsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdFs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/fs"
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{}
// 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 SandboxAPIGetSandboxByIdPortsRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdPortsRequest) Execute() (*SandboxPorts, *http.Response, error) {
return r.ApiService.GetSandboxByIdPortsExecute(r)
}
/*
GetSandboxByIdPorts Lists the TCP ports something listens on in a sandbox the caller holds, each with the preview host that serves it — what the sandbox's Browser can open.
Lists the TCP ports something listens on in a sandbox the caller
holds, each with the preview host that serves it — what the sandbox's Browser
can open. A dev server started in the sandbox appears here once it listens.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox, from the path.
@return SandboxAPIGetSandboxByIdPortsRequest
*/
func (a *SandboxAPIService) GetSandboxByIdPorts(ctx context.Context, id string) SandboxAPIGetSandboxByIdPortsRequest {
return SandboxAPIGetSandboxByIdPortsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxPorts
func (a *SandboxAPIService) GetSandboxByIdPortsExecute(r SandboxAPIGetSandboxByIdPortsRequest) (*SandboxPorts, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxPorts
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdPorts")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/ports"
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 SandboxAPIGetSandboxByIdScreenRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdScreenRequest) Execute() (*http.Response, error) {
return r.ApiService.GetSandboxByIdScreenExecute(r)
}
/*
GetSandboxByIdScreen The screen, as a page
A complete, self-contained desktop — noVNC inline, no other origin — that opens its own socket and draws this sandbox's display. Embed it in an iframe and there is nothing else to build.
`ticket` is the credential from the POST above, carried through to the socket. The page is NOT gated: it is inert markup and does not redeem the ticket, because a ticket is spent once and a page that spent it would hold a credential that no longer opens anything. `frame-ancestors` admits our own brands' hosts and nothing further.
It is served for every class, not only for `desktop`. The class is a fact about the image, and a sandbox with no VNC server already fails exactly — the connection is refused and the page says so — where a check here would be a second opinion about what is running inside a pod, formed from a label rather than from the pod.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIGetSandboxByIdScreenRequest
*/
func (a *SandboxAPIService) GetSandboxByIdScreen(ctx context.Context, id string) SandboxAPIGetSandboxByIdScreenRequest {
return SandboxAPIGetSandboxByIdScreenRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) GetSandboxByIdScreenExecute(r SandboxAPIGetSandboxByIdScreenRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdScreen")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/screen"
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{}
// 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 SandboxAPIGetSandboxByIdScreenWsRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdScreenWsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetSandboxByIdScreenWsExecute(r)
}
/*
GetSandboxByIdScreenWs The screen, as a socket
Upgrades to a WebSocket carrying RFB — the VNC wire protocol — from the sandbox's display, for a host that brings its own client. Requires `ticket`; a missing, expired or already-spent one answers 401 without upgrading.
THE WIRE IS RFB, in BINARY frames both ways, and it is not interpreted here: this is a pipe between the caller's client and the server inside the pod.
THE PIXELS COME OUT THROUGH THE EXEC CHANNEL. The display binds 127.0.0.1 only and deliberately nothing else, so there is no address to dial — `socat` joins the stream to that loopback port over the same Kubernetes exec subresource every other call into a sandbox uses. One way in, one thing to authorize, nothing further exposed.
The window size is ignored. A browser pane is not the X server's geometry, and the client scales what it is given rather than asking a server with no RandR to resize itself.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIGetSandboxByIdScreenWsRequest
*/
func (a *SandboxAPIService) GetSandboxByIdScreenWs(ctx context.Context, id string) SandboxAPIGetSandboxByIdScreenWsRequest {
return SandboxAPIGetSandboxByIdScreenWsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) GetSandboxByIdScreenWsExecute(r SandboxAPIGetSandboxByIdScreenWsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdScreenWs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/screen/ws"
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{}
// 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 SandboxAPIGetSandboxByIdTerminalRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdTerminalRequest) Execute() (*http.Response, error) {
return r.ApiService.GetSandboxByIdTerminalExecute(r)
}
/*
GetSandboxByIdTerminal The terminal, as a page
A complete, self-contained terminal — xterm inline, no other origin — that opens its own socket and runs a shell in this sandbox. Embed it in an iframe and there is nothing else to build.
`ticket` is the credential from the POST above and `arg` names the session (see the socket below); both are simply carried through to the socket. The page is NOT gated — it is inert markup and does not redeem the ticket, because a ticket is spent once and a page that spent it would hold a credential that no longer opens anything.
When the terminal is up it posts `{source:"hanzo-term", ready:true}` to its parent frame, so a host can tell a live terminal from a page that failed into something else. `frame-ancestors` admits our own brands' hosts and nothing further.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIGetSandboxByIdTerminalRequest
*/
func (a *SandboxAPIService) GetSandboxByIdTerminal(ctx context.Context, id string) SandboxAPIGetSandboxByIdTerminalRequest {
return SandboxAPIGetSandboxByIdTerminalRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) GetSandboxByIdTerminalExecute(r SandboxAPIGetSandboxByIdTerminalRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdTerminal")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/terminal"
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{}
// 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 SandboxAPIGetSandboxByIdTerminalWsRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIGetSandboxByIdTerminalWsRequest) Execute() (*http.Response, error) {
return r.ApiService.GetSandboxByIdTerminalWsExecute(r)
}
/*
GetSandboxByIdTerminalWs The terminal, as a socket
Upgrades to a WebSocket carrying a login shell on a pseudo-terminal inside the sandbox — for a host that brings its own emulator. Requires `ticket`; a missing, expired or already-spent one answers 401 without upgrading.
THE WIRE. A text frame is stdin, unless it is the one control object `{"resize":{"cols":N,"rows":M}}`; a binary frame is always stdin. Output comes back as BINARY frames, because a pty emits arbitrary bytes cut at arbitrary offsets and a text frame carrying half a rune is one the browser closes the connection over.
`arg` names a SESSION: the shell runs under `tmux new -A -s <arg>`, which attaches to that session if it exists and creates it if it does not — so one sandbox holds as many terminals as a caller has names for. It is 1-64 characters of letters, digits, `-` or `_` and may not begin with `-`; anything else is 400. Without `arg` the shell is unnamed and unmultiplexed.
The shell is `zsh -l`, falling back to `bash -l` and then to `sh -l`, and to the plain shell again when the image has no tmux. Every step is a preference and none is a requirement: whatever else the image carries — the hanzo CLI included — is a command to type, never a condition for getting a prompt.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIGetSandboxByIdTerminalWsRequest
*/
func (a *SandboxAPIService) GetSandboxByIdTerminalWs(ctx context.Context, id string) SandboxAPIGetSandboxByIdTerminalWsRequest {
return SandboxAPIGetSandboxByIdTerminalWsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) GetSandboxByIdTerminalWsExecute(r SandboxAPIGetSandboxByIdTerminalWsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxByIdTerminalWs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/terminal/ws"
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{}
// 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 SandboxAPIGetSandboxQuotaRequest struct {
ctx context.Context
ApiService *SandboxAPIService
}
func (r SandboxAPIGetSandboxQuotaRequest) Execute() (*SandboxQuota, *http.Response, error) {
return r.ApiService.GetSandboxQuotaExecute(r)
}
/*
GetSandboxQuota Answers the caller's sandbox quota: the account it belongs to — the org, or a person in the signup org — how many of that account's paid sandboxes are running, and how many may run at once (-1 for no bound).
Answers the caller's sandbox quota: the account it belongs to — the org, or a
person in the signup org — how many of that account's paid sandboxes are
running, and how many may run at once (-1 for no bound). Staff set the quota per
org or per plan; where they set none it is 100.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIGetSandboxQuotaRequest
*/
func (a *SandboxAPIService) GetSandboxQuota(ctx context.Context) SandboxAPIGetSandboxQuotaRequest {
return SandboxAPIGetSandboxQuotaRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxQuota
func (a *SandboxAPIService) GetSandboxQuotaExecute(r SandboxAPIGetSandboxQuotaRequest) (*SandboxQuota, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodGet
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxQuota
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.GetSandboxQuota")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/quota"
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 SandboxAPILeaseSandboxRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxLeaseIn *SandboxLeaseIn
}
func (r SandboxAPILeaseSandboxRequest) SandboxLeaseIn(sandboxLeaseIn SandboxLeaseIn) SandboxAPILeaseSandboxRequest {
r.sandboxLeaseIn = &sandboxLeaseIn
return r
}
func (r SandboxAPILeaseSandboxRequest) Execute() (*SandboxLeased, *http.Response, error) {
return r.ApiService.LeaseSandboxExecute(r)
}
/*
LeaseSandbox Lease a sandbox — a real computer — or resume one you hold
Leases the caller's sandbox, or returns the one it named if that
lease is still running, or gives it a pod again if it is parked — with its
disk as it was left.
What comes back is a real computer: a pod under a runtime boundary with a
toolchain already in it, its own filesystem, and a lease that ends it. Every
other op here acts on the one this returns.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPILeaseSandboxRequest
*/
func (a *SandboxAPIService) LeaseSandbox(ctx context.Context) SandboxAPILeaseSandboxRequest {
return SandboxAPILeaseSandboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxLeased
func (a *SandboxAPIService) LeaseSandboxExecute(r SandboxAPILeaseSandboxRequest) (*SandboxLeased, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxLeased
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.LeaseSandbox")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/lease"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxLeaseIn == nil {
return localVarReturnValue, nil, reportError("sandboxLeaseIn 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.sandboxLeaseIn
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 SandboxAPIPostSandboxRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxSandboxIn *SandboxSandboxIn
}
func (r SandboxAPIPostSandboxRequest) SandboxSandboxIn(sandboxSandboxIn SandboxSandboxIn) SandboxAPIPostSandboxRequest {
r.sandboxSandboxIn = &sandboxSandboxIn
return r
}
func (r SandboxAPIPostSandboxRequest) Execute() (*SandboxSandbox, *http.Response, error) {
return r.ApiService.PostSandboxExecute(r)
}
/*
PostSandbox Leases a sandbox — a real computer — for the caller's org.
Leases a sandbox — a real computer — for the caller's org.
The class decides what it is for and therefore its image, working directory
and isolation. A dev or desktop sandbox is SINGLE-ATTACH per project, so
asking twice for one project resumes the one that exists rather than paying
for a second; an exec sandbox carries no project and is bounded per org
instead, refused 429 past the ceiling because the caller's correct response is
to wait.
Answers 201 with the sandbox as leased, which names the runtime it GOT — not
the one that was asked for.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIPostSandboxRequest
*/
func (a *SandboxAPIService) PostSandbox(ctx context.Context) SandboxAPIPostSandboxRequest {
return SandboxAPIPostSandboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxSandbox
func (a *SandboxAPIService) PostSandboxExecute(r SandboxAPIPostSandboxRequest) (*SandboxSandbox, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxSandbox
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandbox")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxSandboxIn == nil {
return localVarReturnValue, nil, reportError("sandboxSandboxIn 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.sandboxSandboxIn
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 SandboxAPIPostSandboxByIdAgentRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdAgentRequest) Execute() (*http.Response, error) {
return r.ApiService.PostSandboxByIdAgentExecute(r)
}
/*
PostSandboxByIdAgent Have a model work a sandbox
Says what to do on a sandbox you hold, and a model does it there while you watch: a shell on any sandbox, and on a desktop or a browser the screen too — it takes a screenshot, clicks where it sees, types, presses keys, opens addresses and runs commands. The answer is a text/event-stream, one event a step, ending with `end`.
The body is JSON: `message` (required, what to do, in words), `history` (the conversation so far, oldest first, each {role: user|assistant, text}) and `model` (a model id from GET /v1/models; empty takes the deployment's).
Events (`event:` name, `data:` JSON): `say` {text} the model's words; `act` {tool, args} a tool it reached for; `result` {tool, ok, text} what the tool answered; `error` {text} the turn could not go on; `end` {rounds} the turn is over. A `: ping` comment every 15 seconds keeps intermediaries from closing the stream.
The server keeps nothing between turns: send the conversation so far as `history` ({role: user|assistant, text}). The model is billed to the caller's account at the gateway's rates, and the sandbox hour is the one the lease already bills. Open the sandbox's screen (POST /v1/sandbox/{id}/screen/ticket) beside it to watch.
409 when the sandbox is not running; 404 for a sandbox you do not hold; 503 where no model gateway is mounted.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIPostSandboxByIdAgentRequest
*/
func (a *SandboxAPIService) PostSandboxByIdAgent(ctx context.Context, id string) SandboxAPIPostSandboxByIdAgentRequest {
return SandboxAPIPostSandboxByIdAgentRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) PostSandboxByIdAgentExecute(r SandboxAPIPostSandboxByIdAgentRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdAgent")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{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{}
// 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 SandboxAPIPostSandboxByIdExecRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
sandboxExecRequest *SandboxExecRequest
}
func (r SandboxAPIPostSandboxByIdExecRequest) SandboxExecRequest(sandboxExecRequest SandboxExecRequest) SandboxAPIPostSandboxByIdExecRequest {
r.sandboxExecRequest = &sandboxExecRequest
return r
}
func (r SandboxAPIPostSandboxByIdExecRequest) Execute() (*SandboxExecResult, *http.Response, error) {
return r.ApiService.PostSandboxByIdExecExecute(r)
}
/*
PostSandboxByIdExec Runs one command in a sandbox the caller holds and answers with its exit code, stdout and stderr.
Runs one command in a sandbox the caller holds and answers with
its exit code, stdout and stderr.
Send `argv` — an argument vector cannot be word-split by accident — or
`command` for a shell line, which is the only input here that ever reaches a
shell. A non-zero exit is a SUCCESSFUL call carrying a failed command: the
status is 200 and the exit code is in the answer, because "the command failed"
and "the call failed" are different facts.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to run in, from the path.
@return SandboxAPIPostSandboxByIdExecRequest
*/
func (a *SandboxAPIService) PostSandboxByIdExec(ctx context.Context, id string) SandboxAPIPostSandboxByIdExecRequest {
return SandboxAPIPostSandboxByIdExecRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxExecResult
func (a *SandboxAPIService) PostSandboxByIdExecExecute(r SandboxAPIPostSandboxByIdExecRequest) (*SandboxExecResult, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxExecResult
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdExec")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/exec"
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.sandboxExecRequest == nil {
return localVarReturnValue, nil, reportError("sandboxExecRequest 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.sandboxExecRequest
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 SandboxAPIPostSandboxByIdFsRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdFsRequest) Execute() (*http.Response, error) {
return r.ApiService.PostSandboxByIdFsExecute(r)
}
/*
PostSandboxByIdFs Write a file
Writes the request body to one file in the sandbox's project directory, creating parent directories. Same confinement as the read above.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id
@return SandboxAPIPostSandboxByIdFsRequest
*/
func (a *SandboxAPIService) PostSandboxByIdFs(ctx context.Context, id string) SandboxAPIPostSandboxByIdFsRequest {
return SandboxAPIPostSandboxByIdFsRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
func (a *SandboxAPIService) PostSandboxByIdFsExecute(r SandboxAPIPostSandboxByIdFsRequest) (*http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdFs")
if err != nil {
return nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/fs"
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{}
// 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 SandboxAPIPostSandboxByIdPauseRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdPauseRequest) Execute() (*SandboxSandbox, *http.Response, error) {
return r.ApiService.PostSandboxByIdPauseExecute(r)
}
/*
PostSandboxByIdPause Stops the pod, keeps the row and the volume, and settles the tail: POST /v1/sandbox/:id/pause.
Stops the pod, keeps the row and the volume, and settles the tail: POST
/v1/sandbox/:id/pause.
The claim, the stop and the ship are ONE settlement for the same reason a
retirement is — the snapshot that carries the advanced watermark has to carry
the new state, or a successor hydrates a running row for a pod that is gone
and bills for it until the reaper notices.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to address, from the path.
@return SandboxAPIPostSandboxByIdPauseRequest
*/
func (a *SandboxAPIService) PostSandboxByIdPause(ctx context.Context, id string) SandboxAPIPostSandboxByIdPauseRequest {
return SandboxAPIPostSandboxByIdPauseRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxSandbox
func (a *SandboxAPIService) PostSandboxByIdPauseExecute(r SandboxAPIPostSandboxByIdPauseRequest) (*SandboxSandbox, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxSandbox
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdPause")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/pause"
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 SandboxAPIPostSandboxByIdPreviewRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
sandboxPreviewIn *SandboxPreviewIn
}
func (r SandboxAPIPostSandboxByIdPreviewRequest) SandboxPreviewIn(sandboxPreviewIn SandboxPreviewIn) SandboxAPIPostSandboxByIdPreviewRequest {
r.sandboxPreviewIn = &sandboxPreviewIn
return r
}
func (r SandboxAPIPostSandboxByIdPreviewRequest) Execute() (*SandboxPreviewGrant, *http.Response, error) {
return r.ApiService.PostSandboxByIdPreviewExecute(r)
}
/*
PostSandboxByIdPreview Opens a port of a sandbox the caller holds in a browser.
Opens a port of a sandbox the caller holds in a browser.
It answers a URL at an origin of the preview's own —
https://sandbox-<id>-preview-<port>.<apex>/ — carrying a single-use ticket.
Opening it sets a cookie on that origin and lands on its root, and from then on
every request there is carried to the port inside the sandbox: pages, assets,
APIs and WebSockets, as the app serves them on localhost. The preview stays open
for twelve hours or until the sandbox stops running; a preview answering 401 is
opened again by asking for another URL. A sandbox that is not running 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 sandbox, from the path.
@return SandboxAPIPostSandboxByIdPreviewRequest
*/
func (a *SandboxAPIService) PostSandboxByIdPreview(ctx context.Context, id string) SandboxAPIPostSandboxByIdPreviewRequest {
return SandboxAPIPostSandboxByIdPreviewRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxPreviewGrant
func (a *SandboxAPIService) PostSandboxByIdPreviewExecute(r SandboxAPIPostSandboxByIdPreviewRequest) (*SandboxPreviewGrant, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxPreviewGrant
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdPreview")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/preview"
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.sandboxPreviewIn == nil {
return localVarReturnValue, nil, reportError("sandboxPreviewIn 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.sandboxPreviewIn
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 SandboxAPIPostSandboxByIdResumeRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdResumeRequest) Execute() (*SandboxSandbox, *http.Response, error) {
return r.ApiService.PostSandboxByIdResumeExecute(r)
}
/*
PostSandboxByIdResume Gives a parked sandbox a pod again: POST /v1/sandbox/:id/resume.
Gives a parked sandbox a pod again: POST /v1/sandbox/:id/resume.
The pod is NEW and so is its lease: a fresh pod name, because a pod name is
never reused (store.go), the volume the row already names, a lease of the
class's own length from now, and the RESUMING caller's credential rather than
the one that took the lease — a session is short-lived and the one that parked
it is gone.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to address, from the path.
@return SandboxAPIPostSandboxByIdResumeRequest
*/
func (a *SandboxAPIService) PostSandboxByIdResume(ctx context.Context, id string) SandboxAPIPostSandboxByIdResumeRequest {
return SandboxAPIPostSandboxByIdResumeRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxSandbox
func (a *SandboxAPIService) PostSandboxByIdResumeExecute(r SandboxAPIPostSandboxByIdResumeRequest) (*SandboxSandbox, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxSandbox
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdResume")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/resume"
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 SandboxAPIPostSandboxByIdScreenTicketRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdScreenTicketRequest) Execute() (*SandboxTicketGrant, *http.Response, error) {
return r.ApiService.PostSandboxByIdScreenTicketExecute(r)
}
/*
PostSandboxByIdScreenTicket Mints a short-lived grant to open the screen of a desktop sandbox.
Mints a short-lived grant to open the screen of a desktop
sandbox. Same properties as the terminal ticket, for the other endpoint.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to address, from the path.
@return SandboxAPIPostSandboxByIdScreenTicketRequest
*/
func (a *SandboxAPIService) PostSandboxByIdScreenTicket(ctx context.Context, id string) SandboxAPIPostSandboxByIdScreenTicketRequest {
return SandboxAPIPostSandboxByIdScreenTicketRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxTicketGrant
func (a *SandboxAPIService) PostSandboxByIdScreenTicketExecute(r SandboxAPIPostSandboxByIdScreenTicketRequest) (*SandboxTicketGrant, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxTicketGrant
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdScreenTicket")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/screen/ticket"
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 SandboxAPIPostSandboxByIdTerminalTicketRequest struct {
ctx context.Context
ApiService *SandboxAPIService
id string
}
func (r SandboxAPIPostSandboxByIdTerminalTicketRequest) Execute() (*SandboxTicketGrant, *http.Response, error) {
return r.ApiService.PostSandboxByIdTerminalTicketExecute(r)
}
/*
PostSandboxByIdTerminalTicket Mints a short-lived grant to open a terminal on a sandbox.
Mints a short-lived grant to open a terminal on a sandbox.
The ticket travels in the query string of the URL it answers with, because a
browser cannot set an Authorization header on a WebSocket handshake. It is
single-purpose and short-lived for exactly that reason. A sandbox that is not
running is 409 rather than a ticket that cannot be used.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@param id ID is the sandbox to address, from the path.
@return SandboxAPIPostSandboxByIdTerminalTicketRequest
*/
func (a *SandboxAPIService) PostSandboxByIdTerminalTicket(ctx context.Context, id string) SandboxAPIPostSandboxByIdTerminalTicketRequest {
return SandboxAPIPostSandboxByIdTerminalTicketRequest{
ApiService: a,
ctx: ctx,
id: id,
}
}
// Execute executes the request
//
// @return SandboxTicketGrant
func (a *SandboxAPIService) PostSandboxByIdTerminalTicketExecute(r SandboxAPIPostSandboxByIdTerminalTicketRequest) (*SandboxTicketGrant, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxTicketGrant
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.PostSandboxByIdTerminalTicket")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/{id}/terminal/ticket"
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 SandboxAPIReadSandboxFileRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxPathIn *SandboxPathIn
}
func (r SandboxAPIReadSandboxFileRequest) SandboxPathIn(sandboxPathIn SandboxPathIn) SandboxAPIReadSandboxFileRequest {
r.sandboxPathIn = &sandboxPathIn
return r
}
func (r SandboxAPIReadSandboxFileRequest) Execute() (*SandboxBlob, *http.Response, error) {
return r.ApiService.ReadSandboxFileExecute(r)
}
/*
ReadSandboxFile Read a file from a sandbox you hold
Reads one path in the caller's sandbox: a file's bytes, or a
directory's entries when the path names one.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIReadSandboxFileRequest
*/
func (a *SandboxAPIService) ReadSandboxFile(ctx context.Context) SandboxAPIReadSandboxFileRequest {
return SandboxAPIReadSandboxFileRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxBlob
func (a *SandboxAPIService) ReadSandboxFileExecute(r SandboxAPIReadSandboxFileRequest) (*SandboxBlob, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxBlob
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.ReadSandboxFile")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/read"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxPathIn == nil {
return localVarReturnValue, nil, reportError("sandboxPathIn 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.sandboxPathIn
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 SandboxAPIRunInSandboxRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxRunIn *SandboxRunIn
}
func (r SandboxAPIRunInSandboxRequest) SandboxRunIn(sandboxRunIn SandboxRunIn) SandboxAPIRunInSandboxRequest {
r.sandboxRunIn = &sandboxRunIn
return r
}
func (r SandboxAPIRunInSandboxRequest) Execute() (*SandboxRan, *http.Response, error) {
return r.ApiService.RunInSandboxExecute(r)
}
/*
RunInSandbox Run a command in a sandbox you hold and read its output
Runs one command inside the caller's sandbox and answers its exit code,
stdout and stderr. A non-zero exit is a successful call carrying a failed
program, so it comes back as data and not as an error.
Name a `session` and the command NARRATES INTO IT: its output is appended to
that session's live log as the program produces it, so anything watching the
session — GET /v1/agent/sessions/stream, scoped to one run with ?root= —
watches the work happen rather than waiting for the verdict. Without it the
call is what it always was: silent until it returns, which for an agentic run
is twenty-five minutes of blank screen.
The session is named; the TENANT is not. It is the org the caller already
proved, so a session belonging to somebody else is absent from the org this
call acts for and the append is refused there.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIRunInSandboxRequest
*/
func (a *SandboxAPIService) RunInSandbox(ctx context.Context) SandboxAPIRunInSandboxRequest {
return SandboxAPIRunInSandboxRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxRan
func (a *SandboxAPIService) RunInSandboxExecute(r SandboxAPIRunInSandboxRequest) (*SandboxRan, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxRan
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.RunInSandbox")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/run"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxRunIn == nil {
return localVarReturnValue, nil, reportError("sandboxRunIn 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.sandboxRunIn
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 SandboxAPIStopRunRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxStopIn *SandboxStopIn
}
func (r SandboxAPIStopRunRequest) SandboxStopIn(sandboxStopIn SandboxStopIn) SandboxAPIStopRunRequest {
r.sandboxStopIn = &sandboxStopIn
return r
}
func (r SandboxAPIStopRunRequest) Execute() (*SandboxStopped, *http.Response, error) {
return r.ApiService.StopRunExecute(r)
}
/*
StopRun Stop what a sandbox is running, and keep the sandbox
Interrupts whatever the caller's sandbox is running and answers how
many commands it ended. The sandbox stays leased — stop ends the WORK, end ends
the RESOURCE — so whoever stopped a run can still read what it left behind.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIStopRunRequest
*/
func (a *SandboxAPIService) StopRun(ctx context.Context) SandboxAPIStopRunRequest {
return SandboxAPIStopRunRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxStopped
func (a *SandboxAPIService) StopRunExecute(r SandboxAPIStopRunRequest) (*SandboxStopped, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxStopped
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.StopRun")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/stop"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxStopIn == nil {
return localVarReturnValue, nil, reportError("sandboxStopIn 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.sandboxStopIn
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 SandboxAPIWriteSandboxFileRequest struct {
ctx context.Context
ApiService *SandboxAPIService
sandboxWriteIn *SandboxWriteIn
}
func (r SandboxAPIWriteSandboxFileRequest) SandboxWriteIn(sandboxWriteIn SandboxWriteIn) SandboxAPIWriteSandboxFileRequest {
r.sandboxWriteIn = &sandboxWriteIn
return r
}
func (r SandboxAPIWriteSandboxFileRequest) Execute() (*SandboxWrote, *http.Response, error) {
return r.ApiService.WriteSandboxFileExecute(r)
}
/*
WriteSandboxFile Write a file into a sandbox you hold
Writes bytes to one path in the caller's sandbox, creating parents,
and answers the resolved path.
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
@return SandboxAPIWriteSandboxFileRequest
*/
func (a *SandboxAPIService) WriteSandboxFile(ctx context.Context) SandboxAPIWriteSandboxFileRequest {
return SandboxAPIWriteSandboxFileRequest{
ApiService: a,
ctx: ctx,
}
}
// Execute executes the request
//
// @return SandboxWrote
func (a *SandboxAPIService) WriteSandboxFileExecute(r SandboxAPIWriteSandboxFileRequest) (*SandboxWrote, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *SandboxWrote
)
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "SandboxAPIService.WriteSandboxFile")
if err != nil {
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
}
localVarPath := localBasePath + "/v1/sandbox/write"
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if r.sandboxWriteIn == nil {
return localVarReturnValue, nil, reportError("sandboxWriteIn 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.sandboxWriteIn
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
}