feat(osi): 实现 OSI JSON 传输层（T-003）

osi/transport.go

@@ -0,0 +1,113 @@
+package osi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"golang.org/x/net/proxy"
+)
+
+type TransportConfig struct {
+	Timeout     time.Duration
+	Socks5Proxy string
+}
+
+type Transport struct {
+	client *http.Client
+}
+
+func NewTransport(config TransportConfig) (*Transport, error) {
+	timeout := config.Timeout
+	if timeout <= 0 {
+		timeout = 20 * time.Second
+	}
+
+	roundTripper := http.DefaultTransport.(*http.Transport).Clone()
+	if strings.TrimSpace(config.Socks5Proxy) != "" {
+		dialer, err := socks5Dialer(config.Socks5Proxy)
+		if err != nil {
+			return nil, err
+		}
+		roundTripper.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
+			if contextDialer, ok := dialer.(proxy.ContextDialer); ok {
+				return contextDialer.DialContext(ctx, network, address)
+			}
+			return dialer.Dial(network, address)
+		}
+	}
+
+	return &Transport{client: &http.Client{Timeout: timeout, Transport: roundTripper}}, nil
+}
+
+func (t *Transport) PostJSON(ctx context.Context, targetURL string, payload any, headers map[string]string) (int, []byte, error) {
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return 0, nil, fmt.Errorf("marshal json payload: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, bytes.NewReader(body))
+	if err != nil {
+		return 0, nil, fmt.Errorf("build request: %w", err)
+	}
+	for name, value := range headers {
+		req.Header.Set(name, value)
+	}
+	if req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	resp, err := t.client.Do(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	defer resp.Body.Close()
+
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp.StatusCode, nil, fmt.Errorf("read response body: %w", err)
+	}
+	return resp.StatusCode, raw, nil
+}
+
+func socks5Dialer(rawProxy string) (proxy.Dialer, error) {
+	proxyURL, err := normalizeSocks5Proxy(rawProxy)
+	if err != nil {
+		return nil, err
+	}
+
+	dialer, err := proxy.SOCKS5("tcp", proxyURL.Host, nil, proxy.Direct)
+	if err != nil {
+		return nil, fmt.Errorf("create socks5 dialer: %w", err)
+	}
+	return dialer, nil
+}
+
+func normalizeSocks5Proxy(rawProxy string) (*url.URL, error) {
+	rawProxy = strings.TrimSpace(rawProxy)
+	if !strings.Contains(rawProxy, "://") {
+		rawProxy = "socks5://" + rawProxy
+	}
+
+	proxyURL, err := url.Parse(rawProxy)
+	if err != nil {
+		return nil, fmt.Errorf("parse socks5 proxy: %w", err)
+	}
+	if proxyURL.Scheme != "socks5" && proxyURL.Scheme != "socks5h" {
+		return nil, fmt.Errorf("unsupported proxy scheme %q", proxyURL.Scheme)
+	}
+	if proxyURL.User != nil {
+		return nil, fmt.Errorf("socks5 proxy authentication is not supported yet")
+	}
+	if _, _, err := net.SplitHostPort(proxyURL.Host); err != nil {
+		return nil, fmt.Errorf("invalid socks5 proxy host %q: %w", proxyURL.Host, err)
+	}
+	return proxyURL, nil
+}

osi/transport_test.go

@@ -0,0 +1,79 @@
+package osi
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestTransportPostJSONSendsPayloadAndHeaders(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Fatalf("method = %s, want POST", r.Method)
+		}
+		if r.Header.Get("Content-Type") != "application/json" {
+			t.Fatalf("Content-Type = %q", r.Header.Get("Content-Type"))
+		}
+		if r.Header.Get("orgCode") != "org-001" {
+			t.Fatalf("orgCode = %q", r.Header.Get("orgCode"))
+		}
+		for _, name := range []string{"Cookie", "Origin", "Referer", "X-Requested-With"} {
+			if got := r.Header.Get(name); got != "" {
+				t.Fatalf("unexpected browser/cookie header %s=%q", name, got)
+			}
+		}
+
+		var payload map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			t.Fatalf("decode payload: %v", err)
+		}
+		if payload["serviceId"] != "JKDA00002" {
+			t.Fatalf("serviceId = %v", payload["serviceId"])
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusAccepted)
+		_, _ = w.Write([]byte(`{"code":"01"}`))
+	}))
+	defer server.Close()
+
+	transport, err := NewTransport(TransportConfig{Timeout: time.Second})
+	if err != nil {
+		t.Fatalf("NewTransport: %v", err)
+	}
+
+	status, raw, err := transport.PostJSON(
+		context.Background(),
+		server.URL,
+		map[string]any{"serviceId": "JKDA00002"},
+		map[string]string{"Content-Type": "application/json", "orgCode": "org-001"},
+	)
+	if err != nil {
+		t.Fatalf("PostJSON: %v", err)
+	}
+	if status != http.StatusAccepted {
+		t.Fatalf("status = %d, want %d", status, http.StatusAccepted)
+	}
+	if string(raw) != `{"code":"01"}` {
+		t.Fatalf("raw = %s", raw)
+	}
+}
+
+func TestNewTransportKeepsTimeout(t *testing.T) {
+	transport, err := NewTransport(TransportConfig{Timeout: 3 * time.Second})
+	if err != nil {
+		t.Fatalf("NewTransport: %v", err)
+	}
+	if transport.client.Timeout != 3*time.Second {
+		t.Fatalf("timeout = %s, want 3s", transport.client.Timeout)
+	}
+}
+
+func TestNewTransportRejectsInvalidSOCKS5Proxy(t *testing.T) {
+	if _, err := NewTransport(TransportConfig{Socks5Proxy: "missing-port"}); err == nil {
+		t.Fatal("NewTransport accepted invalid SOCKS5 proxy")
+	}
+}