) in.readObject();
+ totalLength = in.readLong();
+ }
+}
diff --git a/src/main/java/org/openautonomousconnection/protocol/side/client/ProtocolClient.java b/src/main/java/org/openautonomousconnection/protocol/side/client/ProtocolClient.java
index 532f31b..25fab66 100644
--- a/src/main/java/org/openautonomousconnection/protocol/side/client/ProtocolClient.java
+++ b/src/main/java/org/openautonomousconnection/protocol/side/client/ProtocolClient.java
@@ -30,6 +30,11 @@ public abstract class ProtocolClient extends DefaultMethodsOverrider {
*/
private NetworkClient clientToINS;
+ /**
+ * Handles everything with WebServer-Connection.
+ */
+ private NetworkClient clientToWeb;
+
/**
* Manages the folder structure for client certificates.
*/
@@ -41,9 +46,13 @@ public abstract class ProtocolClient extends DefaultMethodsOverrider {
@Getter
private ProtocolBridge protocolBridge;
/**
- * Stores the protocol version of the connected server.
+ * Stores the protocol version of the connected insserver.
*/
- private ProtocolVersion serverVersion = null;
+ private ProtocolVersion insServerVersion = null;
+ /**
+ * Stores the protocol version of the connected webserver.
+ */
+ private ProtocolVersion webServerVersion = null;
/**
* Initializes the ProtocolClient, setting up certificate folders and the INS client connection.
@@ -64,6 +73,53 @@ public abstract class ProtocolClient extends DefaultMethodsOverrider {
build();
}
+ /**
+ * Connects to a WebServer.
+ *
+ * @param host WebServer host
+ * @param port WebServer port
+ */
+ public final void connectToWebServer(String host, int port) {
+ if (!protocolBridge.isRunningAsClient())
+ throw new IllegalStateException("Not running as client");
+
+ if (clientToWeb != null && clientToWeb.isConnected())
+ return;
+
+ createWebClient(host, port);
+ }
+
+ /**
+ * Gets the WebServer connection client.
+ *
+ * @return the NetworkClient handling the WebServer connection.
+ */
+ public final NetworkClient getClientWebConnection() {
+ return clientToWeb;
+ }
+
+ /**
+ * Initialize connection to WebServer
+ *
+ * @param host WebServer host
+ * @param port WebServer port
+ */
+ private final void createWebClient(String host, int port) {
+ clientToWeb = new NetworkClient.ClientBuilder()
+ .setLogger(protocolBridge.getLogger())
+ .setProxy(protocolBridge.getProxy())
+ .setHost(host)
+ .setPort(port)
+ .setPacketHandler(protocolBridge.getProtocolSettings().packetHandler)
+ .setEventManager(protocolBridge.getProtocolSettings().eventManager)
+ .setRootCAFolder(folderStructure.publicCAFolder)
+ .setClientCertificatesFolder(
+ folderStructure.publicClientFolder,
+ folderStructure.privateClientFolder
+ )
+ .build();
+ }
+
/**
* Injects the ProtocolBridge.
* @param bridge the Bridge instance.
@@ -125,148 +181,293 @@ public abstract class ProtocolClient extends DefaultMethodsOverrider {
*
* @return the ProtocolVersion of the server, or PV_1_0_0_CLASSIC if not set.
*/
- public final ProtocolVersion getServerVersion() {
- return serverVersion == null ? ProtocolVersion.PV_1_0_0_CLASSIC : serverVersion;
+ public final ProtocolVersion getWebServerVersion() {
+ return webServerVersion == null ? ProtocolVersion.PV_1_0_0_CLASSIC : webServerVersion;
}
/**
* Sets the protocol version of the connected server.
*
- * @param serverVersion the ProtocolVersion to set for the server.
+ * @param webServerVersion the ProtocolVersion to set for the server.
*/
- public final void setServerVersion(ProtocolVersion serverVersion) {
- if (serverVersion == null) this.serverVersion = serverVersion;
+ public final void setWebServerVersion(ProtocolVersion webServerVersion) {
+ if (webServerVersion == null) this.webServerVersion = insServerVersion;
}
/**
- * Handles INS disconnection events, resetting the server version and closing the web client connection if necessary.
+ * Gets the protocol version of the connected server.
+ *
+ * @return the ProtocolVersion of the server, or PV_1_0_0_CLASSIC if not set.
+ */
+ public final ProtocolVersion getInsServerVersion() {
+ return insServerVersion == null ? ProtocolVersion.PV_1_0_0_CLASSIC : insServerVersion;
+ }
+
+ /**
+ * Sets the protocol version of the connected server.
+ *
+ * @param insServerVersion the ProtocolVersion to set for the server.
+ */
+ public final void setInsServerVersion(ProtocolVersion insServerVersion) {
+ if (insServerVersion == null) this.insServerVersion = insServerVersion;
+ }
+
+ /**
+ * Handles disconnect events, resetting the server version and closing the web client connection if necessary.
*
* @param event the ClientDisconnectedEvent triggered on INS disconnection.
*/
- public final void onINSDisconnect(ClientDisconnectedEvent event) {
+ public final void onDisconnect(ClientDisconnectedEvent event) {
// Reset server version on INS disconnect
- serverVersion = null;
+ if (!clientToINS.isConnected()) {
+ insServerVersion = null;
+ disconnectFromWebServer();
+ }
+
+ if (!clientToWeb.isConnected()) webServerVersion = null;
}
/**
- * Checks if the connected server is a stable server.
+ * Checks if the connected insserver is a stable server.
*
* @return true if the server is stable, false otherwise.
*/
- public final boolean isStableServer() {
+ public final boolean isINSStableServer() {
// Check if the server version is stable
- return !isBetaServer() && !isClassicServer();
+ return !isINSBetaServer() && !isINSClassicServer();
}
/**
- * Checks if the connected server or its compatible versions support stable protocol.
+ * Checks if the connected insserver or its compatible versions support stable protocol.
*
* @return true if stable protocol is supported, false otherwise.
*/
- public final boolean supportServerStable() {
+ public final boolean supportINSServerStable() {
boolean yes = false;
- for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+ for (ProtocolVersion compatibleVersion : getWebServerVersion().getCompatibleVersions()) {
// Check if compatible version is stable
yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.STABLE;
if (yes) break;
}
// Check if the server version is stable
- return isStableServer() || yes;
+ return isINSStableServer() || yes;
}
/**
- * Checks if the connected server is a beta server.
+ * Checks if the connected insserver is a beta server.
*
* @return true if the server is beta, false otherwise.
*/
- public final boolean isBetaServer() {
+ public final boolean isINSBetaServer() {
// Check if the server version is beta
- return getServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+ return getInsServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.BETA;
}
/**
- * Checks if the connected server or its compatible versions support beta protocol.
+ * Checks if the connected insserver or its compatible versions support beta protocol.
*
* @return true if beta protocol is supported, false otherwise.
*/
- public final boolean supportServerBeta() {
+ public final boolean supportINSServerBeta() {
boolean yes = false;
- for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+ for (ProtocolVersion compatibleVersion : getInsServerVersion().getCompatibleVersions()) {
// Check if compatible version is beta
yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.BETA;
if (yes) break;
}
// Check if the server version is beta
- return isBetaServer() || yes;
+ return isINSBetaServer() || yes;
}
/**
- * Checks if the connected server is a classic server.
+ * Checks if the connected insserver is a classic server.
*
* @return true if the server is classic, false otherwise.
*/
- public final boolean isClassicServer() {
+ public final boolean isINSClassicServer() {
// Check if the server version is classic
- return getServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+ return getInsServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
}
/**
- * Checks if the connected server or its compatible versions support classic protocol.
+ * Checks if the connected insserver or its compatible versions support classic protocol.
*
* @return true if classic protocol is supported, false otherwise.
*/
- public final boolean supportServerClassic() {
+ public final boolean supportINSServerClassic() {
boolean yes = false;
- for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+ for (ProtocolVersion compatibleVersion : getInsServerVersion().getCompatibleVersions()) {
// Check if compatible version is classic
yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
if (yes) break;
}
// Check if the server version is classic
- return isClassicServer() || yes;
+ return isINSClassicServer() || yes;
}
/**
- * Checks if the connected server supports the protocol version of the given packet.
+ * Checks if the connected insserver supports the protocol version of the given packet.
*
* @param packet the OACPacket to check against the server's supported protocol version.
* @return true if the server supports the packet's protocol version, false otherwise.
*/
- public final boolean supportServerPacket(OACPacket packet) {
+ public final boolean supportINSServerPacket(OACPacket packet) {
// Check if the server supports the protocol version of the packet
- return supportServerVersion(packet.getProtocolVersion());
+ return supportINSServerVersion(packet.getProtocolVersion());
}
/**
- * Checks if the connected server or its compatible versions support the specified protocol version.
+ * Checks if the connected insserver or its compatible versions support the specified protocol version.
*
* @param targetVersion the ProtocolVersion to check for support.
* @return true if the server or its compatible versions support the target version, false otherwise.
*/
- public final boolean supportServerVersion(ProtocolVersion targetVersion) {
+ public final boolean supportINSServerVersion(ProtocolVersion targetVersion) {
// Directly check if the server version matches or is in the list of compatible versions
- return getServerVersion() == targetVersion || getServerVersion().getCompatibleVersions().contains(targetVersion);
+ return getInsServerVersion() == targetVersion || getInsServerVersion().getCompatibleVersions().contains(targetVersion);
}
/**
- * Checks if the connected server or its compatible versions support the specified protocol.
+ * Checks if the connected insserver or its compatible versions support the specified protocol.
*
* @param protocol the Protocol to check for support.
* @return true if the server or its compatible versions support the protocol, false otherwise.
*/
- public final boolean supportServerProtocol(ProtocolVersion.Protocol protocol) {
+ public final boolean supportINSServerProtocol(ProtocolVersion.Protocol protocol) {
boolean yes = false;
- for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+ for (ProtocolVersion compatibleVersion : getInsServerVersion().getCompatibleVersions()) {
// Check if compatible version supports the protocol
yes = compatibleVersion.getSupportedProtocols().contains(protocol);
if (yes) break;
}
// Check if the server version supports the protocol
- return getServerVersion().getSupportedProtocols().contains(protocol) || yes;
+ return getInsServerVersion().getSupportedProtocols().contains(protocol) || yes;
+ }
+
+ //fwfwef
+ /**
+ * Checks if the connected webserver is a stable server.
+ *
+ * @return true if the server is stable, false otherwise.
+ */
+ public final boolean isWebStableServer() {
+ // Check if the server version is stable
+ return !isWebBetaServer() && !isWebClassicServer();
+ }
+
+ /**
+ * Checks if the connected webserver or its compatible versions support stable protocol.
+ *
+ * @return true if stable protocol is supported, false otherwise.
+ */
+ public final boolean supportWebServerStable() {
+ boolean yes = false;
+ for (ProtocolVersion compatibleVersion : getWebServerVersion().getCompatibleVersions()) {
+ // Check if compatible version is stable
+ yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.STABLE;
+ if (yes) break;
+ }
+
+ // Check if the server version is stable
+ return isWebBetaServer() || yes;
+ }
+
+ /**
+ * Checks if the connected webserver is a beta server.
+ *
+ * @return true if the server is beta, false otherwise.
+ */
+ public final boolean isWebBetaServer() {
+ // Check if the server version is beta
+ return getWebServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+ }
+
+ /**
+ * Checks if the connected webserver or its compatible versions support beta protocol.
+ *
+ * @return true if beta protocol is supported, false otherwise.
+ */
+ public final boolean supportWebServerBeta() {
+ boolean yes = false;
+ for (ProtocolVersion compatibleVersion : getWebServerVersion().getCompatibleVersions()) {
+ // Check if compatible version is beta
+ yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+ if (yes) break;
+ }
+
+ // Check if the server version is beta
+ return isWebStableServer() || yes;
+ }
+
+ /**
+ * Checks if the connected webserver is a classic server.
+ *
+ * @return true if the server is classic, false otherwise.
+ */
+ public final boolean isWebClassicServer() {
+ // Check if the server version is classic
+ return getWebServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+ }
+
+ /**
+ * Checks if the connected webserver or its compatible versions support classic protocol.
+ *
+ * @return true if classic protocol is supported, false otherwise.
+ */
+ public final boolean supportWebServerClassic() {
+ boolean yes = false;
+ for (ProtocolVersion compatibleVersion : getWebServerVersion().getCompatibleVersions()) {
+ // Check if compatible version is classic
+ yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+ if (yes) break;
+ }
+
+ // Check if the server version is classic
+ return isWebClassicServer() || yes;
+ }
+
+ /**
+ * Checks if the connected webserver supports the protocol version of the given packet.
+ *
+ * @param packet the OACPacket to check against the server's supported protocol version.
+ * @return true if the server supports the packet's protocol version, false otherwise.
+ */
+ public final boolean supportWebServerPacket(OACPacket packet) {
+ // Check if the server supports the protocol version of the packet
+ return supportWebServerVersion(packet.getProtocolVersion());
+ }
+
+ /**
+ * Checks if the connected webserver or its compatible versions support the specified protocol version.
+ *
+ * @param targetVersion the ProtocolVersion to check for support.
+ * @return true if the server or its compatible versions support the target version, false otherwise.
+ */
+ public final boolean supportWebServerVersion(ProtocolVersion targetVersion) {
+ // Directly check if the server version matches or is in the list of compatible versions
+ return getWebServerVersion() == targetVersion || getWebServerVersion().getCompatibleVersions().contains(targetVersion);
+ }
+
+ /**
+ * Checks if the connected webserver or its compatible versions support the specified protocol.
+ *
+ * @param protocol the Protocol to check for support.
+ * @return true if the server or its compatible versions support the protocol, false otherwise.
+ */
+ public final boolean supportWebServerProtocol(ProtocolVersion.Protocol protocol) {
+ boolean yes = false;
+ for (ProtocolVersion compatibleVersion : getWebServerVersion().getCompatibleVersions()) {
+ // Check if compatible version supports the protocol
+ yes = compatibleVersion.getSupportedProtocols().contains(protocol);
+ if (yes) break;
+ }
+
+ // Check if the server version supports the protocol
+ return getWebServerVersion().getSupportedProtocols().contains(protocol) || yes;
}
/**
@@ -289,6 +490,17 @@ public abstract class ProtocolClient extends DefaultMethodsOverrider {
onQuerySent(tln, name, sub, type);
}
+ /**
+ * Disconnects from the WebServer.
+ */
+ public final void disconnectFromWebServer() {
+ if (clientToWeb != null) {
+ clientToWeb.disconnect();
+ clientToWeb = null;
+ }
+ }
+
+
/**
* Called when the client receives an INS response from the server.
*
diff --git a/src/main/java/org/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolWebServerEvent.java b/src/main/java/org/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolWebServerEvent.java
new file mode 100644
index 0000000..2fea6a2
--- /dev/null
+++ b/src/main/java/org/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolWebServerEvent.java
@@ -0,0 +1,25 @@
+package org.openautonomousconnection.protocol.side.client.events;
+
+import dev.unlegitdqrk.unlegitlibrary.event.impl.Event;
+import lombok.Getter;
+import org.openautonomousconnection.protocol.annotations.ProtocolInfo;
+import org.openautonomousconnection.protocol.side.client.ProtocolClient;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+
+/**
+ * Event triggered when a client successfully connects to a INS protocol server.
+ */
+@ProtocolInfo(protocolSide = ProtocolVersion.ProtocolSide.INS)
+public final class ConnectedToProtocolWebServerEvent extends Event {
+
+ /**
+ * Reference to the ProtocolClient object.
+ */
+ @Getter
+ private final ProtocolClient client;
+
+ public ConnectedToProtocolWebServerEvent(ProtocolClient client) {
+ this.client = client;
+ }
+
+}
diff --git a/src/main/java/org/openautonomousconnection/protocol/side/web/ConnectedWebClient.java b/src/main/java/org/openautonomousconnection/protocol/side/web/ConnectedWebClient.java
index 87839c9..aa0d556 100644
--- a/src/main/java/org/openautonomousconnection/protocol/side/web/ConnectedWebClient.java
+++ b/src/main/java/org/openautonomousconnection/protocol/side/web/ConnectedWebClient.java
@@ -1,11 +1,13 @@
package org.openautonomousconnection.protocol.side.web;
import dev.unlegitdqrk.unlegitlibrary.network.system.server.ConnectionHandler;
-import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
import lombok.Getter;
import org.openautonomousconnection.protocol.packets.OACPacket;
import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebRequestPacket;
import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebResponsePacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebStreamChunkPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebStreamEndPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebStreamStartPacket;
import org.openautonomousconnection.protocol.versions.ProtocolVersion;
import javax.net.ssl.SSLSocket;
@@ -14,8 +16,7 @@ import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
- * A connected web client using pure OAC packets.
- * No HTTP, no GET/POST, no header parsing.
+ * A connected web client using pure protocol packets.
*/
public final class ConnectedWebClient {
@@ -28,13 +29,11 @@ public final class ConnectedWebClient {
@Getter
private ProtocolWebServer server;
- /**
- * The protocol version of the connected client.
- */
+ private ObjectOutputStream out;
+ private ObjectInputStream in;
+
private ProtocolVersion clientVersion = null;
- /**
- * Indicates if the client version has been loaded.
- */
+
@Getter
private boolean clientVersionLoaded = false;
@@ -44,46 +43,6 @@ public final class ConnectedWebClient {
this.pipelineConnection = pipelineConnection;
}
- public void attachWebServer(SSLSocket socket, ProtocolWebServer server) {
- if (this.webSocket != null) return;
-
- this.webSocket = socket;
- this.server = server;
-
- this.receiveThread = new Thread(this::receiveLoop, "OAC-WebClient-Receiver");
- this.receiveThread.start();
- }
-
- private void receiveLoop() {
- try {
- ObjectInputStream in = new ObjectInputStream(webSocket.getInputStream());
- ObjectOutputStream out = new ObjectOutputStream(webSocket.getOutputStream());
-
- PacketHandler handler = server.getProtocolBridge().getProtocolSettings().packetHandler;
-
- while (!webSocket.isClosed() && pipelineConnection.isConnected()) {
-
- Object obj = in.readObject();
- if (!(obj instanceof OACPacket packet)) continue;
-
- if (packet instanceof WebRequestPacket requestPacket) {
-
- WebResponsePacket response =
- server.onWebRequest(this, requestPacket);
-
- if (response != null) {
- out.writeObject(response);
- out.flush();
- }
- }
- }
-
- } catch (Exception ignored) {
- } finally {
- disconnect();
- }
- }
-
public boolean isConnected() {
return webSocket != null &&
webSocket.isConnected() &&
@@ -91,25 +50,72 @@ public final class ConnectedWebClient {
pipelineConnection.isConnected();
}
+ public void attachWebServer(SSLSocket socket, ProtocolWebServer server) throws IOException {
+ if (this.webSocket != null) return;
+
+ this.webSocket = socket;
+ this.server = server;
+
+ // IMPORTANT: ObjectOutputStream first, flush, then ObjectInputStream
+ this.out = new ObjectOutputStream(webSocket.getOutputStream());
+ this.out.flush();
+ this.in = new ObjectInputStream(webSocket.getInputStream());
+
+ this.receiveThread = new Thread(this::receiveLoop, "OAC-WebClient-Receiver");
+ this.receiveThread.start();
+ }
+
+ private void receiveLoop() {
+ try {
+ while (isConnected()) {
+ Object obj = in.readObject();
+ if (!(obj instanceof OACPacket packet)) continue;
+
+ if (packet instanceof WebRequestPacket req) {
+ // server decides whether it returns normal response or does streaming itself
+ WebResponsePacket resp = server.onWebRequest(this, req);
+ if (resp != null) send(resp);
+ }
+ }
+ } catch (Exception ignored) {
+ } finally {
+ disconnect();
+ }
+ }
+
+ public synchronized void send(Object packet) throws IOException {
+ if (!isConnected()) return;
+ out.writeObject(packet);
+ out.flush();
+ }
+
+ public synchronized void streamStart(WebStreamStartPacket start) throws IOException {
+ send(start);
+ }
+
+ public synchronized void streamChunk(WebStreamChunkPacket chunk) throws IOException {
+ send(chunk);
+ }
+
+ public synchronized void streamEnd(WebStreamEndPacket end) throws IOException {
+ send(end);
+ }
+
public synchronized void disconnect() {
- try {
- server.onDisconnect(this);
- clientVersionLoaded = false;
- clientVersion = null;
- } catch (Exception ignored) {}
+ try { server.onDisconnect(this); } catch (Exception ignored) {}
- try {
- pipelineConnection.disconnect();
- } catch (Exception ignored) {}
+ try { pipelineConnection.disconnect(); } catch (Exception ignored) {}
- try {
- if (webSocket != null) webSocket.close();
- } catch (IOException ignored) {}
+ try { if (in != null) in.close(); } catch (Exception ignored) {}
+ try { if (out != null) out.close(); } catch (Exception ignored) {}
+ try { if (webSocket != null) webSocket.close(); } catch (Exception ignored) {}
+ in = null;
+ out = null;
webSocket = null;
}
- /**
+/**
* Gets the protocol version of the connected client.
*
* @return The protocol version of the client, defaults to PV_1_0_0_CLASSIC if not set.
diff --git a/src/main/java/org/openautonomousconnection/protocol/side/web/ProtocolWebServer.java b/src/main/java/org/openautonomousconnection/protocol/side/web/ProtocolWebServer.java
index a50d39b..b6427b9 100644
--- a/src/main/java/org/openautonomousconnection/protocol/side/web/ProtocolWebServer.java
+++ b/src/main/java/org/openautonomousconnection/protocol/side/web/ProtocolWebServer.java
@@ -10,6 +10,7 @@ import org.openautonomousconnection.protocol.ProtocolBridge;
import org.openautonomousconnection.protocol.annotations.ProtocolInfo;
import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebRequestPacket;
import org.openautonomousconnection.protocol.packets.v1_0_0.beta.WebResponsePacket;
+import org.openautonomousconnection.protocol.side.web.events.WebClientConnectedEvent;
import org.openautonomousconnection.protocol.side.web.managers.AuthManager;
import org.openautonomousconnection.protocol.side.web.managers.RuleManager;
import org.openautonomousconnection.protocol.versions.ProtocolVersion;
@@ -252,6 +253,7 @@ public abstract class ProtocolWebServer {
if (connectedWebClient.getPipelineConnection().getClientID() != -1 && connectedWebClient.isClientVersionLoaded()) {
// Assign socket to an existing connected client
connectedWebClient.attachWebServer(client, this);
+ protocolBridge.getProtocolSettings().eventManager.executeEvent(new WebClientConnectedEvent(connectedWebClient));
}
}
} catch (IOException e) {
diff --git a/src/main/java/org/openautonomousconnection/protocol/side/web/events/ConnectedWebClientEvent.java b/src/main/java/org/openautonomousconnection/protocol/side/web/events/WebClientConnectedEvent.java
similarity index 84%
rename from src/main/java/org/openautonomousconnection/protocol/side/web/events/ConnectedWebClientEvent.java
rename to src/main/java/org/openautonomousconnection/protocol/side/web/events/WebClientConnectedEvent.java
index 6a2cfd4..567e0e8 100644
--- a/src/main/java/org/openautonomousconnection/protocol/side/web/events/ConnectedWebClientEvent.java
+++ b/src/main/java/org/openautonomousconnection/protocol/side/web/events/WebClientConnectedEvent.java
@@ -10,7 +10,7 @@ import org.openautonomousconnection.protocol.versions.ProtocolVersion;
* Event triggered when a web client connects to the web server.
*/
@ProtocolInfo(protocolSide = ProtocolVersion.ProtocolSide.WEB)
-public final class ConnectedWebClientEvent extends Event {
+public final class WebClientConnectedEvent extends Event {
/**
* The connected web client.
@@ -18,7 +18,7 @@ public final class ConnectedWebClientEvent extends Event {
@Getter
private final ConnectedWebClient webClient;
- public ConnectedWebClientEvent(ConnectedWebClient webClient) {
+ public WebClientConnectedEvent(ConnectedWebClient webClient) {
this.webClient = webClient;
}
}