From 41a81133f1f8479358ccf72655fa49b763fcdbe1 Mon Sep 17 00:00:00 2001 From: wujiawei <12345678> Date: Fri, 13 Dec 2024 13:35:35 +0800 Subject: [PATCH] =?UTF-8?q?[fix]=20=20=E4=BC=98=E5=8C=96tcp=E6=9E=B6?= =?UTF-8?q?=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...UdpHandleChannelHeartbeatTypeAdvanced.java | 28 ++++++++++++ ...tHandleUdpClientChannelActiveAdvanced.java | 25 +++++++++++ ...ClientPermeateClientCloseTypeAdvanced.java | 28 ++++++++++++ ...eClientPermeateClientInitTypeAdvanced.java | 28 ++++++++++++ ...rmeateClientTransferCloseTypeAdvanced.java | 28 ++++++++++++ ...ClientPermeateServerCloseTypeAdvanced.java | 28 ++++++++++++ ...eClientPermeateServerInitTypeAdvanced.java | 28 ++++++++++++ ...rmeateServerTransferCloseTypeAdvanced.java | 28 ++++++++++++ ...entPermeateServerTransferTypeAdvanced.java | 28 ++++++++++++ ...annelConnectionSuccessfulTypeAdvanced.java | 28 ++++++++++++ ...eateChannelInitSuccessfulTypeAdvanced.java | 28 ++++++++++++ ...ientTransferClientRequestTypeAdvanced.java | 28 ++++++++++++ ...annelConnectionSuccessfulTypeAdvanced.java | 28 ++++++++++++ ...ributeClusterNodeRegisterTypeAdvanced.java | 27 ++++++++++++ ...SuccessNotificationTypeAdvancedHandle.java | 23 ++++++++++ ...istributeDisconnectTypeAdvancedHandle.java | 26 +++++++++++ ...PermeateClientRealConnectTypeAdvanced.java | 25 +++++++++++ ...entTransferClientResponseTypeAdvanced.java | 28 ++++++++++++ ...icePermeateClientTransferTypeAdvanced.java | 27 ++++++++++++ ...ributeSingleClientMessageTypeAdvanced.java | 25 +++++++++++ ...ClientRealAutoReadConnectTypeAdvanced.java | 27 ++++++++++++ ...gleClientRealCloseVisitorTypeAdvanced.java | 25 +++++++++++ ...dpDistributeStagingClosedTypeAdvanced.java | 25 +++++++++++ ...dpDistributeStagingOpenedTypeAdvanced.java | 25 +++++++++++ ...leUdpClientConnectSuccessTypeAdvanced.java | 25 +++++++++++ ...ClientPermeateClientCloseTypeAdvanced.java | 27 ++++++++++++ ...tClientPermeateClientInitTypeAdvanced.java | 27 ++++++++++++ ...rmeateClientTransferCloseTypeAdvanced.java | 27 ++++++++++++ ...ClientPermeateServerCloseTypeAdvanced.java | 27 ++++++++++++ ...tClientPermeateServerInitTypeAdvanced.java | 27 ++++++++++++ ...rmeateServerTransferCloseTypeAdvanced.java | 27 ++++++++++++ ...entPermeateServerTransferTypeAdvanced.java | 27 ++++++++++++ ...annelConnectionSuccessfulTypeAdvanced.java | 27 ++++++++++++ ...eateChannelInitSuccessfulTypeAdvanced.java | 27 ++++++++++++ ...entTransferClientResponseTypeAdvanced.java | 27 ++++++++++++ ...eportClientTransferClientTypeAdvanced.java | 27 ++++++++++++ ...annelConnectionSuccessfulTypeAdvanced.java | 27 ++++++++++++ ...ReportClusterNodeRegisterTypeAdvanced.java | 27 ++++++++++++ ...HandleUdpReportDisconnectTypeAdvanced.java | 27 ++++++++++++ ...ReportServerChannelActiveTypeAdvanced.java | 27 ++++++++++++ ...ermeateClientCloseVisitorTypeAdvanced.java | 27 ++++++++++++ ...PermeateClientRealConnectTypeAdvanced.java | 27 ++++++++++++ ...icePermeateClientTransferTypeAdvanced.java | 27 ++++++++++++ ...ClientMessage2OtherClientTypeAdvanced.java | 27 ++++++++++++ ...dleUdpReportStagingClosedTypeAdvanced.java | 29 ++++++++++++ ...dleUdpReportStagingOpenedTypeAdvanced.java | 25 +++++++++++ .../config/HeartbeatServerConfiguration.java | 6 +-- ...ttyTcpServerSocketApplicationListener.java | 10 ++--- ...ttyUdpServerSocketApplicationListener.java | 10 ++--- .../server/init/InitServerSocket.java | 8 ++-- ...andleTcpChannelHeartbeatTypeAdvanced.java} | 2 +- ...annelConnectionSuccessfulTypeAdvanced.java | 4 +- ...HandleTcpReportDisconnectTypeAdvanced.java | 6 +-- ...ttyTcpClientPermeateServerRealFilter.java} | 6 +-- ...rFilter.java => NettyTcpServerFilter.java} | 8 ++-- ...TcpServerPermeateClientVisitorFilter.java} | 8 ++-- ...ttyTcpServerPermeateServerRealFilter.java} | 8 ++-- ...TcpServerPermeateServerVisitorFilter.java} | 8 ++-- .../tcp/handler/HeartBeatServerHandler.java | 44 ------------------- ...ava => LazyTcpServerIdleStateHandler.java} | 18 ++++---- ...tyTcpClientPermeateServerRealHandler.java} | 2 +- ...andler.java => NettyTcpServerHandler.java} | 4 +- ...cpServerPermeateClientVisitorHandler.java} | 4 +- ...tyTcpServerPermeateServerRealHandler.java} | 2 +- ...cpServerPermeateServerVisitorHandler.java} | 8 ++-- .../socket/NettyOnCloudNettyServerSocket.java | 10 ++--- ...lientPermeateServerConnectRealSocket.java} | 6 +-- ...TcpServerPermeateClientVisitorSocket.java} | 18 ++++---- ...erverPermeateServerConnectRealSocket.java} | 6 +-- ...erPermeateServerConnectVisitorSocket.java} | 24 +++++----- ...rPermeateClientMappingApplicationImpl.java | 20 ++++----- ...rPermeateServerMappingApplicationImpl.java | 12 ++--- .../LazyNettyClientStateApplicationImpl.java | 10 ++--- 73 files changed, 1350 insertions(+), 158 deletions(-) create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java create mode 100644 wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/{ServerTcpTcpHandleChannelHeartbeatTypeAdvanced.java => ServerHandleTcpChannelHeartbeatTypeAdvanced.java} (88%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/{ClientPermeateServerRealFilter.java => NettyTcpClientPermeateServerRealFilter.java} (82%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/{NettyServerFilter.java => NettyTcpServerFilter.java} (86%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/{NettyServerPermeateClientVisitorFilter.java => NettyTcpServerPermeateClientVisitorFilter.java} (78%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/{NettyServerPermeateServerRealFilter.java => NettyTcpServerPermeateServerRealFilter.java} (86%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/{NettyServerPermeateServerVisitorFilter.java => NettyTcpServerPermeateServerVisitorFilter.java} (77%) delete mode 100644 wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{LazyServerIdleStateHandler.java => LazyTcpServerIdleStateHandler.java} (97%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{NettyClientPermeateServerRealHandler.java => NettyTcpClientPermeateServerRealHandler.java} (97%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{NettyServerHandler.java => NettyTcpServerHandler.java} (97%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{NettyServerPermeateClientVisitorHandler.java => NettyTcpServerPermeateClientVisitorHandler.java} (97%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{NettyServerPermeateServerRealHandler.java => NettyTcpServerPermeateServerRealHandler.java} (96%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/{NettyServerPermeateServerVisitorHandler.java => NettyTcpServerPermeateServerVisitorHandler.java} (91%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/{NettyClientPermeateServerConnectRealSocket.java => NettyTcpClientPermeateServerConnectRealSocket.java} (95%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/{NettyServerPermeateClientVisitorSocket.java => NettyTcpServerPermeateClientVisitorSocket.java} (88%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/{NettyServerPermeateServerConnectRealSocket.java => NettyTcpServerPermeateServerConnectRealSocket.java} (95%) rename wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/{NettyServerPermeateServerConnectVisitorSocket.java => NettyTcpServerPermeateServerConnectVisitorSocket.java} (83%) diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java new file mode 100644 index 0000000..96fbb3e --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端 处理客户端心跳 + * TYPE_HEARTBEAT + */ + +public abstract class AbstractUdpHandleChannelHeartbeatTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.TYPE_HEARTBEAT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java new file mode 100644 index 0000000..dcfc3af --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 客户端通道 is active + */ + +public abstract class AbstractHandleUdpClientChannelActiveAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.CLIENT_CHANNEL_ACTIVE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java new file mode 100644 index 0000000..5088bed --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透客户端init close 信息 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE + */ +public abstract class AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java new file mode 100644 index 0000000..9b8af5d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透客户端init信息 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT + */ +public abstract class AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..8e5c1b3 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发客户端渗透客户端通信通道关闭 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE + */ +public abstract class AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java new file mode 100644 index 0000000..f2bab20 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透服务端init close 信息 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE + */ +public abstract class AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java new file mode 100644 index 0000000..ecc396f --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透服务端init信息 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT + */ +public abstract class AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..aef8a95 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透服务端通信通道关闭 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE + */ +public abstract class AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java new file mode 100644 index 0000000..95f814c --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透服务端通信传输 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER + */ +public abstract class AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..b49e73d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透客户端数据传输通道连接成功 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..d0ca6c4 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透客户端数据传输通道init 成功 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java new file mode 100644 index 0000000..728809f --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发客户端渗透客户端数据传输 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST + */ +public abstract class AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..18d61b0 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 客户端渗透服务端数据传输通道连接成功 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java new file mode 100644 index 0000000..933fefb --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发 集群注册 + * @see MessageTypeEnums#DISTRIBUTE_CLUSTER_NODE_REGISTER_MESSAGE + */ +public abstract class AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java new file mode 100644 index 0000000..94fec0a --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java @@ -0,0 +1,23 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端连接成功通知 + */ +public abstract class AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_CONNECTION_SUCCESS_NOTIFICATION.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java new file mode 100644 index 0000000..eaa11b4 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java @@ -0,0 +1,26 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发客户端断开连接通知 + * DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION + */ +public abstract class AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + // 下发 客户端断开连接通知 + return MessageTypeEnums.DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java new file mode 100644 index 0000000..70e2557 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端 创建真实连接 + */ + +public abstract class AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java new file mode 100644 index 0000000..d225b55 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java @@ -0,0 +1,28 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 下发客户端渗透客户端数据传输响应 + * + * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE + */ +public abstract class AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java new file mode 100644 index 0000000..211dcb2 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 客户端处理服务端下发数据 + * DISTRIBUTE_CLIENT_TRANSFER + */ +public abstract class AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java new file mode 100644 index 0000000..47f842a --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端关闭代理服务通道 + */ + +public abstract class AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java new file mode 100644 index 0000000..b249e0e --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端代理的真实端口自动读写 + * + * @see MessageTypeEnums#DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ + */ + +public abstract class AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java new file mode 100644 index 0000000..d861557 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端关闭代理服务通道 + */ + +public abstract class AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CLOSE_VISITOR.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java new file mode 100644 index 0000000..79f724f --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端暂存关闭 + */ + +public abstract class AbstractHandleUdpDistributeStagingClosedTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_CLOSED_NOTIFICATION.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java new file mode 100644 index 0000000..8aaf622 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 下发 客户端暂存开启 + */ + +public abstract class AbstractHandleUdpDistributeStagingOpenedTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_OPENED_NOTIFICATION.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java new file mode 100644 index 0000000..dc3376b --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 服务端处理客户端连接成功 + */ +public abstract class AbstractHandleUdpClientConnectSuccessTypeAdvanced extends AbstractHandleChannelTypeAdvanced + implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_CONNECT_SUCCESS.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java new file mode 100644 index 0000000..29e90e0 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透客户端init close 信息 + * REPORT_CLIENT_PERMEATE_CLIENT_CLOSE + */ +public abstract class AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java new file mode 100644 index 0000000..b11c57b --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透客户端init信息 + * REPORT_CLIENT_PERMEATE_CLIENT_INIT + */ +public abstract class AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..74084e5 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报客户端渗透客户端通信通道关闭 + *@see MessageTypeEnums#REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE + */ +public abstract class AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java new file mode 100644 index 0000000..536ee2d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透服务端init close 信息 + * REPORT_CLIENT_PERMEATE_SERVER_CLOSE + */ +public abstract class AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java new file mode 100644 index 0000000..ffacab6 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透服务端init信息 + * REPORT_CLIENT_PERMEATE_SERVER_INIT + */ +public abstract class AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java new file mode 100644 index 0000000..8d95483 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透服务端通信通道关闭 + * REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE + */ +public abstract class AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java new file mode 100644 index 0000000..83a282d --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透服务端通信 + * REPORT_CLIENT_PERMEATE_SERVER_TRANSFER + */ +public abstract class AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..416af3f --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透客户端数据传输通道连接成功 + * REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..6ae8bd4 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透客户端数据传输通道init + * REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CHANNEL_INIT_SUCCESSFUL + */ +public abstract class AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java new file mode 100644 index 0000000..81239b2 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报客户端渗透客户端数据传输结果 + * REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE + */ +public abstract class AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java new file mode 100644 index 0000000..ac728fa --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报客户端渗透客户端数据传输 + * REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST + */ +public abstract class AbstractHandleUdpReportClientTransferClientTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_REQUEST.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java new file mode 100644 index 0000000..4cce3fe --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 客户端渗透服务端数据传输通道连接成功 + * REPORT_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL + */ +public abstract class AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java new file mode 100644 index 0000000..0570a27 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 上报 集群注册 + * REPORT_CLUSTER_NODE_REGISTER_MESSAGE + */ +public abstract class AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java new file mode 100644 index 0000000..52fd441 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 客户端上报断开连接通知 + * DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION + */ + +public abstract class AbstractHandleUdpReportDisconnectTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + // 下发 客户端断开连接通知 + return MessageTypeEnums.REPORT_CLIENT_DISCONNECTION.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java new file mode 100644 index 0000000..a5aecde --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端通道 is active + * SERVER_CHANNEL_ACTIVE + */ +public abstract class AbstractHandleUdpReportServerChannelActiveTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.SERVER_CHANNEL_ACTIVE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java new file mode 100644 index 0000000..a1341a1 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端处理客户端 关闭一个访客 + * REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR + */ +public abstract class AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_SINGLE_CLIENT_CLOSE_VISITOR.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java new file mode 100644 index 0000000..dc9b4ec --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端处理客户端绑定真实服务成功 + * REPORT_SINGLE_CLIENT_REAL_CONNECT + */ +public abstract class AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java new file mode 100644 index 0000000..0e819a8 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端处理客户端上报数据 + * REPORT_CLIENT_STAGING_CLOSED + */ +public abstract class AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_TRANSFER.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java new file mode 100644 index 0000000..58f0cfd --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java @@ -0,0 +1,27 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + + +/** + * 服务端处理客户端 关闭一个访客 + * REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR + */ +public abstract class AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java new file mode 100644 index 0000000..31dfcf8 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java @@ -0,0 +1,29 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 客户端暂存通知 + * 客户端离线后陷入暂存服务业务上使用 + * 云端发送的消息，此模式云端后者说服务端不需要处理 + * CLIENT_STAGING + * 客户端上报暂存 + */ + +public abstract class AbstractHandleUdpReportStagingClosedTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_STAGING_CLOSED.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java new file mode 100644 index 0000000..e6db240 --- /dev/null +++ b/wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java @@ -0,0 +1,25 @@ +package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server; + + +import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced; +import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums; + +/** + * 上报客户端暂存开启 + */ + +public abstract class AbstractHandleUdpReportStagingOpenedTypeAdvanced extends AbstractHandleChannelTypeAdvanced implements HandleChannelTypeAdvanced { + + /** + * 是否支持当前类型 + * + * @param msg 通道数据 + * @return 布尔类型 是、否 + */ + @Override + public boolean doSupport(NettyProxyMsg msg) { + return MessageTypeEnums.REPORT_CLIENT_STAGING_OPENED.getTypeByte() == msg.getType(); + } +} diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java index 172d38b..c6e8a76 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java @@ -16,12 +16,12 @@ public class HeartbeatServerConfiguration { /** * 服务端 处理客户端心跳 * - * @return ServerTcpTcpHandleChannelHeartbeatTypeAdvanced + * @return ServerHandleTcpChannelHeartbeatTypeAdvanced */ @Role(BeanDefinition.ROLE_INFRASTRUCTURE) @Bean - public ServerTcpTcpHandleChannelHeartbeatTypeAdvanced serverChannelHeartbeatTypeAdvanced() { - return new ServerTcpTcpHandleChannelHeartbeatTypeAdvanced(); + public ServerHandleTcpChannelHeartbeatTypeAdvanced serverChannelHeartbeatTypeAdvanced() { + return new ServerHandleTcpChannelHeartbeatTypeAdvanced(); } /** diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java index 794cdbd..df9dfaa 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java @@ -6,7 +6,7 @@ import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; import jakarta.annotation.PreDestroy; import lombok.extern.slf4j.Slf4j; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.springframework.boot.context.event.ApplicationStartedEvent; import org.springframework.context.ApplicationListener; @@ -18,12 +18,12 @@ public class NettyTcpServerSocketApplicationListener implements ApplicationListe private final EventLoopGroup bossGroup = new NioEventLoopGroup(); private final EventLoopGroup workerGroup = new NioEventLoopGroup(); - private final NettyServerFilter nettyServerFilter;// 通道业务处理 + private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理 private ChannelFuture channelFuture; private final ServerNodeProperties serverNodeProperties; - public NettyTcpServerSocketApplicationListener(NettyServerFilter nettyServerFilter, ServerNodeProperties serverNodeProperties) { - this.nettyServerFilter = nettyServerFilter; + public NettyTcpServerSocketApplicationListener(NettyTcpServerFilter nettyTcpServerFilter, ServerNodeProperties serverNodeProperties) { + this.nettyTcpServerFilter = nettyTcpServerFilter; this.serverNodeProperties = serverNodeProperties; } @@ -52,7 +52,7 @@ public class NettyTcpServerSocketApplicationListener implements ApplicationListe // .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .childHandler(nettyServerFilter); + .childHandler(nettyTcpServerFilter); channelFuture = b.bind(tcpPort).sync(); channelFuture.addListener((ChannelFutureListener) channelFuture -> { diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java index ff402b6..30f4509 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java @@ -9,7 +9,7 @@ import io.netty.channel.socket.nio.NioDatagramChannel; import io.netty.util.internal.SystemPropertyUtil; import jakarta.annotation.PreDestroy; import lombok.extern.slf4j.Slf4j; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.springframework.boot.context.event.ApplicationStartedEvent; import org.springframework.context.ApplicationListener; @@ -20,12 +20,12 @@ import org.springframework.stereotype.Component; public class NettyUdpServerSocketApplicationListener implements ApplicationListener { private final EventLoopGroup bossGroup = "linux".equalsIgnoreCase(SystemPropertyUtil.get("os.name")) ? new EpollEventLoopGroup() : new NioEventLoopGroup(); - private final NettyServerFilter nettyServerFilter;// 通道业务处理 + private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理 private ChannelFuture channelFuture; private final ServerNodeProperties serverNodeProperties; - public NettyUdpServerSocketApplicationListener(NettyServerFilter nettyServerFilter, ServerNodeProperties serverNodeProperties) { - this.nettyServerFilter = nettyServerFilter; + public NettyUdpServerSocketApplicationListener(NettyTcpServerFilter nettyTcpServerFilter, ServerNodeProperties serverNodeProperties) { + this.nettyTcpServerFilter = nettyTcpServerFilter; this.serverNodeProperties = serverNodeProperties; } @@ -59,7 +59,7 @@ public class NettyUdpServerSocketApplicationListener implements ApplicationListe .option(ChannelOption.SO_RCVBUF, 1024 * 1024 * 10) //发送缓存区 10M .option(ChannelOption.SO_SNDBUF, 1024 * 1024 * 10) - .handler(nettyServerFilter); + .handler(nettyTcpServerFilter); channelFuture = b.bind(udpPort).sync(); channelFuture.addListener((ChannelFutureListener) channelFuture -> { diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java index 9a8304f..2c9e5bc 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java @@ -4,7 +4,7 @@ package org.framework.lazy.cloud.network.heartbeat.server.init; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.server.context.NettyTcpServerSocketApplicationListener; import org.framework.lazy.cloud.network.heartbeat.server.context.NettyUdpServerSocketApplicationListener; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.autoconfigure.web.ServerProperties; @@ -28,7 +28,7 @@ import java.util.concurrent.TimeUnit; public class InitServerSocket implements CommandLineRunner { private final ServerProperties serverProperties; - private final NettyServerFilter nettyServerFilter; + private final NettyTcpServerFilter nettyTcpServerFilter; private final ServerNodeProperties serverNodeProperties; @@ -36,11 +36,11 @@ public class InitServerSocket implements CommandLineRunner { new ArrayBlockingQueue<>(1)); public InitServerSocket(ServerProperties serverProperties, - NettyServerFilter nettyServerFilter, + NettyTcpServerFilter nettyTcpServerFilter, ServerNodeProperties serverNodeProperties ) { this.serverProperties = serverProperties; - this.nettyServerFilter = nettyServerFilter; + this.nettyTcpServerFilter = nettyTcpServerFilter; this.serverNodeProperties = serverNodeProperties; } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerTcpTcpHandleChannelHeartbeatTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpChannelHeartbeatTypeAdvanced.java similarity index 88% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerTcpTcpHandleChannelHeartbeatTypeAdvanced.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpChannelHeartbeatTypeAdvanced.java index be3040e..b233a0a 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerTcpTcpHandleChannelHeartbeatTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpChannelHeartbeatTypeAdvanced.java @@ -16,7 +16,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; */ @Role(BeanDefinition.ROLE_INFRASTRUCTURE) @Component -public class ServerTcpTcpHandleChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced { +public class ServerHandleTcpChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced { /** * 处理当前数据 diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java index 8105e72..86d4c1e 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java @@ -4,7 +4,7 @@ import io.netty.channel.Channel; import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.server.AbstractHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyClientPermeateServerConnectRealSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpClientPermeateServerConnectRealSocket; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.annotation.Role; import org.springframework.stereotype.Component; @@ -33,7 +33,7 @@ public class ServerHandleTcpReportClientTransferServerPermeateChannelConnectionS // 绑定客户端ID ChannelAttributeKeyUtils.buildClientId(transferChannel,clientId); ChannelAttributeKeyUtils.buildVisitorId(transferChannel,msgVisitorId); - NettyClientPermeateServerConnectRealSocket.buildNewRealServer(new String(msgVisitorId), + NettyTcpClientPermeateServerConnectRealSocket.buildNewRealServer(new String(msgVisitorId), Integer.parseInt(new String(msgVisitorPort)), new String(msgClientTargetIp), Integer.parseInt(new String(msgClientTargetPort)), diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java index d86cc57..3a21a5f 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java @@ -9,7 +9,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorConte import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.server.AbstractHandleTcpReportDisconnectTypeAdvanced; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyClientStatsChangeApplication; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.state.LazyNettyClientLoginCommand; import org.springframework.beans.factory.config.BeanDefinition; @@ -80,9 +80,9 @@ public class ServerHandleTcpReportDisconnectTypeAdvanced extends AbstractHandleT }); // 关闭绑定的访客端口 - List visitorSockets = NettyClientVisitorContext.getVisitorSockets(new String(clientId)); + List visitorSockets = NettyClientVisitorContext.getVisitorSockets(new String(clientId)); if (!ObjectUtils.isEmpty(visitorSockets)) { - for (NettyServerPermeateClientVisitorSocket visitorSocket : visitorSockets) { + for (NettyTcpServerPermeateClientVisitorSocket visitorSocket : visitorSockets) { int visitorPort = visitorSocket.getVisitorPort(); visitorSocket.close(); log.warn("client :[{}] visitorPort:[{}] close", new String(clientId), visitorPort); diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/ClientPermeateServerRealFilter.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpClientPermeateServerRealFilter.java similarity index 82% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/ClientPermeateServerRealFilter.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpClientPermeateServerRealFilter.java index 768846d..79577dc 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/ClientPermeateServerRealFilter.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpClientPermeateServerRealFilter.java @@ -5,12 +5,12 @@ import io.netty.channel.socket.SocketChannel; import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder; import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyClientPermeateServerRealHandler; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpClientPermeateServerRealHandler; /** * 客户端渗透服务端 */ -public class ClientPermeateServerRealFilter extends DebugChannelInitializer { +public class NettyTcpClientPermeateServerRealFilter extends DebugChannelInitializer { /** * This method will be called once the {@link Channel} was registered. After the method returns this instance * will be removed from the {@link ChannelPipeline} of the {@link Channel}. @@ -23,7 +23,7 @@ public class ClientPermeateServerRealFilter extends DebugChannelInitializer { +public class NettyTcpServerFilter extends DebugChannelInitializer { private final List handleChannelTypeAdvancedList; - public NettyServerFilter(List handleChannelTypeAdvancedList) { + public NettyTcpServerFilter(List handleChannelTypeAdvancedList) { this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList; } @@ -46,7 +46,7 @@ public class NettyServerFilter extends DebugChannelInitializer { pipeline.addLast("encoder", new StringEncoder()); // 类型处理器适配器 ChannelTypeAdapter channelTypeAdapter = new ChannelTypeAdapter(handleChannelTypeAdvancedList); - pipeline.addLast("doHandler", new NettyServerHandler(channelTypeAdapter));// 服务端业务逻辑 + pipeline.addLast("doHandler", new NettyTcpServerHandler(channelTypeAdapter));// 服务端业务逻辑 diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateClientVisitorFilter.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateClientVisitorFilter.java similarity index 78% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateClientVisitorFilter.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateClientVisitorFilter.java index be4ab4e..a906ea2 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateClientVisitorFilter.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateClientVisitorFilter.java @@ -8,13 +8,13 @@ import io.netty.channel.socket.SocketChannel; import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkPenetrationRealClient; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateClientVisitorHandler; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateClientVisitorHandler; -public class NettyServerPermeateClientVisitorFilter extends DebugChannelInitializer { +public class NettyTcpServerPermeateClientVisitorFilter extends DebugChannelInitializer { private final InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient; private final ChannelFlowAdapter channelFlowAdapter; - public NettyServerPermeateClientVisitorFilter(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) { + public NettyTcpServerPermeateClientVisitorFilter(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) { this.internalNetworkPenetrationRealClient = internalNetworkPenetrationRealClient; this.channelFlowAdapter = channelFlowAdapter; } @@ -32,6 +32,6 @@ public class NettyServerPermeateClientVisitorFilter extends DebugChannelInitiali protected void initChannel0(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new ChannelDuplexHandler()); - pipeline.addLast(new NettyServerPermeateClientVisitorHandler(internalNetworkPenetrationRealClient, channelFlowAdapter)); + pipeline.addLast(new NettyTcpServerPermeateClientVisitorHandler(internalNetworkPenetrationRealClient, channelFlowAdapter)); } } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerRealFilter.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerRealFilter.java similarity index 86% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerRealFilter.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerRealFilter.java index cefd50f..cb82a46 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerRealFilter.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerRealFilter.java @@ -11,13 +11,13 @@ import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPe import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder; import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder; import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateServerRealHandler; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateServerRealHandler; @Slf4j -public class NettyServerPermeateServerRealFilter extends DebugChannelInitializer { +public class NettyTcpServerPermeateServerRealFilter extends DebugChannelInitializer { private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer; - public NettyServerPermeateServerRealFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer) { + public NettyTcpServerPermeateServerRealFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer) { this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer; } @@ -48,7 +48,7 @@ public class NettyServerPermeateServerRealFilter extends DebugChannelInitializer // 解码、编码 pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10)); pipeline.addLast(new TransferEncoder()); - pipeline.addLast(new NettyServerPermeateServerRealHandler()); + pipeline.addLast(new NettyTcpServerPermeateServerRealHandler()); } } \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerVisitorFilter.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerVisitorFilter.java similarity index 77% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerVisitorFilter.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerVisitorFilter.java index 7c4eea0..150595f 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerVisitorFilter.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerVisitorFilter.java @@ -8,13 +8,13 @@ import io.netty.channel.socket.SocketChannel; import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPermeateServerRealServer; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateServerVisitorHandler; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateServerVisitorHandler; -public class NettyServerPermeateServerVisitorFilter extends DebugChannelInitializer { +public class NettyTcpServerPermeateServerVisitorFilter extends DebugChannelInitializer { private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer; private final ChannelFlowAdapter channelFlowAdapter; - public NettyServerPermeateServerVisitorFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) { + public NettyTcpServerPermeateServerVisitorFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) { this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer; this.channelFlowAdapter = channelFlowAdapter; } @@ -32,6 +32,6 @@ public class NettyServerPermeateServerVisitorFilter extends DebugChannelInitiali protected void initChannel0(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new ChannelDuplexHandler()); - pipeline.addLast(new NettyServerPermeateServerVisitorHandler(internalNetworkServerPermeateServerRealServer, channelFlowAdapter)); + pipeline.addLast(new NettyTcpServerPermeateServerVisitorHandler(internalNetworkServerPermeateServerRealServer, channelFlowAdapter)); } } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java deleted file mode 100644 index a9246e2..0000000 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java +++ /dev/null @@ -1,44 +0,0 @@ -package org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler; - -import io.netty.channel.ChannelHandlerContext; -import io.netty.channel.ChannelInboundHandlerAdapter; -import io.netty.handler.timeout.IdleState; -import io.netty.handler.timeout.IdleStateEvent; -import io.netty.util.AttributeKey; - -@Deprecated -public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter { - - AttributeKey channelAttributeKeyId = AttributeKey.valueOf("channelAttributeTenantId"); - private int lossConnectCount = 0; - - @Override - public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { - String channelAttributeId = ctx.channel().attr(channelAttributeKeyId).get(); - System.out.println("channelAttributeTenantId:" + channelAttributeId); - System.out.println("已经5秒未收到客户端的消息了！"); - - if (evt instanceof IdleStateEvent event) { - if (event.state() == IdleState.READER_IDLE) { - lossConnectCount++; - if (lossConnectCount > 2) { - System.out.println("关闭这个不活跃通道！"); -// ctx.channel().connectionClose(); - } - } - } else { - super.userEventTriggered(ctx, evt); - } - } - - @Override - public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { - lossConnectCount = 0; - System.out.println("client says: " + msg.toString()); - } - - @Override - public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { - ctx.close(); - } -} \ No newline at end of file diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyServerIdleStateHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyTcpServerIdleStateHandler.java similarity index 97% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyServerIdleStateHandler.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyTcpServerIdleStateHandler.java index 3758546..49db7c1 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyServerIdleStateHandler.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyTcpServerIdleStateHandler.java @@ -33,7 +33,7 @@ import java.util.concurrent.TimeUnit; * * public class MyChannelInitializer extends {@link ChannelInitializer}<{@link Channel}> { * public void initChannel({@link Channel} channel) { - * channel.pipeline().addLast("readTimeoutHandler", new {@link LazyServerIdleStateHandler}(30)); + * channel.pipeline().addLast("readTimeoutHandler", new {@link LazyTcpServerIdleStateHandler}(30)); * channel.pipeline().addLast("myHandler", new MyHandler()); * } * } @@ -60,7 +60,7 @@ import java.util.concurrent.TimeUnit; * @see WriteTimeoutHandler * @see IdleStateHandler */ -public class LazyServerIdleStateHandler extends ChannelDuplexHandler { +public class LazyTcpServerIdleStateHandler extends ChannelDuplexHandler { private static final long MIN_TIMEOUT_NANOS = TimeUnit.MILLISECONDS.toNanos(1); private final boolean observeOutput; private final long readerIdleTimeNanos; @@ -103,7 +103,7 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler { * will be triggered when neither read nor write was performed for * the specified period of time. Specify {@code 0} to disable. */ - public LazyServerIdleStateHandler( + public LazyTcpServerIdleStateHandler( int readerIdleTimeSeconds, int writerIdleTimeSeconds, int allIdleTimeSeconds) { @@ -113,9 +113,9 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler { } /** - * @see #LazyServerIdleStateHandler(boolean, long, long, long, TimeUnit) + * @see #LazyTcpServerIdleStateHandler(boolean, long, long, long, TimeUnit) */ - public LazyServerIdleStateHandler( + public LazyTcpServerIdleStateHandler( long readerIdleTime, long writerIdleTime, long allIdleTime, TimeUnit unit) { this(false, readerIdleTime, writerIdleTime, allIdleTime, unit); @@ -138,9 +138,9 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler { * @param unit the {@link TimeUnit} of {@code readerIdleTime}, * {@code writeIdleTime}, and {@code allIdleTime} */ - public LazyServerIdleStateHandler(boolean observeOutput, - long readerIdleTime, long writerIdleTime, long allIdleTime, - TimeUnit unit) { + public LazyTcpServerIdleStateHandler(boolean observeOutput, + long readerIdleTime, long writerIdleTime, long allIdleTime, + TimeUnit unit) { ObjectUtil.checkNotNull(unit, "unit"); this.observeOutput = observeOutput; @@ -470,7 +470,7 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler { @Override protected void run(ChannelHandlerContext ctx) { - long lastWriteTime = LazyServerIdleStateHandler.this.lastWriteTime; + long lastWriteTime = LazyTcpServerIdleStateHandler.this.lastWriteTime; long nextDelay = writerIdleTimeNanos - (ticksInNanos() - lastWriteTime); if (nextDelay <= 0) { // Writer is idle - set a new timeout and notify the callback. diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyClientPermeateServerRealHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpClientPermeateServerRealHandler.java similarity index 97% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyClientPermeateServerRealHandler.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpClientPermeateServerRealHandler.java index 98bded4..7762e8a 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyClientPermeateServerRealHandler.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpClientPermeateServerRealHandler.java @@ -19,7 +19,7 @@ import org.wu.framework.spring.utils.SpringContextHolder; * 客户端渗透服务端 */ @Slf4j -public class NettyClientPermeateServerRealHandler extends SimpleChannelInboundHandler { +public class NettyTcpClientPermeateServerRealHandler extends SimpleChannelInboundHandler { @Override diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerHandler.java similarity index 97% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerHandler.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerHandler.java index 43e8001..7f2c65a 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerHandler.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerHandler.java @@ -19,7 +19,7 @@ import org.wu.framework.core.utils.ObjectUtils; * @date 2023/09/13 10:27 */ @Slf4j -public class NettyServerHandler extends SimpleChannelInboundHandler { +public class NettyTcpServerHandler extends SimpleChannelInboundHandler { private final ChannelTypeAdapter channelTypeAdapter; /** @@ -31,7 +31,7 @@ public class NettyServerHandler extends SimpleChannelInboundHandler { +public class NettyTcpServerPermeateClientVisitorHandler extends SimpleChannelInboundHandler { private final InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient; private final ChannelFlowAdapter channelFlowAdapter;// 流量适配器 // private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10); - public NettyServerPermeateClientVisitorHandler(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) { + public NettyTcpServerPermeateClientVisitorHandler(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) { this.internalNetworkPenetrationRealClient = internalNetworkPenetrationRealClient; this.channelFlowAdapter = channelFlowAdapter; } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerRealHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerRealHandler.java similarity index 96% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerRealHandler.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerRealHandler.java index e1b04bc..8c0e37b 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerRealHandler.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerRealHandler.java @@ -14,7 +14,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeK * 来自客户端 真实服务器返回的数据请求 */ @Slf4j -public class NettyServerPermeateServerRealHandler extends SimpleChannelInboundHandler { +public class NettyTcpServerPermeateServerRealHandler extends SimpleChannelInboundHandler { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerVisitorHandler.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerVisitorHandler.java similarity index 91% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerVisitorHandler.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerVisitorHandler.java index ff571a4..305619c 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerVisitorHandler.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerVisitorHandler.java @@ -12,17 +12,17 @@ import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdap import org.framework.lazy.cloud.network.heartbeat.common.enums.ChannelFlowEnum; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; import org.framework.lazy.cloud.network.heartbeat.server.netty.flow.ServerChannelFlow; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateServerConnectRealSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateServerConnectRealSocket; import java.util.UUID; @Slf4j -public class NettyServerPermeateServerVisitorHandler extends SimpleChannelInboundHandler { +public class NettyTcpServerPermeateServerVisitorHandler extends SimpleChannelInboundHandler { private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer; private final ChannelFlowAdapter channelFlowAdapter;// 流量适配器 // private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10); - public NettyServerPermeateServerVisitorHandler(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) { + public NettyTcpServerPermeateServerVisitorHandler(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) { this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer; this.channelFlowAdapter = channelFlowAdapter; } @@ -45,7 +45,7 @@ public class NettyServerPermeateServerVisitorHandler extends SimpleChannelInboun log.info("开始准备绑定渗透真实通道: {}", internalNetworkServerPermeateServerRealServer.getVisitorPort()); // 创建这是客户端通道池 - NettyServerPermeateServerConnectRealSocket.buildRealServer(internalNetworkServerPermeateServerRealServer, visitorChannel, visitorId); + NettyTcpServerPermeateServerConnectRealSocket.buildRealServer(internalNetworkServerPermeateServerRealServer, visitorChannel, visitorId); log.info("内网渗透 服务端访客端口连接成功了"); diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java index 9702ec4..64957af 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java @@ -6,7 +6,7 @@ import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; import org.framework.lazy.cloud.network.heartbeat.server.context.NettyTcpServerSocketApplicationListener; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter; /** @@ -16,11 +16,11 @@ import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyS public class NettyOnCloudNettyServerSocket { private final EventLoopGroup bossGroup = new NioEventLoopGroup(); private final EventLoopGroup workerGroup = new NioEventLoopGroup(); - private final NettyServerFilter nettyServerFilter;// 通道业务处理 + private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理 private ChannelFuture channelFuture; - public NettyOnCloudNettyServerSocket(NettyServerFilter nettyServerFilter) { - this.nettyServerFilter = nettyServerFilter; + public NettyOnCloudNettyServerSocket(NettyTcpServerFilter nettyTcpServerFilter) { + this.nettyTcpServerFilter = nettyTcpServerFilter; } /** @@ -45,7 +45,7 @@ public class NettyOnCloudNettyServerSocket { // .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .childHandler(nettyServerFilter); + .childHandler(nettyTcpServerFilter); channelFuture = b.bind(serverPort).sync(); channelFuture.addListener((ChannelFutureListener) channelFuture -> { diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyClientPermeateServerConnectRealSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpClientPermeateServerConnectRealSocket.java similarity index 95% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyClientPermeateServerConnectRealSocket.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpClientPermeateServerConnectRealSocket.java index 09d0d19..0b01d5a 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyClientPermeateServerConnectRealSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpClientPermeateServerConnectRealSocket.java @@ -9,7 +9,7 @@ import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.common.MessageType; import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.ClientPermeateServerRealFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpClientPermeateServerRealFilter; import java.util.concurrent.TimeUnit; @@ -17,7 +17,7 @@ import java.util.concurrent.TimeUnit; * 客户端渗透服务端 连接真实通道 */ @Slf4j -public class NettyClientPermeateServerConnectRealSocket { +public class NettyTcpClientPermeateServerConnectRealSocket { private static final EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); @@ -38,7 +38,7 @@ public class NettyClientPermeateServerConnectRealSocket { // .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128 // .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .handler(new ClientPermeateServerRealFilter()) + .handler(new NettyTcpClientPermeateServerRealFilter()) ; diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateClientVisitorSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateClientVisitorSocket.java similarity index 88% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateClientVisitorSocket.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateClientVisitorSocket.java index a570970..772a1aa 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateClientVisitorSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateClientVisitorSocket.java @@ -11,7 +11,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorConte import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateClientVisitorFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateClientVisitorFilter; /** * 内网穿透服务端访客通道 @@ -20,17 +20,17 @@ import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyS * @see NettyClientVisitorContext */ @Slf4j -public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSocket { +public class NettyTcpServerPermeateClientVisitorSocket implements PermeateVisitorSocket { private final EventLoopGroup bossGroup = new NioEventLoopGroup(); private final EventLoopGroup workerGroup = new NioEventLoopGroup(); - private final NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter; + private final NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter; @Getter private final String clientId; @Getter private final int visitorPort; - public NettyServerPermeateClientVisitorSocket(NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter, String clientId, int visitorPort) { - this.nettyServerPermeateClientVisitorFilter = nettyServerPermeateClientVisitorFilter; + public NettyTcpServerPermeateClientVisitorSocket(NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter, String clientId, int visitorPort) { + this.nettyTcpServerPermeateClientVisitorFilter = nettyTcpServerPermeateClientVisitorFilter; this.clientId = clientId; this.visitorPort = visitorPort; } @@ -64,7 +64,7 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .childHandler(nettyServerPermeateClientVisitorFilter); + .childHandler(nettyTcpServerPermeateClientVisitorFilter); try { bootstrap.bind(visitorPort).sync().addListener((ChannelFutureListener) future -> { if (future.isSuccess()) { @@ -211,7 +211,7 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo return this; } - public NettyServerPermeateClientVisitorSocket build() { + public NettyTcpServerPermeateClientVisitorSocket build() { if (clientId == null) { throw new IllegalArgumentException("clientId must not null"); } @@ -232,8 +232,8 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo .visitorPort(visitorPort) .visitorId(visitorId).build(); - NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter = new NettyServerPermeateClientVisitorFilter(internalNetworkPenetrationRealClient, channelFlowAdapter); - return new NettyServerPermeateClientVisitorSocket(nettyServerPermeateClientVisitorFilter, clientId, visitorPort); + NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter = new NettyTcpServerPermeateClientVisitorFilter(internalNetworkPenetrationRealClient, channelFlowAdapter); + return new NettyTcpServerPermeateClientVisitorSocket(nettyTcpServerPermeateClientVisitorFilter, clientId, visitorPort); } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectRealSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectRealSocket.java similarity index 95% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectRealSocket.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectRealSocket.java index ef13d7a..f3db3b5 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectRealSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectRealSocket.java @@ -8,7 +8,7 @@ import io.netty.channel.socket.nio.NioSocketChannel; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPermeateServerRealServer; import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateServerRealFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateServerRealFilter; import java.util.concurrent.TimeUnit; @@ -16,7 +16,7 @@ import java.util.concurrent.TimeUnit; * 服务端渗透服务端 连接真实通道 */ @Slf4j -public class NettyServerPermeateServerConnectRealSocket { +public class NettyTcpServerPermeateServerConnectRealSocket { private static final EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); /** @@ -50,7 +50,7 @@ public class NettyServerPermeateServerConnectRealSocket { // .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128 // .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .handler(new NettyServerPermeateServerRealFilter(internalNetworkServerPermeateServerRealServer)) + .handler(new NettyTcpServerPermeateServerRealFilter(internalNetworkServerPermeateServerRealServer)) ; diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectVisitorSocket.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectVisitorSocket.java similarity index 83% rename from wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectVisitorSocket.java rename to wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectVisitorSocket.java index 609a80b..05f8758 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectVisitorSocket.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectVisitorSocket.java @@ -11,7 +11,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPe import org.framework.lazy.cloud.network.heartbeat.common.NettyServerPermeateServerVisitorContext; import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateServerVisitorFilter; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateServerVisitorFilter; import java.io.IOException; @@ -19,18 +19,18 @@ import java.io.IOException; * 服务端渗透服务端 访客端口 */ @Slf4j -public class NettyServerPermeateServerConnectVisitorSocket { +public class NettyTcpServerPermeateServerConnectVisitorSocket { private final EventLoopGroup bossGroup = new NioEventLoopGroup(); private final EventLoopGroup workerGroup = new NioEventLoopGroup(); - private final NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter; + private final NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter; @Getter private final int visitorPort; - public NettyServerPermeateServerConnectVisitorSocket(NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter, - int visitorPort) { - this.nettyServerPermeateServerVisitorFilter = nettyServerPermeateServerVisitorFilter; + public NettyTcpServerPermeateServerConnectVisitorSocket(NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter, + int visitorPort) { + this.nettyTcpServerPermeateServerVisitorFilter = nettyTcpServerPermeateServerVisitorFilter; this.visitorPort = visitorPort; } @@ -42,8 +42,8 @@ public class NettyServerPermeateServerConnectVisitorSocket { */ public void start() throws Exception { - NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort); - if (nettyServerPermeateServerConnectVisitorSocket == null) { + NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort); + if (nettyTcpServerPermeateServerConnectVisitorSocket == null) { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap .group(bossGroup, workerGroup) @@ -63,7 +63,7 @@ public class NettyServerPermeateServerConnectVisitorSocket { .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2)) - .childHandler(nettyServerPermeateServerVisitorFilter); + .childHandler(nettyTcpServerPermeateServerVisitorFilter); ChannelFuture sync = bootstrap.bind(visitorPort).sync(); sync.addListener((ChannelFutureListener) future -> { if (future.isSuccess()) { @@ -189,7 +189,7 @@ public class NettyServerPermeateServerConnectVisitorSocket { } - public NettyServerPermeateServerConnectVisitorSocket build() { + public NettyTcpServerPermeateServerConnectVisitorSocket build() { if (clientTargetIp == null) { throw new IllegalArgumentException("clientTargetIp must not null"); @@ -208,8 +208,8 @@ public class NettyServerPermeateServerConnectVisitorSocket { .isSsl(isSsl) .build(); - NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter = new NettyServerPermeateServerVisitorFilter(internalNetworkServerPermeateServerRealServer, channelFlowAdapter); - return new NettyServerPermeateServerConnectVisitorSocket(nettyServerPermeateServerVisitorFilter, permeateVisitorPort); + NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter = new NettyTcpServerPermeateServerVisitorFilter(internalNetworkServerPermeateServerRealServer, channelFlowAdapter); + return new NettyTcpServerPermeateServerConnectVisitorSocket(nettyTcpServerPermeateServerVisitorFilter, permeateVisitorPort); } diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java index ff9cc14..9a6f595 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java @@ -4,7 +4,7 @@ import jakarta.annotation.Resource; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyInternalNetworkServerPermeateClientMappingApplication; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.InternalNetworkPenetrationMappingDTOAssembler; @@ -156,14 +156,14 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple */ private void changeCloseSocket(String clientId, Integer visitorPort) { // 删除 客户端映射 - List nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId); - if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) { - nettyServerPermeateClientVisitorSocketList = nettyServerPermeateClientVisitorSocketList.stream() - .filter(nettyServerPermeateClientVisitorSocket -> nettyServerPermeateClientVisitorSocket.getVisitorPort() == visitorPort).toList(); - if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) { + List nettyTcpServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId); + if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) { + nettyTcpServerPermeateClientVisitorSocketList = nettyTcpServerPermeateClientVisitorSocketList.stream() + .filter(nettyTcpServerPermeateClientVisitorSocket -> nettyTcpServerPermeateClientVisitorSocket.getVisitorPort() == visitorPort).toList(); + if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) { // 关闭端口 - for (NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket : nettyServerPermeateClientVisitorSocketList) { - nettyServerPermeateClientVisitorSocket.close(); + for (NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket : nettyTcpServerPermeateClientVisitorSocketList) { + nettyTcpServerPermeateClientVisitorSocket.close(); } // 关闭通道 socket @@ -282,7 +282,7 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple try { // 更新 客户端映射 - NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket = NettyServerPermeateClientVisitorSocket.NettyVisitorSocketBuilder + NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket = NettyTcpServerPermeateClientVisitorSocket.NettyVisitorSocketBuilder .builder() .builderClientId(clientId) .builderClientTargetIp(clientTargetIp) @@ -290,7 +290,7 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple .builderVisitorPort(visitorPort) .builderChannelFlowAdapter(channelFlowAdapter) .build(); - nettyServerPermeateClientVisitorSocket.start(); + nettyTcpServerPermeateClientVisitorSocket.start(); } catch (Exception e) { e.printStackTrace(); log.error("客户端:{},网络端口:{},开放失败", clientId, visitorPort); diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java index 2ee3c9e..3a19c91 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java @@ -4,7 +4,7 @@ import jakarta.annotation.Resource; import lombok.extern.slf4j.Slf4j; import org.framework.lazy.cloud.network.heartbeat.common.NettyServerPermeateServerVisitorContext; import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateServerConnectVisitorSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateServerConnectVisitorSocket; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyInternalNetworkServerPermeateServerMappingApplication; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.LazyInternalNetworkServerPermeateServerMappingDTOAssembler; @@ -222,11 +222,11 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple */ private void closeServerPermeateServerSocket(Integer visitorPort) { // 删除 客户端映射 - NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort); - if (!ObjectUtils.isEmpty(nettyServerPermeateServerConnectVisitorSocket)) { + NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort); + if (!ObjectUtils.isEmpty(nettyTcpServerPermeateServerConnectVisitorSocket)) { // 关闭端口 try { - nettyServerPermeateServerConnectVisitorSocket.close(); + nettyTcpServerPermeateServerConnectVisitorSocket.close(); NettyServerPermeateServerVisitorContext.removeServerPermeateServerVisitorSockets(visitorPort); } catch (IOException | InterruptedException e) { throw new RuntimeException(e); @@ -243,7 +243,7 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple */ private void createServerPermeateServerVisitor(String permeateTargetIp, Integer permeateTargetPort, Integer visitorPort, Boolean isSsl) { // 更新 客户端映射 - NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerConnectVisitorSocket.NettyPermeateVisitorSocketBuilder + NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyTcpServerPermeateServerConnectVisitorSocket.NettyPermeateVisitorSocketBuilder .builder() .builderClientTargetIp(permeateTargetIp) .builderClientTargetPort(permeateTargetPort) @@ -252,7 +252,7 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple .builderChannelFlowAdapter(channelFlowAdapter) .build(); try { - nettyServerPermeateServerConnectVisitorSocket.start(); + nettyTcpServerPermeateServerConnectVisitorSocket.start(); } catch (Exception e) { log.error("内网渗透,网络端口:{},开放失败", visitorPort); throw new RuntimeException(e); diff --git a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java index 30d169f..de5b64b 100644 --- a/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java +++ b/wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java @@ -8,7 +8,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext; import org.framework.lazy.cloud.network.heartbeat.common.MessageType; import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext; import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg; -import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket; +import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket; import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyClientStateApplication; import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.NettyClientStateDTOAssembler; @@ -207,10 +207,10 @@ public class LazyNettyClientStateApplicationImpl implements LazyNettyClientState // 心跳关闭 ChannelContext.clear(clientId); // 关闭访客 - List nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId); - if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) { - for (NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket : nettyServerPermeateClientVisitorSocketList) { - nettyServerPermeateClientVisitorSocket.close(); + List nettyTcpServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId); + if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) { + for (NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket : nettyTcpServerPermeateClientVisitorSocketList) { + nettyTcpServerPermeateClientVisitorSocket.close(); } } NettyClientVisitorContext.removeVisitorSockets(clientId);