Update version to v3.8.3-patch.14

refactor: simplify platformID handling and enhance UserConnContext structure

.env

@@ -1,6 +1,6 @@
 MONGO_IMAGE=mongo:7.0
 REDIS_IMAGE=redis:7.0.0
-KAFKA_IMAGE=bitnami/kafka:3.5.1
+KAFKA_IMAGE=bitnamilegacy/kafka:3.5.1
 MINIO_IMAGE=minio/minio:RELEASE.2024-01-11T07-46-16Z
 ETCD_IMAGE=quay.io/coreos/etcd:v3.5.13
 PROMETHEUS_IMAGE=prom/prometheus:v2.45.6
@@ -22,4 +22,5 @@ MONGO_BACKUP_DIR=${DATA_DIR}components/backup/mongo/
 PROMETHEUS_PORT=19091
 ALERTMANAGER_PORT=19093
 GRAFANA_PORT=13000
+
 NODE_EXPORTER_PORT=19100

.github/workflows/go-build-test.yml

@@ -92,12 +92,13 @@ jobs:
       contents: write
     env:
       SDK_DIR: openim-sdk-core
-      CONFIG_PATH: config/notification.yml
+      NOTIFICATION_CONFIG_PATH: config/notification.yml
-    #   pull-requests: write
+      SHARE_CONFIG_PATH: config/share.yml
+
     strategy:
       matrix:
-        os: [ ubuntu-latest ]
+        os: [ubuntu-latest]
-        go_version: [ "1.22.x" ]
+        go_version: ["1.22.x"]
 
     steps:
       - name: Checkout Server repository
@@ -106,7 +107,8 @@ jobs:
       - name: Checkout SDK repository
         uses: actions/checkout@v4
         with:
-          repository: 'openimsdk/openim-sdk-core'
+          repository: "openimsdk/openim-sdk-core"
+          ref: "main"
           path: ${{ env.SDK_DIR }}
 
       - name: Set up Go ${{ matrix.go_version }}
@@ -119,15 +121,11 @@ jobs:
           go install github.com/magefile/mage@latest
           go mod download
 
-      - name: Install yq
-        run: |
-          sudo wget https://github.com/mikefarah/yq/releases/download/v4.34.1/yq_linux_amd64 -O /usr/bin/yq
-          sudo chmod +x /usr/bin/yq
-
       - name: Modify Server Configuration
         run: |
-          yq e '.groupCreated.unreadCount = true' -i ${{ env.CONFIG_PATH }}
+          yq e '.groupCreated.isSendMsg = true' -i ${{ env.NOTIFICATION_CONFIG_PATH }}
-          yq e '.friendApplicationApproved.unreadCount = true' -i ${{ env.CONFIG_PATH }}
+          yq e '.friendApplicationApproved.isSendMsg = true' -i ${{ env.NOTIFICATION_CONFIG_PATH }}
+          yq e '.secret = 123456' -i ${{ env.SHARE_CONFIG_PATH }}
 
       - name: Start Server Services
         run: |

.github/workflows/publish-docker-image.yml

@@ -4,45 +4,80 @@ on:
   push:
     branches:
       - release-*
-    # tags:
-    #   - 'v*'
-
   release:
     types: [published]
-
   workflow_dispatch:
     inputs:
       tag:
         description: "Tag version to be used for Docker image"
         required: true
-        default: "v3.8.0"
+        default: "v3.8.3"
+
+env:
+  GO_VERSION: "1.22"
+  IMAGE_NAME: "openim-server"
+  # IMAGE_NAME: ${{ github.event.repository.name }}
+  DOCKER_BUILDKIT: 1
 
 jobs:
-  build-and-test:
+  publish-docker-images:
     runs-on: ubuntu-latest
+    if: ${{ !(github.event_name == 'pull_request' && github.event.pull_request.merged == false) }}
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout main repository
+        uses: actions/checkout@v4
         with:
           path: main-repo
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v3.3.0
 
       - name: Set up Docker Buildx
+        id: buildx
         uses: docker/setup-buildx-action@v3
-
-      - name: Build Docker image
-        id: build
-        uses: docker/build-push-action@v5
         with:
-          context: ./main-repo
+          driver-opts: network=host
-          load: true
-          tags: "openim/openim-server:local"
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
 
