07、Sentinel实战:setToServer()

启动独立 Sentinel token server 端口并实际连接,区分本地启动、模式字段与规则处理能力。

简明结论

服务端模式、端口监听与 token 规则正确生效需要分别核对,不能用一个状态值替代全部验证。

setToServer 会尝试停止本地客户端,再通过 SPI 取得嵌入式 token server 并启动。mode 在启动前设置,因此失败路径也必须查看返回值、日志和实际监听状态;isServer 本身不是完整健康检查。

固定版本的启动与连接

复用共享 POM,配置 server-default 和 client-default 1.8.6。本例选择本轮空闲端口,加载 transport 配置,启动后用本地 TCP 连接核对监听;finally 切回未启动模式释放资源。

package site;

import com.alibaba.csp.sentinel.cluster.ClusterStateManager;
import com.alibaba.csp.sentinel.cluster.server.config.ClusterServerConfigManager;
import com.alibaba.csp.sentinel.cluster.server.config.ServerTransportConfig;
import java.net.ServerSocket;
import java.net.Socket;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class SentinelServerModeTest {
  @Test void startsAnOwnedTokenServerPort() throws Exception {
    int port;
    try (var free=new ServerSocket(0)) { port=free.getLocalPort(); }
    ClusterServerConfigManager.loadGlobalTransportConfig(new ServerTransportConfig().setPort(port));
    try {
      assertTrue(ClusterStateManager.setToServer());
      assertTrue(ClusterStateManager.isServer());
      try (var socket=new Socket("127.0.0.1",port)) { assertTrue(socket.isConnected()); }
      System.out.println("server-mode=true; loopback-connect=true; token-rules-tested=false");
    } finally { ClusterStateManager.applyState(ClusterStateManager.CLUSTER_NOT_STARTED); }
  }
}
mvn -Dtest=SentinelServerModeTest test

实际结果与边界

本次输出 server-mode=true; loopback-connect=true; token-rules-tested=false。测试只说明本轮 JVM 能启动并接受一个连接,不证明 namespace/flowId 规则或配额分配正确。

本轮最初的无外网容器无法解析自己的随机主机名,出现过监听已开始而嵌入式连接登记失败的情况。最终容器显式使用可解析的 localhost 主机名后检查通过,未修改宿主网络。这也说明应分别观察模式、启动结果和服务操作,不能只看截图中的一行“启动”。

后续若做集群规则测试,需要明确请求协议、规则分发、客户端数量、阈值模式、失败策略与清理方式。本轮未验证 HA、跨主机通信、控制台或生产配额精度。

下一步阅读

原资料片段(未重建原环境)

下方保留原资料的上下文、示例与截图;本轮验证只对应上方新增文件,未将旧运行结果记为本轮结果。

    public static boolean setToServer() {
        if (mode == 1) {
            return true;
        } else {
            mode = 1;
            sleepIfNeeded();
            lastModified = TimeUtil.currentTimeMillis();
			//启动server
            return startServer();
        }
    }
    private static boolean startServer() {
        try {
            ClusterTokenClient tokenClient = TokenClientProvider.getClient();
            if (tokenClient != null) {
                tokenClient.stop();
            }
			//获取server并启动
            EmbeddedClusterTokenServer server = EmbeddedClusterTokenServerProvider.getServer();
            if (server != null) {
                //启动server(实际上是启动一个netty server)
                server.start();
                RecordLog.info("[ClusterStateManager] Changing cluster mode to server", new Object[0]);
                return true;
            } else {
                RecordLog.warn("[ClusterStateManager] Cannot change to server (no server SPI found)", new Object[0]);
                return false;
            }
        } catch (Exception var2) {
            RecordLog.warn("[ClusterStateManager] Error when changing cluster mode to server", var2);
            return false;
        }
    }
public final class EmbeddedClusterTokenServerProvider {
    private static EmbeddedClusterTokenServer server = null;

    static {
        //类加载的时候加载spiEmbeddedClusterTokenServer
        resolveInstance();
    }
    
    private static void resolveInstance() {
        EmbeddedClusterTokenServer s = (EmbeddedClusterTokenServer)SpiLoader.of(EmbeddedClusterTokenServer.class).loadFirstInstance();
        if (s == null) {
            RecordLog.warn("[EmbeddedClusterTokenServerProvider] No existing cluster token server, cluster server mode will not be activated", new Object[0]);
        } else {
            server = s;
            RecordLog.info("[EmbeddedClusterTokenServerProvider] Cluster token server resolved: {}", new Object[]{server.getClass().getCanonicalName()});
        }

    }
    //返回server
    public static EmbeddedClusterTokenServer getServer() {
        return server;
    }
}

 

com.alibaba.csp.sentinel.cluster.server.DefaultEmbeddedTokenServer

DefaultEmbeddedTokenServer

public class DefaultEmbeddedTokenServer implements EmbeddedClusterTokenServer {
    private final TokenService tokenService = TokenServiceProvider.getService();
    private final ClusterTokenServer server = new SentinelDefaultTokenServer(true);

    public DefaultEmbeddedTokenServer() {
    }

    public void start() throws Exception {
        this.server.start();
    }

    public void stop() throws Exception {
        this.server.stop();
    }

    public TokenResult requestToken(Long ruleId, int acquireCount, boolean prioritized) {
        return this.tokenService != null ? this.tokenService.requestToken(ruleId, acquireCount, prioritized) : new TokenResult(-1);
    }

    public TokenResult requestParamToken(Long ruleId, int acquireCount, Collection<Object> params) {
        return this.tokenService != null ? this.tokenService.requestParamToken(ruleId, acquireCount, params) : new TokenResult(-1);
    }

    public TokenResult requestConcurrentToken(String clientAddress, Long ruleId, int acquireCount) {
        return null;
    }

    public void releaseConcurrentToken(Long tokenId) {
    }
}

SentinelDefaultTokenServer

    public SentinelDefaultTokenServer() {
        this(false);
    }

    public SentinelDefaultTokenServer(boolean embedded) {
        this.shouldStart = new AtomicBoolean(false);
        this.embedded = embedded;
        //ClusterServerConfigManager添加监听
        ClusterServerConfigManager.addTransportConfigChangeObserver(new ServerTransportConfigObserver() {
            public void onTransportConfigChange(ServerTransportConfig config) {
                SentinelDefaultTokenServer.this.changeServerConfig(config);
            }
        });
        //初始化server
        this.initNewServer();
    }

    private void initNewServer() {
        if (this.server == null) {
            int port = ClusterServerConfigManager.getPort();
            if (port > 0) {
                //server为一个netty server
                this.server = new NettyTransportServer(port);
                this.port = port;
            }

        }
    }

版权声明:本文不是「本站」原创文章,版权归原作者所有 | 原文地址: