org.eclipse.ditto.connectivity.model.ImmutableSource 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) 2017 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 java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;

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

import org.eclipse.ditto.base.model.acks.AcknowledgementLabel;
import org.eclipse.ditto.base.model.acks.FilteredAcknowledgementRequest;
import org.eclipse.ditto.base.model.auth.AuthorizationContext;
import org.eclipse.ditto.base.model.auth.AuthorizationModelFactory;
import org.eclipse.ditto.base.model.auth.AuthorizationSubject;
import org.eclipse.ditto.base.model.auth.DittoAuthorizationContextType;
import org.eclipse.ditto.base.model.common.ConditionChecker;
import org.eclipse.ditto.base.model.json.JsonSchemaVersion;
import org.eclipse.ditto.json.JsonArray;
import org.eclipse.ditto.json.JsonCollectors;
import org.eclipse.ditto.json.JsonFactory;
import org.eclipse.ditto.json.JsonField;
import org.eclipse.ditto.json.JsonObject;
import org.eclipse.ditto.json.JsonObjectBuilder;
import org.eclipse.ditto.json.JsonValue;

/**
 * Immutable implementation of {@link Source}.
 */
@Immutable
final class ImmutableSource implements Source {

    /**
     * Default address to publish responses of incoming commands.
     */
    static final String DEFAULT_REPLY_TARGET_ADDRESS = "{{header:reply-to}}";

    /**
     * Placeholder for getting the header 'correlation-id'
     */
    static final String PLACEHOLDER_HEADER_CORRELATION_ID = "{{header:correlation-id}}";
    private static final String PLACEHOLDER_HEADER_CONTENT_TYPE = "{{header:content-type}}";

    /**
     * Default header mapping for legacy sources (i. e., no reply-target defined)
     */
    static final HeaderMapping DEFAULT_SOURCE_HEADER_MAPPING =
            ConnectivityModelFactory.newHeaderMapping(JsonObject.newBuilder()
                    .set("correlation-id", PLACEHOLDER_HEADER_CORRELATION_ID)
                    .set("content-type", PLACEHOLDER_HEADER_CONTENT_TYPE)
                    .set("reply-to", DEFAULT_REPLY_TARGET_ADDRESS)
                    .build());

    /**
     * Default header mapping for the reply-target added to legacy sources.
     */
    static final HeaderMapping DEFAULT_REPLY_TARGET_HEADER_MAPPING =
            ConnectivityModelFactory.newHeaderMapping(JsonObject.newBuilder()
                    .set("correlation-id", PLACEHOLDER_HEADER_CORRELATION_ID)
                    .set("content-type", PLACEHOLDER_HEADER_CONTENT_TYPE)
                    .build());

    private static final int DEFAULT_CONSUMER_COUNT = 1;
    private static final int DEFAULT_INDEX = 0;
    private static final boolean DEFAULT_REPLY_TARGET_ENABLED = true;

    private final Set addresses;
    private final int consumerCount;
    @Nullable private final Integer qos;
    private final int index;
    private final AuthorizationContext authorizationContext;
    @Nullable private final Enforcement enforcement;
    @Nullable private final FilteredAcknowledgementRequest acknowledgementRequests;
    private final HeaderMapping headerMapping;
    private final PayloadMapping payloadMapping;
    private final boolean replyTargetEnabled;
    @Nullable private final ReplyTarget replyTarget;
    private final Set declaredAcknowledgementLabels;

    private ImmutableSource(final Builder builder) {
        addresses = Collections.unmodifiableSet(
                new LinkedHashSet<>(ConditionChecker.checkNotNull(builder.addresses, "addresses")));
        consumerCount = builder.consumerCount;
        qos = builder.qos;
        authorizationContext = ConditionChecker.checkNotNull(builder.authorizationContext, "authorizationContext");
        index = builder.index;
        enforcement = builder.enforcement;
        acknowledgementRequests = builder.acknowledgementRequests;
        headerMapping = builder.headerMapping;
        payloadMapping = builder.payloadMapping;
        replyTargetEnabled = builder.replyTargetEnabled;
        replyTarget = builder.replyTarget;
        declaredAcknowledgementLabels = builder.declaredAcknowledgementLabels;
    }

