Additional HiveMQ Enterprise Extension SDK Services

final ConsumerOptions consumerOptions = EnterpriseBuilders.consumerOptions()
        .topicFilters("+/IN/#", "+/OUT/#")
        .queueLimit(1_000_000).build();

    public class MySimpleConsumer implements MessageConsumer {
        @Override
        public void consume(@NotNull ConsumerInput consumerInput, @NotNull ConsumerOutput consumerOutput) {
            final PublishPacket publishPacket = consumerInput.getPublish();
            final Async<ConsumerOutput> async = consumerOutput.async(Duration.ofSeconds(2));
            Services.extensionExecutorService().submit(() -> doSomethingWith(publishPacket, async));
        }
        private void doSomethingWith(final @NotNull PublishPacket publishPacket, final @NotNull Async<ConsumerOutput> async) {
            try {
                //your business logic
            } catch (Exception any) {
                async.getOutput().cancelConsumption();
            } finally {
                async.resume();
            }
        }
    }

EnterpriseServices.consumerService()

EnterpriseServices.consumerService()
  .registerConsumer(consumerId, consumerOptions, new MessageConsumerProvider() {
      @Override
      public @NotNull MessageConsumer get() {
          return myConsumer;
      }
  });

public void init(final @NotNull ConsumerOptions consumerOptions) {
   log.info("Initialize myConsumer");
}

EnterpriseServices.consumerService().removeConsumer(consumerId);

public void destroy(final @NotNull ConsumerOptions consumerOptions) {
    log.info("Destroy myConsumer");
}

final @NotNull Map<String, @NotNull ModifiableConsumerOptions> myConsumers = EnterpriseServices.consumerService().getConsumers();

EnterpriseServices.sessionAttributeStore()

final @NotNull CompletableFuture<Map<String, ByteBuffer>> attributes = EnterpriseServices.sessionAttributeStore().getAll(clientId);
attributes.whenComplete( (aMap, throwable) -> {
   if (throwable == null) {
       log.info("Attributes found", aMap.keySet());
       checkAttributes(aMap);
   } else {
       log.warn("Exception with reason:", throwable.getMessage());
   }
});

final String clientId = initializerInput.getClientInformation().getClientId();
EnterpriseServices.sessionAttributeStore().clear(clientId);

EnterpriseServices.sessionAttributeStore().put(clientId, "myAttributeKey",
    ByteBuffer.wrap("myAttributeValue".getBytes(StandardCharsets.UTF_8)));

final @NotNull CompletableFuture<Optional<ByteBuffer>> myAttributeValue = EnterpriseServices.sessionAttributeStore().get(clientId, "myAttributeKey");
myAttributeValue.whenComplete( (aBuffer, throwable) -> {
   if (throwable == null) {
       if (aBuffer.isPresent()) {
          log.info("Attribute found", getValueAsStringFrom(aBuffer.get()));
       } else {
          log.info("Attribute not found");
       }
   } else {
       log.warn("Exception with reason:", throwable.getMessage());
   }
});

EnterpriseServices.sessionAttributeStore().remove(clientId,"myAttributeKey");

EnterpriseBuilders.extensionMessageOptions().mode(BroadcastMode.OTHERS).build()

EnterpriseServices.extensionMessagingService()
    .register(MY_MESSAGE_ID, new MySimpleMessagingService.MySimpleRespondCallback());

final List<CompletableFuture<ExtensionMessageResponse>> responseList =
    EnterpriseServices.extensionMessagingService.send(MY_MESSAGE_ID,
                                                        new byte[0],
                                                        extensionMessageOptions);

static class MyRespondCallback implements ExtensionMessageCallback {
    ...

    @Override
    public void receive(@NotNull ExtensionMessage extensionMessage) {
        ...
        extensionMessage.respond(serializedResponseData);
        ...
    }
}

extensionMessagingService.unregister(MY_MESSAGE_ID);

EnterpriseServices.controlCenterService()

//Implementation of the authenticator
public class MyControlCenterAuthenticator implements ControlCenterAuthenticator {

    public void onLogin(final @NotNull ControlCenterAuthInput controlCenterAuthInput, final @NotNull ControlCenterAuthOutput controlCenterAuthOutput) {
        final String username = controlCenterAuthInput.getUsername();
        final String password = controlCenterAuthInput.getPassword();
        if (loginAllowed(username, password)) {
            final Set<String> permissionsForUser = fetchPermissions(username);
            controlCenterAuthOutput.getUserPermissions().addAll(permissionsForUser);
            controlCenterAuthOutput.authenticateSuccessfully();
        } else {
            controlCenterAuthOutput.failAuthentication();
        }
    }
}

