WeKnora/internal/sandbox/cube_remote_client.go

838 lines
24 KiB
Go

// Package sandbox: Cube adapter for the provider-neutral RemoteSandboxClient.
//
// CubeRemoteClient implements RemoteSandboxClient on top of the Cube SDK and
// envd transport. Callers speak RemoteSandboxClient; Cube-specific types,
// HTTP status codes, and workarounds never leak past this file — every return
// value is either a neutral DTO or a RemoteError with a stable Kind.
package sandbox
import (
"context"
"errors"
"fmt"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/Tencent/WeKnora/internal/logger"
cubesandbox "github.com/tencentcloud/CubeSandbox/sdk/go"
)
// CubeRemoteClient implements RemoteSandboxClient on top of the Cube SDK and
// envd transport. It is the only Cube backend the manager and lifecycle
// coordinator see.
type CubeRemoteClient struct {
config *Config
client *cubesandbox.Client
sandboxDomain string
httpTimeout time.Duration
}
// NewCubeRemoteClient constructs a Cube-backed RemoteSandboxClient using the
// SDK default HTTP clients (separate control/data pools). Suitable for the
// process-wide default manager and for throwaway connectivity probes, neither
// of which benefits from an externally owned pool.
func NewCubeRemoteClient(config *Config) (*CubeRemoteClient, error) {
return NewCubeRemoteClientWithPool(config, nil)
}
// NewCubeRemoteClientWithPool builds a client whose connections come from a
// caller-owned pool. Named configs construct a client per request, so the pool
// is what keeps connections alive across requests; it routes control-plane
// traffic onto the transport shared with E2B while preserving the SDK's
// proxy dial rewrite for the data plane. A nil pool keeps the SDK defaults.
func NewCubeRemoteClientWithPool(
config *Config,
pool *CubeTransportPool,
) (*CubeRemoteClient, error) {
if config == nil {
return nil, errors.New("cube remote client config is required")
}
httpTimeout := config.CubeHTTPTimeout
if httpTimeout <= 0 {
httpTimeout = DefaultCubeHTTPTimeout
}
sdkCfg := cubesandbox.Config{
APIURL: config.CubeAPIURL,
APIKey: config.CubeAPIKey,
TemplateID: config.CubeTemplate,
SandboxDomain: config.CubeSandboxDomain,
Timeout: config.CubeHTTPTimeout,
RequestTimeout: config.CubeHTTPTimeout,
}
if proxyHost, proxyPort, proxyScheme, ok := parseProxyURL(config.CubeProxyURL); ok {
sdkCfg.ProxyNodeIP = proxyHost
sdkCfg.ProxyPortHTTP = proxyPort
sdkCfg.ProxyScheme = proxyScheme
}
var opts []cubesandbox.ClientOption
if pool != nil {
httpClient := &http.Client{
Timeout: httpTimeout,
Transport: pool.RoundTripperFor(config),
}
opts = append(opts, cubesandbox.WithHTTPClient(httpClient))
}
return &CubeRemoteClient{
config: config,
client: cubesandbox.NewClient(
sdkCfg,
opts...,
),
sandboxDomain: config.CubeSandboxDomain,
httpTimeout: httpTimeout,
}, nil
}
// cubeRemoteHandle is the RemoteSandboxHandle Cube returns. It wraps the SDK's
// *cubesandbox.Sandbox directly; all envd calls (WriteFile / RunCommand / …)
// dispatch through sb. Metadata is cached at creation time so Metadata()
// can return it without a network round-trip.
type cubeRemoteHandle struct {
sb *cubesandbox.Sandbox
metadata map[string]string
}
func (h *cubeRemoteHandle) ID() string {
if h == nil || h.sb == nil {
return ""
}
return h.sb.SandboxID
}
func (h *cubeRemoteHandle) Provider() RemoteProvider { return SandboxTypeCube }
func (h *cubeRemoteHandle) Metadata() map[string]string {
if h == nil {
return nil
}
return cloneMetadata(h.metadata)
}
// --- RemoteSandboxClient ------------------------------------------------------
func (c *CubeRemoteClient) Provider() RemoteProvider { return SandboxTypeCube }
func (c *CubeRemoteClient) Capabilities() RemoteSandboxCapabilities {
return RemoteSandboxCapabilities{
SupportsReconnect: true,
SupportsMetadata: true,
SupportsListSandboxes: true,
SupportsPauseResume: true,
SupportsTimeoutRefresh: true,
SupportsFilesystemEnumeration: true,
// Cube's CreateOptions has no volume-mount field yet; revisit when the
// official Go SDK reaches v0.6.0.
SupportsVolumes: false,
}
}
func (c *CubeRemoteClient) Health(ctx context.Context) error {
if _, err := c.client.Health(ctx); err != nil {
logger.Errorf(ctx, "cube remote client health check failed: %v", err)
return normalizeCubeError("Health", err)
}
return nil
}
func (c *CubeRemoteClient) ListTemplates(ctx context.Context) ([]RemoteTemplate, error) {
items, err := c.client.ListTemplates(ctx)
if err != nil {
return nil, normalizeCubeError("ListTemplates", err)
}
result := make([]RemoteTemplate, 0, len(items))
for _, item := range items {
name := strings.TrimSpace(item.Name)
if name == "" {
name = item.TemplateID
}
result = append(result, RemoteTemplate{
ID: item.TemplateID,
Name: name,
Status: item.Status,
Version: item.Version,
Image: item.ImageInfo,
CreatedAt: item.CreatedAt,
Standard: isStandardTemplate(name),
})
}
return result, nil
}
func (c *CubeRemoteClient) EnsureStandardTemplate(ctx context.Context) (*RemoteTemplate, error) {
items, err := c.ListTemplates(ctx)
if err != nil {
return nil, err
}
for i := range items {
if items[i].Standard {
return &items[i], nil
}
}
job, err := c.client.BuildTemplate(ctx, cubesandbox.BuildTemplateOptions{
Image: DefaultDockerImage,
Name: StandardTemplateName,
WritableLayerSize: "1G",
ExposedPorts: []uint16{49983},
})
if err != nil {
return nil, normalizeCubeError("EnsureStandardTemplate", err)
}
return &RemoteTemplate{
ID: job.TemplateID,
Name: StandardTemplateName,
Status: job.Status,
Image: DefaultDockerImage,
Standard: true,
}, nil
}
func (c *CubeRemoteClient) Create(
ctx context.Context,
request RemoteCreateRequest,
) (RemoteSandboxHandle, error) {
if strings.TrimSpace(request.TemplateID) == "" {
return nil, cubeInvalidRequest("Create", "template ID is required", nil)
}
timeout, err := cubeTimeout(request.Timeout)
if err != nil {
return nil, cubeInvalidRequest("Create", err.Error(), err)
}
action := request.Timeout.Action
autoResume := request.Timeout.AutoResume
if action == "" {
action = RemoteOnTimeoutKill
}
if action != RemoteOnTimeoutKill && action != RemoteOnTimeoutPause {
return nil, cubeInvalidRequest(
"Create",
fmt.Sprintf("unsupported timeout action %q", action),
nil,
)
}
if request.Timeout.AutoResume && action != RemoteOnTimeoutPause {
return nil, cubeInvalidRequest(
"Create",
"auto resume requires pause on timeout",
nil,
)
}
// Cube honours two independent switches for outbound reachability and
// both must be on for "curl https://example.com" to work from inside
// the VM:
//
// * AllowInternetAccess (top-level, cluster egress switch): when
// nil the SDK omits the field and the server falls back to the
// template's default. Setting it explicitly makes the intent
// obvious to anyone reading a captured payload and keeps
// behaviour identical when the template default flips.
// * Network.AllowPublicTraffic (per-sandbox routing switch): tells
// CubeProxy to attach the public-egress interface to this MicroVM.
// Without it the VM has no outbound route regardless of the
// cluster-level allow.
//
// Callers can override either switch via cubeCreateRequest.Network.
// The permissive (both on) defaults preserve the pre-refactor
// behaviour for callers that leave the policy unset.
//
// See docs/guide/network-policy.md ("示例 7: 混合 L3 allow 和 L7 rules").
network := request.Network
if network.AllowInternetAccess == nil {
defaultOn := true
network.AllowInternetAccess = &defaultOn
}
if network.AllowPublicTraffic == nil {
defaultOn := true
network.AllowPublicTraffic = &defaultOn
}
opts := cubesandbox.CreateOptions{
TemplateID: request.TemplateID,
Timeout: timeout,
EnvVars: cloneMetadata(request.EnvVars),
Metadata: cloneMetadata(request.Metadata),
AllowInternetAccess: network.AllowInternetAccess,
Network: cubesandbox.NetworkOptions{
AllowPublicTraffic: network.AllowPublicTraffic,
AllowOut: append([]string(nil), network.AllowOut...),
DenyOut: append([]string(nil), network.DenyOut...),
},
}
if action != "" {
opts.Extra = map[string]any{
"lifecycle": map[string]any{
"onTimeout": string(action),
"autoResume": autoResume,
},
}
}
sb, err := c.client.Create(ctx, opts)
if err != nil {
return nil, normalizeCubeError("Create", err)
}
if sb == nil || sb.SandboxID == "" {
return nil, errors.New("cube api: create sandbox: empty sandboxID")
}
return &cubeRemoteHandle{
sb: sb,
metadata: cloneMetadata(request.Metadata),
}, nil
}
func (c *CubeRemoteClient) Connect(
ctx context.Context,
sandboxID string,
) (RemoteSandboxHandle, error) {
if strings.TrimSpace(sandboxID) == "" {
return nil, cubeInvalidRequest("Connect", "sandbox ID is required", nil)
}
sb, err := c.client.Connect(ctx, sandboxID)
if err != nil {
return nil, normalizeCubeError("Connect", err)
}
if sb == nil || sb.SandboxID == "" {
return nil, NewRemoteError(
SandboxTypeCube, "Connect", RemoteErrorKindInternal,
"cube returned an empty sandbox handle", nil,
)
}
return &cubeRemoteHandle{sb: sb}, nil
}
func (c *CubeRemoteClient) Get(
ctx context.Context,
sandboxID string,
) (*RemoteSandboxSummary, error) {
if strings.TrimSpace(sandboxID) == "" {
return nil, cubeInvalidRequest("Get", "sandbox ID is required", nil)
}
sb, err := c.client.Connect(ctx, sandboxID)
if err != nil {
return nil, normalizeCubeError("Get", err)
}
info, err := sb.GetInfo(ctx)
if err != nil {
if isSDKNotFound(err) {
return nil, NewRemoteError(
SandboxTypeCube, "Get", RemoteErrorKindNotFound,
"sandbox not found", nil,
)
}
return nil, normalizeCubeError("Get", err)
}
if info == nil {
return nil, NewRemoteError(
SandboxTypeCube, "Get", RemoteErrorKindNotFound,
"sandbox not found", nil,
)
}
return cubeRemoteSummary(*info), nil
}
func (c *CubeRemoteClient) List(
ctx context.Context,
filter RemoteListFilter,
) ([]RemoteSandboxSummary, error) {
sandboxInfos, err := c.client.List(ctx)
if err != nil {
return nil, normalizeCubeError("List", err)
}
result := make([]RemoteSandboxSummary, 0, len(sandboxInfos))
for _, summary := range sandboxInfos {
converted := cubeRemoteSummary(summary)
if !metadataMatches(converted.Metadata, filter.Metadata) ||
!StateMatches(converted.State, filter.States) {
continue
}
result = append(result, *converted)
}
return result, nil
}
func (c *CubeRemoteClient) Delete(ctx context.Context, sandboxID string) error {
if strings.TrimSpace(sandboxID) == "" {
return cubeInvalidRequest("Delete", "sandbox ID is required", nil)
}
sb, err := c.client.Connect(ctx, sandboxID)
if err != nil {
return normalizeCubeError("Delete", err)
}
if err := sb.Kill(ctx); err != nil {
return normalizeCubeError("Delete", err)
}
return nil
}
func (c *CubeRemoteClient) Exec(
ctx context.Context,
handle RemoteSandboxHandle,
request RemoteExecRequest,
) (*RemoteExecResult, error) {
sb, err := cubeHandleSandbox("Exec", handle)
if err != nil {
return nil, err
}
if strings.TrimSpace(request.Command) == "" {
return nil, cubeInvalidRequest("Exec", "command is required", nil)
}
if request.Shell && len(request.Args) != 0 {
return nil, cubeInvalidRequest(
"Exec", "shell execution cannot include argv arguments", nil,
)
}
if request.Timeout < 0 {
return nil, cubeInvalidRequest("Exec", "execution timeout cannot be negative", nil)
}
execCtx := ctx
cancel := func() {}
if request.Timeout > 0 {
execCtx, cancel = context.WithTimeout(ctx, request.Timeout)
}
defer cancel()
line := request.Command
if !request.Shell {
line = buildShellLine(request.Command, request.Args)
}
if request.Stdin != "" {
line = wrapWithStdin(line, request.Stdin)
}
envs := cloneMetadata(request.Env)
if envs == nil {
envs = map[string]string{}
}
startedAt := time.Now()
// User comes from the neutral request rather than being hardcoded: running
// everything as root silently defeats file-mode protections on shared
// volumes, and made this adapter behave differently from E2B's.
sdkResult, execErr := sb.Commands().Run(execCtx, line, cubesandbox.CommandOptions{
Timeout: request.Timeout,
Envs: envs,
Cwd: request.WorkDir,
User: request.User,
})
duration := time.Since(startedAt)
if execErr != nil {
if request.Timeout > 0 &&
errors.Is(execCtx.Err(), context.DeadlineExceeded) {
return &RemoteExecResult{
Duration: duration,
Killed: true,
ExitCode: -1,
}, nil
}
return nil, normalizeCubeError("Exec", execErr)
}
if sdkResult == nil {
return nil, NewRemoteError(
SandboxTypeCube, "Exec", RemoteErrorKindInternal,
"cube returned an empty command result", nil,
)
}
return &RemoteExecResult{
Stdout: sdkResult.Stdout,
Stderr: sdkResult.Stderr,
ExitCode: sdkResult.ExitCode,
Duration: duration,
}, nil
}
func (c *CubeRemoteClient) WriteFile(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
content []byte,
) error {
sb, err := cubeHandleSandbox("WriteFile", handle)
if err != nil {
return err
}
if err := sb.Files().Write(ctx, path, content); err != nil {
return normalizeCubeError("WriteFile", err)
}
return nil
}
func (c *CubeRemoteClient) ReadFile(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
) ([]byte, error) {
sb, err := cubeHandleSandbox("ReadFile", handle)
if err != nil {
return nil, err
}
content, err := sb.Files().Read(ctx, path)
if err != nil {
return nil, normalizeCubeError("ReadFile", err)
}
return []byte(content), nil
}
func (c *CubeRemoteClient) ListDir(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
) ([]RemoteDirEntry, error) {
sb, err := cubeHandleSandbox("ListDir", handle)
if err != nil {
return nil, err
}
if path == "" {
path = "/"
}
entries, err := sb.Files().List(ctx, path)
if err != nil {
return nil, normalizeCubeError("ListDir", err)
}
result := make([]RemoteDirEntry, 0, len(entries))
for _, e := range entries {
result = append(result, RemoteDirEntry{
Name: e.Name,
Path: e.Path,
Type: cubeRemoteEntryType(normaliseFileType(e.Type)),
Size: e.Size,
ModTime: cubeModTime(e.ModifiedTime),
})
}
return result, nil
}
// normaliseFileType maps envd's proto enum strings ("FILE_TYPE_FILE",
// "FILE_TYPE_DIRECTORY", …) onto the short lowercase names WeKnora already
// stores.
func normaliseFileType(t string) string {
switch strings.ToUpper(t) {
case "FILE_TYPE_FILE", "FILE":
return "file"
case "FILE_TYPE_DIRECTORY", "DIRECTORY":
return "directory"
case "FILE_TYPE_SYMLINK", "SYMLINK":
return "symlink"
default:
if t == "" {
return ""
}
return strings.ToLower(t)
}
}
func (c *CubeRemoteClient) MakeDir(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
) error {
sb, err := cubeHandleSandbox("MakeDir", handle)
if err != nil {
return err
}
if _, err := sb.Files().MakeDir(ctx, path); err != nil {
return normalizeCubeError("MakeDir", err)
}
return nil
}
func (c *CubeRemoteClient) Remove(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
) error {
sb, err := cubeHandleSandbox("Remove", handle)
if err != nil {
return err
}
if err := sb.Files().Remove(ctx, path); err != nil {
return normalizeCubeError("Remove", err)
}
return nil
}
func (c *CubeRemoteClient) Stat(
ctx context.Context,
handle RemoteSandboxHandle,
path string,
) (*RemoteStatEntry, error) {
sb, err := cubeHandleSandbox("Stat", handle)
if err != nil {
return nil, err
}
entry, err := sb.Files().Stat(ctx, path)
if err != nil {
if isSDKNotFound(err) {
return nil, NewRemoteError(
SandboxTypeCube, "Stat", RemoteErrorKindNotFound,
"path not found", nil,
)
}
return nil, normalizeCubeError("Stat", err)
}
if entry == nil {
return nil, NewRemoteError(
SandboxTypeCube, "Stat", RemoteErrorKindNotFound,
"path not found", nil,
)
}
return &RemoteStatEntry{
Path: entry.Path,
Type: cubeRemoteEntryType(normaliseFileType(entry.Type)),
Size: entry.Size,
ModTime: cubeModTime(entry.ModifiedTime),
}, nil
}
// --- helpers -----------------------------------------------------------------
// isSDKNotFound spots the SDK's "resource missing" errors without having to
// import its internal error types. Both explicit NotFoundError values and
// textual "not found" mentions in wrapped errors are recognised.
func isSDKNotFound(err error) bool {
if err == nil {
return false
}
var nfe *cubesandbox.NotFoundError
if errors.As(err, &nfe) {
return true
}
lower := strings.ToLower(err.Error())
return strings.Contains(lower, "not found") ||
strings.Contains(lower, "no such file") ||
strings.Contains(lower, "sandbox_not_found") ||
strings.Contains(lower, "http 404")
}
func cubeTimeout(policy RemoteTimeoutPolicy) (*time.Duration, error) {
switch policy.Mode {
case "", RemoteTimeoutServerDefault:
return nil, nil
case RemoteTimeoutExplicit:
value := policy.Value
if value < 0 {
value = cubesandbox.NeverTimeout
}
return &value, nil
default:
return nil, fmt.Errorf("unsupported timeout mode %q", policy.Mode)
}
}
// cubeHandleSandbox extracts the SDK *cubesandbox.Sandbox from an opaque
// RemoteSandboxHandle. Returns an error when the handle is nil, not Cube,
// or has an empty sandbox ID.
func cubeHandleSandbox(op string, handle RemoteSandboxHandle) (*cubesandbox.Sandbox, error) {
cubeHandle, ok := handle.(*cubeRemoteHandle)
if !ok || cubeHandle == nil || cubeHandle.sb == nil ||
strings.TrimSpace(cubeHandle.sb.SandboxID) == "" {
return nil, cubeInvalidRequest(op, "handle was not issued by Cube", nil)
}
return cubeHandle.sb, nil
}
// cubeRemoteSummary converts the SDK's SandboxInfo (from List / GetInfo) into
// the provider-neutral RemoteSandboxSummary DTO.
func cubeRemoteSummary(info cubesandbox.SandboxInfo) *RemoteSandboxSummary {
out := &RemoteSandboxSummary{
ID: info.SandboxID,
TemplateID: info.TemplateID,
State: normalizeCubeState(info.State),
RawState: info.State,
Metadata: cloneMetadata(info.Metadata),
StartedAt: info.StartedAt,
}
if info.EndAt != nil {
out.EndAt = *info.EndAt
}
return out
}
// parseProxyURL turns "http://127.0.0.1:80" into ("127.0.0.1", 80, "http").
// A missing port defaults to 80/443 depending on the scheme; an unparseable
// URL returns ok=false so callers can fall back to the SDK's defaults.
func parseProxyURL(raw string) (host string, port int, scheme string, ok bool) {
raw = strings.TrimSpace(raw)
if raw == "" {
return "", 0, "", false
}
parsed, err := url.Parse(raw)
if err != nil || parsed.Host == "" {
return "", 0, "", false
}
scheme = strings.ToLower(parsed.Scheme)
if scheme == "" {
scheme = "http"
}
h, p, err := net.SplitHostPort(parsed.Host)
if err != nil {
h = parsed.Host
if scheme == "https" {
p = "443"
} else {
p = "80"
}
}
portInt, err := strconv.Atoi(p)
if err != nil || portInt <= 0 {
return "", 0, "", false
}
return h, portInt, scheme, true
}
// buildShellLine turns argv into a single shell-safe command line. It matches
// the semantics of the old hand-rolled path, which relied on envd's bash to
// resolve `python3` (or similar) against $PATH inside the sandbox image.
func buildShellLine(cmd string, args []string) string {
parts := make([]string, 0, len(args)+1)
parts = append(parts, shellQuote(cmd))
for _, a := range args {
parts = append(parts, shellQuote(a))
}
return strings.Join(parts, " ")
}
// wrapWithStdin funnels a caller-supplied stdin payload into the child
// process by prepending a heredoc. This keeps the SDK's Commands.Run contract
// (which does not take an explicit stdin argument) usable in the rare case
// callers actually need to pipe data.
func wrapWithStdin(line, stdin string) string {
// Use a heredoc delimiter unlikely to appear in caller data.
const delim = "WEKNORA_STDIN_EOF"
// Escape lines containing the delimiter defensively.
safe := strings.ReplaceAll(stdin, delim, "")
return "cat <<'" + delim + "' | " + line + "\n" + safe + "\n" + delim
}
// shellQuote wraps s in single quotes, escaping any embedded quotes. Suitable
// for building a /bin/bash -c line where every argv element should be treated
// as literal text.
func shellQuote(s string) string {
if s == "" {
return "''"
}
// Only bare tokens (alnum, dash, underscore, slash, dot, comma, colon,
// equals, plus) can be passed unquoted; everything else gets single
// quotes.
if isShellSafe(s) {
return s
}
return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}
func isShellSafe(s string) bool {
for _, r := range s {
switch {
case r >= 'a' && r <= 'z':
case r >= 'A' && r <= 'Z':
case r >= '0' && r <= '9':
case r == '-' || r == '_' || r == '/' || r == '.' || r == ',' ||
r == ':' || r == '=' || r == '+':
default:
return false
}
}
return true
}
func normalizeCubeState(state string) RemoteSandboxState {
switch strings.ToLower(strings.TrimSpace(state)) {
case "running", "available":
return RemoteStateRunning
case "paused":
return RemoteStatePaused
case "pending", "creating", "provisioning", "starting", "pausing", "resuming":
return RemoteStateTransitioning
case "killing", "killed", "terminated", "stopped", "deleted", "failed", "error":
return RemoteStateTerminal
default:
return RemoteStateUnknown
}
}
func cubeRemoteEntryType(entryType string) RemoteDirEntryType {
switch strings.ToLower(strings.TrimSpace(entryType)) {
case "file":
return RemoteEntryFile
case "directory", "dir":
return RemoteEntryDir
default:
return RemoteEntryOther
}
}
func cubeModTime(value string) time.Time {
for _, layout := range []string{time.RFC3339Nano, time.RFC3339} {
parsed, err := time.Parse(layout, value)
if err == nil {
return parsed
}
}
return time.Time{}
}
func StateMatches(candidate RemoteSandboxState, allowed []RemoteSandboxState) bool {
if len(allowed) == 0 {
return true
}
for _, state := range allowed {
if candidate == state {
return true
}
}
return false
}
func cubeInvalidRequest(op, message string, cause error) error {
return NewRemoteError(
SandboxTypeCube, op, RemoteErrorKindInvalidRequest, message, cause,
)
}
// normalizeCubeError projects a Cube-native error (SDK sentinel, APIError,
// net.Error, context cancellation) onto a RemoteError with a stable Kind. The
// original error is preserved via errors.Unwrap for diagnostics.
func normalizeCubeError(op string, err error) error {
if err == nil {
return nil
}
if errors.Is(err, context.Canceled) {
return fmt.Errorf("cube %s: %w", op, err)
}
kind := RemoteErrorKindInternal
switch {
case errors.Is(err, context.DeadlineExceeded):
kind = RemoteErrorKindTimeout
case errors.Is(err, cubesandbox.ErrAuthentication):
kind = RemoteErrorKindAuthentication
case errors.Is(err, cubesandbox.ErrTemplateNotFound):
kind = RemoteErrorKindInvalidRequest
case errors.Is(err, cubesandbox.ErrSandboxNotFound):
kind = RemoteErrorKindNotFound
default:
var pathNotFound *cubesandbox.NotFoundError
var apiErr *cubesandbox.APIError
var netErr net.Error
switch {
case errors.As(err, &pathNotFound):
kind = RemoteErrorKindNotFound
case errors.As(err, &apiErr):
kind = httpErrorKind(op, apiErr.StatusCode)
case errors.As(err, &netErr) && netErr.Timeout():
kind = RemoteErrorKindTimeout
case errors.As(err, &netErr):
kind = RemoteErrorKindUnavailable
}
}
return NewRemoteError(SandboxTypeCube, op, kind, err.Error(), err)
}
var (
_ RemoteSandboxClient = (*CubeRemoteClient)(nil)
_ RemoteSandboxHandle = (*cubeRemoteHandle)(nil)
)