fix(rest): csi-sanity unblockers — int64 ret_code, /v1/remotes/* stubs

Two regressions surfaced by csi-sanity:

1. APICallRc.RetCode was uint64. golinstor decodes it as int64;
   our 0xC000_0000_0000_0000 (= 13835058055282163712 unsigned) didn't
   fit. Switch to int64 with the negative two's-complement wire shape
   that upstream Java actually emits.

2. golinstor's snapshot-list path probes /v1/remotes/s3 first; a 404
   surfaced as 'failed to list available s3 remotes'. Add
   /v1/remotes(/s3|/linstor|/ebs) returning [] — cozystack doesn't
   do cross-cluster shipping, but we owe the empty-list shape so
   golinstor stops choking.

server.Start refactored into Start + buildMux to stay under funlen.

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: Andrei Kvapil <kvapss@gmail.com>

Author: kvaps

pkg/api/v1/storage_pool.go

@@ -36,7 +36,11 @@ type StoragePool struct {
 // APICallRc is the upstream `ApiCallRc` envelope. We define a minimal subset
 // here so types compile. Phase 2 will populate it from `golinstor` apiconsts.
 type APICallRc struct {
-	RetCode  uint64            `json:"ret_code"`
+	// RetCode is the LINSTOR-style status mask. golinstor's
+	// `client.ApiCallError` decodes this as int64; the upstream
+	// `MASK_ERROR` bit makes the value negative on the wire (the
+	// high bit of a signed int64), so we use int64 to match.
+	RetCode  int64             `json:"ret_code"`
 	Message  string            `json:"message,omitempty"`
 	Cause    string            `json:"cause,omitempty"`
 	Details  string            `json:"details,omitempty"`

pkg/rest/nodes.go

@@ -175,6 +175,8 @@ func writeError(w http.ResponseWriter, status int, msg string) {
 	}})
 }
 
-// apiCallRcError is upstream LINSTOR's ERROR mask (high bit set on a
-// 64-bit mask). golinstor checks for this bit to decide pass/fail.
-const apiCallRcError uint64 = 0xC000_0000_0000_0000
+// apiCallRcError carries upstream LINSTOR's MASK_ERROR + WARN bits.
+// Upstream uses 0xC000_0000_0000_0000 as a `long` literal — that's
+// a negative int64 once you set both top bits. We literal-cast to
+// match the wire shape golinstor expects.
+const apiCallRcError int64 = -0x4000_0000_0000_0000

pkg/rest/remotes.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2026 Cozystack contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package rest
+
+import (
+	"net/http"
+)
+
+// registerRemotes wires the LINSTOR `remotes` endpoints. Cozystack
+// doesn't use cross-cluster snapshot shipping, so the typed-by-kind
+// stubs return empty arrays — golinstor's snapshot list path calls
+// `/v1/remotes/s3` before enumerating snapshots, and a 404 there
+// surfaces as `failed to list available s3 remotes` from linstor-csi.
+//
+// Empty `[]` keeps the wire format LINSTOR-shaped without exposing
+// any remote-shipping surface area we don't implement.
+func (s *Server) registerRemotes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /v1/remotes", handleEmptyArray)
+	mux.HandleFunc("GET /v1/remotes/s3", handleEmptyArray)
+	mux.HandleFunc("GET /v1/remotes/linstor", handleEmptyArray)
+	mux.HandleFunc("GET /v1/remotes/ebs", handleEmptyArray)
+}
+
+func handleEmptyArray(w http.ResponseWriter, _ *http.Request) {
+	writeJSON(w, http.StatusOK, []map[string]string{})
+}

pkg/rest/server.go

@@ -54,32 +54,7 @@ func (s *Server) NeedLeaderElection() bool { return false }
 func (s *Server) Start(ctx context.Context) error {
 	logger := log.FromContext(ctx).WithName("rest")
 
-	mux := http.NewServeMux()
-	mux.HandleFunc("GET /v1/controller/version", handleVersion)
-	mux.HandleFunc("GET /v1/healthz", handleHealth)
-	s.registerNodes(mux)
-	s.registerStoragePools(mux)
-	s.registerResourceGroups(mux)
-	s.registerResourceDefinitions(mux)
-	s.registerVolumeDefinitions(mux)
-	s.registerResources(mux)
-	s.registerKeyValueStore(mux)
-	s.registerSnapshots(mux)
-	s.registerSpawn(mux)
-	s.registerAutoplace(mux)
-	s.registerControllerProperties(mux)
-	s.registerAdjust(mux)
-	s.registerStats(mux)
-	s.registerErrorReports(mux)
-	s.registerPropertiesInfo(mux)
-	s.registerSnapshotRestore(mux)
-	s.registerEncryption(mux)
-	s.registerNodeLifecycle(mux)
-	s.registerDRBDProxy(mux)
-	s.registerExternalFiles(mux)
-	s.registerDRBDPassphrase(mux)
-	s.registerRDClone(mux)
-	s.registerSOSReport(mux)
+	mux := s.buildMux()
 
 	srv := &http.Server{
 		Addr:              s.Addr,
@@ -114,6 +89,41 @@ func (s *Server) Start(ctx context.Context) error {
 	}
 }
 
+// buildMux registers every endpoint on a fresh ServeMux. Pulled out
+// of Start to keep the latter under the funlen budget — Start now
+// only handles lifecycle (listener + shutdown), this owns routing.
+func (s *Server) buildMux() *http.ServeMux {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /v1/controller/version", handleVersion)
+	mux.HandleFunc("GET /v1/healthz", handleHealth)
+	s.registerNodes(mux)
+	s.registerStoragePools(mux)
+	s.registerResourceGroups(mux)
+	s.registerResourceDefinitions(mux)
+	s.registerVolumeDefinitions(mux)
+	s.registerResources(mux)
+	s.registerKeyValueStore(mux)
+	s.registerSnapshots(mux)
+	s.registerSpawn(mux)
+	s.registerAutoplace(mux)
+	s.registerControllerProperties(mux)
+	s.registerAdjust(mux)
+	s.registerStats(mux)
+	s.registerErrorReports(mux)
+	s.registerPropertiesInfo(mux)
+	s.registerSnapshotRestore(mux)
+	s.registerEncryption(mux)
+	s.registerNodeLifecycle(mux)
+	s.registerDRBDProxy(mux)
+	s.registerExternalFiles(mux)
+	s.registerDRBDPassphrase(mux)
+	s.registerRDClone(mux)
+	s.registerSOSReport(mux)
+	s.registerRemotes(mux)
+
+	return mux
+}
+
 // Compile-time check that we satisfy the runnable contract.
 var _ manager.Runnable = (*Server)(nil)