Initial project snapshot

2026-04-28 22:29:50 +03:00
commit 8ba0561f4f
365 changed files with 91832 additions and 0 deletions
@@ -0,0 +1,186 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/example/remote-access-platform/agents/rap-node-agent/internal/mesh"
+)
+
+type smokeNode struct {
+	Local   mesh.PeerIdentity
+	Runtime *mesh.SyntheticRuntime
+	URL     string
+	server  *httptest.Server
+}
+
+type smokeReport struct {
+	Stage                  string         `json:"stage"`
+	ProductionForwarding   bool           `json:"production_forwarding"`
+	ScopedConfigLoaded     bool           `json:"scoped_config_loaded"`
+	DirectProbeAccepted    bool           `json:"direct_probe_accepted"`
+	DirectPath             []string       `json:"direct_path"`
+	RelayProbeAccepted     bool           `json:"relay_probe_accepted"`
+	RelayPath              []string       `json:"relay_path"`
+	TestServiceAccepted    bool           `json:"test_service_accepted"`
+	TestServiceEchoPayload string         `json:"test_service_echo_payload"`
+	PeerEndpoints          map[string]any `json:"peer_endpoints"`
+}
+
+func main() {
+	report, err := run(context.Background())
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "mesh live smoke failed: %v\n", err)
+		os.Exit(1)
+	}
+	payload, err := json.MarshalIndent(report, "", "  ")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "marshal report: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Println(string(payload))
+}
+
+func run(ctx context.Context) (smokeReport, error) {
+	nodeA := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-a"})
+	defer nodeA.Close()
+	nodeR := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-r"})
+	defer nodeR.Close()
+	nodeB := newSmokeNode(mesh.PeerIdentity{ClusterID: "cluster-1", NodeID: "node-b"})
+	defer nodeB.Close()
+
+	directRoute := smokeRoute("route-direct", []string{"node-a", "node-b"})
+	relayRoute := smokeRoute("route-relay", []string{"node-a", "node-r", "node-b"})
+	routes := []mesh.SyntheticRoute{directRoute, relayRoute}
+	nodeAConfigPath, err := writeSmokeScopedConfig(nodeA.Local, map[string]string{
+		"node-r": nodeR.URL,
+		"node-b": nodeB.URL,
+	}, routes)
+	if err != nil {
+		return smokeReport{}, err
+	}
+	nodeAConfig, err := mesh.LoadScopedSyntheticConfig(nodeAConfigPath, nodeA.Local)
+	if err != nil {
+		return smokeReport{}, fmt.Errorf("load node-a scoped config: %w", err)
+	}
+
+	nodeA.Runtime = smokeRuntime(nodeA.Local, nodeAConfig.Routes, nodeAConfig.PeerEndpoints)
+	nodeR.Runtime = smokeRuntime(nodeR.Local, routes, map[string]string{
+		"node-b": nodeB.URL,
+	})
+	nodeB.Runtime = smokeRuntime(nodeB.Local, routes, map[string]string{})
+
+	directAck, err := nodeA.Runtime.SendProbe(ctx, directRoute.RouteID, mesh.SyntheticChannelFabricControl, "smoke-direct")
+	if err != nil {
+		return smokeReport{}, fmt.Errorf("direct probe: %w", err)
+	}
+	relayAck, err := nodeA.Runtime.SendProbe(ctx, relayRoute.RouteID, mesh.SyntheticChannelFabricControl, "smoke-relay")
+	if err != nil {
+		return smokeReport{}, fmt.Errorf("relay probe: %w", err)
+	}
+	testService, err := nodeA.Runtime.SendTestService(ctx, relayRoute.RouteID, mesh.SyntheticChannelRouteControl, mesh.SyntheticTestServiceRequest{
+		RequestID:      "smoke-test-service",
+		OrganizationID: mesh.SyntheticDefaultTestOrganizationID,
+		ServiceType:    mesh.SyntheticTestServiceType,
+		Payload:        "hello-c17e",
+		SentAt:         time.Now().UTC(),
+	})
+	if err != nil {
+		return smokeReport{}, fmt.Errorf("test service: %w", err)
+	}
+
+	return smokeReport{
+		Stage:                  "C17F scoped synthetic config plus live HTTP transport",
+		ProductionForwarding:   false,
+		ScopedConfigLoaded:     nodeAConfig.ConfigVersion == "smoke-config-v1",
+		DirectProbeAccepted:    directAck.MessageType == mesh.SyntheticMessageProbeAck,
+		DirectPath:             decodeProbePath(directAck),
+		RelayProbeAccepted:     relayAck.MessageType == mesh.SyntheticMessageProbeAck,
+		RelayPath:              decodeProbePath(relayAck),
+		TestServiceAccepted:    testService.Ack.MessageType == mesh.SyntheticMessageTestServiceAck,
+		TestServiceEchoPayload: testService.Response.EchoPayload,
+		PeerEndpoints: map[string]any{
+			"node-a": nodeA.URL,
+			"node-r": nodeR.URL,
+			"node-b": nodeB.URL,
+		},
+	}, nil
+}
+
+func writeSmokeScopedConfig(local mesh.PeerIdentity, peers map[string]string, routes []mesh.SyntheticRoute) (string, error) {
+	path := filepath.Join(os.TempDir(), "rap-c17e-node-a-scoped-mesh.json")
+	payload, err := json.Marshal(mesh.ScopedSyntheticConfig{
+		SchemaVersion:        "c17f.synthetic.v1",
+		ClusterID:            local.ClusterID,
+		LocalNodeID:          local.NodeID,
+		ConfigVersion:        "smoke-config-v1",
+		PeerDirectoryVersion: "smoke-peers-v1",
+		PolicyVersion:        "smoke-policy-v1",
+		PeerEndpoints:        peers,
+		Routes:               routes,
+	})
+	if err != nil {
+		return "", err
+	}
+	if err := os.WriteFile(path, payload, 0o600); err != nil {
+		return "", err
+	}
+	return path, nil
+}
+
+func newSmokeNode(local mesh.PeerIdentity) *smokeNode {
+	node := &smokeNode{Local: local}
+	node.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mesh.Server{Local: node.Local, SyntheticRuntime: node.Runtime}.Handler().ServeHTTP(w, r)
+	}))
+	node.URL = node.server.URL
+	return node
+}
+
+func (n *smokeNode) Close() {
+	if n.server != nil {
+		n.server.Close()
+	}
+}
+
+func smokeRuntime(local mesh.PeerIdentity, routes []mesh.SyntheticRoute, peers map[string]string) *mesh.SyntheticRuntime {
+	return mesh.NewSyntheticRuntime(mesh.SyntheticRuntimeConfig{
+		Enabled: true,
+		Local:   local,
+		Routes:  routes,
+		AllowedChannels: []string{
+			mesh.SyntheticChannelFabricControl,
+			mesh.SyntheticChannelRouteControl,
+		},
+		Transport: mesh.NewHTTPPeerTransport(peers),
+	})
+}
+
+func smokeRoute(routeID string, hops []string) mesh.SyntheticRoute {
+	return mesh.SyntheticRoute{
+		RouteID:              routeID,
+		ClusterID:            "cluster-1",
+		SourceNodeID:         hops[0],
+		DestinationNodeID:    hops[len(hops)-1],
+		Hops:                 hops,
+		AllowedChannels:      []string{mesh.SyntheticChannelFabricControl, mesh.SyntheticChannelRouteControl},
+		MaxTTL:               8,
+		MaxHops:              8,
+		ExpiresAt:            time.Now().UTC().Add(time.Hour),
+		RouteVersion:         "route-v1",
+		PolicyVersion:        "policy-v1",
+		PeerDirectoryVersion: "peers-v1",
+	}
+}
+
+func decodeProbePath(envelope mesh.SyntheticEnvelope) []string {
+	var payload mesh.SyntheticProbeAckPayload
+	_ = json.Unmarshal(envelope.Payload, &payload)
+	return payload.Path
+}