-      - name: Save Docker image to file
+      - name: Extract metadata for Docker
-        run: docker save -o image.tar openim/openim-server:local
+        id: meta
+        uses: docker/metadata-action@v5.6.0
+        with:
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/${{ env.IMAGE_NAME }}
+            ghcr.io/${{ github.repository_owner }}/${{ env.IMAGE_NAME }}
+            registry.cn-hangzhou.aliyuncs.com/openimsdk/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=tag
+            type=schedule
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern=v{{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
+
+      - name: Install skopeo
+        run: |
+          sudo apt-get update && sudo apt-get install -y skopeo
+
+      - name: Build multi-arch images as OCI
+        run: |
+          mkdir -p /tmp/oci-image /tmp/docker-cache
+
+          # Build multi-architecture image and save in OCI format        
+          docker buildx build \
+            --platform linux/amd64,linux/arm64 \
+            --output type=oci,dest=/tmp/oci-image/multi-arch.tar \
+            --cache-to type=local,dest=/tmp/docker-cache \
+            --cache-from type=gha \
+            ./main-repo
+
+            # Use skopeo to convert the amd64 image from OCI format to Docker format and load it
+          skopeo copy --override-arch amd64 oci-archive:/tmp/oci-image/multi-arch.tar docker-daemon:${{ secrets.DOCKER_USERNAME }}/${{ env.IMAGE_NAME }}:local
+
+          # check image
+          docker image ls | grep openim
 
       - name: Checkout compose repository
         uses: actions/checkout@v4
@@ -55,18 +90,19 @@ jobs:
         run: |
           IP=$(hostname -I | awk '{print $1}')
           echo "The IP Address is: $IP"
-          echo "::set-output name=ip::$IP"
+          echo "ip=$IP" >> $GITHUB_OUTPUT
 
       - name: Update .env to use the local image
         run: |
-          sed -i 's|OPENIM_SERVER_IMAGE=.*|OPENIM_SERVER_IMAGE=openim/openim-server:local|' ${{ github.workspace }}/compose-repo/.env
+          sed -i 's|OPENIM_SERVER_IMAGE=.*|OPENIM_SERVER_IMAGE=${{ secrets.DOCKER_USERNAME }}/${{ env.IMAGE_NAME }}:local|' ${{ github.workspace }}/compose-repo/.env
           sed -i 's|MINIO_EXTERNAL_ADDRESS=.*|MINIO_EXTERNAL_ADDRESS=http://${{ steps.get-ip.outputs.ip }}:10005|' ${{ github.workspace }}/compose-repo/.env
 
       - name: Start services using Docker Compose
         run: |
           cd ${{ github.workspace }}/compose-repo
           docker compose up -d
-          sleep 60
+
+          docker compose ps
 
       # - name: Check openim-server health
       #   run: |
@@ -97,54 +133,62 @@ jobs:
       #         exit 0
       #       fi
 
-      - name: Load Docker image from file
-        run: docker load -i image.tar
-
-      - name: Extract metadata for Docker (tags, labels)
-        id: meta
-        uses: docker/metadata-action@v5.5.1
-        with:
-          images: |
-            openim/openim-server
-            ghcr.io/openimsdk/openim-server
-            registry.cn-hangzhou.aliyuncs.com/openimsdk/openim-server
-          tags: |
-            type=ref,event=tag
-            type=schedule
-            type=ref,event=branch
-            type=semver,pattern={{version}}
-            type=semver,pattern=v{{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=semver,pattern={{major}}
-            type=semver,pattern=release-{{raw}}
-            type=sha
-            type=raw,value=${{ github.event.inputs.tag }}
-
       - name: Log in to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3.3.0
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3.3.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Log in to Aliyun Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3.3.0
         with:
           registry: registry.cn-hangzhou.aliyuncs.com
           username: ${{ secrets.ALIREGISTRY_USERNAME }}
           password: ${{ secrets.ALIREGISTRY_TOKEN }}
 
-      - name: Push Docker images
+      - name: Push multi-architecture images
-        uses: docker/build-push-action@v5
+        if: success()
-        with:
+        run: |
-          context: ./main-repo
+          docker buildx build \
-          push: true
+            --platform linux/amd64,linux/arm64 \
-          platforms: linux/amd64,linux/arm64
+            $(echo "${{ steps.meta.outputs.tags }}" | sed 's/,/ --tag /g' | sed 's/^/--tag /') \
-          tags: ${{ steps.meta.outputs.tags }}
+            --cache-from type=local,src=/tmp/docker-cache \
-          labels: ${{ steps.meta.outputs.labels }}
+            --push \
+            ./main-repo
+
+      - name: Verify multi-platform support
+        run: |
+          images=(
+            "${{ secrets.DOCKER_USERNAME }}/${{ env.IMAGE_NAME }}"
+            "ghcr.io/${{ github.repository_owner }}/${{ env.IMAGE_NAME }}"
+            "registry.cn-hangzhou.aliyuncs.com/openimsdk/${{ env.IMAGE_NAME }}"
+          )
+
+          for image in "${images[@]}"; do
+              for tag in $(echo "${{ steps.meta.outputs.tags }}" | tr ',' '\n' | cut -d':' -f2); do
+                  echo "Verifying multi-arch support for $image:$tag"
+                  manifest=$(docker manifest inspect "$image:$tag" || echo "error")
+                  if [[ "$manifest" == "error" ]]; then
+                      echo "Manifest not found for $image:$tag"
+                      exit 1
+                  fi
+                  amd64_found=$(echo "$manifest" | jq '.manifests[] | select(.platform.architecture == "amd64")')
+                  arm64_found=$(echo "$manifest" | jq '.manifests[] | select(.platform.architecture == "arm64")')
+                  if [[ -z "$amd64_found" ]]; then
+                      echo "Multi-platform support check failed for $image:$tag - missing amd64"
+                      exit 1
+                  fi
+                  if [[ -z "$arm64_found" ]]; then
+                      echo "Multi-platform support check failed for $image:$tag - missing arm64"
+                      exit 1
+                  fi
+                  echo "✅ $image:$tag supports both amd64 and arm64 architectures"
+              done
+          done

config/redis.yml

@@ -1,7 +1,8 @@
 address: [ localhost:16379 ]
 username: 
 password: openIM123
-clusterMode: false
+# redisMode can be "cluster", "sentinel", or "standalone"
+redisMode: "standalone"
 db: 0
 maxRetry: 10
 poolSize: 100

docker-compose.yml

@@ -63,7 +63,12 @@ services:
     restart: always
     sysctls:
       net.core.somaxconn: 1024
-    command: redis-server /usr/local/redis/config/redis.conf --requirepass openIM123 --appendonly yes
+    command: >
+      redis-server
+      --requirepass openIM123
+      --appendonly yes
+      --aof-use-rdb-preamble yes
+      --save ""
     networks:
       - openim
 

go.mod

@@ -13,14 +13,14 @@ require (
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/openimsdk/protocol v0.0.73-alpha.12
-	github.com/openimsdk/tools v0.0.50-alpha.84
+	github.com/openimsdk/tools v0.0.50-alpha.106
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.10.0
 	go.mongodb.org/mongo-driver v1.14.0
 	google.golang.org/api v0.170.0
-	google.golang.org/grpc v1.68.0
+	google.golang.org/grpc v1.71.0
-	google.golang.org/protobuf v1.35.1
+	google.golang.org/protobuf v1.36.4
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -40,14 +40,13 @@ require (
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/spf13/viper v1.18.2
-	go.etcd.io/etcd/client/v3 v3.5.13
 	go.uber.org/automaxprocs v1.5.3
-	golang.org/x/sync v0.8.0
+	golang.org/x/sync v0.10.0
 )
 
 require (
 	cloud.google.com/go v0.112.1 // indirect
-	cloud.google.com/go/compute/metadata v0.5.0 // indirect
+	cloud.google.com/go/compute/metadata v0.6.0 // indirect
 	cloud.google.com/go/firestore v1.15.0 // indirect
 	cloud.google.com/go/iam v1.1.7 // indirect
 	cloud.google.com/go/longrunning v0.5.5 // indirect
@@ -89,7 +88,7 @@ require (
 	github.com/eapache/queue v1.1.0 // indirect
 	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
@@ -156,6 +155,7 @@ require (
 	github.com/rs/xid v1.5.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sercand/kuberesolver/v6 v6.0.1 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
@@ -174,27 +174,29 @@ require (
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	go.etcd.io/etcd/api/v3 v3.5.13 // indirect
 	go.etcd.io/etcd/client/pkg/v3 v3.5.13 // indirect
+	go.etcd.io/etcd/client/v3 v3.5.13 // indirect
 	go.opencensus.io v0.24.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect
-	go.opentelemetry.io/otel v1.24.0 // indirect
+	go.opentelemetry.io/otel v1.34.0 // indirect
-	go.opentelemetry.io/otel/metric v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.34.0 // indirect
-	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	go.opentelemetry.io/otel/trace v1.34.0 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/arch v0.7.0 // indirect
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
 	golang.org/x/image v0.15.0 // indirect
-	golang.org/x/net v0.29.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
-	golang.org/x/oauth2 v0.23.0 // indirect
+	golang.org/x/oauth2 v0.25.0 // indirect
-	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
-	golang.org/x/term v0.24.0 // indirect
+	golang.org/x/term v0.28.0 // indirect
-	golang.org/x/text v0.18.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	google.golang.org/appengine/v2 v2.0.2 // indirect
 	google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250115164207-1a7da9e5054f // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gorm.io/gorm v1.25.8 // indirect
@@ -216,6 +218,6 @@ require (
 	github.com/spf13/cobra v1.8.0
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	go.uber.org/zap v1.24.0 // indirect
-	golang.org/x/crypto v0.27.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )

go.sum

@@ -1,8 +1,8 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.112.1 h1:uJSeirPke5UNZHIb4SxfZklVSiWWVqW4oXlETwZziwM=
 cloud.google.com/go v0.112.1/go.mod h1:+Vbu+Y1UU+I1rjmzeMOb/8RfkKJK2Gyxi1X6jJCZLo4=
-cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY=
+cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I=
-cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY=
+cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg=
 cloud.google.com/go/firestore v1.15.0 h1:/k8ppuWOtNuDHt2tsRV42yI21uaGnKDEQnRFeBpbFF8=
 cloud.google.com/go/firestore v1.15.0/go.mod h1:GWOxFXcv8GZUtYpWHw/w6IuYNux/BtmeVTMmjrm4yhk=
 cloud.google.com/go/iam v1.1.7 h1:z4VHOhwKLF/+UYXAJDFwGtNF0b6gjsW1Pk9Ml0U/IoM=
@@ -117,8 +117,8 @@ github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8
 github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=
 github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
 github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
@@ -349,8 +349,8 @@ github.com/openimsdk/gomake v0.0.15-alpha.5 h1:eEZCEHm+NsmcO3onXZPIUbGFCYPYbsX5b
 github.com/openimsdk/gomake v0.0.15-alpha.5/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
 github.com/openimsdk/protocol v0.0.73-alpha.12 h1:2NYawXeHChYUeSme6QJ9pOLh+Empce2WmwEtbP4JvKk=
 github.com/openimsdk/protocol v0.0.73-alpha.12/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
-github.com/openimsdk/tools v0.0.50-alpha.84 h1:jN60Ys/0edZjL/TDmm/5VSJFP4pGYRipkWqhILJbq/8=
+github.com/openimsdk/tools v0.0.50-alpha.106 h1:gaqU08IbRxOdL16ZEQNyYLhCTf7K1HNkrik8KZLA+BM=
-github.com/openimsdk/tools v0.0.50-alpha.84/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
+github.com/openimsdk/tools v0.0.50-alpha.106/go.mod h1:x9i/e+WJFW4tocy6RNJQ9NofQiP3KJ1Y576/06TqOG4=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
@@ -384,8 +384,8 @@ github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -393,6 +393,8 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/sercand/kuberesolver/v6 v6.0.1 h1:XZUTA0gy/lgDYp/UhEwv7Js24F1j8NJ833QrWv0Xux4=
+github.com/sercand/kuberesolver/v6 v6.0.1/go.mod h1:C0tsTuRMONSY+Xf7pv7RMW1/JlewY1+wS8SZE+1lf1s=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
@@ -420,8 +422,9 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.563/go.mod h1:7sCQWVkxcsR38nffDW057DRGk8mUjK1Ing/EFOK8s8Y=
@@ -461,18 +464,22 @@ go.mongodb.org/mongo-driver v1.14.0 h1:P98w8egYRjYe3XDjxhYJagTokP/H6HzlsnojRgZRd
 go.mongodb.org/mongo-driver v1.14.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
 go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
 go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0/go.mod h1:Mjt1i1INqiaoZOMGR1RIUJN+i3ChKoFRqzrRQhlkbs0=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw=
-go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
-go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
-go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
-go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
-go.opentelemetry.io/otel/sdk v1.22.0 h1:6coWHw9xw7EfClIC/+O31R8IY3/+EiRFHevmHafB2Gw=
+go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
-go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc=
+go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
-go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk=
-go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
 go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
@@ -493,8 +500,8 @@ golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
-golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
@@ -522,19 +529,19 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug
 golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
-golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs=
+golang.org/x/oauth2 v0.25.0 h1:CY4y7XT9v0cRI9oupztF8AgiIu99L/ksR/Xp/6jrZ70=
-golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
+golang.org/x/oauth2 v0.25.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -549,14 +556,14 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -565,8 +572,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -597,17 +604,17 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y=
 google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s=
-google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 h1:hjSy6tcFQZ171igDaN5QHOw2n6vx40juYbC/x67CEhc=
+google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 h1:GVIKPyP/kLIyVOgOnTwFOrvQaQUzOzGMCxgFUOEmm24=
-google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I=
+google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422/go.mod h1:b6h1vNKhxaSoEI+5jc3PJUCustfli/mRab7295pY7rw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250115164207-1a7da9e5054f h1:OxYkA3wjPsZyBylwymxSHa7ViiW1Sml4ToBrncvFehI=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250115164207-1a7da9e5054f/go.mod h1:+2Yz8+CLJbIfL9z73EW45avw8Lmge3xVElCP9zEKi50=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0=
+google.golang.org/grpc v1.71.0 h1:kF77BGdPTQ4/JZWMlb9VpJ5pa25aqvVqogsxNHHdeBg=
-google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA=
+google.golang.org/grpc v1.71.0/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -617,8 +624,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.36.4 h1:6A3ZDJHn/eNqc1i+IdefRzy/9PokBTPvcqMySR7NNIM=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

internal/api/init.go

@@ -94,9 +94,16 @@ func Start(ctx context.Context, index int, cfg *Config) error {
 				return err
 			}
 
-			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+			etcdClient, ok := client.(*etcd.SvcDiscoveryRegistryImpl)
+			if !ok {
+				return errs.New("only etcd support autoSetPorts").Wrap()
+			}
 
-			_, err = etcdClient.Put(ctx, prommetrics.BuildDiscoveryKey(prommetrics.APIKeyName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
+			target, err := jsonutil.JsonMarshal(prommetrics.BuildDefaultTarget(registerIP, prometheusPort))
+			if err != nil {
+				return errs.Wrap(err)
+			}
+			err = etcdClient.SetWithLease(ctx, prommetrics.BuildDiscoveryKey(prommetrics.APIKeyName, index), target, prommetrics.TTL)
 			if err != nil {
 				return errs.WrapMsg(err, "etcd put err")
 			}

internal/api/prometheus_discovery.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -11,13 +12,11 @@ import (
 	"github.com/openimsdk/tools/discovery"
 	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/log"
-	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
 type PrometheusDiscoveryApi struct {
 	config *Config
-	client *clientv3.Client
+	client discovery.SvcDiscoveryRegistry
 }
 
 func NewPrometheusDiscoveryApi(cfg *Config, client discovery.SvcDiscoveryRegistry) *PrometheusDiscoveryApi {
@@ -25,7 +24,7 @@ func NewPrometheusDiscoveryApi(cfg *Config, client discovery.SvcDiscoveryRegistr
 		config: cfg,
 	}
 	if cfg.Discovery.Enable == config.ETCD {
-		api.client = client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+		api.client = client.(*etcd.SvcDiscoveryRegistryImpl)
 	}
 	return api
 }
@@ -38,35 +37,32 @@ func (p *PrometheusDiscoveryApi) Enable(c *gin.Context) {
 }
 
 func (p *PrometheusDiscoveryApi) discovery(c *gin.Context, key string) {
-	eResp, err := p.client.Get(c, prommetrics.BuildDiscoveryKey(key))
+	value, err := p.client.GetKeyWithPrefix(c, prommetrics.BuildDiscoveryKeyPrefix(key))
 	if err != nil {
-		// Log and respond with an error if preparation fails.
+		if errors.Is(err, discovery.ErrNotSupported) {
-		apiresp.GinError(c, errs.WrapMsg(err, "etcd get err"))
+			c.JSON(http.StatusOK, []struct{}{})
+			return
+		}
+		apiresp.GinError(c, errs.WrapMsg(err, "get key value"))
 		return
 	}
-	if len(eResp.Kvs) == 0 {
+	if len(value) == 0 {
-		c.JSON(http.StatusOK, []*prommetrics.Target{})
+		c.JSON(http.StatusOK, []*prommetrics.RespTarget{})
+		return
+	}
+	var resp prommetrics.RespTarget
+	for i := range value {
+		var tmp prommetrics.Target
+		if err = json.Unmarshal(value[i], &tmp); err != nil {
+			apiresp.GinError(c, errs.WrapMsg(err, "json unmarshal err"))
+			return
+		}
+
+		resp.Targets = append(resp.Targets, tmp.Target)
+		resp.Labels = tmp.Labels // default label is fixed. See prommetrics.BuildDefaultTarget
 	}
 
-	var (
+	c.JSON(http.StatusOK, []*prommetrics.RespTarget{&resp})
-		resp = &prommetrics.RespTarget{
-			Targets: make([]string, 0, len(eResp.Kvs)),
-		}
-	)
-
-	for i := range eResp.Kvs {
-		var target prommetrics.Target
-		err = json.Unmarshal(eResp.Kvs[i].Value, &target)
-		if err != nil {
-			log.ZError(c, "prometheus unmarshal err", errs.Wrap(err))
-		}
-		resp.Targets = append(resp.Targets, target.Target)
-		if resp.Labels == nil {
-			resp.Labels = target.Labels
-		}
-	}
-
-	c.JSON(200, []*prommetrics.RespTarget{resp})
 }
 
 func (p *PrometheusDiscoveryApi) Api(c *gin.Context) {

internal/msggateway/client.go

@@ -16,7 +16,6 @@ package msggateway
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"sync"
 	"sync/atomic"
@@ -31,7 +30,6 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
-	"github.com/openimsdk/tools/utils/stringutil"
 )
 
 var (
@@ -64,7 +62,7 @@ type PingPongHandler func(string) error
 
 type Client struct {
 	w              *sync.Mutex
-	conn           LongConn
+	conn           ClientConn
 	PlatformID     int    `json:"platformID"`
 	IsCompress     bool   `json:"isCompress"`
 	UserID         string `json:"userID"`
@@ -83,10 +81,10 @@ type Client struct {
 }
 
 // ResetClient updates the client's state with new connection and context information.
-func (c *Client) ResetClient(ctx *UserConnContext, conn LongConn, longConnServer LongConnServer) {
+func (c *Client) ResetClient(ctx *UserConnContext, conn ClientConn, longConnServer LongConnServer) {
 	c.w = new(sync.Mutex)
 	c.conn = conn
-	c.PlatformID = stringutil.StringToInt(ctx.GetPlatformID())
+	c.PlatformID = ctx.GetPlatformID()
 	c.IsCompress = ctx.GetCompression()
 	c.IsBackground = ctx.GetBackground()
 	c.UserID = ctx.GetUserID()
@@ -110,22 +108,6 @@ func (c *Client) ResetClient(ctx *UserConnContext, conn LongConn, longConnServer
 	c.subUserIDs = make(map[string]struct{})
 }
 
-func (c *Client) pingHandler(appData string) error {
-	if err := c.conn.SetReadDeadline(pongWait); err != nil {
-		return err
-	}
-
-	log.ZDebug(c.ctx, "ping Handler Success.", "appData", appData)
-	return c.writePongMsg(appData)
-}
-
-func (c *Client) pongHandler(_ string) error {
-	if err := c.conn.SetReadDeadline(pongWait); err != nil {
-		return err
-	}
-	return nil
-}
-
 // readMessage continuously reads messages from the connection.
 func (c *Client) readMessage() {
 	defer func() {
@@ -136,52 +118,25 @@ func (c *Client) readMessage() {
 		c.close()
 	}()
 
-	c.conn.SetReadLimit(maxMessageSize)
-	_ = c.conn.SetReadDeadline(pongWait)
-	c.conn.SetPongHandler(c.pongHandler)
-	c.conn.SetPingHandler(c.pingHandler)
-	c.activeHeartbeat(c.hbCtx)
-
 	for {
 		log.ZDebug(c.ctx, "readMessage")
-		messageType, message, returnErr := c.conn.ReadMessage()
+		message, returnErr := c.conn.ReadMessage()
 		if returnErr != nil {
-			log.ZWarn(c.ctx, "readMessage", returnErr, "messageType", messageType)
+			log.ZWarn(c.ctx, "readMessage", returnErr)
 			c.closedErr = returnErr
 			return
 		}
 
-		log.ZDebug(c.ctx, "readMessage", "messageType", messageType)
 		if c.closed.Load() {
 			// The scenario where the connection has just been closed, but the coroutine has not exited
 			c.closedErr = ErrConnClosed
 			return
 		}
 
-		switch messageType {
+		parseDataErr := c.handleMessage(message)
-		case MessageBinary:
+		if parseDataErr != nil {
-			_ = c.conn.SetReadDeadline(pongWait)
+			c.closedErr = parseDataErr
-			parseDataErr := c.handleMessage(message)
-			if parseDataErr != nil {
-				c.closedErr = parseDataErr
-				return
-			}
-		case MessageText:
-			_ = c.conn.SetReadDeadline(pongWait)
-			parseDataErr := c.handlerTextMessage(message)
-			if parseDataErr != nil {
-				c.closedErr = parseDataErr
-				return
-			}
-		case PingMessage:
-			err := c.writePongMsg("")
-			log.ZError(c.ctx, "writePongMsg", err)
-
-		case CloseMessage:
-			c.closedErr = ErrClientClosed
 			return
-
-		default:
 		}
 	}
 }
@@ -356,109 +311,13 @@ func (c *Client) writeBinaryMsg(resp Resp) error {
 	c.w.Lock()
 	defer c.w.Unlock()
 
-	err = c.conn.SetWriteDeadline(writeWait)
-	if err != nil {
-		return err
-	}
-
 	if c.IsCompress {
 		resultBuf, compressErr := c.longConnServer.CompressWithPool(encodedBuf)
 		if compressErr != nil {
 			return compressErr
 		}
-		return c.conn.WriteMessage(MessageBinary, resultBuf)
+		return c.conn.WriteMessage(resultBuf)
 	}
 
-	return c.conn.WriteMessage(MessageBinary, encodedBuf)
+	return c.conn.WriteMessage(encodedBuf)
-}
-
-// Actively initiate Heartbeat when platform in Web.
-func (c *Client) activeHeartbeat(ctx context.Context) {
-	if c.PlatformID == constant.WebPlatformID {
-		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					log.ZPanic(ctx, "activeHeartbeat Panic", errs.ErrPanic(r))
-				}
-			}()
-			log.ZDebug(ctx, "server initiative send heartbeat start.")
-			ticker := time.NewTicker(pingPeriod)
-			defer ticker.Stop()
-
-			for {
-				select {
-				case <-ticker.C:
-					if err := c.writePingMsg(); err != nil {
-						log.ZWarn(c.ctx, "send Ping Message error.", err)
-						return
-					}
-				case <-c.hbCtx.Done():
-					return
-				}
-			}
-		}()
-	}
-}
-func (c *Client) writePingMsg() error {
-	if c.closed.Load() {
-		return nil
-	}
-
-	c.w.Lock()
-	defer c.w.Unlock()
-
-	err := c.conn.SetWriteDeadline(writeWait)
-	if err != nil {
-		return err
-	}
-
-	return c.conn.WriteMessage(PingMessage, nil)
-}
-
-func (c *Client) writePongMsg(appData string) error {
-	log.ZDebug(c.ctx, "write Pong Msg in Server", "appData", appData)
-	if c.closed.Load() {
-		log.ZWarn(c.ctx, "is closed in server", nil, "appdata", appData, "closed err", c.closedErr)
-		return nil
-	}
-
-	c.w.Lock()
-	defer c.w.Unlock()
-
-	err := c.conn.SetWriteDeadline(writeWait)
-	if err != nil {
-		log.ZWarn(c.ctx, "SetWriteDeadline in Server have error", errs.Wrap(err), "writeWait", writeWait, "appData", appData)
-		return errs.Wrap(err)
-	}
-	err = c.conn.WriteMessage(PongMessage, []byte(appData))
-	if err != nil {
-		log.ZWarn(c.ctx, "Write Message have error", errs.Wrap(err), "Pong msg", PongMessage)
-	}
-
-	return errs.Wrap(err)
-}
-
-func (c *Client) handlerTextMessage(b []byte) error {
-	var msg TextMessage
-	if err := json.Unmarshal(b, &msg); err != nil {
-		return err
-	}
-	switch msg.Type {
-	case TextPong:
-		return nil
-	case TextPing:
-		msg.Type = TextPong
-		msgData, err := json.Marshal(msg)
-		if err != nil {
-			return err
-		}
-		c.w.Lock()
-		defer c.w.Unlock()
-		if err := c.conn.SetWriteDeadline(writeWait); err != nil {
-			return err
-		}
-		return c.conn.WriteMessage(MessageText, msgData)
-	default:
-		return fmt.Errorf("not support message type %s", msg.Type)
-	}
 }

internal/msggateway/client_conn.go

@@ -0,0 +1,212 @@
+package msggateway
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sync/atomic"
+	"time"
+
+	"github.com/gorilla/websocket"
+
+	"github.com/openimsdk/tools/log"
+)
+
+var ErrWriteFull = fmt.Errorf("websocket write buffer full,close connection")
+
+type ClientConn interface {
+	ReadMessage() ([]byte, error)
+	WriteMessage(message []byte) error
+	Close() error
+}
+
+type websocketMessage struct {
+	MessageType int
+	Data        []byte
+}
+
+func NewWebSocketClientConn(conn *websocket.Conn, readLimit int64, readTimeout time.Duration, pingInterval time.Duration) ClientConn {
+	c := &websocketClientConn{
+		readTimeout: readTimeout,
+		conn:        conn,
+		writer:      make(chan *websocketMessage, 256),
+		done:        make(chan struct{}),
+	}
+	if readLimit > 0 {
+		c.conn.SetReadLimit(readLimit)
+	}
+	c.conn.SetPingHandler(c.pingHandler)
+	c.conn.SetPongHandler(c.pongHandler)
+
+	go c.loopSend()
+	if pingInterval > 0 {
+		go c.doPing(pingInterval)
+	}
+	return c
+}
+
+type websocketClientConn struct {
+	readTimeout time.Duration
+	conn        *websocket.Conn
+	writer      chan *websocketMessage
+	done        chan struct{}
+	err         atomic.Pointer[error]
+}
+
+func (c *websocketClientConn) ReadMessage() ([]byte, error) {
+	buf, err := c.readMessage()
+	if err != nil {
+		return nil, c.closeBy(fmt.Errorf("read message %w", err))
+	}
+	return buf, nil
+}
+
+func (c *websocketClientConn) WriteMessage(message []byte) error {
+	return c.writeMessage(websocket.BinaryMessage, message)
+}
+
+func (c *websocketClientConn) Close() error {
+	_ = c.closeBy(fmt.Errorf("websocket connection closed"))
+	return nil
+}
+
+func (c *websocketClientConn) closeBy(err error) error {
+	if !c.err.CompareAndSwap(nil, &err) {
+		return *c.err.Load()
+	}
+	close(c.done)
+	log.ZWarn(context.Background(), "websocket connection closed", err, "remoteAddr", c.conn.RemoteAddr(),
+		"chan length", len(c.writer))
+	_ = c.conn.Close()
+	return err
+}
+
+func (c *websocketClientConn) writeMessage(messageType int, data []byte) error {
+	if errPtr := c.err.Load(); errPtr != nil {
+		return *errPtr
+	}
+	select {
+	case c.writer <- &websocketMessage{MessageType: messageType, Data: data}:
+		return nil
+	default:
+		return c.closeBy(ErrWriteFull)
+	}
+}
+
+func (c *websocketClientConn) loopSend() {
+	var err error
+	for {
+		select {
+		case <-c.done:
+			return
+		case msg := <-c.writer:
+			switch msg.MessageType {
+			case websocket.TextMessage, websocket.BinaryMessage:
+				err = c.conn.WriteMessage(msg.MessageType, msg.Data)
+			default:
+				err = c.conn.WriteControl(msg.MessageType, msg.Data, time.Time{})
+			}
+			if err != nil {
+				_ = c.closeBy(err)
+				return
+			}
+		}
+	}
+}
+
+func (c *websocketClientConn) setReadDeadline() error {
+	deadline := time.Now().Add(c.readTimeout)
+	return c.conn.SetReadDeadline(deadline)
+}
+
+func (c *websocketClientConn) readMessage() ([]byte, error) {
+	for {
+		if err := c.setReadDeadline(); err != nil {
+			return nil, err
+		}
+		messageType, buf, err := c.conn.ReadMessage()
+		if err != nil {
+			return nil, err
+		}
+		switch messageType {
+		case websocket.BinaryMessage:
+			return buf, nil
+		case websocket.TextMessage:
+			if err := c.onReadTextMessage(buf); err != nil {
+				return nil, err
+			}
+		case websocket.PingMessage:
+			if err := c.pingHandler(string(buf)); err != nil {
+				return nil, err
+			}
+		case websocket.PongMessage:
+			if err := c.pongHandler(string(buf)); err != nil {
+				return nil, err
+			}
+		case websocket.CloseMessage:
+			if len(buf) == 0 {
+				return nil, errors.New("websocket connection closed by peer")
+			}
+			return nil, fmt.Errorf("websocket connection closed by peer, data %s", string(buf))
+		default:
+			return nil, fmt.Errorf("unknown websocket message type %d", messageType)
+		}
+	}
+}
+
+func (c *websocketClientConn) onReadTextMessage(buf []byte) error {
+	var msg struct {
+		Type string          `json:"type"`
+		Body json.RawMessage `json:"body"`
+	}
+	if err := json.Unmarshal(buf, &msg); err != nil {
+		return err
+	}
+	switch msg.Type {
+	case TextPong:
+		return nil
+	case TextPing:
+		msg.Type = TextPong
+		msgData, err := json.Marshal(msg)
+		if err != nil {
+			return err
+		}
+		return c.writeMessage(websocket.TextMessage, msgData)
+	default:
+		return fmt.Errorf("not support text message type %s", msg.Type)
+	}
+}
+
+func (c *websocketClientConn) pingHandler(appData string) error {
+	log.ZWarn(context.Background(), "ping handler recv ping", nil, "remoteAddr", c.conn.RemoteAddr(), "appData", appData)
+	if err := c.setReadDeadline(); err != nil {
+		return err
+	}
+	err := c.conn.WriteControl(websocket.PongMessage, []byte(appData), time.Now().Add(time.Second*1))
+	if err != nil {
+		log.ZWarn(context.Background(), "ping handler write pong error", err, "remoteAddr", c.conn.RemoteAddr(), "appData", appData)
+	}
+	log.ZWarn(context.Background(), "ping handler write pong success", nil, "remoteAddr", c.conn.RemoteAddr(), "appData", appData)
+	return nil
+}
+
+func (c *websocketClientConn) pongHandler(string) error {
+	return nil
+}
+
+func (c *websocketClientConn) doPing(d time.Duration) {
+	ticker := time.NewTicker(d)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-c.done:
+			return
+		case <-ticker.C:
+			if err := c.writeMessage(websocket.PingMessage, nil); err != nil {
+				_ = c.closeBy(fmt.Errorf("send ping %w", err))
+				return
+			}
+		}
+	}
+}

internal/msggateway/context.go

@@ -15,18 +15,31 @@
 package msggateway
 
 import (
-	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"encoding/base64"
+	"encoding/json"
 	"net/http"
 	"net/url"
 	"strconv"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/utils/encrypt"
-	"github.com/openimsdk/tools/utils/stringutil"
 	"github.com/openimsdk/tools/utils/timeutil"
 )
 
+type UserConnContextInfo struct {
+	Token        string `json:"token"`
+	UserID       string `json:"userID"`
+	PlatformID   int    `json:"platformID"`
+	OperationID  string `json:"operationID"`
+	Compression  string `json:"compression"`
+	SDKType      string `json:"sdkType"`
+	SendResponse bool   `json:"sendResponse"`
+	Background   bool   `json:"background"`
+}
+
 type UserConnContext struct {
 	RespWriter http.ResponseWriter
 	Req        *http.Request
@@ -34,6 +47,7 @@ type UserConnContext struct {
 	Method     string
 	RemoteAddr string
 	ConnID     string
+	info       *UserConnContextInfo
 }
 
 func (c *UserConnContext) Deadline() (deadline time.Time, ok bool) {
@@ -57,7 +71,7 @@ func (c *UserConnContext) Value(key any) any {
 	case constant.ConnID:
 		return c.GetConnID()
 	case constant.OpUserPlatform:
-		return constant.PlatformIDToName(stringutil.StringToInt(c.GetPlatformID()))
+		return c.GetPlatformID()
 	case constant.RemoteAddr:
 		return c.RemoteAddr
 	default:
@@ -82,30 +96,91 @@ func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnCont
 
 func newTempContext() *UserConnContext {
 	return &UserConnContext{
-		Req: &http.Request{URL: &url.URL{}},
+		Req:  &http.Request{URL: &url.URL{}},
+		info: &UserConnContextInfo{},
 	}
 }
 
+func (c *UserConnContext) ParseEssentialArgs() error {
+	query := c.Req.URL.Query()
+	if data := query.Get("v"); data != "" {
+		return c.parseByJson(data)
+	} else {
+		return c.parseByQuery(query, c.Req.Header)
+	}
+}
+
+func (c *UserConnContext) parseByQuery(query url.Values, header http.Header) error {
+	info := UserConnContextInfo{
+		Token:       query.Get(Token),
+		UserID:      query.Get(WsUserID),
+		OperationID: query.Get(OperationID),
+		Compression: query.Get(Compression),
+		SDKType:     query.Get(SDKType),
+	}
+	platformID, err := strconv.Atoi(query.Get(PlatformID))
+	if err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("platformID is not int")
+	}
+	info.PlatformID = platformID
+	if val := query.Get(SendResponse); val != "" {
+		ok, err := strconv.ParseBool(val)
+		if err != nil {
+			return servererrs.ErrConnArgsErr.WrapMsg("isMsgResp is not bool")
+		}
+		info.SendResponse = ok
+	}
+	if info.Compression == "" {
+		info.Compression = header.Get(Compression)
+	}
+	background, err := strconv.ParseBool(query.Get(BackgroundStatus))
+	if err != nil {
+		return err
+	}
+	info.Background = background
+	return c.checkInfo(&info)
+}
+
+func (c *UserConnContext) parseByJson(data string) error {
+	reqInfo, err := base64.RawURLEncoding.DecodeString(data)
+	if err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("data is not base64")
+	}
+	var info UserConnContextInfo
+	if err := json.Unmarshal(reqInfo, &info); err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("data is not json", "info", err.Error())
+	}
+	return c.checkInfo(&info)
+}
+
+func (c *UserConnContext) checkInfo(info *UserConnContextInfo) error {
+	if info.OperationID == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("operationID is empty")
+	}
+	if info.Token == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("token is empty")
+	}
+	if info.UserID == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("sendID is empty")
+	}
+	if _, ok := constant.PlatformID2Name[info.PlatformID]; !ok {
+		return servererrs.ErrConnArgsErr.WrapMsg("platformID is invalid")
+	}
+	switch info.SDKType {
+	case "":
+		info.SDKType = GoSDK
+	case GoSDK, JsSDK:
+	default:
+		return servererrs.ErrConnArgsErr.WrapMsg("sdkType is invalid")
+	}
+	c.info = info
+	return nil
+}
+
 func (c *UserConnContext) GetRemoteAddr() string {
 	return c.RemoteAddr
 }
 
-func (c *UserConnContext) Query(key string) (string, bool) {
-	var value string
-	if value = c.Req.URL.Query().Get(key); value == "" {
-		return value, false
-	}
-	return value, true
-}
-
-func (c *UserConnContext) GetHeader(key string) (string, bool) {
-	var value string
-	if value = c.Req.Header.Get(key); value == "" {
-		return value, false
-	}
-	return value, true
-}
-
 func (c *UserConnContext) SetHeader(key, value string) {
 	c.RespWriter.Header().Set(key, value)
 }
@@ -119,93 +194,69 @@ func (c *UserConnContext) GetConnID() string {
 }
 
 func (c *UserConnContext) GetUserID() string {
-	return c.Req.URL.Query().Get(WsUserID)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.UserID
 }
 
-func (c *UserConnContext) GetPlatformID() string {
+func (c *UserConnContext) GetPlatformID() int {
-	return c.Req.URL.Query().Get(PlatformID)
+	if c == nil || c.info == nil {
+		return 0
+	}
+	return c.info.PlatformID
 }
 
 func (c *UserConnContext) GetOperationID() string {
-	return c.Req.URL.Query().Get(OperationID)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.OperationID
 }
 
 func (c *UserConnContext) SetOperationID(operationID string) {
-	values := c.Req.URL.Query()
+	if c.info == nil {
-	values.Set(OperationID, operationID)
+		c.info = &UserConnContextInfo{}
-	c.Req.URL.RawQuery = values.Encode()
+	}
+	c.info.OperationID = operationID
 }
 
 func (c *UserConnContext) GetToken() string {
-	return c.Req.URL.Query().Get(Token)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.Token
 }
 
 func (c *UserConnContext) GetCompression() bool {
-	compression, exists := c.Query(Compression)
+	return c != nil && c.info != nil && c.info.Compression == GzipCompressionProtocol
-	if exists && compression == GzipCompressionProtocol {
-		return true
-	} else {
-		compression, exists := c.GetHeader(Compression)
-		if exists && compression == GzipCompressionProtocol {
-			return true
-		}
-	}
-	return false
 }
 
 func (c *UserConnContext) GetSDKType() string {
-	sdkType := c.Req.URL.Query().Get(SDKType)
+	if c == nil || c.info == nil {
-	if sdkType == "" {
+		return GoSDK
-		sdkType = GoSDK
+	}
+	switch c.info.SDKType {
+	case "", GoSDK:
+		return GoSDK
+	case JsSDK:
+		return JsSDK
+	default:
+		return ""
 	}
-	return sdkType
 }
 
 func (c *UserConnContext) ShouldSendResp() bool {
-	errResp, exists := c.Query(SendResponse)
+	return c != nil && c.info != nil && c.info.SendResponse
-	if exists {
-		b, err := strconv.ParseBool(errResp)
-		if err != nil {
-			return false
-		} else {
-			return b
-		}
-	}
-	return false
 }
 
 func (c *UserConnContext) SetToken(token string) {
-	c.Req.URL.RawQuery = Token + "=" + token
+	if c.info == nil {
+		c.info = &UserConnContextInfo{}
+	}
+	c.info.Token = token
 }
 
 func (c *UserConnContext) GetBackground() bool {
-	b, err := strconv.ParseBool(c.Req.URL.Query().Get(BackgroundStatus))
+	return c != nil && c.info != nil && c.info.Background
-	if err != nil {
-		return false
-	}
-	return b
-}
-func (c *UserConnContext) ParseEssentialArgs() error {
-	_, exists := c.Query(Token)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("token is empty")
-	}
-	_, exists = c.Query(WsUserID)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("sendID is empty")
-	}
-	platformIDStr, exists := c.Query(PlatformID)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("platformID is empty")
-	}
-	_, err := strconv.Atoi(platformIDStr)
-	if err != nil {
-		return servererrs.ErrConnArgsErr.WrapMsg("platformID is not int")
-	}
-	switch sdkType, _ := c.Query(SDKType); sdkType {
-	case "", GoSDK, JsSDK:
-	default:
-		return servererrs.ErrConnArgsErr.WrapMsg("sdkType is not go or js")
-	}
-	return nil
 }

internal/msggateway/long_conn.go

@@ -1,179 +0,0 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// 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 msggateway
-
-import (
-	"encoding/json"
-	"net/http"
-	"time"
-
-	"github.com/openimsdk/tools/apiresp"
-
-	"github.com/gorilla/websocket"
-	"github.com/openimsdk/tools/errs"
-)
-
-type LongConn interface {
-	// Close this connection
-	Close() error
-	// WriteMessage Write message to connection,messageType means data type,can be set binary(2) and text(1).
-	WriteMessage(messageType int, message []byte) error
-	// ReadMessage Read message from connection.
-	ReadMessage() (int, []byte, error)
-	// SetReadDeadline sets the read deadline on the underlying network connection,
-	// after a read has timed out, will return an error.
-	SetReadDeadline(timeout time.Duration) error
-	// SetWriteDeadline sets to write deadline when send message,when read has timed out,will return error.
-	SetWriteDeadline(timeout time.Duration) error
-	// Dial Try to dial a connection,url must set auth args,header can control compress data
-	Dial(urlStr string, requestHeader http.Header) (*http.Response, error)
-	// IsNil Whether the connection of the current long connection is nil
-	IsNil() bool
-	// SetConnNil Set the connection of the current long connection to nil
-	SetConnNil()
-	// SetReadLimit sets the maximum size for a message read from the peer.bytes
-	SetReadLimit(limit int64)
-	SetPongHandler(handler PingPongHandler)
-	SetPingHandler(handler PingPongHandler)
-	// GenerateLongConn Check the connection of the current and when it was sent are the same
-	GenerateLongConn(w http.ResponseWriter, r *http.Request) error
-}
-type GWebSocket struct {
-	protocolType     int
-	conn             *websocket.Conn
-	handshakeTimeout time.Duration
-	writeBufferSize  int
-}
-
-func newGWebSocket(protocolType int, handshakeTimeout time.Duration, wbs int) *GWebSocket {
-	return &GWebSocket{protocolType: protocolType, handshakeTimeout: handshakeTimeout, writeBufferSize: wbs}
-}
-
-func (d *GWebSocket) Close() error {
-	return d.conn.Close()
-}
-
-func (d *GWebSocket) GenerateLongConn(w http.ResponseWriter, r *http.Request) error {
-	upgrader := &websocket.Upgrader{
-		HandshakeTimeout: d.handshakeTimeout,
-		CheckOrigin:      func(r *http.Request) bool { return true },
-	}
-	if d.writeBufferSize > 0 { // default is 4kb.
-		upgrader.WriteBufferSize = d.writeBufferSize
-	}
-
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		// The upgrader.Upgrade method usually returns enough error messages to diagnose problems that may occur during the upgrade
-		return errs.WrapMsg(err, "GenerateLongConn: WebSocket upgrade failed")
-	}
-	d.conn = conn
-	return nil
-}
-
-func (d *GWebSocket) WriteMessage(messageType int, message []byte) error {
-	// d.setSendConn(d.conn)
-	return d.conn.WriteMessage(messageType, message)
-}
-
-// func (d *GWebSocket) setSendConn(sendConn *websocket.Conn) {
-//	d.sendConn = sendConn
-//}
-
-func (d *GWebSocket) ReadMessage() (int, []byte, error) {
-	return d.conn.ReadMessage()
-}
-
-func (d *GWebSocket) SetReadDeadline(timeout time.Duration) error {
-	return d.conn.SetReadDeadline(time.Now().Add(timeout))
-}
-
-func (d *GWebSocket) SetWriteDeadline(timeout time.Duration) error {
-	if timeout <= 0 {
-		return errs.New("timeout must be greater than 0")
-	}
-
-	// TODO SetWriteDeadline Future add error handling
-	if err := d.conn.SetWriteDeadline(time.Now().Add(timeout)); err != nil {
-		return errs.WrapMsg(err, "GWebSocket.SetWriteDeadline failed")
-	}
-	return nil
-}
-
-func (d *GWebSocket) Dial(urlStr string, requestHeader http.Header) (*http.Response, error) {
-	conn, httpResp, err := websocket.DefaultDialer.Dial(urlStr, requestHeader)
-	if err != nil {
-		return httpResp, errs.WrapMsg(err, "GWebSocket.Dial failed", "url", urlStr)
-	}
-	d.conn = conn
-	return httpResp, nil
-}
-
-func (d *GWebSocket) IsNil() bool {
-	return d.conn == nil
-	//
-	// if d.conn != nil {
-	// 	return false
-	// }
-	// return true
-}
-
-func (d *GWebSocket) SetConnNil() {
-	d.conn = nil
-}
-
-func (d *GWebSocket) SetReadLimit(limit int64) {
-	d.conn.SetReadLimit(limit)
-}
-
-func (d *GWebSocket) SetPongHandler(handler PingPongHandler) {
-	d.conn.SetPongHandler(handler)
-}
-
-func (d *GWebSocket) SetPingHandler(handler PingPongHandler) {
-	d.conn.SetPingHandler(handler)
-}
-
-func (d *GWebSocket) RespondWithError(err error, w http.ResponseWriter, r *http.Request) error {
-	if err := d.GenerateLongConn(w, r); err != nil {
-		return err
-	}
-	data, err := json.Marshal(apiresp.ParseError(err))
-	if err != nil {
-		_ = d.Close()
-		return errs.WrapMsg(err, "json marshal failed")
-	}
-
-	if err := d.WriteMessage(MessageText, data); err != nil {
-		_ = d.Close()
-		return errs.WrapMsg(err, "WriteMessage failed")
-	}
-	_ = d.Close()
-	return nil
-}
-
-func (d *GWebSocket) RespondWithSuccess() error {
-	data, err := json.Marshal(apiresp.ParseError(nil))
-	if err != nil {
-		_ = d.Close()
-		return errs.WrapMsg(err, "json marshal failed")
-	}
-
-	if err := d.WriteMessage(MessageText, data); err != nil {
-		_ = d.Close()
-		return errs.WrapMsg(err, "WriteMessage failed")
-	}
-	return nil
-}

internal/msggateway/ws_server.go

@@ -2,13 +2,16 @@ package msggateway
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/gorilla/websocket"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/apiresp"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
@@ -26,6 +29,8 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
+var wsSuccessResponse, _ = json.Marshal(&apiresp.ApiResponse{})
+
 type LongConnServer interface {
 	Run(done chan error) error
 	wsHandler(w http.ResponseWriter, r *http.Request)
@@ -42,6 +47,7 @@ type LongConnServer interface {
 }
 
 type WsServer struct {
+	websocket         *websocket.Upgrader
 	msgGatewayConfig  *Config
 	port              int
 	wsMaxConnNum      int64
@@ -131,9 +137,13 @@ func NewWsServer(msgGatewayConfig *Config, opts ...Option) *WsServer {
 		o(&config)
 	}
 	//userRpcClient := rpcclient.NewUserRpcClient(client, config.Share.RpcRegisterName.User, config.Share.IMAdminUserID)
-
+	upgrader := &websocket.Upgrader{
+		HandshakeTimeout: config.handshakeTimeout,
+		CheckOrigin:      func(r *http.Request) bool { return true },
+	}
 	v := validator.New()
 	return &WsServer{
+		websocket:        upgrader,
 		msgGatewayConfig: msgGatewayConfig,
 		port:             config.port,
 		wsMaxConnNum:     config.maxConnNum,
@@ -439,16 +449,39 @@ func (ws *WsServer) unregisterClient(client *Client) {
 // validateRespWithRequest checks if the response matches the expected userID and platformID.
 func (ws *WsServer) validateRespWithRequest(ctx *UserConnContext, resp *pbAuth.ParseTokenResp) error {
 	userID := ctx.GetUserID()
-	platformID := stringutil.StringToInt32(ctx.GetPlatformID())
+	platformID := ctx.GetPlatformID()
 	if resp.UserID != userID {
 		return servererrs.ErrTokenInvalid.WrapMsg(fmt.Sprintf("token uid %s != userID %s", resp.UserID, userID))
 	}
-	if resp.PlatformID != platformID {
+	if int(resp.PlatformID) != platformID {
 		return servererrs.ErrTokenInvalid.WrapMsg(fmt.Sprintf("token platform %d != platformID %d", resp.PlatformID, platformID))
 	}
 	return nil
 }
 
+func (ws *WsServer) handlerError(ctx *UserConnContext, w http.ResponseWriter, r *http.Request, err error) {
+	if !ctx.ShouldSendResp() {
+		httpError(ctx, err)
+		return
+	}
+	// the browser cannot get the response of upgrade failure
+	data, err := json.Marshal(apiresp.ParseError(err))
+	if err != nil {
+		log.ZError(ctx, "json marshal failed", err)
+		return
+	}
+	conn, upgradeErr := ws.websocket.Upgrade(w, r, nil)
+	if upgradeErr != nil {
+		log.ZWarn(ctx, "websocket upgrade failed", upgradeErr, "respErr", err, "resp", string(data))
+		return
+	}
+	defer conn.Close()
+	if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
+		log.ZWarn(ctx, "WriteMessage failed", err, "respErr", err, "resp", string(data))
+		return
+	}
+}
+
 func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 	// Create a new connection context
 	connContext := newContext(w, r)
@@ -456,7 +489,7 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 	// Check if the current number of online user connections exceeds the maximum limit
 	if ws.onlineUserConnNum.Load() >= ws.wsMaxConnNum {
 		// If it exceeds the maximum connection number, return an error via HTTP and stop processing
-		httpError(connContext, servererrs.ErrConnOverMaxNumLimit.WrapMsg("over max conn num limit"))
+		ws.handlerError(connContext, w, r, servererrs.ErrConnOverMaxNumLimit.WrapMsg("over max conn num limit"))
 		return
 	}
 
@@ -464,26 +497,14 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 	err := connContext.ParseEssentialArgs()
 	if err != nil {
 		// If there's an error during parsing, return an error via HTTP and stop processing
-
+		ws.handlerError(connContext, w, r, err)
-		httpError(connContext, err)
 		return
 	}
 
 	// Call the authentication client to parse the Token obtained from the context
 	resp, err := ws.authClient.ParseToken(connContext, connContext.GetToken())
 	if err != nil {
-		// If there's an error parsing the Token, decide whether to send the error message via WebSocket based on the context flag
+		ws.handlerError(connContext, w, r, err)
-		shouldSendError := connContext.ShouldSendResp()
-		if shouldSendError {
-			// Create a WebSocket connection object and attempt to send the error message via WebSocket
-			wsLongConn := newGWebSocket(WebSocket, ws.handshakeTimeout, ws.writeBufferSize)
-			if err := wsLongConn.RespondWithError(err, w, r); err == nil {
-				// If the error message is successfully sent via WebSocket, stop processing
-				return
-			}
-		}
-		// If sending via WebSocket is not required or fails, return the error via HTTP and stop processing
-		httpError(connContext, err)
 		return
 	}
 
@@ -491,32 +512,30 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 	err = ws.validateRespWithRequest(connContext, resp)
 	if err != nil {
 		// If validation fails, return an error via HTTP and stop processing
-		httpError(connContext, err)
+		ws.handlerError(connContext, w, r, err)
 		return
 	}
-
+	conn, err := ws.websocket.Upgrade(w, r, nil)
-	log.ZDebug(connContext, "new conn", "token", connContext.GetToken())
+	if err != nil {
-	// Create a WebSocket long connection object
+		log.ZWarn(connContext, "websocket upgrade failed", err)
-	wsLongConn := newGWebSocket(WebSocket, ws.handshakeTimeout, ws.writeBufferSize)
-	if err := wsLongConn.GenerateLongConn(w, r); err != nil {
-		//If the creation of the long connection fails, the error is handled internally during the handshake process.
-		log.ZWarn(connContext, "long connection fails", err)
 		return
-	} else {
+	}
-		// Check if a normal response should be sent via WebSocket
+	if connContext.ShouldSendResp() {
-		shouldSendSuccessResp := connContext.ShouldSendResp()
+		if err := conn.WriteMessage(websocket.TextMessage, wsSuccessResponse); err != nil {
-		if shouldSendSuccessResp {
+			log.ZWarn(connContext, "WriteMessage first response", err)
-			// Attempt to send a success message through WebSocket
+			return
-			if err := wsLongConn.RespondWithSuccess(); err != nil {
-				// If the success message is successfully sent, end further processing
-				return
-			}
 		}
 	}
+	log.ZDebug(connContext, "new conn", "token", connContext.GetToken())
+
+	var pingInterval time.Duration
+	if connContext.GetPlatformID() == constant.WebPlatformID {
+		pingInterval = pingPeriod
+	}
 
 	// Retrieve a client object from the client pool, reset its state, and associate it with the current WebSocket long connection
 	client := ws.clientPool.Get().(*Client)
-	client.ResetClient(connContext, wsLongConn, ws)
+	client.ResetClient(connContext, NewWebSocketClientConn(conn, maxMessageSize, pongWait, pingInterval), ws)
 
 	// Register the client with the server and start message processing
 	ws.registerChan <- client

internal/msgtransfer/init.go

@@ -176,9 +176,16 @@ func (m *MsgTransfer) Start(index int, cfg *Config) error {
 				return err
 			}
 
-			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+			etcdClient, ok := client.(*etcd.SvcDiscoveryRegistryImpl)
+			if !ok {
+				return errs.New("only etcd support autoSetPorts").Wrap()
+			}
 
-			_, err = etcdClient.Put(context.TODO(), prommetrics.BuildDiscoveryKey(prommetrics.MessageTransferKeyName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
+			target, err := jsonutil.JsonMarshal(prommetrics.BuildDefaultTarget(registerIP, prometheusPort))
+			if err != nil {
+				return errs.Wrap(err)
+			}
+			err = etcdClient.SetWithLease(context.TODO(), prommetrics.BuildDiscoveryKey(prommetrics.MessageTransferKeyName, index), target, prommetrics.TTL)
 			if err != nil {
 				return errs.WrapMsg(err, "etcd put err")
 			}

internal/rpc/conversation/conversation.go

@@ -168,7 +168,18 @@ func (c *conversationServer) GetSortedConversationList(ctx context.Context, req
 	conversation_notPinTime := make(map[int64]string)
 	for _, v := range conversations {
 		conversationID := v.ConversationID
-		time := conversationMsg[conversationID].MsgInfo.LatestMsgRecvTime
+		var time int64
+		if _, ok := conversationMsg[conversationID]; ok {
+			time = conversationMsg[conversationID].MsgInfo.LatestMsgRecvTime
+		} else {
+			conversationMsg[conversationID] = &pbconversation.ConversationElem{
+				ConversationID: conversationID,
+				IsPinned:       v.IsPinned,
+				MsgInfo:        nil,
+			}
+			time = v.CreateTime.UnixMilli()
+		}
+
 		conversationMsg[conversationID].RecvMsgOpt = v.RecvMsgOpt
 		if v.IsPinned {
 			conversationMsg[conversationID].IsPinned = v.IsPinned
@@ -220,6 +231,7 @@ func (c *conversationServer) getConversations(ctx context.Context, ownerUserID s
 	return convert.ConversationsDB2Pb(conversations), nil
 }
 
+// Deprecated
 func (c *conversationServer) SetConversation(ctx context.Context, req *pbconversation.SetConversationReq) (*pbconversation.SetConversationResp, error) {
 	var conversation dbModel.Conversation
 	if err := datautil.CopyStructFields(&conversation, req.Conversation); err != nil {

internal/rpc/conversation/sync.go

@@ -23,7 +23,7 @@ func (c *conversationServer) GetFullOwnerConversationIDs(ctx context.Context, re
 		conversationIDs = nil
 	}
 	return &conversation.GetFullOwnerConversationIDsResp{
-		Version:         idHash,
+		Version:         uint64(vl.Version),
 		VersionID:       vl.ID.Hex(),
 		Equal:           req.IdHash == idHash,
 		ConversationIDs: conversationIDs,

internal/rpc/group/notification.go

@@ -476,14 +476,15 @@ func (g *NotificationSender) GroupApplicationAcceptedNotification(ctx context.Co
 	if err = g.fillOpUser(ctx, &opUser, group.GroupID); err != nil {
 		return
 	}
-	tips := &sdkws.GroupApplicationAcceptedTips{
+	uid := g.uuid()
-		Group:     group,
-		OpUser:    opUser,
-		HandleMsg: req.HandledMsg,
-		Uuid:      g.uuid(),
-		Request:   request,
-	}
 	for _, userID := range append(userIDs, req.FromUserID) {
+		tips := &sdkws.GroupApplicationAcceptedTips{
+			Group:     group,
+			OpUser:    opUser,
+			HandleMsg: req.HandledMsg,
+			Uuid:      uid,
+			Request:   request,
+		}
 		if userID == req.FromUserID {
 			tips.ReceiverAs = applicantReceiver
 		} else {
@@ -520,14 +521,15 @@ func (g *NotificationSender) GroupApplicationRejectedNotification(ctx context.Co
 	if err = g.fillOpUser(ctx, &opUser, group.GroupID); err != nil {
 		return
 	}
-	tips := &sdkws.GroupApplicationRejectedTips{
+	uid := g.uuid()
-		Group:     group,
-		OpUser:    opUser,
-		HandleMsg: req.HandledMsg,
-		Uuid:      g.uuid(),
-		Request:   request,
-	}
 	for _, userID := range append(userIDs, req.FromUserID) {
+		tips := &sdkws.GroupApplicationRejectedTips{
+			Group:     group,
+			OpUser:    opUser,
+			HandleMsg: req.HandledMsg,
+			Uuid:      uid,
+			Request:   request,
+		}
 		if userID == req.FromUserID {
 			tips.ReceiverAs = applicantReceiver
 		} else {

internal/rpc/group/sync.go

@@ -2,6 +2,7 @@ package group
 
 import (
 	"context"
+	"errors"
 
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/incrversion"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -12,23 +13,24 @@ import (
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 )
 
 const versionSyncLimit = 500
 
-func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetFullGroupMemberUserIDsReq) (*pbgroup.GetFullGroupMemberUserIDsResp, error) {
+func (s *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetFullGroupMemberUserIDsReq) (*pbgroup.GetFullGroupMemberUserIDsResp, error) {
-	userIDs, err := g.db.FindGroupMemberUserID(ctx, req.GroupID)
+	userIDs, err := s.db.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		if !datautil.Contain(mcontext.GetOpUserID(ctx), userIDs...) {
 			return nil, errs.ErrNoPermission.WrapMsg("op user not in group")
 		}
 	}
-	vl, err := g.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
+	vl, err := s.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -37,7 +39,7 @@ func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgrou
 		userIDs = nil
 	}
 	return &pbgroup.GetFullGroupMemberUserIDsResp{
-		Version:   idHash,
+		Version:   uint64(vl.Version),
 		VersionID: vl.ID.Hex(),
 		Equal:     req.IdHash == idHash,
 		UserIDs:   userIDs,
@@ -61,7 +63,7 @@ func (s *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 		groupIDs = nil
 	}
 	return &pbgroup.GetFullJoinGroupIDsResp{
-		Version:   idHash,
+		Version:   uint64(vl.Version),
 		VersionID: vl.ID.Hex(),
 		Equal:     req.IdHash == idHash,
 		GroupIDs:  groupIDs,
@@ -146,8 +148,8 @@ func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 	return resp, nil
 }
 
-func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.GetIncrementalJoinGroupReq) (*pbgroup.GetIncrementalJoinGroupResp, error) {
+func (s *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.GetIncrementalJoinGroupReq) (*pbgroup.GetIncrementalJoinGroupResp, error) {
-	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
 	opt := incrversion.Option[*sdkws.GroupInfo, pbgroup.GetIncrementalJoinGroupResp]{
@@ -155,9 +157,9 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 		VersionKey:      req.UserID,
 		VersionID:       req.VersionID,
 		VersionNumber:   req.Version,
-		Version:         g.db.FindJoinIncrVersion,
+		Version:         s.db.FindJoinIncrVersion,
-		CacheMaxVersion: g.db.FindMaxJoinGroupVersionCache,
+		CacheMaxVersion: s.db.FindMaxJoinGroupVersionCache,
-		Find:            g.getGroupsInfo,
+		Find:            s.getGroupsInfo,
 		Resp: func(version *model.VersionLog, delIDs []string, insertList, updateList []*sdkws.GroupInfo, full bool) *pbgroup.GetIncrementalJoinGroupResp {
 			return &pbgroup.GetIncrementalJoinGroupResp{
 				VersionID: version.ID.Hex(),
@@ -172,22 +174,29 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 	return opt.Build()
 }
 
-func (g *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
+func (s *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
 	var num int
 	resp := make(map[string]*pbgroup.GetIncrementalGroupMemberResp)
+
 	for _, memberReq := range req.ReqList {
 		if _, ok := resp[memberReq.GroupID]; ok {
 			continue
 		}
-		memberResp, err := g.GetIncrementalGroupMember(ctx, memberReq)
+		memberResp, err := s.GetIncrementalGroupMember(ctx, memberReq)
 		if err != nil {
+			if errors.Is(err, servererrs.ErrDismissedAlready) {
+				log.ZWarn(ctx, "Failed to get incremental group member", err, "groupID", memberReq.GroupID, "request", memberReq)
+				continue
+			}
 			return nil, err
 		}
+
 		resp[memberReq.GroupID] = memberResp
 		num += len(memberResp.Insert) + len(memberResp.Update) + len(memberResp.Delete)
 		if num >= versionSyncLimit {
 			break
 		}
 	}
+
 	return &pbgroup.BatchGetIncrementalGroupMemberResp{RespList: resp}, nil
 }

internal/rpc/relation/sync.go

@@ -56,7 +56,7 @@ func (s *friendServer) GetFullFriendUserIDs(ctx context.Context, req *relation.G
 		userIDs = nil
 	}
 	return &relation.GetFullFriendUserIDsResp{
-		Version:   idHash,
+		Version:   uint64(vl.Version),
 		VersionID: vl.ID.Hex(),
 		Equal:     req.IdHash == idHash,
 		UserIDs:   userIDs,

pkg/common/config/config.go

@@ -354,13 +354,13 @@ type User struct {
 }
 
 type Redis struct {
-	Address     []string `mapstructure:"address"`
+	Address   []string `mapstructure:"address"`
-	Username    string   `mapstructure:"username"`
+	Username  string   `mapstructure:"username"`
-	Password    string   `mapstructure:"password"`
+	Password  string   `mapstructure:"password"`
-	ClusterMode bool     `mapstructure:"clusterMode"`
+	RedisMode string   `mapstructure:"redisMode"`
-	DB          int      `mapstructure:"db"`
+	DB        int      `mapstructure:"db"`
-	MaxRetry    int      `mapstructure:"maxRetry"`
+	MaxRetry  int      `mapstructure:"maxRetry"`
-	PoolSize    int      `mapstructure:"poolSize"`
+	PoolSize  int      `mapstructure:"poolSize"`
 }
 
 type BeforeConfig struct {
@@ -511,13 +511,13 @@ func (m *Mongo) Build() *mongoutil.Config {
 
 func (r *Redis) Build() *redisutil.Config {
 	return &redisutil.Config{
-		ClusterMode: r.ClusterMode,
+		RedisMode: r.RedisMode,
-		Address:     r.Address,
+		Address:   r.Address,
-		Username:    r.Username,
+		Username:  r.Username,
-		Password:    r.Password,
+		Password:  r.Password,
-		DB:          r.DB,
+		DB:        r.DB,
-		MaxRetry:    r.MaxRetry,
+		MaxRetry:  r.MaxRetry,
-		PoolSize:    r.PoolSize,
+		PoolSize:  r.PoolSize,
 	}
 }
 

pkg/common/discoveryregister/discoveryregister.go

@@ -29,7 +29,7 @@ import (
 func NewDiscoveryRegister(discovery *config.Discovery, share *config.Share, watchNames []string) (discovery.SvcDiscoveryRegistry, error) {
 	switch discovery.Enable {
 	case "k8s":
-		return kubernetes.NewKubernetesConnManager("default",
+		return kubernetes.NewConnManager("default", watchNames,
 			grpc.WithDefaultCallOptions(
 				grpc.MaxCallSendMsgSize(1024*1024*20),
 			),

pkg/common/prommetrics/discovery.go

@@ -5,6 +5,7 @@ import "fmt"
 const (
 	APIKeyName             = "api"
 	MessageTransferKeyName = "message-transfer"
+	TTL                    = 300
 )
 
 type Target struct {
@@ -17,10 +18,14 @@ type RespTarget struct {
 	Labels  map[string]string `json:"labels"`
 }
 
-func BuildDiscoveryKey(name string) string {
+func BuildDiscoveryKeyPrefix(name string) string {
 	return fmt.Sprintf("%s/%s/%s", "openim", "prometheus_discovery", name)
 }
 
+func BuildDiscoveryKey(name string, index int) string {
+	return fmt.Sprintf("%s/%s/%s/%d", "openim", "prometheus_discovery", name, index)
+}
+
 func BuildDefaultTarget(host string, ip int) Target {
 	return Target{
 		Target: fmt.Sprintf("%s:%d", host, ip),

pkg/common/startrpc/start.go

@@ -164,9 +164,16 @@ func Start[T any](ctx context.Context, discovery *conf.Discovery, prometheusConf
 				return err
 			}
 
-			etcdClient := client.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+			etcdClient, ok := client.(*etcd.SvcDiscoveryRegistryImpl)
+			if !ok {
+				return errs.New("only etcd support autoSetPorts").Wrap()
+			}
 
-			_, err = etcdClient.Put(ctx, prommetrics.BuildDiscoveryKey(rpcRegisterName), jsonutil.StructToJsonString(prommetrics.BuildDefaultTarget(registerIP, prometheusPort)))
+			target, err := jsonutil.JsonMarshal(prommetrics.BuildDefaultTarget(registerIP, prometheusPort))
+			if err != nil {
+				return errs.Wrap(err)
+			}
+			err = etcdClient.SetWithLease(ctx, prommetrics.BuildDiscoveryKey(rpcRegisterName, index), target, prommetrics.TTL)
 			if err != nil {
 				return errs.WrapMsg(err, "etcd put err")
 			}

pkg/common/storage/database/mgo/friend_request.go

@@ -137,7 +137,7 @@ func (f *FriendRequestMgo) Take(ctx context.Context, fromUserID, toUserID string
 func (f *FriendRequestMgo) GetUnhandledCount(ctx context.Context, userID string, ts int64) (int64, error) {
 	filter := bson.M{"to_user_id": userID, "handle_result": 0}
 	if ts != 0 {
-		filter["create_time"] = bson.M{"$gt": time.Unix(ts, 0)}
+		filter["create_time"] = bson.M{"$gt": time.UnixMilli(ts)}
 	}
 	return mongoutil.Count(ctx, f.coll, filter)
 }

pkg/common/storage/database/mgo/group_request.go

@@ -109,7 +109,7 @@ func (g *GroupRequestMgo) GetUnhandledCount(ctx context.Context, groupIDs []stri
 	}
 	filter := bson.M{"group_id": bson.M{"$in": groupIDs}, "handle_result": 0}
 	if ts != 0 {
-		filter["req_time"] = bson.M{"$gt": time.Unix(ts, 0)}
+		filter["req_time"] = bson.M{"$gt": time.UnixMilli(ts)}
 	}
 	return mongoutil.Count(ctx, g.coll, filter)
 }

pkg/common/storage/database/mgo/msg.go

@@ -5,6 +5,11 @@ import (
 	"fmt"
 	"time"
 
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/constant"
@@ -14,10 +19,6 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/jsonutil"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 func NewMsgMongo(db *mongo.Database) (database.Msg, error) {
@@ -1149,7 +1150,7 @@ func (m *MsgMgo) findBeforeDocSendTime(ctx context.Context, docID string, limit
 	if err != nil {
 		return 0, 0, err
 	}
-	for i := len(res) - 1; i > 0; i-- {
+	for i := len(res) - 1; i >= 0; i-- {
 		v := res[i]
 		if v.Msgs != nil && v.Msgs.Msg != nil && v.Msgs.Msg.SendTime > 0 {
 			return v.Msgs.Msg.Seq, v.Msgs.Msg.SendTime, nil
@@ -1164,7 +1165,7 @@ func (m *MsgMgo) findBeforeSendTime(ctx context.Context, conversationID string,
 		limit := int64(-1)
 		if first {
 			first = false
-			limit = m.model.GetMsgIndex(seq)
+			limit = m.model.GetLimitForSingleDoc(seq)
 		}
 		docID := m.model.BuildDocIDByIndex(conversationID, i)
 		msgSeq, msgSendTime, err := m.findBeforeDocSendTime(ctx, docID, limit)

pkg/common/storage/model/msg.go

@@ -132,6 +132,10 @@ func (*MsgDocModel) GetMsgIndex(seq int64) int64 {
 	return (seq - 1) % singleGocMsgNum
 }
 
+func (*MsgDocModel) GetLimitForSingleDoc(seq int64) int64 {
+	return seq % singleGocMsgNum
+}
+
 func (*MsgDocModel) indexGen(conversationID string, seqSuffix int64) string {
 	return conversationID + ":" + strconv.FormatInt(seqSuffix, 10)
 }

pkg/localcache/cache.go

@@ -49,7 +49,7 @@ func New[V any](opts ...Option) Cache[V] {
 			if opt.expirationEvict {
 				return lru.NewExpirationLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
 			} else {
-				return lru.NewLayLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
+				return lru.NewLazyLRU[string, V](opt.localSlotSize, opt.localSuccessTTL, opt.localFailedTTL, opt.target, c.onEvict)
 			}
 		}
 		if opt.localSlotNum == 1 {
@@ -72,11 +72,18 @@ type cache[V any] struct {
 
 func (c *cache[V]) onEvict(key string, value V) {
 	if c.link != nil {
-		lks := c.link.Del(key)
+		// Do not delete other keys while the underlying LRU still holds its lock;
-		for k := range lks {
+		// defer linked deletions to avoid re-entering the same slot and deadlocking.
-			if key != k { // prevent deadlock
+		if lks := c.link.Del(key); len(lks) > 0 {
-				c.local.Del(k)
+			go c.delLinked(key, lks)
-			}
+		}
+	}
+}
+
+func (c *cache[V]) delLinked(src string, keys map[string]struct{}) {
+	for k := range keys {
+		if src != k {
+			c.local.Del(k)
 		}
 	}
 }
@@ -103,7 +110,7 @@ func (c *cache[V]) Get(ctx context.Context, key string, fetch func(ctx context.C
 func (c *cache[V]) GetLink(ctx context.Context, key string, fetch func(ctx context.Context) (V, error), link ...string) (V, error) {
 	if c.local != nil {
 		return c.local.Get(key, func() (V, error) {
-			if len(link) > 0 {
+			if len(link) > 0 && c.link != nil {
 				c.link.Link(key, link...)
 			}
 			return fetch(ctx)

pkg/localcache/cache_test.go

@@ -22,6 +22,8 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/localcache/lru"
 )
 
 func TestName(t *testing.T) {
@@ -91,3 +93,68 @@ func TestName(t *testing.T) {
 	t.Log("del", del.Load())
 	// 137.35s
 }
+
+// Test deadlock scenario when eviction callback deletes a linked key that hashes to the same slot.
+func TestCacheEvictDeadlock(t *testing.T) {
+	ctx := context.Background()
+	c := New[string](WithLocalSlotNum(1), WithLocalSlotSize(1), WithLazy())
+
+	if _, err := c.GetLink(ctx, "k1", func(ctx context.Context) (string, error) {
+		return "v1", nil
+	}, "k2"); err != nil {
+		t.Fatalf("seed cache failed: %v", err)
+	}
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		_, _ = c.GetLink(ctx, "k2", func(ctx context.Context) (string, error) {
+			return "v2", nil
+		}, "k1")
+	}()
+
+	select {
+	case <-done:
+		// expected to finish quickly; current implementation deadlocks here.
+	case <-time.After(time.Second):
+		t.Fatal("GetLink deadlocked during eviction of linked key")
+	}
+}
+
+func TestExpirationLRUGetBatch(t *testing.T) {
+	l := lru.NewExpirationLRU[string, string](2, time.Minute, time.Second*5, EmptyTarget{}, nil)
+
+	keys := []string{"a", "b"}
+	values, err := l.GetBatch(keys, func(keys []string) (map[string]string, error) {
+		res := make(map[string]string)
+		for _, k := range keys {
+			res[k] = k + "_v"
+		}
+		return res, nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(values) != len(keys) {
+		t.Fatalf("expected %d values, got %d", len(keys), len(values))
+	}
+	for _, k := range keys {
+		if v, ok := values[k]; !ok || v != k+"_v" {
+			t.Fatalf("unexpected value for %s: %q, ok=%v", k, v, ok)
+		}
+	}
+
+	// second batch should hit cache
+	values, err = l.GetBatch(keys, func(keys []string) (map[string]string, error) {
+		t.Fatalf("should not fetch on cache hit")
+		return nil, nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error on cache hit: %v", err)
+	}
+	for _, k := range keys {
+		if v, ok := values[k]; !ok || v != k+"_v" {
+			t.Fatalf("unexpected cached value for %s: %q, ok=%v", k, v, ok)
+		}
+	}
+}

pkg/localcache/lru/lru_expiration.go

@@ -52,8 +52,53 @@ type ExpirationLRU[K comparable, V any] struct {
 }
 
 func (x *ExpirationLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
-	//TODO implement me
+	var (
-	panic("implement me")
+		err     error
+		results = make(map[K]V)
+		misses  = make([]K, 0, len(keys))
+	)
+
+	for _, key := range keys {
+		x.lock.Lock()
+		v, ok := x.core.Get(key)
+		x.lock.Unlock()
+		if ok {
+			x.target.IncrGetHit()
+			v.lock.RLock()
+			results[key] = v.value
+			if v.err != nil && err == nil {
+				err = v.err
+			}
+			v.lock.RUnlock()
+			continue
+		}
+		misses = append(misses, key)
+	}
+
+	if len(misses) == 0 {
+		return results, err
+	}
+
+	fetchValues, fetchErr := fetch(misses)
+	if fetchErr != nil && err == nil {
+		err = fetchErr
+	}
+
+	for key, val := range fetchValues {
+		results[key] = val
+		if fetchErr != nil {
+			x.target.IncrGetFailed()
+			continue
+		}
+		x.target.IncrGetSuccess()
+		item := &expirationLruItem[V]{value: val}
+		x.lock.Lock()
+		x.core.Add(key, item)
+		x.lock.Unlock()
+	}
+
+	// any keys not returned from fetch remain absent (no cache write)
+	return results, err
 }
 
 func (x *ExpirationLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {

pkg/localcache/lru/lru_lazy.go

@@ -21,25 +21,25 @@ import (
 	"github.com/hashicorp/golang-lru/v2/simplelru"
 )
 
-type layLruItem[V any] struct {
+type lazyLruItem[V any] struct {
 	lock    sync.Mutex
 	expires int64
 	err     error
 	value   V
 }
 
-func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LayLRU[K, V] {
+func NewLazyLRU[K comparable, V any](size int, successTTL, failedTTL time.Duration, target Target, onEvict EvictCallback[K, V]) *LazyLRU[K, V] {
-	var cb simplelru.EvictCallback[K, *layLruItem[V]]
+	var cb simplelru.EvictCallback[K, *lazyLruItem[V]]
 	if onEvict != nil {
-		cb = func(key K, value *layLruItem[V]) {
+		cb = func(key K, value *lazyLruItem[V]) {
 			onEvict(key, value.value)
 		}
 	}
-	core, err := simplelru.NewLRU[K, *layLruItem[V]](size, cb)
+	core, err := simplelru.NewLRU[K, *lazyLruItem[V]](size, cb)
 	if err != nil {
 		panic(err)
 	}
-	return &LayLRU[K, V]{
+	return &LazyLRU[K, V]{
 		core:       core,
 		successTTL: successTTL,
 		failedTTL:  failedTTL,
@@ -47,15 +47,15 @@ func NewLayLRU[K comparable, V any](size int, successTTL, failedTTL time.Duratio
 	}
 }
 
-type LayLRU[K comparable, V any] struct {
+type LazyLRU[K comparable, V any] struct {
 	lock       sync.Mutex
-	core       *simplelru.LRU[K, *layLruItem[V]]
+	core       *simplelru.LRU[K, *lazyLruItem[V]]
 	successTTL time.Duration
 	failedTTL  time.Duration
 	target     Target
 }
 
-func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
+func (x *LazyLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 	x.lock.Lock()
 	v, ok := x.core.Get(key)
 	if ok {
@@ -68,7 +68,7 @@ func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 			return value, err
 		}
 	} else {
-		v = &layLruItem[V]{}
+		v = &lazyLruItem[V]{}
 		x.core.Add(key, v)
 		v.lock.Lock()
 		x.lock.Unlock()
@@ -88,15 +88,15 @@ func (x *LayLRU[K, V]) Get(key K, fetch func() (V, error)) (V, error) {
 	return v.value, v.err
 }
 
-func (x *LayLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
+func (x *LazyLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error)) (map[K]V, error) {
 	var (
 		err  error
 		once sync.Once
 	)
 
 	res := make(map[K]V)
-	queries := make([]K, 0)
+	queries := make([]K, 0, len(keys))
-	setVs := make(map[K]*layLruItem[V])
+
 	for _, key := range keys {
 		x.lock.Lock()
 		v, ok := x.core.Get(key)
@@ -118,14 +118,20 @@ func (x *LayLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error))
 		}
 		queries = append(queries, key)
 	}
-	values, err1 := fetch(queries)
+
-	if err1 != nil {
+	if len(queries) == 0 {
+		return res, err
+	}
+
+	values, fetchErr := fetch(queries)
+	if fetchErr != nil {
 		once.Do(func() {
-			err = err1
+			err = fetchErr
 		})
 	}
+
 	for key, val := range values {
-		v := &layLruItem[V]{}
+		v := &lazyLruItem[V]{}
 		v.value = val
 
 		if err == nil {
@@ -135,7 +141,7 @@ func (x *LayLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error))
 			v.expires = time.Now().Add(x.failedTTL).UnixMilli()
 			x.target.IncrGetFailed()
 		}
-		setVs[key] = v
+
 		x.lock.Lock()
 		x.core.Add(key, v)
 		x.lock.Unlock()
@@ -145,29 +151,29 @@ func (x *LayLRU[K, V]) GetBatch(keys []K, fetch func(keys []K) (map[K]V, error))
 	return res, err
 }
 
-//func (x *LayLRU[K, V]) Has(key K) bool {
+//func (x *LazyLRU[K, V]) Has(key K) bool {
 //	x.lock.Lock()
 //	defer x.lock.Unlock()
 //	return x.core.Contains(key)
 //}
 
-func (x *LayLRU[K, V]) Set(key K, value V) {
+func (x *LazyLRU[K, V]) Set(key K, value V) {
 	x.lock.Lock()
 	defer x.lock.Unlock()
-	x.core.Add(key, &layLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+	x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
 }
 
-func (x *LayLRU[K, V]) SetHas(key K, value V) bool {
+func (x *LazyLRU[K, V]) SetHas(key K, value V) bool {
 	x.lock.Lock()
 	defer x.lock.Unlock()
 	if x.core.Contains(key) {
-		x.core.Add(key, &layLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
+		x.core.Add(key, &lazyLruItem[V]{value: value, expires: time.Now().Add(x.successTTL).UnixMilli()})
 		return true
 	}
 	return false
 }
 
-func (x *LayLRU[K, V]) Del(key K) bool {
+func (x *LazyLRU[K, V]) Del(key K) bool {
 	x.lock.Lock()
 	ok := x.core.Remove(key)
 	x.lock.Unlock()
@@ -179,6 +185,6 @@ func (x *LayLRU[K, V]) Del(key K) bool {
 	return ok
 }
 
-func (x *LayLRU[K, V]) Stop() {
+func (x *LazyLRU[K, V]) Stop() {
 
 }

pkg/msgprocessor/conversation.go

@@ -109,7 +109,7 @@ func GetConversationIDBySessionType(sessionType int, ids ...string) string {
 	case constant.ReadGroupChatType:
 		return "sg_" + ids[0] // super group chat
 	case constant.NotificationChatType:
-		return "sn_" + ids[0] // server notification chat
+		return "sn_" + strings.Join(ids, "_") // server notification chat
 	}
 	return ""
 }

pkg/rpccache/online.go

@@ -3,15 +3,16 @@ package rpccache
 import (
 	"context"
 	"fmt"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	"github.com/openimsdk/protocol/constant"
-	"github.com/openimsdk/protocol/user"
 	"math/rand"
 	"strconv"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/protocol/user"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/cachekey"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache/lru"
@@ -46,7 +47,7 @@ func NewOnlineCache(client *rpcli.UserClient, group *GroupLocalCache, rdb redis.
 	case false:
 		log.ZDebug(ctx, "fullUserCache is false")
 		x.lruCache = lru.NewSlotLRU(1024, localcache.LRUStringHash, func() lru.LRU[string, []int32] {
-			return lru.NewLayLRU[string, []int32](2048, cachekey.OnlineExpire/2, time.Second*3, localcache.EmptyTarget{}, func(key string, value []int32) {})
+			return lru.NewLazyLRU[string, []int32](2048, cachekey.OnlineExpire/2, time.Second*3, localcache.EmptyTarget{}, func(key string, value []int32) {})
 		})
 		x.CurrentPhase.Store(DoSubscribeOver)
 		x.Cond.Broadcast()

version/version

@@ -1 +1 @@
-v3.8.3
+v3.8.3-patch.14