NameServer启动

最新推荐文章于 2024-06-17 22:05:12 发布

EASON_93

最新推荐文章于 2024-06-17 22:05:12 发布

阅读量612

点赞数

分类专栏：开源技术 RocketMq

本文链接：https://blog.youkuaiyun.com/zrqsyh/article/details/116062100

版权

开源技术同时被 2 个专栏收录

2 篇文章

订阅专栏

RocketMq

1 篇文章

订阅专栏

本文详细介绍了RocketMQ NameServer的启动过程，包括源码启动准备、NameServer的作用、启动入口及初始化流程。NameServer作为注册中心，负责Broker的注册与查询，其内部通过NettyServer进行网络通信，并使用固定线程池处理请求。在启动过程中，NameServer会定时扫描无响应的Broker并删除，确保信息的准确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

RocketMq学习

1.源码启动准备

参考文章：https://www.cnblogs.com/shuiyj/p/13215978.html

启动nameserver：需要配置ROCKETMQ_HOME（运行环境）

ROCKETMQ_HOME建立conf,logs,store目录，源码里面的distrbution中的logback_namesvr.xml放在conf模块下面，替换${user.home}为ROCKETMQ_HOME

2.解析NameServer

作用

nameserver类似于zk，是一个注册中心。但它实例之间不进行通信，每台nameserver只保存自己的信息。Broker可以从任意一台Nameserver中获取数据。

NameServer的启动

在这里插入图片描述

启动入口

public static NamesrvController main0(String[] args) {

        try {
            //启动入口
            NamesrvController controller = createNamesrvController(args);
            start(controller);
            String tip = "The Name Server boot success. serializeType=" + RemotingCommand.getSerializeTypeConfigInThisServer();
            log.info(tip);
            System.out.printf("%s%n", tip);
            return controller;
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(-1);
        }

        return null;
    }

初始化NameServer

public static NamesrvController createNamesrvController(String[] args) throws IOException, JoranException {
        System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION));

        Options options = ServerUtil.buildCommandlineOptions(new Options());
        commandLine = ServerUtil.parseCmdLine("mqnamesrv", args, buildCommandlineOptions(options), new PosixParser());
        if (null == commandLine) {
            System.exit(-1);
            return null;
        }

        final NamesrvConfig namesrvConfig = new NamesrvConfig();
        final NettyServerConfig nettyServerConfig = new NettyServerConfig();
        nettyServerConfig.setListenPort(9876);
        //省略，判断服务加载配置

        MixAll.properties2Object(ServerUtil.commandLine2Properties(commandLine), namesrvConfig);

        if (null == namesrvConfig.getRocketmqHome()) {
            System.out.printf("Please set the %s variable in your environment to match the location of the RocketMQ installation%n", MixAll.ROCKETMQ_HOME_ENV);
            System.exit(-2);
        }

        LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
        JoranConfigurator configurator = new JoranConfigurator();
        configurator.setContext(lc);
        lc.reset();
    	//读取日志的配置文件
        configurator.doConfigure(namesrvConfig.getRocketmqHome() + "/conf/logback_namesrv.xml");

        log = InternalLoggerFactory.getLogger(LoggerName.NAMESRV_LOGGER_NAME);

        MixAll.printObjectProperties(log, namesrvConfig);
        MixAll.printObjectProperties(log, nettyServerConfig);
		//namesrvConfig的配置文件，nettyServerConfig这个是netty启动的配置文件
        final NamesrvController controller = new NamesrvController(namesrvConfig, nettyServerConfig);

        // remember all configs to prevent discard
        controller.getConfiguration().registerConfig(properties);

        return controller;
    }

启动以后，初始化controller，代码入口controller.initialize();

public boolean initialize() {

        //初始化配置文件，读取之前的配置信息
        this.kvConfigManager.load();

        //初始化远程连接 server
        this.remotingServer = new NettyRemotingServer(this.nettyServerConfig, this.brokerHousekeepingService);

        //多线程处理器配置
        this.remotingExecutor =
            Executors.newFixedThreadPool(nettyServerConfig.getServerWorkerThreads(), new ThreadFactoryImpl("RemotingExecutorThread_"));

        //线程池和处理器绑定
        this.registerProcessor();

        //定时10S，扫描没有链接的broker
        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                NamesrvController.this.routeInfoManager.scanNotActiveBroker();
            }
        }, 5, 10, TimeUnit.SECONDS);

        //定时10S，打印配置信息
        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                NamesrvController.this.kvConfigManager.printAllPeriodically();
            }
        }, 1, 10, TimeUnit.MINUTES);

        //监听ssl证书更新
        if (TlsSystemConfig.tlsMode != TlsMode.DISABLED) {
            //....没关心这个，没研究
        }

        return true;
    }

