add better way to handle invalid exceptions

Author: JavaSaBr

README.md

@@ -14,7 +14,7 @@ repositories {
 }
 
 ext {
- rlibVersion = "10.0.alpha7"
+ rlibVersion = "10.0.alpha8"
 }
 
 dependencies {

build.gradle

@@ -1,4 +1,4 @@
-rootProject.version = "10.0.alpha7"
+rootProject.version = "10.0.alpha8"
 group = 'javasabr.rlib'
 
 allprojects {

rlib-network/src/loadTest/java/javasabr/rlib/network/StringNetworkLoadTest.java

@@ -67,7 +67,7 @@ void connectAndSendMessages(
  ThreadUtils.sleep(random.nextInt(5000));
  StringDataConnection connection = network.connect(serverAddress);
 
- connection.onReceive((serverConnection, packet) -> statistics
+ connection.onReceiveValidPacket((serverConnection, packet) -> statistics
  .receivedServerPackersPerSecond()
  .accumulate(1));
 
@@ -141,7 +141,7 @@ void testServerWithMultiplyClients() {
  InetSocketAddress serverAddress = serverNetwork.start();
 
  serverNetwork.onAccept(accepted -> accepted
- .onReceive((connection, packet) -> {
+ .onReceiveValidPacket((connection, packet) -> {
  StringReadableNetworkPacket<StringDataConnection> receivedPacket = (StringReadableNetworkPacket<StringDataConnection>) packet;
  statistics
  .receivedClientPackersPerSecond()

rlib-network/src/loadTest/java/javasabr/rlib/network/StringSslNetworkLoadTest.java

@@ -70,7 +70,7 @@ void connectAndSendMessages(
  ThreadUtils.sleep(random.nextInt(5000));
  StringDataSslConnection connection = network.connect(serverAddress);
 
- connection.onReceive((serverConnection, packet) -> statistics
+ connection.onReceiveValidPacket((serverConnection, packet) -> statistics
  .receivedServerPackersPerSecond()
  .accumulate(1));
 
@@ -150,7 +150,7 @@ void testServerWithMultiplyClients() {
  InetSocketAddress serverAddress = serverNetwork.start();
 
  serverNetwork.onAccept(accepted -> accepted
- .onReceive((connection, packet) -> {
+ .onReceiveValidPacket((connection, packet) -> {
  StringReadableNetworkPacket<StringDataSslConnection> receivedPacket = (StringReadableNetworkPacket<StringDataSslConnection>) packet;
  statistics
  .receivedClientPackersPerSecond()

rlib-network/src/main/java/javasabr/rlib/network/Connection.java

@@ -13,10 +13,10 @@
  */
 public interface Connection<C extends Connection<C>> {
 
- record ReceivedPacketEvent<C, R>(C connection, R packet) {
+ record ReceivedPacketEvent<C, R>(C connection, R packet, boolean valid) {
  @Override
  public String toString() {
- return "[" + connection + "|" + packet + ']';
+ return "[" + connection + '|' + packet + '|' + valid + ']';
  }
  }
 
@@ -53,9 +53,14 @@ public String toString() {
  CompletableFuture<Boolean> sendWithFeedback(WritableNetworkPacket<C> packet);
 
  /**
- * Register a consumer to handle received packets.
+ * Register a consumer to handle received valid packets.
  */
- void onReceive(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer);
+ void onReceiveValidPacket(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer);
+
+ /**
+ * Register a consumer to handle received invalid packets.
+ */
+ void onReceiveInvalidPacket(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer);
 
  /**
  * Get a stream of received packet events.
@@ -72,15 +77,29 @@ default <R extends ReadableNetworkPacket<C>> Flux<ReceivedPacketEvent<C, R>> rec
  }
 
  /**
- * Get a stream of received packets.
+ * Get a stream of received valid packets.
+ */
+ Flux<? extends ReadableNetworkPacket<C>> receivedValidPackets();
+
+ /**
+ * Get a stream of received invalid packets.
  */
- Flux<? extends ReadableNetworkPacket<C>> receivedPackets();
+ Flux<? extends ReadableNetworkPacket<C>> receivedInvalidPackets();
+
+ /**
+ * Get a stream of received valid packets with expected type.
+ */
+ default <R extends ReadableNetworkPacket<C>> Flux<R> receivedValidPackets(Class<R> packetType) {
+ return receivedValidPackets()
+ .filter(packetType::isInstance)
+ .map(networkPacket -> (R) networkPacket);
+ }
 
  /**
- * Get a stream of received packets with expected type.
+ * Get a stream of received invalid packets with expected type.
  */
- default <R extends ReadableNetworkPacket<C>> Flux<R> receivedPackets(Class<R> packetType) {
- return receivedPackets()
+ default <R extends ReadableNetworkPacket<C>> Flux<R> receivedInvalidPackets(Class<R> packetType) {
+ return receivedInvalidPackets()
  .filter(packetType::isInstance)
  .map(networkPacket -> (R) networkPacket);
  }

rlib-network/src/main/java/javasabr/rlib/network/exception/MalformedProtocolException.java

@@ -1,6 +1,6 @@
 package javasabr.rlib.network.exception;
 
-public class MalformedProtocolException extends RuntimeException {
+public class MalformedProtocolException extends NetworkException {
  public MalformedProtocolException(String message) {
  super(message);
  }

rlib-network/src/main/java/javasabr/rlib/network/exception/NetworkException.java

@@ -0,0 +1,16 @@
+package javasabr.rlib.network.exception;
+
+public class NetworkException extends RuntimeException {
+
+ protected NetworkException(String message) {
+ super(message);
+ }
+
+ protected NetworkException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ protected NetworkException(Throwable cause) {
+ super(cause);
+ }
+}

rlib-network/src/main/java/javasabr/rlib/network/exception/UserDefinedNetworkException.java

@@ -0,0 +1,15 @@
+package javasabr.rlib.network.exception;
+
+public class UserDefinedNetworkException extends NetworkException {
+ protected UserDefinedNetworkException(String message) {
+ super(message);
+ }
+
+ protected UserDefinedNetworkException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ protected UserDefinedNetworkException(Throwable cause) {
+ super(cause);
+ }
+}

rlib-network/src/main/java/javasabr/rlib/network/impl/AbstractConnection.java

@@ -62,7 +62,8 @@ public WritablePacketWithFeedback(CompletableFuture<Boolean> attachment, Writabl
  final StampedLock lock;
  final AtomicBoolean closed;
 
- final MutableArray<BiConsumer<C, ? super ReadableNetworkPacket<C>>> subscribers;
+ final MutableArray<BiConsumer<C, ? super ReadableNetworkPacket<C>>> validPacketSubscribers;
+ final MutableArray<BiConsumer<C, ? super ReadableNetworkPacket<C>>> invalidPacketSubscribers;
 
  final int maxPacketsByRead;
 
@@ -81,7 +82,8 @@ public AbstractConnection(
  this.pendingPackets = DequeFactory.arrayBasedBased(WritableNetworkPacket.class);
  this.network = network;
  this.closed = new AtomicBoolean(false);
- this.subscribers = ArrayFactory.copyOnModifyArray(BiConsumer.class);
+ this.validPacketSubscribers = ArrayFactory.copyOnModifyArray(BiConsumer.class);
+ this.invalidPacketSubscribers = ArrayFactory.copyOnModifyArray(BiConsumer.class);
  this.remoteAddress = String.valueOf(NetworkUtils.getRemoteAddress(channel));
  }
 
@@ -93,8 +95,14 @@ public void onConnected() {}
  protected abstract NetworkPacketWriter packetWriter();
 
  @Override
- public void onReceive(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer) {
- subscribers.add(consumer);
+ public void onReceiveValidPacket(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer) {
+ validPacketSubscribers.add(consumer);
+ packetReader().startRead();
+ }
+
+ @Override
+ public void onReceiveInvalidPacket(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer) {
+ invalidPacketSubscribers.add(consumer);
  packetReader().startRead();
  }
 
@@ -104,26 +112,43 @@ public void onReceive(BiConsumer<C, ? super ReadableNetworkPacket<C>> consumer)
  }
 
  @Override
- public Flux<? extends ReadableNetworkPacket<C>> receivedPackets() {
- return Flux.create(this::registerFluxOnReceivedPackets);
+ public Flux<? extends ReadableNetworkPacket<C>> receivedValidPackets() {
+ return Flux.create(this::registerFluxOnReceivedValidPackets);
+ }
+
+ @Override
+ public Flux<? extends ReadableNetworkPacket<C>> receivedInvalidPackets() {
+ return Flux.create(this::registerFluxOnReceivedInvalidPackets);
  }
 
  protected void registerFluxOnReceivedEvents(
  FluxSink<ReceivedPacketEvent<C, ? extends ReadableNetworkPacket<C>>> sink) {
 
- BiConsumer<C, ReadableNetworkPacket<C>> listener =
+ BiConsumer<C, ReadableNetworkPacket<C>> validListener =
  (connection, packet) -> sink.next(new ReceivedPacketEvent<>(connection,
- packet));
+ packet, true));
+ BiConsumer<C, ReadableNetworkPacket<C>> invalidListener =
+ (connection, packet) -> sink.next(new ReceivedPacketEvent<>(connection,
+ packet, true));
+
 
- onReceive(listener);
+ onReceiveValidPacket(validListener);
+ onReceiveInvalidPacket(invalidListener);
 
- sink.onDispose(() -> subscribers.remove(listener));
+ sink.onDispose(() -> validPacketSubscribers.remove(validListener));
+ sink.onDispose(() -> invalidPacketSubscribers.remove(invalidListener));
  }
 
- protected void registerFluxOnReceivedPackets(FluxSink<? super ReadableNetworkPacket<C>> sink) {
+ protected void registerFluxOnReceivedValidPackets(FluxSink<? super ReadableNetworkPacket<C>> sink) {
  BiConsumer<C, ReadableNetworkPacket<C>> listener = (connection, packet) -> sink.next(packet);
- onReceive(listener);
- sink.onDispose(() -> subscribers.remove(listener));
+ onReceiveValidPacket(listener);
+ sink.onDispose(() -> validPacketSubscribers.remove(listener));
+ }
+
+ protected void registerFluxOnReceivedInvalidPackets(FluxSink<? super ReadableNetworkPacket<C>> sink) {
+ BiConsumer<C, ReadableNetworkPacket<C>> listener = (connection, packet) -> sink.next(packet);
+ onReceiveInvalidPacket(listener);
+ sink.onDispose(() -> invalidPacketSubscribers.remove(listener));
  }
 
  @Nullable
@@ -169,9 +194,16 @@ public boolean closed() {
 
  protected void serializedPacket(WritableNetworkPacket<?> packet) {}
 
- protected void handleReceivedPacket(ReadableNetworkPacket<C> packet) {
- log.debug(packet, remoteAddress, "Handle received packet:[%s] from:[%s]"::formatted);
- subscribers
+ protected void handleReceivedValidPacket(ReadableNetworkPacket<C> packet) {
+ log.debug(packet, remoteAddress, "Handle received valid packet:[%s] from:[%s]"::formatted);
+ validPacketSubscribers
+ .iterations()
+ .forEach((C) this, packet, BiConsumer::accept);
+ }
+
+ protected void handleReceivedInvalidPacket(ReadableNetworkPacket<C> packet) {
+ log.debug(packet, remoteAddress, "Handle failed received packet:[%s] from:[%s]"::formatted);
+ invalidPacketSubscribers
  .iterations()
  .forEach((C) this, packet, BiConsumer::accept);
  }

rlib-network/src/main/java/javasabr/rlib/network/impl/DefaultDataConnection.java

@@ -44,7 +44,8 @@ protected NetworkPacketReader createPacketReader() {
  return new DefaultNetworkPacketReader<>(
  (C) this,
  this::updateLastActivity,
- this::handleReceivedPacket,
+ this::handleReceivedValidPacket,
+ this::handleReceivedInvalidPacket,
  value -> createReadablePacket(),
  packetLengthHeaderSize,
  maxPacketsByRead);