//usage
EnterpriseServices.controlCenterService().setAuthenticator(new MyControlCenterAuthenticator());

public static class MyEnhancedAuthenticator implements ControlCenterEnhancedAuthenticator {
    @Override
    public void onLoginLoad(@NotNull LoginLoadInput loginLoadInput, @NotNull LoginLoadOutput loginLoadOutput) {
brickhof marked this conversation as resolved.
        // session id of the control center session
        final String sessionId = loginLoadInput.getSessionId();
        // the http request of the login in the control center
        final HttpRequest request = loginLoadInput.getRequest();
        // actions on the output object
        // show ui components on the login page, see the example configuration for more information
        loginLoadOutput.showLoginComponents(List.of());
        // redirect user, see the example configuration for more information
        loginLoadOutput.redirectUser(url, "/callbackPath", (LoginHttpCallback) (input, output) -> {});
        // successfully complete the authentication process
        loginLoadOutput.authenticateSuccessfully("example user");
        // fail authentication process
        loginLoadOutput.failAuthentication();
        // add user permissions for this user
        loginLoadOutput.getUserPermissions().add("SUPER_PERMISSION");
        // skip this extension for the authentication and delegate it to another extension or the default behavior
        loginLoadOutput.nextExtensionOrDefault();
    }
    // this is an optional method that gets called after the authentication finishes
    @Override
    public void onLoginFinished(@NotNull LoginFinishedInput loginFinishedInput) {
        // the session id of the control center user
        final String sessionId = loginFinishedInput.getSessionId();
        System.out.println("User logged in with session id: " + sessionId);
        // check whether there are any error messages, and print error messages that are  present
        if(loginFinishedInput.getErrorMessage().isPresent()){
            System.out.println(loginFinishedInput.getErrorMessage().get());
        }
        // check and react to the outcome of the authentication process
        final LoginFinishedInput.LoginOutcome outcome = loginFinishedInput.getOutcome();
        switch (outcome) {
            case SUCCESS:
                System.out.println("Control center authentication succeeded for session id " + sessionId);
                break;
            case FAIL:
                System.out.println("Control center authentication failed for session id " + sessionId);
                break;
            case TIMEOUT:
                System.out.println("Control center authentication timed out for session id " + sessionId);
                break;
        }
    }
}

final @NotNull ControlCenterPermission permission =
EnterpriseBuilders.controlCenterPermission()
.id(MY_DASHBOARD_VIEW)
.displayName("View My Dashboard")
.description("View My Dashboard Permission")
.group("CUSTOM").build();

EnterpriseServices.controlCenterService().addPermission(permission);

//Use permission by setting in ControlCenterAuthenticator Output for the logged-in user

controlCenterAuthOutput.getUserPermissions().add(MY_DASHBOARD_VIEW);

