Protocol Adapter Full State Machine

hivemq-edge/src/main/java/com/hivemq/common/i18n/StringTemplate.java

@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2019-present HiveMQ GmbH
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.hivemq.common.i18n;
+
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+import java.util.Map;
+
+public final class StringTemplate {
+    private final static @NotNull Configuration CONFIGURATION = new Configuration(Configuration.VERSION_2_3_22);
+
+    static {
+        CONFIGURATION.setDefaultEncoding(StandardCharsets.UTF_8.name());
+        CONFIGURATION.setLocale(Locale.US);
+    }
+
+    private StringTemplate() {
+    }
+
+    public static @NotNull String format(
+            final @NotNull String stringTemplate,
+            final @NotNull Map<String, Object> arguments) {
+        try (final StringWriter stringWriter = new StringWriter();) {
+            final Template template = new Template(stringTemplate, stringTemplate, CONFIGURATION);
+            template.process(arguments, stringWriter);
+            return stringWriter.toString();
+        } catch (final Exception e) {
+            return e.getMessage();
+        }
+    }
+}

hivemq-edge/src/main/java/com/hivemq/protocols/fsm/ClassLoaderUtils.java

@@ -0,0 +1,38 @@
+/*
+ *  Copyright 2019-present HiveMQ GmbH
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.hivemq.protocols.fsm;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Supplier;
+
+public final class ClassLoaderUtils {
+    private ClassLoaderUtils() {
+    }
+
+    public static <T> @NotNull T runWithContextLoader(
+            final @NotNull ClassLoader contextLoader,
+            final @NotNull Supplier<T> wrapperSupplier) {
+        final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(contextLoader);
+            return wrapperSupplier.get();
+        } finally {
+            Thread.currentThread().setContextClassLoader(contextClassLoader);
+        }
+    }
+}

hivemq-edge/src/main/java/com/hivemq/protocols/fsm/I18nProtocolAdapterMessage.java

@@ -0,0 +1,62 @@
+/*
+ *  Copyright 2019-present HiveMQ GmbH
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.hivemq.protocols.fsm;
+
+import com.hivemq.common.i18n.I18nError;
+import com.hivemq.common.i18n.I18nErrorTemplate;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public enum I18nProtocolAdapterMessage implements I18nError {
+    FSM_TRANSITION_FAILURE_UNABLE_TO_TRANSITION_FROM_STATE_TO_STATE,
+    FSM_TRANSITION_SUCCESS_STATE_IS_UNCHANGED,
+    FSM_TRANSITION_SUCCESS_TRANSITIONED_FROM_STATE_TO_STATE,
+    FSM_CONNECTION_TRANSITION_FAILURE_UNABLE_TO_TRANSITION_FROM_STATE_TO_STATE,
+    FSM_CONNECTION_TRANSITION_SUCCESS_STATE_IS_UNCHANGED,
+    FSM_CONNECTION_TRANSITION_SUCCESS_TRANSITIONED_FROM_STATE_TO_STATE,
+    PROTOCOL_ADAPTER_MANAGER_PROTOCOL_ADAPTER_DELETED,
+    PROTOCOL_ADAPTER_MANAGER_PROTOCOL_ADAPTER_NOT_FOUND,
+    ;
+
+    private static final @NotNull String RESOURCE_NAME_PREFIX = "templates/protocol-adapter-messages-";
+    private static final @NotNull String RESOURCE_NAME_SUFFIX = ".properties";
+    private static final @NotNull I18nErrorTemplate TEMPLATE =
+            new I18nErrorTemplate(locale -> RESOURCE_NAME_PREFIX + locale + RESOURCE_NAME_SUFFIX,
+                    I18nProtocolAdapterMessage.class.getClassLoader());
+
+    private final @NotNull String key;
+
+    I18nProtocolAdapterMessage() {
+        key = name().toLowerCase().replace("_", ".");
+    }
+
+    @Override
+    public @NotNull String get(final @NotNull Map<String, Object> map) {
+        return TEMPLATE.get(this, map);
+    }
+
+    @Override
+    public @NotNull String getKey() {
+        return key;
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return name();
+    }
+}

hivemq-edge/src/main/java/com/hivemq/protocols/fsm/ProtocolAdapterConnectionState.java

@@ -0,0 +1,158 @@
+/*
+ *  Copyright 2019-present HiveMQ GmbH
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.hivemq.protocols.fsm;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Function;
+
+public enum ProtocolAdapterConnectionState {
+    Closed(ProtocolAdapterConnectionState::transitionFromClosed),
+    Closing(ProtocolAdapterConnectionState::transitionFromClosing),
+    Connected(ProtocolAdapterConnectionState::transitionFromConnected),
+    Connecting(ProtocolAdapterConnectionState::transitionFromConnecting),
+    Disconnected(ProtocolAdapterConnectionState::transitionFromDisconnected),
+    Disconnecting(ProtocolAdapterConnectionState::transitionFromDisconnecting),
+    Error(ProtocolAdapterConnectionState::transitionFromError),
+    ErrorClosing(ProtocolAdapterConnectionState::transitionFromErrorClosing),
+    ;
+
+    private final @NotNull Function<ProtocolAdapterConnectionState, ProtocolAdapterConnectionTransitionResponse>
+            transitionFunction;
+
+    ProtocolAdapterConnectionState(@NotNull final Function<ProtocolAdapterConnectionState, ProtocolAdapterConnectionTransitionResponse> transitionFunction) {
+        this.transitionFunction = transitionFunction;
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromClosed(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Closed;
+        return switch (toState) {
+            case Closed -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Disconnected -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromClosing(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Closing;
+        return switch (toState) {
+            case Closing -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Closed -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromConnected(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Connected;
+        return switch (toState) {
+            case Connected -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Disconnecting, Closing, ErrorClosing ->
+                    ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromConnecting(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Connecting;
+        return switch (toState) {
+            case Connecting -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Connected, Error -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromDisconnected(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Disconnected;
+        return switch (toState) {
+            case Disconnected -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Connecting -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromDisconnecting(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Disconnecting;
+        return switch (toState) {
+            case Disconnecting -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Connecting, Disconnected -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromError(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.Error;
+        return switch (toState) {
+            case Error -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Disconnected -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public static @NotNull ProtocolAdapterConnectionTransitionResponse transitionFromErrorClosing(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        final ProtocolAdapterConnectionState fromState = ProtocolAdapterConnectionState.ErrorClosing;
+        return switch (toState) {
+            case ErrorClosing -> ProtocolAdapterConnectionTransitionResponse.notChanged(fromState);
+            case Error -> ProtocolAdapterConnectionTransitionResponse.success(fromState, toState);
+            default -> ProtocolAdapterConnectionTransitionResponse.failure(fromState, toState);
+        };
+    }
+
+    public @NotNull ProtocolAdapterConnectionTransitionResponse transition(
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        return transitionFunction.apply(toState);
+    }
+
+    public boolean isClosed() {
+        return this == Closed;
+    }
+
+    public boolean isClosing() {
+        return this == Closing;
+    }
+
+    public boolean isConnected() {
+        return this == Connected;
+    }
+
+    public boolean isConnecting() {
+        return this == Connecting;
+    }
+
+    public boolean isDisconnecting() {
+        return this == Disconnecting;
+    }
+
+    public boolean isDisconnected() {
+        return this == Disconnected;
+    }
+
+    public boolean isError() {
+        return this == Error;
+    }
+
+    public boolean isErrorClosing() {
+        return this == ErrorClosing;
+    }
+}

hivemq-edge/src/main/java/com/hivemq/protocols/fsm/ProtocolAdapterConnectionTransitionResponse.java

@@ -0,0 +1,65 @@
+/*
+ *  Copyright 2019-present HiveMQ GmbH
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package com.hivemq.protocols.fsm;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public record ProtocolAdapterConnectionTransitionResponse(ProtocolAdapterConnectionState fromState,
+                                                          ProtocolAdapterConnectionState toState,
+                                                          ProtocolAdapterTransitionStatus status, String message,
+                                                          Throwable error) {
+
+    public static final String FROM_STATE = "fromState";
+    public static final String TO_STATE = "toState";
+    public static final String STATE = "state";
+
+    public static ProtocolAdapterConnectionTransitionResponse success(
+            final @NotNull ProtocolAdapterConnectionState fromState,
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        return new ProtocolAdapterConnectionTransitionResponse(fromState,
+                toState,
+                ProtocolAdapterTransitionStatus.Success,
+                I18nProtocolAdapterMessage.FSM_CONNECTION_TRANSITION_SUCCESS_TRANSITIONED_FROM_STATE_TO_STATE.get(Map.of(
+                        FROM_STATE,
+                        fromState.name(),
+                        TO_STATE,
+                        toState.name())),
+                null);
+    }
+
+    public static ProtocolAdapterConnectionTransitionResponse notChanged(final @NotNull ProtocolAdapterConnectionState state) {
+        return new ProtocolAdapterConnectionTransitionResponse(state,
+                state,
+                ProtocolAdapterTransitionStatus.NotChanged,
+                I18nProtocolAdapterMessage.FSM_CONNECTION_TRANSITION_SUCCESS_STATE_IS_UNCHANGED.get(Map.of(STATE,
+                        state.name())),
+                null);
+    }
+
+    public static ProtocolAdapterConnectionTransitionResponse failure(
+            final @NotNull ProtocolAdapterConnectionState fromState,
+            final @NotNull ProtocolAdapterConnectionState toState) {
+        return new ProtocolAdapterConnectionTransitionResponse(fromState,
+                toState,
+                ProtocolAdapterTransitionStatus.Failure,
+                I18nProtocolAdapterMessage.FSM_CONNECTION_TRANSITION_FAILURE_UNABLE_TO_TRANSITION_FROM_STATE_TO_STATE.get(
+                        Map.of(FROM_STATE, fromState.name(), TO_STATE, toState.name())),
+                null);
+    }
+}