refactor(sfcompute): use Brev integration API

go.mod

@@ -20,7 +20,6 @@ require (
 	github.com/nebius/gosdk v0.2.22
 	github.com/pkg/errors v0.9.1
 	github.com/sfcompute/nodes-go v0.1.0-alpha.4
-	github.com/sfcompute/sfc-go v0.1.0-preview.3
 	github.com/stretchr/testify v1.11.1
 	github.com/verda-cloud/verdacloud-sdk-go v1.4.2
 	golang.org/x/crypto v0.52.0
@@ -85,7 +84,6 @@ require (
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/spyzhov/ajson v0.8.0 // indirect
 	github.com/tidwall/gjson v1.18.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.1 // indirect

go.sum

@@ -156,16 +156,12 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/sfcompute/nodes-go v0.1.0-alpha.4 h1:oFBWcMPSpqLYm/NDs5I1jTvzgx9rsXDL9Ghsm30Hc0Q=
 github.com/sfcompute/nodes-go v0.1.0-alpha.4/go.mod h1:nUviHgK+Fgt2hDFcRL3M8VoyiypC8fc0dsY8C30QU8M=
-github.com/sfcompute/sfc-go v0.1.0-preview.3 h1:azKThmbm9ljQ+z8RP4039XwV4bJMTcYKNpKcxrpNf5A=
-github.com/sfcompute/sfc-go v0.1.0-preview.3/go.mod h1:SDgYqB2R6gFM+bzLBeF/Fb+J1HHaTlDuStSkiFuMWDU=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spyzhov/ajson v0.8.0 h1:sFXyMbi4Y/BKjrsfkUZHSjA2JM1184enheSjjoT/zCc=
-github.com/spyzhov/ajson v0.8.0/go.mod h1:63V+CGM6f1Bu/p4nLIN8885ojBdt88TbLoSFzyqMuVA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

v1/providers/sfcomputev2/api_client.go

@@ -0,0 +1,226 @@
+package v2
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const (
+	defaultAPIURL = "https://api.sfcompute.com"
+	brevAPIPath   = "/integrations/brev/v1"
+)
+
+type apiClient struct {
+	apiKey     string
+	baseURL    string
+	httpClient *http.Client
+}
+
+type createInstanceRequest struct {
+	Name                    *string           `json:"name,omitempty"`
+	Pool                    string            `json:"pool"`
+	Image                   string            `json:"image"`
+	InstanceSKU             string            `json:"instance_sku"`
+	CloudInitUserData       *string           `json:"cloud_init_user_data,omitempty"`
+	Tags                    map[string]string `json:"tags,omitempty"`
+	PreviewEnableInfiniband bool              `json:"_preview_enable_infiniband"`
+}
+
+type instanceStatus string
+
+const (
+	instanceStatusAwaitingAllocation instanceStatus = "awaiting_allocation"
+	instanceStatusRunning            instanceStatus = "running"
+	instanceStatusTerminated         instanceStatus = "terminated"
+	instanceStatusFailed             instanceStatus = "failed"
+)
+
+type instanceSKUSummary struct {
+	ID string `json:"id"`
+}
+
+type instanceResponse struct {
+	ID          string              `json:"id"`
+	Name        string              `json:"name"`
+	Status      instanceStatus      `json:"status"`
+	InstanceSKU *instanceSKUSummary `json:"instance_sku"`
+	CreatedAt   int64               `json:"created_at"`
+	Tags        map[string]string   `json:"tags"`
+}
+
+type listInstancesResponse struct {
+	Cursor  *string            `json:"cursor,omitempty"`
+	HasMore bool               `json:"has_more"`
+	Data    []instanceResponse `json:"data"`
+}
+
+type instanceSSHInfo struct {
+	Hostname string `json:"hostname"`
+	Port     int64  `json:"port"`
+}
+
+func (i *instanceSSHInfo) GetHostname() string {
+	if i == nil {
+		return ""
+	}
+	return i.Hostname
+}
+
+func (i *instanceSSHInfo) GetPort() int64 {
+	if i == nil {
+		return 0
+	}
+	return i.Port
+}
+
+type scheduleEntry struct {
+	StartAt   int64  `json:"start_at"`
+	EndAt     *int64 `json:"end_at"`
+	NodeCount int    `json:"node_count"`
+}
+
+type allocationSchedule struct {
+	ByInstanceSKU map[string][]scheduleEntry `json:"by_instance_sku"`
+}
+
+type poolResponse struct {
+	AllocationSchedule allocationSchedule `json:"allocation_schedule"`
+}
+
+type apiError struct {
+	statusCode int
+	body       string
+}
+
+func (e *apiError) Error() string {
+	return fmt.Sprintf("SFCompute API request failed: status %d: %s", e.statusCode, e.body)
+}
+
+func newAPIClient(apiKey string) *apiClient {
+	return &apiClient{
+		apiKey:     apiKey,
+		baseURL:    defaultAPIURL,
+		httpClient: &http.Client{Timeout: 60 * time.Second},
+	}
+}
+
+func (c *apiClient) createInstance(ctx context.Context, request createInstanceRequest) (*instanceResponse, error) {
+	var response instanceResponse
+	if err := c.do(ctx, http.MethodPost, "/instances", nil, request, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) getInstance(ctx context.Context, id string) (*instanceResponse, error) {
+	var response instanceResponse
+	if err := c.do(ctx, http.MethodGet, "/instances/"+url.PathEscape(id), nil, nil, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) listInstances(ctx context.Context, workspace, pool string) (*listInstancesResponse, error) {
+	query := url.Values{"workspace": {workspace}, "pool": {pool}, "limit": {"200"}}
+	var response listInstancesResponse
+	for {
+		var page listInstancesResponse
+		if err := c.do(ctx, http.MethodGet, "/instances", query, nil, &page); err != nil {
+			return nil, err
+		}
+		response.Data = append(response.Data, page.Data...)
+		response.Cursor = page.Cursor
+		response.HasMore = page.HasMore
+
+		if !page.HasMore {
+			return &response, nil
+		}
+		if page.Cursor == nil || *page.Cursor == "" {
+			return nil, fmt.Errorf("list instances response has_more without a cursor")
+		}
+		if query.Get("starting_after") == *page.Cursor {
+			return nil, fmt.Errorf("list instances response repeated cursor %q", *page.Cursor)
+		}
+		query.Set("starting_after", *page.Cursor)
+	}
+}
+
+func (c *apiClient) terminateInstance(ctx context.Context, id string) error {
+	var response instanceResponse
+	return c.do(ctx, http.MethodPost, "/instances/"+url.PathEscape(id)+"/terminate", nil, nil, &response)
+}
+
+func (c *apiClient) getSSHInfo(ctx context.Context, id string) (*instanceSSHInfo, error) {
+	var response instanceSSHInfo
+	if err := c.do(ctx, http.MethodGet, "/instances/"+url.PathEscape(id)+"/ssh", nil, nil, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) getPool(ctx context.Context, id string) (*poolResponse, error) {
+	var response poolResponse
+	if err := c.do(ctx, http.MethodGet, "/pools/"+url.PathEscape(id), nil, nil, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) do(
+	ctx context.Context,
+	method string,
+	path string,
+	query url.Values,
+	requestBody any,
+	responseBody any,
+) error {
+	var body io.Reader
+	if requestBody != nil {
+		encoded, err := json.Marshal(requestBody)
+		if err != nil {
+			return err
+		}
+		body = bytes.NewReader(encoded)
+	}
+
+	request, err := http.NewRequestWithContext(
+		ctx,
+		method,
+		strings.TrimRight(c.baseURL, "/")+brevAPIPath+path,
+		body,
+	)
+	if err != nil {
+		return err
+	}
+	request.URL.RawQuery = query.Encode()
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Authorization", "Bearer "+c.apiKey)
+	if requestBody != nil {
+		request.Header.Set("Content-Type", "application/json")
+	}
+
+	response, err := c.httpClient.Do(request)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = response.Body.Close() }()
+
+	responseBytes, err := io.ReadAll(response.Body)
+	if err != nil {
+		return err
+	}
+	if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
+		return &apiError{statusCode: response.StatusCode, body: string(responseBytes)}
+	}
+	if responseBody == nil || len(responseBytes) == 0 {
+		return nil
+	}
+	return json.Unmarshal(responseBytes, responseBody)
+}

v1/providers/sfcomputev2/api_client_test.go

@@ -0,0 +1,126 @@
+package v2
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAPIClientUsesBrevContract(t *testing.T) {
+	t.Parallel()
+
+	handler := http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		require.Equal(t, "Bearer api-key", request.Header.Get("Authorization"))
+
+		switch request.Method + " " + request.URL.Path {
+		case "POST /integrations/brev/v1/instances":
+			var body map[string]any
+			require.NoError(t, json.NewDecoder(request.Body).Decode(&body))
+			require.Equal(t, "sfc:pool:account:workspace:default", body["pool"])
+			require.Equal(t, "sfc:image:sfcompute:public:ubuntu", body["image"])
+			require.Equal(t, "is_sku", body["instance_sku"])
+			require.Equal(t, "cloud-init", body["cloud_init_user_data"])
+			tags, ok := body["tags"].(map[string]any)
+			require.True(t, ok)
+			require.Equal(t, "brev-ref", tags[tagKeyRefID])
+			require.Equal(t, false, body["_preview_enable_infiniband"])
+			writeJSON(t, writer, instanceResponse{ID: "inst_created", Status: instanceStatusAwaitingAllocation})
+		case "GET /integrations/brev/v1/instances":
+			require.Equal(t, "sfc:workspace:account:workspace", request.URL.Query().Get("workspace"))
+			require.Equal(t, []string{"sfc:pool:account:workspace:default"}, request.URL.Query()["pool"])
+			require.Equal(t, "200", request.URL.Query().Get("limit"))
+			if request.URL.Query().Get("starting_after") == "" {
+				writeJSON(t, writer, listInstancesResponse{
+					Cursor:  pointerTo("next-page"),
+					HasMore: true,
+					Data:    []instanceResponse{{ID: "inst_listed_1"}},
+				})
+				return
+			}
+			require.Equal(t, "next-page", request.URL.Query().Get("starting_after"))
+			writeJSON(t, writer, listInstancesResponse{Data: []instanceResponse{{ID: "inst_listed_2"}}})
+		case "GET /integrations/brev/v1/instances/inst_test":
+			writeJSON(t, writer, instanceResponse{ID: "inst_test", Status: instanceStatusRunning})
+		case "GET /integrations/brev/v1/instances/inst_test/ssh":
+			writeJSON(t, writer, instanceSSHInfo{Hostname: "192.0.2.1", Port: 22})
+		case "POST /integrations/brev/v1/instances/inst_test/terminate":
+			writeJSON(t, writer, instanceResponse{ID: "inst_test", Status: instanceStatusTerminated})
+		case "GET /integrations/brev/v1/pools/sfc:pool:account:workspace:default":
+			writeJSON(t, writer, poolResponse{AllocationSchedule: allocationSchedule{
+				ByInstanceSKU: map[string][]scheduleEntry{"is_sku": {{StartAt: 0, NodeCount: 1}}},
+			}})
+		default:
+			http.NotFound(writer, request)
+		}
+	})
+	server := httptest.NewServer(handler)
+	t.Cleanup(server.Close)
+
+	client := newAPIClient("api-key")
+	client.baseURL = server.URL
+	ctx := context.Background()
+
+	created, err := client.createInstance(ctx, createInstanceRequest{
+		Pool:              "sfc:pool:account:workspace:default",
+		Image:             "sfc:image:sfcompute:public:ubuntu",
+		InstanceSKU:       "is_sku",
+		CloudInitUserData: pointerTo("cloud-init"),
+		Tags:              map[string]string{tagKeyRefID: "brev-ref"},
+	})
+	require.NoError(t, err)
+	require.Equal(t, "inst_created", created.ID)
+
+	listed, err := client.listInstances(
+		ctx,
+		"sfc:workspace:account:workspace",
+		"sfc:pool:account:workspace:default",
+	)
+	require.NoError(t, err)
+	require.Equal(t, []instanceResponse{{ID: "inst_listed_1"}, {ID: "inst_listed_2"}}, listed.Data)
+
+	instance, err := client.getInstance(ctx, "inst_test")
+	require.NoError(t, err)
+	require.Equal(t, instanceStatusRunning, instance.Status)
+
+	sshInfo, err := client.getSSHInfo(ctx, "inst_test")
+	require.NoError(t, err)
+	require.Equal(t, "192.0.2.1", sshInfo.Hostname)
+
+	require.NoError(t, client.terminateInstance(ctx, "inst_test"))
+
+	pool, err := client.getPool(ctx, "sfc:pool:account:workspace:default")
+	require.NoError(t, err)
+	require.Equal(t, 1, pool.AllocationSchedule.ByInstanceSKU["is_sku"][0].NodeCount)
+}
+
+func TestAPIClientReturnsResponseErrors(t *testing.T) {
+	t.Parallel()
+
+	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
+		http.Error(writer, `{"error":"not found"}`, http.StatusNotFound)
+	}))
+	t.Cleanup(server.Close)
+
+	client := newAPIClient("api-key")
+	client.baseURL = server.URL
+
+	_, err := client.getInstance(context.Background(), "inst_missing")
+	var responseError *apiError
+	require.ErrorAs(t, err, &responseError)
+	require.Equal(t, http.StatusNotFound, responseError.statusCode)
+	require.Contains(t, responseError.body, "not found")
+}
+
+func writeJSON(t *testing.T, writer http.ResponseWriter, value any) {
+	t.Helper()
+	writer.Header().Set("Content-Type", "application/json")
+	require.NoError(t, json.NewEncoder(writer).Encode(value))
+}
+
+func pointerTo[T any](value T) *T {
+	return &value
+}