feat(multiplayer): refresh allocator ready servers

server/agones/allocation.go

@@ -52,6 +52,68 @@ type allocationResponse struct {
 	} `json:"status"`
 }
 
+type gameServerListResponse struct {
+	Items []struct {
+		Metadata struct {
+			Name   string            `json:"name"`
+			Labels map[string]string `json:"labels"`
+		} `json:"metadata"`
+		Status struct {
+			State string `json:"state"`
+		} `json:"status"`
+	} `json:"items"`
+}
+
+// ListReadyServers projects only Agones Ready GameServers into the durable
+// allocator registry. Compatibility fields must be present as Fleet labels;
+// malformed Ready objects fail closed instead of creating selectable capacity.
+func (c Client) ListReadyServers(ctx context.Context) ([]domain.ReadyServer, error) {
+	if c.HTTP == nil {
+		c.HTTP = http.DefaultClient
+	}
+	base, err := c.endpoint()
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, base+"/apis/agones.dev/v1/namespaces/"+url.PathEscape(c.Namespace)+"/gameservers", nil)
+	if err != nil {
+		return nil, err
+	}
+	response, err := c.HTTP.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return nil, fmt.Errorf("Agones GameServer list returned %s", response.Status)
+	}
+	var decoded gameServerListResponse
+	if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&decoded); err != nil {
+		return nil, fmt.Errorf("decode Agones GameServer list: %w", err)
+	}
+	ready := make([]domain.ReadyServer, 0, len(decoded.Items))
+	for _, item := range decoded.Items {
+		if item.Status.State != "Ready" {
+			continue
+		}
+		server, err := readyServerFromGameServer(item.Metadata.Name, item.Metadata.Labels)
+		if err != nil {
+			return nil, err
+		}
+		ready = append(ready, server)
+	}
+	return ready, nil
+}
+
+func readyServerFromGameServer(name string, labels map[string]string) (domain.ReadyServer, error) {
+	protocol, err := strconv.Atoi(labels["cosmic-clash.io/protocol"])
+	server := domain.ReadyServer{ServerID: name, Region: labels["cosmic-clash.io/region"], Build: labels["cosmic-clash.io/build"], Protocol: protocol, Transport: labels["cosmic-clash.io/transport"], State: domain.ServerReady}
+	if err != nil || server.ServerID == "" || (server.Region != "EU" && server.Region != "NA") || server.Build == "" || server.Protocol < 1 || (server.Transport != "enet" && server.Transport != "steam_sdr") {
+		return domain.ReadyServer{}, fmt.Errorf("invalid Ready GameServer compatibility labels")
+	}
+	return server, nil
+}
+
 func (c Client) Allocate(ctx context.Context, request domain.AllocationRequest, labels map[string]string, now time.Time) (AllocatedServer, error) {
 	if c.HTTP == nil {
 		c.HTTP = http.DefaultClient

server/agones/allocation_test.go

@@ -70,3 +70,27 @@ func TestAllocateRejectsUnsafeConfigurationAndProviderFailure(t *testing.T) {
 		t.Fatalf("provider failure err=%v", err)
 	}
 }
+
+func TestListReadyServersProjectsOnlyStrictReadyFleetMembers(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet || r.URL.Path != "/apis/agones.dev/v1/namespaces/games/gameservers" {
+			t.Fatalf("request=%s %s", r.Method, r.URL.Path)
+		}
+		_, _ = w.Write([]byte(`{"items":[{"metadata":{"name":"ready-a","labels":{"cosmic-clash.io/region":"EU","cosmic-clash.io/build":"build-1","cosmic-clash.io/protocol":"1","cosmic-clash.io/transport":"enet"}},"status":{"state":"Ready"}},{"metadata":{"name":"allocated-a","labels":{}},"status":{"state":"Allocated"}}]}`))
+	}))
+	defer server.Close()
+	ready, err := (Client{BaseURL: server.URL, Namespace: "games", HTTP: server.Client()}).ListReadyServers(context.Background())
+	if err != nil || len(ready) != 1 || ready[0] != (domain.ReadyServer{ServerID: "ready-a", Region: "EU", Build: "build-1", Protocol: 1, Transport: "enet", State: domain.ServerReady}) {
+		t.Fatalf("ready=%+v err=%v", ready, err)
+	}
+}
+
+func TestListReadyServersFailsClosedOnInvalidReadyCompatibility(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`{"items":[{"metadata":{"name":"ready-a","labels":{"cosmic-clash.io/region":"EU","cosmic-clash.io/build":"build-1","cosmic-clash.io/protocol":"bad","cosmic-clash.io/transport":"enet"}},"status":{"state":"Ready"}}]}`))
+	}))
+	defer server.Close()
+	if _, err := (Client{BaseURL: server.URL, Namespace: "games", HTTP: server.Client()}).ListReadyServers(context.Background()); err == nil {
+		t.Fatal("invalid Ready GameServer accepted")
+	}
+}