if (returnData instanceof String && expressionManager.isExpression(returnData.toString())) { replyBuilder = replyBuilder.value(expressionManager.parse(returnData.toString(), event, getLocation())); } else { replyBuilder = replyBuilder.value(returnData); replyBuilder = replyBuilder.value(append(muleContext.getTransformationService() .transform(event.getMessage(), DataType.STRING).getPayload().getValue().toString(), event)); CoreEvent replyMessage = CoreEvent.builder(event).message(replyBuilder.build()).build();
final Message.Builder messageBuilder; messageBuilder = Message.builder().value(payload).mediaType(mediaType); messageBuilder.attributesValue(attributes); final Message muleMessage = messageBuilder.build();
@Test public void regularToString() { Message message = Message.builder() .payload(TypedValue.of("test")) .attributes(new TypedValue<>("{}", JSON_STRING)) .mediaType(TEXT) .build(); assertThat(message.toString(), is(equalToIgnoringLineBreaks("\n" + "org.mule.runtime.core.internal.message.DefaultMessageBuilder$MessageImplementation\n" + "{\n" + " payload=test\n" + " mediaType=text/plain\n" + " attributes={}\n" + " attributesMediaType=application/json\n" + "}"))); }
return new MuleVariableResolver<>(PAYLOAD, new MessageContext(event, eventBuilder, muleContext).getPayload(), null, (name1, value, newValue) -> eventBuilder .message(Message.builder(event.getMessage()).value(newValue).build())); } else if (ATTRIBUTES.equals(name)) { return new MuleImmutableVariableResolver<>(ATTRIBUTES, event.getMessage().getAttributes().getValue(), null);
builder.value(muleContext.getObjectSerializer().getInternalProtocol().deserialize(baos.toByteArray())); } catch (SerializationException e) { builder.value(baos.toByteArray()); return PrivilegedEvent.builder(collectedEvents[collectedEvents.length - 1]).message(builder.build()) .session(getMergedSession(events.toArray())).build(); } catch (Exception e) {
Message incomingMessage = lookupValue(context, MESSAGE, Message.builder().nullValue().build()); Map<String, ?> incomingVariables = lookupValue(context, VARS, EMPTY_MAP); Error incomingError = lookupValue(context, ERROR, null); Message message = Message.builder(incomingMessage).value(payload).mediaType(APPLICATION_JAVA).build(); CoreEvent event = CoreEvent.builder(PrivilegedEvent.getCurrentEvent().getContext()) .variables(incomingVariables)
protected Message toMessage(Object value, ExecutionContextAdapter operationContext) { final MediaType mediaType = resolveMediaType(value, operationContext); final CoreEvent event = operationContext.getEvent(); if (value instanceof Result) { Result resultValue = (Result) value; return isSpecialHandling && returnHandler.handles(resultValue.getOutput()) ? MessageUtils.toMessage((Result) value, mediaType, cursorProviderFactory, event, returnHandler.getDataType()) : MessageUtils.toMessage((Result) value, mediaType, cursorProviderFactory, event); } else { if (value instanceof Collection && returnsListOfMessages) { value = toMessageCollection((Collection<Result>) value, cursorProviderFactory, event); } else if (value instanceof Iterator && returnsListOfMessages) { value = toMessageIterator((Iterator<Result>) value, cursorProviderFactory, event); } value = streamingContent(value, cursorProviderFactory, event); Message.Builder messageBuilder; //TODO MULE-13302: this doesn't completely makes sense. IT doesn't account for an Iterator<Message> // org.mule.runtime.api.metadata.DataType.MULE_MESSAGE_COLLECTION doesn't completely makes sense if (returnsListOfMessages && value instanceof Collection) { messageBuilder = Message.builder().collectionValue((Collection) value, Message.class); } else if (isSpecialHandling && returnHandler.handles(value)) { messageBuilder = returnHandler.toMessageBuilder(value); } else { messageBuilder = Message.builder().value(value); } return messageBuilder.mediaType(mediaType).build(); } }
@Override public Object transformMessage(CoreEvent event, Charset outputEncoding) throws MessageTransformerException { Message result = event.getMessage(); Object temp = event.getMessage(); Transformer lastTransformer = null; for (Object element : transformers) { lastTransformer = (Transformer) element; try { temp = lastTransformer.transform(temp); } catch (TransformerException e) { throw new MessageTransformerException(lastTransformer, e, event.getMessage()); } if (temp instanceof Message) { result = (Message) temp; } else { result = Message.builder(event.getMessage()).value(temp).build(); event = CoreEvent.builder(event).message(result).build(); } } if (lastTransformer != null && Message.class.isAssignableFrom(lastTransformer.getReturnDataType().getType())) { return result; } else { return result.getPayload().getValue(); } }
private void initEventBuilder(Object sequenceValue, CoreEvent originalEvent, Builder builder, Map<String, ?> flowVarsFromLastResult) { if (sequenceValue instanceof EventBuilderConfigurer) { ((EventBuilderConfigurer) sequenceValue).configure(builder); } else if (sequenceValue instanceof CoreEvent) { final CoreEvent payloadAsEvent = (CoreEvent) sequenceValue; builder.message(payloadAsEvent.getMessage()); for (String flowVarName : payloadAsEvent.getVariables().keySet()) { if (!flowVarsFromLastResult.containsKey(flowVarName)) { builder.addVariable(flowVarName, payloadAsEvent.getVariables().get(flowVarName).getValue(), payloadAsEvent.getVariables().get(flowVarName).getDataType()); } } } else if (sequenceValue instanceof Message) { final Message message = (Message) sequenceValue; builder.message(message); } else if (sequenceValue instanceof TypedValue) { builder.message(Message.builder().payload((TypedValue) sequenceValue).build()); } else if (sequenceValue instanceof Collection) { builder.message(Message.builder(originalEvent.getMessage()).value(((Collection) sequenceValue).stream() .map(v -> v instanceof TypedValue ? ((TypedValue) v).getValue() : v).collect(toList())).build()); } else { builder.message(Message.builder(originalEvent.getMessage()).value(sequenceValue).build()); } }
protected PrivilegedEvent enrich(PrivilegedEvent currentEvent, PrivilegedEvent enrichmentEvent, String sourceExpressionArg, String targetExpressionArg, ExtendedExpressionManager expressionManager) { if (StringUtils.isEmpty(sourceExpressionArg)) { sourceExpressionArg = "#[mel:payload:]"; } TypedValue typedValue = expressionManager.evaluate(sourceExpressionArg, enrichmentEvent, getLocation()); if (typedValue.getValue() instanceof Message) { Message muleMessage = (Message) typedValue.getValue(); typedValue = new TypedValue(muleMessage.getPayload().getValue(), muleMessage.getPayload().getDataType()); } if (!StringUtils.isEmpty(targetExpressionArg)) { PrivilegedEvent.Builder eventBuilder = PrivilegedEvent.builder(currentEvent); expressionManager.enrich(targetExpressionArg, currentEvent, eventBuilder, getLocation(), typedValue); return eventBuilder.build(); } else { return PrivilegedEvent.builder(currentEvent).message(Message.builder(currentEvent.getMessage()) .value(typedValue.getValue()).mediaType(typedValue.getDataType().getMediaType()).build()).build(); } }
/** * Attempts to obtain the payload of this message with the desired Class type. This will try and resolve a transformer that can * do this transformation. If a transformer cannot be found an exception is thrown. Any transformers added to the registry will * be checked for compatibility * <p/> * If the existing payload is consumable (i.e. can't be read twice) then the existing payload of the message will be replaced * with a byte[] representation as part of this operations. * <p/> * * * @param message * @param outputDataType the desired return type * @return The converted payload of this message. Note that this method will not alter the payload of this message *unless* the * payload is an InputStream in which case the stream will be read and the payload will become the fully read stream. * @throws MessageTransformerException if a transformer cannot be found or there is an error during transformation of the payload */ private Message internalTransform(Message message, DataType outputDataType) throws MessageTransformerException { checkNotNull(message, "Message cannot be null"); checkNotNull(outputDataType, "DataType cannot be null"); return Message.builder(message).value(getPayload(message, outputDataType, resolveEncoding(message))).build(); }
private Message transformMessage(final Message message, final CoreEvent event, final Transformer transformer) throws MessageTransformerException, TransformerException { Object result; if (transformer instanceof MessageTransformer) { result = ((MessageTransformer) transformer).transform(message, event); } else { result = transformer.transform(message); } if (result instanceof Message) { return (Message) result; } else { // We need to use message from event if it's available in case the transformer mutated the message by creating // a new message instance. This issue goes away once transformers are cleaned up and always return event or // message. See MULE-9342 Message messagePostTransform = (event != null && event.getMessage() != null) ? event.getMessage() : message; return Message.builder(messagePostTransform).value(result) .mediaType(mergeMediaType(messagePostTransform, transformer.getReturnDataType())).build(); } }
@Override public CoreEvent process(CoreEvent event) { evaluateCorrectArguments(); Object result = muleContext.getExpressionManager().parseLogTemplate(content, event, getLocation(), NULL_BINDING_CONTEXT); Message resultMessage = Message.builder(event.getMessage()).value(result).nullAttributesValue().build(); if (target == null) { return CoreEvent.builder(event).message(resultMessage).build(); } else { if (targetValue == null) { //Return the whole message return CoreEvent.builder(event).addVariable(target, resultMessage).build(); } else { //typeValue was defined by the user return CoreEvent.builder(event).addVariable(target, muleContext.getExpressionManager() .evaluate(targetValue, CoreEvent.builder(event) .message(resultMessage).build())) .build(); } } }
/** * Provides a function that updates the payload value of an {@link CoreEvent} by replacing it with a {@link CursorProvider}. * * @param streamingManager the streaming manager * @return function that maps the an {@link CoreEvent} */ public static Function<CoreEvent, CoreEvent> updateEventForStreaming(final StreamingManager streamingManager) { return event -> { TypedValue payload = event.getMessage().getPayload(); if (payload.getValue() instanceof CursorProvider) { Message message = Message.builder(event.getMessage()) .payload(updateTypedValueForStreaming(payload, event, streamingManager)) .build(); return CoreEvent.builder(event).message(message).build(); } return event; }; }
@Test @Description("Verifies that XML content can be used for logging in DW.") public void parseLogXml() throws MuleException { CoreEvent event = getEventBuilder().message(Message.builder().value("<?xml version='1.0' encoding='US-ASCII'?>\n" + "<wsc_fields>\n" + " <operation>echo</operation>\n" + " <body_test>test</body_test>\n" + "</wsc_fields>") .mediaType(XML) .build()) .build(); assertThat(expressionManager.parseLogTemplate("this is #[payload.wsc_fields.operation]", event, TEST_CONNECTOR_LOCATION, NULL_BINDING_CONTEXT), is("this is \"echo\"")); }
@Override public CoreEvent process(CoreEvent event) throws MuleException { try { final Message message = event.getMessage(); return CoreEvent.builder(event) .message(Message.builder(message) .value(receive(muleContext.getTransformationService().transform(event.getMessage(), DataType.STRING).getPayload() .getValue().toString())) .build()) .build(); } catch (Exception e) { throw new DefaultMuleException(e); } }
@Override public CoreEvent process(CoreEvent event) throws MuleException { final Message.Builder builder = Message.builder(event.getMessage()); final CoreEvent.Builder eventBuilder = CoreEvent.builder(event); if (dataType == null) { final TypedValue typedValue = resolveTypedValue(event); builder.value(typedValue.getValue()).mediaType(typedValue.getDataType().getMediaType()); } else { Object value = resolveValue(event); final DataTypeParamsBuilder dataTypeBuilder = DataType.builder(dataType).type(value == null ? Object.class : value.getClass()); builder.value(value).mediaType(dataTypeBuilder.build().getMediaType()); } return eventBuilder.message(builder.build()).build(); }
@Test public void maintainsDataTypeOnGetPayloadTransformation() throws Exception { InputStream payload = mock(InputStream.class); Message message = Message.builder().value(payload).mediaType(APPLICATION_XML_CUSTOM).build(); MuleRegistry muleRegistry = mock(MuleRegistry.class); when(muleContext.getRegistry()).thenReturn(muleRegistry); Transformer transformer = mock(Transformer.class); when(transformer.transform(anyObject(), anyObject())).thenReturn(TEST_PAYLOAD); when(muleRegistry.lookupTransformer(any(), any())).thenReturn(transformer); assertThat(message.getPayload().getDataType().getMediaType().getPrimaryType(), equalTo(APPLICATION_XML.getPrimaryType())); assertThat(message.getPayload().getDataType().getMediaType().getSubType(), equalTo(APPLICATION_XML.getSubType())); assertThat(message.getPayload().getDataType().getMediaType().getCharset().get(), equalTo(CUSTOM_ENCODING)); }