初始化配置文件this.kvConfigManager.load()

//配置项数据结构
private final HashMap<String/* Namespace */, HashMap<String/* Key */, String/* Value */>> configTable;

public void load() {
        String content = null;
        try {
            //每次写入配置文件的时候，他都会持久化
            //重启的时候直接读取
            content = MixAll.file2String(this.namesrvController.getNamesrvConfig().getKvConfigPath());
        } catch (IOException e) {
            log.warn("Load KV config table exception", e);
        }
        //key value 读取到配置文件
        if (content != null) {
            KVConfigSerializeWrapper kvConfigSerializeWrapper =
                KVConfigSerializeWrapper.fromJson(content, KVConfigSerializeWrapper.class);
            if (null != kvConfigSerializeWrapper) {
                this.configTable.putAll(kvConfigSerializeWrapper.getConfigTable());
                log.info("load KV config table OK");
            }
        }
    }

NOTE 关于持久化：写入的config.json，上一次的数据文件是config.json.bak

初始化NettyRemoteServer

 public NettyRemotingServer(final NettyServerConfig nettyServerConfig,
        final ChannelEventListener channelEventListener) {
        super(nettyServerConfig.getServerOnewaySemaphoreValue(), nettyServerConfig.getServerAsyncSemaphoreValue());
        this.serverBootstrap = new ServerBootstrap();
        this.nettyServerConfig = nettyServerConfig;
        this.channelEventListener = channelEventListener;

        int publicThreadNums = nettyServerConfig.getServerCallbackExecutorThreads();
        if (publicThreadNums <= 0) {
            publicThreadNums = 4;
        }

        this.publicExecutor = Executors.newFixedThreadPool(publicThreadNums, new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);

            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "NettyServerPublicExecutor_" + this.threadIndex.incrementAndGet());
            }
        });

        //初始化worker线程和boss线程处理器
     	//EpollEventLoopGroup在Linux的环境下面要比NioEventLoopGroup要好，这边判断一次来获取更好的服务性能
        if (useEpoll()) {
            this.eventLoopGroupBoss = new EpollEventLoopGroup(1, new ThreadFactory() {
                //省略，初始化配置项
            });

            this.eventLoopGroupSelector = new EpollEventLoopGroup(
            //省略，初始化配置项
            );
        } else {
            this.eventLoopGroupBoss = new NioEventLoopGroup(1, new ThreadFactory() {
                //省略，初始化配置项
            });

            this.eventLoopGroupSelector = new NioEventLoopGroup(nettyServerConfig.getServerSelectorThreads(), new ThreadFactory() {
                //省略，初始化配置项});
        }

        //配置HTTPS的信息，跳过不研究先 todo
        loadSslContext();
    }

注册请求处理器

private void registerProcessor() {
    if (namesrvConfig.isClusterTest()) {

        this.remotingServer.registerDefaultProcessor(new ClusterTestRequestProcessor(this, namesrvConfig.getProductEnvName()),
            this.remotingExecutor);
    } else {
		//注册默认的执行服务器，带了默认的线程管理器；用来异步执行使用
        this.remotingServer.registerDefaultProcessor(new DefaultRequestProcessor(this), this.remotingExecutor);
    }
}

上诉的处理器是用来执行监听的Netty事件，包含了N多的事件；在Nameserver的管理只用到了Broker注册，注销相关的事件

public RemotingCommand processRequest(ChannelHandlerContext ctx,
    RemotingCommand request) throws RemotingCommandException {

    if (ctx != null) {
        log.debug("receive request, {} {} {}",
            request.getCode(),
            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
            request);
    }

    switch (request.getCode()) {
        //.....省略
        case RequestCode.REGISTER_BROKER:
            Version brokerVersion = MQVersion.value2Version(request.getVersion());
            if (brokerVersion.ordinal() >= MQVersion.Version.V3_0_11.ordinal()) {
                return this.registerBrokerWithFilterServer(ctx, request);
            } else {
                return this.registerBroker(ctx, request);
            }
        case RequestCode.UNREGISTER_BROKER:
            return this.unregisterBroker(ctx, request);
        //....省略
        default:
            break;
    }
    return null;
}

删除无用的broker信息

public void scanNotActiveBroker() {
    Iterator<Entry<String, BrokerLiveInfo>> it = this.brokerLiveTable.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, BrokerLiveInfo> next = it.next();
        long last = next.getValue().getLastUpdateTimestamp();
        //过期时间已经超过上次上报的时间，直接删除
        if ((last + BROKER_CHANNEL_EXPIRED_TIME) < System.currentTimeMillis()) {
            RemotingUtil.closeChannel(next.getValue().getChannel());
            it.remove();
            log.warn("The broker channel expired, {} {}ms", next.getKey(), BROKER_CHANNEL_EXPIRED_TIME);
            this.onChannelDestroy(next.getKey(), next.getValue().getChannel());
        }
    }
}