    @Override
    public Set getAddresses() {
        return addresses;
    }

    @Override
    public int getConsumerCount() {
        return consumerCount;
    }

    @Override
    public AuthorizationContext getAuthorizationContext() {
        return authorizationContext;
    }

    @Override
    public int getIndex() {
        return index;
    }

    @Override
    public Optional getQos() {
        return Optional.ofNullable(qos);
    }

    @Override
    public Optional getEnforcement() {
        return Optional.ofNullable(enforcement);
    }

    @Override
    public Optional getAcknowledgementRequests() {
        return Optional.ofNullable(acknowledgementRequests);
    }

    @Override
    public HeaderMapping getHeaderMapping() {
        return headerMapping;
    }

    @Override
    public PayloadMapping getPayloadMapping() {
        return payloadMapping;
    }

    @Override
    public Optional getReplyTarget() {
        return Optional.ofNullable(replyTarget);
    }

    @Override
    public boolean isReplyTargetEnabled() {
        return replyTargetEnabled;
    }

    @Override
    public Set getDeclaredAcknowledgementLabels() {
        return declaredAcknowledgementLabels;
    }

    @Override
    public JsonObject toJson(final JsonSchemaVersion schemaVersion, final Predicate thePredicate) {
        final Predicate predicate = schemaVersion.and(thePredicate);
        final JsonObjectBuilder jsonObjectBuilder = JsonFactory.newObjectBuilder();

        jsonObjectBuilder.set(JsonFields.ADDRESSES, addresses.stream()
                .map(JsonFactory::newValue)
                .collect(JsonCollectors.valuesToArray()), predicate.and(Objects::nonNull));
        jsonObjectBuilder.set(JsonFields.CONSUMER_COUNT, consumerCount, predicate);
        if (qos != null) {
            jsonObjectBuilder.set(JsonFields.QOS, qos);
        }

        if (!authorizationContext.isEmpty()) {
            jsonObjectBuilder.set(JsonFields.AUTHORIZATION_CONTEXT, authorizationContext.stream()
                    .map(AuthorizationSubject::getId)
                    .map(JsonFactory::newValue)
                    .collect(JsonCollectors.valuesToArray()), predicate);
        }

        if (enforcement != null) {
            jsonObjectBuilder.set(JsonFields.ENFORCEMENT, enforcement.toJson(schemaVersion, thePredicate), predicate);
        }

        if (acknowledgementRequests != null) {
            jsonObjectBuilder.set(JsonFields.ACKNOWLEDGEMENT_REQUESTS,
                    acknowledgementRequests.toJson(schemaVersion, thePredicate), predicate);
        }

        jsonObjectBuilder.set(JsonFields.HEADER_MAPPING, headerMapping.toJson(schemaVersion, thePredicate), predicate);

        if (!payloadMapping.isEmpty()) {
            jsonObjectBuilder.set(JsonFields.PAYLOAD_MAPPING, payloadMapping.toJson(), predicate);
        }

        if (replyTarget != null) {
            jsonObjectBuilder.set(JsonFields.REPLY_TARGET, replyTarget.toJson(schemaVersion, thePredicate), predicate);
        }

        if (!(replyTargetEnabled && replyTarget == null)) {
            // only set replyTargetEnabled if it is not set by reply-target migration
            jsonObjectBuilder.set(JsonFields.REPLY_TARGET_ENABLED, replyTargetEnabled, predicate);
        }

        if (!declaredAcknowledgementLabels.isEmpty()) {
            jsonObjectBuilder.set(JsonFields.DECLARED_ACKS, declaredAcksToJson(declaredAcknowledgementLabels));
        }

        return jsonObjectBuilder.build();
    }