EnterpriseServices.controlCenterService().addView(new MyExtensionView(myViewDataProvider);

@NotNull Notification myNotification;
myNotification = new Notification() {
@Override
public @NotNull String getMessage() { return "Hello from myExtension"; }
@Override
public @NotNull NotificationLevel getLevel() { return NotificationLevel.INFO; }
};

EnterpriseServices.controlCenterService().addNotification(myNotification);
EnterpriseServices.controlCenterService().removeNotification(myNotification);

EnterpriseServices.restService()

//simple example for rest service usage
Resource r = new Resource("backend");
try {
   EnterpriseServices.restService().setRestApplication(() -> List.of(r));
} catch (FeatureDisabledException disabledException) {
   //ignore
   log.error("REST-API is not enabled in config.xml");
}

EnterpriseServices.restService().removeRestApplication();

EnterpriseServices.restService().setAuthenticator(new MyRestAuthenticator());

public class DemoAuthenticator implements RestAuthenticator {
    @Override
    public void onRequest(final @NotNull RestAuthInput restAuthInput, final @NotNull RestAuthOutput restAuthOutput) {
            restAuthOutput.authenticateSuccessfully("myuser");
    }
}

public class HelloWorldEnterpriseMain implements ExtensionMain {

    @Override
    public void extensionStart(
            final @NotNull ExtensionStartInput extensionStartInput,
            final @NotNull ExtensionStartOutput extensionStartOutput) {
        //Register the custom REST authenticator
       EnterpriseServices.restService().setAuthenticator(new DemoAuthenticator());
     }
}

public class DemoAuthenticator implements RestAuthenticator {
    @Override
    public void onRequest(final @NotNull RestAuthInput restAuthInput, final @NotNull RestAuthOutput restAuthOutput) {
            restAuthOutput.authenticateSuccessfully("user");
    }
}

public class DemoAuthenticator implements RestAuthenticator {
    @Override
    public void onRequest(final @NotNull RestAuthInput restAuthInput, final @NotNull RestAuthOutput restAuthOutput) {
            restAuthOutput.failAuthentication();
    }
}

public class DemoAuthenticator implements RestAuthenticator {
    @Override
    public void onRequest(final @NotNull RestAuthInput restAuthInput, final @NotNull RestAuthOutput restAuthOutput) {
            restAuthOutput.nextExtensionOrDefault();
    }
}

public class DemoAuthenticator implements RestAuthenticator {

    @Override
    public void onRequest(@NotNull RestAuthInput restAuthInput, @NotNull RestAuthOutput restAuthOutput) {
        // print all inputs:
        log.info("Input: {url:" + restAuthInput.getRequestUrl().toExternalForm() +
                ", http-method: " + restAuthInput.getHttpMethod() +
                ", listener-name:" + restAuthInput.getListener().getName() +
                ", remote-addr:" + restAuthInput.getRemoteAddress() +
                ", remote-port:" + restAuthInput.getRemotePort() +
                ", headers:" + restAuthInput.getHttpHeaders().toString() +
                (restAuthInput.getTlsInformation().isPresent() ? ", tls-info: [protocol:" + restAuthInput.getTlsInformation().get().getProtocol() +
                        ", cipher:" + restAuthInput.getTlsInformation().get().getCipherSuite() + "]" : "none"));


        restAuthOutput.authenticateSuccessfully(username);
    }
}

@Path("/demo")
public class DemoResource {

	// resource with default behavior that requires authentication but does not require authorization/permissions
    @Path("/example-default-behavior")
    @GET
    public String noauth() {
        return "This resource requires authentication but does not require authorization";
    }
}

public class DemoAuthenticator implements RestAuthenticator {
    @Override
    public void onRequest(final @NotNull RestAuthInput restAuthInput, final @NotNull RestAuthOutput restAuthOutput) {
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_BACKUPS_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_BACKUPS_BACKUPID_POST");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_BACKUPS_BACKUPID_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_BACKUPS_BACKUPID_POST");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_TRACE_RECORDINGS_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_TRACE_RECORDINGS_POST");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_TRACE_RECORDINGS_TRACERECORDINGID_PATCH");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_TRACE_RECORDINGS_TRACERECORDINGID_DELETE");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_FILES_TRACE_RECORDINGS_TRACERECORDINGID_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MANAGEMENT_FILES_BACKUPS_BACKUPID_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_SUBSCRIPTIONS_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_CONNECTION_DELETE");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_DELETE");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_CONNECTION_GET");
                restAuthOutput.getUserPermissions().add("HIVEMQ_MQTT_CLIENTS_CLIENTID_CONNECTION_DELETE");
                restAuthOutput.getUserPermissions().add("CUSTOM_PERMISSION");
                restAuthOutput.authenticateSuccessfully("user");
    }
}

@Path("/demo")
public class DemoResource {

	// resource that does not require authentication and allows access to everyone:
    @Path("/example-no-authentication")
    @GET
    @NoAuthenticationRequired
    public String noauth() {
        return "This resource does not need any authentication or authorization";
    }
}

@Path("/demo")
public class DemoResource {

	// resource that requires the  permission "/perm1"
    @Path("/perm1")
    @GET
    @RequiresPermissions("PERMISSION1")
    public String perm1() {
        return "this resource requires successful authentication with the permission \"PERMISSION1\"";
    }
}

@Path("/demo")
public class DemoResource {
	// a security context can be injected to use information such as  usernname, http/https, roles and permissions
    @Path("/context")
    @GET
    @Produces("application/json")
    public Map<String, String> secure(@Context SecurityContext securityContext) {
        if (securityContext == null) {
            return null;
        }

        return Map.of(
                "username", securityContext.getUserPrincipal() != null ? securityContext.getUserPrincipal().getName() : "null",
                "secure", securityContext.isSecure() ? "true" : "false",
                "super-admin", securityContext.isUserInRole("HIVEMQ_SUPER_ADMIN") ? "true" : "false",
                "perm1", securityContext.isUserInRole("PERMISSION1") ? "true" : "false",
                "perm2", securityContext.isUserInRole("PERMISSION2") ? "true" : "false"
        );
    }


}

