return Optional.of(topicPath.getGroup().getName()); case CHANNEL_PLACEHOLDER: return Optional.of(topicPath.getChannel().getName()); case CRITERION_PLACEHOLDER: return Optional.of(topicPath.getCriterion().getName());
private static Optional<Topic> topicFromSignal(final Signal<?> signal) { // only things as group supported final TopicPath.Group group = signal instanceof WithThingId ? TopicPath.Group.THINGS : null; final TopicPath.Channel channel = signal.getDittoHeaders() .getChannel() .flatMap(TopicPath.Channel::forName) .orElse(TopicPath.Channel.TWIN); final TopicPath.Criterion criterion = getCriterionOfSignal(signal); if (TopicPath.Group.THINGS.equals(group)) { if (TopicPath.Channel.TWIN.equals(channel)) { if (EVENTS.equals(criterion)) { return Optional.of(Topic.TWIN_EVENTS); } } else if (TopicPath.Channel.LIVE.equals(channel) && criterion != null) { switch (criterion) { case COMMANDS: return Optional.of(Topic.LIVE_COMMANDS); case EVENTS: return Optional.of(Topic.LIVE_EVENTS); case MESSAGES: return Optional.of(Topic.LIVE_MESSAGES); default: return Optional.empty(); } } } return Optional.empty(); }
/** * Creates a Channel from the passed Channel {@code name} if such an enum value exists, otherwise an empty * Optional. * * @param name the Channel name to create the Channel enum value of. * @return the optional Channel. */ public static Optional<Channel> forName(final String name) { return Stream.of(values()) // .filter(a -> Objects.equals(a.getName(), name)) // .findFirst(); }
.orElseThrow(() -> UnknownTopicPathException.newBuilder(path).build()); final TopicPath.Channel channel = TopicPath.Channel.forName(parts[3]) .orElseThrow(() -> UnknownTopicPathException.newBuilder(path).build()); final TopicPath.Criterion criterion =
.orElseThrow(() -> UnknownTopicPathException.newBuilder(path).build()); final TopicPath.Channel channel = TopicPath.Channel.forName(parts[3]) .orElseThrow(() -> UnknownTopicPathException.newBuilder(path).build()); final TopicPath.Criterion criterion =
authContextWithPrefixedSubjects, authContext -> parameterOptional(TopicPath.Channel.LIVE.getName(), liveParam -> withDittoHeaders(
private static Adaptable jsonifiableToAdaptable(final Jsonifiable.WithPredicate<JsonObject, JsonField> jsonifiable, final TopicPath.Channel channel, final ProtocolAdapter adapter) { final Adaptable adaptable; if (jsonifiable instanceof Command) { adaptable = adapter.toAdaptable((Command) jsonifiable, channel); } else if (jsonifiable instanceof Event) { adaptable = adapter.toAdaptable((Event) jsonifiable, channel); } else if (jsonifiable instanceof CommandResponse) { adaptable = adapter.toAdaptable((CommandResponse) jsonifiable, channel); } else if (jsonifiable instanceof DittoRuntimeException) { final DittoHeaders enhancedHeaders = ((DittoRuntimeException) jsonifiable).getDittoHeaders().toBuilder() .channel(channel.getName()) .build(); ThingErrorResponse errorResponse; try { errorResponse = ThingErrorResponse.of(MessageHeaders.of(enhancedHeaders).getThingId(), (DittoRuntimeException) jsonifiable, enhancedHeaders); } catch (final IllegalStateException | IllegalArgumentException | DittoRuntimeException e) { // thrown if headers did not contain the thing ID: errorResponse = ThingErrorResponse.of((DittoRuntimeException) jsonifiable, enhancedHeaders); } adaptable = adapter.toAdaptable(errorResponse, channel); } else { throw new IllegalArgumentException("Jsonifiable was neither Command nor CommandResponse nor" + " Event nor DittoRuntimeException: " + jsonifiable.getClass().getSimpleName()); } return adaptable; }
private static Optional<Topic> topicFromSignal(final Signal<?> signal) { // only things as group supported final TopicPath.Group group = signal instanceof WithThingId ? TopicPath.Group.THINGS : null; final TopicPath.Channel channel = signal.getDittoHeaders() .getChannel() .flatMap(TopicPath.Channel::forName) .orElse(TopicPath.Channel.TWIN); final TopicPath.Criterion criterion = getCriterionOfSignal(signal); if (TopicPath.Group.THINGS.equals(group)) { if (TopicPath.Channel.TWIN.equals(channel)) { if (EVENTS.equals(criterion)) { return Optional.of(Topic.TWIN_EVENTS); } } else if (TopicPath.Channel.LIVE.equals(channel) && criterion != null) { switch (criterion) { case COMMANDS: return Optional.of(Topic.LIVE_COMMANDS); case EVENTS: return Optional.of(Topic.LIVE_EVENTS); case MESSAGES: return Optional.of(Topic.LIVE_MESSAGES); default: return Optional.empty(); } } } return Optional.empty(); }
private static Function<Jsonifiable.WithPredicate<JsonObject, JsonField>, String> jsonifiableToString( final ProtocolAdapter adapter) { return jsonifiable -> { if (jsonifiable instanceof StreamingAck) { return streamingAckToString((StreamingAck) jsonifiable); } final Adaptable adaptable; if (jsonifiable instanceof WithDittoHeaders && ((WithDittoHeaders) jsonifiable).getDittoHeaders().getChannel().isPresent()) { // if channel was present in headers, use that one: final TopicPath.Channel channel = TopicPath.Channel.forName(((WithDittoHeaders) jsonifiable).getDittoHeaders().getChannel().get()) .orElse(TopicPath.Channel.TWIN); adaptable = jsonifiableToAdaptable(jsonifiable, channel, adapter); } else if (jsonifiable instanceof Signal && isLiveSignal((Signal<?>) jsonifiable)) { adaptable = jsonifiableToAdaptable(jsonifiable, TopicPath.Channel.LIVE, adapter); } else { adaptable = jsonifiableToAdaptable(jsonifiable, TopicPath.Channel.TWIN, adapter); } final JsonifiableAdaptable jsonifiableAdaptable = ProtocolFactory.wrapAsJsonifiableAdaptable(adaptable); return jsonifiableAdaptable.toJsonString(); }; }
private Signal<?> fromLiveAdaptable(final Adaptable adaptable) { final TopicPath topicPath = adaptable.getTopicPath(); final Signal<?> liveSignal; if (TopicPath.Criterion.MESSAGES.equals(topicPath.getCriterion())) { // /things/live/messages final boolean isResponse = adaptable.getPayload().getStatus().isPresent(); if (isResponse) { liveSignal = messageCommandResponseAdapter.fromAdaptable(adaptable); } else { liveSignal = messageCommandAdapter.fromAdaptable(adaptable); } } else { liveSignal = signalFromAdaptable(adaptable, topicPath); // /things/live/(commands|events) } if (liveSignal != null) { final DittoHeadersBuilder enhancedHeadersBuilder = liveSignal.getDittoHeaders() .toBuilder() .channel(TopicPath.Channel.LIVE.getName()); return liveSignal.setDittoHeaders(enhancedHeadersBuilder.build()); } else { throw UnknownTopicPathException.newBuilder(topicPath).build(); } }
private Signal<?> fromLiveAdaptable(final Adaptable adaptable) { final TopicPath topicPath = adaptable.getTopicPath(); final Signal<?> liveSignal; if (TopicPath.Criterion.MESSAGES.equals(topicPath.getCriterion())) { // /things/live/messages final boolean isResponse = adaptable.getPayload().getStatus().isPresent(); if (isResponse) { liveSignal = messageCommandResponseAdapter.fromAdaptable(adaptable); } else { liveSignal = messageCommandAdapter.fromAdaptable(adaptable); } } else { liveSignal = signalFromAdaptable(adaptable, topicPath); // /things/live/(commands|events) } if (liveSignal != null) { final DittoHeadersBuilder enhancedHeadersBuilder = liveSignal.getDittoHeaders() .toBuilder() .channel(TopicPath.Channel.LIVE.getName()); return liveSignal.setDittoHeaders(enhancedHeadersBuilder.build()); } else { throw UnknownTopicPathException.newBuilder(topicPath).build(); } }
private DittoHeaders buildDittoHeaders(final AuthorizationContext authorizationContext, final Integer version, final String correlationId, final RequestContext ctx, @Nullable final String liveParam, final CustomHeadersHandler.RequestType requestType) { final DittoHeadersBuilder builder = DittoHeaders.newBuilder(); final Map<String, String> externalHeadersMap = getFilteredExternalHeaders(ctx.getRequest()); builder.putHeaders(externalHeadersMap); final JsonSchemaVersion jsonSchemaVersion = JsonSchemaVersion.forInt(version) .orElseThrow(() -> CommandNotSupportedException.newBuilder(version).build()); builder.authorizationContext(authorizationContext) .schemaVersion(jsonSchemaVersion) .correlationId(correlationId); authorizationContext.getFirstAuthorizationSubject().map(AuthorizationSubject::getId).ifPresent(builder::source); if (liveParam != null) { // once the "live" query param was set - no matter what the value was - use live // channel builder.channel(TopicPath.Channel.LIVE.getName()); } final DittoHeaders dittoDefaultHeaders = builder.build(); return handleCustomHeaders(correlationId, ctx, requestType, authorizationContext, dittoDefaultHeaders); }
/** * Add any extra information in topic path as Ditto headers. Currently "channel" is the only relevant header. * * @param topicPath the topic path to extract information from. * @return headers containing extra information from topic path. */ private static DittoHeaders mapTopicPathToHeaders(final TopicPath topicPath) { if (topicPath.getChannel() == TopicPath.Channel.LIVE) { return DittoHeaders.newBuilder() .channel(TopicPath.Channel.LIVE.getName()) .build(); } else { return DittoHeaders.empty(); } }
static boolean isLiveSignal(final Signal<?> signal) { return signal.getDittoHeaders().getChannel().filter(TopicPath.Channel.LIVE.getName()::equals).isPresent(); }
private static boolean isLiveSignal(final Signal<?> signal) { return signal.getDittoHeaders().getChannel().filter(TopicPath.Channel.LIVE.getName()::equals).isPresent(); }
private static boolean isLiveSignal(final Signal<?> signal) { return signal.getDittoHeaders().getChannel().filter(TopicPath.Channel.LIVE.getName()::equals).isPresent(); }
/** * Add any extra information in topic path as Ditto headers. Currently "channel" is the only relevant header. * * @param topicPath the topic path to extract information from. * @return headers containing extra information from topic path. */ private static DittoHeaders mapTopicPathToHeaders(final TopicPath topicPath) { if (topicPath.getChannel() == TopicPath.Channel.LIVE) { return DittoHeaders.newBuilder() .channel(TopicPath.Channel.LIVE.getName()) .build(); } else { return DittoHeaders.empty(); } }
private static StreamingType determineStreamingType(final Signal<?> signal) { final String channel = signal.getDittoHeaders().getChannel().orElse(TopicPath.Channel.TWIN.getName()); final StreamingType streamingType; if (signal instanceof Event) { streamingType = channel.equals(TopicPath.Channel.TWIN.getName()) ? StreamingType.EVENTS : StreamingType.LIVE_EVENTS; } else if (signal instanceof MessageCommand) { streamingType = StreamingType.MESSAGES; } else { streamingType = StreamingType.LIVE_COMMANDS; } return streamingType; }
@Override public Signal<?> fromAdaptable(final Adaptable adaptable) { final TopicPath topicPath = adaptable.getTopicPath(); if (TopicPath.Group.THINGS.equals(topicPath.getGroup())) { // /things final TopicPath.Channel channel = topicPath.getChannel(); if (channel.equals(TopicPath.Channel.LIVE)) { // /things/live return fromLiveAdaptable(adaptable); } else if (channel.equals(TopicPath.Channel.TWIN)) { // /things/twin return fromTwinAdaptable(adaptable); } } throw UnknownTopicPathException.newBuilder(topicPath).build(); }
@Test public void testReplaceChannel() { assertThat(UNDER_TEST.apply(KNOWN_TOPIC_PATH, "channel")).contains(KNOWN_CHANNEL.getName()); }