    /**
     * Creates a new {@code Source} object from the specified JSON object.
     *
     * @param jsonObject a JSON object which provides the data for the Source to be created.
     * @param index the index to distinguish between sources that would otherwise be different
     * @return a new Source which is initialised with the extracted data from {@code jsonObject}.
     * @throws NullPointerException if {@code jsonObject} is {@code null}.
     * @throws org.eclipse.ditto.json.JsonParseException if {@code jsonObject} is not an appropriate JSON object.
     */
    public static Source fromJson(final JsonObject jsonObject, final int index) {
        final Set readSources = jsonObject.getValue(JsonFields.ADDRESSES)
                .map(array -> array.stream()
                        .map(JsonValue::asString)
                        .collect(Collectors.toCollection(LinkedHashSet::new)))
                .orElseGet(LinkedHashSet::new);
        final int readConsumerCount =
                jsonObject.getValue(JsonFields.CONSUMER_COUNT).orElse(DEFAULT_CONSUMER_COUNT);
        final Integer readQos = jsonObject.getValue(JsonFields.QOS).orElse(null);
        final JsonArray authContext = jsonObject.getValue(JsonFields.AUTHORIZATION_CONTEXT)
                .orElseGet(() -> JsonArray.newBuilder().build());
        final List authorizationSubjects = authContext.stream()
                .filter(JsonValue::isString)
                .map(JsonValue::asString)
                .map(AuthorizationSubject::newInstance)
                .collect(Collectors.toList());
        final AuthorizationContext readAuthorizationContext =
                AuthorizationModelFactory.newAuthContext(DittoAuthorizationContextType.PRE_AUTHENTICATED_CONNECTION,
                        authorizationSubjects);

        final Enforcement readEnforcement =
                jsonObject.getValue(JsonFields.ENFORCEMENT)
                        .filter(f -> !f.isNull())
                        .map(ImmutableEnforcement::fromJson)
                        .orElse(null);

        final FilteredAcknowledgementRequest readAcknowledgementRequests =
                jsonObject.getValue(JsonFields.ACKNOWLEDGEMENT_REQUESTS)
                        .filter(f -> !f.isNull())
                        .map(FilteredAcknowledgementRequest::fromJson)
                        .orElse(null);

        final HeaderMapping readHeaderMapping =
                jsonObject.getValue(JsonFields.HEADER_MAPPING)
                        .filter(f -> !f.isNull())
                        .map(ImmutableHeaderMapping::fromJson)
                        .orElse(null);

        final PayloadMapping readPayloadMapping =
                jsonObject.getValue(JsonFields.PAYLOAD_MAPPING)
                        .filter(f -> !f.isNull())
                        .map(ImmutablePayloadMapping::fromJson)
                        .orElse(ConnectivityModelFactory.emptyPayloadMapping());

        final boolean replyTargetEnabled =
                jsonObject.getValue(JsonFields.REPLY_TARGET_ENABLED).orElse(DEFAULT_REPLY_TARGET_ENABLED);

        final ReplyTarget readReplyTarget =
                jsonObject.getValue(JsonFields.REPLY_TARGET)
                        .filter(f -> !f.isNull())
                        .flatMap(ImmutableReplyTarget::fromJsonOptional)
                        .orElse(null);

        final Set declaredAcknowledgementLabels =
                jsonObject.getValue(JsonFields.DECLARED_ACKS)
                        .map(ImmutableSource::declaredAcksFromJson)
                        .orElse(Collections.emptySet());

        return new Builder()
                .addresses(readSources)
                .qos(readQos)
                .authorizationContext(readAuthorizationContext)
                .consumerCount(readConsumerCount)
                .index(index)
                .enforcement(readEnforcement)
                .acknowledgementRequests(readAcknowledgementRequests)
                .headerMapping(readHeaderMapping)
                .payloadMapping(readPayloadMapping)
                .replyTargetEnabled(replyTargetEnabled)
                .replyTarget(readReplyTarget)
                .declaredAcknowledgementLabels(declaredAcknowledgementLabels)
                .build();
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        final ImmutableSource that = (ImmutableSource) o;
        return consumerCount == that.consumerCount &&
                Objects.equals(addresses, that.addresses) &&
                Objects.equals(index, that.index) &&
                Objects.equals(qos, that.qos) &&
                Objects.equals(enforcement, that.enforcement) &&
                Objects.equals(acknowledgementRequests, that.acknowledgementRequests) &&
                Objects.equals(headerMapping, that.headerMapping) &&
                Objects.equals(payloadMapping, that.payloadMapping) &&
                Objects.equals(authorizationContext, that.authorizationContext) &&
                replyTargetEnabled == that.replyTargetEnabled &&
                Objects.equals(replyTarget, that.replyTarget) &&
                Objects.equals(declaredAcknowledgementLabels, that.declaredAcknowledgementLabels);
    }