EnterpriseServices.clientEventService()

EnterpriseServices.clientEventService().iterateEventsForClient(clientId, from, to, (context, event) -> {
   switch (event.getType()) {
       case OVERLOAD_PROTECTION_ON: {
           resource.getClientStates().add( OVERLOAD_PROTECTION_ON.toString());
           break;
       }
       case OVERLOAD_PROTECTION_OFF: {
           resource.getClientStates().add( OVERLOAD_PROTECTION_OFF.toString());
           break;
       }
       case DISCONNECT_BY_CLIENT_GRACEFUL:
       case DISCONNECT_BY_CLIENT_UNGRACEFUL:
       case DISCONNECT_BY_SERVER:
       {
           resource.getClientStates().add(event.toString());
           context.abortIteration();
           break;
       }
   }
});

Services.initializerRegistry().setClientInitializer(((initializerInput, clientContext) -> {
    clientContext.addPublishInboundInterceptor((publishInboundInput, publishInboundOutput) -> {

        // original publish packet class name is "ModifiablePublishPacket"
        final ModifiablePublishPacket originalPacket = publishInboundOutput.getPublishPacket();

        // add "Enterprise" to "ModifiablePublishPacket" to get the class name of the enterprise version
        final EnterpriseModifiablePublishPacket enterprisePacket = (EnterpriseModifiablePublishPacket) originalPacket;

        final ModifiablePublishAttributes publishAttributes = enterprisePacket.getPublishAttributes();
        publishAttributes.put("key", StandardCharsets.UTF_8.encode("value"));
    });
}));

Services.initializerRegistry().setClientInitializer(((initializerInput, clientContext) -> {
    clientContext.addPublishInboundInterceptor((publishInboundInput, publishInboundOutput) -> {

        final String clientId = publishInboundInput.getClientInformation().getClientId();
        final EnterpriseModifiablePublishPacket publishPacket = (EnterpriseModifiablePublishPacket) publishInboundOutput.getPublishPacket();

        final ModifiablePublishAttributes publishAttributes = publishPacket.getPublishAttributes();
        publishAttributes.put("inbound-interceptor-attribute", StandardCharsets.UTF_8.encode(clientId));
        publishAttributes.put("inbound-interceptor-attribute-second", StandardCharsets.UTF_8.encode(clientId));
    });
}));

final EnterprisePublish enterprisePublish = EnterpriseBuilders.publish()
        .topic("test/topic")
        .payload(ByteBuffer.wrap("messageWithAttributes".getBytes(StandardCharsets.UTF_8)))
        .publishAttribute("key", ByteBuffer.wrap("value".getBytes(StandardCharsets.UTF_8)))
        .publishAttribute("key1", ByteBuffer.wrap("value1".getBytes(StandardCharsets.UTF_8)))
        .build();

final ModifiablePublishAttributes publishAttributes = publishPacket.getPublishAttributes();
final String key = "key-to-remove";
final Optional<@Immutable ByteBuffer> removedValue = publishAttributes.remove(key);

if (removedValue.isPresent()) {
    logger.info("Remove key {} had value {}", key, StandardCharsets.UTF_8.decode(removedValue.get()));
} else {
    logger.info("Removed key {} had no value attached", key);
}

final ModifiablePublishAttributes publishAttributes = publishPacket.getPublishAttributes();

publishAttributes.clear();

final PublishAttributes publishAttributes = publishPacket.getPublishAttributes();

final Map<String, ByteBuffer> stringByteBufferMap = publishAttributes.asMap();

for (final Map.Entry<String, ByteBuffer> entry : stringByteBufferMap.entrySet()) {
    final String key = entry.getKey();
    final String value = StandardCharsets.UTF_8.decode(entry.getValue()).toString();

    logger.info("The value key {} is {}", key, value);
}

final String key = "key-to-get-value";
final PublishAttributes publishAttributes = publishPacket.getPublishAttributes();

final Optional<@Immutable ByteBuffer> fetchedValue = publishAttributes.get(key);

if (fetchedValue.isPresent()) {
    logger.info("The value for key {} is {}", key, StandardCharsets.UTF_8.decode(fetchedValue.get()));
} else {
    logger.info("Key {} has no value attached", key);
}