repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/counter/CounterService.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/counter/CounterService.java | package cn.bixin.sona.gateway.concurrent.counter;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.ctrip.framework.apollo.ConfigService;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
/**
* @author qinwei
* <p>
* 当房间5分钟内没有任何消息，清除掉对应的时间窗口计数
*/
@Component
public class CounterService {
private static final String APOLLO_KEY_THRESHOLD = "counter.threshold.config";
private static final String APOLLO_KEY_DURATION = "counter.duration.config";
private static final Cache<String, TimeSlidingWindow> CAFFEINE = Caffeine.newBuilder().initialCapacity(64).expireAfterAccess(Duration.ofMinutes(5)).build();
private static Map<String, Integer> thresholdConfig = new HashMap<>();
private static TimeSlidingWindow getSlidingWindow(String name) {
return CAFFEINE.get(name, s -> new TimeSlidingWindow(thresholdConfig.getOrDefault(s, 8)));
}
public static void increment(String name) {
getSlidingWindow(name).increment();
}
public static boolean compute(String name) {
return getSlidingWindow(name).exceedThreshold();
}
@PostConstruct
public void init() {
updateConfig(ConfigService.getAppConfig().getProperty(APOLLO_KEY_THRESHOLD, "{}"));
ConfigService.getAppConfig().addChangeListener(changeEvent -> {
if (changeEvent.isChanged(APOLLO_KEY_THRESHOLD)) {
updateConfig(changeEvent.getChange(APOLLO_KEY_THRESHOLD).getNewValue());
}
if (changeEvent.isChanged(APOLLO_KEY_DURATION)) {
String newValue = changeEvent.getChange(APOLLO_KEY_DURATION).getNewValue();
CAFFEINE.policy().expireAfterAccess().ifPresent(expiration -> expiration.setExpiresAfter(Duration.ofMinutes(Long.parseLong(newValue))));
}
});
}
private static void updateConfig(String config) {
Map<String, Integer> map = JSON.parseObject(config, new TypeReference<Map<String, Integer>>() {
});
if (map != null) {
thresholdConfig = map;
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/counter/WindowHolder.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/counter/WindowHolder.java | package cn.bixin.sona.gateway.concurrent.counter;
/**
* @author qinwei
*/
public class WindowHolder<T> {
private final long windowLengthInMs;
private long windowStart;
private T value;
public WindowHolder(long windowLengthInMs, long windowStart, T value) {
this.windowLengthInMs = windowLengthInMs;
this.windowStart = windowStart;
this.value = value;
}
public long windowLength() {
return windowLengthInMs;
}
public long windowStart() {
return windowStart;
}
public T value() {
return value;
}
public void setValue(T value) {
this.value = value;
}
/**
* 复位该时间窗口
*/
public void resetTo(long startTime) {
this.windowStart = startTime;
}
/**
* 判断是否该时间在该窗口内
*/
public boolean isTimeInWindow(long timeMillis) {
return windowStart <= timeMillis && timeMillis < windowStart + windowLengthInMs;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/buffer/ChannelBuffer.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/buffer/ChannelBuffer.java | package cn.bixin.sona.gateway.concurrent.buffer;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.BatchResolve;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.function.Consumer;
/**
* @author qinwei
* <p>
* thread safe
* <p>
* buffer size 必须是2的幂次方，这里默认16 ，如果是8的话，太容易迅速被填满了，可能会导致性能不高
* 而且有sona那边的频控，还有每隔50ms 我都会把buffer里面的数据拿出来合并发送，一般也不会达到16
*/
public class ChannelBuffer extends RingBuffer<AccessMessage> {
private static final int DEFAULT_BUFFER_SIZE = 16;
/**
* 减少内存使用
*/
private static final AtomicIntegerFieldUpdater<ChannelBuffer> STATE_UPDATER = AtomicIntegerFieldUpdater.newUpdater(ChannelBuffer.class, "state");
private volatile int state;
public ChannelBuffer() {
super(DEFAULT_BUFFER_SIZE);
}
@Override
public void drainTo(Consumer<AccessMessage> consumer) {
if (STATE_UPDATER.compareAndSet(this, 0, 1)) {
try {
batchConsumer(obtain(), consumer);
} finally {
STATE_UPDATER.set(this, 0);
}
}
}
private static void batchConsumer(List<AccessMessage> list, Consumer<AccessMessage> consumer) {
if (CollectionUtils.isEmpty(list)) {
return;
}
consumer.accept(BatchResolve.merge(list));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/buffer/RingBuffer.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/concurrent/buffer/RingBuffer.java | package cn.bixin.sona.gateway.concurrent.buffer;
import org.springframework.util.Assert;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.locks.LockSupport;
import java.util.function.Consumer;
/**
* @author qinwei
* <p>
* 无锁化 ring buffer
* <p>
* buffer size 必须是2的幂次方 ，这样可以通过 位运算来计算下标，提升性能
* <p>
* index是long类型，即使100万QPS的处理速度，也需要30万年才能用完 ，disruptor 就是这样设计的
* <p>
* disruptor 里面的buffer 设计很牛逼，但是比较适合buffer 较大、单 producer 的场景，在多 producer 的情况下 write 会比较复杂，性能较差
* 它里面会引入了一个与Ring Buffer 大小相同的 buffer：available buffer。
* 当某个位置写入成功的时候，便把 availble buffer 相应的位置置位，标记为写入成功。
* 读取的时候，会遍历 available buffer ，来判断元素是否已经就绪。
* <p>
* 这里我主要用于缓存房间消息，buffer size不会超过16，并且属于多 producer 的场景，如果使用 disruptor那种方式，性能不见得会高多少
* 所以这里借鉴了 caffeine 里面的buffer 设计 ，实现比较简单，在buffer size 较小、并发 write 的情况下，能提供不错的性能
* <p>
* 借鉴 skywalking 中 解决伪共享的高性能设计
* https://github.com/apache/skywalking/pull/2930
*/
public class RingBuffer<E> {
private static final int FULL = -1;
private static final int FAILED = 0;
private static final int SUCCESS = 1;
private static final int VALUE_OFFSET = 7;
private final int bufferSize;
private final int mask;
private final AtomicReferenceArray<E> buffer;
private final AtomicLongArray writeCounter;
private final AtomicLongArray readCounter;
/**
* buffer size 必须是 2的幂次方
*/
public RingBuffer(int bufferSize) {
Assert.isTrue((bufferSize & (bufferSize - 1)) == 0, "buffer size not a power of two");
this.buffer = new AtomicReferenceArray<>(bufferSize);
this.bufferSize = bufferSize;
this.mask = bufferSize - 1;
this.writeCounter = new AtomicLongArray(15);
this.writeCounter.set(VALUE_OFFSET, 0);
this.readCounter = new AtomicLongArray(15);
this.readCounter.set(VALUE_OFFSET, 0);
}
public final int offer(final E data) {
long head = reads();
long tail = writes();
long size = tail - head;
if (size >= bufferSize) {
return FULL;
}
if (this.writeCounter.compareAndSet(VALUE_OFFSET, tail, tail + 1)) {
int index = calculateIndex(tail);
buffer.lazySet(index, data);
return SUCCESS;
}
return FAILED;
}
public List<E> obtain() {
long head = reads();
long tail = writes();
long size = tail - head;
if (size == 0) {
return null;
}
List<E> list = new ArrayList<>((int) size);
do {
int index = calculateIndex(head);
list.add(buffer.get(index));
buffer.lazySet(index, null);
head++;
} while (head != tail);
lazySetReadCounter(head);
return list;
}
public void offer(E data, Consumer<E> consumer) {
for (int i = 0; ; i++) {
int result = offer(data);
if (result == SUCCESS) {
return;
}
if (result == FULL) {
drainTo(consumer);
}
waitFor(i);
}
}
public void drainTo(Consumer<E> consumer) {
long head = reads();
long tail = writes();
long size = tail - head;
if (size == 0) {
return;
}
do {
int index = calculateIndex(head);
E e = buffer.get(index);
if (e == null) {
break;
}
buffer.lazySet(index, null);
consumer.accept(e);
head++;
} while (head != tail);
lazySetReadCounter(head);
}
private void waitFor(int count) {
if (count > 10) {
LockSupport.parkNanos(1L);
} else {
Thread.yield();
}
}
private int calculateIndex(long sequence) {
return (int) (sequence & mask);
}
public int getBufferSize() {
return bufferSize;
}
public final long writes() {
return this.writeCounter.get(VALUE_OFFSET);
}
public final long reads() {
return this.readCounter.get(VALUE_OFFSET);
}
private void lazySetReadCounter(long head) {
this.readCounter.lazySet(VALUE_OFFSET, head);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/HeaderEnum.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/HeaderEnum.java | package cn.bixin.sona.gateway.common;
/**
* @author qinwei
*/
public enum HeaderEnum {
COMPRESS(1, "Body被压缩"),
CHATROOM(2, "聊天室房间header"),
BATCH(3, "批量"),
AUTH(4, "鉴权");
private int type;
private String desc;
HeaderEnum(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getType() {
return type;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Header.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Header.java | package cn.bixin.sona.gateway.common;
import java.nio.charset.StandardCharsets;
/**
* @author qinwei
*/
public class Header {
private int type;
private byte[] data;
public Header() {
}
public Header(int type, byte[] data) {
this.type = type;
this.data = data;
}
public Header(HeaderEnum header, byte[] data) {
this(header.getType(), data);
}
public Header(HeaderEnum header, String data) {
this(header.getType(), data);
}
public Header(int type, String data) {
this(type, data == null ? null : data.getBytes(StandardCharsets.UTF_8));
}
public int calcDataLength() {
return data == null ? 0 : data.length;
}
public int calcTotalLength() {
int dataLength = calcDataLength();
return 1 + Varint.computeRawVarint32Size(dataLength) + dataLength;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public byte[] getData() {
return data;
}
public void setData(byte[] data) {
this.data = data;
}
@Override
public String toString() {
return "Header{" +
"type=" + type +
", data=" + (data == null ? null : new String(data, StandardCharsets.UTF_8)) +
'}';
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/AccessMessage.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/AccessMessage.java | package cn.bixin.sona.gateway.common;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
/**
* @author qinwei
*/
public class AccessMessage {
private boolean req;
private boolean twoWay;
private boolean heartbeat;
private int version;
private int id;
private int cmd;
private int length;
private List<Header> headers;
private byte[] body;
public AccessMessage() {
}
public AccessMessage(AccessMessage message) {
this.req = message.req;
this.twoWay = message.twoWay;
this.heartbeat = message.heartbeat;
this.version = message.version;
this.id = message.id;
this.cmd = message.cmd;
if (message.headers != null) {
this.headers = new ArrayList<>(message.headers);
}
this.body = message.body;
}
public void addHeader(Header header) {
if (headers == null) {
headers = new ArrayList<>();
}
headers.add(header);
}
public boolean isReq() {
return req;
}
public void setReq(boolean req) {
this.req = req;
}
public boolean isTwoWay() {
return twoWay;
}
public void setTwoWay(boolean twoWay) {
this.twoWay = twoWay;
}
public boolean isHeartbeat() {
return heartbeat;
}
public void setHeartbeat(boolean heartbeat) {
this.heartbeat = heartbeat;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getCmd() {
return cmd;
}
public void setCmd(int cmd) {
this.cmd = cmd;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public List<Header> getHeaders() {
return headers;
}
public void setHeaders(List<Header> headers) {
this.headers = headers;
}
public byte[] getBody() {
return body;
}
public void setBody(byte[] body) {
this.body = body;
}
@Override
public String toString() {
return "AccessMessage{" +
"req=" + req +
", twoWay=" + twoWay +
", heartbeat=" + heartbeat +
", version=" + version +
", id=" + id +
", cmd=" + cmd +
", length=" + length +
", headers=" + headers +
", body=" + (body == null ? null : new String(body, StandardCharsets.UTF_8)) +
'}';
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/ChannelTypeEnum.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/ChannelTypeEnum.java | package cn.bixin.sona.gateway.common;
/**
* @author qinwei
*/
public enum ChannelTypeEnum {
GENERAL(0, "通用连接"),
WHITEBOARD(1, "白板连接"),
CHATROOM(2, "房间连接"),
SIGNAL(3, "RTC信令连接"),
ACTIVITY(4, "活动连接");
private int type;
private String desc;
ChannelTypeEnum(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getType() {
return type;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/CommandEnum.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/CommandEnum.java | package cn.bixin.sona.gateway.common;
/**
* @author qinwei
*/
public enum CommandEnum {
CLOSE_CHANNEL(-1, "断开连接"),
LOGIN_AUTH(1, "客户端登录认证"),
CLIENT_PUSH(2, "客户端上报消息"),
CHATROOM_JOIN(10, "加入房间"),
CHATROOM_LEAVE(11, "离开房间"),
CHATROOM_SEND(12, "发送房间消息"),
CHATROOM_SIGNAL(13, "发送房间指令"),
GROUP_SEND(14, "发送群组消息");
private int command;
private String desc;
CommandEnum(int command, String desc) {
this.command = command;
this.desc = desc;
}
public int getCommand() {
return command;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Varint.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Varint.java | package cn.bixin.sona.gateway.common;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.CorruptedFrameException;
/**
* @author qinwei
*/
public final class Varint {
private Varint() {
}
public static int readRawVarint32(ByteBuf buffer) {
if (!buffer.isReadable()) {
return 0;
}
buffer.markReaderIndex();
byte tmp = buffer.readByte();
if (tmp >= 0) {
return tmp;
} else {
int result = tmp & 127;
if (!buffer.isReadable()) {
buffer.resetReaderIndex();
return 0;
}
if ((tmp = buffer.readByte()) >= 0) {
result |= tmp << 7;
} else {
result |= (tmp & 127) << 7;
if (!buffer.isReadable()) {
buffer.resetReaderIndex();
return 0;
}
if ((tmp = buffer.readByte()) >= 0) {
result |= tmp << 14;
} else {
result |= (tmp & 127) << 14;
if (!buffer.isReadable()) {
buffer.resetReaderIndex();
return 0;
}
if ((tmp = buffer.readByte()) >= 0) {
result |= tmp << 21;
} else {
result |= (tmp & 127) << 21;
if (!buffer.isReadable()) {
buffer.resetReaderIndex();
return 0;
}
result |= (tmp = buffer.readByte()) << 28;
if (tmp < 0) {
throw new CorruptedFrameException("malformed varint.");
}
}
}
}
return result;
}
}
public static void writeRawVarint32(ByteBuf out, int value) {
while (true) {
if ((value & ~0x7F) == 0) {
out.writeByte(value);
return;
} else {
out.writeByte((value & 0x7F) | 0x80);
value >>>= 7;
}
}
}
public static int computeRawVarint32Size(final int value) {
if ((value & (0xffffffff << 7)) == 0) {
return 1;
}
if ((value & (0xffffffff << 14)) == 0) {
return 2;
}
if ((value & (0xffffffff << 21)) == 0) {
return 3;
}
if ((value & (0xffffffff << 28)) == 0) {
return 4;
}
return 5;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/DeflaterCompress.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/DeflaterCompress.java | package cn.bixin.sona.gateway.common;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterOutputStream;
/**
* @author qinwei
*/
public final class DeflaterCompress {
private DeflaterCompress() {
}
public static byte[] compress(byte[] input) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream(input.length);
DeflaterOutputStream dos = new DeflaterOutputStream(baos);
dos.write(input);
dos.close();
return baos.toByteArray();
}
public static byte[] decompress(byte[] input) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream(input.length);
InflaterOutputStream ios = new InflaterOutputStream(baos);
ios.write(input);
ios.close();
return baos.toByteArray();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Bytes.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/Bytes.java | package cn.bixin.sona.gateway.common;
import io.netty.buffer.ByteBuf;
/**
* @author qinwei
*/
public final class Bytes {
private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
private Bytes() {
}
public static byte[] int2bytes(int v) {
byte[] ret = {0, 0, 0, 0};
int2bytes(v, ret);
return ret;
}
public static void int2bytes(int v, byte[] b) {
int2bytes(v, b, 0);
}
public static void int2bytes(int v, byte[] b, int off) {
b[off + 3] = (byte) v;
b[off + 2] = (byte) (v >>> 8);
b[off + 1] = (byte) (v >>> 16);
b[off + 0] = (byte) (v >>> 24);
}
public static int bytes2int(byte[] b) {
return bytes2int(b, 0);
}
public static int bytes2int(byte[] b, int off) {
return ((b[off + 3] & 0xFF) << 0) +
((b[off + 2] & 0xFF) << 8) +
((b[off + 1] & 0xFF) << 16) +
((b[off + 0]) << 24);
}
public static byte[] getFromBuf(ByteBuf in, int length) {
if (length <= 0) {
return EMPTY_BYTE_ARRAY;
}
byte[] bTemp = new byte[length];
in.readBytes(bTemp);
return bTemp;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/BatchResolve.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/BatchResolve.java | package cn.bixin.sona.gateway.common;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.buffer.Unpooled;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 不能用 Lambda 表达式，安卓是复用这个代码，使用 Lambda 的话可能会报错
*
* @author qinwei
*/
public final class BatchResolve {
private BatchResolve() {
}
public static List<AccessMessage> resolve(AccessMessage message) {
List<Header> headers = message.getHeaders();
if (headers == null || headers.isEmpty()) {
return Collections.singletonList(message);
}
int size = getBatchSize(headers);
if (size == 0) {
return Collections.singletonList(message);
}
ByteBuf byteBuf = Unpooled.wrappedBuffer(message.getBody());
List<AccessMessage> list = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
AccessMessage msg = new AccessMessage(message);
msg.setBody(Bytes.getFromBuf(byteBuf, byteBuf.readInt()));
list.add(msg);
}
return list;
}
private static int getBatchSize(List<Header> headers) {
for (Header header : headers) {
if (HeaderEnum.BATCH.getType() == header.getType()) {
return Integer.parseInt(new String(header.getData(), StandardCharsets.UTF_8));
}
}
return 0;
}
public static AccessMessage merge(List<AccessMessage> list) {
ByteBuf byteBuf = PooledByteBufAllocator.DEFAULT.heapBuffer();
for (AccessMessage message : list) {
byte[] body = message.getBody();
byteBuf.writeInt(body.length);
byteBuf.writeBytes(body);
}
AccessMessage message = new AccessMessage(list.get(0));
message.addHeader(new Header(HeaderEnum.BATCH, String.valueOf(list.size())));
message.setBody(Bytes.getFromBuf(byteBuf, byteBuf.readableBytes()));
byteBuf.release();
return message;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/common/MessageCodec.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/common/MessageCodec.java | package cn.bixin.sona.gateway.common;
import cn.bixin.sona.gateway.exception.AccessMessageDecodeException;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* @author qinwei
*/
public final class MessageCodec {
private static final int MIN_BODY_SIZE_TO_COMPRESS = 2048;
private MessageCodec() {
}
public static void encode(ByteBuf buf, AccessMessage msg) throws Exception {
buf.writeBoolean(msg.isReq());
buf.writeBoolean(msg.isTwoWay());
buf.writeBoolean(msg.isHeartbeat());
buf.writeByte(msg.getVersion());
Varint.writeRawVarint32(buf, msg.getId());
if (msg.isHeartbeat()) {
return;
}
buf.writeByte(msg.getCmd());
compress(msg);
List<Header> headers = msg.getHeaders();
int headerCount = headers == null ? 0 : headers.size();
int headerLength = 0;
for (int i = 0; i < headerCount; i++) {
headerLength += headers.get(i).calcTotalLength();
}
byte[] body = msg.getBody();
int bodyLength = body == null ? 0 : body.length;
msg.setLength(headerLength + bodyLength);
Varint.writeRawVarint32(buf, msg.getLength());
buf.writeByte(headerCount);
for (int i = 0; i < headerCount; i++) {
Header header = headers.get(i);
buf.writeByte(header.getType());
Varint.writeRawVarint32(buf, header.calcDataLength());
buf.writeBytes(header.getData());
}
if (bodyLength != 0) {
buf.writeBytes(body);
}
}
private static void compress(AccessMessage msg) throws IOException {
byte[] body = msg.getBody();
if (body != null && body.length >= MIN_BODY_SIZE_TO_COMPRESS) {
msg.setBody(DeflaterCompress.compress(body));
msg.addHeader(new Header(HeaderEnum.COMPRESS, "1"));
}
}
public static AccessMessage decode(ByteBuf buf) {
AccessMessage msg = new AccessMessage();
try {
msg.setReq(buf.readBoolean());
msg.setTwoWay(buf.readBoolean());
msg.setHeartbeat(buf.readBoolean());
msg.setVersion(buf.readByte());
msg.setId(Varint.readRawVarint32(buf));
if (msg.isHeartbeat()) {
return msg;
}
msg.setCmd(buf.readByte());
msg.setLength(Varint.readRawVarint32(buf));
int bodyLength = msg.getLength();
boolean compressed = false;
List<Header> headers = new ArrayList<>();
int headerCount = buf.readByte();
for (int i = 0; i < headerCount; i++) {
int headerType = buf.readByte();
int headerLength = Varint.readRawVarint32(buf);
if (buf.readableBytes() < headerLength) {
throw new AccessMessageDecodeException("given header len is wrong, curHeaderType=" + headerType + ", headerLength=" + headerLength + ", current ByteBuf length=" + buf.readableBytes());
}
Header header = new Header(headerType, Bytes.getFromBuf(buf, headerLength));
headers.add(header);
if (headerType == HeaderEnum.COMPRESS.getType()) {
compressed = true;
}
bodyLength -= header.calcTotalLength();
}
msg.setHeaders(headers);
byte[] body = Bytes.getFromBuf(buf, bodyLength);
if (compressed) {
body = DeflaterCompress.decompress(body);
}
msg.setBody(body);
return msg;
} catch (Exception e) {
if (e instanceof AccessMessageDecodeException) {
throw (AccessMessageDecodeException) e;
}
throw new AccessMessageDecodeException("msg decoder failed!", e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/ChatRoomInterceptor.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/ChatRoomInterceptor.java | package cn.bixin.sona.gateway.interceptor;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.ChannelTypeEnum;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
/**
* @author qinwei
*/
@Order(Ordered.HIGHEST_PRECEDENCE)
@Interceptor(name = "chatRoom")
public class ChatRoomInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(NettyChannel channel, AccessMessage message) throws Exception {
ChannelAttrs attrs = channel.getAttrs();
if (ChannelTypeEnum.CHATROOM.getType() != attrs.getChannelType()) {
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "WrongChannelType");
return false;
}
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/LoginAuthInterceptor.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/LoginAuthInterceptor.java | package cn.bixin.sona.gateway.interceptor;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.handler.IdleChannelHandler;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.CommandEnum;
import cn.bixin.sona.gateway.handler.LoginAuthHandler;
import cn.bixin.sona.gateway.msg.AccessResponse;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.EventRecordLog;
import com.alibaba.fastjson.JSON;
import io.netty.util.Timeout;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
/**
* @author qinwei
*/
@Order(Ordered.HIGHEST_PRECEDENCE)
@Interceptor(name = "loginAuth")
public class LoginAuthInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(NettyChannel channel, AccessMessage message) throws Exception {
byte[] body = message.getBody();
if (body == null || body.length == 0) {
channel.send(AccessMessageUtils.createResponse(message.getId(), message.getCmd(), JSON.toJSONBytes(AccessResponse.ACCESS_FAIL)), false, true);
EventRecordLog.logEvent(channel, LoginAuthHandler.LOGIN_EVENT, message, "EmptyBody");
MonitorUtils.logEvent(MonitorUtils.LOGIN_PROBLEM, "EmptyBody");
return false;
}
if (CommandEnum.LOGIN_AUTH.getCommand() != message.getCmd()) {
EventRecordLog.logEvent(channel, LoginAuthHandler.LOGIN_EVENT, message, "Unknown cmd");
MonitorUtils.logEvent(MonitorUtils.LOGIN_PROBLEM, "UnknownCmd");
return false;
}
return true;
}
@Override
public void postHandle(NettyChannel channel, AccessMessage message) throws Exception {
Timeout timeout = channel.removeAttribute(IdleChannelHandler.KEY_HAND_SHAKE, Timeout.class);
if (timeout != null) {
timeout.cancel();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/HandlerInterceptorChain.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/HandlerInterceptorChain.java | package cn.bixin.sona.gateway.interceptor;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author qinwei
*/
@Slf4j
@Component
public class HandlerInterceptorChain implements ApplicationContextAware {
private static List<HandlerInterceptor> allInterceptors;
private final List<HandlerInterceptor> interceptors;
private int interceptorIndex = -1;
private HandlerInterceptorChain(List<HandlerInterceptor> interceptors) {
this.interceptors = interceptors;
AnnotationAwareOrderComparator.sort(this.interceptors);
}
public static void init(Map<String, HandlerInterceptor> handlerInterceptors) {
allInterceptors = new ArrayList<>(handlerInterceptors.values());
}
public static HandlerInterceptorChain getHandlerInterceptorChain(String name) {
List<HandlerInterceptor> list = allInterceptors.stream().filter(interceptor -> match(name, interceptor)).collect(Collectors.toList());
return new HandlerInterceptorChain(list);
}
private static boolean match(String name, HandlerInterceptor interceptor) {
Interceptor annotation = AnnotationUtils.findAnnotation(interceptor.getClass(), Interceptor.class);
if (annotation == null) {
return false;
}
return ObjectUtils.isEmpty(annotation.name()) || Arrays.asList(annotation.name()).contains(name);
}
public boolean applyPreHandle(NettyChannel channel, AccessMessage message) throws Exception {
if (!CollectionUtils.isEmpty(interceptors)) {
for (int i = 0; i < interceptors.size(); i++) {
HandlerInterceptor interceptor = interceptors.get(i);
if (!interceptor.preHandle(channel, message)) {
applyAfterHandle(channel, message, null);
return false;
}
this.interceptorIndex = i;
}
}
return true;
}
public void applyPostHandle(NettyChannel channel, AccessMessage message) throws Exception {
if (!ObjectUtils.isEmpty(interceptors)) {
for (int i = interceptors.size() - 1; i >= 0; i--) {
HandlerInterceptor interceptor = interceptors.get(i);
interceptor.postHandle(channel, message);
}
}
}
public void applyAfterHandle(NettyChannel channel, AccessMessage message, Exception ex) {
if (!CollectionUtils.isEmpty(interceptors)) {
for (int i = interceptorIndex; i > 0; i--) {
HandlerInterceptor interceptor = interceptors.get(i);
try {
interceptor.afterHandle(channel, message, ex);
} catch (Throwable t) {
log.error("HandlerInterceptor.afterHandle threw exception", t);
}
}
this.interceptorIndex = -1;
}
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
init(applicationContext.getBeansOfType(HandlerInterceptor.class));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/HandlerInterceptor.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/HandlerInterceptor.java | package cn.bixin.sona.gateway.interceptor;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
/**
* @author qinwei
* <p>
* 业务 handler 拦截器 ,在实现类上添加注解 {@link Interceptor}, 指定需要拦截的handler (默认拦截所有)
* 并且支持下面几种方式排序
* @see org.springframework.core.Ordered
* @see org.springframework.core.annotation.Order
* @see javax.annotation.Priority
*/
public interface HandlerInterceptor {
default boolean preHandle(NettyChannel channel, AccessMessage message) throws Exception {
return true;
}
default void postHandle(NettyChannel channel, AccessMessage message) throws Exception {
}
default void afterHandle(NettyChannel channel, AccessMessage message, Exception ex) throws Exception {
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/Interceptor.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/interceptor/Interceptor.java | package cn.bixin.sona.gateway.interceptor;
import org.springframework.stereotype.Component;
import java.lang.annotation.*;
/**
* @author qinwei
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Interceptor {
String[] name() default {};
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/cat/MonitorUtils.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/cat/MonitorUtils.java | package cn.bixin.sona.gateway.cat;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.util.ExecuteFunction;
import cn.bixin.sona.gateway.util.NetUtil;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import com.google.common.base.Joiner;
import org.apache.commons.lang3.StringUtils;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
/**
* @author qinwei
*/
public final class MonitorUtils {
public static final String IDLE_STATE_EVENT = "Mercury.IdleStateEvent";
public static final String PROBE_IDLE = "Mercury.ProbeIdle";
public static final String CLOSE_LONG_LASTING_CHANNEL = "Mercury.CloseLongLastingChannel";
public static final String SAFE_EXCEPTION = "SafeException";
public static final String CONNECTION_RESET_BY_PEER = "SafeException.ConnectionResetByPeer";
public static final String LOGIN_PROBLEM = "Mercury.LoginProblem";
public static final String CLIENT_PUSH_PROBLEM = "Mercury.ClientPushProblem";
public static final String IM_MSG_PROBLEM = "Mercury.IMMsgProblem";
public static final String CHATROOM_PROBLEM = "Mercury.ChatRoomProblem";
public static final String SIGNAL_MSG_PROBLEM = "Mercury.SignalMsgProblem";
public static final String ACTIVITY_MSG_PROBLEM = "Mercury.ActivityMsgProblem";
public static final String MQ_LISTENER_PROBLEM = "Mercury.MqListenerProblem";
public static final String IM_MSG_LISTENER_PROBLEM = "Mercury.IMMsgListenerProblem";
public static final String SEND_MESSAGE_PROBLEM = "Mercury.SendMessageProblem";
public static final String RECEIVE_MESSAGE_PROBLEM = "Mercury.ReceiveMessageProblem";
public static final String LOGIN = "Mercury.Login";
public static final String ACK_RECEIVE = "Mercury.AckReceive";
public static final String MERCURY_ACCESS_DENY = "Mercury.AccessDeny";
public static final String CAT_IN_TRANS_TYPE = "ChIn";
public static final String CAT_OUT_TRANS_TYPE = "ChOut";
public static final String CAT_METRIC_IN_SIZE = "Msg.In.Size";
public static final String CAT_METRIC_OUT_SIZE = "Msg.Out.Size";
private MonitorUtils() {
}
public static void logEvent(String type, String name) {
Cat.logEvent(type, name);
}
public static void logBatchEvent(String type, String name, int count, int error) {
Cat.logBatchEvent(type, name, count, error);
}
public static void logMetricForCount(String name, int quantity, Map<String, String> tags) {
Cat.logMetricForCount(name, quantity, tags);
}
public static void logMetricForDuration(String name, long durationInMillis) {
Cat.logMetricForDuration(name, durationInMillis);
}
public static void newTransaction(String type, String name, ExecuteFunction execution) {
newTransaction(type, name, execution, null);
}
public static void newCompletedTransactionWithDuration(String type, String name, long duration) {
Cat.newCompletedTransactionWithDuration(type, name, duration);
}
public static void newTransaction(String type, String name, ExecuteFunction execution, BiConsumer<Transaction, String> finallyExecution) {
Transaction t = Cat.newTransaction(type, name);
try {
execution.execute();
t.setSuccessStatus();
} catch (Exception e) {
t.setStatus(e);
} finally {
if (finallyExecution != null) {
finallyExecution.accept(t, name);
}
t.complete();
}
}
public static void logCatEventWithMessage(String type, String name, Object msg, boolean isSuccess) {
String fullName;
if (msg instanceof AccessMessage) {
AccessMessage message = (AccessMessage) msg;
fullName = Joiner.on(":").join(name, message.getCmd());
} else {
fullName = Joiner.on(":").join(name, msg.getClass().getName());
}
logBatchEvent(type, fullName, 1, isSuccess ? 0 : 1);
}
public static void logCatEventWithChannelAttrs(String type, String name, NettyChannel channel, boolean isSuccess) {
logCatEventWithChannelAttrs(type, name, channel, isSuccess, false);
}
public static void logCatEventWithChannelAttrs(String type, String name, NettyChannel channel, boolean isSuccess, boolean withRemoteAddr) {
List<String> nameParts = new ArrayList<>();
if (StringUtils.isNotBlank(name)) {
nameParts.add(name);
}
ChannelAttrs attrs = channel.getAttrsIfExists();
if (attrs != null) {
nameParts.add(String.valueOf(attrs.getPlatform()));
nameParts.add("t" + attrs.getChannelType());
} else {
nameParts.add("0");
nameParts.add("t0");
}
if (withRemoteAddr) {
SocketAddress remoteAddr = channel.getRemoteAddress();
nameParts.add(NetUtil.getIpAddr(remoteAddr));
nameParts.add(String.valueOf(NetUtil.getPort(remoteAddr)));
}
logCatEventWithComplexName(type, nameParts, isSuccess);
}
private static void logCatEventWithComplexName(String type, Iterable<String> nameParts, boolean isSuccess) {
String fullName = Joiner.on(":").join(nameParts);
logBatchEvent(type, fullName, 1, isSuccess ? 0 : 1);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/cat/MercuryStatCollector.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/cat/MercuryStatCollector.java | package cn.bixin.sona.gateway.cat;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.RoomChannelManager;
import com.dianping.cat.Cat;
import com.dianping.cat.status.AbstractCollector;
import io.netty.util.internal.PlatformDependent;
import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author qinwei
*/
@Slf4j
public class MercuryStatCollector extends AbstractCollector {
@Override
public String getId() {
return "mercury.stat";
}
@Override
public Map<String, String> getProperties() {
Map<String, String> map = new LinkedHashMap<>();
map.put("conn.auth.count", String.valueOf(NettyChannel.authChannelCount()));
map.put("conn.unAuth.count", String.valueOf(NettyChannel.unAuthChannelCount()));
Map<Integer, AtomicInteger> channelTypeCount = NettyChannel.channelTypeCount();
for (Map.Entry<Integer, AtomicInteger> entry : channelTypeCount.entrySet()) {
Map<String, String> tags = new HashMap<>();
tags.put("t", String.valueOf(entry.getKey()));
Cat.logMetricForCount("mercury.conn.auth-", entry.getValue().get(), tags);
}
Cat.logMetricForCount("mercury.conn.unAuth-", NettyChannel.unAuthChannelCount());
map.put("netty.used.direct.mem", String.valueOf(PlatformDependent.usedDirectMemory()));
collectRoomChannelManagerStat(RoomChannelManager.MANAGER_FOR_CHATROOM);
return map;
}
private void collectRoomChannelManagerStat(RoomChannelManager manager) {
RoomChannelManager.SimpleStat roomStat = manager.stat();
if (roomStat != null) {
Cat.logMetricForCount("mercury.room." + manager.getName() + ".total", roomStat.getRoomCount());
Cat.logMetricForCount("mercury.room." + manager.getName() + ".conn", roomStat.getTotalRoomChannelCount());
}
RoomChannelManager.DetailStat detailStat = manager.detailStat();
String eventType = "Mercury.RoomConn." + manager.getName();
for (Map.Entry<String, Integer> entry : detailStat.getRoomChannelCount().entrySet()) {
Cat.logBatchEvent(eventType, entry.getKey(), entry.getValue(), 0);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/HashStrategy.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/HashStrategy.java | package cn.bixin.sona.gateway.loadbalance;
/**
* @author qinwei
*/
public interface HashStrategy {
int hash(String origin);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/ConsistentHashLoadBalance.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/ConsistentHashLoadBalance.java | package cn.bixin.sona.gateway.loadbalance;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
* @author qinwei
*/
public class ConsistentHashLoadBalance<T> implements LoadBalance<T> {
private static final int REPLICA_NUM = 8;
private static final String VIRTUAL_SEPARATOR = "|";
private final TreeMap<Integer, T> virtualNodes = new TreeMap<>();
private final HashStrategy strategy = new FnvHashStrategy();
public ConsistentHashLoadBalance(List<T> list) {
this(list, REPLICA_NUM);
}
public ConsistentHashLoadBalance(List<T> list, int replicaNum) {
for (T t : list) {
String key = t.toString();
for (int i = 0; i < replicaNum; i++) {
virtualNodes.put(strategy.hash(key + VIRTUAL_SEPARATOR + Integer.toHexString(i)), t);
}
}
}
@Override
public T selectNode(String key) {
return locate(strategy.hash(key));
}
private T locate(int hash) {
Map.Entry<Integer, T> entry = virtualNodes.ceilingEntry(hash);
if (entry == null) {
entry = virtualNodes.firstEntry();
}
return entry.getValue();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/FnvHashStrategy.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/FnvHashStrategy.java | package cn.bixin.sona.gateway.loadbalance;
/**
* @author qinwei
* <p>
* FNV 能快速 hash 大量数据并保持较小的冲突率，它的高度分散使它适用于 hash 一些非常相近的字符串，比如 URL，hostname，文件名，text，IP 地址等。
*/
public class FnvHashStrategy implements HashStrategy {
private static final long FNV_32_INIT = 2166136261L;
private static final int FNV_32_PRIME = 16777619;
@Override
public int hash(String origin) {
final int p = FNV_32_PRIME;
int hash = (int) FNV_32_INIT;
for (int i = 0; i < origin.length(); i++) {
hash = (hash ^ origin.charAt(i)) * p;
}
hash += hash << 13;
hash ^= hash >> 7;
hash += hash << 3;
hash ^= hash >> 17;
hash += hash << 5;
hash = Math.abs(hash);
return hash;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/LoadBalance.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/LoadBalance.java | package cn.bixin.sona.gateway.loadbalance;
/**
* @author qinwei
*/
public interface LoadBalance<T> {
T selectNode(String key);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/RoundRobinLoadLoadBalance.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/loadbalance/RoundRobinLoadLoadBalance.java | package cn.bixin.sona.gateway.loadbalance;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author qinwei
*/
public class RoundRobinLoadLoadBalance<T> implements LoadBalance<T> {
private final AtomicInteger id = new AtomicInteger();
private final List<T> list;
private final boolean optimize;
public RoundRobinLoadLoadBalance(List<T> list) {
this.list = list;
optimize = isPowerOfTwo(list.size());
}
@Override
public T selectNode(String key) {
if (optimize) {
return list.get(id.getAndIncrement() & list.size() - 1);
}
return list.get(id.getAndIncrement() % list.size());
}
private static boolean isPowerOfTwo(int val) {
return (val & -val) == val;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/config/TraceConfiguration.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/config/TraceConfiguration.java | package cn.bixin.sona.gateway.config;
import cn.bixin.sona.common.rocket.TraceConsumerHook;
import cn.bixin.sona.common.rocket.TraceSendHook;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author qinwei
*/
@Configuration
public class TraceConfiguration {
@Bean
public TraceConsumerHook traceConsumerHook() {
return new TraceConsumerHook();
}
@Bean
public TraceSendHook traceSendHook() {
return new TraceSendHook();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/config/ApolloConfiguration.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/config/ApolloConfiguration.java | package cn.bixin.sona.gateway.config;
import cn.bixin.sona.gateway.channel.support.AccessFilter;
import com.ctrip.framework.apollo.Config;
import com.ctrip.framework.apollo.model.ConfigChangeEvent;
import com.ctrip.framework.apollo.spring.annotation.ApolloConfig;
import com.ctrip.framework.apollo.spring.annotation.ApolloConfigChangeListener;
import lombok.Getter;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
* @author qinwei
*/
@Component
@Getter
@Setter
public class ApolloConfiguration {
/**
* server端需要重启时，对发送的close消息进行平滑限流，每秒最多发出X条close消息
*/
@Value("${close.msg.throttling:750}")
private int closeMsgThrottling;
/**
* 开始发送close消息后，server会等待连接全部被关闭。但此过程如果超过X秒，则不再等待，直接调用shutdownGracefully。
*/
@Value("${close.msg.max.wait.seconds:40}")
private int closeMsgMaxWaitSeconds;
/**
* 连接建立后X秒内不握手的连接，会被强制断开
*/
@Value("${handshake.wait.seconds:5}")
private int handshakeWaitSeconds;
/**
* X秒内没有读到过新数据的连接，认为是僵死连接，会被强制断开
*/
@Value("${channel.idle.seconds:280}")
private int channelIdleSeconds;
/**
* X秒内没有读到过新数据，且在前台状态的连接，服务端主动发送探测消息
*/
@Value("${probe.idle.seconds:130}")
private int probeIdleSeconds;
/**
* 发送探测消息后X秒内没有收到回复的连接，会被强制断开
*/
@Value("${probe.wait.seconds:4}")
private int probeWaitSeconds;
/**
* 持续时间超过X小时的连接，定期断开，以免redis数据过期失效，导致其他错误。设为-1关闭此功能
*/
@Value("${long.lasting.close.hours:144}")
private int longLastingCloseHours;
@Value("${room.message.async:false}")
private boolean roomMessageAsync;
@ApolloConfig
private Config config;
private static final String KEY_IP_RULES = "access.filter.rules";
@PostConstruct
public void init() {
AccessFilter.INSTANCE.updateRules(config.getProperty(KEY_IP_RULES, "[]"));
}
@ApolloConfigChangeListener
public void onChange(ConfigChangeEvent changeEvent) {
if (changeEvent.isChanged(KEY_IP_RULES)) {
AccessFilter.INSTANCE.updateRules(config.getProperty(KEY_IP_RULES, "[]"));
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/AbstractTimerTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/AbstractTimerTask.java | package cn.bixin.sona.gateway.task;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
import lombok.Getter;
import java.util.concurrent.TimeUnit;
/**
* @author qinwei
*/
@Getter
public abstract class AbstractTimerTask implements TimerTask {
private final long tick;
private int retry;
private volatile boolean cancel;
public AbstractTimerTask(long tick) {
this.tick = tick;
}
public void cancel() {
this.cancel = true;
}
protected void retry(Timeout timeout) {
retry(timeout, tick);
}
protected void retry(Timeout timeout, long tick) {
Timer timer = getTimer(timeout);
if (timer == null) {
return;
}
retry++;
timer.newTimeout(this, tick, TimeUnit.MILLISECONDS);
}
protected void reput(Timeout timeout) {
reput(timeout, tick, this);
}
protected void reput(Timeout timeout, long tick) {
reput(timeout, tick, this);
}
protected void reput(Timeout timeout, long tick, TimerTask task) {
Timer timer = getTimer(timeout);
if (timer == null) {
return;
}
timer.newTimeout(task, tick, TimeUnit.MILLISECONDS);
}
private Timer getTimer(Timeout timeout) {
if (timeout == null) {
return null;
}
if (cancel) {
return null;
}
Timer timer = timeout.timer();
if (timer == null || timeout.isCancelled()) {
return null;
}
return timer;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/ScheduleTimerTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/ScheduleTimerTask.java | package cn.bixin.sona.gateway.task;
import cn.bixin.sona.gateway.channel.NettyChannel;
import io.netty.util.Timeout;
import lombok.extern.slf4j.Slf4j;
import java.util.Collection;
/**
* @author qinwei
*/
@Slf4j
public abstract class ScheduleTimerTask extends AbstractTimerTask {
public ScheduleTimerTask(long tick) {
super(tick);
}
@Override
public void run(Timeout timeout) throws Exception {
Collection<NettyChannel> allChannels = NettyChannel.getAllChannels();
for (NettyChannel channel : allChannels) {
if (channel.isConnected()) {
doTask(channel);
}
}
reput(timeout);
}
protected abstract void doTask(NettyChannel channel);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/RetryTimerTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/RetryTimerTask.java | package cn.bixin.sona.gateway.task;
import io.netty.util.Timeout;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
*/
@Slf4j
public abstract class RetryTimerTask extends AbstractTimerTask {
private int maxRetries;
private int waitTime;
public RetryTimerTask(int maxRetries) {
this(maxRetries, 0);
}
public RetryTimerTask(int maxRetries, int waitTime) {
this(0, maxRetries, waitTime);
}
public RetryTimerTask(long tick, int maxRetries, int waitTime) {
super(tick);
this.maxRetries = maxRetries;
this.waitTime = waitTime;
}
@Override
public void run(Timeout timeout) throws Exception {
try {
doTask();
} catch (Throwable e) {
log.error("RetryTimerTask execute failure , the task will retry {} times after {} ms. ", maxRetries - getRetry(), waitTime, e);
if (getRetry() < maxRetries) {
retry(timeout, waitTime);
}
}
}
protected abstract void doTask();
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/HandshakeTimeoutTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/HandshakeTimeoutTask.java | package cn.bixin.sona.gateway.task;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import io.netty.util.Timeout;
import io.netty.util.TimerTask;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
*/
@Slf4j
public class HandshakeTimeoutTask implements TimerTask {
private final NettyChannel channel;
public HandshakeTimeoutTask(NettyChannel channel) {
this.channel = channel;
}
@Override
public void run(Timeout timeout) throws Exception {
try {
if (!channel.isConnected()) {
return;
}
channel.close();
log.info("HandshakeNotReceived, remoteAddress={}", channel.getRemoteAddress());
MonitorUtils.logEvent(MonitorUtils.LOGIN_PROBLEM, "HandshakeNotReceived");
} catch (Throwable t) {
log.warn("Exception when handle handshake task , channel " + channel.getRemoteAddress(), t);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/ProbeIdleTimerTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/ProbeIdleTimerTask.java | package cn.bixin.sona.gateway.task;
import cn.bixin.sona.common.spring.SpringApplicationContext;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.concurrent.counter.SystemClock;
import cn.bixin.sona.gateway.config.ApolloConfiguration;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.EventRecordLog;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeoutException;
/**
* @author qinwei
*/
@Slf4j
public class ProbeIdleTimerTask extends HeartbeatTimerTask {
public ProbeIdleTimerTask(long tick, int idleTimeout) {
super(tick, idleTimeout);
}
@Override
protected void doTask(NettyChannel channel) {
try {
if (!channel.isConnected()) {
return;
}
long now = SystemClock.currentTimeMillis();
boolean isReadTimeout = isReadTimeout(channel, now);
if (isReadTimeout) {
ChannelAttrs attrs = channel.getAttrsIfExists();
if (attrs == null) {
return;
}
if (attrs.isForeground()) {
int probeWaitSeconds = SpringApplicationContext.getBean(ApolloConfiguration.class).getProbeWaitSeconds();
if (probeWaitSeconds <= 0) {
return;
}
log.info("ProbeSent, remoteAddress={}", channel.getRemoteAddress());
AccessMessage request = AccessMessageUtils.createHeartRequest(channel.getSequece());
channel.request(request, probeWaitSeconds * 1000)
.whenComplete((message, throwable) -> {
if (throwable instanceof TimeoutException) {
EventRecordLog.logEvent(channel, "Probe timeout", probeWaitSeconds + " s");
channel.close();
MonitorUtils.logCatEventWithChannelAttrs(MonitorUtils.PROBE_IDLE, "", channel, false);
}
});
}
}
} catch (Throwable t) {
log.warn("Exception when handle probe message , channel " + channel.getRemoteAddress(), t);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/task/HeartbeatTimerTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/task/HeartbeatTimerTask.java | package cn.bixin.sona.gateway.task;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.handler.IdleChannelHandler;
import cn.bixin.sona.gateway.concurrent.counter.SystemClock;
import cn.bixin.sona.gateway.util.EventRecordLog;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
*/
@Slf4j
public class HeartbeatTimerTask extends ScheduleTimerTask {
private final int idleTimeout;
public HeartbeatTimerTask(long tick, int idleTimeout) {
super(tick);
this.idleTimeout = idleTimeout;
}
@Override
protected void doTask(NettyChannel channel) {
try {
if (!channel.isConnected()) {
return;
}
long now = SystemClock.currentTimeMillis();
boolean isReadTimeout = isReadTimeout(channel, now);
boolean isWriteTimeout = isWriteTimeout(channel, now);
if (isReadTimeout || isWriteTimeout) {
EventRecordLog.logEvent(channel, "Heartbeat timeout", idleTimeout + " ms");
channel.close();
MonitorUtils.logCatEventWithChannelAttrs(MonitorUtils.IDLE_STATE_EVENT, isReadTimeout ? "READER_IDLE" : "WRITER_IDLE", channel, true);
}
} catch (Throwable t) {
log.warn("Exception when close channel " + channel.getRemoteAddress(), t);
}
}
protected boolean isReadTimeout(NettyChannel channel, long now) {
Long lastRead = lastRead(channel);
return lastRead != null && now - lastRead > idleTimeout;
}
protected boolean isWriteTimeout(NettyChannel channel, long now) {
Long lastWrite = lastWrite(channel);
return lastWrite != null && now - lastWrite > idleTimeout;
}
public static Long lastRead(NettyChannel channel) {
return channel.getAttribute(IdleChannelHandler.KEY_READ_TIMESTAMP, Long.class);
}
public static Long lastWrite(NettyChannel channel) {
return channel.getAttribute(IdleChannelHandler.KEY_WRITE_TIMESTAMP, Long.class);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/Channel.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/Channel.java | package cn.bixin.sona.gateway.channel;
import cn.bixin.sona.gateway.channel.support.NettyFuture;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import java.net.InetSocketAddress;
/**
* @author qinwei
* <p>
* 对 netty 底层 channel 的封装，业务层直接操作 NettyChannel，无需关心底层channel的处理
*/
public interface Channel {
InetSocketAddress getLocalAddress();
InetSocketAddress getRemoteAddress();
boolean isConnected();
NettyFuture request(AccessMessage request) throws RemoteException;
NettyFuture request(AccessMessage request, int timeout) throws RemoteException;
void send(Object message) throws RemoteException;
void send(Object message, boolean sent, boolean closeWhenComplete) throws RemoteException;
void close();
boolean isClosed();
boolean hasAttribute(String key);
Object getAttribute(String key);
void setAttribute(String key, Object value);
Object removeAttribute(String key);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/AbstractChannel.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/AbstractChannel.java | package cn.bixin.sona.gateway.channel;
import cn.bixin.sona.gateway.channel.support.NettyFuture;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author qinwei
*/
public abstract class AbstractChannel implements Channel {
private volatile boolean closed;
private volatile boolean active;
protected final Map<Integer, NettyFuture> futures = new ConcurrentHashMap<>();
@Override
public NettyFuture request(AccessMessage request) throws RemoteException {
return request(request, 3000);
}
@Override
public void send(Object message) throws RemoteException {
send(message, false, false);
}
public void markActive(boolean isActive) {
this.active = isActive;
}
public boolean isActive() {
return this.active;
}
@Override
public boolean isConnected() {
return !isClosed() && isActive();
}
@Override
public void send(Object message, boolean sent, boolean closeWhenComplete) throws RemoteException {
if (isClosed()) {
throw new RemoteException(this, "Failed to send message " + (message == null ? "" : message.getClass().getName()) + ":" + message
+ ", cause: Channel closed. channel: " + getLocalAddress() + " -> " + getRemoteAddress());
}
}
@Override
public void close() {
this.closed = true;
}
@Override
public boolean isClosed() {
return closed;
}
public Map<Integer, NettyFuture> getFutures() {
return futures;
}
@Override
public String toString() {
return getLocalAddress() + " -> " + getRemoteAddress();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/RoomChannelManager.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/RoomChannelManager.java | package cn.bixin.sona.gateway.channel;
import com.google.common.collect.Maps;
import lombok.Data;
import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.common.utils.ConcurrentHashSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
/**
* 管理连接与房间的对应关系
*
* @author qinwei
*/
public class RoomChannelManager {
public static final RoomChannelManager MANAGER_FOR_CHATROOM = new RoomChannelManager("ChatRoom");
private final Map<String, RoomInfo> roomInfoMap = new ConcurrentHashMap<>();
@Getter
private final String name;
public RoomChannelManager(String name) {
this.name = name;
}
@Data
public static class RoomInfo {
private final String name;
private final Set<NettyChannel> channels;
private final Map<String, Set<NettyChannel>> memberChannelsMap;
public RoomInfo(String name) {
this.name = name;
this.channels = new ConcurrentHashSet<>();
this.memberChannelsMap = new ConcurrentHashMap<>();
}
public boolean registerUid(String uid, NettyChannel channel) {
return memberChannelsMap.computeIfAbsent(uid, k -> new ConcurrentHashSet<>(1)).add(channel);
}
public boolean deregisterUid(NettyChannel channel) {
String oldUid = channel.getAttrs().getUid();
if (StringUtils.isBlank(oldUid)) {
return false;
}
Set<NettyChannel> channels = memberChannelsMap.get(oldUid);
if (channels != null && channels.remove(channel)) {
if (channels.isEmpty()) {
// destroy if empty
memberChannelsMap.computeIfPresent(oldUid, (k, v) -> v.isEmpty() ? null : v);
}
return true;
}
return false;
}
public Set<NettyChannel> getChannelsByMember(String member) {
return member == null ? Collections.emptySet() : memberChannelsMap.getOrDefault(member, Collections.emptySet());
}
}
public boolean addChannel(String roomName, NettyChannel channel, String uid) {
RoomInfo roomInfo = roomInfoMap.computeIfAbsent(roomName, RoomInfo::new);
if (StringUtils.isNotBlank(uid)) {
roomInfo.registerUid(uid, channel);
}
boolean isNewAdded = roomInfo.getChannels().add(channel);
channel.getAttrs().getRooms().add(roomName);
return isNewAdded;
}
public void removeChannel(String roomName, NettyChannel channel) {
RoomInfo roomInfo = roomInfoMap.get(roomName);
if (roomInfo != null) {
Set<NettyChannel> channels = roomInfo.getChannels();
channels.remove(channel);
if (channels.isEmpty()) {
// destroy room if empty
roomInfoMap.computeIfPresent(roomName, (k, v) -> v.getChannels().isEmpty() ? null : v);
}
roomInfo.deregisterUid(channel);
}
channel.getAttrs().getRooms().remove(roomName);
}
public void destroyRoom(String roomName) {
RoomInfo roomInfo = roomInfoMap.remove(roomName);
if (roomInfo != null) {
for (NettyChannel channel : roomInfo.getChannels()) {
channel.getAttrs().getRooms().remove(roomName);
}
}
}
public RoomInfo getRoomInfo(String roomName) {
return roomInfoMap.get(roomName);
}
public Collection<RoomInfo> getAllRoomInfos() {
return roomInfoMap.values();
}
@Data
public static class SimpleStat {
private int roomCount;
private int totalRoomChannelCount;
private String maxRoom;
private int maxRoomChannelCount;
}
public SimpleStat stat() {
SimpleStat stat = new SimpleStat();
stat.setRoomCount(roomInfoMap.size());
int totalRoomChannelCount = 0;
String maxRoom = null;
int maxRoomChannelCount = 0;
for (RoomInfo roomInfo : roomInfoMap.values()) {
int size = roomInfo.getChannels().size();
totalRoomChannelCount += size;
if (size > maxRoomChannelCount) {
maxRoomChannelCount = size;
maxRoom = roomInfo.getName();
}
}
stat.setTotalRoomChannelCount(totalRoomChannelCount);
stat.setMaxRoom(maxRoom);
stat.setMaxRoomChannelCount(maxRoomChannelCount);
return stat;
}
@Data
public static class DetailStat {
private Map<String, Integer> roomChannelCount;
}
public DetailStat detailStat() {
DetailStat stat = new DetailStat();
Map<String, Integer> roomChannelCount = Maps.newHashMapWithExpectedSize(roomInfoMap.size());
for (RoomInfo roomInfo : roomInfoMap.values()) {
roomChannelCount.put(roomInfo.getName(), roomInfo.getChannels().size());
}
stat.setRoomChannelCount(roomChannelCount);
return stat;
}
@Data
public static class MemberStat {
private Map<String, Set<String>> roomMembers;
}
public MemberStat memberStat() {
MemberStat stat = new MemberStat();
Map<String, Set<String>> roomMembers = Maps.newHashMapWithExpectedSize(roomInfoMap.size());
for (RoomInfo roomInfo : roomInfoMap.values()) {
roomMembers.put(roomInfo.getName(), roomInfo.getMemberChannelsMap().keySet());
}
stat.setRoomMembers(roomMembers);
return stat;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/NettyChannel.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/NettyChannel.java | package cn.bixin.sona.gateway.channel;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.channel.support.NettyFuture;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.concurrent.buffer.ChannelBuffer;
import cn.bixin.sona.gateway.exception.RemoteException;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.util.internal.PlatformDependent;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
/**
* @author qinwei
* <p>
* 对 netty 底层 channel 的封装，业务层直接操作 NettyChannel，无需关心底层channel的处理
*/
@Slf4j
public class NettyChannel extends AbstractChannel {
private static final ConcurrentMap<String, NettyChannel> CHANNEL_MAP = PlatformDependent.newConcurrentHashMap(1 << 14);
private static final ConcurrentMap<Integer, AtomicInteger> CHANNEL_TYPE_COUNT_MAP = PlatformDependent.newConcurrentHashMap();
private static final AtomicInteger UN_AUTH_COUNT = new AtomicInteger();
/**
* 减少内存使用
*/
private static final AtomicIntegerFieldUpdater<NettyChannel> FLUSH_UPDATER = AtomicIntegerFieldUpdater.newUpdater(NettyChannel.class, "flush");
private static final AtomicIntegerFieldUpdater<NettyChannel> SEQUECE_UPDATER = AtomicIntegerFieldUpdater.newUpdater(NettyChannel.class, "sequece");
private final ConcurrentMap<String, Object> attributes = PlatformDependent.newConcurrentHashMap();
private final Channel channel;
private final AtomicBoolean auth = new AtomicBoolean(false);
private final ChannelBuffer buffer = new ChannelBuffer();
private volatile int flush;
private volatile int sequece;
private NettyChannel(Channel channel) {
this.channel = channel;
}
public static NettyChannel getOrAddChannel(Channel channel) {
if (channel == null) {
return null;
}
String channelId = ChannelAttrs.getChannelId(channel);
NettyChannel result = CHANNEL_MAP.get(channelId);
if (result == null) {
NettyChannel nettyChannel = new NettyChannel(channel);
UN_AUTH_COUNT.incrementAndGet();
if (channel.isActive()) {
nettyChannel.markActive(true);
result = CHANNEL_MAP.putIfAbsent(channelId, nettyChannel);
}
if (result == null) {
result = nettyChannel;
}
}
return result;
}
public static void removeChannel(Channel channel) {
if (channel == null) {
return;
}
NettyChannel nettyChannel = CHANNEL_MAP.remove(ChannelAttrs.getChannelId(channel));
if (nettyChannel != null) {
nettyChannel.markActive(false);
if (nettyChannel.isAuth()) {
int channelType = nettyChannel.getAttrs().getChannelType();
CHANNEL_TYPE_COUNT_MAP.computeIfAbsent(channelType, k -> new AtomicInteger()).decrementAndGet();
} else {
UN_AUTH_COUNT.decrementAndGet();
}
}
}
public static void addChannelTypeCount(NettyChannel channel) {
if (channel.isConnected()) {
int channelType = channel.getAttrs().getChannelType();
CHANNEL_TYPE_COUNT_MAP.computeIfAbsent(channelType, k -> new AtomicInteger()).incrementAndGet();
}
}
public static Map<Integer, AtomicInteger> channelTypeCount() {
return CHANNEL_TYPE_COUNT_MAP;
}
public static int authChannelCount() {
return Math.max(CHANNEL_MAP.size() - unAuthChannelCount(), 0);
}
public static int unAuthChannelCount() {
return UN_AUTH_COUNT.get();
}
public static NettyChannel getChannel(String channelId) {
return CHANNEL_MAP.get(channelId);
}
public static Collection<NettyChannel> getAllChannels() {
return CHANNEL_MAP.values();
}
public boolean markAuth() {
if (isConnected() && auth.compareAndSet(false, true)) {
UN_AUTH_COUNT.decrementAndGet();
return true;
}
return false;
}
public int getSequece() {
return SEQUECE_UPDATER.incrementAndGet(this);
}
public boolean isAuth() {
return auth.get();
}
public String getChannelId() {
return getAttrs().getChannelId();
}
public ChannelAttrs getAttrs() {
return ChannelAttrs.getAttrs(channel);
}
public ChannelAttrs getAttrsIfExists() {
return ChannelAttrs.getAttrsIfExists(channel);
}
public boolean isWritable() {
return channel.isWritable();
}
@Override
public InetSocketAddress getLocalAddress() {
return (InetSocketAddress) channel.localAddress();
}
@Override
public InetSocketAddress getRemoteAddress() {
return (InetSocketAddress) channel.remoteAddress();
}
public String getUid() {
return getAttrs().getUid();
}
public void fastSend(AccessMessage message, boolean immediate) {
if (immediate) {
fastSendNow(message);
} else {
fastSendLater(message);
}
}
private void fastSendNow(AccessMessage msg) {
if (canSend(msg)) {
channel.writeAndFlush(msg).addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
}
}
private void fastSendLater(AccessMessage msg) {
buffer.offer(msg, this::fastSendNow);
if (FLUSH_UPDATER.compareAndSet(this, 0, 1)) {
channel.eventLoop().schedule(this::flush, 50, TimeUnit.MILLISECONDS);
}
}
private void flush() {
while (FLUSH_UPDATER.getAndSet(this, 0) == 1) {
buffer.drainTo(this::fastSendNow);
}
}
private boolean canSend(AccessMessage message) {
if (!isConnected()) {
MonitorUtils.logCatEventWithMessage(MonitorUtils.SEND_MESSAGE_PROBLEM, "ChannelNotActive", message, false);
return false;
}
if (!isWritable()) {
MonitorUtils.logCatEventWithMessage(MonitorUtils.SEND_MESSAGE_PROBLEM, "ChannelNotWritable", message, false);
return false;
}
return true;
}
@Override
public NettyFuture request(AccessMessage request, int timeout) throws RemoteException {
NettyFuture future = NettyFuture.newFuture(request.getId(), timeout, this);
try {
send(request, true, false);
} catch (RemoteException e) {
future.cancel(e);
}
return future;
}
@Override
public void send(Object message, boolean sent, boolean closeWhenComplete) throws RemoteException {
super.send(message, sent, closeWhenComplete);
String name;
if (!(message instanceof AccessMessage)) {
name = message.getClass().getSimpleName();
} else {
AccessMessage msg = (AccessMessage) message;
name = msg.isHeartbeat() ? "HB" : String.valueOf(msg.getCmd());
}
MonitorUtils.newTransaction(MonitorUtils.CAT_OUT_TRANS_TYPE, name, () -> doSend(message, sent, closeWhenComplete));
}
private void doSend(Object message, boolean sent, boolean closeWhenComplete) throws RemoteException {
boolean success = true;
int timeout = 1000;
try {
ChannelFuture future = channel.writeAndFlush(message);
if (closeWhenComplete) {
future.addListener((ChannelFutureListener) f -> close());
}
if (sent) {
success = future.await(timeout);
}
Throwable cause = future.cause();
if (cause != null) {
throw cause;
} else {
future.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
}
} catch (Throwable t) {
throw new RemoteException(this, "Failed to send message " + message + " to " + getRemoteAddress() + ", cause: " + t.getMessage(), t);
}
if (!success) {
throw new RemoteException(this, "Failed to send message " + message + " to " + getRemoteAddress() + "in timeout(" + timeout + "ms) limit");
}
}
@Override
public boolean hasAttribute(String key) {
return attributes.containsKey(key);
}
@Override
public Object getAttribute(String key) {
return attributes.get(key);
}
public <T> T getAttribute(String key, Class<T> type) {
return type.cast(getAttribute(key));
}
public <T> T removeAttribute(String key, Class<T> type) {
return type.cast(removeAttribute(key));
}
@Override
public void setAttribute(String key, Object value) {
if (value != null) {
attributes.put(key, value);
} else {
removeAttribute(key);
}
}
@Override
public Object removeAttribute(String key) {
return attributes.remove(key);
}
public void clear() {
attributes.clear();
}
@Override
public void close() {
try {
super.close();
channel.close();
} catch (Exception e) {
log.warn(e.getMessage(), e);
}
}
@Override
public final int hashCode() {
return channel.id().hashCode();
}
@Override
public final boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof NettyChannel)) {
return false;
}
return ((NettyChannel) o).channel.id().asLongText().equals(this.channel.id().asLongText());
}
@Override
public String toString() {
return "NettyChannel [channelId=" + ChannelAttrs.getChannelId(channel) + ", channel=" + channel + "]";
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelIdGenerator.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelIdGenerator.java | package cn.bixin.sona.gateway.channel.support;
import cn.bixin.sona.gateway.util.NetUtil;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author qinwei
*/
@Slf4j
public final class ChannelIdGenerator {
private static final String CH_ID_SEPARATOR = "|";
private static final AtomicInteger SEQ = new AtomicInteger();
private ChannelIdGenerator() {
}
public static String generateChannelId(InetSocketAddress remoteAddr, long timestamp) {
StringBuilder sb = new StringBuilder(96);
sb.append(NetUtil.LOCAL_IP_ADDR);
sb.append(CH_ID_SEPARATOR);
sb.append(remoteAddr.getAddress().getHostAddress());
sb.append(CH_ID_SEPARATOR);
sb.append(remoteAddr.getPort());
sb.append(CH_ID_SEPARATOR);
sb.append(timestamp);
sb.append(CH_ID_SEPARATOR);
sb.append(Integer.toHexString(SEQ.getAndIncrement()));
return sb.toString();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelAttrs.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelAttrs.java | package cn.bixin.sona.gateway.channel.support;
import cn.bixin.sona.gateway.concurrent.counter.SystemClock;
import io.netty.channel.Channel;
import io.netty.util.AttributeKey;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.common.utils.ConcurrentHashSet;
import java.net.InetSocketAddress;
import java.util.Set;
/**
* mercury自定义的channel扩展属性
*
* @author qinwei
*/
@Slf4j
@Getter
@Setter
public class ChannelAttrs {
public static final AttributeKey<ChannelAttrs> MERCURY_ATTRS = AttributeKey.valueOf("MERCURY.ATTRS");
private final long createTime;
private final String channelId;
/**
* 连接类型
*/
private int channelType = -1;
/**
* 客户端协议版本
*/
private int clientProtoVer;
/**
* 设备id
*/
private String deviceId;
private int platform = -1;
private String sysVer;
private String model;
private String uid;
/**
* 是否游客模式
*/
private boolean isVisitor = false;
private Set<String> rooms = new ConcurrentHashSet<>(2);
private boolean foreground = true;
public ChannelAttrs(InetSocketAddress remoteAddr) {
this.createTime = SystemClock.currentTimeMillis();
this.channelId = ChannelIdGenerator.generateChannelId(remoteAddr, createTime);
}
public static ChannelAttrs init(Channel ch, InetSocketAddress remoteAddr) {
ChannelAttrs attrs = new ChannelAttrs(remoteAddr);
attrs = ch.attr(MERCURY_ATTRS).setIfAbsent(attrs);
return attrs;
}
public static ChannelAttrs getAttrs(Channel ch) {
ChannelAttrs attrs = ch.attr(MERCURY_ATTRS).get();
if (attrs == null) {
throwIllegalStateException("MERCURY_ATTRS is null! ch=" + ch);
}
return attrs;
}
public static ChannelAttrs getAttrsIfExists(io.netty.channel.Channel ch) {
return ch.attr(MERCURY_ATTRS).get();
}
public static String getChannelId(Channel ch) {
ChannelAttrs attrs = getAttrs(ch);
String chId = attrs.getChannelId();
if (StringUtils.isBlank(chId)) {
throwIllegalStateException("CH_ID is blank! ch=" + ch);
}
return chId;
}
private static void throwIllegalStateException(String msg) {
IllegalStateException e = new IllegalStateException(msg);
log.error(msg, e);
throw e;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelEventState.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelEventState.java | package cn.bixin.sona.gateway.channel.support;
/**
* @author qinwei
*/
public enum ChannelEventState {
CONNECT,
DISCONNECT,
SENT,
RECEIVE,
CAUGHT
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/AccessFilter.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/AccessFilter.java | package cn.bixin.sona.gateway.channel.support;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Splitter;
import io.netty.handler.ipfilter.IpFilterRule;
import io.netty.handler.ipfilter.IpFilterRuleType;
import io.netty.handler.ipfilter.IpSubnetFilterRule;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
import java.util.List;
/**
* 连接接入 黑名单过滤
*
* @author qinwei
*/
@Slf4j
public class AccessFilter {
public static final AccessFilter INSTANCE = new AccessFilter();
private static final Splitter FIELD_SPLITTER = Splitter.on('/').trimResults().omitEmptyStrings();
private volatile IpFilterRule[] rules;
public void updateRules(String str) {
List<String> ruleStrs = JSON.parseArray(str, String.class);
if (ruleStrs == null) {
log.error("AccessFilter updateRules() error!", new IllegalArgumentException());
return;
}
IpFilterRule[] newRules = new IpFilterRule[ruleStrs.size()];
for (int i = 0; i < ruleStrs.size(); i++) {
try {
String ruleStr = ruleStrs.get(i);
List<String> fields = FIELD_SPLITTER.splitToList(ruleStr);
if (!fields.isEmpty()) {
String ip = fields.get(0);
int maskLen = 32;
if (fields.size() >= 2) {
maskLen = Integer.parseInt(fields.get(1));
}
newRules[i] = new IpSubnetFilterRule(ip, maskLen, IpFilterRuleType.REJECT);
}
} catch (Exception e) {
log.error("AccessFilter updateRules() error!", e);
}
}
log.info("AccessFilter updateRules() success, newRules={}", str);
rules = newRules;
}
public boolean accept(InetSocketAddress remoteAddress) {
if (rules == null) {
return true;
}
try {
for (IpFilterRule rule : rules) {
if (rule == null) {
continue;
}
if (rule.matches(remoteAddress)) {
return rule.ruleType() == IpFilterRuleType.ACCEPT;
}
}
} catch (Exception e) {
log.error("AccessFilter accept() error!", e);
}
return true;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/NettyFuture.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/NettyFuture.java | package cn.bixin.sona.gateway.channel.support;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.NamedThreadFactory;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* @author qinwei
*/
@Slf4j
public class NettyFuture extends CompletableFuture<AccessMessage> {
public static final Timer TIME_OUT_TIMER = new HashedWheelTimer(new NamedThreadFactory("future-timeout", true), 30, TimeUnit.MILLISECONDS);
private final int id;
private final int timeout;
private final NettyChannel channel;
private Timeout timeoutCheckTask;
public NettyFuture(int id, int timeout, NettyChannel channel) {
this.id = id;
this.timeout = timeout;
this.channel = channel;
channel.getFutures().put(id, this);
}
public static NettyFuture newFuture(int id, int timeout, NettyChannel channel) {
final NettyFuture future = new NettyFuture(id, timeout, channel);
timeoutCheck(future);
return future;
}
private static void timeoutCheck(NettyFuture future) {
TimeoutCheckTask task = new TimeoutCheckTask(future.channel, future.id);
future.timeoutCheckTask = TIME_OUT_TIMER.newTimeout(task, future.timeout, TimeUnit.MILLISECONDS);
}
public static void received(AccessMessage message, NettyChannel channel) {
NettyFuture future = channel.getFutures().remove(message.getId());
if (future == null) {
return;
}
Timeout t = future.timeoutCheckTask;
t.cancel();
future.complete(message);
}
public static void exception(Throwable throwable, NettyChannel channel, int id) {
NettyFuture future = channel.getFutures().remove(id);
if (future == null) {
return;
}
Timeout t = future.timeoutCheckTask;
t.cancel();
future.completeExceptionally(throwable);
}
public void cancel(Exception e) {
exception(e, channel, id);
}
private static class TimeoutCheckTask implements TimerTask {
private final NettyChannel channel;
private final int id;
TimeoutCheckTask(NettyChannel channel, int id) {
this.channel = channel;
this.id = id;
}
@Override
public void run(Timeout timeout) throws Exception {
NettyFuture future = channel.getFutures().get(id);
if (future == null || future.isDone()) {
return;
}
exception(new TimeoutException("request future has been timeout!"), channel, id);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/RoomMessageTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/RoomMessageTask.java | package cn.bixin.sona.gateway.channel.support;
import cn.bixin.sona.common.spring.SpringApplicationContext;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.RoomChannelManager;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.CommandEnum;
import cn.bixin.sona.gateway.common.Header;
import cn.bixin.sona.gateway.common.HeaderEnum;
import cn.bixin.sona.gateway.concurrent.counter.CounterService;
import cn.bixin.sona.gateway.service.SocketNotifyService;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.Constants;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import io.netty.util.Recycler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.IntStream;
/**
* @author qinwei
* <p>
* 使用 netty 对象池 ，减少对象的创建
*/
@Slf4j
public class RoomMessageTask implements Runnable {
private static final Recycler<RoomMessageTask> RECYCLER = new Recycler<RoomMessageTask>() {
@Override
protected RoomMessageTask newObject(Handle<RoomMessageTask> handle) {
return new RoomMessageTask(handle);
}
};
private final Recycler.Handle<RoomMessageTask> handle;
private RoomChannelManager.RoomInfo roomInfo;
private JSONObject json;
private RoomMessageTask(Recycler.Handle<RoomMessageTask> handle) {
this.handle = handle;
}
public static RoomMessageTask newTask(JSONObject json, RoomChannelManager.RoomInfo roomInfo) {
RoomMessageTask task = RECYCLER.get();
task.roomInfo = roomInfo;
task.json = json;
return task;
}
private void recycle() {
roomInfo = null;
json = null;
handle.recycle(this);
}
@Override
public void run() {
String room = roomInfo.getName();
int cmd = json.getInteger(Constants.MQ_SEND_KEY_CMD);
MonitorUtils.newTransaction("CHATROOM.Message", room + ":" + cmd, () -> handTask(room, cmd), (transaction, s) -> recycle());
}
private void handTask(String room, int cmd) throws Exception {
try {
CounterService.increment(room);
JSONArray members = json.getJSONArray(Constants.MQ_REPORT_KEY_MEMBERS);
if (members == null) {
sendAllMember(room, cmd);
} else {
sendAssignMember(room, members, cmd);
}
} catch (Exception t) {
throw new RuntimeException("RoomMessageTask error, room : " + room + ", message : " + json, t);
}
}
private void sendAssignMember(String room, JSONArray members, int cmd) {
IntStream.range(0, members.size()).mapToObj(members::getString)
.filter(member -> !CollectionUtils.isEmpty(roomInfo.getChannelsByMember(member)))
.forEach(member -> sendMember(room, cmd, member, roomInfo.getChannelsByMember(member)));
}
private void sendAllMember(String room, int cmd) {
sendMember(room, cmd, null, roomInfo.getChannels());
closeRoomIfNeeded(room, cmd);
}
private void sendMember(String room, int cmd, String member, Set<NettyChannel> channels) {
AccessMessage msg = buildMessage(room, cmd, false);
Set<String> ackUids = getAckUids();
AccessMessage ackMsg = null;
if (!CollectionUtils.isEmpty(ackUids)) {
ackMsg = buildMessage(room, cmd, true);
}
boolean priority = Optional.ofNullable(json.getBoolean(Constants.MQ_REPORT_KEY_PRIORITY)).orElse(false);
//如果是高优先级消息，或者不属于高频房间，立即发送
boolean immediate = priority || !CounterService.compute(room);
for (NettyChannel channel : channels) {
//ack消息 立即发送
if (ackUids.contains(channel.getUid())) {
channel.fastSend(ackMsg, true);
} else {
channel.fastSend(msg, immediate);
}
removeChannelIfNeeded(room, cmd, member, channel);
}
}
private AccessMessage buildMessage(String room, int cmd, boolean ack) {
AccessMessage message = AccessMessageUtils.createRequest(cmd, json.getString(Constants.MQ_REPORT_KEY_DATA).getBytes(StandardCharsets.UTF_8));
JSONObject jsonObject = new JSONObject();
jsonObject.put(Constants.CHATROOM_MSG_KEY_ROOM, room);
if (ack) {
jsonObject.put(Constants.CHATROOM_MSG_KEY_ACK, 1);
}
if (CommandEnum.CHATROOM_SIGNAL.getCommand() == cmd) {
jsonObject.put(Constants.CHATROOM_MSG_KEY_SIGNAL, json.getInteger(Constants.CHATROOM_MSG_KEY_SIGNAL));
}
message.addHeader(new Header(HeaderEnum.CHATROOM, jsonObject.toJSONString()));
return message;
}
private Set<String> getAckUids() {
JSONArray ackUids = json.getJSONArray(Constants.MQ_REPORT_KEY_ACK_UIDS);
if (CollectionUtils.isEmpty(ackUids)) {
return Collections.emptySet();
}
return new HashSet<>(ackUids.toJavaList(String.class));
}
private void removeChannelIfNeeded(String room, int cmd, String member, NettyChannel channel) {
if (CommandEnum.CHATROOM_SIGNAL.getCommand() == cmd && 1 == json.getInteger(Constants.CHATROOM_MSG_KEY_SIGNAL)) {
SpringApplicationContext.getBean(SocketNotifyService.class).notifyChatRoomSession(channel, cmd, room, member);
RoomChannelManager.MANAGER_FOR_CHATROOM.removeChannel(room, channel);
}
}
private void closeRoomIfNeeded(String room, int cmd) {
if (CommandEnum.CHATROOM_SIGNAL.getCommand() == cmd && 2 == json.getInteger(Constants.CHATROOM_MSG_KEY_SIGNAL)) {
RoomChannelManager.MANAGER_FOR_CHATROOM.destroyRoom(room);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelEventTask.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/support/ChannelEventTask.java | package cn.bixin.sona.gateway.channel.support;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.handler.ChannelHandler;
import cn.bixin.sona.gateway.common.AccessMessage;
import io.netty.util.Recycler;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
*/
@Slf4j
public class ChannelEventTask implements Runnable {
private static final Recycler<ChannelEventTask> RECYCLER = new Recycler<ChannelEventTask>() {
@Override
protected ChannelEventTask newObject(Handle<ChannelEventTask> handle) {
return new ChannelEventTask(handle);
}
};
private final Recycler.Handle<ChannelEventTask> handle;
private ChannelHandler handler;
@Getter
private NettyChannel channel;
private ChannelEventState state;
private Throwable exception;
private Object message;
private ChannelEventTask(Recycler.Handle<ChannelEventTask> handle) {
this.handle = handle;
}
public static ChannelEventTask newInstance(ChannelHandler handler, NettyChannel channel, ChannelEventState state) {
return newInstance(handler, channel, state, null);
}
public static ChannelEventTask newInstance(ChannelHandler handler, NettyChannel channel, ChannelEventState state, Throwable exception) {
return newInstance(handler, channel, state, exception, null);
}
public static ChannelEventTask newInstance(ChannelHandler handler, NettyChannel channel, ChannelEventState state, Object message) {
return newInstance(handler, channel, state, null, message);
}
public static ChannelEventTask newInstance(ChannelHandler handler, NettyChannel channel, ChannelEventState state, Throwable exception, Object message) {
ChannelEventTask eventTask = RECYCLER.get();
eventTask.handler = handler;
eventTask.channel = channel;
eventTask.state = state;
eventTask.exception = exception;
eventTask.message = message;
return eventTask;
}
private void recycle() {
handler = null;
channel = null;
state = null;
exception = null;
message = null;
handle.recycle(this);
}
@Override
public void run() {
try {
//绝大数请求都是 receive ，减少判断次数
if (state == ChannelEventState.RECEIVE) {
AccessMessage msg = (AccessMessage) message;
MonitorUtils.newTransaction(MonitorUtils.CAT_IN_TRANS_TYPE, String.valueOf(msg.getCmd()), () -> handler.receive(channel, message));
} else {
switch (state) {
case SENT:
handler.send(channel, message);
break;
case CONNECT:
MonitorUtils.newTransaction(MonitorUtils.CAT_IN_TRANS_TYPE, "Active", () -> handler.connect(channel));
break;
case DISCONNECT:
MonitorUtils.newTransaction(MonitorUtils.CAT_IN_TRANS_TYPE, "Inactive", () -> handler.disconnect(channel));
break;
case CAUGHT:
handler.caught(channel, exception);
break;
default:
log.warn("unknown state: " + state + ", message is " + message);
}
}
} catch (Throwable t) {
log.error("ChannelEventTask handle " + state + " operation error, channel is " + channel, t);
} finally {
recycle();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/MercuryServerHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/MercuryServerHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.NettyFuture;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.handler.Handler;
import cn.bixin.sona.gateway.handler.MercuryRouter;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import com.alibaba.fastjson.JSON;
/**
* @author qinwei
* <p>
* 最上层的业务 ChannelHandler
*/
public class MercuryServerHandler extends ChannelHandlerDelegate {
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
AccessMessage msg = (AccessMessage) message;
if (msg.isReq()) {
if (msg.isTwoWay()) {
handRequest(channel, msg);
} else {
MercuryRouter.router(msg.getCmd()).receive(channel, msg);
}
} else {
NettyFuture.received(msg, channel);
}
super.receive(channel, message);
}
private static void handRequest(NettyChannel channel, AccessMessage msg) throws RemoteException {
Handler handler = MercuryRouter.router(msg.getCmd());
Object result;
try {
result = handler.handle(channel, msg);
} catch (RemoteException e) {
result = e.getMessage();
}
if (result == null) {
return;
}
channel.send(AccessMessageUtils.createResponse(msg.getId(), msg.getCmd(), JSON.toJSONBytes(result)));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/AbstractChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/AbstractChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.exception.RemoteException;
import org.springframework.util.Assert;
/**
* @author qinwei
*/
public abstract class AbstractChannelHandler implements ChannelHandler {
protected final ChannelHandler handler;
public AbstractChannelHandler(ChannelHandler handler) {
Assert.notNull(handler, "handler == null");
this.handler = handler;
}
@Override
public void connect(NettyChannel channel) throws RemoteException {
handler.connect(channel);
}
@Override
public void disconnect(NettyChannel channel) throws RemoteException {
handler.disconnect(channel);
}
@Override
public void send(NettyChannel channel, Object message) throws RemoteException {
handler.send(channel, message);
}
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
handler.receive(channel, message);
}
@Override
public void caught(NettyChannel channel, Throwable exception) throws RemoteException {
handler.caught(channel, exception);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.exception.RemoteException;
/**
* @author qinwei
* <p>
* 对netty 底层事件的封装，业务层根据不同的事件执行相应的处理
*/
public interface ChannelHandler {
void connect(NettyChannel channel) throws RemoteException;
void disconnect(NettyChannel channel) throws RemoteException;
void send(NettyChannel channel, Object message) throws RemoteException;
void receive(NettyChannel channel, Object message) throws RemoteException;
void caught(NettyChannel channel, Throwable exception) throws RemoteException;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/IdleChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/IdleChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.common.spring.SpringApplicationContext;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.NettyFuture;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.config.ApolloConfiguration;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.task.HandshakeTimeoutTask;
import cn.bixin.sona.gateway.task.HeartbeatTimerTask;
import cn.bixin.sona.gateway.task.ProbeIdleTimerTask;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.NamedThreadFactory;
import java.util.concurrent.TimeUnit;
/**
* @author qinwei
*/
@Slf4j
public class IdleChannelHandler extends AbstractChannelHandler {
public static final HashedWheelTimer IDLE_CHECK_TIMER = new HashedWheelTimer(new NamedThreadFactory("mercury-idleCheck", true), 1, TimeUnit.SECONDS, 128);
public static final String KEY_READ_TIMESTAMP = "READ_TIMESTAMP";
public static final String KEY_WRITE_TIMESTAMP = "WRITE_TIMESTAMP";
public static final String KEY_HAND_SHAKE = "HAND_SHAKE_TIMER";
public IdleChannelHandler(ChannelHandler handler) {
super(handler);
startIdleTask();
}
@Override
public void connect(NettyChannel channel) throws RemoteException {
setReadTimestamp(channel);
setWriteTimestamp(channel);
handler.connect(channel);
startHandshakeTask(channel);
}
@Override
public void disconnect(NettyChannel channel) throws RemoteException {
clearReadTimestamp(channel);
clearWriteTimestamp(channel);
handler.disconnect(channel);
closeTask(channel);
}
@Override
public void send(NettyChannel channel, Object message) throws RemoteException {
setWriteTimestamp(channel);
handler.send(channel, message);
}
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
setReadTimestamp(channel);
AccessMessage msg = (AccessMessage) message;
if (!msg.isHeartbeat()) {
handler.receive(channel, message);
return;
}
if (!msg.isReq()) {
NettyFuture.received(msg, channel);
return;
}
if (msg.isTwoWay()) {
channel.send(AccessMessageUtils.createHeartResponse(msg.getId()));
}
}
private static void setReadTimestamp(NettyChannel channel) {
channel.setAttribute(KEY_READ_TIMESTAMP, System.currentTimeMillis());
}
private static void setWriteTimestamp(NettyChannel channel) {
channel.setAttribute(KEY_WRITE_TIMESTAMP, System.currentTimeMillis());
}
private static void clearReadTimestamp(NettyChannel channel) {
channel.removeAttribute(KEY_READ_TIMESTAMP);
}
private static void clearWriteTimestamp(NettyChannel channel) {
channel.removeAttribute(KEY_WRITE_TIMESTAMP);
}
private static void startIdleTask() {
ApolloConfiguration apolloConfig = SpringApplicationContext.getBean(ApolloConfiguration.class);
//心跳检测
int channelIdleSeconds = apolloConfig.getChannelIdleSeconds();
HeartbeatTimerTask heartbeatTimerTask = new HeartbeatTimerTask(30 * 1000, channelIdleSeconds * 1000);
IDLE_CHECK_TIMER.newTimeout(heartbeatTimerTask, 10, TimeUnit.SECONDS);
//消息探测
int probeIdleSeconds = apolloConfig.getProbeIdleSeconds();
ProbeIdleTimerTask probeIdleTimerTask = new ProbeIdleTimerTask(30 * 1000, probeIdleSeconds * 1000);
IDLE_CHECK_TIMER.newTimeout(probeIdleTimerTask, 10, TimeUnit.SECONDS);
}
private static void startHandshakeTask(NettyChannel channel) {
//握手认证
ApolloConfiguration apolloConfig = SpringApplicationContext.getBean(ApolloConfiguration.class);
int handshakeWaitSeconds = apolloConfig.getHandshakeWaitSeconds();
if (handshakeWaitSeconds > 0) {
HandshakeTimeoutTask handshakeTimeoutTask = new HandshakeTimeoutTask(channel);
channel.setAttribute(KEY_HAND_SHAKE, IDLE_CHECK_TIMER.newTimeout(handshakeTimeoutTask, handshakeWaitSeconds, TimeUnit.SECONDS));
}
}
private static void closeTask(NettyChannel channel) {
Timeout timeout = channel.removeAttribute(KEY_HAND_SHAKE, Timeout.class);
if (timeout != null) {
timeout.cancel();
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/AccessChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/AccessChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.AccessFilter;
import cn.bixin.sona.gateway.exception.RemoteException;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
* <p>
* Access 权限校验
*/
@Slf4j
public class AccessChannelHandler extends AbstractChannelHandler {
public AccessChannelHandler(ChannelHandler handler) {
super(handler);
}
@Override
public void connect(NettyChannel channel) throws RemoteException {
if (!AccessFilter.INSTANCE.accept(channel.getRemoteAddress())) {
log.info("AccessDeny, remoteAddress={}", channel.getRemoteAddress());
MonitorUtils.logEvent(MonitorUtils.MERCURY_ACCESS_DENY, channel.getRemoteAddress().getAddress().getHostAddress());
channel.close();
return;
}
handler.connect(channel);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/DispatchChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/DispatchChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.ChannelEventState;
import cn.bixin.sona.gateway.channel.support.ChannelEventTask;
import cn.bixin.sona.gateway.concurrent.OrderedChannelExecutor;
import cn.bixin.sona.gateway.exception.RemoteException;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @author qinwei
* <p>
* handler分发，通过线程池并发执行
*/
@Slf4j
public class DispatchChannelHandler extends AbstractChannelHandler {
public static final ThreadPoolExecutor SHARED_EXECUTOR = new OrderedChannelExecutor(64, "mercury-handler-");
public DispatchChannelHandler(ChannelHandler handler) {
super(handler);
}
@Override
public void connect(NettyChannel channel) throws RemoteException {
try {
SHARED_EXECUTOR.execute(ChannelEventTask.newInstance(handler, channel, ChannelEventState.CONNECT));
} catch (Throwable t) {
throw new RemoteException("connect event error , channel : " + channel + ".", t);
}
}
@Override
public void disconnect(NettyChannel channel) throws RemoteException {
try {
SHARED_EXECUTOR.execute(ChannelEventTask.newInstance(handler, channel, ChannelEventState.DISCONNECT));
} catch (Throwable t) {
throw new RemoteException("disconnect event error , channel : " + channel + ".", t);
}
}
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
try {
SHARED_EXECUTOR.execute(ChannelEventTask.newInstance(handler, channel, ChannelEventState.RECEIVE, message));
} catch (Throwable t) {
throw new RemoteException("receive event error , channel : " + channel + ".", t, message);
}
}
@Override
public void send(NettyChannel channel, Object message) throws RemoteException {
try {
SHARED_EXECUTOR.execute(ChannelEventTask.newInstance(handler, channel, ChannelEventState.SENT, message));
} catch (Throwable t) {
throw new RemoteException("send event error , channel : " + channel + ".", t);
}
}
@Override
public void caught(NettyChannel channel, Throwable exception) throws RemoteException {
try {
SHARED_EXECUTOR.execute(ChannelEventTask.newInstance(handler, channel, ChannelEventState.CAUGHT, exception));
} catch (Throwable t) {
throw new RemoteException("caught event error , channel : " + channel + ".", t);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/CatReportChannelHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/CatReportChannelHandler.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
* <p>
* cat 数据上报
*/
@Slf4j
public class CatReportChannelHandler extends AbstractChannelHandler {
public CatReportChannelHandler(ChannelHandler handler) {
super(handler);
}
@Override
public void send(NettyChannel channel, Object message) throws RemoteException {
if (!channel.isConnected()) {
log.warn("ChannelNotActiveInHandler, channelId={}, remoteAddress={}, cmd={}",
channel.getChannelId(), channel.getRemoteAddress(), message instanceof AccessMessage ? ((AccessMessage) message).getCmd() : message.getClass().getSimpleName());
MonitorUtils.logCatEventWithMessage(MonitorUtils.SEND_MESSAGE_PROBLEM, "ChannelNotActiveInHandler", message, false);
return;
}
handler.send(channel, message);
}
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
if (!(message instanceof AccessMessage)) {
MonitorUtils.logEvent(MonitorUtils.RECEIVE_MESSAGE_PROBLEM, channel.getChannelId());
log.error("Unsupport message :{} , remoteAddress={}", JSON.toJSONString(message), channel.getRemoteAddress());
return;
}
AccessMessage msg = (AccessMessage) message;
String name = msg.isHeartbeat() ? "HB" : String.valueOf(msg.getCmd());
AccessMessageUtils.logInboundMsgSize(msg, name);
handler.receive(channel, message);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandlerWrap.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandlerWrap.java | package cn.bixin.sona.gateway.channel.handler;
/**
* @author qinwei
* <p>
* ChannelHandler 包装类
*/
public class ChannelHandlerWrap {
private static final ChannelHandlerWrap INSTANCE = new ChannelHandlerWrap();
private ChannelHandlerWrap() {
}
private static ChannelHandlerWrap getInstance() {
return INSTANCE;
}
public static ChannelHandler wrap(ChannelHandler handler) {
return getInstance().wrapHandler(handler);
}
private ChannelHandler wrapHandler(ChannelHandler handler) {
return new AccessChannelHandler(new CatReportChannelHandler(new IdleChannelHandler(new DispatchChannelHandler(handler))));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandlerDelegate.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/channel/handler/ChannelHandlerDelegate.java | package cn.bixin.sona.gateway.channel.handler;
import cn.bixin.sona.common.spring.SpringApplicationContext;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.RoomChannelManager;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.common.ChannelTypeEnum;
import cn.bixin.sona.gateway.concurrent.counter.SystemClock;
import cn.bixin.sona.gateway.exception.AccessMessageDecodeException;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.service.SocketNotifyService;
import cn.bixin.sona.gateway.util.EventRecordLog;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.SendResult;
import org.springframework.util.CollectionUtils;
import java.net.InetSocketAddress;
import java.nio.channels.ClosedChannelException;
import java.util.Set;
import java.util.regex.Pattern;
/**
* @author qinwei
*/
@Slf4j
public class ChannelHandlerDelegate implements ChannelHandler {
private static final Pattern IGNORABLE_ERROR_MESSAGE = Pattern.compile(
"^.*(?:connection.*(?:reset|closed|abort|broken)|broken.*pipe).*$", Pattern.CASE_INSENSITIVE);
@Override
public void connect(NettyChannel channel) throws RemoteException {
}
@Override
public void disconnect(NettyChannel channel) throws RemoteException {
ChannelAttrs attrs = channel.getAttrsIfExists();
if (attrs == null) {
return;
}
double duration = (SystemClock.currentTimeMillis() - attrs.getCreateTime()) / 1000.0;
int channelType = attrs.getChannelType();
if (ChannelTypeEnum.CHATROOM.getType() == channelType) {
Set<String> rooms = attrs.getRooms();
if (!CollectionUtils.isEmpty(rooms)) {
for (String roomName : rooms) {
RoomChannelManager.MANAGER_FOR_CHATROOM.removeChannel(roomName, channel);
}
}
}
if (channel.isAuth()) {
SendResult result = SpringApplicationContext.getBean(SocketNotifyService.class).processDisConnect(channel);
StringBuilder msg = new StringBuilder().append(duration).append("s.");
if (result != null) {
msg.append(result.getSendStatus()).append('=').append(result.getMsgId());
}
EventRecordLog.logEvent(channel, "TTL", msg.toString());
} else {
log.info("inactive channel, address={}, type={}, duration={} s", channel.getRemoteAddress(), channelType, duration);
}
}
@Override
public void send(NettyChannel channel, Object message) throws RemoteException {
}
@Override
public void receive(NettyChannel channel, Object message) throws RemoteException {
}
@Override
public void caught(NettyChannel channel, Throwable exception) throws RemoteException {
InetSocketAddress remoteAddress = channel.getRemoteAddress();
String message = exception.getMessage();
// for epoll module
if (ignoreException(message)) {
if (message.contains("Connection reset by peer")) {
MonitorUtils.logCatEventWithChannelAttrs(MonitorUtils.CONNECTION_RESET_BY_PEER, "", channel, true);
return;
}
if (message.contains("Broken pipe")) {
log.info("IOException.BrokenPipe, remoteAddress={}", remoteAddress);
MonitorUtils.logCatEventWithChannelAttrs(MonitorUtils.SAFE_EXCEPTION, "BrokenPipe", channel, true, true);
}
return;
}
if (exception instanceof AccessMessageDecodeException || exception.getCause() instanceof AccessMessageDecodeException) {
Throwable e = exception;
while (e != null) {
e = e.getCause();
}
log.error("AccessMessageDecodeException, remoteAddress = {}", remoteAddress, exception);
return;
}
if (exception instanceof RemoteException) {
RemoteException ex = (RemoteException) exception;
log.warn("RemoteException , remoteAddress = {} , msg = {}", remoteAddress, ex.getMsgBody(), ex);
return;
}
if (exception instanceof ClosedChannelException) {
log.warn("channel close ! remoteAddress= {}", remoteAddress);
return;
}
log.error("exceptionCaught, remoteAddress=" + remoteAddress, exception);
}
private static boolean ignoreException(String message) {
return message != null && IGNORABLE_ERROR_MESSAGE.matcher(message).matches();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/AbstractHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/AbstractHandler.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
/**
* @author qinwei
*/
public abstract class AbstractHandler implements Handler {
@Override
public Object handle(NettyChannel channel, AccessMessage message) throws RemoteException {
// 这里可以加一些通用处理
return doHandle(channel, message);
}
protected abstract Object doHandle(NettyChannel channel, AccessMessage message) throws RemoteException;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/ClientPushHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/ClientPushHandler.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.CommandEnum;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.util.Constants;
import cn.bixin.sona.gateway.util.EventRecordLog;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import static cn.bixin.sona.gateway.msg.AccessResponse.*;
/**
* @author qinwei
* <p>
* 处理client端上报消息
*/
@Service("clientPush")
public class ClientPushHandler extends AbstractHandler {
public static final String CLIENT_PUSH_EVENT = "Client push";
@Override
protected Object doHandle(NettyChannel channel, AccessMessage message) throws RemoteException {
byte[] body = message.getBody();
if (body == null || body.length == 0) {
EventRecordLog.logEvent(channel, CLIENT_PUSH_EVENT, message, "Empty body");
MonitorUtils.logEvent(MonitorUtils.CLIENT_PUSH_PROBLEM, "EmptyBody");
return EMPTY_BODY;
}
if (CommandEnum.CLIENT_PUSH.getCommand() != message.getCmd()) {
EventRecordLog.logEvent(channel, CLIENT_PUSH_EVENT, message, "Unknown cmd");
MonitorUtils.logEvent(MonitorUtils.CLIENT_PUSH_PROBLEM, "UnknownCmd");
return null;
}
String bodyData = new String(body, StandardCharsets.UTF_8);
EventRecordLog.logEvent(channel, CLIENT_PUSH_EVENT, message, bodyData);
JSONObject jsonObject = JSON.parseObject(bodyData);
String type = Optional.ofNullable(jsonObject.getString(Constants.PUSH_MSG_KEY_TYPE)).orElse("");
JSONObject data = jsonObject.getJSONObject(Constants.PUSH_MSG_KEY_DATA);
switch (type) {
case Constants.PUSH_MSG_TYPE_APPSTATE:
if (data == null || !StringUtils.hasText(data.getString(Constants.APPSTATE_KEY_FOREGROUND))) {
MonitorUtils.logEvent(MonitorUtils.CLIENT_PUSH_PROBLEM, "InvalidData");
return INVALID_DATA;
}
channel.getAttrs().setForeground(data.getBooleanValue(Constants.APPSTATE_KEY_FOREGROUND));
return SUCCESS;
default:
MonitorUtils.logEvent(MonitorUtils.CLIENT_PUSH_PROBLEM, "UnknownType");
return null;
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/MercuryRouter.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/MercuryRouter.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.exception.RemoteException;
import io.netty.util.internal.PlatformDependent;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.ClassUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
/**
* @author qinwei
*/
@Slf4j
@Component
public class MercuryRouter implements ApplicationListener<ContextRefreshedEvent> {
private static final Map<Integer, String> HANDLES = new HashMap<>();
public static final String DIR = "META-INF/mercury/";
private static ApplicationContext applicationContext;
private static final Map<String, Handler> HANDLER_WRAPPERS = PlatformDependent.newConcurrentHashMap();
public static Handler router(int cmd) throws RemoteException {
String name = HANDLES.get(cmd);
if (!StringUtils.hasText(name)) {
throw new RemoteException("MercuryRouter failure , unable to find the cmd " + cmd + " !");
}
return HANDLER_WRAPPERS.computeIfAbsent(name, MercuryRouter::wrapHandler);
}
private static HandlerWrapper wrapHandler(String name) {
return new HandlerWrapper(name, applicationContext.getBean(name, Handler.class));
}
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
applicationContext = event.getApplicationContext();
loadDirectory(Handler.class);
}
private void loadDirectory(Class<?> clazz) {
String fileName = DIR + clazz.getName();
try {
Enumeration<URL> urls = ClassUtils.getClassLoader().getResources(fileName);
if (urls != null) {
while (urls.hasMoreElements()) {
loadResource(clazz, urls.nextElement());
}
}
} catch (Throwable t) {
log.error("Exception occurred when loading config (interface: " + clazz.getName() + ", description file: " + fileName + ").", t);
}
}
private void loadResource(Class<?> clazz, URL url) {
try {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))) {
String line;
while ((line = reader.readLine()) != null) {
final int ci = line.indexOf('#');
if (ci >= 0) {
line = line.substring(0, ci);
}
line = line.trim();
if (line.length() > 0) {
try {
String name = null;
int i = line.indexOf('=');
if (i > 0) {
name = line.substring(0, i).trim();
line = line.substring(i + 1).trim();
}
if (name != null && line.length() > 0) {
String[] names = name.split(",");
for (String s : names) {
HANDLES.put(Integer.parseInt(s), line);
}
}
} catch (Throwable t) {
log.error("Failed to load config (interface: " + clazz.getName() + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
}
}
}
}
} catch (Throwable t) {
log.error("Exception occurred when loading config (interface: " + clazz.getName() + ", class file: " + url + ") in " + url, t);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/LoginAuthHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/LoginAuthHandler.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.msg.AccessResponse;
import cn.bixin.sona.gateway.msg.HandShakeBody;
import cn.bixin.sona.gateway.service.SocketNotifyService;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.EventRecordLog;
import com.alibaba.fastjson.JSON;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
/**
* @author qinwei
* <p>
* 登录认证
*/
@Service("loginAuth")
public class LoginAuthHandler extends AbstractHandler {
public static final String LOGIN_EVENT = "Login";
@Resource
private SocketNotifyService socketNotifyService;
@Override
protected Object doHandle(NettyChannel channel, AccessMessage message) throws RemoteException {
String bodyData = new String(message.getBody(), StandardCharsets.UTF_8);
HandShakeBody handShake = JSON.parseObject(bodyData, HandShakeBody.class);
String deviceId = handShake.getD();
if (!StringUtils.hasText(deviceId)) {
channel.send(AccessMessageUtils.createResponse(message.getId(), message.getCmd(), JSON.toJSONBytes(AccessResponse.ACCESS_FAIL)), false, true);
EventRecordLog.logEvent(channel, LOGIN_EVENT, message, "EmptyDeviceId");
MonitorUtils.logEvent(MonitorUtils.LOGIN_PROBLEM, "EmptyDeviceId");
return null;
}
ChannelAttrs attrs = channel.getAttrs();
attrs.setClientProtoVer(message.getVersion());
attrs.setChannelType(handShake.getT());
attrs.setDeviceId(deviceId);
attrs.setPlatform(handShake.getP());
attrs.setSysVer(handShake.getSv());
attrs.setModel(handShake.getM());
attrs.setUid(handShake.getU());
attrs.setForeground(handShake.getB() == 0);
if (!channel.markAuth()) {
EventRecordLog.logEvent(channel, LOGIN_EVENT, message, "Repeated handshake");
return AccessResponse.SUCCESS;
}
NettyChannel.addChannelTypeCount(channel);
socketNotifyService.processConnect(channel);
EventRecordLog.logEvent(channel, LOGIN_EVENT, message, bodyData);
MonitorUtils.logCatEventWithChannelAttrs(MonitorUtils.LOGIN, "", channel, true);
return AccessResponse.SUCCESS;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/Handler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/Handler.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
/**
* @author qinwei
* <p>
* 具体的业务处理，所有的业务处理类统一实现此接口
*/
public interface Handler {
Object handle(NettyChannel channel, AccessMessage message) throws RemoteException;
default void receive(NettyChannel channel, AccessMessage message) throws RemoteException {
handle(channel, message);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/HandlerWrapper.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/HandlerWrapper.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.interceptor.HandlerInterceptorChain;
import lombok.extern.slf4j.Slf4j;
/**
* @author qinwei
*/
@Slf4j
public class HandlerWrapper implements Handler {
private final Handler handler;
private final HandlerInterceptorChain chain;
public HandlerWrapper(String name, Handler handler) {
this.handler = handler;
this.chain = HandlerInterceptorChain.getHandlerInterceptorChain(name);
}
@Override
public Object handle(NettyChannel channel, AccessMessage message) throws RemoteException {
if (handler == null) {
return null;
}
try {
if (!chain.applyPreHandle(channel, message)) {
return null;
}
Object result = handler.handle(channel, message);
chain.applyPostHandle(channel, message);
chain.applyAfterHandle(channel, message, null);
return result;
} catch (Exception e) {
chain.applyAfterHandle(channel, message, e);
throw new RemoteException("HandlerInterceptorChain execute failure !", e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/ChatRoomHandler.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/handler/ChatRoomHandler.java | package cn.bixin.sona.gateway.handler;
import cn.bixin.sona.api.im.MessageCallbackService;
import cn.bixin.sona.api.im.enums.MsgFormatEnum;
import cn.bixin.sona.api.im.request.ChatroomMessageRequest;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.channel.RoomChannelManager;
import cn.bixin.sona.gateway.channel.support.ChannelAttrs;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.CommandEnum;
import cn.bixin.sona.gateway.common.HeaderEnum;
import cn.bixin.sona.gateway.config.ApolloConfiguration;
import cn.bixin.sona.gateway.exception.RemoteException;
import cn.bixin.sona.gateway.msg.AccessResponse;
import cn.bixin.sona.gateway.service.SocketNotifyService;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.Constants;
import cn.bixin.sona.gateway.util.EventRecordLog;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;
import java.util.Set;
import static cn.bixin.sona.gateway.msg.AccessResponse.*;
/**
* @author qinwei
* <p>
* 房间处理
*/
@Service("chatRoom")
public class ChatRoomHandler extends AbstractHandler {
public static final String CHATROOM_EVENT = "ChatRoom";
@Resource
private ApolloConfiguration apolloConfiguration;
@Resource
private SocketNotifyService socketNotifyService;
@DubboReference
private MessageCallbackService messageCallbackService;
@Override
protected Object doHandle(NettyChannel channel, AccessMessage message) throws RemoteException {
ChannelAttrs attrs = channel.getAttrs();
Set<String> lastRooms = attrs.getRooms();
String header = AccessMessageUtils.extractHeaderData(message, HeaderEnum.CHATROOM);
JSONObject headerObj = JSON.parseObject(header);
if (headerObj == null) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Room header not found : " + lastRooms);
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "RoomHeaderNotFound");
return ROOM_HEADER_NOT_FOUND;
}
String room = headerObj.getString(Constants.CHATROOM_MSG_KEY_ROOM);
if (!StringUtils.hasText(room)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Invalid room name");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "InvalidRoomName");
return INVALID_ROOM_NAME;
}
int cmd = message.getCmd();
if (CommandEnum.CHATROOM_SEND.getCommand() == cmd) {
return handMessageSend(channel, message, room);
} else if (CommandEnum.CHATROOM_JOIN.getCommand() == cmd) {
return handleJoin(channel, message, headerObj, room);
} else if (CommandEnum.CHATROOM_LEAVE.getCommand() == cmd) {
return handleLeave(channel, message, room);
} else {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Unknown cmd");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "UnknownCmd");
return null;
}
}
private AccessResponse handMessageSend(NettyChannel channel, AccessMessage message, String room) {
ChannelAttrs attrs = channel.getAttrs();
Set<String> lastRooms = attrs.getRooms();
if (lastRooms == null || !lastRooms.contains(room)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Not in room when send : " + lastRooms);
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "NotInRoomWhenSend");
return NOT_IN_ROOM_WHEN_SEND;
}
String uid = attrs.getUid();
if (!StringUtils.hasText(uid)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Empty uid");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "EmptyUid");
return EMPTY_UID;
}
if (attrs.isVisitor()) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Visitor send");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "VisitorSend");
return VISITOR_SEND;
}
String body = new String(message.getBody(), StandardCharsets.UTF_8);
if (apolloConfiguration.isRoomMessageAsync()) {
socketNotifyService.notifyChatRoomMessage(channel, uid, room, body);
return SUCCESS;
}
ChatroomMessageRequest request = JSON.parseObject(body, ChatroomMessageRequest.class);
if (MsgFormatEnum.ACK.getCode() == request.getMsgFormat()) {
socketNotifyService.notifyChatRoomMessage(channel, uid, room, body);
return SUCCESS;
}
Response<Boolean> response = messageCallbackService.sendChatroomMessage(request);
if (response.isSuccess() && response.getResult()) {
return SUCCESS;
}
return new AccessResponse(Integer.parseInt(response.getCode()), response.getMsg());
}
private AccessResponse handleJoin(NettyChannel channel, AccessMessage message, JSONObject headerObj, String room) {
ChannelAttrs attrs = channel.getAttrs();
Set<String> lastRooms = attrs.getRooms();
String uid = headerObj.getString(Constants.CHATROOM_MSG_KEY_UID);
if (!StringUtils.hasText(uid)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Invalid uid");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "InvalidUid");
return INVALID_UID;
}
if (!uid.equals(attrs.getUid()) && !CollectionUtils.isEmpty(lastRooms)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "uid changed when in room : " + lastRooms);
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "UidChangedWhenInRoom");
return new AccessResponse(8010, "you should leave room [" + lastRooms + "] first before changing to another user!");
}
String identity = headerObj.getString(Constants.CHATROOM_MSG_KEY_IDENTITY);
attrs.setVisitor("0".equals(identity));
attrs.setUid(uid);
RoomChannelManager.MANAGER_FOR_CHATROOM.addChannel(room, channel, uid);
socketNotifyService.notifyChatRoomSession(channel, message.getCmd(), room, uid);
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, room);
return SUCCESS;
}
private AccessResponse handleLeave(NettyChannel channel, AccessMessage message, String room) {
ChannelAttrs attrs = channel.getAttrs();
Set<String> lastRooms = attrs.getRooms();
if (lastRooms == null || !lastRooms.contains(room)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Not in room when leave : " + lastRooms);
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "NotInRoomWhenLeave");
}
RoomChannelManager.MANAGER_FOR_CHATROOM.removeChannel(room, channel);
String uid = attrs.getUid();
if (!StringUtils.hasText(uid)) {
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, "Empty uid");
MonitorUtils.logEvent(MonitorUtils.CHATROOM_PROBLEM, "EmptyUid");
return EMPTY_UID;
}
socketNotifyService.notifyChatRoomSession(channel, message.getCmd(), room, attrs.getUid());
EventRecordLog.logEvent(channel, CHATROOM_EVENT, message, room);
return SUCCESS;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/msg/AccessResponse.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/msg/AccessResponse.java | package cn.bixin.sona.gateway.msg;
import lombok.Getter;
import lombok.Setter;
/**
* @author qinwei
*/
@Getter
@Setter
public class AccessResponse {
public static final AccessResponse SUCCESS = new AccessResponse(0, "success");
public static final AccessResponse ROOM_HEADER_NOT_FOUND = new AccessResponse(8010, "Room header not found");
public static final AccessResponse INVALID_ROOM_NAME = new AccessResponse(8010, "Invalid room name");
public static final AccessResponse NOT_IN_ROOM_WHEN_SEND = new AccessResponse(8010, "Not in room when send");
public static final AccessResponse EMPTY_UID = new AccessResponse(8010, "Empty uid");
public static final AccessResponse VISITOR_SEND = new AccessResponse(8010, "Visitor can't send message");
public static final AccessResponse INVALID_UID = new AccessResponse(8010, "Invalid uid");
public static final AccessResponse INVALID_DATA = new AccessResponse(8010, "Invalid data");
public static final AccessResponse EMPTY_BODY = new AccessResponse(8010, "Empty body");
public static final AccessResponse ACCESS_FAIL = new AccessResponse(404, "Access fail,error param");
/**
* 状态码 0：成功 其他：失败
*/
private int c;
/**
* 响应数据
*/
private String d;
public AccessResponse() {
}
public AccessResponse(int c, String d) {
this.c = c;
this.d = d;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/msg/HandShakeBody.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/msg/HandShakeBody.java | package cn.bixin.sona.gateway.msg;
import lombok.Getter;
import lombok.Setter;
/**
* 握手消息body
*
* @author qinwei
*/
@Getter
@Setter
public class HandShakeBody {
/**
* 设备id
*/
private String d;
/**
* 平台 1: iOS；2: Android; 3: PC
*/
private int p;
/**
* 系统版本号
*/
private String sv;
/**
* 用户ID
*/
private String u;
/**
* model
*/
private String m;
/**
* type，通道类型。
*
* @see cn.bixin.sona.gateway.common.ChannelTypeEnum
*/
private int t;
/**
* app是否在后台 0: 前台, 1: 后台
*/
private int b;
public HandShakeBody() {
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/ChatRoomMessageListener.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/ChatRoomMessageListener.java | package cn.bixin.sona.gateway.listener;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.RoomChannelManager;
import cn.bixin.sona.gateway.channel.support.RoomMessageTask;
import cn.bixin.sona.gateway.concurrent.FastThreadPool;
import cn.bixin.sona.gateway.util.Constants;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* @author qinwei
*/
@Slf4j
@Component
@RocketMQMessageListener(topic = "TOPIC_CHATROOM_MESSAGE_SEND", consumerGroup = "CHATROOM_MESSAGE-MERCURY_GROUP", messageModel = MessageModel.BROADCASTING)
public class ChatRoomMessageListener implements RocketMQListener<MessageExt> {
private final FastThreadPool threadPool = new FastThreadPool("chatroom", 18);
@Override
public void onMessage(MessageExt messageExt) {
MonitorUtils.logBatchEvent("RocketMQListener", getClass().getSimpleName(), 1, 0);
if (ObjectUtils.isEmpty(messageExt.getBody())) {
log.warn("ChatRoomMessageListener.onMessage, msg empty, msg={}", JSON.toJSONString(messageExt));
return;
}
String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);
try {
JSONObject json = JSON.parseObject(body);
boolean global = Boolean.TRUE.equals(json.getBoolean(Constants.MQ_REPORT_KEY_GLOBAL));
String roomVal = json.getString(Constants.MQ_REPORT_KEY_ROOM);
String[] roomList = StringUtils.hasText(roomVal) ? new String[]{roomVal} : json.getObject(Constants.MQ_REPORT_KEY_ROOMS, String[].class);
if (!global && ObjectUtils.isEmpty(roomList)) {
log.warn("ChatRoomMessageListener.onMessage fail, msgId={}, body={}", messageExt.getMsgId(), body);
MonitorUtils.logEvent(MonitorUtils.MQ_LISTENER_PROBLEM, "RequiredParamNotFound");
return;
}
asyncHandle(json, global, roomList);
} catch (Exception e) {
log.error("ChatRoomMessageListener.onMessage fail, msg: {}", body, e);
}
}
public void asyncHandle(JSONObject json, boolean global, String[] roomList) {
RoomMessageTask[] tasks;
if (global) {
tasks = RoomChannelManager.MANAGER_FOR_CHATROOM.getAllRoomInfos().stream().map(roomInfo -> RoomMessageTask.newTask(json, roomInfo)).toArray(RoomMessageTask[]::new);
} else {
tasks = Arrays.stream(roomList).map(RoomChannelManager.MANAGER_FOR_CHATROOM::getRoomInfo).filter(Objects::nonNull).map(roomInfo -> RoomMessageTask.newTask(json, roomInfo)).toArray(RoomMessageTask[]::new);
}
threadPool.submit(tasks, 0, tasks.length);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/GroupMessageListener.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/GroupMessageListener.java | package cn.bixin.sona.gateway.listener;
import cn.bixin.sona.gateway.cat.MonitorUtils;
import cn.bixin.sona.gateway.channel.NettyChannel;
import cn.bixin.sona.gateway.common.AccessMessage;
import cn.bixin.sona.gateway.common.Header;
import cn.bixin.sona.gateway.common.HeaderEnum;
import cn.bixin.sona.gateway.util.AccessMessageUtils;
import cn.bixin.sona.gateway.util.Constants;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* @author qinwei
*/
@Slf4j
@Component
@RocketMQMessageListener(topic = "TOPIC_GROUP_MESSAGE_SEND", consumerGroup = "GROUP_MESSAGE-MERCURY_GROUP", messageModel = MessageModel.BROADCASTING)
public class GroupMessageListener implements RocketMQListener<MessageExt> {
@Override
public void onMessage(MessageExt messageExt) {
MonitorUtils.logBatchEvent("RocketMQListener", getClass().getSimpleName(), 1, 0);
if (ObjectUtils.isEmpty(messageExt.getBody())) {
log.warn("GroupMessageListener.onMessage, msg empty, msg={}", JSON.toJSONString(messageExt));
return;
}
String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);
try {
JSONObject json = JSON.parseObject(body);
String[] channels = json.getObject("channels", String[].class);
if (channels == null || channels.length == 0) {
return;
}
int cmd = json.getInteger(Constants.MQ_SEND_KEY_CMD);
AccessMessage message = AccessMessageUtils.createRequest(cmd, json.getString(Constants.MQ_REPORT_KEY_DATA).getBytes(StandardCharsets.UTF_8));
JSONObject jsonObject = new JSONObject();
jsonObject.put(Constants.CHATROOM_MSG_KEY_ROOM, json.getString(Constants.MQ_REPORT_KEY_ROOM));
message.addHeader(new Header(HeaderEnum.CHATROOM, jsonObject.toJSONString()));
Arrays.stream(channels)
.map(NettyChannel::getChannel)
.filter(Objects::nonNull)
.forEach(channel -> channel.fastSend(message, true));
} catch (Exception e) {
log.error("GroupMessageListener.onMessage fail, msg: {}", body, e);
}
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/BaseRocketMqListener.java | sona-gateway/src/main/java/cn/bixin/sona/gateway/listener/BaseRocketMqListener.java | package cn.bixin.sona.gateway.listener;
import cn.bixin.sona.gateway.util.NetUtil;
import com.ctrip.framework.apollo.ConfigService;
import com.dianping.cat.Cat;
import com.dianping.cat.message.Transaction;
import com.google.common.base.Joiner;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.*;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import java.util.List;
/**
* @author qinwei
*/
@Slf4j
public abstract class BaseRocketMqListener {
protected DefaultMQPushConsumer consumer;
/**
* 处理数据
*
* @param messageExt
*/
protected abstract void handleMessage(MessageExt messageExt);
protected DefaultMQPushConsumer initConsumer(String topic, ConsumeMode consumeMode) {
String tag = getTag(NetUtil.LOCAL_IP_ADDR);
String groupName = Joiner.on("_").join(topic, tag, "group");
return initConsumer(topic, tag, groupName, consumeMode);
}
/**
* 初始化消费者
*
* @param topic
* @param tag
* @param groupName
* @return
*/
protected DefaultMQPushConsumer initConsumer(String topic, String tag, String groupName, ConsumeMode consumeMode) {
log.info("initConsumer(), topic={}, tag={}, groupName={}, consumeMode={}", topic, tag, groupName, consumeMode);
consumer = new DefaultMQPushConsumer();
consumer.setNamesrvAddr(ConfigService.getAppConfig().getProperty("rocketmq.name-server", ""));
consumer.setConsumerGroup(groupName);
consumer.setInstanceName(groupName);
try {
consumer.subscribe(topic, tag);
log.info("topic of {} is listening and waiting mq start...", topic);
} catch (MQClientException e) {
log.error("{} rocketMq subscribe fail.[topic={}},Error={}", getClass().getSimpleName(), topic, e.getErrorMessage());
return null;
}
if (consumeMode == ConsumeMode.CONCURRENTLY) {
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgList, ConsumeConcurrentlyContext context) {
for (MessageExt messageExt : msgList) {
Transaction transaction = Cat.newTransaction("RocketMQConsume", messageExt.getTopic());
try {
transaction.addData("msgId", messageExt.getMsgId());
handleMessage(messageExt);
transaction.setSuccessStatus();
} catch (Exception e) {
transaction.setStatus(e);
log.error("handle message failed from MQ", e);
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
} finally {
transaction.complete();
}
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
} else if (consumeMode == ConsumeMode.ORDERLY) {
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgList, ConsumeOrderlyContext context) {
for (MessageExt messageExt : msgList) {
Transaction transaction = Cat.newTransaction("RocketMQConsume", messageExt.getTopic());
try {
transaction.addData("msgId", messageExt.getMsgId());
handleMessage(messageExt);
transaction.setSuccessStatus();
} catch (Exception e) {
transaction.setStatus(e);
log.error("handle message failed from MQ", e);
return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
} finally {
transaction.complete();
}
}
return ConsumeOrderlyStatus.SUCCESS;
}
});
}
try {
consumer.start();
} catch (MQClientException e) {
log.error("mq consumer start error!", e);
}
return consumer;
}
/**
* 生成指定tag
*
* @param ip
* @return
*/
protected String getTag(String ip) {
String ipStr = StringUtils.replace(ip, ".", "-");
return Joiner.on("-").join("tag", ipStr);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/test/java/cn/bixin/sona/console/SonaConsoleApplicationTests.java | sona-console/src/test/java/cn/bixin/sona/console/SonaConsoleApplicationTests.java | package cn.bixin.sona.console;
import cn.bixin.sona.console.domain.es.MercuryEventLog;
import cn.bixin.sona.console.domain.es.MercuryReportLog;
import cn.bixin.sona.console.domain.es.RoomImMsgLog;
import cn.bixin.sona.console.domain.req.MercuryEventLogQuery;
import cn.bixin.sona.console.domain.req.StreamQueryRequest;
import cn.bixin.sona.console.facade.StreamServiceFacade;
import cn.bixin.sona.console.manager.StreamManager;
import cn.bixin.sona.console.mapper.ChatroomMapper;
import cn.bixin.sona.console.repository.MercuryEventLogRepository;
import cn.bixin.sona.console.repository.MercuryReportLogRepository;
import cn.bixin.sona.console.repository.RoomImMsgLogRepository;
import cn.bixin.sona.console.service.MercuryEventLogService;
import com.alibaba.fastjson.JSON;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
@RunWith(SpringRunner.class)
@SpringBootTest
class SonaConsoleApplicationTests {
@Resource
private ChatroomMapper chatroomMapper;
@Resource
private MercuryEventLogService mercuryEventLogService;
@Resource
private MercuryEventLogRepository mercuryEventLogRepository;
@Resource
private MercuryReportLogRepository mercuryReportLogRepository;
@Resource
private RoomImMsgLogRepository roomImMsgLogRepository;
@Resource
private StreamManager streamManager;
@Resource
private StreamServiceFacade facade;
@Test
void contextLoads() {
/* mercuryEventLogRepository.deleteAll();
mercuryReportLogRepository.deleteAll();
roomImMsgLogRepository.deleteAll();*/
facade.switchAudioSupplierRoom(4069035967902148864L, 5);
}
@Test
void selectByPrimaryKey() {
chatroomMapper.selectByPrimaryKey(2L);
}
@Test
void test00(){
MercuryEventLog mercuryEventLog = new MercuryEventLog();
mercuryEventLog.setUid("2013123");
mercuryEventLog.setServer("");
mercuryEventLog.setAddr("");
mercuryEventLog.setType("");
mercuryEventLog.setDevice("");
mercuryEventLog.setEvent("");
mercuryEventLog.setContent("你好 hello world");
mercuryEventLog.setCmd("1");
mercuryEventLog.setHeader("");
mercuryEventLog.setSendTime(System.currentTimeMillis());
mercuryEventLogService.save(mercuryEventLog);
MercuryReportLog mercuryReportLog = new MercuryReportLog();
mercuryReportLog.setSendTime(System.currentTimeMillis());
mercuryReportLog.setCommon("");
mercuryReportLog.setDesc("");
mercuryReportLog.setDetails("");
mercuryReportLog.setIp("");
mercuryReportLog.setModel("");
mercuryReportLog.setNetwork("");
mercuryReportLog.setOsVer("");
mercuryReportLog.setPlatform("");
mercuryReportLog.setType("");
mercuryReportLog.setUid("");
mercuryReportLogRepository.save(mercuryReportLog);
RoomImMsgLog roomImMsgLog = new RoomImMsgLog();
roomImMsgLog.setMessageId("");
roomImMsgLog.setRoomId("");
roomImMsgLog.setMsgType("");
roomImMsgLog.setProductCode("");
roomImMsgLog.setPriority("");
roomImMsgLog.setUid("");
roomImMsgLog.setContent("");
roomImMsgLog.setToUid("");
roomImMsgLog.setSendTime(System.currentTimeMillis());
roomImMsgLogRepository.save(roomImMsgLog);
}
@Test
void test0(){
mercuryEventLogRepository.deleteAll();
MercuryEventLog mercuryEventLog = new MercuryEventLog();
mercuryEventLog.setUid("2013123");
mercuryEventLog.setServer("");
mercuryEventLog.setAddr("");
mercuryEventLog.setType("");
mercuryEventLog.setDevice("");
mercuryEventLog.setEvent("");
mercuryEventLog.setContent("你好 hello world");
mercuryEventLog.setCmd("1");
mercuryEventLog.setHeader("");
mercuryEventLog.setSendTime(System.currentTimeMillis());
mercuryEventLogService.save(mercuryEventLog);
MercuryEventLogQuery query = new MercuryEventLogQuery();
query.setFromTime(System.currentTimeMillis() - 10000);
query.setToTime(System.currentTimeMillis() + 10000);
query.setContent("hell");
query.setUid("2013123");
Page<MercuryEventLog> mercuryEventLogs = mercuryEventLogService.pageQuery(query);
System.out.println(JSON.toJSONString(mercuryEventLogs));
}
@Test
void test1() {
StreamQueryRequest request = new StreamQueryRequest();
request.setRoomId("4069090844816730368");
request.setUid("123");
request.setStartTime("2022-09-20 18:31:27");
request.setEndTime("2022-09-20 20:31:27");
request.setLimit(20);
System.out.println(streamManager.queryChatroomStreamRecord(request));
}
@Test
void test2() {
StreamQueryRequest request = new StreamQueryRequest();
request.setRoomId("4069090844816730368");
request.setStartTime("2022-09-20 18:31:27");
request.setEndTime("2022-09-20 20:31:27");
request.setLimit(20);
System.out.println(streamManager.queryChatroomMixStream(request));
}
@Test
void test3() {
StreamQueryRequest request = new StreamQueryRequest();
request.setStreamId("STGZ4069090844816730368Z123Z4086981608179537920");
request.setStartTime("2022-09-20 18:31:27");
request.setEndTime("2022-09-20 20:31:27");
request.setLimit(20);
System.out.println(streamManager.queryChatroomStream(request));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/SonaConsoleApplication.java | sona-console/src/main/java/cn/bixin/sona/console/SonaConsoleApplication.java | package cn.bixin.sona.console;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
/**
* @author qinwei
*/
@Slf4j
@SpringBootApplication
@ComponentScan(basePackages = { "cn.bixin.sona.*" })
public class SonaConsoleApplication {
public static void main(String[] args) {
SpringApplication.run(SonaConsoleApplication.class, args);
log.info("SonaConsoleApplication start ...");
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/controller/StreamRecordController.java | sona-console/src/main/java/cn/bixin/sona/console/controller/StreamRecordController.java | package cn.bixin.sona.console.controller;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.console.domain.dto.ChatroomStreamDTO;
import cn.bixin.sona.console.domain.req.StreamQueryRequest;
import cn.bixin.sona.console.manager.StreamManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@CrossOrigin
@Slf4j
@RestController
public class StreamRecordController {
@Resource
private StreamManager streamManager;
/**
* 流录制查询单流
*
* @param request 参数
* @return
*/
@PostMapping("/stream/record/multi")
public Response<PageResult<ChatroomStreamDTO>> queryChatroomMultiStream(@RequestBody StreamQueryRequest request) {
return Response.success(streamManager.queryChatroomStreamRecord(request));
}
/**
* 流录制查询混流
*
* @param request 参数
* @return
*/
@PostMapping("/stream/record/mixed")
Response<PageResult<ChatroomStreamDTO>> queryChatroomMixStream(@RequestBody StreamQueryRequest request) {
return Response.success(streamManager.queryChatroomMixStream(request));
}
/**
* 流录制查询流地址
*
* @param request 参数
* @return
*/
@PostMapping("/stream/record/addr")
Response<PageResult<ChatroomStreamDTO>> queryChatroomStream(@RequestBody StreamQueryRequest request) {
return Response.success(streamManager.queryChatroomStream(request));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/controller/RoomConsoleController.java | sona-console/src/main/java/cn/bixin/sona/console/controller/RoomConsoleController.java | package cn.bixin.sona.console.controller;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.console.domain.db.SwitchBatch;
import cn.bixin.sona.console.domain.dto.MediaRoomInfoDTO;
import cn.bixin.sona.console.domain.req.HotSwitchRequest;
import cn.bixin.sona.console.domain.req.MediaRoomRequest;
import cn.bixin.sona.console.domain.req.PageQuery;
import cn.bixin.sona.console.manager.MediaRoomInfoManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@Slf4j
@CrossOrigin
@RestController
public class RoomConsoleController {
@Resource
private MediaRoomInfoManager mediaRoomInfoManager;
/**
* 查询房间配置
* @return
*/
@PostMapping("/media/room/info")
public Response<List<MediaRoomInfoDTO>> queryMediaRoomInfo(@RequestBody MediaRoomRequest request) {
return Response.success(mediaRoomInfoManager.queryMediaRoomInfo(request));
}
/**
* 手动热切
* @return
*/
@PostMapping("/media/room/switch/self")
public Response<String> hotSwitchSelf(@RequestBody HotSwitchRequest request) {
return Response.success(mediaRoomInfoManager.hotSwitchSelf(request));
}
/**
* 热切记录
* @return
*/
@PostMapping("/media/room/switch/record")
public Response<PageResult<SwitchBatch>> queryHotSwitchRecords(@RequestBody PageQuery pageQuery) {
return Response.success(mediaRoomInfoManager.queryHotSwitchRecords(pageQuery.getStart(), pageQuery.getPageSize()));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/controller/SonaLogController.java | sona-console/src/main/java/cn/bixin/sona/console/controller/SonaLogController.java | package cn.bixin.sona.console.controller;
import cn.bixin.sona.common.dto.Response;
import cn.bixin.sona.console.domain.es.MercuryEventLog;
import cn.bixin.sona.console.domain.es.MercuryReportLog;
import cn.bixin.sona.console.domain.es.RoomImMsgLog;
import cn.bixin.sona.console.domain.req.MercuryEventLogQuery;
import cn.bixin.sona.console.domain.req.MercuryReportLogQuery;
import cn.bixin.sona.console.domain.req.RoomImMsgLogQuery;
import cn.bixin.sona.console.service.MercuryEventLogService;
import cn.bixin.sona.console.service.MercuryReportLogService;
import cn.bixin.sona.console.service.RoomImMsgLogService;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@CrossOrigin
@RestController
public class SonaLogController {
@Resource
private MercuryEventLogService mercuryEventLogService;
@Resource
private MercuryReportLogService mercuryReportLogService;
@Resource
private RoomImMsgLogService roomImMsgLogService;
/**
* 长连事件上报日志查询
* @return
*/
@PostMapping("/mercury/event/log/query")
public Response<Page<MercuryEventLog>> mercuryEventLogQuery(@RequestBody MercuryEventLogQuery query) {
return Response.success(mercuryEventLogService.pageQuery(query));
}
/**
* 长连客户端上报日志查询
* @return
*/
@PostMapping("/mercury/client/log/query")
public Response<Page<MercuryReportLog>> mercuryClientLogQuery(@RequestBody MercuryReportLogQuery query) {
return Response.success(mercuryReportLogService.pageQuery(query));
}
/**
* 房间消息全链路日志查询
* @return
*/
@PostMapping("/room/im/msg/log/query")
public Response<Page<RoomImMsgLog>> roomImMsgLogQuery(@RequestBody RoomImMsgLogQuery query) {
return Response.success(roomImMsgLogService.pageQuery(query));
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/SwitchBatchService.java | sona-console/src/main/java/cn/bixin/sona/console/service/SwitchBatchService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.SwitchBatch;
import java.util.List;
public interface SwitchBatchService{
int deleteByPrimaryKey(Long id);
int insert(SwitchBatch record);
int insertSelective(SwitchBatch record);
SwitchBatch selectByPrimaryKey(Long id);
int updateByPrimaryKeySelective(SwitchBatch record);
int updateByPrimaryKey(SwitchBatch record);
List<SwitchBatch> queryByParam(int start, int pageSize);
Integer queryTotalCount();
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/ProductConfigService.java | sona-console/src/main/java/cn/bixin/sona/console/service/ProductConfigService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.ProductConfig;
import java.util.Collection;
import java.util.List;
public interface ProductConfigService{
ProductConfig selectByProductCode(String productCode);
List<ProductConfig> selectByProductCodes(Collection<String> productCodeCollection);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/MercuryEventLogService.java | sona-console/src/main/java/cn/bixin/sona/console/service/MercuryEventLogService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.es.MercuryEventLog;
import cn.bixin.sona.console.domain.req.MercuryEventLogQuery;
import org.springframework.data.domain.Page;
public interface MercuryEventLogService {
void save(MercuryEventLog mercuryEventLog);
Page<MercuryEventLog> pageQuery(MercuryEventLogQuery query);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/RoomImMsgLogService.java | sona-console/src/main/java/cn/bixin/sona/console/service/RoomImMsgLogService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.es.RoomImMsgLog;
import cn.bixin.sona.console.domain.req.RoomImMsgLogQuery;
import org.springframework.data.domain.Page;
public interface RoomImMsgLogService {
RoomImMsgLog save(RoomImMsgLog roomImMsgLog);
Page<RoomImMsgLog> pageQuery(RoomImMsgLogQuery query);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/RoomConfigService.java | sona-console/src/main/java/cn/bixin/sona/console/service/RoomConfigService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.RoomConfig;
import java.util.Collection;
import java.util.List;
public interface RoomConfigService{
List<RoomConfig> selectByStreamSupplierAndPullMode(String streamSupplier, String pullMode);
List<RoomConfig> selectByRoomIds(Collection<Long> roomIdCollection);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/SwitchDetailService.java | sona-console/src/main/java/cn/bixin/sona/console/service/SwitchDetailService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.SwitchDetail;
import java.util.List;
public interface SwitchDetailService {
int deleteByPrimaryKey(Long id);
int insert(SwitchDetail record);
int insertSelective(SwitchDetail record);
SwitchDetail selectByPrimaryKey(Long id);
int updateByPrimaryKeySelective(SwitchDetail record);
int updateByPrimaryKey(SwitchDetail record);
List<SwitchDetail> queryDetailsByIds(List<Long> batchIds);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/ChatroomService.java | sona-console/src/main/java/cn/bixin/sona/console/service/ChatroomService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.Chatroom;
public interface ChatroomService{
int deleteByPrimaryKey(Long pid);
int insert(Chatroom record);
int insertSelective(Chatroom record);
Chatroom selectByPrimaryKey(Long pid);
int updateByPrimaryKeySelective(Chatroom record);
int updateByPrimaryKey(Chatroom record);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/MercuryReportLogService.java | sona-console/src/main/java/cn/bixin/sona/console/service/MercuryReportLogService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.es.MercuryReportLog;
import cn.bixin.sona.console.domain.req.MercuryReportLogQuery;
import org.springframework.data.domain.Page;
public interface MercuryReportLogService {
void save(MercuryReportLog mercuryReportLog);
Page<MercuryReportLog> pageQuery(MercuryReportLogQuery query);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/RoomService.java | sona-console/src/main/java/cn/bixin/sona/console/service/RoomService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.db.Room;
import java.util.List;
public interface RoomService{
int deleteByPrimaryKey(Long roomId);
int insert(Room record);
int insertSelective(Room record);
Room selectByPrimaryKey(Long roomId);
int updateByPrimaryKeySelective(Room record);
int updateByPrimaryKey(Room record);
List<Room> selectByRoomIds(List<Long> roomIds);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/StreamService.java | sona-console/src/main/java/cn/bixin/sona/console/service/StreamService.java | package cn.bixin.sona.console.service;
import cn.bixin.sona.console.domain.dto.StreamRecordDTO;
import java.util.List;
public interface StreamService {
List<StreamRecordDTO> queryStreamRecordInfo(StreamRecordDTO request);
List<StreamRecordDTO> selectStreamCount(StreamRecordDTO request);
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomConfigServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomConfigServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.service.RoomConfigService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import cn.bixin.sona.console.mapper.RoomConfigMapper;
import cn.bixin.sona.console.domain.db.RoomConfig;
import java.util.Collection;
import java.util.List;
@Service
public class RoomConfigServiceImpl implements RoomConfigService {
@Resource
private RoomConfigMapper roomConfigMapper;
@Override
public List<RoomConfig> selectByStreamSupplierAndPullMode(String streamSupplier, String pullMode) {
return roomConfigMapper.selectByStreamSupplierAndPullMode(streamSupplier, pullMode);
}
@Override
public List<RoomConfig> selectByRoomIds(Collection<Long> roomIdCollection) {
return roomConfigMapper.selectByRoomIdIn(roomIdCollection);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomImMsgLogServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomImMsgLogServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.domain.es.RoomImMsgLog;
import cn.bixin.sona.console.domain.req.RoomImMsgLogQuery;
import cn.bixin.sona.console.repository.RoomImMsgLogRepository;
import cn.bixin.sona.console.service.RoomImMsgLogService;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Objects;
@Service
public class RoomImMsgLogServiceImpl implements RoomImMsgLogService {
@Resource
private RoomImMsgLogRepository repository;
@Override
public RoomImMsgLog save(RoomImMsgLog roomImMsgLog) {
return repository.save(roomImMsgLog);
}
@Override
public Page<RoomImMsgLog> pageQuery(RoomImMsgLogQuery query) {
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
if (StringUtils.isNotBlank(query.getMessageId())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("messageId", query.getMessageId()));
}
if (StringUtils.isNotBlank(query.getRoomId())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("roomId", query.getRoomId()));
}
if (StringUtils.isNotBlank(query.getMsgType())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("msgType", query.getMsgType()));
}
if (StringUtils.isNotBlank(query.getProductCode())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("productCode", query.getProductCode()));
}
if (StringUtils.isNotBlank(query.getPriority())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("priority", query.getPriority()));
}
if (StringUtils.isNotBlank(query.getUid())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("uid", query.getUid()));
}
if (StringUtils.isNotBlank(query.getContent())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("content", query.getContent()));
}
if (StringUtils.isNotBlank(query.getToUid())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("toUid", query.getToUid()));
}
if (Objects.nonNull(query.getFromTime()) && Objects.nonNull(query.getToTime())) {
queryBuilder.must(QueryBuilders.rangeQuery("sendTime").from(query.getFromTime()).to(query.getToTime()));
}
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(queryBuilder)
.withPageable(PageRequest.of(query.getPageNo(), query.getPageSize()))
.build();
return repository.search(searchQuery);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/SwitchBatchServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/SwitchBatchServiceImpl.java | package cn.bixin.sona.console.service.impl;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import cn.bixin.sona.console.mapper.SwitchBatchMapper;
import cn.bixin.sona.console.domain.db.SwitchBatch;
import cn.bixin.sona.console.service.SwitchBatchService;
import java.util.List;
@Service
public class SwitchBatchServiceImpl implements SwitchBatchService{
@Resource
private SwitchBatchMapper switchBatchMapper;
@Override
public int deleteByPrimaryKey(Long id) {
return switchBatchMapper.deleteByPrimaryKey(id);
}
@Override
public int insert(SwitchBatch record) {
return switchBatchMapper.insert(record);
}
@Override
public int insertSelective(SwitchBatch record) {
return switchBatchMapper.insertSelective(record);
}
@Override
public SwitchBatch selectByPrimaryKey(Long id) {
return switchBatchMapper.selectByPrimaryKey(id);
}
@Override
public int updateByPrimaryKeySelective(SwitchBatch record) {
return switchBatchMapper.updateByPrimaryKeySelective(record);
}
@Override
public int updateByPrimaryKey(SwitchBatch record) {
return switchBatchMapper.updateByPrimaryKey(record);
}
@Override
public List<SwitchBatch> queryByParam(int start, int pageSize) {
return switchBatchMapper.queryByParam(start, pageSize);
}
@Override
public Integer queryTotalCount() {
return switchBatchMapper.queryTotalCount();
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/ChatroomServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/ChatroomServiceImpl.java | package cn.bixin.sona.console.service.impl;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import cn.bixin.sona.console.domain.db.Chatroom;
import cn.bixin.sona.console.mapper.ChatroomMapper;
import cn.bixin.sona.console.service.ChatroomService;
@Service
public class ChatroomServiceImpl implements ChatroomService{
@Resource
private ChatroomMapper chatroomMapper;
@Override
public int deleteByPrimaryKey(Long pid) {
return chatroomMapper.deleteByPrimaryKey(pid);
}
@Override
public int insert(Chatroom record) {
return chatroomMapper.insert(record);
}
@Override
public int insertSelective(Chatroom record) {
return chatroomMapper.insertSelective(record);
}
@Override
public Chatroom selectByPrimaryKey(Long pid) {
return chatroomMapper.selectByPrimaryKey(pid);
}
@Override
public int updateByPrimaryKeySelective(Chatroom record) {
return chatroomMapper.updateByPrimaryKeySelective(record);
}
@Override
public int updateByPrimaryKey(Chatroom record) {
return chatroomMapper.updateByPrimaryKey(record);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/SwitchDetailServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/SwitchDetailServiceImpl.java | package cn.bixin.sona.console.service.impl;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import cn.bixin.sona.console.mapper.SwitchDetailMapper;
import cn.bixin.sona.console.domain.db.SwitchDetail;
import cn.bixin.sona.console.service.SwitchDetailService;
import java.util.List;
@Service
public class SwitchDetailServiceImpl implements SwitchDetailService{
@Resource
private SwitchDetailMapper switchDetailMapper;
@Override
public int deleteByPrimaryKey(Long id) {
return switchDetailMapper.deleteByPrimaryKey(id);
}
@Override
public int insert(SwitchDetail record) {
return switchDetailMapper.insert(record);
}
@Override
public int insertSelective(SwitchDetail record) {
return switchDetailMapper.insertSelective(record);
}
@Override
public SwitchDetail selectByPrimaryKey(Long id) {
return switchDetailMapper.selectByPrimaryKey(id);
}
@Override
public int updateByPrimaryKeySelective(SwitchDetail record) {
return switchDetailMapper.updateByPrimaryKeySelective(record);
}
@Override
public int updateByPrimaryKey(SwitchDetail record) {
return switchDetailMapper.updateByPrimaryKey(record);
}
@Override
public List<SwitchDetail> queryDetailsByIds(List<Long> batchIds) {
return switchDetailMapper.selectAllByBatchIdIn(batchIds);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/StreamServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/StreamServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.domain.converter.StreamRecordConverter;
import cn.bixin.sona.console.domain.db.Stream;
import cn.bixin.sona.console.domain.dto.StreamRecordDTO;
import cn.bixin.sona.console.mapper.StreamMapper;
import cn.bixin.sona.console.service.StreamService;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;
@Service
@Slf4j
public class StreamServiceImpl implements StreamService {
@Resource
private StreamMapper streamMapper;
public List<StreamRecordDTO> queryStreamRecordInfo(StreamRecordDTO request){
log.info("queryStreamRecordInfo param:{}", JSON.toJSONString(request));
//根据用户信息查询流信息
List<Stream> streams = streamMapper.selectStream(request.getStreamId(), request.getRoomId(), request.getUid()
, request.getBeginTime(), request.getEndTime(), request.getAnchor(), request.getLimit());
//过滤拉流模式
return streams.stream().map(StreamRecordConverter::convert2DTO).collect(Collectors.toList());
}
public List<StreamRecordDTO> selectStreamCount(StreamRecordDTO request){
log.info("selectStreamCount param:{}", JSON.toJSONString(request));
List<Stream> streams = streamMapper.selectStreamInfo(request.getStreamId(), request.getRoomId(),
request.getUid(), request.getBeginTime(), request.getEndTime());
return streams.stream().map(StreamRecordConverter::convert2DTO).collect(Collectors.toList());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/ProductConfigServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/ProductConfigServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.domain.db.ProductConfig;
import cn.bixin.sona.console.mapper.ProductConfigMapper;
import cn.bixin.sona.console.service.ProductConfigService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
@Service
public class ProductConfigServiceImpl implements ProductConfigService {
@Resource
private ProductConfigMapper productConfigMapper;
@Override
public ProductConfig selectByProductCode(String productCode) {
return productConfigMapper.selectByProductCode(productCode);
}
@Override
public List<ProductConfig> selectByProductCodes(Collection<String> productCodeCollection) {
return productConfigMapper.selectByProductCodeIn(productCodeCollection);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/RoomServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.service.RoomService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import cn.bixin.sona.console.domain.db.Room;
import cn.bixin.sona.console.mapper.RoomMapper;
import java.util.List;
@Service
public class RoomServiceImpl implements RoomService {
@Resource
private RoomMapper roomMapper;
@Override
public int deleteByPrimaryKey(Long roomId) {
return roomMapper.deleteByPrimaryKey(roomId);
}
@Override
public int insert(Room record) {
return roomMapper.insert(record);
}
@Override
public int insertSelective(Room record) {
return roomMapper.insertSelective(record);
}
@Override
public Room selectByPrimaryKey(Long roomId) {
return roomMapper.selectByPrimaryKey(roomId);
}
@Override
public int updateByPrimaryKeySelective(Room record) {
return roomMapper.updateByPrimaryKeySelective(record);
}
@Override
public int updateByPrimaryKey(Room record) {
return roomMapper.updateByPrimaryKey(record);
}
@Override
public List<Room> selectByRoomIds(List<Long> roomIds) {
return roomMapper.selectByRoomIdIn(roomIds);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/MercuryReportLogServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/MercuryReportLogServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.domain.es.MercuryReportLog;
import cn.bixin.sona.console.domain.req.MercuryReportLogQuery;
import cn.bixin.sona.console.repository.MercuryReportLogRepository;
import cn.bixin.sona.console.service.MercuryReportLogService;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Objects;
@Service
public class MercuryReportLogServiceImpl implements MercuryReportLogService {
@Resource
private MercuryReportLogRepository mercuryReportLogRepository;
@Override
public void save(MercuryReportLog mercuryReportLog) {
mercuryReportLogRepository.save(mercuryReportLog);
}
@Override
public Page<MercuryReportLog> pageQuery(MercuryReportLogQuery query) {
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
if (StringUtils.isNotBlank(query.getCommon())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("common", query.getCommon()));
}
if (StringUtils.isNotBlank(query.getDesc())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("desc", query.getDesc()));
}
if (StringUtils.isNotBlank(query.getDetails())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("details", query.getDetails()));
}
if (StringUtils.isNotBlank(query.getIp())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("ip", query.getIp()));
}
if (StringUtils.isNotBlank(query.getModel())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("model", query.getModel()));
}
if (StringUtils.isNotBlank(query.getNetwork())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("network", query.getNetwork()));
}
if (StringUtils.isNotBlank(query.getOsVer())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("osVer", query.getOsVer()));
}
if (StringUtils.isNotBlank(query.getPlatform())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("platform", query.getPlatform()));
}
if (StringUtils.isNotBlank(query.getType())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("type", query.getType()));
}
if (StringUtils.isNotBlank(query.getUid())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("uid", query.getUid()));
}
if (Objects.nonNull(query.getFromTime()) && Objects.nonNull(query.getToTime())) {
queryBuilder.must(QueryBuilders.rangeQuery("sendTime").from(query.getFromTime()).to(query.getToTime()));
}
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(queryBuilder)
.withPageable(PageRequest.of(query.getPageNo(), query.getPageSize()))
.build();
return mercuryReportLogRepository.search(searchQuery);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/service/impl/MercuryEventLogServiceImpl.java | sona-console/src/main/java/cn/bixin/sona/console/service/impl/MercuryEventLogServiceImpl.java | package cn.bixin.sona.console.service.impl;
import cn.bixin.sona.console.domain.es.MercuryEventLog;
import cn.bixin.sona.console.domain.req.MercuryEventLogQuery;
import cn.bixin.sona.console.repository.MercuryEventLogRepository;
import cn.bixin.sona.console.service.MercuryEventLogService;
import cn.bixin.sona.console.utils.DateUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Objects;
@Service
public class MercuryEventLogServiceImpl implements MercuryEventLogService {
@Resource
private MercuryEventLogRepository mercuryEventLogRepository;
@Override
public void save(MercuryEventLog mercuryEventLog) {
mercuryEventLogRepository.save(mercuryEventLog);
}
@Override
public Page<MercuryEventLog> pageQuery(MercuryEventLogQuery query) {
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
if (StringUtils.isNotBlank(query.getUid())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("uid", query.getUid()));
}
if (StringUtils.isNotBlank(query.getServer())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("server", query.getServer()));
}
if (StringUtils.isNotBlank(query.getAddr())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("addr", query.getAddr()));
}
if (StringUtils.isNotBlank(query.getType())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("type", query.getType()));
}
if (StringUtils.isNotBlank(query.getDevice())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("device", query.getDevice()));
}
if (StringUtils.isNotBlank(query.getEvent())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("event", query.getEvent()));
}
if (StringUtils.isNotBlank(query.getContent())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("content", query.getContent()));
}
if (StringUtils.isNotBlank(query.getCmd())) {
queryBuilder.must(QueryBuilders.matchPhraseQuery("cmd", query.getCmd()));
}
if (StringUtils.isNotBlank(query.getHeader())) {
queryBuilder.must(QueryBuilders.fuzzyQuery("header", query.getHeader()));
}
if (Objects.nonNull(query.getFromTime()) && Objects.nonNull(query.getToTime())) {
queryBuilder.must(QueryBuilders.rangeQuery("sendTime").from(query.getFromTime()).to(query.getToTime()));
}
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(queryBuilder)
.withPageable(PageRequest.of(query.getPageNo(), query.getPageSize()))
.build();
return mercuryEventLogRepository.search(searchQuery);
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/manager/MediaRoomInfoManager.java | sona-console/src/main/java/cn/bixin/sona/console/manager/MediaRoomInfoManager.java | package cn.bixin.sona.console.manager;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.util.IdGenerator;
import cn.bixin.sona.console.convert.BeanCreator;
import cn.bixin.sona.console.domain.db.*;
import cn.bixin.sona.console.domain.dto.MediaRoomInfoDTO;
import cn.bixin.sona.console.domain.enums.HotSwitchStatusEnum;
import cn.bixin.sona.console.domain.req.HotSwitchRequest;
import cn.bixin.sona.console.domain.req.MediaRoomRequest;
import cn.bixin.sona.console.facade.StreamServiceFacade;
import cn.bixin.sona.console.service.*;
import cn.bixin.sona.console.utils.CollectionUtil;
import cn.bixin.sona.enums.RoomMixedEnum;
import com.google.common.util.concurrent.RateLimiter;
import org.apache.dubbo.common.utils.CollectionUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Service
public class MediaRoomInfoManager {
@Resource
private SwitchDetailService switchDetailService;
@Resource
private RoomService roomService;
@Resource
private ProductConfigService productConfigService;
@Resource
private RoomConfigService roomConfigService;
@Resource
private SwitchBatchService switchBatchService;
@Resource
private IdGenerator idGenerator;
@Resource
private StreamServiceFacade streamServiceFacade;
public List<MediaRoomInfoDTO> queryMediaRoomInfo(MediaRoomRequest request) {
List<Long> roomIds = CollectionUtil.spiltToLong(request.getRoomIds(), ',');
if (CollectionUtils.isEmpty(roomIds)) {
List<RoomConfig> roomConfigs = roomConfigService.selectByStreamSupplierAndPullMode(request.getCloudSupplierType(), request.getPullStreamType());
return roomConfigs.stream().map(BeanCreator::createMediaRoomInfoDTO).collect(Collectors.toList());
}
List<Room> rooms = roomService.selectByRoomIds(roomIds);
Map<Long, String> roomProductMap = rooms.stream().collect(Collectors.toMap(Room::getRoomId, Room::getProductCode, (a, b) -> a));
List<RoomConfig> roomConfigs = roomConfigService.selectByRoomIds(roomIds);
List<MediaRoomInfoDTO> mediaRoomInfoDTOS = roomConfigs.stream().map(BeanCreator::createMediaRoomInfoDTO).collect(Collectors.toList());
List<Long> hitRoomIds = roomConfigs.stream().map(RoomConfig::getRoomId).collect(Collectors.toList());
roomIds.removeIf(hitRoomIds::contains);
List<ProductConfig> productConfigs = productConfigService.selectByProductCodes(roomProductMap.values());
Map<String, ProductConfig> productConfigMap = productConfigs.stream().collect(Collectors.toMap(ProductConfig::getProductCode, a -> a, (a, b) -> a));
List<MediaRoomInfoDTO> defaultMediaRoomInfoDTO = roomIds.stream().map(i -> BeanCreator.createMediaRoomInfoDTO(i, productConfigMap, roomProductMap)).collect(Collectors.toList());
mediaRoomInfoDTOS.addAll(defaultMediaRoomInfoDTO);
return mediaRoomInfoDTOS;
}
@SuppressWarnings("UnstableApiUsage")
public String hotSwitchSelf(HotSwitchRequest request) {
List<Long> roomIds = CollectionUtil.spiltToLong(request.getRoomIds(), ',');
RoomMixedEnum roomMixedEnum = RoomMixedEnum.getRoomMixedEnum(request.getSwitchType());
//数据库添加批次切换记录
long batchId = idGenerator.id();
saveBatchOperation(roomMixedEnum.getSupplier(), roomMixedEnum.getPullMode() , batchId);
RateLimiter rateLimiter = RateLimiter.create(10);
roomIds.forEach(roomId -> {
rateLimiter.acquire();
Boolean flag = streamServiceFacade.switchAudioSupplierRoom(roomId, roomMixedEnum.getCode());
SwitchDetail switchDetail = new SwitchDetail();
switchDetail.setBatchId(batchId);
switchDetail.setRoomId(roomId);
switchDetail.setStreamSupplier(roomMixedEnum.getSupplier());
switchDetail.setPullMode(roomMixedEnum.getPullMode());
switchDetail.setStatus(flag ? 1 : 2);
switchDetail.setOperator("admin");
switchDetailService.insertSelective(switchDetail);
});
return batchId + "";
}
private void saveBatchOperation(String supplier, String pullMode, long batchId) {
SwitchBatch switchBatch = new SwitchBatch();
switchBatch.setId(batchId);
switchBatch.setSwitchType(1);
switchBatch.setStreamSupplier(supplier);
switchBatch.setPullMode(pullMode);
switchBatch.setStatus(0);
switchBatch.setOperator("admin");
switchBatchService.insertSelective(switchBatch);
}
public PageResult<SwitchBatch> queryHotSwitchRecords(int start, int pageSize) {
if (start <= 0) { start = 1; }
if (pageSize <= 0) { pageSize = 10; }
int offset = (start - 1) * pageSize;
List<SwitchBatch> switchBatchDTOS = switchBatchService.queryByParam(offset, pageSize);
if (CollectionUtils.isEmpty(switchBatchDTOS)) {
return PageResult.newPageResult(Collections.emptyList(), true);
}
List<Long> batchIds = switchBatchDTOS.stream().filter(item -> item.getSwitchType() == 1).map(SwitchBatch::getId).collect(Collectors.toList());
List<SwitchDetail> switchDetails = switchDetailService.queryDetailsByIds(batchIds);
Map<Long, List<SwitchDetail>> collect = switchDetails.stream().collect(
Collectors.groupingBy(SwitchDetail::getBatchId));
switchBatchDTOS.forEach(item -> {
List<SwitchDetail> resultDetail = collect.get(item.getId());
if(CollectionUtils.isEmpty(resultDetail)){
item.setStatus(0);
return;
}
List<SwitchDetail> running = resultDetail.stream().filter(ele -> ele.getStatus() == 0).collect(
Collectors.toList());
List<SwitchDetail> failed = resultDetail.stream().filter(ele -> ele.getStatus() == 2).collect(
Collectors.toList());
if(!org.springframework.util.CollectionUtils.isEmpty(running)){
item.setStatus(HotSwitchStatusEnum.RUNNING.getCode());
}else if(!org.springframework.util.CollectionUtils.isEmpty(failed)){
item.setStatus(HotSwitchStatusEnum.FAILED.getCode());
}else{
item.setStatus(HotSwitchStatusEnum.SUCCESS.getCode());
}
});
Integer totalCount = switchBatchService.queryTotalCount();
PageResult<SwitchBatch> pageResult = new PageResult<>();
pageResult.setCount((long)totalCount);
pageResult.setEnd(false);
pageResult.setList(switchBatchDTOS);
return pageResult;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/manager/StreamManager.java | sona-console/src/main/java/cn/bixin/sona/console/manager/StreamManager.java | package cn.bixin.sona.console.manager;
import cn.bixin.sona.common.dto.PageResult;
import cn.bixin.sona.common.exception.YppRunTimeException;
import cn.bixin.sona.console.domain.converter.StreamConverter;
import cn.bixin.sona.console.domain.dto.ChatroomStreamDTO;
import cn.bixin.sona.console.domain.dto.StreamRecordDTO;
import cn.bixin.sona.console.domain.req.StreamQueryRequest;
import cn.bixin.sona.console.exception.ExceptionCode;
import cn.bixin.sona.console.service.StreamService;
import cn.bixin.sona.console.utils.DateUtils;
import com.google.common.collect.Sets;
import org.apache.dubbo.common.utils.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
@Service
public class StreamManager {
@Resource
private StreamService streamService;
public PageResult<ChatroomStreamDTO> queryChatroomStreamRecord(StreamQueryRequest request) {
if (request == null || (StringUtils.isBlank(request.getUid()) && StringUtils.isBlank(request.getRoomId()) && StringUtils.isBlank(request.getStreamId()))) {
throw new YppRunTimeException(ExceptionCode.NULL_PARAM);
}
return getStreamsPageResult(request);
}
public PageResult<ChatroomStreamDTO> queryChatroomMixStream(StreamQueryRequest request) {
if (request == null || (StringUtils.isBlank(request.getRoomId()) && StringUtils.isBlank(request.getStartTime())) && StringUtils.isBlank(request.getEndTime())) {
throw new YppRunTimeException(ExceptionCode.NULL_PARAM);
}
return getStreamsPageResult(request);
}
public PageResult<ChatroomStreamDTO> queryChatroomStream(StreamQueryRequest request) {
if (request == null || StringUtils.isBlank(request.getStreamId())) {
throw new YppRunTimeException(ExceptionCode.NULL_PARAM);
}
return getStreamsPageResult(request);
}
private PageResult<ChatroomStreamDTO> getStreamsPageResult(StreamQueryRequest request) {
StreamRecordDTO param = new StreamRecordDTO();
if (StringUtils.isNotEmpty(request.getUid())) {
param.setUid(Long.parseLong(request.getUid()));
}
if (StringUtils.isNotEmpty(request.getRoomId())) {
param.setRoomId(Long.parseLong(request.getRoomId()));
}
if (StringUtils.isNotEmpty(request.getAnchor())) {
param.setAnchor(Long.parseLong(request.getAnchor()));
}
param.setStreamId(request.getStreamId());
param.setLimit(request.getLimit());
param.setBeginTime(DateUtils.formatToDate(request.getStartTime()));
param.setEndTime(DateUtils.formatToDate(request.getEndTime()));
List<StreamRecordDTO> streamRecordDTOList = streamService.queryStreamRecordInfo(param);
List<StreamRecordDTO> recordDTOList = streamService.selectStreamCount(param);
return fillChatroomStream(streamRecordDTOList, recordDTOList);
}
private PageResult<ChatroomStreamDTO> fillChatroomStream(List<StreamRecordDTO> streams, List<StreamRecordDTO> sums) {
if (CollectionUtils.isEmpty(streams)) {
return PageResult.newPageResult(Collections.emptyList(), true);
}
List<ChatroomStreamDTO> chatroomStreamDTOS = StreamConverter.convertChatroomStreamList(streams);
PageResult<ChatroomStreamDTO> pageResult = new PageResult<>();
pageResult.setCount((long) sums.size());
pageResult.setEnd(false);
pageResult.setList(chatroomStreamDTOS);
pageResult.setAnchor(CollectionUtils.isEmpty(streams) ? "" : String.valueOf(streams.get(streams.size() - 1).getId()));
return pageResult;
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/exception/ExceptionCode.java | sona-console/src/main/java/cn/bixin/sona/console/exception/ExceptionCode.java | package cn.bixin.sona.console.exception;
import cn.bixin.sona.common.dto.Code;
import cn.bixin.sona.common.dto.Response;
public enum ExceptionCode implements Code {
/**
* 返回错误码定义
*/
ERROR_PARAM("8010","参数错误"),
NULL_PARAM("8011","参数为空"),
EMPTY_PARAM("8012","缺少参数"),
SERVER_ERROR("9000", "服务器异常"),
DATA_NOT_FOUND("8014","数据没有找到"),
PARAM_OVER_MAX("8015","参数超过最大长度"),
ERROR_AUTH("8016", "没有权限操作"),
ERROR_ACCID("8017", "获取accId失败"),
ERROR_PASSWORD("8018", "密码错误"),
OWNER_NOT_FOUND("8019", "房主没有找到"),
ERROR_SEND_MESSAGE("8020", "发送消息失败"),
PARAMETER_LENGTH_IS_TOO_LONG("8021","参数长度过长"),
HTTP_ERROR("8022", "http请求异常"),
DIAMOND_NOT_ENOUGH("8050", "账户钻石不足"),
APP_VERSION_IS_LOW("8023", "当前版本过低，请升级版本"),
CHATROOM_INVALID("10010", "聊天室无效"),
CREATE_CHATROOM_ERROR("10011", "创建房间失败"),
CHECK_ONLINE_ROOM_MEMBER_ERROR("10012", "检查房间在线人员失败"),
OPEN_CLOSE_CHATROOM_ERROR("10013", "开关房间失败"),
CREATOR_NOT_SAME_ERROR("10014", "操作人不是房主"),
CHATROOM_EXISTS("10015", "房间已经存在"),
CHATROOM_NOT_EXISTS("10016", "房间不存在"),
KICK_OUT_ROOM_MEMBER_ERROR("10017", "房间踢人失败"),
GET_ONLINE_ROOM_MEMBER_ERROR("10018", "获取在线成员失败"),
IM_CHATROOM_NOT_FOUNT("10019", "im房间查询未找到"),
RTC_RECORD_NOT_EXISTS("10020", "连麦记录不存在"),
RTC_RECORD_REPETITION("10021", "连麦重复上报"),
RTC_ROOM_NOT_EXISTS("10022", "rtc房间不存在"),
SET_USER_ROLE_ERROR("10023", "设置用户信息失败"),
SET_GROUP_ADMIN_ERROR("10024", "设置群组管理员失败"),
REMOVE_GROUP_ADMIN_ERROR("10025", "移除群组管理员失败"),
GET_GROUP_INFO_ERROR("10026", "获取群组信息失败"),
GET_CHATROOM_INFO_ERROR("10027", "获取聊天室信息失败"),
CREATE_GROUP_ERROR("20010", "创建群组失败"),
GROUP_NOT_FOUND("20011", "群组没有找到"),
GROUP_COUNT_EXCEED("20012", "群人数已经超限"),
JOIN_GROUP_ERROR("20013", "加入群组失败"),
KICK_MEMBER_ERROR("20014", "踢人失败"),
REMOVE_GROUP_ERROR("20015", "解散群组失败"),
QUERY_GROUP_ERROR("20016", "查询群组失败"),
MEMBER_NOT_FOUND("20017", "没有该成员"),
GROUP_MSG_ERROR("20018", "发送群组消息失败"),
LEAVE_GROUP_ERROR("20019", "退群失败"),
ROOM_CLOSED_ERROR("20020", "房间已经关闭"),
HAS_BEEN_BLOCKED("20021", "已经被拉黑，无法进入房间"),
OWNER_LEAVE_GROUP("20022", "群主不能退出群"),
USER_STREAM_EXISTS("300010", "该用户已经创建流"),
STREAM_SUPPLIER_NOT_FOUND("300011", "流供应商没有找到"),
STREAM_PUSH_FORBID("300012", "已被禁流"),
STREAM_ERROR("300013", "流操作失败"),
STREAM_NOT_FOUND("300013", "流id不存在"),
NOT_SUPPORT("300014", "功能暂不支持"),
MIX_STREAM_ERROR("300015", "混流失败"),
STREAM_CHANGE_TYPE_ERROR("300016","上报流改变类型错误"),
PARSE_STREAM_ERROR("300017","解析流失败"),
MIX_STOP_STREAM_ERROR("300016", "取消混流失败"),
NOT_HAVE_USABLE_SUPPLIER("300018", "无可用供应商"),
PRODUCT_NOT_FOUND("400010", "没有该产品"),
PRODUCT_IM_MODEL_ERROR("400011", "imModule错误"),
IM_CONFIG_ERROR("400013", "im配置错误'"),
SUPPLIER_NOT_FOUND("400014", "没有该供应商"),
BALANCE_NOT_ENOUGH("300100", "账户钻石不足"),
NOT_FREE_GIFT("300102", "该礼物不是免费礼物"),
IS_FREE_GIFT("300103", "该礼物不是付费礼物"),
GIFT_TYPE_ERROR("300104","礼物类型错误"),
GIFT_PRICE_ERROR("300105","礼物价格错误"),
FREE_GIFT_IN_TIME("300106", "免费礼物还在倒计时中,请耐心等候..."),
INVALID_GIFT("300107", "礼物已下架，换一个吧！"),
EXPIRED_GIFT("300108", "礼物已过期，请重新打开礼物面板刷新"),
GIFT_ACTIVITY_END("300109", "该礼物的活动已结束"),
PAY_ERROR("300101","支付失败"),
USER_NOT_EXISTS("300110", "用户不存在"),
USER_STATUS_ERROR("300111","用户状态异常"),
Gift_NOT_EXISTS("300112", "礼物不存在"),
Gift_CURRENT_TYPE_ERROR("300113", "礼物支付类型错误"),
TO_UID_NOT_IN_CHATROOM("300114","被打赏人不在聊天室"),
NO_GAME_READY_START("500010", "当前没有游戏准备开始"),
GAME_NUM_ENOUGH("500011", "游戏人数已满"),
GAME_CANCELED("500012", "对方已取消游戏"),
GAME_NOT_FOUND("500013", "游戏没有找到"),
GAME_NOT_FOUND_NOT_NOTIFY("500013", ""),
GAME_NOT_TEAMING_STATUS_ERROR("500014", "游戏不在组队中"),
GAME_INVITE_ERROR("500015", "麦位已满,暂无法邀请用户上麦游戏"),
GAME_END_ERROR("500016", "游戏已经结束"),
GAME_MIC_ERROR("500017", "麦位已满"),
CALL_GAME_ERROR("500018", "调用游戏失败"),
GAME_LIVING_ERROR("500019", "当前房间游戏中，结束后才可发起新游戏"),
START_GAME_ERROR("500020", "发起游戏失败"),
INVOKE_EXCEPTION("99999", "调用异常"),
/**
* web rtc
*/
MULTI_MEDIA_FAILED_CUR_ONLINE("300400","通话正在进行,请结束当前通话"),
MULTI_MEDIA_FAILED_TARGET_ONLINE("300401","对方正在通话,请稍后重试"),
MULTI_MEDIA_FAILED_CUR_VIDEO_TYPE("300402","当前模式正是视频模式"),
MULTI_MEDIA_FAILED_CUR_VERSION_NOT_SUPPORT("300403","对方版本不支持"),
MULTI_MEDIA_FAILED_CUR_USER_NOT_SUPPORT("300404","当前用户不支持该功能"),
MULTI_MEDIA_FAILED_CUR_MEDIA_NOT_EXIST("300405","当前通话不存在"),
MULTI_MEDIA_FAILED_CUR_USER_NOT_POWER("300406","当前用户没有权限"),
MULTI_MEDIA_FAILED_CUR_MEDIA_OPERATE_NOT_EXIST("300407","当前操作不存在"),
MULTI_MEDIA_FAILED_TARGET_USER_NOT_ONLINE("300408","对方暂时未在线"),
;
private String code;
private String message;
ExceptionCode(String code, String message){
this.code = code;
this.message = message;
}
@Override
public String getCode() {
return code;
}
@Override
public String getMessage() {
return message;
}
public Response getFailResponse(){
return Response.fail(this.getCode(),this.getMessage());
}
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/dto/MediaRoomInfoDTO.java | sona-console/src/main/java/cn/bixin/sona/console/domain/dto/MediaRoomInfoDTO.java | package cn.bixin.sona.console.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class MediaRoomInfoDTO implements Serializable {
/**
* 房间id
*/
private String roomId;
/**
* 云商类型
*/
private String cloudType;
/**
* 拉流模式
*/
private String pullStreamType;
/**
* 流地址
*/
private String streamUrl;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/dto/ChatroomStreamDTO.java | sona-console/src/main/java/cn/bixin/sona/console/domain/dto/ChatroomStreamDTO.java | package cn.bixin.sona.console.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class ChatroomStreamDTO implements Serializable {
/**
* 房间id
*/
private String roomId;
/**
* 用户uid
*/
private String uid;
/**
* 流状态 -1=初始化 0=关闭 1=打开
*/
private int status;
/**
* 回放地址 录制地址
*/
private String replayUrl;
/**
* 来源 ZEGO/TECENT 云商
*/
private String source;
/**
* 流开始时间
*/
private String beginTime;
/**
* 流结束时间
*/
private String endTime;
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/dto/StreamRecordDTO.java | sona-console/src/main/java/cn/bixin/sona/console/domain/dto/StreamRecordDTO.java | package cn.bixin.sona.console.domain.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class StreamRecordDTO implements Serializable {
private Long uid;
private String streamId;
private int status;
private String replayUrl;
private Date beginTime;
private Date endTime;
private int source;
private Long roomId;
private Long id;
private int limit;
private Long anchor;
}
| java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/dto/SwitchBatchRecordDTO.java | sona-console/src/main/java/cn/bixin/sona/console/domain/dto/SwitchBatchRecordDTO.java | package cn.bixin.sona.console.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class SwitchBatchRecordDTO implements Serializable {
private static final long serialVersionUID = -2096671673412479497L;
private Long id;
private Integer switchType;
private String streamSupplier;
private String pullMode;
private String fileUrl;
private Integer status;
private String operator;
private String createTime;
private String updateTime;
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/db/SwitchBatch.java | sona-console/src/main/java/cn/bixin/sona/console/domain/db/SwitchBatch.java | package cn.bixin.sona.console.domain.db;
import java.util.Date;
import lombok.Data;
/**
* 热切批次信息表
*/
@Data
public class SwitchBatch {
/**
* 主键ID
*/
private Long id;
/**
* 状态：0，1-手动，2-自动
*/
private Integer switchType;
/**
* 流供应商
*/
private String streamSupplier;
/**
* 拉流模式
*/
private String pullMode;
/**
* 文件地址
*/
private String fileUrl;
/**
* 状态：0-进行，1-完成，2-失败
*/
private Integer status;
/**
* 操作人
*/
private String operator;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
BixinTech/sona | https://github.com/BixinTech/sona/blob/96b4d7bafa534c8d0173abab992d61e4dbcfab47/sona-console/src/main/java/cn/bixin/sona/console/domain/db/RoomConfig.java | sona-console/src/main/java/cn/bixin/sona/console/domain/db/RoomConfig.java | package cn.bixin.sona.console.domain.db;
import java.util.Date;
import lombok.Data;
/**
* 房间配置表
*/
@Data
public class RoomConfig {
/**
* 房间ID
*/
private Long roomId;
/**
* 产品码
*/
private String productCode;
/**
* im模块 CHATROOM=聊天室 GROUP=群组
*/
private String imModule;
/**
* 流供应商
*/
private String streamSupplier;
/**
* 流类型 AUDIO=音频 VIDEO=视频
*/
private String type;
/**
* 推流模式
*/
private String pushMode;
/**
* 拉流模式
*/
private String pullMode;
/**
* 是否下发进房消息
*/
private Byte enterNotifySwitch;
/**
* 是否校验管理员 0=否 1=是
*/
private Byte checkAdmin;
/**
* 是否需要回放功能 0=否 1=是
*/
private Byte needReplay;
/**
* 客户端类型 1=weblink 2=commonlink 3=wechatlink
*/
private Byte clientType;
/**
* 播放器码率
*/
private Integer bitrate;
/**
* 1=短连 2=长连
*/
private Byte imSendType;
/**
* 产品短码
*/
private String shortCode;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
} | java | Apache-2.0 | 96b4d7bafa534c8d0173abab992d61e4dbcfab47 | 2026-01-05T02:40:29.261548Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.