    @Override
    public int hashCode() {
        return Objects.hash(index, addresses, qos, consumerCount, authorizationContext, enforcement,
                acknowledgementRequests,
                headerMapping, payloadMapping, replyTargetEnabled, replyTarget, declaredAcknowledgementLabels);
    }

    @Override
    public String toString() {
        return getClass().getSimpleName() + " [" +
                "index=" + index +
                ", addresses=" + addresses +
                ", consumerCount=" + consumerCount +
                ", qos=" + qos +
                ", authorizationContext=" + authorizationContext +
                ", enforcement=" + enforcement +
                ", acknowledgementRequests=" + acknowledgementRequests +
                ", headerMapping=" + headerMapping +
                ", payloadMapping=" + payloadMapping +
                ", replyTargetEnabled=" + replyTargetEnabled +
                ", replyTarget=" + replyTarget +
                ", declaredAcknowledgementLabels=" + declaredAcknowledgementLabels +
                "]";
    }

    static Source migrateReplyTarget(final Source source, final ConnectionType connectionType) {
        final boolean isLegacySource = source.isReplyTargetEnabled() && !source.getReplyTarget().isPresent();
        final boolean supportsHeaders = ConnectionType.supportsHeaders(connectionType);
        if (isLegacySource && supportsHeaders) {
            return migrateReplyTargetWithHeaders(source);
        } else if (isLegacySource) {
            return migrateReplyTargetWithoutHeaders(source);
        } else {
            return source;
        }
    }

    private static Source migrateReplyTargetWithoutHeaders(final Source source) {
        return ConnectivityModelFactory.newSourceBuilder(source)
                .replyTarget(ReplyTarget.newBuilder().address(DEFAULT_REPLY_TARGET_ADDRESS).build())
                .build();
    }

    private static Source migrateReplyTargetWithHeaders(final Source source) {
        final Map mergedMapping = new HashMap<>(DEFAULT_SOURCE_HEADER_MAPPING.getMapping());
        mergedMapping.putAll(source.getHeaderMapping().getMapping());
        final HeaderMapping mapping = ConnectivityModelFactory.newHeaderMapping(mergedMapping);

        return ConnectivityModelFactory.newSourceBuilder(source)
                .headerMapping(mapping)
                .replyTarget(ReplyTarget.newBuilder()
                        .address(DEFAULT_REPLY_TARGET_ADDRESS)
                        .headerMapping(DEFAULT_REPLY_TARGET_HEADER_MAPPING)
                        .build())
                .build();
    }

