alsace/wu-lazy-cloud-network
1
0
Fork 0
mirror of https://gitee.com/wujiawei1207537021/wu-lazy-cloud-network.git synced 2025-06-06 13:27:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

[fix] 优化tcp架构

Browse Source
This commit is contained in:
wujiawei 2024-12-13 13:35:35 +08:00
parent ddaa5568e0
commit 41a81133f1
73 changed files with 1350 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
*
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.TYPE_HEARTBEAT.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.CLIENT_CHANNEL_ACTIVE.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType();
}
}

23
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_CONNECTION_SUCCESS_NOTIFICATION.getTypeByte() == msg.getType();
}
}

26
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
// 下发 客户端断开连接通知
return MessageTypeEnums.DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType();
}
}

28
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CLOSE_VISITOR.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_CLOSED_NOTIFICATION.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_OPENED_NOTIFICATION.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg>
implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_CONNECT_SUCCESS.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_REQUEST.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
// 下发 客户端断开连接通知
return MessageTypeEnums.REPORT_CLIENT_DISCONNECTION.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.SERVER_CHANNEL_ACTIVE.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_SINGLE_CLIENT_CLOSE_VISITOR.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_TRANSFER.getTypeByte() == msg.getType();
}
}

27
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType();
}
}

29
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_STAGING_CLOSED.getTypeByte() == msg.getType();
}
}

25
wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java Normal file
View File

@ -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<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
/**
* 是否支持当前类型
*
* @param msg 通道数据
* @return 布尔类型 是、否
*/
@Override
public boolean doSupport(NettyProxyMsg msg) {
return MessageTypeEnums.REPORT_CLIENT_STAGING_OPENED.getTypeByte() == msg.getType();
}
}

6
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java
View File

@ -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();
}
/**

10
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java
View File

@ -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 -> {

10
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java
View File

@ -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<ApplicationStartedEvent> {
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 -> {

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java
View File

@ -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;
}

2
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerTcpTcpHandleChannelHeartbeatTypeAdvanced.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpChannelHeartbeatTypeAdvanced.java
View File

@ -16,7 +16,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
*/
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
@Component
public class ServerTcpTcpHandleChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
public class ServerHandleTcpChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
/**
* 处理当前数据

4
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java
View File

@ -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)),

6
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java
View File

@ -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<NettyServerPermeateClientVisitorSocket> visitorSockets = NettyClientVisitorContext.getVisitorSockets(new String(clientId));
List<NettyTcpServerPermeateClientVisitorSocket> 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);

6
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/ClientPermeateServerRealFilter.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpClientPermeateServerRealFilter.java
View File

@ -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<SocketChannel> {
public class NettyTcpClientPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
/**
* 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<Sock
// 解码、编码
pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
pipeline.addLast(new TransferEncoder());
pipeline.addLast(new NettyClientPermeateServerRealHandler());
pipeline.addLast(new NettyTcpClientPermeateServerRealHandler());
}
}

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerFilter.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerFilter.java
View File

@ -6,7 +6,7 @@ import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerHandler;
import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerHandler;
import org.springframework.stereotype.Component;
import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
@ -23,10 +23,10 @@ import java.util.concurrent.TimeUnit;
* @date 2023/09/13 10:26
*/
@Component
public class NettyServerFilter extends DebugChannelInitializer<SocketChannel> {
public class NettyTcpServerFilter extends DebugChannelInitializer<SocketChannel> {
private final List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList;
public NettyServerFilter(List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
public NettyTcpServerFilter(List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
}
@ -46,7 +46,7 @@ public class NettyServerFilter extends DebugChannelInitializer<SocketChannel> {
pipeline.addLast("encoder", new StringEncoder());
// 类型处理器适配器
ChannelTypeAdapter channelTypeAdapter = new ChannelTypeAdapter(handleChannelTypeAdvancedList);
pipeline.addLast("doHandler", new NettyServerHandler(channelTypeAdapter));// 服务端业务逻辑
pipeline.addLast("doHandler", new NettyTcpServerHandler(channelTypeAdapter));// 服务端业务逻辑

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateClientVisitorFilter.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateClientVisitorFilter.java
View File

@ -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<SocketChannel> {
public class NettyTcpServerPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
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));
}
}

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerRealFilter.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerRealFilter.java
View File

@ -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<SocketChannel> {
public class NettyTcpServerPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
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());
}
}

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyServerPermeateServerVisitorFilter.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerVisitorFilter.java
View File

