@Test
public void testSimpleDiscovery() throws Exception {
Transformer t =
muleContext
.getRegistry()
.lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Apple.class));
assertNotNull(t);
assertEquals(StringToApple.class, t.getClass());
t =
muleContext
.getRegistry()
.lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Orange.class));
assertNotNull(t);
assertEquals(StringToOrange.class, t.getClass());
try {
muleContext
.getRegistry()
.lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(Banana.class));
fail("There is no transformer to go from String to Banana");
} catch (TransformerException e) {
// expected
}
muleContext.getRegistry().registerTransformer(new StringToRedApple());
t =
muleContext
.getRegistry()
.lookupTransformer(DataTypeFactory.STRING, DataTypeFactory.create(RedApple.class));
assertNotNull(t);
assertEquals(StringToRedApple.class, t.getClass());
}
public JsonToXml() {
this.registerSourceType(DataTypeFactory.STRING);
this.registerSourceType(DataTypeFactory.INPUT_STREAM);
this.registerSourceType(DataTypeFactory.BYTE_ARRAY);
this.registerSourceType(DataTypeFactory.create(Reader.class));
this.registerSourceType(DataTypeFactory.create(URL.class));
this.registerSourceType(DataTypeFactory.create(File.class));
setReturnDataType(DataTypeFactory.XML_STRING);
}
/**
* Will set a session level property. These will either be stored and retrieved using the
* underlying transport mechanism of stored using a default mechanism
*
* @param key the key for the object data being stored on the session
* @param value the value of the session data
*/
@Override
public void setProperty(String key, Object value) {
if (!(value instanceof Serializable)) {
logger.warn(CoreMessages.sessionPropertyNotSerializableWarning(key));
}
DataType dataType = DataTypeFactory.createFromObject(value);
properties.put(key, new TypedValue(value, dataType));
}
@Override
public Transformer getRoundTripTransformer() throws Exception {
JsonToObject trans = new JsonToObject();
trans.setReturnDataType(DataTypeFactory.create(getTestData().getClass()));
trans.getDeserializationMixins().put(FruitCollection.class, FruitCollectionMixin.class);
trans.getDeserializationMixins().put(Apple.class, AppleMixin.class);
trans.getDeserializationMixins().put(Orange.class, OrangeMixin.class);
initialiseObject(trans);
return trans;
}
public XmlToXMLStreamReader() {
super();
registerSourceType(Source.class);
registerSourceType(InputStream.class);
registerSourceType(Document.class);
registerSourceType(byte[].class);
registerSourceType(String.class);
setReturnDataType(DataTypeFactory.create(XMLStreamReader.class));
}
public StringToApple() {
setReturnDataType(DataTypeFactory.create(Apple.class));
}
@Override
public void setProperty(String key, Serializable value) {
setProperty(key, value, DataTypeFactory.createFromObject(value));
}
public ObjectToInputStream() {
this.registerSourceType(DataTypeFactory.STRING);
this.registerSourceType(DataTypeFactory.create(OutputHandler.class));
setReturnDataType(DataTypeFactory.INPUT_STREAM);
}
public TransformHttpToNodeRq() {
registerSourceType(DataTypeFactory.OBJECT);
setReturnDataType(DataTypeFactory.create(BaseNodeRq.class));
}
public JsonToProcessInstance() {
this.setReturnDataType(DataTypeFactory.create(ProcessInstance.class));
}
/**
* Constructor for multi-part transformers.
*
* <p>Host to Java transformers expects a map of byte arrays for multi part payloads. Inheriting
* classes will set the return class.
*
* @param bindingTransformersMap map of transformer sets, one for each part type.
*/
public AbstractHostToJavaMuleTransformer(
final Map<String, AbstractTransformers> bindingTransformersMap) {
super(bindingTransformersMap);
registerSourceType(DataTypeFactory.create(Map.class));
}
/**
* Constructor for single part transformers.
*
* <p>Host to Java transformers expect byte array sources corresponding to mainframe raw data.
* Alternatively, source can be an inputStream in which case, it is assumed to stream a byte
* array. Inheriting classes will set the return class.
*
* @param bindingTransformers a set of transformers for the part type.
*/
public AbstractHostToJavaMuleTransformer(final AbstractTransformers bindingTransformers) {
super(bindingTransformers);
registerSourceType(DataTypeFactory.create(InputStream.class));
registerSourceType(DataTypeFactory.BYTE_ARRAY);
}
@Override
public Transformer getRoundTripTransformer() throws Exception {
XmlToDomDocument trans = createObject(XmlToDomDocument.class); // encoding is not interesting
trans.setReturnDataType(DataTypeFactory.create(byte[].class));
return trans;
}
public ObjectToByteArray() {
this.registerSourceType(DataTypeFactory.INPUT_STREAM);
this.registerSourceType(DataTypeFactory.STRING);
this.registerSourceType(DataTypeFactory.create(OutputHandler.class));
setReturnDataType(DataTypeFactory.BYTE_ARRAY);
}
public StringToRedApple() {
setReturnDataType(DataTypeFactory.create(RedApple.class));
setPriorityWeighting(MAX_PRIORITY_WEIGHTING);
}
public StringToOrange() {
setReturnDataType(DataTypeFactory.create(Orange.class));
}
@Override
public void processReplyTo(MuleEvent event, MuleMessage returnMessage, Object replyTo)
throws MuleException {
Destination replyToDestination = null;
MessageProducer replyToProducer = null;
Session session = null;
try {
// now we need to send the response
if (replyTo instanceof Destination) {
replyToDestination = (Destination) replyTo;
}
if (replyToDestination == null) {
super.processReplyTo(event, returnMessage, replyTo);
return;
}
// This is a work around for JmsTransformers where the current endpoint needs
// to be set on the transformer so that a JMSMessage can be created correctly (the transformer
// needs a Session)
Class srcType = returnMessage.getPayload().getClass();
for (Iterator iterator = getTransformers().iterator(); iterator.hasNext(); ) {
Transformer t = (Transformer) iterator.next();
if (t.isSourceDataTypeSupported(DataTypeFactory.create(srcType))) {
if (t.getEndpoint() == null) {
t.setEndpoint(getEndpoint(event, "jms://temporary"));
break;
}
}
}
returnMessage.applyTransformers(getTransformers());
Object payload = returnMessage.getPayload();
if (replyToDestination instanceof Topic
&& replyToDestination instanceof Queue
&& connector.getJmsSupport() instanceof Jms102bSupport) {
logger.error(
StringMessageUtils.getBoilerPlate(
"ReplyTo destination implements both Queue and Topic "
+ "while complying with JMS 1.0.2b specification. "
+ "Please report your application server or JMS vendor name and version "
+ "to dev<_at_>mule.codehaus.org or http://mule.mulesource.org/jira"));
}
final boolean topic = connector.getTopicResolver().isTopic(replyToDestination);
session = connector.getSession(false, topic);
Message replyToMessage = JmsMessageUtils.toMessage(payload, session);
processMessage(replyToMessage, event);
if (logger.isDebugEnabled()) {
logger.debug(
"Sending jms reply to: "
+ replyToDestination
+ "("
+ replyToDestination.getClass().getName()
+ ")");
}
replyToProducer =
connector.getJmsSupport().createProducer(session, replyToDestination, topic);
// QoS support
MuleMessage eventMsg = event.getMessage();
String ttlString = (String) eventMsg.removeProperty(JmsConstants.TIME_TO_LIVE_PROPERTY);
String priorityString = (String) eventMsg.removeProperty(JmsConstants.PRIORITY_PROPERTY);
String persistentDeliveryString =
(String) eventMsg.removeProperty(JmsConstants.PERSISTENT_DELIVERY_PROPERTY);
String correlationIDString = replyToMessage.getJMSCorrelationID();
if (StringUtils.isBlank(correlationIDString)) {
correlationIDString = (String) eventMsg.getProperty(JmsConstants.JMS_MESSAGE_ID);
replyToMessage.setJMSCorrelationID(correlationIDString);
}
event.getService().getStatistics().incSentReplyToEvent();
final ImmutableEndpoint endpoint = event.getEndpoint();
if (ttlString == null && priorityString == null && persistentDeliveryString == null) {
connector.getJmsSupport().send(replyToProducer, replyToMessage, topic, endpoint);
} else {
long ttl = Message.DEFAULT_TIME_TO_LIVE;
int priority = Message.DEFAULT_PRIORITY;
if (ttlString != null) {
ttl = Long.parseLong(ttlString);
}
if (priorityString != null) {
priority = Integer.parseInt(priorityString);
}
boolean persistent =
StringUtils.isNotBlank(persistentDeliveryString)
? Boolean.valueOf(persistentDeliveryString)
: connector.isPersistentDelivery();
connector
.getJmsSupport()
.send(replyToProducer, replyToMessage, persistent, priority, ttl, topic, endpoint);
}
logger.info(
"Reply Message sent to: "
+ replyToDestination
+ " with correlationID:"
+ correlationIDString);
} catch (Exception e) {
throw new DispatchException(
JmsMessages.failedToCreateAndDispatchResponse(replyToDestination),
returnMessage,
null,
e);
} finally {
connector.closeQuietly(replyToProducer);
final Transaction transaction = TransactionCoordination.getInstance().getTransaction();
if (transaction == null) {
if (logger.isDebugEnabled()) {
logger.debug("Closing non-TX replyTo session: " + session);
}
connector.closeQuietly(session);
} else if (logger.isDebugEnabled()) {
logger.debug("Not closing TX replyTo session: " + session);
}
}
}