    private static Set declaredAcksFromJson(final JsonArray jsonArray) {
        return jsonArray.stream()
                .map(JsonValue::formatAsString)
                .map(AcknowledgementLabel::of)
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    private static JsonArray declaredAcksToJson(final Set declaredAcks) {
        return declaredAcks.stream()
                .map(JsonValue::of)
                .collect(JsonCollectors.valuesToArray());
    }

    /**
     * Builder for {@code ImmutableSource}.
     */
    @NotThreadSafe
    static final class Builder implements SourceBuilder {

        // required but changeable:
        @Nullable private Set addresses = new LinkedHashSet<>();
        @Nullable private AuthorizationContext authorizationContext;

        // optional:
        @Nullable private Enforcement enforcement;
        private HeaderMapping headerMapping = ConnectivityModelFactory.emptyHeaderMapping();
        @Nullable private Integer qos = null;
        @Nullable private FilteredAcknowledgementRequest acknowledgementRequests;
        private boolean replyTargetEnabled = DEFAULT_REPLY_TARGET_ENABLED;
        @Nullable private ReplyTarget replyTarget;
        private Set declaredAcknowledgementLabels = Collections.emptySet();

        // optional with default:
        private PayloadMapping payloadMapping = ConnectivityModelFactory.emptyPayloadMapping();
        private int index = DEFAULT_INDEX;
        private int consumerCount = DEFAULT_CONSUMER_COUNT;

        Builder() {}

        public Builder(final Source source) {
            addresses(source.getAddresses())
                    .authorizationContext(source.getAuthorizationContext())
                    .enforcement(source.getEnforcement().orElse(null))
                    .headerMapping(source.getHeaderMapping())
                    .qos(source.getQos().orElse(null))
                    .acknowledgementRequests(source.getAcknowledgementRequests().orElse(null))
                    .replyTarget(source.getReplyTarget().orElse(null))
                    .replyTargetEnabled(source.isReplyTargetEnabled())
                    .declaredAcknowledgementLabels(source.getDeclaredAcknowledgementLabels())
                    .payloadMapping(source.getPayloadMapping())
                    .index(source.getIndex())
                    .consumerCount(source.getConsumerCount());
        }

        @Override
        public Builder addresses(final Set addresses) {
            this.addresses = addresses;
            return this;
        }

        @Override
        public Builder address(final String address) {
            if (addresses == null) {
                addresses = new LinkedHashSet<>();
            }
            addresses.add(address);
            return this;
        }

        @Override
        public Builder consumerCount(final int consumerCount) {
            this.consumerCount = consumerCount;
            return this;
        }

        @Override
        public Builder index(final int index) {
            this.index = index;
            return this;
        }

        @Override
        public Builder qos(@Nullable final Integer qos) {
            this.qos = qos;
            return this;
        }

        @Override
        public Builder authorizationContext(final AuthorizationContext authorizationContext) {
            this.authorizationContext = ConditionChecker.checkNotNull(authorizationContext, "authorizationContext");
            return this;
        }

        @Override
        public Builder enforcement(@Nullable final Enforcement enforcement) {
            this.enforcement = enforcement;
            return this;
        }

        @Override
        public Builder acknowledgementRequests(final @Nullable FilteredAcknowledgementRequest acknowledgementRequests) {
            this.acknowledgementRequests = acknowledgementRequests;
            return this;
        }

        @Override
        public Builder headerMapping(@Nullable final HeaderMapping headerMapping) {
            this.headerMapping = headerMapping == null ? ConnectivityModelFactory.emptyHeaderMapping() : headerMapping;
            return this;
        }

        @Override
        public Builder payloadMapping(final PayloadMapping payloadMapping) {
            this.payloadMapping = payloadMapping;
            return this;
        }

        @Override
        public Builder replyTarget(@Nullable final ReplyTarget replyTarget) {
            this.replyTarget = replyTarget;
            return this;
        }

        @Override
        public Builder replyTargetEnabled(final boolean replyTargetEnabled) {
            this.replyTargetEnabled = replyTargetEnabled;
            return this;
        }

        @Override
        public Builder declaredAcknowledgementLabels(final Set declaredAcknowledgmentLabels) {
            declaredAcknowledgementLabels = declaredAcknowledgmentLabels;
            return this;
        }

        @Override
        public Source build() {
            return new ImmutableSource(this);
        }

    }

}