注册JVM的钩子函数，可以用来优雅停机（暂时无研究，mark一下，以后看一下）

Runtime.getRuntime().addShutdownHook(new ShutdownHookThread(log, new Callable<Void>() {
    @Override
    public Void call() throws Exception {
        controller.shutdown();
        return null;
    }
}));

启动Nameserver

public void start() {
    this.defaultEventExecutorGroup = new DefaultEventExecutorGroup(
        nettyServerConfig.getServerWorkerThreads(),
        new ThreadFactory() {

            private AtomicInteger threadIndex = new AtomicInteger(0);

            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "NettyServerCodecThread_" + this.threadIndex.incrementAndGet());
            }
        });

    //初始化请求一些处理器
    prepareSharableHandlers();

    ServerBootstrap childHandler =
        this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupSelector)
            .channel(useEpoll() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG, 1024)
            .option(ChannelOption.SO_REUSEADDR, true)
            .option(ChannelOption.SO_KEEPALIVE, false)
            .childOption(ChannelOption.TCP_NODELAY, true)
            .childOption(ChannelOption.SO_SNDBUF, nettyServerConfig.getServerSocketSndBufSize())
            .childOption(ChannelOption.SO_RCVBUF, nettyServerConfig.getServerSocketRcvBufSize())
            .localAddress(new InetSocketAddress(this.nettyServerConfig.getListenPort()))
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline()
                        .addLast(defaultEventExecutorGroup, HANDSHAKE_HANDLER_NAME, handshakeHandler)
                        .addLast(defaultEventExecutorGroup,
                            encoder,
                            new NettyDecoder(),
                            new IdleStateHandler(0, 0, nettyServerConfig.getServerChannelMaxIdleTimeSeconds()),
                            connectionManageHandler,
                            serverHandler
                        );
                }
            });

    if (nettyServerConfig.isServerPooledByteBufAllocatorEnable()) {
        childHandler.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
    }

    try {
        ChannelFuture sync = this.serverBootstrap.bind().sync();
        InetSocketAddress addr = (InetSocketAddress) sync.channel().localAddress();
        this.port = addr.getPort();
    } catch (InterruptedException e1) {
        throw new RuntimeException("this.serverBootstrap.bind().sync() InterruptedException", e1);
    }

    //监听Netty的Event事件
    if (this.channelEventListener != null) {
        this.nettyEventExecutor.start();
    }

    //清理一波超出请求时间的请求
    this.timer.scheduleAtFixedRate(new TimerTask() {

        @Override
        public void run() {
            try {
                NettyRemotingServer.this.scanResponseTable();
            } catch (Throwable e) {
                log.error("scanResponseTable exception", e);
            }
        }
    }, 1000 * 3, 1000);
}

3.NameServer好玩的东西

BrokerHousekeepingService 自定义的事件驱动模型
为啥不直接触发删除流程？后续删除表结构逻辑复杂，解耦
BrokerHousekeepingService 处理的org.apache.rocketmq.remoting.netty.NettyRemotingAbstract.NettyEventExecutor#eventQueue的长度有限，怎么处理丢弃的事件？

猜想：队列已经够长了（10000个），如果还来不及处理那就直接丢弃。里面的broker的数据存在脏数据就存在吧