diff --git a/application/src/main/java/javasabr/mqtt/broker/application/config/MqttBrokerSpringConfig.java b/application/src/main/java/javasabr/mqtt/broker/application/config/MqttBrokerSpringConfig.java index ec1610c2..eb4c4470 100644 --- a/application/src/main/java/javasabr/mqtt/broker/application/config/MqttBrokerSpringConfig.java +++ b/application/src/main/java/javasabr/mqtt/broker/application/config/MqttBrokerSpringConfig.java @@ -5,11 +5,11 @@ import javasabr.mqtt.model.MqttProperties; import javasabr.mqtt.model.MqttServerConnectionConfig; import javasabr.mqtt.model.QoS; -import javasabr.mqtt.network.MqttClientFactory; import javasabr.mqtt.network.MqttConnection; import javasabr.mqtt.network.MqttConnectionFactory; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUserFactory; import javasabr.mqtt.service.AuthenticationService; import javasabr.mqtt.service.ClientIdRegistry; import javasabr.mqtt.service.ConnectionService; @@ -19,14 +19,14 @@ import javasabr.mqtt.service.PublishReceivingService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.TopicService; -import javasabr.mqtt.service.handler.client.ExternalMqttClientReleaseHandler; +import javasabr.mqtt.service.handler.client.ExternalNetworkMqttUserReleaseHandler; import javasabr.mqtt.service.impl.DefaultConnectionService; import javasabr.mqtt.service.impl.DefaultMessageOutFactoryService; import javasabr.mqtt.service.impl.DefaultMqttConnectionFactory; import javasabr.mqtt.service.impl.DefaultPublishDeliveringService; import javasabr.mqtt.service.impl.DefaultPublishReceivingService; import javasabr.mqtt.service.impl.DefaultTopicService; -import javasabr.mqtt.service.impl.ExternalMqttClientFactory; +import javasabr.mqtt.service.impl.ExternalNetworkMqttUserFactory; import javasabr.mqtt.service.impl.FileCredentialsSource; import javasabr.mqtt.service.impl.InMemoryClientIdRegistry; import javasabr.mqtt.service.impl.InMemorySubscriptionService; @@ -195,7 +195,7 @@ MqttInMessageHandler unsubscribeMqttInMessageHandler( @Bean ConnectionService externalMqttConnectionService(Collection inMessageHandlers) { - return new DefaultConnectionService(ExternalMqttClient.class, inMessageHandlers); + return new DefaultConnectionService(ExternalNetworkMqttUser.class, inMessageHandlers); } @Bean @@ -265,11 +265,11 @@ PublishReceivingService publishReceivingService( } @Bean - MqttClientReleaseHandler externalMqttClientReleaseHandler( + NetworkMqttUserReleaseHandler externalMqttClientReleaseHandler( ClientIdRegistry clientIdRegistry, MqttSessionService sessionService, SubscriptionService subscriptionService) { - return new ExternalMqttClientReleaseHandler(clientIdRegistry, sessionService, subscriptionService); + return new ExternalNetworkMqttUserReleaseHandler(clientIdRegistry, sessionService, subscriptionService); } @Bean @@ -352,16 +352,16 @@ ServerNetworkConfig externalNetworkConfig( } @Bean - MqttClientFactory externalClientFactory(MqttClientReleaseHandler externalMqttClientReleaseHandler) { - return new ExternalMqttClientFactory(externalMqttClientReleaseHandler); + NetworkMqttUserFactory externalClientFactory(NetworkMqttUserReleaseHandler externalNetworkMqttUserReleaseHandler) { + return new ExternalNetworkMqttUserFactory(externalNetworkMqttUserReleaseHandler); } @Bean MqttConnectionFactory externalConnectionFactory( MqttServerConnectionConfig externalServerConnectionConfig, - MqttClientFactory externalClientFactory, + NetworkMqttUserFactory mqttUserFactory, @Value("${mqtt.external.connection.max.packets.by.read:100}") int maxPacketsByRead) { - return new DefaultMqttConnectionFactory(externalServerConnectionConfig, externalClientFactory, maxPacketsByRead); + return new DefaultMqttConnectionFactory(externalServerConnectionConfig, mqttUserFactory, maxPacketsByRead); } @Bean diff --git a/application/src/test/groovy/javasabr/mqtt/broker/application/IntegrationSpecification.groovy b/application/src/test/groovy/javasabr/mqtt/broker/application/IntegrationSpecification.groovy index 49960d17..70bf8dde 100644 --- a/application/src/test/groovy/javasabr/mqtt/broker/application/IntegrationSpecification.groovy +++ b/application/src/test/groovy/javasabr/mqtt/broker/application/IntegrationSpecification.groovy @@ -10,6 +10,7 @@ import javasabr.mqtt.model.MqttServerConnectionConfig import javasabr.mqtt.model.MqttVersion import javasabr.mqtt.network.MqttConnection import javasabr.mqtt.network.MqttMockClient +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser import org.springframework.beans.factory.annotation.Autowired import org.springframework.test.context.junit.jupiter.SpringJUnitConfig import spock.lang.Specification @@ -18,8 +19,6 @@ import java.nio.charset.StandardCharsets import java.util.concurrent.atomic.AtomicInteger import java.util.concurrent.atomic.AtomicReference -import static javasabr.mqtt.network.MqttClient.UnsafeMqttClient - @SpringJUnitConfig(classes = MqttBrokerTestConfig) class IntegrationSpecification extends Specification { @@ -153,7 +152,7 @@ class IntegrationSpecification extends Specification { isSupported(MqttVersion.MQTT_3_1_1) >> true serverConnectionConfig() >> serverConnConfig clientConnectionConfig() >> clientConnConfig - client() >> Stub(UnsafeMqttClient) { + user() >> Stub(ConfigurableNetworkMqttUser) { connectionConfig() >> clientConnConfig connection() >> connectionRef.get() clientId() >> clientId @@ -181,7 +180,7 @@ class IntegrationSpecification extends Specification { isSupported(MqttVersion.MQTT_3_1_1) >> true serverConnectionConfig() >> serverConnConfig clientConnectionConfig() >> clientConnConfig - client() >> Stub(UnsafeMqttClient) { + user() >> Stub(ConfigurableNetworkMqttUser) { connectionConfig() >> clientConnConfig connection() >> connectionRef.get() clientId() >> clientId diff --git a/application/src/test/groovy/javasabr/mqtt/broker/application/service/SubscriptionServiceTest.groovy b/application/src/test/groovy/javasabr/mqtt/broker/application/service/SubscriptionServiceTest.groovy index fe36ef53..7fa776e7 100644 --- a/application/src/test/groovy/javasabr/mqtt/broker/application/service/SubscriptionServiceTest.groovy +++ b/application/src/test/groovy/javasabr/mqtt/broker/application/service/SubscriptionServiceTest.groovy @@ -4,7 +4,7 @@ import com.hivemq.client.mqtt.datatypes.MqttQos import com.hivemq.client.mqtt.mqtt5.exceptions.Mqtt5SubAckException import javasabr.mqtt.broker.application.IntegrationSpecification import javasabr.mqtt.model.topic.TopicName -import javasabr.mqtt.network.MqttClient +import javasabr.mqtt.network.user.NetworkMqttUser import javasabr.mqtt.service.ClientIdRegistry import javasabr.mqtt.service.impl.InMemorySubscriptionService import org.springframework.beans.factory.annotation.Autowired @@ -38,11 +38,11 @@ class SubscriptionServiceTest extends IntegrationSpecification { .findSubscribers(topicName) then: "should find the subscriber" subscribers.size() == 1 - subscribers.get(0).user() instanceof MqttClient + subscribers.get(0).user() instanceof NetworkMqttUser when: def matchedSubscriber = subscribers.get(0) def subscription = matchedSubscriber.subscription() - def owner = matchedSubscriber.user() as MqttClient + def owner = matchedSubscriber.user() as NetworkMqttUser then: owner.clientId() == clientId subscription.topicFilter().rawTopic() == topicFilter @@ -61,11 +61,11 @@ class SubscriptionServiceTest extends IntegrationSpecification { .findSubscribers(topicName) then: "should find the reconnected subscriber" subscribers3.size() == 1 - subscribers3.get(0).user() instanceof MqttClient + subscribers3.get(0).user() instanceof NetworkMqttUser when: matchedSubscriber = subscribers3.get(0) subscription = matchedSubscriber.subscription() - owner = matchedSubscriber.user() as MqttClient + owner = matchedSubscriber.user() as NetworkMqttUser then: owner.clientId() == clientId subscription.topicFilter().rawTopic() == topicFilter @@ -147,8 +147,8 @@ class SubscriptionServiceTest extends IntegrationSpecification { def subscribers = subscriptionService.findSubscribers(TopicName.valueOf(topicName)) then: subscribers.size() == targetCount - (subscribers[0].user() as MqttClient).clientId() == clientId1 - (subscribers[1].user() as MqttClient).clientId() == clientId2 + (subscribers[0].user() as NetworkMqttUser).clientId() == clientId1 + (subscribers[1].user() as NetworkMqttUser).clientId() == clientId2 cleanup: subscriber1.disconnect().join() subscriber2.disconnect().join() diff --git a/application/src/test/resources/log4j2.xml b/application/src/test/resources/log4j2.xml index 8cbe6688..1c8d6108 100644 --- a/application/src/test/resources/log4j2.xml +++ b/application/src/test/resources/log4j2.xml @@ -6,7 +6,7 @@ - + diff --git a/core-service/src/main/java/javasabr/mqtt/service/MessageOutFactoryService.java b/core-service/src/main/java/javasabr/mqtt/service/MessageOutFactoryService.java index 76acd42d..9f051ad1 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/MessageOutFactoryService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/MessageOutFactoryService.java @@ -1,12 +1,12 @@ package javasabr.mqtt.service; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.message.out.factory.MqttMessageOutFactory; public interface MessageOutFactoryService { - MqttMessageOutFactory resolveFactory(MqttClient client); + MqttMessageOutFactory resolveFactory(NetworkMqttUser user); MqttMessageOutFactory resolveFactory(MqttConnection connection); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/PublishReceivingService.java b/core-service/src/main/java/javasabr/mqtt/service/PublishReceivingService.java index 09eaa5c7..02fdf553 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/PublishReceivingService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/PublishReceivingService.java @@ -1,9 +1,9 @@ package javasabr.mqtt.service; import javasabr.mqtt.model.publishing.Publish; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.user.NetworkMqttUser; public interface PublishReceivingService { - void processPublish(MqttClient client, Publish publish); + void processPublish(NetworkMqttUser user, Publish publish); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/SubscriptionService.java b/core-service/src/main/java/javasabr/mqtt/service/SubscriptionService.java index 3286984a..9b009e0c 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/SubscriptionService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/SubscriptionService.java @@ -7,8 +7,8 @@ import javasabr.mqtt.model.subscription.Subscription; import javasabr.mqtt.model.topic.TopicFilter; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.rlib.collections.array.Array; import javasabr.rlib.collections.array.MutableArray; @@ -17,7 +17,7 @@ */ public interface SubscriptionService { - MqttClient resolveClient(Subscriber subscriber); + NetworkMqttUser resolveClient(Subscriber subscriber); default Array findSubscribers(TopicName topicName) { return findSubscribersTo(MutableArray.ofType(SingleSubscriber.class), topicName); @@ -28,22 +28,22 @@ default Array findSubscribers(TopicName topicName) { /** * Subscribes MQTT client to listen to topics. * - * @param client MQTT client which requests subscriptions + * @param user MQTT client which requests subscriptions * @param subscriptions the list of request to subscribe topics * @return array of subscribe ack reason codes */ - Array subscribe(MqttClient client, MqttNetworkSession session, Array subscriptions); + Array subscribe(NetworkMqttUser user, MqttNetworkSession session, Array subscriptions); /** * Removes MQTT client from listening to the topics. * - * @param client MQTT client to be removed + * @param user MQTT client to be removed * @param topicFilters topic filters * @return array of unsubscribe ack reason codes */ - Array unsubscribe(MqttClient client, MqttNetworkSession session, Array topicFilters); + Array unsubscribe(NetworkMqttUser user, MqttNetworkSession session, Array topicFilters); - void cleanSubscriptions(MqttClient client, MqttNetworkSession session); + void cleanSubscriptions(NetworkMqttUser user, MqttNetworkSession session); - void restoreSubscriptions(MqttClient client, MqttNetworkSession session); + void restoreSubscriptions(NetworkMqttUser user, MqttNetworkSession session); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/TopicService.java b/core-service/src/main/java/javasabr/mqtt/service/TopicService.java index fa98a1d3..17413d92 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/TopicService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/TopicService.java @@ -2,13 +2,13 @@ import javasabr.mqtt.model.topic.TopicFilter; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.user.NetworkMqttUser; public interface TopicService { - TopicFilter createTopicFilter(MqttClient client, String rawTopicFilter); + TopicFilter createTopicFilter(NetworkMqttUser user, String rawTopicFilter); - boolean isValidTopicFilter(MqttClient client, String rawTopicFilter); + boolean isValidTopicFilter(NetworkMqttUser user, String rawTopicFilter); - TopicName createTopicName(MqttClient client, String rawTopicName); + TopicName createTopicName(NetworkMqttUser user, String rawTopicName); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractMqttClientReleaseHandler.java b/core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractNetworkMqttUserReleaseHandler.java similarity index 58% rename from core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractMqttClientReleaseHandler.java rename to core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractNetworkMqttUserReleaseHandler.java index 992e0e27..f1f11524 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractMqttClientReleaseHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/handler/client/AbstractNetworkMqttUserReleaseHandler.java @@ -1,10 +1,10 @@ package javasabr.mqtt.service.handler.client; import javasabr.mqtt.model.MqttClientConnectionConfig; -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; -import javasabr.mqtt.network.impl.AbstractMqttClient; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; +import javasabr.mqtt.network.impl.AbstractNetworkMqttUser; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; import javasabr.mqtt.service.ClientIdRegistry; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.session.MqttSessionService; @@ -18,40 +18,40 @@ @CustomLog @RequiredArgsConstructor @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) -public abstract class AbstractMqttClientReleaseHandler implements - MqttClientReleaseHandler { +public abstract class AbstractNetworkMqttUserReleaseHandler implements + NetworkMqttUserReleaseHandler { ClientIdRegistry clientIdRegistry; MqttSessionService sessionService; SubscriptionService subscriptionService; @Override - public Mono release(UnsafeMqttClient client) { - var clientId = client.clientId(); + public Mono release(ConfigurableNetworkMqttUser user) { + var clientId = user.clientId(); //noinspection unchecked - return releaseImpl((T) client) + return releaseImpl((T) user) .doOnNext(_ -> log.info(clientId, "[%s] Client was released"::formatted)); } - protected Mono releaseImpl(T client) { + protected Mono releaseImpl(T user) { - String clientId = client.clientId(); - client.clientId(StringUtils.EMPTY); + String clientId = user.clientId(); + user.clientId(StringUtils.EMPTY); if (StringUtils.isEmpty(clientId)) { - log.warning(client.clientId(), "[%s] This client is already released or rejected"::formatted); + log.warning(user.clientId(), "[%s] This client is already released or rejected"::formatted); return Mono.empty(); } - MqttNetworkSession session = client.session(); + MqttNetworkSession session = user.session(); Mono asyncActions = null; if (session != null) { - subscriptionService.cleanSubscriptions(client, session); - MqttClientConnectionConfig connectionConfig = client.connectionConfig(); + subscriptionService.cleanSubscriptions(user, session); + MqttClientConnectionConfig connectionConfig = user.connectionConfig(); if (connectionConfig.sessionsEnabled()) { asyncActions = sessionService.store(clientId, session, connectionConfig.sessionExpiryInterval()); - client.session(null); + user.session(null); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalMqttClientReleaseHandler.java b/core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalNetworkMqttUserReleaseHandler.java similarity index 63% rename from core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalMqttClientReleaseHandler.java rename to core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalNetworkMqttUserReleaseHandler.java index 0cbfa708..66f57870 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalMqttClientReleaseHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/handler/client/ExternalNetworkMqttUserReleaseHandler.java @@ -1,13 +1,14 @@ package javasabr.mqtt.service.handler.client; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.service.ClientIdRegistry; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.session.MqttSessionService; -public class ExternalMqttClientReleaseHandler extends AbstractMqttClientReleaseHandler { +public class ExternalNetworkMqttUserReleaseHandler extends + AbstractNetworkMqttUserReleaseHandler { - public ExternalMqttClientReleaseHandler( + public ExternalNetworkMqttUserReleaseHandler( ClientIdRegistry clientIdRegistry, MqttSessionService sessionService, SubscriptionService subscriptionService) { diff --git a/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultConnectionService.java b/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultConnectionService.java index 7ad86fb6..6b9a1f4f 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultConnectionService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultConnectionService.java @@ -2,9 +2,9 @@ import java.util.Collection; import javasabr.mqtt.model.message.MqttMessageType; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.MqttConnection; import javasabr.mqtt.network.message.in.MqttInMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.ConnectionService; import javasabr.mqtt.service.message.handler.MqttInMessageHandler; import javasabr.rlib.network.packet.ReadableNetworkPacket; @@ -17,16 +17,16 @@ @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class DefaultConnectionService implements ConnectionService { - Class expectedClientType; + Class expectedUserType; @Nullable MqttInMessageHandler[] inMessageHandlers; - public DefaultConnectionService(Class expectedClientType, + public DefaultConnectionService(Class expectedUserType, Collection knownInMessageHandlers) { - this.expectedClientType = expectedClientType; + this.expectedUserType = expectedUserType; int highestPacketType = knownInMessageHandlers .stream() - .filter(handler -> expectedClientType.isAssignableFrom(handler.expectedClientType())) + .filter(handler -> expectedUserType.isAssignableFrom(handler.expectedUserType())) .map(MqttInMessageHandler::messageType) .mapToInt(MqttMessageType::typeIndex) .max() @@ -35,8 +35,8 @@ public DefaultConnectionService(Class expectedClientType, var inMessageHandlers = new MqttInMessageHandler[highestPacketType + 1]; for (MqttInMessageHandler knownInMessageHandler : knownInMessageHandlers) { - Class clientType = knownInMessageHandler.expectedClientType(); - if (!expectedClientType.isAssignableFrom(clientType)) { + Class clientType = knownInMessageHandler.expectedUserType(); + if (!expectedUserType.isAssignableFrom(clientType)) { continue; } MqttMessageType messageType = knownInMessageHandler.messageType(); @@ -47,7 +47,7 @@ public DefaultConnectionService(Class expectedClientType, } this.inMessageHandlers = inMessageHandlers; - log.info(expectedClientType, inMessageHandlers, DefaultConnectionService::buildServiceDescription); + log.info(expectedUserType, inMessageHandlers, DefaultConnectionService::buildServiceDescription); } @Override @@ -67,7 +67,7 @@ protected void processReceivedValidMessage( } log.debug( - connection.client().clientId(), + connection.user().clientId(), mqttInMessage.name(), mqttInMessage, "[%s] Received from client valid message:[%s] %s"::formatted); @@ -91,7 +91,7 @@ protected void processReceivedInvalidMessage( } log.warning( - connection.client().clientId(), + connection.user().clientId(), mqttInMessage.name(), mqttInMessage, "[%s] Received from client invalid message:[%s] %s"::formatted); @@ -106,7 +106,7 @@ protected void processReceivedInvalidMessage( } private static String buildServiceDescription( - Class expectedClientType, + Class expectedClientType, @Nullable MqttInMessageHandler[] inMessageHandlers) { var builder = new StringBuilder(); builder.append("{\n"); diff --git a/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultMessageOutFactoryService.java b/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultMessageOutFactoryService.java index 185163c9..f9f39e24 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultMessageOutFactoryService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/impl/DefaultMessageOutFactoryService.java @@ -3,9 +3,9 @@ import java.util.Collection; import javasabr.mqtt.model.MqttClientConnectionConfig; import javasabr.mqtt.model.MqttVersion; -import javasabr.mqtt.network.MqttClient; -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.message.out.factory.MqttMessageOutFactory; import lombok.AccessLevel; @@ -44,11 +44,11 @@ public DefaultMessageOutFactoryService(Collection connectionConfig.maxTopicLevels()) { - log.warning(client.clientId(), rawTopicFilter, "[%s] Too deep shared topic filter:[%s]"::formatted); + log.warning(user.clientId(), rawTopicFilter, "[%s] Too deep shared topic filter:[%s]"::formatted); return TopicFilter.INVALID_TOPIC_FILTER; } return sharedTopicFilter; } - private TopicFilter createStandardTopicFilter(MqttClient client, String rawTopicFilter) { + private TopicFilter createStandardTopicFilter(NetworkMqttUser user, String rawTopicFilter) { if (!TopicValidator.validateTopicFilter(rawTopicFilter)) { - log.warning(client.clientId(), rawTopicFilter, "[%s] Invalid topic filter:[%s]"::formatted); + log.warning(user.clientId(), rawTopicFilter, "[%s] Invalid topic filter:[%s]"::formatted); return TopicFilter.INVALID_TOPIC_FILTER; } TopicFilter topicFilter = TopicFilter.valueOf(rawTopicFilter); - MqttClientConnectionConfig connectionConfig = client.connectionConfig(); + MqttClientConnectionConfig connectionConfig = user.connectionConfig(); if (topicFilter.levelsCount() > connectionConfig.maxTopicLevels()) { - log.warning(client.clientId(), rawTopicFilter, "[%s] Too deep topic filter:[%s]"::formatted); + log.warning(user.clientId(), rawTopicFilter, "[%s] Too deep topic filter:[%s]"::formatted); return TopicFilter.INVALID_TOPIC_FILTER; } diff --git a/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalMqttClientFactory.java b/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalMqttClientFactory.java deleted file mode 100644 index 666be76f..00000000 --- a/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalMqttClientFactory.java +++ /dev/null @@ -1,22 +0,0 @@ -package javasabr.mqtt.service.impl; - -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; -import javasabr.mqtt.network.MqttClientFactory; -import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; -import javasabr.mqtt.network.impl.ExternalMqttClient; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - -@RequiredArgsConstructor -@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) -public class ExternalMqttClientFactory implements MqttClientFactory { - - MqttClientReleaseHandler releaseHandler; - - @Override - public UnsafeMqttClient newClient(MqttConnection connection) { - return new ExternalMqttClient(connection, releaseHandler); - } -} diff --git a/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalNetworkMqttUserFactory.java b/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalNetworkMqttUserFactory.java new file mode 100644 index 00000000..d66028b6 --- /dev/null +++ b/core-service/src/main/java/javasabr/mqtt/service/impl/ExternalNetworkMqttUserFactory.java @@ -0,0 +1,22 @@ +package javasabr.mqtt.service.impl; + +import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUserFactory; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; +import lombok.experimental.FieldDefaults; + +@RequiredArgsConstructor +@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) +public class ExternalNetworkMqttUserFactory implements NetworkMqttUserFactory { + + NetworkMqttUserReleaseHandler releaseHandler; + + @Override + public ConfigurableNetworkMqttUser createNetworkUser(MqttConnection connection) { + return new ExternalNetworkMqttUser(connection, releaseHandler); + } +} diff --git a/core-service/src/main/java/javasabr/mqtt/service/impl/InMemorySubscriptionService.java b/core-service/src/main/java/javasabr/mqtt/service/impl/InMemorySubscriptionService.java index b5398fd6..aa1a21f7 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/impl/InMemorySubscriptionService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/impl/InMemorySubscriptionService.java @@ -14,8 +14,8 @@ import javasabr.mqtt.model.topic.SharedTopicFilter; import javasabr.mqtt.model.topic.TopicFilter; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.SubscriptionService; import javasabr.rlib.collections.array.Array; import javasabr.rlib.collections.array.ArrayFactory; @@ -38,9 +38,9 @@ public InMemorySubscriptionService() { } @Override - public MqttClient resolveClient(Subscriber subscriber) { + public NetworkMqttUser resolveClient(Subscriber subscriber) { if (subscriber instanceof SingleSubscriber single) { - return (MqttClient) single.user(); + return (NetworkMqttUser) single.user(); } throw new IllegalArgumentException("Unexpected subscriber: " + subscriber); } @@ -54,7 +54,7 @@ public Array findSubscribersTo(MutableArray @Override public Array subscribe( - MqttClient client, + NetworkMqttUser user, MqttNetworkSession session, Array subscriptions) { @@ -63,14 +63,14 @@ public Array subscribe( subscriptions.size()); for (Subscription subscription : subscriptions) { - subscribeResults.add(addSubscription(client, session, subscription)); + subscribeResults.add(addSubscription(user, session, subscription)); } return subscribeResults; } - private SubscribeAckReasonCode addSubscription(MqttClient client, MqttNetworkSession session, Subscription subscription) { - MqttClientConnectionConfig connectionConfig = client.connectionConfig(); + private SubscribeAckReasonCode addSubscription(NetworkMqttUser user, MqttNetworkSession session, Subscription subscription) { + MqttClientConnectionConfig connectionConfig = user.connectionConfig(); TopicFilter topicFilter = subscription.topicFilter(); if (topicFilter.isInvalid()) { return SubscribeAckReasonCode.TOPIC_FILTER_INVALID; @@ -80,7 +80,7 @@ private SubscribeAckReasonCode addSubscription(MqttClient client, MqttNetworkSes return SubscribeAckReasonCode.WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED; } ActiveSubscriptions activeSubscriptions = session.activeSubscriptions(); - SingleSubscriber previous = subscriberTree.subscribe(client, subscription); + SingleSubscriber previous = subscriberTree.subscribe(user, subscription); if (previous != null) { activeSubscriptions.remove(previous.subscription()); } @@ -90,7 +90,7 @@ private SubscribeAckReasonCode addSubscription(MqttClient client, MqttNetworkSes @Override public Array unsubscribe( - MqttClient client, + NetworkMqttUser user, MqttNetworkSession session, Array topicFilters) { @@ -99,16 +99,16 @@ public Array unsubscribe( topicFilters.size()); for (TopicFilter topicFilter : topicFilters) { - unsubscribeResults.add(removeSubscription(client, session, topicFilter)); + unsubscribeResults.add(removeSubscription(user, session, topicFilter)); } return unsubscribeResults; } - private UnsubscribeAckReasonCode removeSubscription(MqttClient client, MqttNetworkSession session, TopicFilter topicFilter) { + private UnsubscribeAckReasonCode removeSubscription(NetworkMqttUser user, MqttNetworkSession session, TopicFilter topicFilter) { if (topicFilter.isInvalid()) { return UnsubscribeAckReasonCode.TOPIC_FILTER_INVALID; - } else if (subscriberTree.unsubscribe(client, topicFilter)) { + } else if (subscriberTree.unsubscribe(user, topicFilter)) { session .activeSubscriptions() .removeByTopicFilter(topicFilter); @@ -119,22 +119,22 @@ private UnsubscribeAckReasonCode removeSubscription(MqttClient client, MqttNetwo } @Override - public void cleanSubscriptions(MqttClient client, MqttNetworkSession session) { + public void cleanSubscriptions(NetworkMqttUser user, MqttNetworkSession session) { Array subscriptions = session .activeSubscriptions() .subscriptions(); for (Subscription subscription : subscriptions) { - subscriberTree.unsubscribe(client, subscription.topicFilter()); + subscriberTree.unsubscribe(user, subscription.topicFilter()); } } @Override - public void restoreSubscriptions(MqttClient client, MqttNetworkSession session) { + public void restoreSubscriptions(NetworkMqttUser user, MqttNetworkSession session) { Array subscriptions = session .activeSubscriptions() .subscriptions(); for (Subscription subscription : subscriptions) { - subscriberTree.subscribe(client, subscription); + subscriberTree.subscribe(user, subscription); } } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/MqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/MqttInMessageHandler.java index cef35042..6758bc47 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/MqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/MqttInMessageHandler.java @@ -1,15 +1,15 @@ package javasabr.mqtt.service.message.handler; import javasabr.mqtt.model.message.MqttMessageType; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.MqttConnection; import javasabr.mqtt.network.message.in.MqttInMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; public interface MqttInMessageHandler { MqttMessageType messageType(); - Class expectedClientType(); + Class expectedUserType(); void processValidMessage(MqttConnection connection, MqttInMessage mqttInMessage); diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/AbstractMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/AbstractMqttInMessageHandler.java index 7e33c717..d7f4b757 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/AbstractMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/AbstractMqttInMessageHandler.java @@ -2,11 +2,11 @@ import javasabr.mqtt.model.exception.MalformedProtocolMqttException; import javasabr.mqtt.model.reason.code.DisconnectReasonCode; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.MqttNetworkSession; import javasabr.mqtt.network.message.in.MqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.network.util.ExtraErrorReasons; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.message.handler.MqttInMessageHandler; @@ -18,16 +18,16 @@ @CustomLog @RequiredArgsConstructor @FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true) -public abstract class AbstractMqttInMessageHandler +public abstract class AbstractMqttInMessageHandler implements MqttInMessageHandler { - Class expectedClient; - Class expectedNetworkPacket; + Class expectedUser; + Class expectedMessage; MessageOutFactoryService messageOutFactoryService; @Override - public Class expectedClientType() { - return expectedClient; + public Class expectedUserType() { + return expectedUser; } protected boolean requireSession() { @@ -36,93 +36,92 @@ protected boolean requireSession() { @Override public void processValidMessage(MqttConnection connection, MqttInMessage mqttInMessage) { - MqttClient client = connection.client(); - if (!expectedClient.isInstance(client)) { - log.warning(client, "Received not expected client:[%s]"::formatted); + NetworkMqttUser user = connection.user(); + if (!expectedUser.isInstance(user)) { + log.warning(user, "Received not expected user:[%s]"::formatted); return; - } else if (!expectedNetworkPacket.isInstance(mqttInMessage)) { - log.warning(mqttInMessage, "Received not expected network packet:[%s]"::formatted); + } else if (!expectedMessage.isInstance(mqttInMessage)) { + log.warning(mqttInMessage, "Received not expected message:[%s]"::formatted); return; } - C castedClient = expectedClient.cast(client); - M castedMessage = expectedNetworkPacket.cast(mqttInMessage); + U castedUser = expectedUser.cast(user); + M castedMessage = expectedMessage.cast(mqttInMessage); if (requireSession()) { - MqttNetworkSession session = client.session(); + MqttNetworkSession session = user.session(); if (session == null) { - log.warning(client.clientId(), "[%s] Session is already closed"::formatted); - handleSessionIsAlreadyClosed(client); + log.warning(user.clientId(), "[%s] Session is already closed"::formatted); + handleSessionIsAlreadyClosed(user); return; } - processValidMessage(connection, castedClient, session, castedMessage); + processValidMessage(connection, castedUser, session, castedMessage); } else { - processValidMessage(connection, castedClient, castedMessage); + processValidMessage(connection, castedUser, castedMessage); } } @Override public void processInvalidMessage(MqttConnection connection, MqttInMessage mqttInMessage) { - MqttClient client = connection.client(); - if (!expectedClient.isInstance(client)) { - log.warning(client, "Received not expected client:[%s]"::formatted); + NetworkMqttUser user = connection.user(); + if (!expectedUser.isInstance(user)) { + log.warning(user, "Received not expected user:[%s]"::formatted); return; - } else if (!expectedNetworkPacket.isInstance(mqttInMessage)) { - log.warning(mqttInMessage, "Received not expected network packet:[%s]"::formatted); + } else if (!expectedMessage.isInstance(mqttInMessage)) { + log.warning(mqttInMessage, "Received not expected message:[%s]"::formatted); return; } - C castedClient = expectedClient.cast(client); - M castedMessage = expectedNetworkPacket.cast(mqttInMessage); + U castedUser = expectedUser.cast(user); + M castedMessage = expectedMessage.cast(mqttInMessage); if (requireSession()) { - MqttNetworkSession session = client.session(); + MqttNetworkSession session = user.session(); if (session == null) { - log.warning(client.clientId(), "[%s] Session is already closed"::formatted); - handleSessionIsAlreadyClosed(client); + log.warning(user.clientId(), "[%s] Session is already closed"::formatted); + handleSessionIsAlreadyClosed(user); return; } - processInvalidMessage(connection, castedClient, session, castedMessage); + processInvalidMessage(connection, castedUser, session, castedMessage); } else { - processInvalidMessage(connection, castedClient, castedMessage); + processInvalidMessage(connection, castedUser, castedMessage); } } - protected void processValidMessage(MqttConnection connection, C client, M message) {} + protected void processValidMessage(MqttConnection connection, U user, M message) {} - protected void processValidMessage(MqttConnection connection, C client, MqttNetworkSession session, M message) {} + protected void processValidMessage(MqttConnection connection, U user, MqttNetworkSession session, M message) {} - protected boolean processInvalidMessage(MqttConnection connection, C client, M message) { + protected boolean processInvalidMessage(MqttConnection connection, U user, M message) { Exception exception = message.exception(); if (exception instanceof MalformedProtocolMqttException) { - malformedProtocolError(connection, client, exception); + malformedProtocolError(connection, user, exception); return true; } return false; } - protected boolean processInvalidMessage(MqttConnection connection, C client, MqttNetworkSession session, M message) { + protected boolean processInvalidMessage(MqttConnection connection, U user, MqttNetworkSession session, M message) { Exception exception = message.exception(); if (exception instanceof MalformedProtocolMqttException) { - malformedProtocolError(connection, client, exception); + malformedProtocolError(connection, user, exception); return true; } return false; } - protected void malformedProtocolError(MqttConnection connection, C client, Exception exception) { + protected void malformedProtocolError(MqttConnection connection, U user, Exception exception) { // send feedback and close connection MqttOutMessage feedback = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.MALFORMED_PACKET, exception.getMessage()); - client - .sendWithFeedback(feedback) + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.MALFORMED_PACKET, exception.getMessage()); + user.sendWithFeedback(feedback) .thenAccept(_ -> connection.close()); } - protected void handleSessionIsAlreadyClosed(MqttClient client) { + protected void handleSessionIsAlreadyClosed(NetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newDisconnect( - client, + user, DisconnectReasonCode.UNSPECIFIED_ERROR, ExtraErrorReasons.SESSION_IS_ALREADY_CLOSED); - client.closeWithReason(response); + user.closeWithReason(response); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/ConnectInMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/ConnectInMqttInMessageHandler.java index 136946a2..c46a1d89 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/ConnectInMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/ConnectInMqttInMessageHandler.java @@ -17,12 +17,12 @@ import javasabr.mqtt.model.exception.ConnectionRejectException; import javasabr.mqtt.model.message.MqttMessageType; import javasabr.mqtt.model.reason.code.ConnectAckReasonCode; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.ConnectMqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; import javasabr.mqtt.service.AuthenticationService; import javasabr.mqtt.service.ClientIdRegistry; import javasabr.mqtt.service.MessageOutFactoryService; @@ -37,7 +37,7 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class ConnectInMqttInMessageHandler - extends AbstractMqttInMessageHandler { + extends AbstractMqttInMessageHandler { ClientIdRegistry clientIdRegistry; AuthenticationService authenticationService; @@ -50,7 +50,7 @@ public ConnectInMqttInMessageHandler( MqttSessionService sessionService, SubscriptionService subscriptionService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, ConnectMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, ConnectMqttInMessage.class, messageOutFactoryService); this.clientIdRegistry = clientIdRegistry; this.authenticationService = authenticationService; this.sessionService = sessionService; @@ -70,34 +70,36 @@ protected boolean requireSession() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, ConnectMqttInMessage message) { - resolveClientConnectionConfig(client, message); + resolveClientConnectionConfig(user, message); authenticationService .auth(message.username(), message.password()) - .flatMap(ifTrue(client, - message, this::registerClient, BAD_USER_NAME_OR_PASSWORD, connectAckReasonCode -> reject(client, connectAckReasonCode))) - .flatMap(ifTrue(client, - message, this::restoreSession, CLIENT_IDENTIFIER_NOT_VALID, connectAckReasonCode -> reject(client, connectAckReasonCode))) + .flatMap(ifTrue( + user, + message, this::registerClient, BAD_USER_NAME_OR_PASSWORD, connectAckReasonCode -> reject(user, connectAckReasonCode))) + .flatMap(ifTrue( + user, + message, this::restoreSession, CLIENT_IDENTIFIER_NOT_VALID, connectAckReasonCode -> reject(user, connectAckReasonCode))) .subscribe(); } - private void reject(ExternalMqttClient client, ConnectAckReasonCode connectAckReasonCode) { - client.send(messageOutFactoryService - .resolveFactory(client) - .newConnectAck(client, connectAckReasonCode)); + private void reject(ExternalNetworkMqttUser user, ConnectAckReasonCode connectAckReasonCode) { + user.send(messageOutFactoryService + .resolveFactory(user) + .newConnectAck(user, connectAckReasonCode)); } - private Mono registerClient(ExternalMqttClient client, ConnectMqttInMessage networkPacket) { + private Mono registerClient(ExternalNetworkMqttUser user, ConnectMqttInMessage networkPacket) { String requestedClientId = networkPacket.clientId(); if (StringUtils.isNotEmpty(requestedClientId)) { return clientIdRegistry .register(requestedClientId) - .map(ifTrue(requestedClientId, client::clientId)); + .map(ifTrue(requestedClientId, user::clientId)); } - MqttVersion mqttVersion = client + MqttVersion mqttVersion = user .connection() .clientConnectionConfig() .mqttVersion(); @@ -111,27 +113,27 @@ private Mono registerClient(ExternalMqttClient client, ConnectMqttInMes .generate() .flatMap(newClientId -> clientIdRegistry .register(newClientId) - .map(ifTrue(newClientId, client::clientId))); + .map(ifTrue(newClientId, user::clientId))); } - private Mono restoreSession(MqttClient.UnsafeMqttClient client, ConnectMqttInMessage packet) { + private Mono restoreSession(ConfigurableNetworkMqttUser user, ConnectMqttInMessage packet) { if (packet.cleanStart()) { return sessionService - .create(client.clientId()) - .flatMap(session -> onConnected(client, packet, session, false)); + .create(user.clientId()) + .flatMap(session -> onConnected(user, packet, session, false)); } else { return sessionService - .restore(client.clientId()) - .flatMap(session -> onConnected(client, packet, session, true)) + .restore(user.clientId()) + .flatMap(session -> onConnected(user, packet, session, true)) .switchIfEmpty(Mono.defer(() -> sessionService - .create(client.clientId()) - .flatMap(session -> onConnected(client, packet, session, false)))); + .create(user.clientId()) + .flatMap(session -> onConnected(user, packet, session, false)))); } } - private void resolveClientConnectionConfig(MqttClient.UnsafeMqttClient client, ConnectMqttInMessage packet) { + private void resolveClientConnectionConfig(ConfigurableNetworkMqttUser user, ConnectMqttInMessage packet) { - MqttConnection connection = client.connection(); + MqttConnection connection = user.connection(); MqttServerConnectionConfig serverConfig = connection.serverConnectionConfig(); // select result keep alive time @@ -176,66 +178,66 @@ private void resolveClientConnectionConfig(MqttClient.UnsafeMqttClient client, C } private Mono onConnected( - MqttClient.UnsafeMqttClient client, - ConnectMqttInMessage packet, + ConfigurableNetworkMqttUser user, + ConnectMqttInMessage message, MqttNetworkSession session, boolean sessionRestored) { - MqttConnection connection = client.connection(); + MqttConnection connection = user.connection(); MqttServerConnectionConfig serverConfig = connection.serverConnectionConfig(); MqttClientConnectionConfig clientConfig = connection.clientConnectionConfig(); // if it was closed in parallel if (connection.closed() && serverConfig.sessionsEnabled()) { // store the session again - return sessionService.store(client.clientId(), session, clientConfig.sessionExpiryInterval()); + return sessionService.store(user.clientId(), session, clientConfig.sessionExpiryInterval()); } - client.session(session); + user.session(session); var connectAck = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newConnectAck( - client, + user, ConnectAckReasonCode.SUCCESS, sessionRestored, - packet.clientId(), - packet.sessionExpiryInterval(), - packet.keepAlive(), - packet.receiveMaxPublishes()); + message.clientId(), + message.sessionExpiryInterval(), + message.keepAlive(), + message.receiveMaxPublishes()); - subscriptionService.restoreSubscriptions(client, session); + subscriptionService.restoreSubscriptions(user, session); - return Mono.fromFuture(client + return Mono.fromFuture(user .sendWithFeedback(connectAck) - .thenApply(result -> onSentConnAck(client, session, result))); + .thenApply(result -> onSentConnAck(user, session, result))); } - private boolean onSentConnAck(MqttClient.UnsafeMqttClient client, MqttNetworkSession session, boolean result) { + private boolean onSentConnAck(ConfigurableNetworkMqttUser user, MqttNetworkSession session, boolean result) { if (!result) { - log.warning(client.clientId(), "Was issue with sending conn ack packet to client:[%s]"::formatted); + log.warning(user.clientId(), "Was issue with sending conn ack packet to client:[%s]"::formatted); return false; } - session.resendPendingPackets(client); + session.resendPendingPackets(user); return true; } @Override protected boolean processInvalidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, ConnectMqttInMessage message) { Exception exception = message.exception(); if (exception instanceof ConnectionRejectException cre) { MqttOutMessage feedback = messageOutFactoryService - .resolveFactory(client) - .newConnectAck(client, cre.reasonCode()); - client.closeWithReason(feedback); + .resolveFactory(user) + .newConnectAck(user, cre.reasonCode()); + user.closeWithReason(feedback); return true; } - return super.processInvalidMessage(connection, client, session, message); + return super.processInvalidMessage(connection, user, session, message); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/DisconnectMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/DisconnectMqttInMessageHandler.java index 32cb6b91..20aebccd 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/DisconnectMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/DisconnectMqttInMessageHandler.java @@ -3,17 +3,17 @@ import javasabr.mqtt.model.message.MqttMessageType; import javasabr.mqtt.model.reason.code.DisconnectReasonCode; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.DisconnectMqttInMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import lombok.CustomLog; @CustomLog -public class DisconnectMqttInMessageHandler extends AbstractMqttInMessageHandler { +public class DisconnectMqttInMessageHandler extends AbstractMqttInMessageHandler { public DisconnectMqttInMessageHandler(MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, DisconnectMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, DisconnectMqttInMessage.class, messageOutFactoryService); } @Override @@ -24,14 +24,14 @@ public MqttMessageType messageType() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, DisconnectMqttInMessage message) { DisconnectReasonCode reasonCode = message.reasonCode(); if (reasonCode == DisconnectReasonCode.NORMAL_DISCONNECTION) { - log.info(client.clientId(), "Disconnect client:[%s]"::formatted); + log.info(user.clientId(), "Disconnect client:[%s]"::formatted); } else { - log.error("Disconnect client:[%s] by error reason:[%s]".formatted(client, reasonCode)); + log.error("Disconnect client:[%s] by error reason:[%s]".formatted(user, reasonCode)); } connection.close(); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PendingOutResponseMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PendingOutResponseMqttInMessageHandler.java index 0a632138..25b518fb 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PendingOutResponseMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PendingOutResponseMqttInMessageHandler.java @@ -2,26 +2,26 @@ import javasabr.mqtt.model.message.TrackableMqttMessage; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.MqttInMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; public abstract class PendingOutResponseMqttInMessageHandler

- extends AbstractMqttInMessageHandler { + extends AbstractMqttInMessageHandler { protected PendingOutResponseMqttInMessageHandler( Class

expectedNetworkPacket, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, expectedNetworkPacket, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, expectedNetworkPacket, messageOutFactoryService); } @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, P message) { - session.updateOutPendingPacket(client, message); + session.updateOutPendingPacket(user, message); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandler.java index 0fed4ff6..904c5859 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandler.java @@ -12,10 +12,10 @@ import javasabr.mqtt.model.topic.TopicName; import javasabr.mqtt.model.topic.TopicValidator; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.PublishMqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishReceivingService; import javasabr.mqtt.service.TopicService; @@ -27,7 +27,7 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class PublishMqttInMessageHandler - extends AbstractMqttInMessageHandler { + extends AbstractMqttInMessageHandler { PublishReceivingService publishReceivingService; TopicService topicService; @@ -36,7 +36,7 @@ public PublishMqttInMessageHandler( PublishReceivingService publishReceivingService, MessageOutFactoryService messageOutFactoryService, TopicService topicService) { - super(ExternalMqttClient.class, PublishMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, PublishMqttInMessage.class, messageOutFactoryService); this.publishReceivingService = publishReceivingService; this.topicService = topicService; } @@ -49,11 +49,11 @@ public MqttMessageType messageType() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, PublishMqttInMessage publishMessage) { - if (!validateBaseFields(connection, client, publishMessage)) { + if (!validateBaseFields(connection, user, publishMessage)) { return; } @@ -61,11 +61,11 @@ protected void processValidMessage( TopicName responseTopicName = null; if (rawResponseTopicName != null) { if (!TopicValidator.validateTopicName(rawResponseTopicName)) { - log.warning(client.clientId(), rawResponseTopicName, "[%s] Provided invalid response TopicName:[%s]"::formatted); - handleInvalidResponseTopicName(client); + log.warning(user.clientId(), rawResponseTopicName, "[%s] Provided invalid response TopicName:[%s]"::formatted); + handleInvalidResponseTopicName(user); return; } - responseTopicName = topicService.createTopicName(client, rawResponseTopicName); + responseTopicName = topicService.createTopicName(user, rawResponseTopicName); } MqttClientConnectionConfig connectionConfig = connection.clientConnectionConfig(); @@ -79,18 +79,18 @@ protected void processValidMessage( if (!providedRawTopicName) { if (topicAlias == MqttProperties.TOPIC_ALIAS_NOT_SET) { - log.warning(client.clientId(), "[%s] Not provided any information about TopicName"::formatted); - handleNotProvidedTopicName(client); + log.warning(user.clientId(), "[%s] Not provided any information about TopicName"::formatted); + handleNotProvidedTopicName(user); return; } else if (topicAlias < MqttProperties.TOPIC_ALIAS_MIN || topicAlias > topicAliasMaxValue) { - log.warning(client.clientId(), topicAlias, "[%s] Provided invalid TopicAlias:[%d]"::formatted); - handleInvalidTopicAlias(client); + log.warning(user.clientId(), topicAlias, "[%s] Provided invalid TopicAlias:[%d]"::formatted); + handleInvalidTopicAlias(user); return; } topicNameByAlias = topicNameMapping.resolve(topicAlias); if (topicNameByAlias == null) { - log.warning(client.clientId(), topicAlias, "[%s] Unknown TopicAlias:[%d]"::formatted); - handleNotProvidedTopicName(client); + log.warning(user.clientId(), topicAlias, "[%s] Unknown TopicAlias:[%d]"::formatted); + handleNotProvidedTopicName(user); return; } } @@ -99,11 +99,11 @@ protected void processValidMessage( if (providedRawTopicName) { if (!TopicValidator.validateTopicName(rawTopicName)) { - handleInvalidTopicName(client, session, publishMessage); - log.warning(client.clientId(), publishMessage.rawTopicName(), "[%s] TopicName:[%s] is invalid"::formatted); + handleInvalidTopicName(user, session, publishMessage); + log.warning(user.clientId(), publishMessage.rawTopicName(), "[%s] TopicName:[%s] is invalid"::formatted); return; } - topicName = topicService.createTopicName(client, rawTopicName); + topicName = topicService.createTopicName(user, rawTopicName); if (topicAlias != MqttProperties.TOPIC_ALIAS_NOT_SET) { topicNameMapping.update(topicAlias, topicName); } @@ -130,112 +130,112 @@ protected void processValidMessage( publishMessage.payloadFormat(), publishMessage.userProperties()); - publishReceivingService.processPublish(client, publish); + publishReceivingService.processPublish(user, publish); } private boolean validateBaseFields( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, PublishMqttInMessage publishMessage) { byte[] payload = publishMessage.payload(); if (payload == null) { - log.warning(client.clientId(), "[%s] Unexpected missed payload"::formatted); + log.warning(user.clientId(), "[%s] Unexpected missed payload"::formatted); return false; } QoS requestedQos = publishMessage.qos(); MqttClientConnectionConfig connectionConfig = connection.clientConnectionConfig(); if (connectionConfig.maxQos().isLowerThan(requestedQos)) { - log.warning(client.clientId(), requestedQos, "[%s] Requested QoS:[%s] is not supported"::formatted); - handleNotSupportedQos(client); + log.warning(user.clientId(), requestedQos, "[%s] Requested QoS:[%s] is not supported"::formatted); + handleNotSupportedQos(user); return false; } boolean retain = publishMessage.retain(); if (retain && !connectionConfig.retainAvailable()) { - log.warning(client.clientId(), "[%s] 'RETAIN' option is not supported"::formatted); - handleNotSupportedRetain(client); + log.warning(user.clientId(), "[%s] 'RETAIN' option is not supported"::formatted); + handleNotSupportedRetain(user); return false; } PayloadFormat payloadFormat = publishMessage.payloadFormat(); if (payloadFormat == PayloadFormat.INVALID) { - log.warning(client.clientId(), "[%s] Provided invalid PayloadFormat"::formatted); - handleInvalidPayloadFormat(client); + log.warning(user.clientId(), "[%s] Provided invalid PayloadFormat"::formatted); + handleInvalidPayloadFormat(user); return false; } long messageExpiryInterval = publishMessage.messageExpiryInterval(); if (messageExpiryInterval != MqttProperties.MESSAGE_EXPIRY_INTERVAL_IS_NOT_SET && messageExpiryInterval < MqttProperties.MESSAGE_EXPIRY_INTERVAL_MIN) { - log.warning(client.clientId(), "[%s] Provided invalid MessageExpiryInterval"::formatted); - handleInvalidMessageExpiryInterval(client); + log.warning(user.clientId(), "[%s] Provided invalid MessageExpiryInterval"::formatted); + handleInvalidMessageExpiryInterval(user); return false; } return true; } - private void handleNotSupportedQos(ExternalMqttClient client) { - client.closeWithReason(messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.QOS_NOT_SUPPORTED)); + private void handleNotSupportedQos(ExternalNetworkMqttUser user) { + user.closeWithReason(messageOutFactoryService + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.QOS_NOT_SUPPORTED)); } - private void handleNotSupportedRetain(ExternalMqttClient client) { - client.closeWithReason(messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.RETAIN_NOT_SUPPORTED)); + private void handleNotSupportedRetain(ExternalNetworkMqttUser user) { + user.closeWithReason(messageOutFactoryService + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.RETAIN_NOT_SUPPORTED)); } - private void handleNotProvidedTopicName(ExternalMqttClient client) { + private void handleNotProvidedTopicName(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.NO_ANY_TOPIC_NANE); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.NO_ANY_TOPIC_NANE); + user.closeWithReason(response); } - private void handleInvalidTopicAlias(ExternalMqttClient client) { + private void handleInvalidTopicAlias(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.TOPIC_ALIAS_INVALID); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.TOPIC_ALIAS_INVALID); + user.closeWithReason(response); } - private void handleInvalidPayloadFormat(ExternalMqttClient client) { + private void handleInvalidPayloadFormat(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.PROVIDED_INVALID_PAYLOAD_FORMAT); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.PROVIDED_INVALID_PAYLOAD_FORMAT); + user.closeWithReason(response); } - private void handleInvalidResponseTopicName(ExternalMqttClient client) { + private void handleInvalidResponseTopicName(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.INVALID_RESPONSE_TOPIC_NAME); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.INVALID_RESPONSE_TOPIC_NAME); + user.closeWithReason(response); } - private void handleInvalidMessageExpiryInterval(ExternalMqttClient client) { + private void handleInvalidMessageExpiryInterval(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.PROVIDED_INVALID_MESSAGE_EXPIRY_INTERVAL); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.PROVIDED_INVALID_MESSAGE_EXPIRY_INTERVAL); + user.closeWithReason(response); } private void handleInvalidTopicName( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, PublishMqttInMessage publishMessage) { int messagedId = publishMessage.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.TOPIC_NAME_INVALID); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.TOPIC_NAME_INVALID); // without messageId we do not need to clean it if (messagedId == MqttProperties.MESSAGE_ID_IS_NOT_SET) { - client.closeWithReason(response); + user.closeWithReason(response); return; } - client + user .closeWithReason(response) .thenAccept(_ -> session .inMessageTracker() diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishReleaseMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishReleaseMqttInMessageHandler.java index 961779e6..815c7e37 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishReleaseMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/PublishReleaseMqttInMessageHandler.java @@ -6,9 +6,9 @@ import javasabr.mqtt.model.session.MessageTacker; import javasabr.mqtt.model.session.ProcessingPublishes; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.PublishReleaseMqttInMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import lombok.AccessLevel; import lombok.CustomLog; @@ -17,10 +17,10 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class PublishReleaseMqttInMessageHandler - extends AbstractMqttInMessageHandler { + extends AbstractMqttInMessageHandler { public PublishReleaseMqttInMessageHandler(MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, PublishReleaseMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, PublishReleaseMqttInMessage.class, messageOutFactoryService); } @Override @@ -31,7 +31,7 @@ public MqttMessageType messageType() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, PublishReleaseMqttInMessage releaseMessage) { @@ -40,18 +40,18 @@ protected void processValidMessage( ProcessingPublishes processingPublishes = session.inProcessingPublishes(); if (releaseMessage.reasonCode() == PublishReleaseReasonCode.PACKET_IDENTIFIER_NOT_FOUND) { - log.warning(client.clientId(), messageId, "[%s] Client doesnt know about messageId:[%d]"::formatted); + log.warning(user.clientId(), messageId, "[%s] Client doesnt know about messageId:[%d]"::formatted); messageTacker.remove(messageId); processingPublishes.remove(releaseMessage); return; } - if (!processingPublishes.apply(client, releaseMessage)) { - handleUnknownMessageId(client, messageId); + if (!processingPublishes.apply(user, releaseMessage)) { + handleUnknownMessageId(user, messageId); } } - private void handleUnknownMessageId(ExternalMqttClient client, int messageId) { + private void handleUnknownMessageId(ExternalNetworkMqttUser client, int messageId) { client.send(messageOutFactoryService .resolveFactory(client) .newPublishCompleted(messageId, PublishCompletedReasonCode.PACKET_IDENTIFIER_NOT_FOUND)); diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandler.java index 2b6e4519..a5f47115 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandler.java @@ -15,10 +15,10 @@ import javasabr.mqtt.model.subscription.Subscription; import javasabr.mqtt.model.topic.TopicFilter; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.SubscribeMqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.TopicService; @@ -32,7 +32,7 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class SubscribeMqttInMessageHandler extends - AbstractMqttInMessageHandler { + AbstractMqttInMessageHandler { private final static Set DISCONNECT_CASES = Set.of( SHARED_SUBSCRIPTIONS_NOT_SUPPORTED, @@ -45,7 +45,7 @@ public SubscribeMqttInMessageHandler( SubscriptionService subscriptionService, MessageOutFactoryService messageOutFactoryService, TopicService topicService) { - super(ExternalMqttClient.class, SubscribeMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, SubscribeMqttInMessage.class, messageOutFactoryService); this.subscriptionService = subscriptionService; this.topicService = topicService; } @@ -58,16 +58,16 @@ public MqttMessageType messageType() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, SubscribeMqttInMessage subscribeMessage) { - MqttClientConnectionConfig connectionConfig = client.connectionConfig(); + MqttClientConnectionConfig connectionConfig = user.connectionConfig(); int messageId = subscribeMessage.messageId(); MessageTacker messageTacker = session.inMessageTracker(); if (messageTacker.stored(messageId) != null) { - log.warning(client.clientId(), messageId, "[%s] MessageId:[%d] is already in use"::formatted); - handleMessageIdIsInUse(client, subscribeMessage); + log.warning(user.clientId(), messageId, "[%s] MessageId:[%d] is already in use"::formatted); + handleMessageIdIsInUse(user, subscribeMessage); return; } @@ -76,22 +76,24 @@ protected void processValidMessage( int subscriptionId = subscribeMessage.subscriptionId(); if (subscriptionId != MqttProperties.SUBSCRIPTION_ID_IS_NOT_SET) { if (!connectionConfig.subscriptionIdAvailable()) { - log.warning(client.clientId(), subscriptionId, + log.warning( + user.clientId(), subscriptionId, "[%s] Provided subscriptionId:[%d] but server doesn't allow it"::formatted); - handleSubscriptionIdNotSupported(client, session, subscribeMessage); + handleSubscriptionIdNotSupported(user, session, subscribeMessage); return; } } Array subscriptions = transformSubscriptions( - connectionConfig, - client, - subscribeMessage.subscriptions(), subscriptionId); + connectionConfig, + user, + subscribeMessage.subscriptions(), + subscriptionId); Array subscribeResults = subscriptionService - .subscribe(client, session, subscriptions); + .subscribe(user, session, subscriptions); - sendSubscribeResults(client, session, subscribeMessage, subscribeResults); + sendSubscribeResults(user, session, subscribeMessage, subscribeResults); SubscribeAckReasonCode anyReasonToDisconnect = subscribeResults .iterations() @@ -99,17 +101,17 @@ protected void processValidMessage( .findAny(DISCONNECT_CASES, Set::contains); if (anyReasonToDisconnect != null) { - log.info(client.clientId(), anyReasonToDisconnect, "[%s] Will be forced closing by reason:[%s]"::formatted); + log.info(user.clientId(), anyReasonToDisconnect, "[%s] Will be forced closing by reason:[%s]"::formatted); DisconnectReasonCode reasonCode = DisconnectReasonCode.ofCode(anyReasonToDisconnect.code()); - client.closeWithReason(messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, reasonCode)); + user.closeWithReason(messageOutFactoryService + .resolveFactory(user) + .newDisconnect(user, reasonCode)); } } private Array transformSubscriptions( MqttClientConnectionConfig connectionConfig, - ExternalMqttClient client, + ExternalNetworkMqttUser user, Array requestedSubscriptions, int subscriptionId) { @@ -118,7 +120,7 @@ private Array transformSubscriptions( ArrayFactory.mutableArray(Subscription.class, requestedSubscriptions.size()); for (RequestedSubscription requested : requestedSubscriptions) { - TopicFilter topicFilter = topicService.createTopicFilter(client, requested.rawTopicFilter()); + TopicFilter topicFilter = topicService.createTopicFilter(user, requested.rawTopicFilter()); QoS resultQos = maxQos.lower(requested.qos()); subscriptions.add(new Subscription( topicFilter, @@ -133,18 +135,18 @@ private Array transformSubscriptions( } private void handleMessageIdIsInUse( - ExternalMqttClient client, + ExternalNetworkMqttUser user, SubscribeMqttInMessage subscribeMessage) { Array subscribeResults = Array.repeated( SubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE, subscribeMessage.subscriptionsCount()); - client.send(messageOutFactoryService - .resolveFactory(client) + user.send(messageOutFactoryService + .resolveFactory(user) .newSubscribeAck(subscribeMessage.messageId(), subscribeResults)); } private void handleSubscriptionIdNotSupported( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, SubscribeMqttInMessage subscribeMessage) { Array subscribeResults = Array.repeated( @@ -152,24 +154,24 @@ private void handleSubscriptionIdNotSupported( subscribeMessage.subscriptionsCount()); int messageId = subscribeMessage.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newSubscribeAck(messageId, subscribeResults); - client.sendWithFeedback(response) + user.sendWithFeedback(response) .thenAccept(_ -> session .inMessageTracker() .remove(messageId)); } private void sendSubscribeResults( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, SubscribeMqttInMessage subscribeMessage, Array subscribeResults) { int messageId = subscribeMessage.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newSubscribeAck(messageId, subscribeResults); - client.sendWithFeedback(response) + user.sendWithFeedback(response) .thenAccept(_ -> session .inMessageTracker() .remove(messageId)); diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandler.java index a8d873fb..fd4b8446 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandler.java @@ -5,10 +5,10 @@ import javasabr.mqtt.model.session.MessageTacker; import javasabr.mqtt.model.topic.TopicFilter; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.UnsubscribeMqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.TopicService; @@ -21,7 +21,7 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) public class UnsubscribeMqttInMessageHandler - extends AbstractMqttInMessageHandler { + extends AbstractMqttInMessageHandler { SubscriptionService subscriptionService; TopicService topicService; @@ -30,7 +30,7 @@ public UnsubscribeMqttInMessageHandler( SubscriptionService subscriptionService, MessageOutFactoryService messageOutFactoryService, TopicService topicService) { - super(ExternalMqttClient.class, UnsubscribeMqttInMessage.class, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, UnsubscribeMqttInMessage.class, messageOutFactoryService); this.subscriptionService = subscriptionService; this.topicService = topicService; } @@ -43,15 +43,15 @@ public MqttMessageType messageType() { @Override protected void processValidMessage( MqttConnection connection, - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, UnsubscribeMqttInMessage unsubscribeMessage) { int messageId = unsubscribeMessage.messageId(); MessageTacker messageTacker = session.inMessageTracker(); if (messageTacker.stored(messageId) != null) { - log.warning(client.clientId(), messageId, "[%s] MessageId:[%d] is already in use"::formatted); - handleMessageIdIsInUse(client, unsubscribeMessage); + log.warning(user.clientId(), messageId, "[%s] MessageId:[%d] is already in use"::formatted); + handleMessageIdIsInUse(user, unsubscribeMessage); return; } @@ -60,30 +60,31 @@ protected void processValidMessage( Array topicFilters = unsubscribeMessage .rawTopicFilters() .stream() - .map(rawTopicFilter -> topicService.createTopicFilter(client, rawTopicFilter)) + .map(rawTopicFilter -> topicService.createTopicFilter(user, rawTopicFilter)) .collect(ArrayCollectors.toArray(TopicFilter.class)); Array unsubscribeResults = subscriptionService - .unsubscribe(client, session, topicFilters); + .unsubscribe(user, session, topicFilters); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newUnsubscribeAck(unsubscribeMessage.messageId(), unsubscribeResults); - client.sendWithFeedback(response) + user + .sendWithFeedback(response) .thenAccept(_ -> session .inMessageTracker() .remove(messageId)); } private void handleMessageIdIsInUse( - ExternalMqttClient client, + ExternalNetworkMqttUser user, UnsubscribeMqttInMessage unsubscribeMessage) { Array unsubscribeResults = Array.repeated( UnsubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE, unsubscribeMessage.topicFiltersCount()); - client.send(messageOutFactoryService - .resolveFactory(client) + user.send(messageOutFactoryService + .resolveFactory(user) .newUnsubscribeAck(unsubscribeMessage.messageId(), unsubscribeResults)); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt311MessageOutFactory.java b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt311MessageOutFactory.java index 67c525bb..97e61c25 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt311MessageOutFactory.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt311MessageOutFactory.java @@ -14,7 +14,6 @@ import javasabr.mqtt.model.reason.code.SubscribeAckReasonCode; import javasabr.mqtt.model.reason.code.UnsubscribeAckReasonCode; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.out.ConnectAckMqtt311OutMessage; import javasabr.mqtt.network.message.out.DisconnectMqtt311OutMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; @@ -27,6 +26,7 @@ import javasabr.mqtt.network.message.out.PublishReleaseMqtt311OutMessage; import javasabr.mqtt.network.message.out.SubscribeAckMqtt311OutMessage; import javasabr.mqtt.network.message.out.UnsubscribeAckMqtt311OutMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.rlib.collections.array.Array; import org.jspecify.annotations.Nullable; @@ -39,7 +39,7 @@ public MqttVersion mqttVersion() { @Override public MqttOutMessage newConnectAck( - MqttClient client, + NetworkMqttUser user, ConnectAckReasonCode reasonCode, boolean sessionPresent, String requestedClientId, @@ -100,7 +100,7 @@ public MqttOutMessage newUnsubscribeAck( @Override public MqttOutMessage newDisconnect( - MqttClient client, + NetworkMqttUser user, DisconnectReasonCode reasonCode, Array userProperties, String reason, diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt5MessageOutFactory.java b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt5MessageOutFactory.java index 22a7758b..f367f19c 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt5MessageOutFactory.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/Mqtt5MessageOutFactory.java @@ -15,7 +15,6 @@ import javasabr.mqtt.model.reason.code.SubscribeAckReasonCode; import javasabr.mqtt.model.reason.code.UnsubscribeAckReasonCode; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.out.AuthenticationMqtt5OutMessage; import javasabr.mqtt.network.message.out.ConnectAckMqtt5OutMessage; import javasabr.mqtt.network.message.out.DisconnectMqtt5OutMessage; @@ -27,6 +26,7 @@ import javasabr.mqtt.network.message.out.PublishReleaseMqtt5OutMessage; import javasabr.mqtt.network.message.out.SubscribeAckMqtt5OutMessage; import javasabr.mqtt.network.message.out.UnsubscribeAckMqtt5OutMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.rlib.collections.array.Array; import org.jspecify.annotations.Nullable; @@ -39,7 +39,7 @@ public MqttVersion mqttVersion() { @Override public MqttOutMessage newConnectAck( - MqttClient client, + NetworkMqttUser user, ConnectAckReasonCode reasonCode, boolean sessionPresent, String requestedClientId, @@ -55,7 +55,7 @@ public MqttOutMessage newConnectAck( return new ConnectAckMqtt5OutMessage( reasonCode, sessionPresent, - client.clientId(), + user.clientId(), requestedClientId, requestedSessionExpiryInterval, requestedKeepAlive, @@ -124,12 +124,12 @@ public MqttOutMessage newUnsubscribeAck( @Override public MqttOutMessage newDisconnect( - MqttClient client, + NetworkMqttUser user, DisconnectReasonCode reasonCode, Array userProperties, String reason, String serverReference) { - MqttClientConnectionConfig connectionConfig = client.connectionConfig(); + MqttClientConnectionConfig connectionConfig = user.connectionConfig(); return new DisconnectMqtt5OutMessage( reasonCode, userProperties, diff --git a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/MqttMessageOutFactory.java b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/MqttMessageOutFactory.java index 55b058b5..32efacf1 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/MqttMessageOutFactory.java +++ b/core-service/src/main/java/javasabr/mqtt/service/message/out/factory/MqttMessageOutFactory.java @@ -6,6 +6,7 @@ import javasabr.mqtt.model.PayloadFormat; import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.data.type.StringPair; +import javasabr.mqtt.model.message.MqttMessage; import javasabr.mqtt.model.reason.code.AuthenticateReasonCode; import javasabr.mqtt.model.reason.code.ConnectAckReasonCode; import javasabr.mqtt.model.reason.code.DisconnectReasonCode; @@ -16,8 +17,8 @@ import javasabr.mqtt.model.reason.code.SubscribeAckReasonCode; import javasabr.mqtt.model.reason.code.UnsubscribeAckReasonCode; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.out.MqttOutMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.rlib.collections.array.Array; import javasabr.rlib.collections.array.MutableArray; import javasabr.rlib.common.util.ArrayUtils; @@ -25,13 +26,11 @@ import org.jspecify.annotations.Nullable; public abstract class MqttMessageOutFactory { - - public static final Array EMPTY_USER_PROPERTIES = Array.empty(StringPair.class); - + public abstract MqttVersion mqttVersion(); public abstract MqttOutMessage newConnectAck( - MqttClient client, + NetworkMqttUser user, ConnectAckReasonCode reasonCode, boolean sessionPresent, String requestedClientId, @@ -46,7 +45,7 @@ public abstract MqttOutMessage newConnectAck( Array userProperties); public MqttOutMessage newConnectAck( - MqttClient client, + NetworkMqttUser user, ConnectAckReasonCode reasonCode, boolean sessionPresent, String requestedClientId, @@ -54,7 +53,7 @@ public MqttOutMessage newConnectAck( int requestedKeepAlive, int requestedReceiveMax) { return newConnectAck( - client, + user, reasonCode, sessionPresent, requestedClientId, @@ -69,7 +68,7 @@ public MqttOutMessage newConnectAck( MutableArray.ofType(StringPair.class)); } - public MqttOutMessage newConnectAck(MqttClient client, ConnectAckReasonCode reasonCode) { + public MqttOutMessage newConnectAck(NetworkMqttUser client, ConnectAckReasonCode reasonCode) { MqttClientConnectionConfig connectionConfig = client.connectionConfig(); return newConnectAck( client, @@ -128,11 +127,11 @@ public abstract MqttOutMessage newPublishAck( Array userProperties); public MqttOutMessage newPublishAck(int messageId, PublishAckReasonCode reasonCode) { - return newPublishAck(messageId, reasonCode, null, EMPTY_USER_PROPERTIES); + return newPublishAck(messageId, reasonCode, null, MqttMessage.EMPTY_USER_PROPERTIES); } public MqttOutMessage newPublishAck(int messageId, PublishAckReasonCode reasonCode, String reason) { - return newPublishAck(messageId, reasonCode, reason, EMPTY_USER_PROPERTIES); + return newPublishAck(messageId, reasonCode, reason, MqttMessage.EMPTY_USER_PROPERTIES); } public abstract MqttOutMessage newSubscribeAck( @@ -142,7 +141,7 @@ public abstract MqttOutMessage newSubscribeAck( Array userProperties); public MqttOutMessage newSubscribeAck(int messageId, Array reasonCodes) { - return newSubscribeAck(messageId, reasonCodes, StringUtils.EMPTY, EMPTY_USER_PROPERTIES); + return newSubscribeAck(messageId, reasonCodes, StringUtils.EMPTY, MqttMessage.EMPTY_USER_PROPERTIES); } public MqttOutMessage newSubscribeAck( @@ -159,7 +158,7 @@ public abstract MqttOutMessage newUnsubscribeAck( String reason); public MqttOutMessage newUnsubscribeAck(int messageId, Array reasonCodes) { - return newUnsubscribeAck(messageId, reasonCodes, EMPTY_USER_PROPERTIES, StringUtils.EMPTY); + return newUnsubscribeAck(messageId, reasonCodes, MqttMessage.EMPTY_USER_PROPERTIES, StringUtils.EMPTY); } public MqttOutMessage newUnsubscribeAck( @@ -170,33 +169,33 @@ public MqttOutMessage newUnsubscribeAck( } public abstract MqttOutMessage newDisconnect( - MqttClient client, + NetworkMqttUser user, DisconnectReasonCode reasonCode, Array userProperties, @Nullable String reason, @Nullable String serverReference); - public MqttOutMessage newDisconnect(MqttClient client, DisconnectReasonCode reasonCode) { + public MqttOutMessage newDisconnect(NetworkMqttUser user, DisconnectReasonCode reasonCode) { return newDisconnect( - client, + user, reasonCode, - EMPTY_USER_PROPERTIES, + MqttMessage.EMPTY_USER_PROPERTIES, null, null); } public MqttOutMessage newDisconnect( - MqttClient client, + NetworkMqttUser client, DisconnectReasonCode reasonCode, Array userProperties) { return newDisconnect(client, reasonCode, userProperties, null, null); } public MqttOutMessage newDisconnect( - MqttClient client, + NetworkMqttUser user, DisconnectReasonCode reasonCode, @Nullable String reason) { - return newDisconnect(client, reasonCode, EMPTY_USER_PROPERTIES, reason, null); + return newDisconnect(user, reasonCode, MqttMessage.EMPTY_USER_PROPERTIES, reason, null); } public abstract MqttOutMessage newAuthenticate( @@ -215,7 +214,7 @@ public MqttOutMessage newAuthenticate( null, authenticateMethod, authenticateData, - EMPTY_USER_PROPERTIES); + MqttMessage.EMPTY_USER_PROPERTIES); } public abstract MqttOutMessage newPingRequest(); @@ -229,7 +228,7 @@ public abstract MqttOutMessage newPublishRelease( String reason); public MqttOutMessage newPublishRelease(int messageId, PublishReleaseReasonCode reasonCode) { - return newPublishRelease(messageId, reasonCode, EMPTY_USER_PROPERTIES, StringUtils.EMPTY); + return newPublishRelease(messageId, reasonCode, MqttMessage.EMPTY_USER_PROPERTIES, StringUtils.EMPTY); } public abstract MqttOutMessage newPublishReceived( @@ -239,7 +238,7 @@ public abstract MqttOutMessage newPublishReceived( @Nullable String reason); public MqttOutMessage newPublishReceived(int messageId, PublishReceivedReasonCode reasonCode) { - return newPublishReceived(messageId, reasonCode, EMPTY_USER_PROPERTIES, null); + return newPublishReceived(messageId, reasonCode, MqttMessage.EMPTY_USER_PROPERTIES, null); } public abstract MqttOutMessage newPublishCompleted( @@ -249,6 +248,6 @@ public abstract MqttOutMessage newPublishCompleted( @Nullable String reason); public MqttOutMessage newPublishCompleted(int messageId, PublishCompletedReasonCode reasonCode) { - return newPublishCompleted(messageId, reasonCode, EMPTY_USER_PROPERTIES, null); + return newPublishCompleted(messageId, reasonCode, MqttMessage.EMPTY_USER_PROPERTIES, null); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/MqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/MqttPublishInMessageHandler.java index 3a9c7543..05eb17ed 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/MqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/MqttPublishInMessageHandler.java @@ -2,11 +2,11 @@ import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.publishing.Publish; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.user.NetworkMqttUser; public interface MqttPublishInMessageHandler { QoS qos(); - void handle(MqttClient client, Publish publish); + void handle(NetworkMqttUser user, Publish publish); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishInMessageHandler.java index 44899c46..97ece02e 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishInMessageHandler.java @@ -2,11 +2,12 @@ import javasabr.mqtt.model.publishing.Publish; import javasabr.mqtt.model.session.MessageTacker; +import javasabr.mqtt.model.session.MqttSession; import javasabr.mqtt.model.subscriber.SingleSubscriber; import javasabr.mqtt.model.topic.TopicName; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.MqttNetworkSession; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishDeliveringService; import javasabr.mqtt.service.SubscriptionService; @@ -21,108 +22,108 @@ @CustomLog @RequiredArgsConstructor @FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true) -public abstract class AbstractMqttPublishInMessageHandler +public abstract class AbstractMqttPublishInMessageHandler implements MqttPublishInMessageHandler { - Class expectedClientType; + Class expectedUserType; SubscriptionService subscriptionService; PublishDeliveringService publishDeliveringService; MessageOutFactoryService messageOutFactoryService; @Override - public void handle(MqttClient client, Publish publish) { - if (!expectedClientType.isInstance(client)) { - log.warning(client.clientId(), client.getClass(), + public void handle(NetworkMqttUser user, Publish publish) { + if (!expectedUserType.isInstance(user)) { + log.warning( + user.clientId(), user.getClass(), "[%s] Not expected client of type:[%s]"::formatted); return; } - C expectedClient = expectedClientType.cast(client); - MqttNetworkSession session = expectedClient.session(); + U expectedUser = expectedUserType.cast(user); + MqttNetworkSession session = expectedUser.session(); if (session == null) { - log.warning(client.clientId(), "[%s] Session is already closed"::formatted); + log.warning(user.clientId(), "[%s] Session is already closed"::formatted); return; } - if (validateImpl(expectedClient, session, publish)) { - handleImpl(expectedClient, session, publish); + if (validateImpl(expectedUser, session, publish)) { + handleImpl(expectedUser, session, publish); } } - protected boolean validateImpl(C client, MqttNetworkSession session, Publish publish) { + protected boolean validateImpl(U user, MqttNetworkSession session, Publish publish) { return true; } - protected void handleImpl(C client, MqttNetworkSession session, Publish publish) { + protected void handleImpl(U user, MqttNetworkSession session, Publish publish) { TopicName topicName = publish.topicName(); Array subscribers = subscriptionService.findSubscribers(topicName); if (subscribers.isEmpty()) { - log.debug(client.clientId(), publish, "[%s] Not found any subscriber for publish: [%s]"::formatted); - handleNoMatchedSubscribers(client, session, publish); + log.debug(user.clientId(), publish, "[%s] Not found any subscriber for publish: [%s]"::formatted); + handleNoMatchedSubscribers(user, session, publish); return; } int count = 0; for (SingleSubscriber subscriber : subscribers) { - PublishHandlingResult checkResult = checkSubscriber(client, publish, subscriber); + PublishHandlingResult checkResult = checkSubscriber(user, publish, subscriber); if (checkResult.error()) { - log.debug(client.clientId(), checkResult, subscriber, + log.debug(user.clientId(), checkResult, subscriber, "[%s] Found error:[%s] for subscriber:[%s] during checking"::formatted); - handleError(client, session, publish, checkResult); + handleError(user, session, publish, checkResult); return; } else if(checkResult == PublishHandlingResult.SUCCESS) { count++; } } - log.debug(client.clientId(), count, + log.debug(user.clientId(), count, "[%s] Started delivering publish to [%s] subscribers"::formatted); - handleSuccess(client, session, publish, count); + handleSuccess(user, session, publish, count); for (SingleSubscriber subscriber : subscribers) { - startDelivering(client, session, publish, subscriber); + startDelivering(user, session, publish, subscriber); } } - protected void handleNoMatchedSubscribers(C client, MqttNetworkSession session, Publish publish) {} + protected void handleNoMatchedSubscribers(U user, MqttNetworkSession session, Publish publish) {} protected void handleSuccess( - C client, + U user, MqttNetworkSession session, Publish publish, int matchedSubscribers) {} protected void handleError( - C client, + U user, MqttNetworkSession session, Publish publish, PublishHandlingResult handlingResult) {} protected PublishHandlingResult checkSubscriber( - C client, + U user, Publish publish, SingleSubscriber subscriber) { return PublishHandlingResult.SUCCESS; } protected PublishHandlingResult startDelivering( - C client, + U user, MqttNetworkSession session, Publish publish, SingleSubscriber subscriber) { return publishDeliveringService.startDelivering(publish, subscriber); } - protected void sendFeedback(C client, MqttOutMessage response) { - client.send(response); + protected void sendFeedback(U user, MqttOutMessage response) { + user.send(response); } protected void sendFeedback( - C client, - MqttNetworkSession session, + U user, + MqttSession session, MqttOutMessage response, int messageId) { MessageTacker messageTacker = session.inMessageTracker(); - client - .sendWithFeedback(response) + user.sendWithFeedback(response) .thenAccept(_ -> messageTacker.remove(messageId)); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishOutMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishOutMessageHandler.java index e752bd25..52cf60fa 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishOutMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/AbstractMqttPublishOutMessageHandler.java @@ -3,8 +3,8 @@ import javasabr.mqtt.model.MqttProperties; import javasabr.mqtt.model.publishing.Publish; import javasabr.mqtt.model.subscriber.SingleSubscriber; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.out.MqttOutMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.publish.handler.MqttPublishOutMessageHandler; @@ -18,7 +18,7 @@ @CustomLog @RequiredArgsConstructor @FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true) -public abstract class AbstractMqttPublishOutMessageHandler +public abstract class AbstractMqttPublishOutMessageHandler implements MqttPublishOutMessageHandler { Class expectedClient; @@ -27,20 +27,20 @@ public abstract class AbstractMqttPublishOutMessageHandler @Override public PublishHandlingResult handle(Publish publish, SingleSubscriber subscriber) { - MqttClient client = subscriptionService.resolveClient(subscriber); - if (!expectedClient.isInstance(client)) { - log.warning(client, "Accepted not expected client:[%s]"::formatted); + NetworkMqttUser user = subscriptionService.resolveClient(subscriber); + if (!expectedClient.isInstance(user)) { + log.warning(user, "Accepted not expected client:[%s]"::formatted); return PublishHandlingResult.NOT_EXPECTED_CLIENT; } - publish = reconstruct(client, publish); + publish = reconstruct(user, publish); if (publish == null) { return PublishHandlingResult.SKIPPED; } - return handleImpl(publish, expectedClient.cast(client)); + return handleImpl(publish, expectedClient.cast(user)); } @Nullable - protected Publish reconstruct(MqttClient client, Publish original) { + protected Publish reconstruct(NetworkMqttUser client, Publish original) { return original.with( MqttProperties.MESSAGE_ID_IS_NOT_SET, qos(), @@ -50,7 +50,7 @@ protected Publish reconstruct(MqttClient client, Publish original) { protected abstract PublishHandlingResult handleImpl(Publish publish, C client) ; - protected void startDelivering(MqttClient client, Publish publish) { + protected void startDelivering(NetworkMqttUser client, Publish publish) { MqttOutMessage outMessage = messageOutFactoryService .resolveFactory(client) .newPublish( diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/PersistedMqttPublishOutMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/PersistedMqttPublishOutMessageHandler.java index a06692fc..617b8d6c 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/PersistedMqttPublishOutMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/PersistedMqttPublishOutMessageHandler.java @@ -3,10 +3,10 @@ import javasabr.mqtt.model.MqttProperties; import javasabr.mqtt.model.message.TrackableMqttMessage; import javasabr.mqtt.model.publishing.Publish; -import javasabr.mqtt.network.MqttClient; -import javasabr.mqtt.network.impl.ExternalMqttClient; -import javasabr.mqtt.network.session.MqttNetworkSession; -import javasabr.mqtt.network.session.MqttNetworkSession.PendingMessageHandler; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession.PendingMessageHandler; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.publish.handler.PublishHandlingResult; @@ -16,30 +16,30 @@ @FieldDefaults(level = AccessLevel.PROTECTED, makeFinal = true) public abstract class PersistedMqttPublishOutMessageHandler extends - AbstractMqttPublishOutMessageHandler { + AbstractMqttPublishOutMessageHandler { PendingMessageHandler pendingMessageHandler; protected PersistedMqttPublishOutMessageHandler( SubscriptionService subscriptionService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, subscriptionService, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, subscriptionService, messageOutFactoryService); this.pendingMessageHandler = new PendingMessageHandler() { @Override - public boolean handleResponse(MqttClient client, TrackableMqttMessage response) { - return handleReceivedResponse(client, response); + public boolean handleResponse(NetworkMqttUser user, TrackableMqttMessage response) { + return handleReceivedResponse(user, response); } @Override - public void resend(MqttClient client, Publish publish) { - tryToDeliverAgain(client, publish); + public void resend(NetworkMqttUser user, Publish publish) { + tryToDeliverAgain(user, publish); } }; } @Nullable @Override - protected Publish reconstruct(MqttClient client, Publish original) { - MqttNetworkSession session = client.session(); + protected Publish reconstruct(NetworkMqttUser user, Publish original) { + MqttNetworkSession session = user.session(); if (session == null) { return null; } @@ -52,7 +52,7 @@ protected Publish reconstruct(MqttClient client, Publish original) { } @Override - protected PublishHandlingResult handleImpl(Publish publish, ExternalMqttClient client) { + protected PublishHandlingResult handleImpl(Publish publish, ExternalNetworkMqttUser client) { MqttNetworkSession session = client.session(); if (session == null) { @@ -67,11 +67,11 @@ protected PublishHandlingResult handleImpl(Publish publish, ExternalMqttClient c return PublishHandlingResult.SUCCESS; } - protected boolean handleReceivedResponse(MqttClient client, TrackableMqttMessage response) { + protected boolean handleReceivedResponse(NetworkMqttUser user, TrackableMqttMessage response) { return false; } - protected void tryToDeliverAgain(MqttClient client, Publish publish) { + protected void tryToDeliverAgain(NetworkMqttUser client, Publish publish) { startDelivering(client, publish.withDuplicated()); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandler.java index c4e343dc..6a1b71ac 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandler.java @@ -5,20 +5,20 @@ import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.publishing.Publish; import javasabr.mqtt.model.reason.code.DisconnectReasonCode; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishDeliveringService; import javasabr.mqtt.service.SubscriptionService; -public class Qos0MqttPublishInMessageHandler extends AbstractMqttPublishInMessageHandler { +public class Qos0MqttPublishInMessageHandler extends AbstractMqttPublishInMessageHandler { public Qos0MqttPublishInMessageHandler( SubscriptionService subscriptionService, PublishDeliveringService publishDeliveringService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, subscriptionService, publishDeliveringService, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, subscriptionService, publishDeliveringService, messageOutFactoryService); } @Override @@ -27,19 +27,19 @@ public QoS qos() { } @Override - protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession session, Publish publish) { + protected boolean validateImpl(ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish) { int messageId = publish.messageId(); if (messageId != MqttProperties.MESSAGE_ID_IS_NOT_SET) { - handleNotExpectedMessageId(client); + handleNotExpectedMessageId(user); return false; } - return super.validateImpl(client, session, publish); + return super.validateImpl(user, session, publish); } - private void handleNotExpectedMessageId(ExternalMqttClient client) { + private void handleNotExpectedMessageId(ExternalNetworkMqttUser user) { MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) - .newDisconnect(client, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.NOT_EXPECTED_MESSAGE_ID); - client.closeWithReason(response); + .resolveFactory(user) + .newDisconnect(user, DisconnectReasonCode.PROTOCOL_ERROR, MqttProtocolErrors.NOT_EXPECTED_MESSAGE_ID); + user.closeWithReason(response); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishOutMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishOutMessageHandler.java index 2dafce82..ad09e51d 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishOutMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishOutMessageHandler.java @@ -2,17 +2,17 @@ import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.publishing.Publish; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; import javasabr.mqtt.service.publish.handler.PublishHandlingResult; -public class Qos0MqttPublishOutMessageHandler extends AbstractMqttPublishOutMessageHandler { +public class Qos0MqttPublishOutMessageHandler extends AbstractMqttPublishOutMessageHandler { public Qos0MqttPublishOutMessageHandler( SubscriptionService subscriptionService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, subscriptionService, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, subscriptionService, messageOutFactoryService); } @Override @@ -21,7 +21,7 @@ public QoS qos() { } @Override - protected PublishHandlingResult handleImpl(Publish publish, ExternalMqttClient client) { + protected PublishHandlingResult handleImpl(Publish publish, ExternalNetworkMqttUser client) { startDelivering(client, publish); return PublishHandlingResult.SUCCESS; } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandler.java index 57248c72..4c55da2b 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandler.java @@ -6,9 +6,9 @@ import javasabr.mqtt.model.reason.code.PublishAckReasonCode; import javasabr.mqtt.model.session.MessageTacker; import javasabr.mqtt.model.session.TrackedMessageMeta; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishDeliveringService; import javasabr.mqtt.service.SubscriptionService; @@ -19,13 +19,13 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) -public class Qos1MqttPublishInMessageHandler extends TrackableMqttPublishInMessageHandler { +public class Qos1MqttPublishInMessageHandler extends TrackableMqttPublishInMessageHandler { public Qos1MqttPublishInMessageHandler( SubscriptionService subscriptionService, PublishDeliveringService publishDeliveringService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, subscriptionService, publishDeliveringService, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, subscriptionService, publishDeliveringService, messageOutFactoryService); } @Override @@ -34,8 +34,8 @@ public QoS qos() { } @Override - protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession session, Publish publish) { - if (!super.validateImpl(client, session, publish)) { + protected boolean validateImpl(ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish) { + if (!super.validateImpl(user, session, publish)) { return false; } int messagedId = publish.messageId(); @@ -46,7 +46,7 @@ protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession ses if (publish.duplicated() && alreadyInProcess.messageType() == MqttMessageType.PUBLISH) { return false; } - handleMessageIdIsInUse(client, messagedId); + handleMessageIdIsInUse(user, messagedId); return false; } return true; @@ -54,48 +54,48 @@ protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession ses @Override protected void handleNoMatchedSubscribers( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish) { - super.handleNoMatchedSubscribers(client, session, publish); + super.handleNoMatchedSubscribers(user, session, publish); int messageId = publish.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newPublishAck(messageId, PublishAckReasonCode.NO_MATCHING_SUBSCRIBERS); - sendFeedback(client, session, response, messageId); + sendFeedback(user, session, response, messageId); } @Override protected void handleSuccess( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish, int matchedSubscribers) { - super.handleSuccess(client, session, publish, matchedSubscribers); + super.handleSuccess(user, session, publish, matchedSubscribers); int messageId = publish.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newPublishAck(messageId, PublishAckReasonCode.SUCCESS); - sendFeedback(client, session, response, messageId); + sendFeedback(user, session, response, messageId); } @Override protected void handleError( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish, PublishHandlingResult handlingResult) { - super.handleError(client, session, publish, handlingResult); + super.handleError(user, session, publish, handlingResult); int messageId = publish.messageId(); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(user) .newPublishAck(publish.messageId(), handlingResult.ackReasonCode()); - sendFeedback(client, session, response, messageId); + sendFeedback(user, session, response, messageId); } - private void handleMessageIdIsInUse(ExternalMqttClient client, int messageId) { - client.send(messageOutFactoryService - .resolveFactory(client) + private void handleMessageIdIsInUse(ExternalNetworkMqttUser user, int messageId) { + user.send(messageOutFactoryService + .resolveFactory(user) .newPublishAck(messageId, PublishAckReasonCode.PACKET_IDENTIFIER_IN_USE)); } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishOutMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishOutMessageHandler.java index 428c36fa..4aec8dd7 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishOutMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishOutMessageHandler.java @@ -2,8 +2,8 @@ import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.message.TrackableMqttMessage; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.in.PublishAckMqttInMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; @@ -21,7 +21,7 @@ public QoS qos() { } @Override - protected boolean handleReceivedResponse(MqttClient client, TrackableMqttMessage response) { + protected boolean handleReceivedResponse(NetworkMqttUser user, TrackableMqttMessage response) { if (!(response instanceof PublishAckMqttInMessage)) { throw new IllegalStateException("Unexpected response: " + response); } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandler.java index f092f0ad..7deabcba 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandler.java @@ -8,14 +8,15 @@ import javasabr.mqtt.model.reason.code.PublishCompletedReasonCode; import javasabr.mqtt.model.reason.code.PublishReceivedReasonCode; import javasabr.mqtt.model.session.MessageTacker; +import javasabr.mqtt.model.session.MqttSession; import javasabr.mqtt.model.session.ProcessingPublishes; import javasabr.mqtt.model.session.PublishRetryer; import javasabr.mqtt.model.session.TrackableMessageCallback; import javasabr.mqtt.model.session.TrackedMessageMeta; -import javasabr.mqtt.network.impl.ExternalMqttClient; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser; import javasabr.mqtt.network.message.in.PublishReleaseMqttInMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishDeliveringService; import javasabr.mqtt.service.SubscriptionService; @@ -26,7 +27,7 @@ @CustomLog @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) -public class Qos2MqttPublishInMessageHandler extends TrackableMqttPublishInMessageHandler { +public class Qos2MqttPublishInMessageHandler extends TrackableMqttPublishInMessageHandler { TrackableMessageCallback trackableMessageCallback; @@ -34,7 +35,7 @@ public Qos2MqttPublishInMessageHandler( SubscriptionService subscriptionService, PublishDeliveringService publishDeliveringService, MessageOutFactoryService messageOutFactoryService) { - super(ExternalMqttClient.class, subscriptionService, publishDeliveringService, messageOutFactoryService); + super(ExternalNetworkMqttUser.class, subscriptionService, publishDeliveringService, messageOutFactoryService); this.trackableMessageCallback = this::handleReceivedTrackableMessage; } @@ -44,8 +45,8 @@ public QoS qos() { } @Override - protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession session, Publish publish) { - if (!super.validateImpl(client, session, publish)) { + protected boolean validateImpl(ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish) { + if (!super.validateImpl(user, session, publish)) { return false; } @@ -55,10 +56,10 @@ protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession ses if (alreadyInProcess != null) { // in the case if we already process the fist publish attempt, we should ack response if (publish.duplicated() && (alreadyInProcess.messageType() == MqttMessageType.PUBLISH)) { - handleDuplicated(client, messagedId, alreadyInProcess); + handleDuplicated(user, messagedId, alreadyInProcess); return false; } - handleMessageIdIsInUse(client, messagedId); + handleMessageIdIsInUse(user, messagedId); return false; } @@ -67,28 +68,30 @@ protected boolean validateImpl(ExternalMqttClient client, MqttNetworkSession ses @Override protected void handleNoMatchedSubscribers( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish) { - super.handleNoMatchedSubscribers(client, session, publish); + super.handleNoMatchedSubscribers(user, session, publish); var reasonCode = PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS; updateSessionState(session, publish, reasonCode); - sendFeedback(client, messageOutFactoryService - .resolveFactory(client) + sendFeedback( + user, messageOutFactoryService + .resolveFactory(user) .newPublishReceived(publish.messageId(), reasonCode)); } @Override protected void handleSuccess( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish, int matchedSubscribers) { - super.handleSuccess(client, session, publish, matchedSubscribers); + super.handleSuccess(user, session, publish, matchedSubscribers); var reasonCode = PublishReceivedReasonCode.SUCCESS; updateSessionState(session, publish, reasonCode); - sendFeedback(client, messageOutFactoryService - .resolveFactory(client) + sendFeedback( + user, messageOutFactoryService + .resolveFactory(user) .newPublishReceived(publish.messageId(), PublishReceivedReasonCode.SUCCESS)); } @@ -103,11 +106,11 @@ private void updateSessionState(MqttNetworkSession session, Publish publish, Pub @Override protected void handleError( - ExternalMqttClient client, + ExternalNetworkMqttUser user, MqttNetworkSession session, Publish publish, PublishHandlingResult handlingResult) { - super.handleError(client, session, publish, handlingResult); + super.handleError(user, session, publish, handlingResult); int messageId = publish.messageId(); PublishReceivedReasonCode reasonCode = handlingResult.receivedReasonCode(); @@ -115,48 +118,47 @@ protected void handleError( MessageTacker messageTacker = session.inMessageTracker(); messageTacker.update(messageId, MqttMessageType.PUBLISH, reasonCode); - sendFeedback(client, session, messageOutFactoryService - .resolveFactory(client) + sendFeedback(user, session, messageOutFactoryService + .resolveFactory(user) .newPublishReceived(messageId, reasonCode), messageId); } private void handleDuplicated( - ExternalMqttClient client, + ExternalNetworkMqttUser user, int messageId, TrackedMessageMeta alreadyInProcess) { PublishReceivedReasonCode reasonCode = PublishReceivedReasonCode.SUCCESS; if (alreadyInProcess.reasonCode() instanceof PublishReceivedReasonCode receivedReasonCode) { reasonCode = receivedReasonCode; } - sendFeedback(client, messageOutFactoryService - .resolveFactory(client) + sendFeedback(user, messageOutFactoryService + .resolveFactory(user) .newPublishReceived(messageId, reasonCode)); } - private void handleMessageIdIsInUse(ExternalMqttClient client, int messageId) { - client.send(messageOutFactoryService - .resolveFactory(client) + private void handleMessageIdIsInUse(ExternalNetworkMqttUser user, int messageId) { + user.send(messageOutFactoryService + .resolveFactory(user) .newPublishReceived(messageId, PublishReceivedReasonCode.PACKET_IDENTIFIER_IN_USE)); } - private boolean handleReceivedTrackableMessage(MqttUser user, Object object, TrackableMqttMessage message) { - ExternalMqttClient client = (ExternalMqttClient) user; - MqttNetworkSession session = (MqttNetworkSession) object; + private boolean handleReceivedTrackableMessage(MqttUser user, MqttSession session, TrackableMqttMessage message) { + ExternalNetworkMqttUser networkUser = (ExternalNetworkMqttUser) user; int messageId = message.messageId(); MessageTacker messageTacker = session.inMessageTracker(); TrackedMessageMeta messageMeta = messageTacker.stored(messageId); if (messageMeta == null) { - log.warning(client.clientId(), messageId, "[%s] No any stored information for messageId:[%d]"::formatted); + log.warning(networkUser.clientId(), messageId, "[%s] No any stored information for messageId:[%d]"::formatted); return true; } if (messageMeta.messageType() != MqttMessageType.PUBLISH) { - log.warning(client.clientId(), messageMeta, messageId, + log.warning(networkUser.clientId(), messageMeta, messageId, "[%s] Not expected tracked message meta:[%s] for messageId:[%d]"::formatted); return true; } else if (!(message instanceof PublishReleaseMqttInMessage release)) { - log.warning(client.clientId(), message, "[%s] Not expected message:%s]"::formatted); + log.warning(networkUser.clientId(), message, "[%s] Not expected message:%s]"::formatted); return true; } @@ -166,10 +168,10 @@ private boolean handleReceivedTrackableMessage(MqttUser user, Object object, Tra PublishCompletedReasonCode.SUCCESS); MqttOutMessage response = messageOutFactoryService - .resolveFactory(client) + .resolveFactory(networkUser) .newPublishCompleted(message.messageId(), PublishCompletedReasonCode.SUCCESS); - sendFeedback(client, session, response, messageId); + sendFeedback(networkUser, session, response, messageId); return true; } } diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishOutMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishOutMessageHandler.java index f5c81ae9..7375e739 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishOutMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishOutMessageHandler.java @@ -4,9 +4,9 @@ import javasabr.mqtt.model.QoS; import javasabr.mqtt.model.message.TrackableMqttMessage; -import javasabr.mqtt.network.MqttClient; import javasabr.mqtt.network.message.in.PublishCompleteMqttInMessage; import javasabr.mqtt.network.message.in.PublishReceivedMqttInMessage; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.SubscriptionService; @@ -24,10 +24,10 @@ public QoS qos() { } @Override - protected boolean handleReceivedResponse(MqttClient client, TrackableMqttMessage response) { + protected boolean handleReceivedResponse(NetworkMqttUser user, TrackableMqttMessage response) { if (response instanceof PublishReceivedMqttInMessage) { - client.send(messageOutFactoryService - .resolveFactory(client) + user.send(messageOutFactoryService + .resolveFactory(user) .newPublishRelease(response.messageId(), SUCCESS)); return false; } else if (response instanceof PublishCompleteMqttInMessage) { diff --git a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/TrackableMqttPublishInMessageHandler.java b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/TrackableMqttPublishInMessageHandler.java index 33dc935e..3a4443d8 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/TrackableMqttPublishInMessageHandler.java +++ b/core-service/src/main/java/javasabr/mqtt/service/publish/handler/impl/TrackableMqttPublishInMessageHandler.java @@ -6,14 +6,14 @@ import javasabr.mqtt.model.publishing.Publish; import javasabr.mqtt.model.reason.code.DisconnectReasonCode; import javasabr.mqtt.model.session.MessageTacker; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.MqttNetworkSession; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.mqtt.service.MessageOutFactoryService; import javasabr.mqtt.service.PublishDeliveringService; import javasabr.mqtt.service.SubscriptionService; -public abstract class TrackableMqttPublishInMessageHandler +public abstract class TrackableMqttPublishInMessageHandler extends AbstractMqttPublishInMessageHandler { public TrackableMqttPublishInMessageHandler( @@ -25,20 +25,20 @@ public TrackableMqttPublishInMessageHandler( } @Override - protected boolean validateImpl(C client, MqttNetworkSession session, Publish publish) { + protected boolean validateImpl(C user, MqttNetworkSession session, Publish publish) { int messagedId = publish.messageId(); if (messagedId == MqttProperties.MESSAGE_ID_IS_NOT_SET) { - handleMissedMessageId(client); + handleMissedMessageId(user); return false; } - return super.validateImpl(client, session, publish); + return super.validateImpl(user, session, publish); } @Override - protected void handleImpl(C client, MqttNetworkSession session, Publish publish) { + protected void handleImpl(C user, MqttNetworkSession session, Publish publish) { MessageTacker messageTacker = session.inMessageTracker(); messageTacker.add(publish.messageId(), MqttMessageType.PUBLISH); - super.handleImpl(client, session, publish); + super.handleImpl(user, session, publish); } protected void handleMissedMessageId(C client) { diff --git a/core-service/src/main/java/javasabr/mqtt/service/session/MqttSessionService.java b/core-service/src/main/java/javasabr/mqtt/service/session/MqttSessionService.java index 394f2d8d..8aa1a457 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/session/MqttSessionService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/session/MqttSessionService.java @@ -1,6 +1,6 @@ package javasabr.mqtt.service.session; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; import reactor.core.publisher.Mono; public interface MqttSessionService { diff --git a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttNetworkSession.java b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttNetworkSession.java index b66d2d88..5d1d09e8 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttNetworkSession.java +++ b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttNetworkSession.java @@ -9,8 +9,8 @@ import javasabr.mqtt.model.session.MessageTacker; import javasabr.mqtt.model.session.ProcessingPublishes; import javasabr.mqtt.model.session.TopicNameMapping; -import javasabr.mqtt.network.MqttClient; -import javasabr.mqtt.network.session.MqttNetworkSession.UnsafeMqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession.UnsafeMqttNetworkSession; +import javasabr.mqtt.network.user.NetworkMqttUser; import javasabr.rlib.collections.array.ArrayFactory; import javasabr.rlib.collections.array.LockableArray; import lombok.AccessLevel; @@ -42,7 +42,7 @@ private static void registerPublish( } private static void updatePendingPacket( - MqttClient client, + NetworkMqttUser client, TrackableMqttMessage response, LockableArray pendingPublishes, String clientId) { @@ -146,13 +146,13 @@ public boolean hasOutPending(int messageId) { } @Override - public void resendPendingPackets(MqttClient client) { + public void resendPendingPackets(NetworkMqttUser user) { long stamp = pendingOutPublishes.readLock(); try { for (PendingPublish pending : pendingOutPublishes) { PendingMessageHandler handler = pending.handler; Publish publish = pending.publish; - handler.resend(client, publish); + handler.resend(user, publish); } } finally { pendingOutPublishes.readUnlock(stamp); @@ -160,8 +160,8 @@ public void resendPendingPackets(MqttClient client) { } @Override - public void updateOutPendingPacket(MqttClient client, TrackableMqttMessage response) { - updatePendingPacket(client, response, pendingOutPublishes, clientId); + public void updateOutPendingPacket(NetworkMqttUser user, TrackableMqttMessage response) { + updatePendingPacket(user, response, pendingOutPublishes, clientId); } @Override diff --git a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttSessionService.java b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttSessionService.java index 359020d9..6a24bd88 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttSessionService.java +++ b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryMqttSessionService.java @@ -1,8 +1,8 @@ package javasabr.mqtt.service.session.impl; import java.io.Closeable; -import javasabr.mqtt.network.session.MqttNetworkSession; -import javasabr.mqtt.network.session.MqttNetworkSession.UnsafeMqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession.UnsafeMqttNetworkSession; import javasabr.mqtt.service.session.MqttSessionService; import javasabr.rlib.collections.array.ArrayFactory; import javasabr.rlib.collections.array.MutableArray; diff --git a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryProcessingPublishes.java b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryProcessingPublishes.java index 37ee69b7..4085445d 100644 --- a/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryProcessingPublishes.java +++ b/core-service/src/main/java/javasabr/mqtt/service/session/impl/InMemoryProcessingPublishes.java @@ -7,7 +7,7 @@ import javasabr.mqtt.model.session.ProcessingPublishes; import javasabr.mqtt.model.session.PublishRetryer; import javasabr.mqtt.model.session.TrackableMessageCallback; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.MqttNetworkSession; import javasabr.rlib.collections.dictionary.DictionaryFactory; import javasabr.rlib.collections.dictionary.MutableIntToRefDictionary; import lombok.AccessLevel; diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/IntegrationServiceSpecification.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/IntegrationServiceSpecification.groovy index dcbe3b49..f1054d75 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/IntegrationServiceSpecification.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/IntegrationServiceSpecification.groovy @@ -7,7 +7,7 @@ import javasabr.mqtt.model.MqttServerConnectionConfig import javasabr.mqtt.model.MqttVersion import javasabr.mqtt.model.QoS import javasabr.mqtt.network.MqttConnection -import javasabr.mqtt.network.handler.MqttClientReleaseHandler +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler import javasabr.mqtt.service.impl.DefaultMessageOutFactoryService import javasabr.mqtt.service.impl.DefaultPublishDeliveringService import javasabr.mqtt.service.impl.DefaultPublishReceivingService @@ -121,10 +121,10 @@ abstract class IntegrationServiceSpecification extends Specification { { MqttConnection ownedConnection -> def generatedClientId = "mockedClient_${clientIdGenerator.incrementAndGet()}" def createdSession = defaultMqttSessionService.create(generatedClientId).block() - def client = new TestExternalMqttClient(ownedConnection, Mock(MqttClientReleaseHandler)) - client.session(createdSession) - client.clientId(generatedClientId) - return client + def user = new TestExternalNetworkMqttUser(ownedConnection, Mock(NetworkMqttUserReleaseHandler)) + user.session(createdSession) + user.clientId(generatedClientId) + return user }) connection.configure(new MqttClientConnectionConfig( diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/TestExternalMqttClient.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/TestExternalNetworkMqttUser.groovy similarity index 84% rename from core-service/src/test/groovy/javasabr/mqtt/service/TestExternalMqttClient.groovy rename to core-service/src/test/groovy/javasabr/mqtt/service/TestExternalNetworkMqttUser.groovy index f52d6caf..bcc82a63 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/TestExternalMqttClient.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/TestExternalNetworkMqttUser.groovy @@ -1,8 +1,8 @@ package javasabr.mqtt.service import javasabr.mqtt.network.MqttConnection -import javasabr.mqtt.network.handler.MqttClientReleaseHandler -import javasabr.mqtt.network.impl.ExternalMqttClient +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler +import javasabr.mqtt.network.impl.ExternalNetworkMqttUser import javasabr.mqtt.network.message.out.MqttOutMessage import javasabr.rlib.collections.array.MutableArray @@ -10,14 +10,14 @@ import java.util.concurrent.CompletableFuture import java.util.concurrent.Executor import java.util.concurrent.TimeUnit -class TestExternalMqttClient extends ExternalMqttClient { +class TestExternalNetworkMqttUser extends ExternalNetworkMqttUser { private static final Executor DELAYED_EXECUTOR = CompletableFuture.delayedExecutor(5000, TimeUnit.MILLISECONDS) private final MutableArray sentMessages private boolean returnCompletedFeatures = true; - TestExternalMqttClient(MqttConnection connection, MqttClientReleaseHandler releaseHandler) { + TestExternalNetworkMqttUser(MqttConnection connection, NetworkMqttUserReleaseHandler releaseHandler) { super(connection, releaseHandler) this.sentMessages = MutableArray.ofType(MqttOutMessage) } diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/impl/InMemorySubscriptionServiceTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/impl/InMemorySubscriptionServiceTest.groovy index 3dcdb370..6e97e1de 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/impl/InMemorySubscriptionServiceTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/impl/InMemorySubscriptionServiceTest.groovy @@ -18,31 +18,31 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { given: def serverConfig = defaultExternalServerConnectionConfig def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() + def mqttUser = mqttConnection.user() def subscriptions = Array.of( new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 30, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/2"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/2"), 30, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/invalid/##"), + defaultTopicService.createTopicFilter(mqttUser, "topic/invalid/##"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, @@ -50,7 +50,7 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { true)) when: def result = subscriptionService - .subscribe(mqttClient, mqttClient.session(), subscriptions) + .subscribe(mqttUser, mqttUser.session(), subscriptions) then: result.size() == 4 result == Array.of( @@ -66,38 +66,38 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { .withSharedSubscriptionAvailable(false) .withWildcardSubscriptionAvailable(false) def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() + def mqttUser = mqttConnection.user() def subscriptions = Array.of( new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/+"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/+"), 5, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/#"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/#"), 5, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "\$share/group1/topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "\$share/group1/topic/filter/3"), 5, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "\$share/group1/topic/filter/#"), + defaultTopicService.createTopicFilter(mqttUser, "\$share/group1/topic/filter/#"), 5, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "\$share/group1/topic/filter/+"), + defaultTopicService.createTopicFilter(mqttUser, "\$share/group1/topic/filter/+"), 5, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, @@ -105,7 +105,7 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { true)) when: def result = subscriptionService - .subscribe(mqttClient, mqttClient.session(), subscriptions) + .subscribe(mqttUser, mqttUser.session(), subscriptions) then: result.size() == 5 result == Array.of( @@ -120,16 +120,16 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { given: def serverConfig = defaultExternalServerConnectionConfig def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() + def mqttUser = mqttConnection.user() def sub1 = new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 15, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true) def sub2 = new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/2"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/2"), 15, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, @@ -137,14 +137,14 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { true) def sub3 = new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true) def sub4 = new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/invalid/4"), + defaultTopicService.createTopicFilter(mqttUser, "topic/invalid/4"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, @@ -153,7 +153,7 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { def subscriptions = Array.of(sub1, sub2, sub3, sub4) when: def result = subscriptionService - .subscribe(mqttClient, mqttClient.session(), subscriptions) + .subscribe(mqttUser, mqttUser.session(), subscriptions) then: result.size() == 4 result == Array.of( @@ -162,7 +162,7 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { SubscribeAckReasonCode.GRANTED_QOS_2, SubscribeAckReasonCode.GRANTED_QOS_2) when: - def mqttSession = mqttClient.session() + def mqttSession = mqttUser.session() def activeSubscriptions = mqttSession.activeSubscriptions() def subsWithId15 = activeSubscriptions.findBySubscriptionId(15) def subsWithId30 = activeSubscriptions.findBySubscriptionId(30) @@ -177,38 +177,38 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { given: def serverConfig = defaultExternalServerConnectionConfig def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() + def mqttUser = mqttConnection.user() def subscriptions = Array.of( new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 30, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/2"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/2"), 30, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true)) - subscriptionService.subscribe(mqttClient, mqttClient.session(), subscriptions) + subscriptionService.subscribe(mqttUser, mqttUser.session(), subscriptions) def topicsToUnsubscribe = Array.of( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/notexist"), - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/invalid##")) + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/notexist"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/invalid##")) when: def result = subscriptionService - .unsubscribe(mqttClient, mqttClient.session(), topicsToUnsubscribe) + .unsubscribe(mqttUser, mqttUser.session(), topicsToUnsubscribe) then: result.size() == 4 result == Array.of( @@ -222,42 +222,42 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { given: def serverConfig = defaultExternalServerConnectionConfig def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() - def mqttSession = mqttClient.session() + def mqttUser = mqttConnection.user() + def mqttSession = mqttUser.session() def activeSubscriptions = mqttSession.activeSubscriptions() def subscriptions = Array.of( new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 30, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/2"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/2"), 30, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true)) def topicsToUnsubscribe = Array.of( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3")) + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3")) when: - subscriptionService.subscribe(mqttClient, mqttClient.session(), subscriptions) + subscriptionService.subscribe(mqttUser, mqttUser.session(), subscriptions) def storedSubscriptions = activeSubscriptions.subscriptions() then: storedSubscriptions.size() == 3 storedSubscriptions == subscriptions when: - subscriptionService.unsubscribe(mqttClient, mqttClient.session(), topicsToUnsubscribe) + subscriptionService.unsubscribe(mqttUser, mqttUser.session(), topicsToUnsubscribe) storedSubscriptions = activeSubscriptions.subscriptions() then: storedSubscriptions.size() == 1 @@ -268,26 +268,26 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { given: def serverConfig = defaultExternalServerConnectionConfig def mqttConnection = mockedExternalConnection(serverConfig, MqttVersion.MQTT_5) - def mqttClient = mqttConnection.client() - def mqttSession = mqttClient.session() + def mqttUser = mqttConnection.user() + def mqttSession = mqttUser.session() def activeSubscriptions = mqttSession.activeSubscriptions() def subscriptions = Array.of( new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 30, QoS.AT_MOST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/2"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/2"), 30, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 30, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, @@ -295,14 +295,14 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { true)) def subscriptions2 = Array.typed(Subscription, new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/1"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/1"), 55, QoS.EXACTLY_ONCE, SubscribeRetainHandling.SEND, true, true), new Subscription( - defaultTopicService.createTopicFilter(mqttClient, "topic/filter/3"), + defaultTopicService.createTopicFilter(mqttUser, "topic/filter/3"), 55, QoS.AT_LEAST_ONCE, SubscribeRetainHandling.SEND, @@ -313,13 +313,13 @@ class InMemorySubscriptionServiceTest extends IntegrationServiceSpecification { subscriptions.get(1), subscriptions2.get(1)) when: - subscriptionService.subscribe(mqttClient, mqttClient.session(), subscriptions) + subscriptionService.subscribe(mqttUser, mqttUser.session(), subscriptions) def storedSubscriptions = activeSubscriptions.subscriptions() then: storedSubscriptions.size() == 3 storedSubscriptions == subscriptions when: - subscriptionService.subscribe(mqttClient, mqttClient.session(), subscriptions2) + subscriptionService.subscribe(mqttUser, mqttUser.session(), subscriptions2) storedSubscriptions = activeSubscriptions.subscriptions() then: storedSubscriptions.size() == 3 diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandlerTest.groovy index fba7f28f..cc47a675 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/PublishMqttInMessageHandlerTest.groovy @@ -13,7 +13,7 @@ import javasabr.mqtt.network.message.out.DisconnectMqtt5OutMessage import javasabr.mqtt.network.message.out.PublishAckMqtt5OutMessage import javasabr.mqtt.network.util.ExtraErrorReasons import javasabr.mqtt.service.IntegrationServiceSpecification -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { @@ -26,8 +26,8 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultTopicService) def expectedMessageId = 15 def expectedTopicAlias = 5 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - def expectedTopicName = defaultTopicService.createTopicName(mqttClient, "topic/name1") + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + def expectedTopicName = defaultTopicService.createTopicName(mqttUser, "topic/name1") when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -37,10 +37,10 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def publishAck = mqttClient.nextSentMessage(PublishAckMqtt5OutMessage) + def publishAck = mqttUser.nextSentMessage(PublishAckMqtt5OutMessage) publishAck.reasonCode() == PublishAckReasonCode.NO_MATCHING_SUBSCRIBERS publishAck.reason() == null - mqttClient.session() + mqttUser.session() .topicNameMapping() .resolve(expectedTopicAlias) == expectedTopicName } @@ -53,9 +53,9 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.returnCompletedFeatures(false) - def session = mqttClient.session() + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.returnCompletedFeatures(false) + def session = mqttUser.session() def inMessageTracker = session.inMessageTracker() when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ @@ -65,7 +65,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def publishAck = mqttClient.nextSentMessage(PublishAckMqtt5OutMessage) + def publishAck = mqttUser.nextSentMessage(PublishAckMqtt5OutMessage) publishAck.reasonCode() == PublishAckReasonCode.NO_MATCHING_SUBSCRIBERS publishAck.reason() == null inMessageTracker.stored(expectedMessageId) != null @@ -78,13 +78,13 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { publishReceivingService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.session(null) + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.session(null) when: def publishMessage = new PublishMqttInMessage(0b0110_0010 as byte) messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.UNSPECIFIED_ERROR disconnectReason.reason() == ExtraErrorReasons.SESSION_IS_ALREADY_CLOSED disconnectReason.serverReference() == null @@ -97,7 +97,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { publishReceivingService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0010 as byte) {{ payload = testPayload @@ -105,7 +105,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.MISSED_REQUIRED_MESSAGE_ID disconnectReason.serverReference() == null @@ -119,8 +119,8 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser .session() .inMessageTracker() .add(expectedMessageId, MqttMessageType.PUBLISH) @@ -132,7 +132,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def publishAck = mqttClient.nextSentMessage(PublishAckMqtt5OutMessage) + def publishAck = mqttUser.nextSentMessage(PublishAckMqtt5OutMessage) publishAck.reasonCode() == PublishAckReasonCode.PACKET_IDENTIFIER_IN_USE publishAck.reason() == null } @@ -146,12 +146,12 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { publishReceivingService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0 as byte) messageHandler.processValidMessage(mqttConnection, publishMessage) then: - mqttClient.isEmpty() + mqttUser.isEmpty() } def "should response that requested QoS 1 is not supported"() { @@ -164,7 +164,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -172,7 +172,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.QOS_NOT_SUPPORTED disconnectReason.reason() == null disconnectReason.serverReference() == null @@ -188,7 +188,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -196,7 +196,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.RETAIN_NOT_SUPPORTED disconnectReason.reason() == null disconnectReason.serverReference() == null @@ -210,7 +210,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -219,7 +219,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.PROVIDED_INVALID_PAYLOAD_FORMAT disconnectReason.serverReference() == null @@ -233,7 +233,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -242,7 +242,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.PROVIDED_INVALID_MESSAGE_EXPIRY_INTERVAL disconnectReason.serverReference() == null @@ -256,7 +256,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -265,7 +265,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.INVALID_RESPONSE_TOPIC_NAME disconnectReason.serverReference() == null @@ -279,7 +279,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -287,7 +287,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.NO_ANY_TOPIC_NANE disconnectReason.serverReference() == null @@ -301,7 +301,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: 'topic alias is too high' def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -310,7 +310,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.TOPIC_ALIAS_INVALID disconnectReason.reason() == null disconnectReason.serverReference() == null @@ -322,7 +322,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage2) then: - def disconnectReason2 = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason2 = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason2.reasonCode() == DisconnectReasonCode.TOPIC_ALIAS_INVALID disconnectReason2.reason() == null disconnectReason2.serverReference() == null @@ -336,7 +336,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -345,7 +345,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnectReason.reason() == MqttProtocolErrors.NO_ANY_TOPIC_NANE disconnectReason.serverReference() == null @@ -359,7 +359,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def publishMessage = new PublishMqttInMessage(0b0110_0011 as byte) {{ messageId = expectedMessageId @@ -368,7 +368,7 @@ class PublishMqttInMessageHandlerTest extends IntegrationServiceSpecification { }} messageHandler.processValidMessage(mqttConnection, publishMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.TOPIC_NAME_INVALID disconnectReason.reason() == null disconnectReason.serverReference() == null diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandlerTest.groovy index e47c729e..df3539ba 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/SubscribeMqttInMessageHandlerTest.groovy @@ -11,7 +11,7 @@ import javasabr.mqtt.network.message.out.DisconnectMqtt5OutMessage import javasabr.mqtt.network.message.out.SubscribeAckMqtt5OutMessage import javasabr.mqtt.network.util.ExtraErrorReasons import javasabr.mqtt.service.IntegrationServiceSpecification -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser import javasabr.rlib.collections.array.Array import javasabr.rlib.collections.array.MutableArray import javasabr.rlib.common.util.ThreadUtils @@ -32,13 +32,13 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultSubscriptionService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.session(null) + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.session(null) when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.UNSPECIFIED_ERROR disconnectReason.reason() == ExtraErrorReasons.SESSION_IS_ALREADY_CLOSED disconnectReason.serverReference() == null @@ -52,8 +52,8 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - def session = mqttClient.session() + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + def session = mqttUser.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.SUBSCRIBE) when: @@ -66,7 +66,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == SubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE @@ -84,7 +84,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -96,7 +96,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == SubscribeAckReasonCode.SUBSCRIPTION_IDENTIFIERS_NOT_SUPPORTED @@ -114,7 +114,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -126,7 +126,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == SubscribeAckReasonCode.GRANTED_QOS_0 @@ -144,7 +144,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -155,13 +155,13 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == SubscribeAckReasonCode.WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED reasonCodes.get(1) == SubscribeAckReasonCode.WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED subscribeAck.messageId() == expectedMessageId - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED disconnectReason.reason() == null disconnectReason.serverReference() == null @@ -177,7 +177,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -188,13 +188,13 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == SubscribeAckReasonCode.SHARED_SUBSCRIPTIONS_NOT_SUPPORTED reasonCodes.get(1) == SubscribeAckReasonCode.SHARED_SUBSCRIPTIONS_NOT_SUPPORTED subscribeAck.messageId() == expectedMessageId - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.SHARED_SUBSCRIPTIONS_NOT_SUPPORTED disconnectReason.reason() == null disconnectReason.serverReference() == null @@ -207,12 +207,12 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultSubscriptionService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(0 as byte) messageHandler.processInvalidMessage(mqttConnection, subscribeMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.MALFORMED_PACKET disconnectReason.reason() == "Unexpected message flags:[0b0000_0000] in message:[$MqttMessageType.SUBSCRIBE]" disconnectReason.serverReference() == null @@ -226,7 +226,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -235,7 +235,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 1 reasonCodes.get(0) == SubscribeAckReasonCode.GRANTED_QOS_2 @@ -249,7 +249,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage2) then: - def subscribeAck2 = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck2 = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes2 = subscribeAck2.reasonCodes() reasonCodes2.size() == 1 reasonCodes2.get(0) == SubscribeAckReasonCode.GRANTED_QOS_2 @@ -264,8 +264,8 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.returnCompletedFeatures(false) + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.returnCompletedFeatures(false) when: def subscribeMessage = new SubscribeMqttInMessage(SubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -274,7 +274,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage) then: - def subscribeAck = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes = subscribeAck.reasonCodes() reasonCodes.size() == 1 reasonCodes.get(0) == SubscribeAckReasonCode.GRANTED_QOS_2 @@ -288,7 +288,7 @@ class SubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecification }} messageHandler.processValidMessage(mqttConnection, subscribeMessage2) then: - def subscribeAck2 = mqttClient.nextSentMessage(SubscribeAckMqtt5OutMessage) + def subscribeAck2 = mqttUser.nextSentMessage(SubscribeAckMqtt5OutMessage) def reasonCodes2 = subscribeAck2.reasonCodes() reasonCodes2.size() == 1 reasonCodes2.get(0) == SubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandlerTest.groovy index 33a37300..2ebca07c 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/message/handler/impl/UnsubscribeMqttInMessageHandlerTest.groovy @@ -11,7 +11,7 @@ import javasabr.mqtt.network.message.out.DisconnectMqtt5OutMessage import javasabr.mqtt.network.message.out.UnsubscribeAckMqtt5OutMessage import javasabr.mqtt.network.util.ExtraErrorReasons import javasabr.mqtt.service.IntegrationServiceSpecification -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser import javasabr.mqtt.service.impl.InMemorySubscriptionService import javasabr.rlib.collections.array.Array import javasabr.rlib.collections.array.MutableArray @@ -26,13 +26,13 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultSubscriptionService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.session(null) + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.session(null) when: def unsubscribeMessage = new UnsubscribeMqttInMessage(UnsubscribeMqttInMessage.MESSAGE_FLAGS) messageHandler.processValidMessage(mqttConnection, unsubscribeMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.UNSPECIFIED_ERROR disconnectReason.reason() == ExtraErrorReasons.SESSION_IS_ALREADY_CLOSED disconnectReason.serverReference() == null @@ -46,8 +46,8 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - def session = mqttClient.session() + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + def session = mqttUser.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.UNSUBSCRIBE_ACK) when: @@ -58,7 +58,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage) then: - def unsubscribeAck = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes = unsubscribeAck.reasonCodes() reasonCodes.size() == 2 reasonCodes.get(0) == UnsubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE @@ -75,13 +75,13 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - def session = mqttClient.session() - def topicFilter1 = defaultTopicService.createTopicFilter(mqttClient, "topic/exist") - def topicFilter2 = defaultTopicService.createTopicFilter(mqttClient, "topic/exist2") - def topicFilter3 = defaultTopicService.createTopicFilter(mqttClient, "topic/exist3") + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + def session = mqttUser.session() + def topicFilter1 = defaultTopicService.createTopicFilter(mqttUser, "topic/exist") + def topicFilter2 = defaultTopicService.createTopicFilter(mqttUser, "topic/exist2") + def topicFilter3 = defaultTopicService.createTopicFilter(mqttUser, "topic/exist3") subscriptionService.subscribe( - mqttClient, + mqttUser, session, Array.of( Subscription.minimal(topicFilter1, QoS.AT_MOST_ONCE), @@ -95,7 +95,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage) then: - def unsubscribeAck = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes = unsubscribeAck.reasonCodes() reasonCodes.size() == 4 reasonCodes.get(0) == UnsubscribeAckReasonCode.SUCCESS @@ -104,16 +104,16 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio reasonCodes.get(3) == UnsubscribeAckReasonCode.TOPIC_FILTER_INVALID unsubscribeAck.messageId() == expectedMessageId when: - def topicName1 = defaultTopicService.createTopicName(mqttClient, "topic/exist") - def topicName2 = defaultTopicService.createTopicName(mqttClient, "topic/exist2") - def topicName3 = defaultTopicService.createTopicName(mqttClient, "topic/exist3") + def topicName1 = defaultTopicService.createTopicName(mqttUser, "topic/exist") + def topicName2 = defaultTopicService.createTopicName(mqttUser, "topic/exist2") + def topicName3 = defaultTopicService.createTopicName(mqttUser, "topic/exist3") def subscribers1 = subscriptionService.findSubscribers(topicName1) def subscribers2 = subscriptionService.findSubscribers(topicName2) def subscribers3 = subscriptionService.findSubscribers(topicName3) then: subscribers1.isEmpty() subscribers2.isEmpty() - subscribers3.size() == 1 && subscribers3.first().user() == mqttClient + subscribers3.size() == 1 && subscribers3.first().user() == mqttUser } def "should close connection by reason MQTT protocol error"() { @@ -123,12 +123,12 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultSubscriptionService, defaultMessageOutFactoryService, defaultTopicService) - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def unsubscribeMessage = new UnsubscribeMqttInMessage(0 as byte) messageHandler.processInvalidMessage(mqttConnection, unsubscribeMessage) then: - def disconnectReason = mqttClient.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnectReason = mqttUser.nextSentMessage(DisconnectMqtt5OutMessage) disconnectReason.reasonCode() == DisconnectReasonCode.MALFORMED_PACKET disconnectReason.reason() == "Unexpected message flags:[0b0000_0000] in message:[$MqttMessageType.UNSUBSCRIBE]" disconnectReason.serverReference() == null @@ -142,7 +142,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser when: def unsubscribeMessage = new UnsubscribeMqttInMessage(UnsubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -151,7 +151,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage) then: - def unsubscribeAck = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes = unsubscribeAck.reasonCodes() reasonCodes.size() == 1 reasonCodes.get(0) == UnsubscribeAckReasonCode.NO_SUBSCRIPTION_EXISTED @@ -165,7 +165,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage2) then: - def unsubscribeAck2 = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck2 = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes2 = unsubscribeAck2.reasonCodes() reasonCodes2.size() == 1 reasonCodes2.get(0) == UnsubscribeAckReasonCode.NO_SUBSCRIPTION_EXISTED @@ -180,8 +180,8 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio defaultMessageOutFactoryService, defaultTopicService) def expectedMessageId = 15 - def mqttClient = mqttConnection.client() as TestExternalMqttClient - mqttClient.returnCompletedFeatures(false) + def mqttUser = mqttConnection.user() as TestExternalNetworkMqttUser + mqttUser.returnCompletedFeatures(false) when: def unsubscribeMessage = new UnsubscribeMqttInMessage(UnsubscribeMqttInMessage.MESSAGE_FLAGS) {{ this.messageId = expectedMessageId @@ -190,7 +190,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage) then: - def unsubscribeAck = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes = unsubscribeAck.reasonCodes() reasonCodes.size() == 1 reasonCodes.get(0) == UnsubscribeAckReasonCode.NO_SUBSCRIPTION_EXISTED @@ -204,7 +204,7 @@ class UnsubscribeMqttInMessageHandlerTest extends IntegrationServiceSpecificatio }} messageHandler.processValidMessage(mqttConnection, unsubscribeMessage2) then: - def unsubscribeAck2 = mqttClient.nextSentMessage(UnsubscribeAckMqtt5OutMessage) + def unsubscribeAck2 = mqttUser.nextSentMessage(UnsubscribeAckMqtt5OutMessage) def reasonCodes2 = unsubscribeAck2.reasonCodes() reasonCodes2.size() == 1 reasonCodes2.get(0) == UnsubscribeAckReasonCode.PACKET_IDENTIFIER_IN_USE diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandlerTest.groovy index 0174c330..7abb9682 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos0MqttPublishInMessageHandlerTest.groovy @@ -5,7 +5,7 @@ import javasabr.mqtt.model.QoS import javasabr.mqtt.model.publishing.Publish import javasabr.mqtt.model.subscription.Subscription import javasabr.mqtt.network.message.out.PublishMqtt5OutMessage -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser import javasabr.rlib.collections.array.Array class Qos0MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandlerTest { @@ -19,9 +19,9 @@ class Qos0MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler def subscriber1 = mockedExternalConnection(MqttVersion.MQTT_5) def subscriber2 = mockedExternalConnection(MqttVersion.MQTT_5) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client1 = subscriber1.client() as TestExternalMqttClient - def client2 = subscriber2.client() as TestExternalMqttClient - def client3 = publisher.client() as TestExternalMqttClient + def client1 = subscriber1.user() as TestExternalNetworkMqttUser + def client2 = subscriber2.user() as TestExternalNetworkMqttUser + def client3 = publisher.user() as TestExternalNetworkMqttUser def topicFilter = defaultTopicService.createTopicFilter(client1, "Qos0MqttPublishInMessageHandlerTest/1") def topicName = defaultTopicService.createTopicName(client1, "Qos0MqttPublishInMessageHandlerTest/1") defaultSubscriptionService.subscribe( @@ -50,11 +50,11 @@ class Qos0MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos0MqttPublishInMessageHandlerTest/2") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos0MqttPublishInMessageHandlerTest/2") when: - publishInHandler.handle(client, Publish.minimal(QoS.AT_MOST_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(QoS.AT_MOST_ONCE, topicName, testPayload)) then: 'sender should not have any feedback' - client.isEmpty() + user.isEmpty() } } diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandlerTest.groovy index 0d597fcb..1f69fba0 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos1MqttPublishInMessageHandlerTest.groovy @@ -13,7 +13,7 @@ import javasabr.mqtt.network.message.out.DisconnectMqtt5OutMessage import javasabr.mqtt.network.message.out.MqttOutMessage import javasabr.mqtt.network.message.out.PublishAckMqtt5OutMessage import javasabr.mqtt.network.message.out.PublishMqtt5OutMessage -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser import javasabr.rlib.collections.array.Array class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandlerTest { @@ -27,9 +27,9 @@ class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler def subscriber1 = mockedExternalConnection(MqttVersion.MQTT_5) def subscriber2 = mockedExternalConnection(MqttVersion.MQTT_5) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client1 = subscriber1.client() as TestExternalMqttClient - def client2 = subscriber2.client() as TestExternalMqttClient - def client3 = publisher.client() as TestExternalMqttClient + def client1 = subscriber1.user() as TestExternalNetworkMqttUser + def client2 = subscriber2.user() as TestExternalNetworkMqttUser + def client3 = publisher.user() as TestExternalNetworkMqttUser def topicFilter = defaultTopicService.createTopicFilter(client1, "Qos1MqttPublishInMessageHandlerTest/1") def topicName = defaultTopicService.createTopicName(client1, "Qos1MqttPublishInMessageHandlerTest/1") def expectedMessageId = 35 @@ -67,15 +67,15 @@ class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos1MqttPublishInMessageHandlerTest/2") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos1MqttPublishInMessageHandlerTest/2") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() when: - publishInHandler.handle(client, Publish.minimal(expectedMessageId, QoS.AT_MOST_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(expectedMessageId, QoS.AT_MOST_ONCE, topicName, testPayload)) then: 'sender should have feedback that no matched subscribers' - def publishAck = client.nextSentMessage(PublishAckMqtt5OutMessage) + def publishAck = user.nextSentMessage(PublishAckMqtt5OutMessage) publishAck.reasonCode() == PublishAckReasonCode.NO_MATCHING_SUBSCRIBERS publishAck.messageId() == expectedMessageId publishAck.reason() == null @@ -90,16 +90,16 @@ class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos1MqttPublishInMessageHandlerTest/3") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos1MqttPublishInMessageHandlerTest/3") when: - publishInHandler.handle(client, Publish.minimal( + publishInHandler.handle(user, Publish.minimal( MqttProperties.MESSAGE_ID_IS_NOT_SET, QoS.AT_MOST_ONCE, topicName, testPayload)) then: - def disconnect = client.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnect = user.nextSentMessage(DisconnectMqtt5OutMessage) disconnect.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnect.reason() == MqttProtocolErrors.MISSED_REQUIRED_MESSAGE_ID disconnect.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -112,16 +112,16 @@ class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos1MqttPublishInMessageHandlerTest/4") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos1MqttPublishInMessageHandlerTest/4") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.SUBSCRIBE) when: - publishInHandler.handle(client, Publish.minimal(expectedMessageId, QoS.AT_MOST_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(expectedMessageId, QoS.AT_MOST_ONCE, topicName, testPayload)) then: - def publishAck = client.nextSentMessage(PublishAckMqtt5OutMessage) + def publishAck = user.nextSentMessage(PublishAckMqtt5OutMessage) publishAck.reasonCode() == PublishAckReasonCode.PACKET_IDENTIFIER_IN_USE publishAck.reason() == null publishAck.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -137,17 +137,17 @@ class Qos1MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos1MqttPublishInMessageHandlerTest/5") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos1MqttPublishInMessageHandlerTest/5") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.PUBLISH) when: - publishInHandler.handle(client, Publish + publishInHandler.handle(user, Publish .minimal(expectedMessageId, QoS.AT_MOST_ONCE, topicName, testPayload) .withDuplicated()) then: - client.isEmpty() + user.isEmpty() } } diff --git a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandlerTest.groovy b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandlerTest.groovy index 368d50e8..c185f68d 100644 --- a/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandlerTest.groovy +++ b/core-service/src/test/groovy/javasabr/mqtt/service/publish/handler/impl/Qos2MqttPublishInMessageHandlerTest.groovy @@ -17,7 +17,7 @@ import javasabr.mqtt.network.message.out.MqttOutMessage import javasabr.mqtt.network.message.out.PublishCompleteMqtt5OutMessage import javasabr.mqtt.network.message.out.PublishMqtt5OutMessage import javasabr.mqtt.network.message.out.PublishReceivedMqtt5OutMessage -import javasabr.mqtt.service.TestExternalMqttClient +import javasabr.mqtt.service.TestExternalNetworkMqttUser import javasabr.rlib.collections.array.Array class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandlerTest { @@ -31,9 +31,9 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler def subscriber1 = mockedExternalConnection(MqttVersion.MQTT_5) def subscriber2 = mockedExternalConnection(MqttVersion.MQTT_5) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client1 = subscriber1.client() as TestExternalMqttClient - def client2 = subscriber2.client() as TestExternalMqttClient - def client3 = publisher.client() as TestExternalMqttClient + def client1 = subscriber1.user() as TestExternalNetworkMqttUser + def client2 = subscriber2.user() as TestExternalNetworkMqttUser + def client3 = publisher.user() as TestExternalNetworkMqttUser def topicFilter = defaultTopicService.createTopicFilter(client1, "Qos2MqttPublishInMessageHandlerTest/1") def topicName = defaultTopicService.createTopicName(client1, "Qos2MqttPublishInMessageHandlerTest/1") def expectedMessageId = 35 @@ -87,15 +87,15 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos2MqttPublishInMessageHandlerTest/2") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos2MqttPublishInMessageHandlerTest/2") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() when: - publishInHandler.handle(client, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) then: 'sender should have feedback that no matched subscribers' - def publishReceive = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive.reasonCode() == PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS publishReceive.messageId() == expectedMessageId publishReceive.reason() == null @@ -111,7 +111,7 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler }} defaultPublishReleaseMqttInMessageHandler.processValidMessage(publisher, publishRelease) then: - def publishComplete = client.nextSentMessage(PublishCompleteMqtt5OutMessage) + def publishComplete = user.nextSentMessage(PublishCompleteMqtt5OutMessage) publishComplete.reasonCode() == PublishCompletedReasonCode.SUCCESS publishComplete.messageId() == expectedMessageId publishComplete.reason() == null @@ -126,16 +126,16 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos2MqttPublishInMessageHandlerTest/3") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos2MqttPublishInMessageHandlerTest/3") when: - publishInHandler.handle(client, Publish.minimal( + publishInHandler.handle(user, Publish.minimal( MqttProperties.MESSAGE_ID_IS_NOT_SET, QoS.EXACTLY_ONCE, topicName, testPayload)) then: - def disconnect = client.nextSentMessage(DisconnectMqtt5OutMessage) + def disconnect = user.nextSentMessage(DisconnectMqtt5OutMessage) disconnect.reasonCode() == DisconnectReasonCode.PROTOCOL_ERROR disconnect.reason() == MqttProtocolErrors.MISSED_REQUIRED_MESSAGE_ID disconnect.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -148,16 +148,16 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos2MqttPublishInMessageHandlerTest/4") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos2MqttPublishInMessageHandlerTest/4") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.SUBSCRIBE) when: - publishInHandler.handle(client, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) then: - def publishReceive = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive.reasonCode() == PublishReceivedReasonCode.PACKET_IDENTIFIER_IN_USE publishReceive.reason() == null publishReceive.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -173,18 +173,18 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos2MqttPublishInMessageHandlerTest/5") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos2MqttPublishInMessageHandlerTest/5") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() inMessageTracker.add(expectedMessageId, MqttMessageType.PUBLISH, PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS) when: - publishInHandler.handle(client, Publish + publishInHandler.handle(user, Publish .minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload) .withDuplicated()) then: - def publishReceive = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive.reasonCode() == PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS publishReceive.reason() == null publishReceive.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -200,15 +200,15 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler defaultPublishDeliveringService, defaultMessageOutFactoryService) def publisher = mockedExternalConnection(MqttVersion.MQTT_5) - def client = publisher.client() as TestExternalMqttClient - def topicName = defaultTopicService.createTopicName(client, "Qos2MqttPublishInMessageHandlerTest/5") + def user = publisher.user() as TestExternalNetworkMqttUser + def topicName = defaultTopicService.createTopicName(user, "Qos2MqttPublishInMessageHandlerTest/5") def expectedMessageId = 35 - def session = client.session() + def session = user.session() def inMessageTracker = session.inMessageTracker() when: 'init floy by original publish' - publishInHandler.handle(client, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) + publishInHandler.handle(user, Publish.minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload)) then: - def publishReceive = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive.reasonCode() == PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS publishReceive.reason() == null publishReceive.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -217,11 +217,11 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler trackedMessageMeta.messageType() == MqttMessageType.PUBLISH trackedMessageMeta.reasonCode() == PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS when: 'send duplicated before publish release' - publishInHandler.handle(client, Publish + publishInHandler.handle(user, Publish .minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload) .withDuplicated()) then: 'server should return the same feedback for duplicated as for original' - def publishReceive2 = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive2 = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive2.reasonCode() == PublishReceivedReasonCode.NO_MATCHING_SUBSCRIBERS publishReceive2.reason() == null publishReceive2.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES @@ -234,10 +234,10 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler messageId = expectedMessageId reasonCode = PublishReleaseReasonCode.SUCCESS }} - client.returnCompletedFeatures(false) + user.returnCompletedFeatures(false) defaultPublishReleaseMqttInMessageHandler.processValidMessage(publisher, publishRelease) then: - def publishComplete = client.nextSentMessage(PublishCompleteMqtt5OutMessage) + def publishComplete = user.nextSentMessage(PublishCompleteMqtt5OutMessage) publishComplete.reasonCode() == PublishCompletedReasonCode.SUCCESS publishComplete.messageId() == expectedMessageId publishComplete.reason() == null @@ -246,11 +246,11 @@ class Qos2MqttPublishInMessageHandlerTest extends QosMqttPublishInMessageHandler trackedMessageMeta3 != null trackedMessageMeta3.messageType() == MqttMessageType.PUBLISH_COMPLETE when: 'send duplicated after publish release' - publishInHandler.handle(client, Publish + publishInHandler.handle(user, Publish .minimal(expectedMessageId, QoS.EXACTLY_ONCE, topicName, testPayload) .withDuplicated()) then: 'server should return that this message id is already used because publish complete is in progress of sending' - def publishReceive3 = client.nextSentMessage(PublishReceivedMqtt5OutMessage) + def publishReceive3 = user.nextSentMessage(PublishReceivedMqtt5OutMessage) publishReceive3.reasonCode() == PublishReceivedReasonCode.PACKET_IDENTIFIER_IN_USE publishReceive3.reason() == null publishReceive3.userProperties() == MqttOutMessage.EMPTY_USER_PROPERTIES diff --git a/model/src/main/java/javasabr/mqtt/model/session/TrackableMessageCallback.java b/model/src/main/java/javasabr/mqtt/model/session/TrackableMessageCallback.java index cb2d9861..02f0d7b2 100644 --- a/model/src/main/java/javasabr/mqtt/model/session/TrackableMessageCallback.java +++ b/model/src/main/java/javasabr/mqtt/model/session/TrackableMessageCallback.java @@ -8,5 +8,5 @@ public interface TrackableMessageCallback { /** * @return true if this handler should be de-register */ - boolean accept(MqttUser owner, Object session, TrackableMqttMessage message); + boolean accept(MqttUser owner, MqttSession session, TrackableMqttMessage message); } diff --git a/model/src/main/java/javasabr/mqtt/model/session/package-info.java b/model/src/main/java/javasabr/mqtt/model/session/package-info.java new file mode 100644 index 00000000..6bf24328 --- /dev/null +++ b/model/src/main/java/javasabr/mqtt/model/session/package-info.java @@ -0,0 +1,4 @@ +@NullMarked +package javasabr.mqtt.model.session; + +import org.jspecify.annotations.NullMarked; diff --git a/network/src/main/java/javasabr/mqtt/network/MqttClientFactory.java b/network/src/main/java/javasabr/mqtt/network/MqttClientFactory.java deleted file mode 100644 index 1f44c450..00000000 --- a/network/src/main/java/javasabr/mqtt/network/MqttClientFactory.java +++ /dev/null @@ -1,8 +0,0 @@ -package javasabr.mqtt.network; - -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; - -public interface MqttClientFactory { - - UnsafeMqttClient newClient(MqttConnection connection); -} diff --git a/network/src/main/java/javasabr/mqtt/network/MqttConnection.java b/network/src/main/java/javasabr/mqtt/network/MqttConnection.java index 61ad22a1..e88c1cf6 100644 --- a/network/src/main/java/javasabr/mqtt/network/MqttConnection.java +++ b/network/src/main/java/javasabr/mqtt/network/MqttConnection.java @@ -4,9 +4,11 @@ import javasabr.mqtt.model.MqttClientConnectionConfig; import javasabr.mqtt.model.MqttServerConnectionConfig; import javasabr.mqtt.model.MqttVersion; -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; import javasabr.mqtt.network.message.MqttMessageReader; import javasabr.mqtt.network.message.MqttMessageWriter; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUser; +import javasabr.mqtt.network.user.NetworkMqttUserFactory; import javasabr.rlib.network.BufferAllocator; import javasabr.rlib.network.Network; import javasabr.rlib.network.impl.AbstractConnection; @@ -29,7 +31,7 @@ public class MqttConnection extends AbstractConnection { @Getter(AccessLevel.PROTECTED) final NetworkPacketWriter packetWriter; - final UnsafeMqttClient client; + final ConfigurableNetworkMqttUser user; @Getter final MqttServerConnectionConfig serverConnectionConfig; @@ -42,12 +44,12 @@ public MqttConnection( BufferAllocator bufferAllocator, int maxPacketsByRead, MqttServerConnectionConfig serverConnectionConfig, - MqttClientFactory clientFactory) { + NetworkMqttUserFactory mqttUserFactory) { super(network, channel, bufferAllocator, maxPacketsByRead); this.serverConnectionConfig = serverConnectionConfig; this.packetReader = createPacketReader(); this.packetWriter = createPacketWriter(); - this.client = clientFactory.newClient(this); + this.user = mqttUserFactory.createNetworkUser(this); } public boolean isSupported(MqttVersion mqttVersion) { @@ -75,8 +77,8 @@ public MqttClientConnectionConfig clientConnectionConfig() { return config; } - public MqttClient client() { - return client; + public NetworkMqttUser user() { + return user; } private NetworkPacketReader createPacketReader() { @@ -104,7 +106,7 @@ public String toString() { @Override protected void doClose() { - client.release().subscribe(); + user.release().subscribe(); super.doClose(); } } diff --git a/network/src/main/java/javasabr/mqtt/network/session/MqttNetworkSession.java b/network/src/main/java/javasabr/mqtt/network/MqttNetworkSession.java similarity index 66% rename from network/src/main/java/javasabr/mqtt/network/session/MqttNetworkSession.java rename to network/src/main/java/javasabr/mqtt/network/MqttNetworkSession.java index fe04c2ef..2fd1fd6d 100644 --- a/network/src/main/java/javasabr/mqtt/network/session/MqttNetworkSession.java +++ b/network/src/main/java/javasabr/mqtt/network/MqttNetworkSession.java @@ -1,9 +1,9 @@ -package javasabr.mqtt.network.session; +package javasabr.mqtt.network; import javasabr.mqtt.model.message.TrackableMqttMessage; import javasabr.mqtt.model.publishing.Publish; import javasabr.mqtt.model.session.MqttSession; -import javasabr.mqtt.network.MqttClient; +import javasabr.mqtt.network.user.NetworkMqttUser; public interface MqttNetworkSession extends MqttSession { @@ -23,12 +23,12 @@ interface PendingMessageHandler { /** * @return true if pending packet can be removed. */ - boolean handleResponse(MqttClient client, TrackableMqttMessage response); + boolean handleResponse(NetworkMqttUser user, TrackableMqttMessage response); - default void resend(MqttClient client, Publish publish) {} + default void resend(NetworkMqttUser user, Publish publish) {} } - void resendPendingPackets(MqttClient client); + void resendPendingPackets(NetworkMqttUser user); boolean hasOutPending(); @@ -36,5 +36,5 @@ default void resend(MqttClient client, Publish publish) {} void registerOutPublish(Publish publish, PendingMessageHandler handler); - void updateOutPendingPacket(MqttClient client, TrackableMqttMessage response); + void updateOutPendingPacket(NetworkMqttUser user, TrackableMqttMessage response); } diff --git a/network/src/main/java/javasabr/mqtt/network/handler/MqttClientReleaseHandler.java b/network/src/main/java/javasabr/mqtt/network/handler/MqttClientReleaseHandler.java deleted file mode 100644 index ee6676c7..00000000 --- a/network/src/main/java/javasabr/mqtt/network/handler/MqttClientReleaseHandler.java +++ /dev/null @@ -1,9 +0,0 @@ -package javasabr.mqtt.network.handler; - -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; -import reactor.core.publisher.Mono; - -public interface MqttClientReleaseHandler { - - Mono release(UnsafeMqttClient client); -} diff --git a/network/src/main/java/javasabr/mqtt/network/handler/NetworkMqttUserReleaseHandler.java b/network/src/main/java/javasabr/mqtt/network/handler/NetworkMqttUserReleaseHandler.java new file mode 100644 index 00000000..19a3bf05 --- /dev/null +++ b/network/src/main/java/javasabr/mqtt/network/handler/NetworkMqttUserReleaseHandler.java @@ -0,0 +1,9 @@ +package javasabr.mqtt.network.handler; + +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; +import reactor.core.publisher.Mono; + +public interface NetworkMqttUserReleaseHandler { + + Mono release(ConfigurableNetworkMqttUser user); +} diff --git a/network/src/main/java/javasabr/mqtt/network/impl/AbstractMqttClient.java b/network/src/main/java/javasabr/mqtt/network/impl/AbstractNetworkMqttUser.java similarity index 85% rename from network/src/main/java/javasabr/mqtt/network/impl/AbstractMqttClient.java rename to network/src/main/java/javasabr/mqtt/network/impl/AbstractNetworkMqttUser.java index b26df952..23114468 100644 --- a/network/src/main/java/javasabr/mqtt/network/impl/AbstractMqttClient.java +++ b/network/src/main/java/javasabr/mqtt/network/impl/AbstractNetworkMqttUser.java @@ -4,12 +4,12 @@ import java.util.concurrent.atomic.AtomicBoolean; import javasabr.mqtt.base.util.DebugUtils; import javasabr.mqtt.model.MqttClientConnectionConfig; -import javasabr.mqtt.network.MqttClient.UnsafeMqttClient; import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; import javasabr.mqtt.network.message.out.ConnectAckMqtt311OutMessage; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser; import lombok.AccessLevel; import lombok.CustomLog; import lombok.Getter; @@ -23,14 +23,14 @@ @CustomLog @Accessors(fluent = true, chain = false) @FieldDefaults(level = AccessLevel.PROTECTED) -public abstract class AbstractMqttClient implements UnsafeMqttClient { +public abstract class AbstractNetworkMqttUser implements ConfigurableNetworkMqttUser { static { DebugUtils.registerIncludedFields("clientId"); } final MqttConnection connection; - final MqttClientReleaseHandler releaseHandler; + final NetworkMqttUserReleaseHandler releaseHandler; final AtomicBoolean released; @Setter @@ -43,7 +43,7 @@ public abstract class AbstractMqttClient implements UnsafeMqttClient { @Nullable volatile MqttNetworkSession session; - public AbstractMqttClient(MqttConnection connection, MqttClientReleaseHandler releaseHandler) { + public AbstractNetworkMqttUser(MqttConnection connection, NetworkMqttUserReleaseHandler releaseHandler) { this.connection = connection; this.releaseHandler = releaseHandler; this.released = new AtomicBoolean(false); diff --git a/network/src/main/java/javasabr/mqtt/network/impl/ExternalMqttClient.java b/network/src/main/java/javasabr/mqtt/network/impl/ExternalMqttClient.java deleted file mode 100644 index 202136eb..00000000 --- a/network/src/main/java/javasabr/mqtt/network/impl/ExternalMqttClient.java +++ /dev/null @@ -1,16 +0,0 @@ -package javasabr.mqtt.network.impl; - -import javasabr.mqtt.base.util.DebugUtils; -import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; - -public class ExternalMqttClient extends AbstractMqttClient { - - static { - DebugUtils.registerIncludedFields("clientId"); - } - - public ExternalMqttClient(MqttConnection connection, MqttClientReleaseHandler releaseHandler) { - super(connection, releaseHandler); - } -} diff --git a/network/src/main/java/javasabr/mqtt/network/impl/ExternalNetworkMqttUser.java b/network/src/main/java/javasabr/mqtt/network/impl/ExternalNetworkMqttUser.java new file mode 100644 index 00000000..c5f5bfc0 --- /dev/null +++ b/network/src/main/java/javasabr/mqtt/network/impl/ExternalNetworkMqttUser.java @@ -0,0 +1,16 @@ +package javasabr.mqtt.network.impl; + +import javasabr.mqtt.base.util.DebugUtils; +import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; + +public class ExternalNetworkMqttUser extends AbstractNetworkMqttUser { + + static { + DebugUtils.registerIncludedFields("clientId"); + } + + public ExternalNetworkMqttUser(MqttConnection connection, NetworkMqttUserReleaseHandler releaseHandler) { + super(connection, releaseHandler); + } +} diff --git a/network/src/main/java/javasabr/mqtt/network/impl/InternalMqttClient.java b/network/src/main/java/javasabr/mqtt/network/impl/InternalMqttClient.java deleted file mode 100644 index bc901e64..00000000 --- a/network/src/main/java/javasabr/mqtt/network/impl/InternalMqttClient.java +++ /dev/null @@ -1,16 +0,0 @@ -package javasabr.mqtt.network.impl; - -import javasabr.mqtt.base.util.DebugUtils; -import javasabr.mqtt.network.MqttConnection; -import javasabr.mqtt.network.handler.MqttClientReleaseHandler; - -public class InternalMqttClient extends AbstractMqttClient { - - static { - DebugUtils.registerIncludedFields("clientId"); - } - - public InternalMqttClient(MqttConnection connection, MqttClientReleaseHandler releaseHandler) { - super(connection, releaseHandler); - } -} diff --git a/network/src/main/java/javasabr/mqtt/network/impl/InternalNetworkMqttUser.java b/network/src/main/java/javasabr/mqtt/network/impl/InternalNetworkMqttUser.java new file mode 100644 index 00000000..b9d1b52c --- /dev/null +++ b/network/src/main/java/javasabr/mqtt/network/impl/InternalNetworkMqttUser.java @@ -0,0 +1,16 @@ +package javasabr.mqtt.network.impl; + +import javasabr.mqtt.base.util.DebugUtils; +import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.handler.NetworkMqttUserReleaseHandler; + +public class InternalNetworkMqttUser extends AbstractNetworkMqttUser { + + static { + DebugUtils.registerIncludedFields("clientId"); + } + + public InternalNetworkMqttUser(MqttConnection connection, NetworkMqttUserReleaseHandler releaseHandler) { + super(connection, releaseHandler); + } +} diff --git a/network/src/main/java/javasabr/mqtt/network/session/package-info.java b/network/src/main/java/javasabr/mqtt/network/session/package-info.java deleted file mode 100644 index 86ec8b47..00000000 --- a/network/src/main/java/javasabr/mqtt/network/session/package-info.java +++ /dev/null @@ -1,4 +0,0 @@ -@NullMarked -package javasabr.mqtt.network.session; - -import org.jspecify.annotations.NullMarked; \ No newline at end of file diff --git a/network/src/main/java/javasabr/mqtt/network/user/ConfigurableNetworkMqttUser.java b/network/src/main/java/javasabr/mqtt/network/user/ConfigurableNetworkMqttUser.java new file mode 100644 index 00000000..c849b6fc --- /dev/null +++ b/network/src/main/java/javasabr/mqtt/network/user/ConfigurableNetworkMqttUser.java @@ -0,0 +1,20 @@ +package javasabr.mqtt.network.user; + +import javasabr.mqtt.network.MqttConnection; +import javasabr.mqtt.network.MqttNetworkSession; +import javasabr.mqtt.network.message.out.ConnectAckMqtt311OutMessage; +import org.jspecify.annotations.Nullable; +import reactor.core.publisher.Mono; + +public interface ConfigurableNetworkMqttUser extends NetworkMqttUser { + + MqttConnection connection(); + + void clientId(String clientId); + + void session(@Nullable MqttNetworkSession session); + + void reject(ConnectAckMqtt311OutMessage connectAsk); + + Mono release(); +} diff --git a/network/src/main/java/javasabr/mqtt/network/MqttClient.java b/network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUser.java similarity index 57% rename from network/src/main/java/javasabr/mqtt/network/MqttClient.java rename to network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUser.java index c6f0720f..2e4c7447 100644 --- a/network/src/main/java/javasabr/mqtt/network/MqttClient.java +++ b/network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUser.java @@ -1,29 +1,14 @@ -package javasabr.mqtt.network; +package javasabr.mqtt.network.user; import java.util.concurrent.CompletableFuture; import javasabr.mqtt.model.MqttClientConnectionConfig; import javasabr.mqtt.model.MqttUser; -import javasabr.mqtt.network.message.out.ConnectAckMqtt311OutMessage; +import javasabr.mqtt.network.MqttNetworkSession; import javasabr.mqtt.network.message.out.MqttOutMessage; -import javasabr.mqtt.network.session.MqttNetworkSession; import org.jspecify.annotations.Nullable; -import reactor.core.publisher.Mono; - -public interface MqttClient extends MqttUser { - - interface UnsafeMqttClient extends MqttClient { - - MqttConnection connection(); - - void clientId(String clientId); - - void session(@Nullable MqttNetworkSession session); - - void reject(ConnectAckMqtt311OutMessage connectAsk); - - Mono release(); - } +public interface NetworkMqttUser extends MqttUser { + @Nullable @Override MqttNetworkSession session(); diff --git a/network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUserFactory.java b/network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUserFactory.java new file mode 100644 index 00000000..5a9dee29 --- /dev/null +++ b/network/src/main/java/javasabr/mqtt/network/user/NetworkMqttUserFactory.java @@ -0,0 +1,8 @@ +package javasabr.mqtt.network.user; + +import javasabr.mqtt.network.MqttConnection; + +public interface NetworkMqttUserFactory { + + ConfigurableNetworkMqttUser createNetworkUser(MqttConnection connection); +} diff --git a/network/src/testFixtures/groovy/javasabr/mqtt/network/NetworkUnitSpecification.groovy b/network/src/testFixtures/groovy/javasabr/mqtt/network/NetworkUnitSpecification.groovy index 0644fc3d..c8d7da76 100644 --- a/network/src/testFixtures/groovy/javasabr/mqtt/network/NetworkUnitSpecification.groovy +++ b/network/src/testFixtures/groovy/javasabr/mqtt/network/NetworkUnitSpecification.groovy @@ -12,6 +12,8 @@ import javasabr.mqtt.model.reason.code.UnsubscribeAckReasonCode import javasabr.mqtt.model.subscription.Subscription import javasabr.mqtt.model.topic.TopicFilter import javasabr.mqtt.model.topic.TopicName +import javasabr.mqtt.network.user.ConfigurableNetworkMqttUser +import javasabr.mqtt.network.user.NetworkMqttUser import javasabr.mqtt.test.support.UnitSpecification import javasabr.rlib.collections.array.Array import javasabr.rlib.collections.array.IntArray @@ -113,10 +115,10 @@ class NetworkUnitSpecification extends UnitSpecification { MqttServerConnectionConfig defaultServerConnectionConfig = defaultServerConnectionConfig() @Shared - MqttClient defaultMqtt311Client = mqttClient(defaultMqtt311ClientConnectionConfig(), mqtt311ClientId) + NetworkMqttUser defaultMqtt311User = networkUser(defaultMqtt311ClientConnectionConfig(), mqtt311ClientId) @Shared - MqttClient defaultMqtt5Client = mqttClient(defaultMqtt5ClientConnectionConfig(), mqtt5ClientId) + NetworkMqttUser defaultMqtt5User = networkUser(defaultMqtt5ClientConnectionConfig(), mqtt5ClientId) @Shared MqttConnection defaultMqtt5Connection = mqtt5Connection(); @@ -253,25 +255,15 @@ class NetworkUnitSpecification extends UnitSpecification { } serverConnectionConfig() >> serverConfig clientConnectionConfig() >> clientConfig - client() >> mqttClient(clientConfig, clientId) + user() >> networkUser(clientConfig, clientId) } } - MqttClient mqttClient(MqttClientConnectionConfig clientConfig, String id) { - return Stub(MqttClient.UnsafeMqttClient) { + NetworkMqttUser networkUser(MqttClientConnectionConfig clientConfig, String id) { + return Stub(ConfigurableNetworkMqttUser) { connectionConfig() >> clientConfig clientId() >> id toString() >> id } } - - MqttClient newMqtt311Client() { - def config = defaultMqtt311ClientConnectionConfig() - def id = "generatedClient_${clientIdGenerator.incrementAndGet()}" - return Stub(MqttClient.UnsafeMqttClient) { - connectionConfig() >> config - clientId() >> id - toString() >> id - } - } }