@ -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<SocketChannel> {
public class NettyTcpServerPermeateServerVisitorFilter extends DebugChannelInitializer<SocketChannel> {
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));
}
}

44
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java
View File

@ -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<String> 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();
}
}

14
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyServerIdleStateHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyTcpServerIdleStateHandler.java
View File

@ -33,7 +33,7 @@ import java.util.concurrent.TimeUnit;
*
* public class MyChannelInitializer extends {@link ChannelInitializer}&lt;{@link Channel}&gt; {
* 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,7 +138,7 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
* @param unit the {@link TimeUnit} of {@code readerIdleTime},
* {@code writeIdleTime}, and {@code allIdleTime}
*/
public LazyServerIdleStateHandler(boolean observeOutput,
public LazyTcpServerIdleStateHandler(boolean observeOutput,
long readerIdleTime, long writerIdleTime, long allIdleTime,
TimeUnit unit) {
ObjectUtil.checkNotNull(unit, "unit");
@ -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.

2
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyClientPermeateServerRealHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpClientPermeateServerRealHandler.java
View File

@ -19,7 +19,7 @@ import org.wu.framework.spring.utils.SpringContextHolder;
* 客户端渗透服务端
*/
@Slf4j
public class NettyClientPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
public class NettyTcpClientPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
@Override

4
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerHandler.java
View File

@ -19,7 +19,7 @@ import org.wu.framework.core.utils.ObjectUtils;
* @date 2023/09/13 10:27
*/
@Slf4j
public class NettyServerHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
public class NettyTcpServerHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
private final ChannelTypeAdapter channelTypeAdapter;
/**
@ -31,7 +31,7 @@ public class NettyServerHandler extends SimpleChannelInboundHandler<NettyProxyMs
*/
private int transfer_count = 1;
public NettyServerHandler(ChannelTypeAdapter channelTypeAdapter) {
public NettyTcpServerHandler(ChannelTypeAdapter channelTypeAdapter) {
this.channelTypeAdapter = channelTypeAdapter;
}

4
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateClientVisitorHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateClientVisitorHandler.java
View File

@ -18,12 +18,12 @@ import org.wu.framework.core.utils.ObjectUtils;
import java.util.UUID;
@Slf4j
public class NettyServerPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
public class NettyTcpServerPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
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;
}

2
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerRealHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerRealHandler.java
View File

@ -14,7 +14,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeK
* 来自客户端 真实服务器返回的数据请求
*/
@Slf4j
public class NettyServerPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
public class NettyTcpServerPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {

8
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyServerPermeateServerVisitorHandler.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerVisitorHandler.java
View File

@ -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<ByteBuf> {
public class NettyTcpServerPermeateServerVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
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("内网渗透 服务端访客端口连接成功了");

10
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java
View File

@ -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 -> {

6
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyClientPermeateServerConnectRealSocket.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpClientPermeateServerConnectRealSocket.java
View File

@ -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())
;

18
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateClientVisitorSocket.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateClientVisitorSocket.java
View File

@ -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);
}

6
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectRealSocket.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectRealSocket.java
View File

@ -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))
;

22
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyServerPermeateServerConnectVisitorSocket.java → wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectVisitorSocket.java
View File

@ -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,
public NettyTcpServerPermeateServerConnectVisitorSocket(NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter,
int visitorPort) {
this.nettyServerPermeateServerVisitorFilter = nettyServerPermeateServerVisitorFilter;
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);
}

20
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java
View File

@ -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<NettyServerPermeateClientVisitorSocket> nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
nettyServerPermeateClientVisitorSocketList = nettyServerPermeateClientVisitorSocketList.stream()
.filter(nettyServerPermeateClientVisitorSocket -> nettyServerPermeateClientVisitorSocket.getVisitorPort() == visitorPort).toList();
if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
List<NettyTcpServerPermeateClientVisitorSocket> 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);

12
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java
View File

@ -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);

10
wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java
View File

@ -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<NettyServerPermeateClientVisitorSocket> nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
for (NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket : nettyServerPermeateClientVisitorSocketList) {
nettyServerPermeateClientVisitorSocket.close();
List<NettyTcpServerPermeateClientVisitorSocket> nettyTcpServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) {
for (NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket : nettyTcpServerPermeateClientVisitorSocketList) {
nettyTcpServerPermeateClientVisitorSocket.close();
}
}
NettyClientVisitorContext.removeVisitorSockets(clientId);