chore: 初始开源发布

iotlcm-worker-svr：异步执行中枢（RabbitMQ 消费者 + 全量同步编排）。 - Go module：iotlcm-worker-svr → git.5iot.com/iotlcm-public/iotlcm-worker-svr（214 文件） - 凭据与内部标识脱敏：MySQL/Redis 凭据、私网与生产 IP、内网域名、库名 xiujie_admin → iotlcm、哨兵名占位 - 159 处真实手机号 → 合法 11 位编造号（保留号段与后 4 位，维持互异，不破坏「校验 MSISDN 格式」等测试断言） - 移除内部资产：CI 触发器、Jenkins 触发测试文档、预演门禁与镜像 digest 记录 - Dockerfile 改用公共基础镜像（golang:1.25-alpine → alpine:3.23），移除写死的 git 凭据 - README 重写（架构/全量同步模型/配置/已知失败），补 Apache-2.0 LICENSE，LF 行尾 + .gitattributes 已知：3 个测试包在源仓同一提交上同样失败（client/upstream、 service/allocate、service/inbound），属既有缺陷，本仓未引入亦未修复。
2026-10-22 16:37:56 +08:00
commit 2bec257289
361 changed files with 71524 additions and 0 deletions
@@ -0,0 +1,274 @@
+package zset
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gvar"
+)
+
+type redisCall struct {
+	command string
+	args    []any
+}
+
+type fakeRedis struct {
+	calls     []redisCall
+	responses []*gvar.Var
+	err       error
+}
+
+func (f *fakeRedis) Do(_ context.Context, command string, args ...any) (*gvar.Var, error) {
+	f.calls = append(f.calls, redisCall{command: command, args: args})
+	if f.err != nil {
+		return nil, f.err
+	}
+	if len(f.responses) == 0 {
+		return gvar.New(int64(1)), nil
+	}
+	response := f.responses[0]
+	f.responses = f.responses[1:]
+	return response, nil
+}
+
+func (f *fakeRedis) Eval(_ context.Context, script string, numKeys int64, keys []string, args []any) (*gvar.Var, error) {
+	allArgs := []any{script, numKeys}
+	for _, k := range keys {
+		allArgs = append(allArgs, k)
+	}
+	allArgs = append(allArgs, args...)
+	f.calls = append(f.calls, redisCall{command: "EVAL", args: allArgs})
+	if f.err != nil {
+		return nil, f.err
+	}
+	if len(f.responses) == 0 {
+		return gvar.New(int64(1)), nil
+	}
+	response := f.responses[0]
+	f.responses = f.responses[1:]
+	return response, nil
+}
+
+func TestStoreUsesContractKeys(t *testing.T) {
+	store, err := New(&fakeRedis{}, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	key, err := store.Key("mobile-a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if key != "flow:mobile-a" {
+		t.Fatalf("task key = %q, want flow:mobile-a", key)
+	}
+	lease, err := store.leaseKey("mobile-a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease != "flow:lease:mobile-a" {
+		t.Fatalf("lease key = %q, want flow:lease:mobile-a", lease)
+	}
+	if got := store.ChannelsKey(); got != "flow:channels" {
+		t.Fatalf("channels key = %q, want flow:channels", got)
+	}
+}
+
+func TestStableTaskID(t *testing.T) {
+	if got := StableTaskID("run-1", "current_month_usage", 42); got != "run-1:current_month_usage:42" {
+		t.Fatalf("stable task id = %q", got)
+	}
+}
+
+func TestRunKeysShareRedisHashTag(t *testing.T) {
+	store, err := New(&fakeRedis{}, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	keys := []func() (string, error){
+		func() (string, error) { return store.RunMetaKey("run-1") },
+		func() (string, error) { return store.RoundActiveKey("run-1", 1, "mobile-a") },
+		func() (string, error) { return store.RoundWaitingKey("run-1", 2, "mobile-a") },
+		func() (string, error) { return store.RoundLeaseKey("run-1", 1, "mobile-a") },
+		func() (string, error) { return store.TaskStateKey("run-1") },
+		func() (string, error) { return store.FailedKey("run-1") },
+	}
+	for _, build := range keys {
+		key, err := build()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(key, "flow:{run-1}") {
+			t.Fatalf("run key %q does not contain hash tag", key)
+		}
+	}
+}
+
+func TestEnqueueMemberExcludesSchedulingScore(t *testing.T) {
+	fake := &fakeRedis{responses: []*gvar.Var{gvar.New(int64(1))}}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := Task{TaskID: "run:current_month_usage:1", ChanKey: "mobile-a", CardID: 1}
+	if err = store.Enqueue(context.Background(), task, time.UnixMilli(1234)); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.calls) != 1 || fake.calls[0].command != "EVAL" {
+		t.Fatalf("Redis calls = %+v", fake.calls)
+	}
+	member, ok := fake.calls[0].args[len(fake.calls[0].args)-1].(string)
+	if !ok {
+		t.Fatalf("member type = %T", fake.calls[0].args[len(fake.calls[0].args)-1])
+	}
+	if strings.Contains(member, "nextExecuteAt") {
+		t.Fatalf("member contains volatile score: %s", member)
+	}
+}
+
+func TestClaimDecodesMemberAndUsesLeaseKey(t *testing.T) {
+	task := Task{
+		TaskID:     "run-1:current_month_usage:42",
+		RunID:      "run-1",
+		Operation:  "current_month_usage",
+		QueryMonth: "202608",
+		ChanKey:    "mobile-a",
+		CardID:     42,
+		ICCID:      "8986000000000042",
+	}
+	member, err := json.Marshal(task)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fake := &fakeRedis{responses: []*gvar.Var{gvar.New([]any{string(member), "worker:token"})}}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	now := time.UnixMilli(1000)
+	leaseUntil := now.Add(time.Minute)
+	claimed, err := store.Claim(context.Background(), "mobile-a", now, leaseUntil, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(claimed) != 1 || claimed[0].Task.TaskID != task.TaskID {
+		t.Fatalf("claimed tasks = %+v", claimed)
+	}
+	if claimed[0].LeaseToken != "worker:token" {
+		t.Fatalf("lease token = %q", claimed[0].LeaseToken)
+	}
+	if len(fake.calls) != 1 || fake.calls[0].command != "EVAL" {
+		t.Fatalf("Redis calls = %+v", fake.calls)
+	}
+	args := fake.calls[0].args
+	if len(args) < 4 || args[3] != "flow:lease:mobile-a" {
+		t.Fatalf("claim args do not use lease key: %+v", args)
+	}
+}
+
+func TestAckBatchUsesLuaOwnershipProtocol(t *testing.T) {
+	fake := &fakeRedis{}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	claimed := ClaimedTask{
+		Task:       Task{TaskID: "run:current_month_usage:1", ChanKey: "mobile-a", CardID: 1},
+		Member:     `{"taskId":"run:current_month_usage:1","chanKey":"mobile-a","cardId":1}`,
+		LeaseToken: "token-1",
+	}
+	count, err := store.AckBatch(context.Background(), []ClaimedTask{claimed})
+	if err != nil || count != 1 {
+		t.Fatalf("ack count = %d, err = %v", count, err)
+	}
+	renewed, err := store.Renew(context.Background(), claimed, time.Now().Add(time.Minute))
+	if err != nil || !renewed {
+		t.Fatalf("renew = %t, err = %v", renewed, err)
+	}
+	if len(fake.calls) != 2 {
+		t.Fatalf("Redis calls = %d, want 2", len(fake.calls))
+	}
+	for _, call := range fake.calls {
+		if call.command != "EVAL" {
+			t.Fatalf("command = %q, want EVAL", call.command)
+		}
+		script, ok := call.args[0].(string)
+		if !ok || !strings.Contains(script, "HGET") {
+			t.Fatalf("Lua script does not validate ownership: %v", call.args[0])
+		}
+	}
+}
+
+func TestRenewBatchUsesOneAtomicLuaCall(t *testing.T) {
+	fake := &fakeRedis{responses: []*gvar.Var{gvar.New(int64(2))}}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tasks := []ClaimedTask{
+		{Task: Task{ChanKey: "mobile-a"}, Member: "member-1", LeaseToken: "token-1"},
+		{Task: Task{ChanKey: "mobile-a"}, Member: "member-2", LeaseToken: "token-2"},
+	}
+	count, err := store.RenewBatch(context.Background(), tasks, time.UnixMilli(5000))
+	if err != nil || count != 2 {
+		t.Fatalf("RenewBatch() = %d, err = %v", count, err)
+	}
+	if len(fake.calls) != 1 || fake.calls[0].command != "EVAL" {
+		t.Fatalf("Redis calls = %+v, want one EVAL", fake.calls)
+	}
+	script := fake.calls[0].args[0].(string)
+	if !strings.Contains(script, "HGET") || !strings.Contains(script, "ZSCORE") {
+		t.Fatalf("renew script does not validate all leases: %s", script)
+	}
+}
+
+func TestEnqueueBatchRegistersChannelAndWritesTasksOnce(t *testing.T) {
+	fake := &fakeRedis{responses: []*gvar.Var{gvar.New(int64(2))}}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tasks := []Task{
+		{TaskID: "run:usage:1", RunID: "run", ChanKey: "mobile-a", CardID: 1},
+		{TaskID: "run:usage:2", RunID: "run", ChanKey: "mobile-a", CardID: 2},
+	}
+	added, err := store.EnqueueBatch(context.Background(), "mobile-a", tasks, time.UnixMilli(1234))
+	if err != nil || added != 2 {
+		t.Fatalf("EnqueueBatch() = %d, err = %v", added, err)
+	}
+	if len(fake.calls) != 1 || fake.calls[0].command != "EVAL" {
+		t.Fatalf("Redis calls = %+v, want one EVAL", fake.calls)
+	}
+	if fake.calls[0].args[2] != "flow:mobile-a" || fake.calls[0].args[3] != "flow:channels" || fake.calls[0].args[4] != "flow:blocked:mobile-a" {
+		t.Fatalf("batch keys = %+v", fake.calls[0].args)
+	}
+}
+
+func TestEnqueueBatchRejectsMixedChannels(t *testing.T) {
+	store, err := New(&fakeRedis{}, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = store.EnqueueBatch(context.Background(), "mobile-a", []Task{{TaskID: "1", RunID: "run", ChanKey: "mobile-b"}}, time.Now())
+	if err == nil {
+		t.Fatal("expected mixed channel batch error")
+	}
+}
+
+func TestBlockRunUsesTaskLeaseAndBlockedKeys(t *testing.T) {
+	fake := &fakeRedis{responses: []*gvar.Var{gvar.New(int64(7))}}
+	store, err := New(fake, "flow:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	removed, err := store.BlockRun(context.Background(), "telecom-a", "run-1")
+	if err != nil || removed != 7 {
+		t.Fatalf("BlockRun() = %d, err = %v", removed, err)
+	}
+	args := fake.calls[0].args
+	if args[2] != "flow:telecom-a" || args[3] != "flow:lease:telecom-a" || args[4] != "flow:blocked:telecom-a" {
+		t.Fatalf("block keys = %+v", args)
+	}
+}