Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Mqtt broker (#176)

Michael Rademakerb52f7ec80328
diff --git a/container/build.gradle b/container/build.gradle
index 901137af2..11f721db3 100644
--- a/container/build.gradle
+++ b/container/build.gradle
@@ -62,4 +62,4 @@ dependencies {
jar {
archivesBaseName = "openremote-${project.name}"
-}
\ No newline at end of file
+}
diff --git a/container/src/main/java/org/openremote/container/security/AuthForm.java b/container/src/main/java/org/openremote/container/security/AuthForm.java
index 77ba39a9c..ba6500a4e 100644
--- a/container/src/main/java/org/openremote/container/security/AuthForm.java
+++ b/container/src/main/java/org/openremote/container/security/AuthForm.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016, OpenRemote Inc.
+ * Copyright 2020, OpenRemote Inc.
*
* See the CONTRIBUTORS.txt file in the distribution for a
* full listing of individual contributors.
@@ -21,52 +21,21 @@ package org.openremote.container.security;
import javax.ws.rs.FormParam;
-public class AuthForm {
+public abstract class AuthForm {
@FormParam("client_id")
public String clientId;
- @FormParam("username")
- public String username;
-
- @FormParam("password")
- public String password;
-
@FormParam("grant_type")
public String grantType;
- public AuthForm() {
- }
-
public AuthForm setClientId(String clientId) {
this.clientId = clientId;
return this;
}
- public AuthForm setUsername(String username) {
- this.username = username;
- return this;
- }
-
- public AuthForm setPassword(String password) {
- this.password = password;
- return this;
- }
-
public AuthForm setGrantType(String grantType) {
this.grantType = grantType;
return this;
}
-
- public AuthForm(String clientId, String username, String password) {
- this(clientId, username, password, "password");
- }
-
- public AuthForm(String clientId, String username, String password, String grantType) {
- this.clientId = clientId;
- this.username = username;
- this.password = password;
- this.grantType = grantType;
- }
}
-
diff --git a/container/src/main/java/org/openremote/container/security/ClientCredentialsAuthForm.java b/container/src/main/java/org/openremote/container/security/ClientCredentialsAuthForm.java
new file mode 100644
index 000000000..bab112509
--- /dev/null
+++ b/container/src/main/java/org/openremote/container/security/ClientCredentialsAuthForm.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.container.security;
+
+import javax.ws.rs.FormParam;
+
+public class ClientCredentialsAuthForm extends AuthForm {
+
+ @FormParam("client_secret")
+ public String clientSecret;
+
+ public ClientCredentialsAuthForm setClientSecret(String clientSecret) {
+ this.clientSecret = clientSecret;
+ return this;
+ }
+
+ public ClientCredentialsAuthForm(String clientId, String clientSecret) {
+ this(clientId, clientSecret, "client_credentials");
+ }
+
+ public ClientCredentialsAuthForm(String clientId, String clientSecret, String grantType) {
+ this.clientId = clientId;
+ this.clientSecret = clientSecret;
+ this.grantType = grantType;
+ }
+}
diff --git a/container/src/main/java/org/openremote/container/security/PasswordAuthForm.java b/container/src/main/java/org/openremote/container/security/PasswordAuthForm.java
new file mode 100644
index 000000000..4a9b213c5
--- /dev/null
+++ b/container/src/main/java/org/openremote/container/security/PasswordAuthForm.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2020, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.container.security;
+
+import javax.ws.rs.FormParam;
+
+public class PasswordAuthForm extends AuthForm {
+
+ @FormParam("username")
+ public String username;
+
+ @FormParam("password")
+ public String password;
+
+ public PasswordAuthForm setUsername(String username) {
+ this.username = username;
+ return this;
+ }
+
+ public PasswordAuthForm setPassword(String password) {
+ this.password = password;
+ return this;
+ }
+
+ public PasswordAuthForm(String clientId, String username, String password) {
+ this(clientId, username, password, "password");
+ }
+
+ public PasswordAuthForm(String clientId, String username, String password, String grantType) {
+ this.clientId = clientId;
+ this.username = username;
+ this.password = password;
+ this.grantType = grantType;
+ }
+}
+
diff --git a/container/src/main/java/org/openremote/container/security/keycloak/KeycloakIdentityProvider.java b/container/src/main/java/org/openremote/container/security/keycloak/KeycloakIdentityProvider.java
index 8160cab04..0e27455ee 100644
--- a/container/src/main/java/org/openremote/container/security/keycloak/KeycloakIdentityProvider.java
+++ b/container/src/main/java/org/openremote/container/security/keycloak/KeycloakIdentityProvider.java
@@ -304,6 +304,11 @@ public abstract class KeycloakIdentityProvider implements IdentityProvider {
.proxy(KeycloakResource.class);
}
+ public KeycloakResource getExternalKeycloak() {
+ return getTarget(httpClient, keycloakServiceUri.build(), null, null, externalServerUri.build())
+ .proxy(KeycloakResource.class);
+ }
+
public RealmsResource getRealms(ClientRequestInfo clientRequestInfo) {
return getRealms(clientRequestInfo.getRemoteAddress(), clientRequestInfo.getAccessToken());
}
diff --git a/container/src/main/java/org/openremote/container/security/keycloak/KeycloakResource.java b/container/src/main/java/org/openremote/container/security/keycloak/KeycloakResource.java
index ffc7fcab6..3f9fb1ec5 100644
--- a/container/src/main/java/org/openremote/container/security/keycloak/KeycloakResource.java
+++ b/container/src/main/java/org/openremote/container/security/keycloak/KeycloakResource.java
@@ -22,7 +22,8 @@ package org.openremote.container.security.keycloak;
import org.keycloak.representations.AccessTokenResponse;
import org.keycloak.representations.adapters.config.AdapterConfig;
import org.keycloak.representations.idm.PublishedRealmRepresentation;
-import org.openremote.container.security.AuthForm;
+import org.openremote.container.security.PasswordAuthForm;
+import org.openremote.container.security.ClientCredentialsAuthForm;
import javax.ws.rs.*;
import javax.ws.rs.core.Response;
@@ -42,7 +43,13 @@ public interface KeycloakResource {
@Path("realms/{realm}/protocol/openid-connect/token")
@Consumes(APPLICATION_FORM_URLENCODED)
@Produces(APPLICATION_JSON)
- AccessTokenResponse getAccessToken(@PathParam("realm") String realm, @BeanParam AuthForm authForm);
+ AccessTokenResponse getAccessToken(@PathParam("realm") String realm, @BeanParam PasswordAuthForm authForm);
+
+ @POST
+ @Path("realms/{realm}/protocol/openid-connect/token")
+ @Consumes(APPLICATION_FORM_URLENCODED)
+ @Produces(APPLICATION_JSON)
+ AccessTokenResponse getAccessToken(@PathParam("realm") String realm, @BeanParam ClientCredentialsAuthForm authForm);
@GET
@Path("realms/{realm}")
@@ -54,4 +61,4 @@ public interface KeycloakResource {
@Produces(APPLICATION_JSON)
AdapterConfig getAdapterConfig(@PathParam("realm") String realm, @PathParam("clientId") String clientId);
-}
\ No newline at end of file
+}
diff --git a/container/src/main/java/org/openremote/container/web/socket/WebsocketConstants.java b/container/src/main/java/org/openremote/container/web/ConnectionConstants.java
similarity index 65%
rename from container/src/main/java/org/openremote/container/web/socket/WebsocketConstants.java
rename to container/src/main/java/org/openremote/container/web/ConnectionConstants.java
index 82d7cee83..663356f44 100644
--- a/container/src/main/java/org/openremote/container/web/socket/WebsocketConstants.java
+++ b/container/src/main/java/org/openremote/container/web/ConnectionConstants.java
@@ -17,16 +17,16 @@
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-package org.openremote.container.web.socket;
+package org.openremote.container.web;
-public interface WebsocketConstants {
+public interface ConnectionConstants {
- String SESSION = "websocket.session";
- String SESSION_KEY = "websocket.sessionKey";
- String SEND_TO_ALL = "websocket.sendToAll";
- String HANDSHAKE_AUTH = "websocket.auth";
- String SESSION_OPEN = "websocket.sessionOpen";
- String SESSION_CLOSE = "websocket.sessionClose";
- String SESSION_CLOSE_ERROR = "websocket.sessionCloseError";
+ String SESSION = "connection.session";
+ String SESSION_KEY = "connection.sessionKey";
+ String SEND_TO_ALL = "connection.sendToAll";
+ String HANDSHAKE_AUTH = "connection.auth";
+ String SESSION_OPEN = "connection.sessionOpen";
+ String SESSION_CLOSE = "connection.sessionClose";
+ String SESSION_CLOSE_ERROR = "connection.sessionCloseError";
}
diff --git a/container/src/main/java/org/openremote/container/web/DefaultWebsocketComponent.java b/container/src/main/java/org/openremote/container/web/DefaultWebsocketComponent.java
index e5174f27a..f181a89a2 100644
--- a/container/src/main/java/org/openremote/container/web/DefaultWebsocketComponent.java
+++ b/container/src/main/java/org/openremote/container/web/DefaultWebsocketComponent.java
@@ -35,7 +35,6 @@ import org.openremote.container.security.basic.BasicAuthContext;
import org.openremote.container.security.keycloak.AccessTokenAuthContext;
import org.openremote.container.web.socket.WebsocketAdapter;
import org.openremote.container.web.socket.WebsocketComponent;
-import org.openremote.container.web.socket.WebsocketConstants;
import org.xnio.OptionMap;
import org.xnio.Options;
import org.xnio.Xnio;
@@ -112,7 +111,7 @@ public class DefaultWebsocketComponent extends WebsocketComponent {
throw new WebApplicationException("Unsupported user principal type: " + principal, INTERNAL_SERVER_ERROR);
}
- config.getUserProperties().put(WebsocketConstants.HANDSHAKE_AUTH, authContext);
+ config.getUserProperties().put(ConnectionConstants.HANDSHAKE_AUTH, authContext);
super.modifyHandshake(config, request, response);
}
diff --git a/container/src/main/java/org/openremote/container/web/socket/WebsocketAdapter.java b/container/src/main/java/org/openremote/container/web/socket/WebsocketAdapter.java
index d628f76f8..e52b811f5 100644
--- a/container/src/main/java/org/openremote/container/web/socket/WebsocketAdapter.java
+++ b/container/src/main/java/org/openremote/container/web/socket/WebsocketAdapter.java
@@ -20,6 +20,7 @@
package org.openremote.container.web.socket;
import org.openremote.container.security.AuthContext;
+import org.openremote.container.web.ConnectionConstants;
import javax.websocket.CloseReason;
import javax.websocket.Endpoint;
@@ -48,14 +49,14 @@ public class WebsocketAdapter extends Endpoint {
session.setMaxIdleTimeout(0);
consumer.getEndpoint().getWebsocketSessions().add(session);
this.consumer.sendMessage(session.getId(), getHandshakeAuth(session), null, exchange -> {
- exchange.getIn().setHeader(WebsocketConstants.SESSION, session);
- exchange.getIn().setHeader(WebsocketConstants.SESSION_OPEN, true);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION, session);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION_OPEN, true);
});
session.addMessageHandler(String.class, message -> {
if (LOG.isLoggable(Level.FINE))
LOG.fine("Websocket session " + session.getId() + " message received: " + message);
this.consumer.sendMessage(session.getId(), getHandshakeAuth(session), message, exchange -> {
- exchange.getIn().setHeader(WebsocketConstants.SESSION, session);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION, session);
});
});
}
@@ -65,8 +66,8 @@ public class WebsocketAdapter extends Endpoint {
if (LOG.isLoggable(Level.FINE))
LOG.fine("Websocket session close: " + session.getId() + " " + closeReason);
this.consumer.sendMessage(session.getId(), getHandshakeAuth(session), closeReason, exchange -> {
- exchange.getIn().setHeader(WebsocketConstants.SESSION, session);
- exchange.getIn().setHeader(WebsocketConstants.SESSION_CLOSE, true);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION, session);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION_CLOSE, true);
});
consumer.getEndpoint().getWebsocketSessions().remove(session);
}
@@ -81,14 +82,14 @@ public class WebsocketAdapter extends Endpoint {
LOG.log(Level.INFO, "Websocket session error: " + session.getId(), thr);
}
this.consumer.sendMessage(session.getId(), getHandshakeAuth(session), thr, exchange -> {
- exchange.getIn().setHeader(WebsocketConstants.SESSION, session);
- exchange.getIn().setHeader(WebsocketConstants.SESSION_CLOSE_ERROR, true);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION, session);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION_CLOSE_ERROR, true);
});
consumer.getEndpoint().getWebsocketSessions().remove(session);
}
protected AuthContext getHandshakeAuth(Session session) {
- AuthContext auth = (AuthContext) session.getUserProperties().get(WebsocketConstants.HANDSHAKE_AUTH);
+ AuthContext auth = (AuthContext) session.getUserProperties().get(ConnectionConstants.HANDSHAKE_AUTH);
if (auth == null)
throw new IllegalStateException("No authorization details in websocket session: " + session.getId());
return auth;
diff --git a/container/src/main/java/org/openremote/container/web/socket/WebsocketConsumer.java b/container/src/main/java/org/openremote/container/web/socket/WebsocketConsumer.java
index 30ba704d5..6e3caddb1 100644
--- a/container/src/main/java/org/openremote/container/web/socket/WebsocketConsumer.java
+++ b/container/src/main/java/org/openremote/container/web/socket/WebsocketConsumer.java
@@ -23,6 +23,7 @@ import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.impl.DefaultConsumer;
import org.openremote.container.security.AuthContext;
+import org.openremote.container.web.ConnectionConstants;
import org.openremote.model.Constants;
import java.util.function.Consumer;
@@ -62,7 +63,7 @@ public class WebsocketConsumer extends DefaultConsumer {
public void sendMessage(final String sessionKey, final AuthContext authContext, final Object message, Consumer<Exchange> exchangePreparer) {
final Exchange exchange = getEndpoint().createExchange();
- exchange.getIn().setHeader(WebsocketConstants.SESSION_KEY, sessionKey);
+ exchange.getIn().setHeader(ConnectionConstants.SESSION_KEY, sessionKey);
exchange.getIn().setHeader(Constants.AUTH_CONTEXT, authContext);
exchange.getIn().setBody(message);
if (exchangePreparer != null) {
diff --git a/container/src/main/java/org/openremote/container/web/socket/WebsocketProducer.java b/container/src/main/java/org/openremote/container/web/socket/WebsocketProducer.java
index 031513ef4..146203ca2 100644
--- a/container/src/main/java/org/openremote/container/web/socket/WebsocketProducer.java
+++ b/container/src/main/java/org/openremote/container/web/socket/WebsocketProducer.java
@@ -23,6 +23,7 @@ import org.apache.camel.CamelExchangeException;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.impl.DefaultProducer;
+import org.openremote.container.web.ConnectionConstants;
import javax.websocket.Session;
import java.io.IOException;
@@ -53,7 +54,7 @@ public class WebsocketProducer extends DefaultProducer {
if (isSendToAllSet(in)) {
sendToAll(message, exchange);
} else {
- String sessionKey = in.getHeader(WebsocketConstants.SESSION_KEY, String.class);
+ String sessionKey = in.getHeader(ConnectionConstants.SESSION_KEY, String.class);
if (sessionKey != null) {
Session websocket = getEndpoint().getComponent().getWebsocketSessions().get(sessionKey);
sendMessage(websocket, message);
@@ -68,7 +69,7 @@ public class WebsocketProducer extends DefaultProducer {
}
protected boolean isSendToAllSet(Message in) {
- Boolean value = in.getHeader(WebsocketConstants.SEND_TO_ALL, sendToAll, Boolean.class);
+ Boolean value = in.getHeader(ConnectionConstants.SEND_TO_ALL, sendToAll, Boolean.class);
return value == null ? false : value;
}
diff --git a/gradle.properties b/gradle.properties
index 1a8b209ee..07116ee2d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -51,3 +51,4 @@ firebaseAdminVersion = 6.1.0
simpleJavaMailVersion = 5.0.4
jaywayJsonPathVersion = 2.4.0
typescriptGeneratorVersion = 2.13.489
+moquetteVersion = 0.13
diff --git a/manager/build.gradle b/manager/build.gradle
index 5b909ba80..4766df034 100644
--- a/manager/build.gradle
+++ b/manager/build.gradle
@@ -23,6 +23,8 @@ dependencies {
compile ("io.netty:netty-codec-http:$nettyVersion") {
force = true
}
+
+ compile "io.moquette:moquette-broker:$moquetteVersion"
}
// Load version properties file and use same version as source code
@@ -42,4 +44,4 @@ distributions {
}
}
}
-}
\ No newline at end of file
+}
diff --git a/manager/src/main/java/org/openremote/manager/event/ClientEventService.java b/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
index e0377d062..5954a3b95 100644
--- a/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
+++ b/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
@@ -26,19 +26,22 @@ import org.openremote.container.ContainerService;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.security.AuthContext;
import org.openremote.container.timer.TimerService;
-import org.openremote.container.web.socket.WebsocketConstants;
+import org.openremote.container.web.ConnectionConstants;
import org.openremote.manager.concurrent.ManagerExecutorService;
import org.openremote.manager.gateway.GatewayService;
+import org.openremote.manager.mqtt.MqttBrokerService;
import org.openremote.manager.security.ManagerIdentityService;
import org.openremote.model.Constants;
import org.openremote.model.event.shared.*;
import org.openremote.model.syslog.SyslogEvent;
import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.logging.Logger;
-import static org.apache.camel.builder.PredicateBuilder.or;
+import static org.apache.camel.builder.PredicateBuilder.*;
import static org.openremote.manager.gateway.GatewayService.isGatewayClientId;
/**
@@ -100,8 +103,12 @@ public class ClientEventService implements ContainerService {
public static final String CLIENT_EVENT_QUEUE = "seda://ClientEventQueue?multipleConsumers=false&waitForTaskToComplete=NEVER&purgeWhenStopping=true&discardIfNoConsumers=true&size=25000";
public static final String HEADER_ACCESS_RESTRICTED = ClientEventService.class.getName() + ".HEADER_ACCESS_RESTRICTED";
+ public static final String HEADER_CONNECTION_TYPE = ClientEventService.class.getName() + ".HEADER_CONNECTION_TYPE";
+ public static final String HEADER_CONNECTION_TYPE_WEBSOCKET = ClientEventService.class.getName() + ".HEADER_CONNECTION_TYPE_WEBSOCKET";
+ public static final String HEADER_CONNECTION_TYPE_MQTT = ClientEventService.class.getName() + ".HEADER_CONNECTION_TYPE_MQTT";
final protected Collection<EventSubscriptionAuthorizer> eventSubscriptionAuthorizers = new CopyOnWriteArraySet<>();
+ protected Map<String, String> sessionKeyConnectionTypeMap;
protected TimerService timerService;
protected MessageBrokerService messageBrokerService;
protected ManagerIdentityService identityService;
@@ -121,12 +128,13 @@ public class ClientEventService implements ContainerService {
identityService = container.getService(ManagerIdentityService.class);
gatewayService = container.getService(GatewayService.class);
+ sessionKeyConnectionTypeMap = new HashMap<>();
+
eventSubscriptions = new EventSubscriptions(
container.getService(TimerService.class),
container.getService(ManagerExecutorService.class)
);
- MessageBrokerService messageBrokerService = container.getService(MessageBrokerService.class);
messageBrokerService.getContext().getTypeConverterRegistry().addTypeConverters(
new EventTypeConverters()
);
@@ -138,23 +146,30 @@ public class ClientEventService implements ContainerService {
from("websocket://" + WEBSOCKET_EVENTS)
.routeId("FromClientWebsocketEvents")
+ .process(exchange -> exchange.getIn().setHeader(HEADER_CONNECTION_TYPE, HEADER_CONNECTION_TYPE_WEBSOCKET))
+ .to(ClientEventService.CLIENT_EVENT_QUEUE)
+ .end();
+
+ from(ClientEventService.CLIENT_EVENT_QUEUE)
+ .routeId("ClientEvents")
.choice()
- .when(header(WebsocketConstants.SESSION_OPEN))
- .process(exchange -> {
- String sessionKey = getSessionKey(exchange);
- sendToSession(sessionKey, "CONNECTED");
- })
- .choice()
- .when(exchange -> isGatewayClientId(getClientId(exchange)))
- .to(GatewayService.GATEWAY_EVENT_TOPIC)
- .endChoice()
- .stop()
+ .when(header(ConnectionConstants.SESSION_OPEN))
+ .process(exchange -> {
+ String sessionKey = getSessionKey(exchange);
+ sessionKeyConnectionTypeMap.put(sessionKey, (String) exchange.getIn().getHeader(HEADER_CONNECTION_TYPE));
+ })
+ .choice()
+ .when(exchange -> isGatewayClientId(getClientId(exchange)))
+ .to(GatewayService.GATEWAY_EVENT_TOPIC)
+ .endChoice()
+ .stop()
.when(or(
- header(WebsocketConstants.SESSION_CLOSE),
- header(WebsocketConstants.SESSION_CLOSE_ERROR)
+ header(ConnectionConstants.SESSION_CLOSE),
+ header(ConnectionConstants.SESSION_CLOSE_ERROR)
))
.process(exchange -> {
String sessionKey = getSessionKey(exchange);
+ sessionKeyConnectionTypeMap.remove(sessionKey);
eventSubscriptions.cancelAll(sessionKey);
})
.choice()
@@ -168,30 +183,41 @@ public class ClientEventService implements ContainerService {
String sessionKey = getSessionKey(exchange);
EventSubscription subscription = exchange.getIn().getBody(EventSubscription.class);
AuthContext authContext = exchange.getIn().getHeader(Constants.AUTH_CONTEXT, AuthContext.class);
- if (eventSubscriptionAuthorizers.stream()
- .anyMatch(authorizer -> authorizer.apply(authContext, subscription))) {
+ if (authorizeEventSubscription(authContext, subscription)) {
boolean restrictedUser = identityService.getIdentityProvider().isRestrictedUser(authContext.getUserId());
eventSubscriptions.createOrUpdate(sessionKey, restrictedUser, subscription);
subscription.setSubscribed(true);
sendToSession(sessionKey, subscription);
} else {
LOG.warning("Unauthorized subscription from '"
- + authContext.getUsername() + "' in realm '" + authContext.getAuthenticatedRealm()
- + "': " + subscription
+ + authContext.getUsername() + "' in realm '" + authContext.getAuthenticatedRealm()
+ + "': " + subscription
);
sendToSession(sessionKey, new UnauthorizedEventSubscription(subscription));
}
})
.stop()
- .when(bodyAs(String.class).startsWith(CancelEventSubscription.MESSAGE_PREFIX))
- .convertBodyTo(CancelEventSubscription.class)
+ .when(or(
+ body().isInstanceOf(CancelEventSubscription.class),
+ bodyAs(String.class).startsWith(CancelEventSubscription.MESSAGE_PREFIX)
+ ))
+ .choice()
+ .when(bodyAs(String.class).startsWith(CancelEventSubscription.MESSAGE_PREFIX))
+ .convertBodyTo(CancelEventSubscription.class)
+ .endChoice()
.process(exchange -> {
String sessionKey = getSessionKey(exchange);
eventSubscriptions.cancel(sessionKey, exchange.getIn().getBody(CancelEventSubscription.class));
})
.stop()
- .when(bodyAs(String.class).startsWith(RenewEventSubscriptions.MESSAGE_PREFIX))
- .convertBodyTo(RenewEventSubscriptions.class)
+ .when(or(
+ body().isInstanceOf(RenewEventSubscriptions.class),
+ bodyAs(String.class).startsWith(RenewEventSubscriptions.MESSAGE_PREFIX)
+ ))
+ .choice()
+ .when(bodyAs(String.class).startsWith(RenewEventSubscriptions.MESSAGE_PREFIX))
+ .convertBodyTo(RenewEventSubscriptions.class)
+ .endChoice()
.process(exchange -> {
String sessionKey = getSessionKey(exchange);
AuthContext authContext = exchange.getIn().getHeader(Constants.AUTH_CONTEXT, AuthContext.class);
@@ -199,8 +225,14 @@ public class ClientEventService implements ContainerService {
eventSubscriptions.update(sessionKey, restrictedUser,exchange.getIn().getBody(RenewEventSubscriptions.class).getSubscriptionIds());
})
.stop()
- .when(bodyAs(String.class).startsWith(SharedEvent.MESSAGE_PREFIX))
- .convertBodyTo(SharedEvent.class)
+ .when(or(
+ body().isInstanceOf(SharedEvent.class),
+ bodyAs(String.class).startsWith(SharedEvent.MESSAGE_PREFIX)
+ ))
+ .choice()
+ .when(bodyAs(String.class).startsWith(SharedEvent.MESSAGE_PREFIX))
+ .convertBodyTo(SharedEvent.class)
+ .endChoice()
.process(exchange -> {
SharedEvent event = exchange.getIn().getBody(SharedEvent.class);
// If there is no timestamp in event, set to system time
@@ -209,22 +241,24 @@ public class ClientEventService implements ContainerService {
}
})
.choice()
- .when(exchange -> isGatewayClientId(getClientId(exchange)))
- .to(GatewayService.GATEWAY_EVENT_TOPIC)
- .otherwise()
- .to(ClientEventService.CLIENT_EVENT_TOPIC)
+ .when(header(HEADER_CONNECTION_TYPE).isNotNull())
+ .choice()
+ .when(exchange -> isGatewayClientId(getClientId(exchange)))
+ .to(GatewayService.GATEWAY_EVENT_TOPIC)
+ .otherwise()
+ .to(ClientEventService.CLIENT_EVENT_TOPIC)
+ .endChoice()
+ .when(header(HEADER_CONNECTION_TYPE).isNull())
+ .split(method(eventSubscriptions, "splitForSubscribers"))
+ .process(exchange -> {
+ String sessionKey = getSessionKey(exchange);
+ sendToSession(sessionKey, exchange.getIn().getBody());
+ })
.endChoice()
+ .stop()
.otherwise()
.process(exchange -> LOG.fine("Unsupported message body: " + exchange.getIn().getBody()))
.end();
-
- from(ClientEventService.CLIENT_EVENT_QUEUE)
- .routeId("ToClientWebsocketEvents")
- .choice()
- .when(body().isInstanceOf(SharedEvent.class))
- .split(method(eventSubscriptions, "splitForSubscribers"))
- .to("websocket://" + WEBSOCKET_EVENTS)
- .end();
}
});
}
@@ -243,6 +277,11 @@ public class ClientEventService implements ContainerService {
this.eventSubscriptionAuthorizers.add(authorizer);
}
+ public boolean authorizeEventSubscription(AuthContext authContext, EventSubscription subscription) {
+ return eventSubscriptionAuthorizers.stream()
+ .anyMatch(authorizer -> authorizer.apply(authContext, subscription));
+ }
+
public void publishEvent(SharedEvent event) {
publishEvent(true, event);
}
@@ -269,16 +308,25 @@ public class ClientEventService implements ContainerService {
public void sendToSession(String sessionKey, Object data) {
if (messageBrokerService != null && messageBrokerService.getProducerTemplate() != null) {
LOG.fine("Sending to session '" + sessionKey + "': " + data);
- messageBrokerService.getProducerTemplate().sendBodyAndHeader(
- "websocket://" + WEBSOCKET_EVENTS,
- data,
- WebsocketConstants.SESSION_KEY, sessionKey
- );
+ String sessionConnectionType = sessionKeyConnectionTypeMap.get(sessionKey);
+ if (sessionConnectionType.equals(HEADER_CONNECTION_TYPE_WEBSOCKET)) {
+ messageBrokerService.getProducerTemplate().sendBodyAndHeader(
+ "websocket://" + WEBSOCKET_EVENTS,
+ data,
+ ConnectionConstants.SESSION_KEY, sessionKey
+ );
+ } else if (sessionConnectionType.equals(HEADER_CONNECTION_TYPE_MQTT)) {
+ messageBrokerService.getProducerTemplate().sendBodyAndHeader(
+ MqttBrokerService.MQTT_CLIENT_QUEUE,
+ data,
+ ConnectionConstants.SESSION_KEY, sessionKey
+ );
+ }
}
}
public static String getSessionKey(Exchange exchange) {
- return exchange.getIn().getHeader(WebsocketConstants.SESSION_KEY, String.class);
+ return exchange.getIn().getHeader(ConnectionConstants.SESSION_KEY, String.class);
}
public EventSubscriptions getEventSubscriptions() {
@@ -293,6 +341,9 @@ public class ClientEventService implements ContainerService {
public static String getClientId(Exchange exchange) {
AuthContext authContext = exchange.getIn().getHeader(Constants.AUTH_CONTEXT, AuthContext.class);
- return authContext.getClientId();
+ if(authContext != null) {
+ return authContext.getClientId();
+ }
+ return null;
}
}
diff --git a/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java b/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java
index 4b384f365..1fbc3814a 100644
--- a/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java
+++ b/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java
@@ -23,7 +23,7 @@ import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.impl.DefaultMessage;
import org.openremote.container.timer.TimerService;
-import org.openremote.container.web.socket.WebsocketConstants;
+import org.openremote.container.web.ConnectionConstants;
import org.openremote.manager.concurrent.ManagerExecutorService;
import org.openremote.model.event.TriggeredEventSubscription;
import org.openremote.model.event.shared.CancelEventSubscription;
@@ -31,7 +31,6 @@ import org.openremote.model.event.shared.EventSubscription;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.util.TextUtil;
-import java.lang.reflect.Array;
import java.util.*;
import java.util.logging.Logger;
@@ -206,7 +205,7 @@ public class EventSubscriptions {
Message msg = new DefaultMessage();
msg.setBody(triggeredEventSubscription); // Don't copy the event, use same reference
msg.setHeaders(new HashMap<>(exchange.getIn().getHeaders())); // Copy headers
- msg.setHeader(WebsocketConstants.SESSION_KEY, sessionKey);
+ msg.setHeader(ConnectionConstants.SESSION_KEY, sessionKey);
messageList.add(msg);
} else {
sessionSubscription.subscription.getInternalConsumer().accept(triggeredEventSubscription);
diff --git a/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java b/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
index 06847e3d7..1bd84e0d5 100644
--- a/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
+++ b/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
@@ -27,7 +27,7 @@ import org.openremote.container.ContainerService;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.persistence.PersistenceEvent;
import org.openremote.container.web.ClientRequestInfo;
-import org.openremote.container.web.socket.WebsocketConstants;
+import org.openremote.container.web.ConnectionConstants;
import org.openremote.manager.asset.AssetProcessingException;
import org.openremote.manager.asset.AssetProcessingService;
import org.openremote.manager.asset.AssetStorageService;
@@ -54,7 +54,6 @@ import javax.ws.rs.core.Response;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
-import java.util.function.Function;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
@@ -194,9 +193,9 @@ public class GatewayService extends RouteBuilder implements ContainerService, As
from(GATEWAY_EVENT_TOPIC)
.routeId("FromGatewayUpdates")
.choice()
- .when(header(WebsocketConstants.SESSION_OPEN))
+ .when(header(ConnectionConstants.SESSION_OPEN))
.process(exchange -> {
- Session session = exchange.getIn().getHeader(WebsocketConstants.SESSION, Session.class);
+ Session session = exchange.getIn().getHeader(ConnectionConstants.SESSION, Session.class);
String sessionKey = getSessionKey(exchange);
String clientId = getClientId(exchange);
if (isGatewayClientId(clientId)) {
@@ -205,8 +204,8 @@ public class GatewayService extends RouteBuilder implements ContainerService, As
})
.stop()
.when(or(
- header(WebsocketConstants.SESSION_CLOSE),
- header(WebsocketConstants.SESSION_CLOSE_ERROR)
+ header(ConnectionConstants.SESSION_CLOSE),
+ header(ConnectionConstants.SESSION_CLOSE_ERROR)
))
.process(exchange -> {
String clientId = getClientId(exchange);
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/EventInterceptHandler.java b/manager/src/main/java/org/openremote/manager/mqtt/EventInterceptHandler.java
new file mode 100644
index 000000000..9acbceac3
--- /dev/null
+++ b/manager/src/main/java/org/openremote/manager/mqtt/EventInterceptHandler.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2017, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.manager.mqtt;
+
+import io.moquette.interception.AbstractInterceptHandler;
+import io.moquette.interception.messages.*;
+import org.keycloak.adapters.rotation.AdapterTokenVerifier;
+import org.keycloak.common.VerificationException;
+import org.keycloak.exceptions.TokenNotActiveException;
+import org.keycloak.representations.AccessToken;
+import org.openremote.container.message.MessageBrokerService;
+import org.openremote.container.security.ClientCredentialsAuthForm;
+import org.openremote.container.security.keycloak.AccessTokenAuthContext;
+import org.openremote.container.util.UniqueIdentifierGenerator;
+import org.openremote.container.web.ConnectionConstants;
+import org.openremote.manager.event.ClientEventService;
+import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
+import org.openremote.model.Constants;
+import org.openremote.model.asset.AssetFilter;
+import org.openremote.model.attribute.AttributeEvent;
+import org.openremote.model.attribute.AttributeRef;
+import org.openremote.model.event.shared.CancelEventSubscription;
+import org.openremote.model.event.shared.EventSubscription;
+import org.openremote.model.event.shared.RenewEventSubscriptions;
+
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.openremote.manager.mqtt.MqttBrokerService.TOPIC_SEPARATOR;
+import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID;
+
+public class EventInterceptHandler extends AbstractInterceptHandler {
+
+ private static final Logger LOG = Logger.getLogger(EventInterceptHandler.class.getName());
+
+ protected final ManagerKeycloakIdentityProvider identityProvider;
+ protected final MessageBrokerService messageBrokerService;
+ protected final Map<String, MqttConnection> mqttConnectionMap;
+
+ EventInterceptHandler(ManagerKeycloakIdentityProvider managerKeycloakIdentityProvider,
+ MessageBrokerService messageBrokerService,
+ Map<String, MqttConnection> mqttConnectionMap) {
+
+ this.identityProvider = managerKeycloakIdentityProvider;
+ this.messageBrokerService = messageBrokerService;
+ this.mqttConnectionMap = mqttConnectionMap;
+ }
+
+ @Override
+ public String getID() {
+ return UniqueIdentifierGenerator.generateId(EventInterceptHandler.class.getName());
+ }
+
+ @Override
+ public Class<?>[] getInterceptedMessageTypes() {
+ return new Class[]{
+ InterceptConnectMessage.class,
+ InterceptDisconnectMessage.class,
+ InterceptConnectionLostMessage.class,
+ InterceptSubscribeMessage.class,
+ InterceptUnsubscribeMessage.class
+ };
+ }
+
+ @Override
+ public void onConnect(InterceptConnectMessage interceptConnectMessage) {
+
+ MqttConnection connection = new MqttConnection(interceptConnectMessage.getClientID(), interceptConnectMessage.getUsername(), interceptConnectMessage.getPassword());
+ String suppliedClientSecret = new String(interceptConnectMessage.getPassword(), StandardCharsets.UTF_8);
+ connection.accessToken = identityProvider.getExternalKeycloak().getAccessToken(connection.realm, new ClientCredentialsAuthForm(connection.username, suppliedClientSecret)).getToken();
+
+ mqttConnectionMap.put(connection.clientId, connection);
+
+ Map<String, Object> headers = prepareHeaders(connection);
+ headers.put(ConnectionConstants.SESSION_OPEN, true);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, null, headers);
+ }
+
+ @Override
+ public void onDisconnect(InterceptDisconnectMessage interceptDisconnectMessage) {
+ MqttConnection connection = mqttConnectionMap.remove(interceptDisconnectMessage.getClientID());
+ if (connection != null) {
+ Map<String, Object> headers = prepareHeaders(connection);
+ headers.put(ConnectionConstants.SESSION_CLOSE, true);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, null, headers);
+ }
+ }
+
+ @Override
+ public void onConnectionLost(InterceptConnectionLostMessage interceptConnectionLostMessage) {
+ MqttConnection connection = mqttConnectionMap.remove(interceptConnectionLostMessage.getClientID());
+ if (connection != null) {
+ Map<String, Object> headers = prepareHeaders(connection);
+ headers.put(ConnectionConstants.SESSION_CLOSE_ERROR, true);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, null, headers);
+
+ }
+ LOG.info("Connection lost for client: " + interceptConnectionLostMessage.getClientID());
+ }
+
+ @Override
+ public void onSubscribe(InterceptSubscribeMessage interceptSubscribeMessage) {
+ MqttConnection connection = mqttConnectionMap.get(interceptSubscribeMessage.getClientID());
+ if (connection != null) {
+ String[] topicParts = interceptSubscribeMessage.getTopicFilter().split(TOPIC_SEPARATOR);
+ String assetId = topicParts[1];
+ String subscriptionId = connection.assetSubscriptions.get(assetId);
+ if (subscriptionId != null) { //renew subscription
+ RenewEventSubscriptions renewEventSubscriptions = new RenewEventSubscriptions(new String[]{subscriptionId});
+ Map<String, Object> headers = prepareHeaders(connection);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, renewEventSubscriptions, headers);
+ } else {
+ EventSubscription<AttributeEvent> subscription = new EventSubscription<>(
+ AttributeEvent.class,
+ new AssetFilter<AttributeEvent>().setRealm(connection.realm).setAssetIds(assetId),
+ String.valueOf(connection.getNextSubscriptionId())
+ );
+ Map<String, Object> headers = prepareHeaders(connection);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, subscription, headers);
+ connection.assetSubscriptions.put(assetId, subscription.getSubscriptionId());
+ }
+ } else {
+ throw new IllegalStateException("Connection with clientId " + interceptSubscribeMessage.getClientID() + " not found.");
+ }
+ }
+
+ @Override
+ public void onUnsubscribe(InterceptUnsubscribeMessage interceptUnsubscribeMessage) {
+ MqttConnection connection = mqttConnectionMap.get(interceptUnsubscribeMessage.getClientID());
+ if (connection != null) {
+ String[] topicParts = interceptUnsubscribeMessage.getTopicFilter().split(TOPIC_SEPARATOR);
+ String assetId = topicParts[1];
+ String subscriptionId = connection.assetSubscriptions.remove(assetId);
+ if (subscriptionId != null) {
+ Map<String, Object> headers = prepareHeaders(connection);
+ CancelEventSubscription<AttributeEvent> cancelEventSubscription = new CancelEventSubscription<>(AttributeEvent.class, subscriptionId);
+ messageBrokerService.getProducerTemplate().sendBodyAndHeaders(ClientEventService.CLIENT_EVENT_QUEUE, cancelEventSubscription, headers);
+ }
+ }
+ }
+
+ private Map<String, Object> prepareHeaders(MqttConnection connection) {
+ Map<String, Object> headers = new HashMap<>();
+ headers.put(ConnectionConstants.SESSION_KEY, connection.clientId);
+ headers.put(ClientEventService.HEADER_CONNECTION_TYPE, ClientEventService.HEADER_CONNECTION_TYPE_MQTT);
+ try {
+ AccessToken accessToken = AdapterTokenVerifier.verifyToken(connection.accessToken, identityProvider.getKeycloakDeployment(connection.realm, KEYCLOAK_CLIENT_ID));
+ headers.put(Constants.AUTH_CONTEXT, new AccessTokenAuthContext(connection.realm, accessToken));
+ } catch (VerificationException e) {
+ if (e instanceof TokenNotActiveException) {
+ String suppliedClientSecret = new String(connection.password, StandardCharsets.UTF_8);
+ connection.accessToken = identityProvider.getExternalKeycloak().getAccessToken(connection.realm, new ClientCredentialsAuthForm(connection.username, suppliedClientSecret)).getToken();
+ try {
+ AccessToken accessToken = AdapterTokenVerifier.verifyToken(connection.accessToken, identityProvider.getKeycloakDeployment(connection.realm, KEYCLOAK_CLIENT_ID));
+ headers.put(Constants.AUTH_CONTEXT, new AccessTokenAuthContext(connection.realm, accessToken));
+ } catch (VerificationException verificationException) {
+ LOG.log(Level.WARNING, "Couldn't verify token", verificationException);
+ }
+ }
+ LOG.log(Level.WARNING, e.getMessage(), e);
+ }
+ return headers;
+ }
+}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthenticator.java b/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthenticator.java
new file mode 100644
index 000000000..60bdd681a
--- /dev/null
+++ b/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthenticator.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2017, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.manager.mqtt;
+
+import io.moquette.broker.security.IAuthenticator;
+import org.keycloak.admin.client.resource.ClientResource;
+import org.keycloak.admin.client.resource.ClientsResource;
+import org.keycloak.admin.client.resource.RealmResource;
+import org.keycloak.representations.idm.ClientRepresentation;
+import org.openremote.container.web.ClientRequestInfo;
+import org.openremote.manager.security.ManagerIdentityProvider;
+import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
+
+import javax.ws.rs.NotFoundException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.logging.Logger;
+
+public class KeycloakAuthenticator implements IAuthenticator {
+
+ private static final Logger LOG = Logger.getLogger(KeycloakAuthenticator.class.getName());
+
+ public static final String MQTT_CLIENT_ID_SEPARATOR = "_";
+
+ final ManagerKeycloakIdentityProvider identityProvider;
+
+ public KeycloakAuthenticator(ManagerKeycloakIdentityProvider managerIdentityProvider) {
+ identityProvider = managerIdentityProvider;
+ }
+
+ @Override
+ public boolean checkValid(String realm, String clientId, byte[] password) {
+ int indexSplit = realm.indexOf(MQTT_CLIENT_ID_SEPARATOR);
+ if (indexSplit > 0) {
+ realm = realm.substring(0, indexSplit);
+ }
+
+ RealmResource realmResource = identityProvider.getRealms(getClientRequestInfo()).realm(realm);
+ if (realmResource == null) {
+ LOG.info("Realm not found");
+ return false;
+ }
+
+ List<ClientRepresentation> clientRepresentations = realmResource.clients().findByClientId(clientId);
+ if (clientRepresentations.isEmpty()) {
+ LOG.info("Client not found");
+ return false;
+ }
+
+ String suppliedClientSecret = new String(password, StandardCharsets.UTF_8);
+ String clientSecret = realmResource.clients().get(clientRepresentations.get(0).getId()).getSecret().getValue();
+
+ return suppliedClientSecret.equals(clientSecret);
+ }
+
+ private ClientRequestInfo getClientRequestInfo() {
+ String accessToken = identityProvider.getAdminAccessToken(null);
+ return new ClientRequestInfo(null, accessToken);
+ }
+}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthorizatorPolicy.java b/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthorizatorPolicy.java
new file mode 100644
index 000000000..be5a04ed9
--- /dev/null
+++ b/manager/src/main/java/org/openremote/manager/mqtt/KeycloakAuthorizatorPolicy.java
@@ -0,0 +1,100 @@
+package org.openremote.manager.mqtt;
+
+import io.moquette.broker.security.IAuthorizatorPolicy;
+import io.moquette.broker.subscriptions.Topic;
+import org.keycloak.adapters.rotation.AdapterTokenVerifier;
+import org.keycloak.common.VerificationException;
+import org.keycloak.exceptions.TokenNotActiveException;
+import org.keycloak.representations.AccessToken;
+import org.openremote.container.security.ClientCredentialsAuthForm;
+import org.openremote.container.security.keycloak.AccessTokenAuthContext;
+import org.openremote.manager.event.ClientEventService;
+import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
+import org.openremote.model.asset.AssetFilter;
+import org.openremote.model.attribute.AttributeEvent;
+import org.openremote.model.event.shared.EventSubscription;
+import org.openremote.model.security.ClientRole;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.openremote.manager.mqtt.MqttBrokerService.ASSETS_TOPIC;
+import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID;
+
+public class KeycloakAuthorizatorPolicy implements IAuthorizatorPolicy {
+
+ private static final Logger LOG = Logger.getLogger(KeycloakAuthorizatorPolicy.class.getName());
+
+ protected final ManagerKeycloakIdentityProvider identityProvider;
+ protected final ClientEventService clientEventService;
+ protected final Map<String, MqttConnection> mqttConnectionMap;
+
+ public KeycloakAuthorizatorPolicy(ManagerKeycloakIdentityProvider identityProvider,
+ ClientEventService clientEventService,
+ Map<String, MqttConnection> mqttConnectionMap) {
+ this.identityProvider = identityProvider;
+ this.clientEventService = clientEventService;
+ this.mqttConnectionMap = mqttConnectionMap;
+ }
+
+ @Override
+ public boolean canWrite(Topic topic, String username, String clientId) {
+ return verifyRights(topic, username, clientId, ClientRole.WRITE_ASSETS);
+ }
+
+ @Override
+ public boolean canRead(Topic topic, String username, String clientId) {
+ return verifyRights(topic, username, clientId, ClientRole.READ_ASSETS);
+ }
+
+ private boolean verifyRights(Topic topic, String username, String clientId, ClientRole... roles) {
+ MqttConnection connection = mqttConnectionMap.get(clientId);
+ if (connection == null) {
+ LOG.info("No connection found for clientId: " + clientId);
+ return false;
+ }
+
+ if (!connection.username.equals(username)) {
+ LOG.info("Username mismatch");
+ return false;
+ }
+
+ if (topic.isEmpty() || topic.getTokens().size() != 2) {
+ LOG.info("Topic may not be empty and should have the following format: assets/{assetId}");
+ return false;
+ }
+
+ if (!topic.headToken().toString().equals(ASSETS_TOPIC)) {
+ LOG.info("Topic should have the following format: assets/{assetId}");
+ return false;
+ }
+
+ String assetId = topic.getTokens().get(1).toString();
+ EventSubscription<AttributeEvent> subscription = new EventSubscription<>(
+ AttributeEvent.class,
+ new AssetFilter<AttributeEvent>().setRealm(connection.realm).setAssetIds(assetId)
+ );
+
+ try {
+ AccessToken accessToken = AdapterTokenVerifier.verifyToken(connection.accessToken, identityProvider.getKeycloakDeployment(connection.realm, KEYCLOAK_CLIENT_ID));
+ return clientEventService.authorizeEventSubscription(new AccessTokenAuthContext(connection.realm, accessToken), subscription);
+ } catch (VerificationException e) {
+ if (e instanceof TokenNotActiveException) {
+ String suppliedClientSecret = new String(connection.password, StandardCharsets.UTF_8);
+ connection.accessToken = identityProvider.getExternalKeycloak().getAccessToken(connection.realm, new ClientCredentialsAuthForm(connection.username, suppliedClientSecret)).getToken();
+ try {
+ AccessToken accessToken = AdapterTokenVerifier.verifyToken(connection.accessToken, identityProvider.getKeycloakDeployment(connection.realm, KEYCLOAK_CLIENT_ID));
+ return clientEventService.authorizeEventSubscription(new AccessTokenAuthContext(connection.realm, accessToken), subscription);
+ } catch (VerificationException verificationException) {
+ LOG.log(Level.INFO, "Couldn't verify token", verificationException);
+ return false;
+ }
+ } else {
+ LOG.log(Level.INFO, "Couldn't verify token", e);
+ return false;
+ }
+ }
+ }
+}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/MqttBrokerService.java b/manager/src/main/java/org/openremote/manager/mqtt/MqttBrokerService.java
new file mode 100644
index 000000000..6f7b51a78
--- /dev/null
+++ b/manager/src/main/java/org/openremote/manager/mqtt/MqttBrokerService.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2017, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.manager.mqtt;
+
+import com.google.inject.internal.cglib.proxy.$FixedValue;
+import io.moquette.BrokerConstants;
+import io.moquette.broker.Server;
+import io.moquette.broker.config.MemoryConfig;
+import io.moquette.interception.InterceptHandler;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.mqtt.*;
+import org.apache.camel.builder.RouteBuilder;
+import org.openremote.container.Container;
+import org.openremote.container.ContainerService;
+import org.openremote.container.message.MessageBrokerService;
+import org.openremote.manager.event.ClientEventService;
+import org.openremote.manager.security.ManagerIdentityService;
+import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
+import org.openremote.model.attribute.AttributeEvent;
+import org.openremote.model.event.TriggeredEventSubscription;
+import org.openremote.model.value.ArrayValue;
+import org.openremote.model.value.ObjectValue;
+import org.openremote.model.value.Value;
+import org.openremote.model.value.Values;
+
+import java.nio.charset.Charset;
+import java.util.*;
+import java.util.logging.Logger;
+
+import static org.openremote.container.util.MapAccess.getInteger;
+import static org.openremote.container.util.MapAccess.getString;
+import static org.openremote.manager.event.ClientEventService.getSessionKey;
+
+public class MqttBrokerService implements ContainerService {
+
+ private static final Logger LOG = Logger.getLogger(MqttBrokerService.class.getName());
+
+ public static final String MQTT_CLIENT_QUEUE = "seda://MqttClientQueue?waitForTaskToComplete=IfReplyExpected&timeout=10000&purgeWhenStopping=true&discardIfNoConsumers=false&size=25000";
+
+ public static final String MQTT_CLIENT_ID_PREFIX = "mqtt-";
+ public static final String MQTT_SERVER_LISTEN_HOST = "MQTT_SERVER_LISTEN_HOST";
+ public static final String MQTT_SERVER_LISTEN_PORT = "MQTT_SERVER_LISTEN_PORT";
+
+ public static final String ASSETS_TOPIC = "assets";
+ public static final String TOPIC_SEPARATOR = "/";
+
+ public static final String PAYLOAD_SEPARATOR = ":";
+
+ protected ManagerKeycloakIdentityProvider identityProvider;
+ protected ClientEventService clientEventService;
+ protected MessageBrokerService messageBrokerService;
+
+ protected Map<String, MqttConnection> mqttConnectionMap;
+
+ protected boolean active;
+ protected String host;
+ protected int port;
+ protected Server mqttBroker;
+
+ @Override
+ public int getPriority() {
+ return DEFAULT_PRIORITY;
+ }
+
+ @Override
+ public void init(Container container) throws Exception {
+ host = getString(container.getConfig(), MQTT_SERVER_LISTEN_HOST, BrokerConstants.HOST);
+ port = getInteger(container.getConfig(), MQTT_SERVER_LISTEN_PORT, BrokerConstants.PORT);
+
+ mqttConnectionMap = new HashMap<>();
+
+ clientEventService = container.getService(ClientEventService.class);
+ ManagerIdentityService identityService = container.getService(ManagerIdentityService.class);
+ messageBrokerService = container.getService(MessageBrokerService.class);
+
+ if (!identityService.isKeycloakEnabled()) {
+ LOG.warning("MQTT connections are not supported when not using Keycloak identity provider");
+ active = false;
+ } else {
+ active = true;
+ identityProvider = (ManagerKeycloakIdentityProvider) identityService.getIdentityProvider();
+ }
+
+ mqttBroker = new Server();
+
+ messageBrokerService.getContext().addRoutes(new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+
+ from(MQTT_CLIENT_QUEUE)
+ .routeId("MqttClientEvents")
+ .choice()
+ .when(body().isInstanceOf(TriggeredEventSubscription.class))
+ .process(exchange -> {
+ String sessionKey = getSessionKey(exchange);
+ TriggeredEventSubscription<AttributeEvent> triggeredEventSubscription = exchange.getIn().getBody(TriggeredEventSubscription.class);
+ triggeredEventSubscription.getEvents()
+ .forEach(event -> sendAttributeEvent(sessionKey, event));
+ })
+ .end();
+
+ }
+ });
+ }
+
+ @Override
+ public void start(Container container) throws Exception {
+ Properties properties = new Properties();
+ properties.setProperty(BrokerConstants.HOST_PROPERTY_NAME, host);
+ properties.setProperty(BrokerConstants.PORT_PROPERTY_NAME, String.valueOf(port));
+ properties.setProperty(BrokerConstants.ALLOW_ANONYMOUS_PROPERTY_NAME, String.valueOf(false));
+ List<? extends InterceptHandler> interceptHandlers = Collections.singletonList(new EventInterceptHandler(identityProvider, messageBrokerService, mqttConnectionMap));
+ mqttBroker.startServer(new MemoryConfig(properties), interceptHandlers, null, new KeycloakAuthenticator(identityProvider), new KeycloakAuthorizatorPolicy(identityProvider, clientEventService, mqttConnectionMap));
+ LOG.fine("Started MQTT broker");
+ }
+
+ @Override
+ public void stop(Container container) throws Exception {
+ mqttBroker.stopServer();
+ LOG.fine("Stopped MQTT broker");
+ }
+
+ public void sendAttributeEvent(String clientId, AttributeEvent attributeEvent) {
+ ByteBuf payload = Unpooled.copiedBuffer(attributeEvent.getAttributeName() + PAYLOAD_SEPARATOR, Charset.defaultCharset());
+ attributeEvent.getValue().ifPresent(value -> payload.writeCharSequence(value.toJson(), Charset.defaultCharset()));
+
+ MqttPublishMessage publishMessage = MqttMessageBuilders.publish()
+ .qos(MqttQoS.AT_MOST_ONCE)
+ .topicName(ASSETS_TOPIC + TOPIC_SEPARATOR + attributeEvent.getEntityId())
+ .payload(payload)
+ .build();
+
+ mqttBroker.internalPublish(publishMessage, clientId);
+ }
+}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/MqttConnection.java b/manager/src/main/java/org/openremote/manager/mqtt/MqttConnection.java
new file mode 100644
index 000000000..e6ef1c51a
--- /dev/null
+++ b/manager/src/main/java/org/openremote/manager/mqtt/MqttConnection.java
@@ -0,0 +1,35 @@
+package org.openremote.manager.mqtt;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.openremote.manager.mqtt.KeycloakAuthenticator.MQTT_CLIENT_ID_SEPARATOR;
+
+public class MqttConnection {
+
+ protected final String realm;
+ protected final String clientId;
+ protected final String username;
+ protected final byte[] password;
+ protected final Map<String, String> assetSubscriptions;
+ protected String accessToken;
+ protected int subscriptionId;
+
+ public MqttConnection(String clientId, String username, byte[] password) {
+ int indexSplit = clientId.indexOf(MQTT_CLIENT_ID_SEPARATOR);
+ if (indexSplit > 0) {
+ realm = clientId.substring(0, indexSplit);
+ } else {
+ realm = clientId;
+ }
+ this.clientId = clientId;
+ this.username = username;
+ this.password = password;
+ this.assetSubscriptions = new HashMap<>();
+ this.subscriptionId = 0;
+ }
+
+ public int getNextSubscriptionId() {
+ return ++subscriptionId;
+ }
+}
diff --git a/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java b/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
index 1dad13112..56d61e8db 100644
--- a/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
+++ b/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
@@ -30,7 +30,7 @@ import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.persistence.PersistenceEvent;
import org.openremote.container.persistence.PersistenceService;
import org.openremote.container.security.AuthContext;
-import org.openremote.container.security.AuthForm;
+import org.openremote.container.security.PasswordAuthForm;
import org.openremote.container.security.keycloak.KeycloakIdentityProvider;
import org.openremote.container.timer.TimerService;
import org.openremote.container.web.ClientRequestInfo;
@@ -38,7 +38,6 @@ import org.openremote.container.web.WebService;
import org.openremote.manager.apps.ConsoleAppService;
import org.openremote.manager.event.ClientEventService;
import org.openremote.model.Constants;
-import org.openremote.model.asset.Asset;
import org.openremote.model.asset.AssetTreeModifiedEvent;
import org.openremote.model.event.shared.TenantFilter;
import org.openremote.model.query.UserQuery;
@@ -517,7 +516,7 @@ public class ManagerKeycloakIdentityProvider extends KeycloakIdentityProvider im
if (token == null || !token.getIssuedFor().equals(ADMIN_CLI_CLIENT_ID)) {
return getKeycloak().getAccessToken(
- MASTER_REALM, new AuthForm(ADMIN_CLI_CLIENT_ID, MASTER_REALM_ADMIN_USER, keycloakAdminPassword)
+ MASTER_REALM, new PasswordAuthForm(ADMIN_CLI_CLIENT_ID, MASTER_REALM_ADMIN_USER, keycloakAdminPassword)
).getToken();
}
return clientRequestInfo.getAccessToken();
diff --git a/manager/src/main/java/org/openremote/manager/setup/AbstractKeycloakSetup.java b/manager/src/main/java/org/openremote/manager/setup/AbstractKeycloakSetup.java
index 281095470..ee96433b3 100644
--- a/manager/src/main/java/org/openremote/manager/setup/AbstractKeycloakSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/AbstractKeycloakSetup.java
@@ -24,7 +24,7 @@ import org.keycloak.admin.client.resource.RealmResource;
import org.keycloak.admin.client.resource.UsersResource;
import org.keycloak.representations.idm.ClientRepresentation;
import org.openremote.container.Container;
-import org.openremote.container.security.AuthForm;
+import org.openremote.container.security.PasswordAuthForm;
import org.openremote.container.security.keycloak.KeycloakIdentityProvider;
import org.openremote.manager.security.ManagerIdentityService;
import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
@@ -89,7 +89,7 @@ public abstract class AbstractKeycloakSetup implements Setup {
// Use direct access grant feature of Keycloak Admin CLI to get superuser access token
String keycloakAdminPassword = container.getConfig().getOrDefault(SETUP_ADMIN_PASSWORD, SETUP_ADMIN_PASSWORD_DEFAULT);
this.accessToken = keycloakProvider.getKeycloak().getAccessToken(
- MASTER_REALM, new AuthForm(KeycloakIdentityProvider.ADMIN_CLI_CLIENT_ID, MASTER_REALM_ADMIN_USER, keycloakAdminPassword)
+ MASTER_REALM, new PasswordAuthForm(KeycloakIdentityProvider.ADMIN_CLI_CLIENT_ID, MASTER_REALM_ADMIN_USER, keycloakAdminPassword)
).getToken();
masterRealmResource = keycloakProvider.getRealms(accessToken).realm(MASTER_REALM);
@@ -97,11 +97,11 @@ public abstract class AbstractKeycloakSetup implements Setup {
masterUsersResource = masterRealmResource.users();
}
- protected String getClientObjectId(ClientsResource clientsResource) {
- return clientsResource.findByClientId(KEYCLOAK_CLIENT_ID)
+ protected String getClientObjectId(ClientsResource clientsResource, String clientId) {
+ return clientsResource.findByClientId(clientId)
.stream()
.map(ClientRepresentation::getId)
- .findFirst().orElseThrow(() -> new RuntimeException("Client object ID not found: " + KEYCLOAK_CLIENT_ID));
+ .findFirst().orElseThrow(() -> new RuntimeException("Client object ID not found: " + clientId));
}
}
diff --git a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
index dd398002c..fdb0c53c6 100644
--- a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakDemoSetup.java
@@ -19,13 +19,17 @@
*/
package org.openremote.manager.setup.builtin;
+import org.keycloak.admin.client.resource.ClientResource;
import org.keycloak.admin.client.resource.ClientsResource;
import org.keycloak.admin.client.resource.RolesResource;
import org.keycloak.admin.client.resource.UsersResource;
+import org.keycloak.representations.idm.ClientRepresentation;
import org.keycloak.representations.idm.CredentialRepresentation;
import org.keycloak.representations.idm.UserRepresentation;
import org.openremote.container.Container;
+import org.openremote.container.util.UniqueIdentifierGenerator;
import org.openremote.container.web.ClientRequestInfo;
+import org.openremote.manager.mqtt.MqttBrokerService;
import org.openremote.manager.setup.AbstractKeycloakSetup;
import org.openremote.model.security.ClientRole;
import org.openremote.model.security.Tenant;
@@ -34,6 +38,8 @@ import org.openremote.model.Constants;
import java.util.Arrays;
import java.util.logging.Logger;
+import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID;
+
/**
* We have the following demo users:
* <ul>
@@ -85,7 +91,7 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
tenantCity = keycloakProvider.getTenant(tenantCity.getRealm());
// Users
- String masterClientObjectId = getClientObjectId(masterClientsResource);
+ String masterClientObjectId = getClientObjectId(masterClientsResource, KEYCLOAK_CLIENT_ID);
RolesResource masterRolesResource = masterClientsResource.get(masterClientObjectId).roles();
UserRepresentation testuser1 = new UserRepresentation();
@@ -111,11 +117,32 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
));
LOG.info("Added demo user '" + testuser1.getUsername() + "' with password '" + testuser1Credentials.getValue() + "'");
- UsersResource tenantBuildingUsersResource = keycloakProvider.getRealms(accessToken).realm("building").users();
- ClientsResource tenantBuildingClientsResource = keycloakProvider.getRealms(accessToken).realm("building").clients();
- String tenantBuildingClientObjectId = getClientObjectId(tenantBuildingClientsResource);
+ UsersResource tenantBuildingUsersResource = keycloakProvider.getRealms(accessToken).realm(tenantBuilding.getRealm()).users();
+ ClientsResource tenantBuildingClientsResource = keycloakProvider.getRealms(accessToken).realm(tenantBuilding.getRealm()).clients();
+ String tenantBuildingClientObjectId = getClientObjectId(tenantBuildingClientsResource, KEYCLOAK_CLIENT_ID);
RolesResource tenantBuildingRolesResource = tenantBuildingClientsResource.get(tenantBuildingClientObjectId).roles();
+ /**
+ * MQTT Client
+ */
+ ClientRepresentation mqttClientRepresentation = new ClientRepresentation();
+ String buildingMqttClientId = MqttBrokerService.MQTT_CLIENT_ID_PREFIX + UniqueIdentifierGenerator.generateId(tenantBuilding.getRealm());
+ mqttClientRepresentation.setClientId(buildingMqttClientId);
+ mqttClientRepresentation.setName("MQTT");
+ mqttClientRepresentation.setStandardFlowEnabled(false);
+ mqttClientRepresentation.setImplicitFlowEnabled(false);
+ mqttClientRepresentation.setDirectAccessGrantsEnabled(false);
+ mqttClientRepresentation.setServiceAccountsEnabled(true);
+ mqttClientRepresentation.setSecret(UniqueIdentifierGenerator.generateId(tenantBuilding.getRealm()));
+ keycloakProvider.createClientApplication(new ClientRequestInfo(null, keycloakProvider.getAdminAccessToken(null)), tenantBuilding.getRealm(), mqttClientRepresentation);
+
+ ClientResource mqttResource = tenantBuildingClientsResource.get(getClientObjectId(tenantBuildingClientsResource, buildingMqttClientId));
+ UserRepresentation user = mqttResource.getServiceAccountUser();
+ tenantBuildingUsersResource.get(user.getId()).roles().clientLevel(tenantBuildingClientObjectId).add(Arrays.asList(
+ tenantBuildingRolesResource.get(ClientRole.READ_ASSETS.getValue()).toRepresentation(),
+ tenantBuildingRolesResource.get(ClientRole.WRITE_ASSETS.getValue()).toRepresentation()
+ ));
+
UserRepresentation testuser2 = new UserRepresentation();
testuser2.setUsername("testuser2");
testuser2.setFirstName("DemoA2");
@@ -187,7 +214,7 @@ public class KeycloakDemoSetup extends AbstractKeycloakSetup {
UsersResource tenantCityUsersResource = keycloakProvider.getRealms(accessToken).realm("smartcity").users();
ClientsResource tenantCityClientsResource = keycloakProvider.getRealms(accessToken).realm("smartcity").clients();
- String tenantCityClientObjectId = getClientObjectId(tenantCityClientsResource);
+ String tenantCityClientObjectId = getClientObjectId(tenantCityClientsResource, KEYCLOAK_CLIENT_ID);
RolesResource tenantCityRolesResource = tenantCityClientsResource.get(tenantCityClientObjectId).roles();
UserRepresentation smartCityUser = new UserRepresentation();
diff --git a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakInitSetup.java b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakInitSetup.java
index b9c7c712f..f68263d56 100644
--- a/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakInitSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/builtin/KeycloakInitSetup.java
@@ -32,6 +32,7 @@ import org.openremote.model.security.ClientRole;
import java.util.Arrays;
import java.util.logging.Logger;
+import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID;
import static org.openremote.model.Constants.MASTER_REALM_ADMIN_USER;
public class KeycloakInitSetup extends AbstractKeycloakSetup {
@@ -71,7 +72,7 @@ public class KeycloakInitSetup extends AbstractKeycloakSetup {
// Get the client application ID so we can assign roles to users at the client
// level (we can only check realm _or_ client application roles in @RolesAllowed!)
- String clientObjectId = getClientObjectId(masterClientsResource);
+ String clientObjectId = getClientObjectId(masterClientsResource, KEYCLOAK_CLIENT_ID);
ClientResource clientResource = masterClientsResource.get(clientObjectId);
RolesResource rolesResource = clientResource.roles();
diff --git a/manager/src/main/resources/META-INF/services/org.openremote.container.ContainerService b/manager/src/main/resources/META-INF/services/org.openremote.container.ContainerService
index f02801120..8a12c9b2c 100644
--- a/manager/src/main/resources/META-INF/services/org.openremote.container.ContainerService
+++ b/manager/src/main/resources/META-INF/services/org.openremote.container.ContainerService
@@ -26,3 +26,4 @@ org.openremote.manager.notification.EmailNotificationHandler
org.openremote.manager.predicted.AssetPredictedDatapointService
org.openremote.manager.gateway.GatewayService
org.openremote.manager.gateway.GatewayClientService
+org.openremote.manager.mqtt.MqttBrokerService
diff --git a/model/src/main/java/org/openremote/model/asset/AssetType.java b/model/src/main/java/org/openremote/model/asset/AssetType.java
index 29c13f600..a1d5fc2eb 100644
--- a/model/src/main/java/org/openremote/model/asset/AssetType.java
+++ b/model/src/main/java/org/openremote/model/asset/AssetType.java
@@ -26,8 +26,7 @@ import org.openremote.model.value.Values;
import java.util.Optional;
-import static org.openremote.model.Constants.ASSET_META_NAMESPACE;
-import static org.openremote.model.Constants.ASSET_NAMESPACE;
+import static org.openremote.model.Constants.*;
import static org.openremote.model.attribute.AttributeType.*;
import static org.openremote.model.attribute.AttributeValueType.*;
import static org.openremote.model.attribute.MetaItemType.*;
diff --git a/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java b/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
index 1995bf47b..ae6045e41 100644
--- a/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
+++ b/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
@@ -80,6 +80,12 @@ public class EventSubscription<E extends SharedEvent> {
this.internalConsumer = internalConsumer;
}
+ public EventSubscription(Class<E> eventClass, EventFilter<E> filter, String subscriptionId) {
+ this.eventType = Event.getEventType(eventClass);
+ this.filter = filter;
+ this.subscriptionId = subscriptionId;
+ }
+
public EventSubscription(Class<E> eventClass, EventFilter<E> filter, String subscriptionId, Consumer<TriggeredEventSubscription<E>> internalConsumer) {
this.eventType = Event.getEventType(eventClass);
this.filter = filter;
diff --git a/profile/deploy.yml b/profile/deploy.yml
index 9c0e22c91..83ff658d1 100644
--- a/profile/deploy.yml
+++ b/profile/deploy.yml
@@ -70,6 +70,7 @@ services:
ports:
- "80:80"
- "443:443"
+ - "8883:8883"
# Resource limits
mem_reservation: 512m
diff --git a/proxy/Dockerfile b/proxy/Dockerfile
index 20c9fcb10..2fe5d7136 100644
--- a/proxy/Dockerfile
+++ b/proxy/Dockerfile
@@ -58,7 +58,7 @@ ADD selfsigned /opt/selfsigned
ADD cli.ini /root/.config/letsencrypt/
-EXPOSE 80 443
+EXPOSE 80 443 8883
HEALTHCHECK --interval=3s --timeout=3s --start-period=2s --retries=30 CMD curl --fail --silent http://localhost:80 || exit 1
diff --git a/proxy/haproxy.cfg b/proxy/haproxy.cfg
index 0a4714147..3c8aeaeb7 100644
--- a/proxy/haproxy.cfg
+++ b/proxy/haproxy.cfg
@@ -68,5 +68,17 @@ frontend https
use_backend proxy_backend
+listen mqtt
+ bind *:8883 ssl crt "${CERT_FILE}" no-sslv3 no-tls-tickets no-tlsv10 no-tlsv11
+ mode tcp
+ #Use this to avoid the connection loss when client subscribed for a topic and its idle for sometime
+ option clitcpka # For TCP keep-alive
+ timeout client 3h #By default TCP keep-alive interval is 2hours in OS kernal, 'cat /proc/sys/net/ipv4/tcp_keepalive_time'
+ timeout server 3h #By default TCP keep-alive interval is 2hours in OS kernal
+ option tcplog
+ balance leastconn
+
+ server proxy_backend_host "${PROXY_BACKEND_HOST}":1883
+
backend proxy_backend
- server proxy_backend_host "${PROXY_BACKEND_HOST}":"${PROXY_BACKEND_PORT}"
+ server proxy_backend_host "${PROXY_BACKEND_HOST}":"${PROXY_BACKEND_PORT}"
diff --git a/test/src/main/groovy/org/openremote/test/ContainerTrait.groovy b/test/src/main/groovy/org/openremote/test/ContainerTrait.groovy
index c805f1f22..83aaa1f8c 100644
--- a/test/src/main/groovy/org/openremote/test/ContainerTrait.groovy
+++ b/test/src/main/groovy/org/openremote/test/ContainerTrait.groovy
@@ -29,7 +29,7 @@ import org.keycloak.representations.AccessTokenResponse
import org.openremote.container.Container
import org.openremote.container.ContainerService
import org.openremote.container.message.MessageBrokerService
-import org.openremote.container.security.AuthForm
+import org.openremote.container.security.PasswordAuthForm
import org.openremote.container.security.IdentityService
import org.openremote.container.security.keycloak.KeycloakIdentityProvider
import org.openremote.container.web.DefaultWebsocketComponent
@@ -112,7 +112,7 @@ trait ContainerTrait {
static AccessTokenResponse authenticate(Container container, String realm, String clientId, String username, String password) {
((KeycloakIdentityProvider)container.getService(IdentityService.class).getIdentityProvider()).getKeycloak()
- .getAccessToken(realm, new AuthForm(clientId, username, password))
+ .getAccessToken(realm, new PasswordAuthForm(clientId, username, password))
}
static ProducerTemplate getMessageProducerTemplate(Container container) {
diff --git a/test/src/main/groovy/org/openremote/test/MqttClient.groovy b/test/src/main/groovy/org/openremote/test/MqttClient.groovy
new file mode 100644
index 000000000..f90d8252d
--- /dev/null
+++ b/test/src/main/groovy/org/openremote/test/MqttClient.groovy
@@ -0,0 +1,192 @@
+package org.openremote.test
+
+import io.netty.bootstrap.Bootstrap
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.Unpooled
+import io.netty.channel.Channel
+import io.netty.channel.ChannelHandler
+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.ChannelInboundHandlerAdapter
+import io.netty.channel.ChannelInitializer
+import io.netty.channel.ChannelOption
+import io.netty.channel.ChannelPipeline
+import io.netty.channel.EventLoopGroup
+import io.netty.channel.nio.NioEventLoopGroup
+import io.netty.channel.socket.SocketChannel
+import io.netty.channel.socket.nio.NioSocketChannel
+import io.netty.util.ReferenceCountUtil
+
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Semaphore
+import java.util.concurrent.TimeUnit
+
+import static io.netty.channel.ChannelFutureListener.CLOSE_ON_FAILURE
+
+class RawClient {
+
+ @ChannelHandler.Sharable
+ class RawMessageHandler extends ChannelInboundHandlerAdapter {
+
+ @Override
+ void channelRead(ChannelHandlerContext ctx, Object message) {
+ try {
+ ByteBuf byteBuf = (ByteBuf) message
+ int readBytes = byteBuf.readableBytes()
+ heapBuffer.writeBytes(byteBuf)
+ readableBytesSem.release(readBytes)
+ } finally {
+ ReferenceCountUtil.release(message)
+ }
+ }
+
+ @Override
+ void channelInactive(ChannelHandlerContext ctx) {
+ disconnectLatch.countDown()
+ ctx.close().addListener(CLOSE_ON_FAILURE)
+ }
+ }
+
+ final RawMessageHandler handler
+ EventLoopGroup workerGroup
+ Channel m_channel
+
+ private boolean connected
+ private ByteBuf heapBuffer
+ private CountDownLatch disconnectLatch
+ private final Semaphore readableBytesSem
+
+ @SuppressWarnings("FutureReturnValueIgnored")
+ private RawClient(String host, int port) {
+ handler = new RawMessageHandler()
+ heapBuffer = Unpooled.buffer(128)
+ disconnectLatch = new CountDownLatch(1)
+ readableBytesSem = new Semaphore(0, true)
+
+ workerGroup = new NioEventLoopGroup()
+
+ try {
+ Bootstrap b = new Bootstrap()
+ b.group(workerGroup)
+ b.channel(NioSocketChannel.class)
+ b.option(ChannelOption.SO_KEEPALIVE, true)
+ b.handler(new ChannelInitializer<SocketChannel>() {
+
+ @Override
+ void initChannel(SocketChannel ch) throws Exception {
+ ChannelPipeline pipeline = ch.pipeline()
+ pipeline.addLast("handler", handler)
+ }
+ })
+
+ // Start the client.
+ m_channel = b.connect(host, port).sync().channel()
+ this.connected = true
+ } catch (Exception ex) {
+ LOG.error("Error received in client setup", ex)
+ workerGroup.shutdownGracefully()
+ }
+ }
+
+ static RawClient connect(String host, int port) {
+ return new RawClient(host, port)
+ }
+
+ RawClient isConnected() {
+ if (!this.connected) {
+ throw new IllegalStateException("Can't connect the client")
+ }
+ return this
+ }
+
+ RawClient write(int... bytes) {
+ ByteBuf buff = Unpooled.buffer(bytes.length)
+ buff.clear()
+ for (int b : bytes) {
+ buff.writeByte((byte) b)
+ }
+ m_channel.write(buff).addListener(CLOSE_ON_FAILURE)
+ return this
+ }
+
+ RawClient writeWithSize(String str) {
+ ByteBuf buff = Unpooled.buffer(str.length() + 2)
+ buff.writeBytes(encodeString(str))
+ m_channel.write(buff).addListener(CLOSE_ON_FAILURE)
+ return this
+ }
+
+ /**
+ * Write just String bytes not length
+ */
+ RawClient write(String str) {
+ ByteBuf out = Unpooled.buffer(str.length())
+ byte[] raw
+ try {
+ raw = str.getBytes("UTF-8")
+ // NB every Java platform has got UTF-8 encoding by default, so this
+ // exception are never raised.
+ } catch (UnsupportedEncodingException ex) {
+ throw new IllegalStateException(ex)
+ }
+ out.writeBytes(raw)
+ m_channel.write(out).addListener(CLOSE_ON_FAILURE)
+ return this
+ }
+
+ RawClient flush() {
+ m_channel.flush()
+ return this
+ }
+
+ RawClient read(int expectedByte) {
+ try {
+ readableBytesSem.acquire(1)
+ } catch (InterruptedException e) {
+ throw new IllegalStateException("Interrupted while waiting data")
+ }
+ byte b = heapBuffer.readByte()
+ if (b != expectedByte) {
+ throw new IllegalStateException(String.format("Expected byte 0x%02X but found 0x%02X", b, expectedByte))
+ }
+ return this
+ }
+
+ /**
+ * Expect the closing of the underling channel, with timeout
+ */
+ void closed(long timeout) throws InterruptedException {
+ disconnectLatch.await(timeout, TimeUnit.MILLISECONDS)
+ }
+
+ /**
+ * Expect closing the connect with unbound time
+ */
+ void closed() throws InterruptedException {
+ disconnectLatch.await()
+ }
+
+ /**
+ * Return the IoBuffer with string encoded as MSB, LSB and UTF-8 encoded string content.
+ */
+ static ByteBuf encodeString(String str) {
+ byte[] raw
+ try {
+ raw = str.getBytes("UTF-8")
+ // NB every Java platform has got UTF-8 encoding by default, so this
+ // exception are never raised.
+ } catch (UnsupportedEncodingException ex) {
+ return null
+ }
+ return encodeFixedLengthContent(raw)
+ }
+
+ /**
+ * Return the IoBuffer with string encoded as MSB, LSB and bytes array content.
+ */
+ static ByteBuf encodeFixedLengthContent(byte[] content) {
+ ByteBuf out = Unpooled.buffer(2)
+ out.writeShort(content.length)
+ out.writeBytes(content)
+ return out
+ }
+}
diff --git a/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy b/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
index ec7cb3d61..89055f473 100644
--- a/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
@@ -131,10 +131,9 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
and: "the server should have sent a CONNECTED message and an asset read request"
conditions.eventually {
- assert clientReceivedMessages.size() >= 2
- assert clientReceivedMessages[0] == "CONNECTED"
- assert clientReceivedMessages[1].startsWith(SharedEvent.MESSAGE_PREFIX)
- def readAssetsEvent = Container.JSON.readValue(clientReceivedMessages[1].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ assert clientReceivedMessages.size() >= 1
+ assert clientReceivedMessages[0].startsWith(SharedEvent.MESSAGE_PREFIX)
+ def readAssetsEvent = Container.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
assert readAssetsEvent.name == GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL
assert readAssetsEvent.assetQuery != null
assert readAssetsEvent.assetQuery.select.excludeAttributes
@@ -606,12 +605,11 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
assert gateway.getAttribute("status").flatMap{it.getValueAsString()}.orElse(null) == ConnectionStatus.CONNECTING.name()
}
- and: "the local manager should have sent a CONNECTED message and an asset read request"
+ and: "the local manager should have sent an asset read request"
conditions.eventually {
- assert clientReceivedMessages.size() >= 2
- assert clientReceivedMessages[0] == "CONNECTED"
- assert clientReceivedMessages[1].startsWith(SharedEvent.MESSAGE_PREFIX)
- assert clientReceivedMessages[1].contains("read-assets")
+ assert clientReceivedMessages.size() >= 1
+ assert clientReceivedMessages[0].startsWith(SharedEvent.MESSAGE_PREFIX)
+ assert clientReceivedMessages[0].contains("read-assets")
}
when: "the previously received messages are cleared"
diff --git a/test/src/test/groovy/org/openremote/test/mqtt/MqttTest.groovy b/test/src/test/groovy/org/openremote/test/mqtt/MqttTest.groovy
new file mode 100644
index 000000000..9f61dab41
--- /dev/null
+++ b/test/src/test/groovy/org/openremote/test/mqtt/MqttTest.groovy
@@ -0,0 +1,244 @@
+package org.openremote.test.mqtt
+
+import com.google.common.collect.Lists
+import io.moquette.BrokerConstants
+import org.openremote.container.util.UniqueIdentifierGenerator
+import org.openremote.manager.asset.AssetProcessingService
+import org.openremote.manager.mqtt.MqttBrokerService
+import org.openremote.manager.setup.SetupService
+import org.openremote.manager.setup.builtin.ManagerDemoSetup
+import org.openremote.model.attribute.AttributeEvent
+import org.openremote.model.value.Values
+import org.openremote.test.ManagerContainerTrait
+import org.openremote.test.RawClient
+import spock.lang.Specification
+import spock.util.concurrent.PollingConditions
+
+import java.nio.charset.Charset
+
+import static org.openremote.container.util.MapAccess.*
+import static org.openremote.manager.mqtt.KeycloakAuthenticator.MQTT_CLIENT_ID_SEPARATOR
+import static org.openremote.manager.mqtt.MqttBrokerService.MQTT_SERVER_LISTEN_HOST
+import static org.openremote.manager.mqtt.MqttBrokerService.MQTT_SERVER_LISTEN_PORT
+import static org.openremote.manager.mqtt.MqttBrokerService.PAYLOAD_SEPARATOR
+
+class MqttTest extends Specification implements ManagerContainerTrait {
+ def "Mqtt broker test"() {
+
+ given: "the container environment is started"
+ def mqttBrokerServiceAttributeEventCalls = 0
+ def spyMqttBrokerService = Spy(MqttBrokerService) {
+ sendAttributeEvent(_ as String, _ as AttributeEvent) >> {
+ clientId, attributeEvent ->
+ mqttBrokerServiceAttributeEventCalls++
+ callRealMethod()
+ }
+ }
+
+ def conditions = new PollingConditions(timeout: 10, delay: 1)
+ def serverPort = findEphemeralPort()
+ def services = Lists.newArrayList(defaultServices())
+ services.replaceAll { it instanceof MqttBrokerService ? spyMqttBrokerService : it }
+ def container = startContainer(defaultConfig(serverPort), services)
+ def managerDemoSetup = container.getService(SetupService.class).getTaskOfType(ManagerDemoSetup.class)
+ def mqttBrokerService = container.getService(MqttBrokerService.class)
+ def assetProcessingService = container.getService(AssetProcessingService.class)
+ def mqttClientId = managerDemoSetup.realmBuildingTenant + MQTT_CLIENT_ID_SEPARATOR + UniqueIdentifierGenerator.generateId()
+ def clientId = MqttBrokerService.MQTT_CLIENT_ID_PREFIX + UniqueIdentifierGenerator.generateId(managerDemoSetup.realmBuildingTenant)
+ def clientSecret = UniqueIdentifierGenerator.generateId(managerDemoSetup.realmBuildingTenant)
+
+ def mqttHost = getString(container.getConfig(), MQTT_SERVER_LISTEN_HOST, BrokerConstants.HOST);
+ def mqttPort = getInteger(container.getConfig(), MQTT_SERVER_LISTEN_PORT, BrokerConstants.PORT);
+
+ expect: "the container should be running and initialised"
+ conditions.eventually {
+ assert container.isRunning()
+ }
+
+ when: "a mqtt client connects with wrong credentials"
+ def payloadLength = "client1".size() + clientId.size() + clientSecret.size()
+ def remainingLength = 16 + payloadLength
+ def client = RawClient.connect(mqttHost, mqttPort).isConnected()
+ // CONNECT
+ .write(0x10) // MQTT Control Packet type(1)
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x04) // Protocol Name Length
+ .write("MQTT") // Protocol Name
+ .write(0x04) // The value of the Protocol Level field for the version 3.1.1 of the protocol is 4 (0x04)
+
+ // Connect Flags
+ // User Name Flag(1)
+ // Password Flag(1)
+ // Will Retain(0)
+ // Will QoS(00)
+ // Will Flag(0)
+ // Clean Session(1)
+ // Reserved(0)
+ .write(0xC2)
+ .write(0x00, 0x00) // Keep Alive
+
+ // Payload
+ .write(0x00, "client1".size().byteValue()) // Client Identifier Length
+ .write("client1") // Client Identifier
+ .write(0x00, clientId.size().byteValue())
+ .write(clientId)
+ .write(0x00, clientSecret.size().byteValue())
+ .write(clientSecret)
+ .flush()
+
+ then: "no connection should be made"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.size() == 0
+ }
+
+ when: "a mqtt client connects"
+ payloadLength = mqttClientId.size() + clientId.size() + clientSecret.size()
+ remainingLength = 16 + payloadLength
+ client = RawClient.connect(mqttHost, mqttPort).isConnected()
+ // CONNECT
+ .write(0x10) // MQTT Control Packet type(1)
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x04) // Protocol Name Length
+ .write("MQTT") // Protocol Name
+ .write(0x04) // The value of the Protocol Level field for the version 3.1.1 of the protocol is 4 (0x04)
+
+ // Connect Flags
+ // User Name Flag(1)
+ // Password Flag(1)
+ // Will Retain(0)
+ // Will QoS(00)
+ // Will Flag(0)
+ // Clean Session(1)
+ // Reserved(0)
+ .write(0xC2)
+ .write(0x00, 0x00) // Keep Alive
+
+ // Payload
+ .write(0x00, mqttClientId.size().byteValue()) // Client Identifier Length
+ .write(mqttClientId) // Client Identifier
+ .write(0x00, clientId.size().byteValue())
+ .write(clientId)
+ .write(0x00, clientSecret.size().byteValue())
+ .write(clientSecret)
+ .flush()
+
+ then: "mqtt connection should exist"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.get(mqttClientId) != null
+ }
+
+ when: "a mqtt client subscribes to an asset in another realm"
+ def topic = "assets/" + managerDemoSetup.thingId + "/" + managerDemoSetup.thingLightToggleAttributeName
+ remainingLength = 4 + topic.size() + 1 //plus one for the QoS byte
+
+ client
+ // SUBSCRIBE
+ .write(0x82) // MQTT Control Packet type(8) with QoS level 1
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x10) // MessageId
+
+ // Payload
+ .write(0x00, topic.size().byteValue()) // Topic Length
+ .write(topic) // Topic
+ .write(0x01) // QoS level 1
+ .flush()
+
+ then: "No subscription should exist"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.get(mqttClientId).assetSubscriptions.size() == 0
+ }
+
+ when: "a mqtt client subscribes to an non existing asset"
+ topic = "assets/dhajkdasjfgh/"
+ remainingLength = 4 + topic.size() + 1 //plus one for the QoS byte
+
+ client
+ // SUBSCRIBE
+ .write(0x82) // MQTT Control Packet type(8) with QoS level 1
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x10) // MessageId
+
+ // Payload
+ .write(0x00, topic.size().byteValue()) // Topic Length
+ .write(topic) // Topic
+ .write(0x01) // QoS level 1
+ .flush()
+
+ then: "No subscription should exist"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.get(mqttClientId).assetSubscriptions.size() == 0
+ }
+
+ when: "a mqtt client subscribes to an asset"
+ topic = "assets/" + managerDemoSetup.apartment1HallwayId
+ remainingLength = 4 + topic.size() + 1 //plus one for the QoS byte
+
+ client
+ // SUBSCRIBE
+ .write(0x82) // MQTT Control Packet type(8) with QoS level 1
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x10) // MessageId
+
+ // Payload
+ .write(0x00, topic.size().byteValue()) // Topic Length
+ .write(topic) // Topic
+ .write(0x01) // QoS level 1
+ .flush()
+
+ then: "A subscription should exist"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.get(mqttClientId).assetSubscriptions.size() > 0
+ }
+
+ when: "An asset attribute changed the client is subscribed on"
+ def attributeEvent = new AttributeEvent(managerDemoSetup.apartment1HallwayId, "motionSensor", Values.create(50))
+ assetProcessingService.sendAttributeEvent(attributeEvent)
+
+ then: "A publish message should be sent"
+ conditions.eventually {
+ assert mqttBrokerServiceAttributeEventCalls == 1
+ }
+
+ when: "Another asset attribute changed the client is subscribed on"
+ attributeEvent = new AttributeEvent(managerDemoSetup.apartment1HallwayId, "presenceDetected", Values.create(true))
+ assetProcessingService.sendAttributeEvent(attributeEvent)
+
+ then: "A second publish message should be sent"
+ conditions.eventually {
+ assert mqttBrokerServiceAttributeEventCalls == 2
+ }
+
+ when: "a mqtt client unsubscribes to an asset"
+ topic = "assets/" + managerDemoSetup.apartment1HallwayId
+ remainingLength = 4 + topic.size()
+
+ client
+ // UNSUBSCRIBE
+ .write(0xA2) // MQTT Control Packet type(10) with QoS level 1
+ .write(remainingLength.byteValue()) // Remaining Length
+ .write(0x00, 0x10) // MessageId
+
+ // Payload
+ .write(0x00, topic.size().byteValue()) // Topic Length
+ .write(topic) // Topic
+ .flush()
+
+
+ then: "No subscription should exist"
+ conditions.eventually {
+ assert mqttBrokerService.mqttConnectionMap.get(mqttClientId).assetSubscriptions.size() == 0
+ }
+
+ when: "Another asset attribute changed without any subscriptions"
+ attributeEvent = new AttributeEvent(managerDemoSetup.apartment1HallwayId, "presenceDetected", Values.create(false))
+ assetProcessingService.sendAttributeEvent(attributeEvent)
+
+ then: "No publish message should be sent"
+ conditions.eventually {
+ assert mqttBrokerServiceAttributeEventCalls == 2
+ }
+
+ cleanup: "the server should be stopped"
+ stopContainer(container)
+ }
+}
diff --git a/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy b/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
index 761ef79c8..73b704d6a 100644
--- a/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/notification/NotificationTest.groovy
@@ -581,15 +581,16 @@ class NotificationTest extends Specification implements ManagerContainerTrait {
then: "the email should have been sent to all tenant users"
conditions.eventually {
- assert notificationMessages.size() == 3
+ assert notificationMessages.size() == 4
assert ((EmailNotificationMessage) notificationMessages.get(0)).getText() == "Hello world!"
assert ((EmailNotificationMessage) notificationMessages.get(0)).getSubject() == "Test"
assert ((EmailNotificationMessage) notificationMessages.get(1)).getText() == "Hello world!"
assert ((EmailNotificationMessage) notificationMessages.get(1)).getSubject() == "Test"
- assert toAddresses.size() == 3
+ assert toAddresses.size() == 4
assert toAddresses.any { it == "[email protected]" }
assert toAddresses.any { it == "[email protected]" }
assert toAddresses.any { it == "[email protected]" }
+ assert toAddresses.any { ((String) it).startsWith("service-account") } //mqtt service account
}
when: "an email attribute is added to an asset"
@@ -603,8 +604,8 @@ class NotificationTest extends Specification implements ManagerContainerTrait {
then: "the child asset with the email attribute should have been sent an email"
conditions.eventually {
- assert notificationMessages.size() == 4
- assert toAddresses.size() == 4
+ assert notificationMessages.size() == 5
+ assert toAddresses.size() == 5
assert toAddresses.any { it == "[email protected]" }
}
diff --git a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
index 1aea3769b..e7fc1cbf4 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
@@ -97,12 +97,6 @@ class WebsocketClientTest extends Specification implements ManagerContainerTrait
assert connectionStatus == ConnectionStatus.CONNECTED
}
- and: "the server should have sent a CONNECTED message"
- conditions.eventually {
- assert lastMessage != null
- assert lastMessage == "CONNECTED"
- }
-
when: "we subscribe to events produced by the server"
client.sendMessage(EventSubscription.SUBSCRIBE_MESSAGE_PREFIX + Container.JSON.writeValueAsString(
new EventSubscription(