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(final @NotNull ConsumerInput consumerInput, final @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 Map<String, ModifiableConsumerOptions> myConsumers = EnterpriseServices.consumerService().getConsumers();

EnterpriseServices.sessionAttributeStore()

final 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 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(final @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(final @NotNull LoginLoadInput loginLoadInput, final @NotNull LoginLoadOutput loginLoadOutput) {
        // 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(final @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 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);

final Notification 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(final @NotNull RestAuthInput restAuthInput, final @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<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<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);
}