org.eclipse.ditto.connectivity.model.AbstractConnectionBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ditto-connectivity-model Show documentation
Eclipse Ditto is a framework for creating and managing digital twins in the IoT.
The newest version!
/*
 * Copyright (c) 2022 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 */
package org.eclipse.ditto.connectivity.model;

import static org.eclipse.ditto.base.model.common.ConditionChecker.checkArgument;
import static org.eclipse.ditto.base.model.common.ConditionChecker.checkNotNull;

import java.text.MessageFormat;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;

/**
 * Abstract implementation for common aspects of {@link ConnectionBuilder}.
 *
 * @since 3.2.0
 */

@Immutable
abstract class AbstractConnectionBuilder implements ConnectionBuilder {

    private static final String MIGRATED_MAPPER_ID = "javascript";

    // required but changeable:
    @Nullable ConnectionId id;
    @Nullable ConnectivityStatus connectionStatus;
    String uri;
    // optional:
    @Nullable String name = null;
    @Nullable Credentials credentials;
    @Nullable MappingContext mappingContext = null;
    @Nullable String trustedCertificates;
    @Nullable ConnectionLifecycle lifecycle = null;
    @Nullable ConnectionRevision revision = null;
    @Nullable Instant modified = null;
    @Nullable Instant created = null;
    @Nullable SshTunnel sshTunnel = null;

    // optional with default:
    Set tags = new LinkedHashSet<>();
    boolean failOverEnabled = true;
    boolean validateCertificate = true;
    final List sources = new ArrayList<>();
    final List targets = new ArrayList<>();
    int clientCount = 1;
    int processorPoolSize = 1;
    PayloadMappingDefinition payloadMappingDefinition =
            ConnectivityModelFactory.emptyPayloadMappingDefinition();
    final Map specificConfig = new HashMap<>();
    ConnectionType connectionType;

    AbstractConnectionBuilder(final ConnectionType connectionType) {
        this.connectionType = connectionType;
    }

    private static boolean isBlankOrNull(@Nullable final String toTest) {
        return null == toTest || toTest.trim().isEmpty();
    }

    @Override
    public ConnectionBuilder id(final ConnectionId id) {
        this.id = checkNotNull(id, "id");
        return this;
    }

    @Override
    public ConnectionBuilder name(@Nullable final String name) {
        this.name = name;
        return this;
    }

    @Override
    public ConnectionBuilder credentials(@Nullable final Credentials credentials) {
        this.credentials = credentials;
        return this;
    }

    @Override
    public ConnectionBuilder trustedCertificates(@Nullable final String trustedCertificates) {
        if (isBlankOrNull(trustedCertificates)) {
            this.trustedCertificates = null;
        } else {
            this.trustedCertificates = trustedCertificates;
        }
        return this;
    }

    @Override
    public ConnectionBuilder uri(final String uri) {
        this.uri = checkNotNull(uri, "uri");
        return this;
    }

    @Override
    public ConnectionBuilder connectionStatus(final ConnectivityStatus connectionStatus) {
        this.connectionStatus = checkNotNull(connectionStatus, "connectionStatus");
        return this;
    }

    @Override
    public ConnectionBuilder failoverEnabled(final boolean failOverEnabled) {
        this.failOverEnabled = failOverEnabled;
        return this;
    }

    @Override
    public ConnectionBuilder validateCertificate(final boolean validateCertificate) {
        this.validateCertificate = validateCertificate;
        return this;
    }

    @Override
    public ConnectionBuilder processorPoolSize(final int processorPoolSize) {
        checkArgument(processorPoolSize, ps -> ps > 0, () -> "The processor pool size must be positive!");
        this.processorPoolSize = processorPoolSize;
        return this;
    }

    @Override
    public ConnectionBuilder sources(final List sources) {
        this.sources.addAll(checkNotNull(sources, "sources"));
        return this;
    }

    @Override
    public ConnectionBuilder targets(final List targets) {
        this.targets.addAll(checkNotNull(targets, "targets"));
        return this;
    }

    @Override
    public ConnectionBuilder setSources(final List sources) {
        this.sources.clear();
        return sources(sources);
    }

    @Override
    public ConnectionBuilder setTargets(final List targets) {
        this.targets.clear();
        return targets(targets);
    }

    @Override
    public ConnectionBuilder clientCount(final int clientCount) {
        checkArgument(clientCount, ps -> ps > 0, () -> "The client count must be positive!");
        this.clientCount = clientCount;
        return this;
    }

    @Override
    public ConnectionBuilder specificConfig(final Map specificConfig) {
        this.specificConfig.putAll(checkNotNull(specificConfig, "specificConfig"));
        return this;
    }

    @Override
    public ConnectionBuilder mappingContext(@Nullable final MappingContext mappingContext) {
        this.mappingContext = mappingContext;
        return this;
    }

    @Override
    public ConnectionBuilder tags(final Collection tags) {
        this.tags = new LinkedHashSet<>(checkNotNull(tags, "tags to set"));
        return this;
    }

    @Override
    public ConnectionBuilder tag(final String tag) {
        tags.add(checkNotNull(tag, "tag to set"));
        return this;
    }

    @Override
    public ConnectionBuilder lifecycle(@Nullable final ConnectionLifecycle lifecycle) {
        this.lifecycle = lifecycle;
        return this;
    }

    @Override
    public ConnectionBuilder revision(@Nullable final ConnectionRevision revision) {
        this.revision = revision;
        return this;
    }

