private DittoHeaders buildDittoHeaders() { return DittoHeaders.newBuilder() .correlationId(batchId) .build(); }
/** * Read Ditto headers from external headers. * * @param externalHeaders external headers as a map. * @return Ditto headers initialized with values from external headers. */ public DittoHeaders fromExternalHeaders(final Map<String, String> externalHeaders) { final DittoHeadersBuilder builder = DittoHeaders.newBuilder(); externalHeaders.forEach((externalKey, value) -> { if (value == null) { return; } final String key = externalKey.toLowerCase(); final HeaderDefinition definition = headerDefinitionMap.get(key); if (definition == null || definition.shouldReadFromExternalHeaders()) { builder.putHeader(key, value); } }); return builder.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); }
private static DittoHeaders buildDevOpsDittoHeaders(final CharSequence correlationId) { return DittoHeaders.newBuilder() .schemaVersion(JsonSchemaVersion.V_2) .correlationId(correlationId) .build(); }
private static DittoHeaders createHeaders(final Optional<Long> optionalTimeout) { final DittoHeadersBuilder headersBuilder = DittoHeaders.newBuilder().correlationId(UUID.randomUUID().toString()); optionalTimeout.ifPresent(t -> headersBuilder.putHeader(TIMEOUT_PARAMETER, Long.toString(t))); return headersBuilder.build(); }
/** * Returns a new instance of {@code DittoHeaders} containing the specified key-value-pairs. * * @param headers the key-value-pairs of the result. * @return the DittoHeaders. * @throws NullPointerException if {@code headers} is {@code null}. * @throws IllegalArgumentException if {@code headers} contains an invalid key-value-pair. */ static DittoHeaders of(final Map<String, String> headers) { return newBuilder(headers).build(); }
/** * Add to headers any information that will be missing from topic path. * * @param filteredHeaders headers read from external headers. * @param topicPath topic path of an adaptable. * @return filteredHeaders with extra information from topicPath. */ private static DittoHeaders addTopicPathInfo(final DittoHeaders filteredHeaders, final TopicPath topicPath) { final DittoHeaders extraInfo = mapTopicPathToHeaders(topicPath); return extraInfo.isEmpty() ? filteredHeaders : filteredHeaders.toBuilder().putHeaders(extraInfo).build(); }
private <A extends ThingModifiedEvent<? extends A>> void persistAndApplyEvent( final A event, final BiConsumer<A, Thing> handler) { final A modifiedEvent; if (thing != null) { // set version of event to the version of the thing final DittoHeaders newHeaders = event.getDittoHeaders().toBuilder() .schemaVersion(thing.getImplementedSchemaVersion()) .build(); modifiedEvent = event.setDittoHeaders(newHeaders); } else { modifiedEvent = event; } if (modifiedEvent.getDittoHeaders().isDryRun()) { handler.accept(modifiedEvent, thing); } else { persistEvent(modifiedEvent, persistedEvent -> { // after the event was persisted, apply the event on the current actor state applyEvent(persistedEvent); handler.accept(persistedEvent, thing); }); } }
.schemaVersion(jsonSchemaVersion) .authorizationContext(connectionAuthContext) .correlationId(connectionCorrelationId) // for logging .origin(connectionCorrelationId) .build(); signal = adapter.fromAdaptable(jsonifiableAdaptable); } catch (final DittoRuntimeException e) { throw e.setDittoHeaders(e.getDittoHeaders().toBuilder().origin(connectionCorrelationId).build()); internalHeadersBuilder.putHeaders(initialInternalHeaders); internalHeadersBuilder.putHeaders(additionalHeaders); internalHeadersBuilder.putHeaders(signalHeaders); internalHeadersBuilder.correlationId(correlationId); return signal.setDittoHeaders(internalHeadersBuilder.build()); };
@Override public DittoHeaders apply(final ExternalMessage externalMessage, final DittoHeaders dittoHeaders) { final DittoHeadersBuilder dittoHeadersBuilder = dittoHeaders.toBuilder(); final String beforeMapping = externalMessage .findHeader(DittoHeaderDefinition.AUTHORIZATION_SUBJECTS.getKey()) .orElseThrow(() -> new IllegalArgumentException( "Missing header " + DittoHeaderDefinition.AUTHORIZATION_SUBJECTS.getKey())); // do not use dittoHeadersBuilder.authorizationSubjects(beforeMapping); // because beforeMapping is a JsonArray String, we need to set AUTHORIZATION_SUBJECTS header directly dittoHeadersBuilder.putHeader(DittoHeaderDefinition.AUTHORIZATION_SUBJECTS.getKey(), beforeMapping); if (!dittoHeaders.getOrigin().isPresent()) { dittoHeadersBuilder.origin(connectionId); } // overwrite the auth-subjects to the configured ones after mapping in order to be sure that the mapping // does not choose/change the auth-subjects itself: return dittoHeadersBuilder.build(); }
dittoHeadersBuilder.putHeader(REPLY_TO_HEADER, replyTo); message.getJMSMessageID(); dittoHeadersBuilder.authorizationSubjects(authorizationSubject.getId()); .orElse(jmsCorrelationId); dittoHeadersBuilder.correlationId(correlationId); LogUtil.enhanceLogWithCorrelationId(log, correlationId); log.debug("received public command: {}", jsonifiableAdaptable.toJsonString()); final DittoHeaders dittoHeaders = dittoHeadersBuilder.build(); return command.setDittoHeaders(dittoHeaders); } catch (final DittoRuntimeException e) {
private void tellCommandAsDryRun(final Command command) { final String correlationId = encodeCorrelationId(command.getDittoHeaders()); final DittoHeadersBuilder dittoHeadersBuilder = command.getDittoHeaders() .toBuilder() .correlationId(correlationId); commands.put(correlationId, command.setDittoHeaders(dittoHeadersBuilder.build())); pendingCommands.add(correlationId); final Command commandAsDryRun = command.setDittoHeaders(dittoHeadersBuilder.dryRun(true).build()); conciergeForwarder.tell(commandAsDryRun, getSelf()); }
/** * Returns new {@code Headers} for the specified {@code headers} map. * * @param headers the headers map. * @return the headers. */ public static DittoHeaders newHeadersWithDittoContentType(final Map<String, String> headers) { return DittoHeaders.of(headers).toBuilder().contentType(DittoConstants.DITTO_PROTOCOL_CONTENT_TYPE).build(); }
/** * Extend a signal by read-subjects header given explicitly. * * @param <T> type of the signal. * @param signal the signal to extend. * @param readSubjects explicitly-given read subjects. * @return the extended signal. */ protected static <T extends Signal> T addReadSubjectsToSignal(final Signal<T> signal, final Set<String> readSubjects) { final DittoHeaders newHeaders = signal.getDittoHeaders() .toBuilder() .readSubjects(readSubjects) .build(); return signal.setDittoHeaders(newHeaders); }
/** * Returns new {@code Headers} for the specified {@code headersAsJson}. * * @param headersAsJson the headers as JSON. * @return the headers. */ public static DittoHeaders newHeaders(final JsonObject headersAsJson) { return DittoHeaders.newBuilder(headersAsJson).build(); }
@Override public Optional<Adaptable> map(final ExternalMessage message) { final ExternalMessage enhancedMessage; final String correlationId; if (!message.getHeaders().containsKey(DittoHeaderDefinition.CORRELATION_ID.getKey())) { // if no correlation-id was provided in the ExternalMessage, generate one here: correlationId = UUID.randomUUID().toString(); enhancedMessage = ExternalMessageFactory.newExternalMessageBuilder(message) .withAdditionalHeaders(DittoHeaderDefinition.CORRELATION_ID.getKey(), correlationId) .build(); } else { correlationId = message.getHeaders().get(DittoHeaderDefinition.CORRELATION_ID.getKey()); enhancedMessage = message; } final Optional<Adaptable> mappedOpt = delegate.map(enhancedMessage); return mappedOpt.map(mapped -> { final DittoHeadersBuilder headersBuilder = DittoHeaders.newBuilder(); headersBuilder.correlationId(correlationId); Optional.ofNullable(message.getHeaders().get(ExternalMessage.REPLY_TO_HEADER)).ifPresent(replyTo -> headersBuilder.putHeader(ExternalMessage.REPLY_TO_HEADER, replyTo) ); final Optional<DittoHeaders> headersOpt = mapped.getHeaders(); headersOpt.ifPresent(headersBuilder::putHeaders); // overwrite with mapped headers (if any) return ProtocolFactory.newAdaptableBuilder(mapped) .withHeaders(headersBuilder.build()) .build(); }); }