    @Override
    public ConnectionBuilder modified(@Nullable final Instant modified) {
        this.modified = modified;
        return this;
    }

    @Override
    public ConnectionBuilder created(@Nullable final Instant created) {
        this.created = created;
        return this;
    }

    @Override
    public ConnectionBuilder sshTunnel(@Nullable final SshTunnel sshTunnel) {
        this.sshTunnel = sshTunnel;
        return this;
    }

    @Override
    public ConnectionBuilder payloadMappingDefinition(final PayloadMappingDefinition payloadMappingDefinition) {
        this.payloadMappingDefinition = payloadMappingDefinition;
        return this;
    }

    private boolean shouldMigrateMappingContext() {
        return mappingContext != null;
    }

    void migrateLegacyConfigurationOnTheFly() {
        if (shouldMigrateMappingContext()) {
            this.payloadMappingDefinition =
                    payloadMappingDefinition.withDefinition(MIGRATED_MAPPER_ID, mappingContext);
        }
        setSources(sources.stream().map(this::migrateSource).collect(Collectors.toList()));
        setTargets(targets.stream().map(this::migrateTarget).collect(Collectors.toList()));
    }

    private Source migrateSource(final Source source) {
        final Source sourceAfterReplyTargetMigration = ImmutableSource.migrateReplyTarget(source, connectionType);
        if (shouldMigrateMappingContext()) {
            return new ImmutableSource.Builder(sourceAfterReplyTargetMigration)
                    .payloadMapping(addMigratedPayloadMappings(source.getPayloadMapping()))
                    .build();
        } else {
            return sourceAfterReplyTargetMigration;
        }
    }

    private Target migrateTarget(final Target target) {
        final boolean shouldAddHeaderMapping = shouldAddDefaultHeaderMappingToTarget(connectionType);
        final boolean shouldMigrateMappingContext = shouldMigrateMappingContext();
        if (shouldMigrateMappingContext || shouldAddHeaderMapping) {
            final TargetBuilder builder = new ImmutableTarget.Builder(target);
            if (shouldMigrateMappingContext) {
                builder.payloadMapping(addMigratedPayloadMappings(target.getPayloadMapping()));
            }
            if (shouldAddHeaderMapping) {
                builder.headerMapping(target.getHeaderMapping());
            }
            return builder.build();
        } else {
            return target;
        }
    }

    private boolean shouldAddDefaultHeaderMappingToTarget(final ConnectionType connectionType) {
        switch (connectionType) {
            case AMQP_091:
            case AMQP_10:
            case KAFKA:
            case MQTT_5:
            case HONO:
                return true;
            case MQTT:
            case HTTP_PUSH:
            default:
                return false;
        }
    }


    private PayloadMapping addMigratedPayloadMappings(final PayloadMapping payloadMapping) {
        final ArrayList merged = new ArrayList<>(payloadMapping.getMappings());
        merged.add(MIGRATED_MAPPER_ID);
        return ConnectivityModelFactory.newPayloadMapping(merged);
    }

    void checkSourceAndTargetAreValid() {
        if (sources.isEmpty() && targets.isEmpty()) {
            throw ConnectionConfigurationInvalidException.newBuilder("Either a source or a target must be " +
                    "specified in the configuration of a connection!").build();
        }
    }

    /**
     * If no context is set on connection level each target and source must have its own context.
     */
    void checkAuthorizationContextsAreValid() {
        // if the auth context on connection level is empty,
        // an auth context is required to be set on each source/target
        final Set sourcesWithoutAuthContext = sources.stream()
                .filter(source -> source.getAuthorizationContext().isEmpty())
                .flatMap(source -> source.getAddresses().stream())
                .collect(Collectors.toCollection(LinkedHashSet::new));
        final Set targetsWithoutAuthContext = targets.stream()
                .filter(target -> target.getAuthorizationContext().isEmpty())
                .map(Target::getAddress)
                .collect(Collectors.toCollection(LinkedHashSet::new));

        if (!sourcesWithoutAuthContext.isEmpty() || !targetsWithoutAuthContext.isEmpty()) {
            final StringBuilder message = new StringBuilder("The ");
            if (!sourcesWithoutAuthContext.isEmpty()) {
                message.append("Sources ").append(sourcesWithoutAuthContext);
            }
            if (!sourcesWithoutAuthContext.isEmpty() && !targetsWithoutAuthContext.isEmpty()) {
                message.append(" and ");
            }
            if (!targetsWithoutAuthContext.isEmpty()) {
                message.append("Targets ").append(targetsWithoutAuthContext);
            }
            message.append(" are missing an authorization context.");
            throw ConnectionConfigurationInvalidException.newBuilder(message.toString()).build();
        }
    }

    void checkConnectionAnnouncementsOnlySetIfClientCount1() {
        if (clientCount > 1 && containsTargetWithConnectionAnnouncementsTopic()) {
            final String message = MessageFormat.format("Connection announcements (topic {0}) can" +
                    " only be used with client count 1.", Topic.CONNECTION_ANNOUNCEMENTS.getName());
            throw ConnectionConfigurationInvalidException.newBuilder(message)
                    .build();
        }
    }

    private boolean containsTargetWithConnectionAnnouncementsTopic() {
        return targets.stream()
                .map(Target::getTopics)
                .flatMap(Set::stream)
                .map(FilteredTopic::getTopic)
                .anyMatch(Topic.CONNECTION_ANNOUNCEMENTS::equals);
    }

}