public InOnly createInOnlyExchange() throws MessagingException { InOnly exchange = getExchangeFactory().createInOnlyExchange(); NormalizedMessage in = exchange.createMessage(); exchange.setInMessage(in); return exchange; }
protected void processFile(File file) throws Exception { InputStream stream = new BufferedInputStream(new FileInputStream(file)); InOnly exchange = getExchangeFactory().createInOnlyExchange(); configureExchangeTarget(exchange); NormalizedMessage message = exchange.createMessage(); exchange.setInMessage(message); marshaler.readMessage(exchange, message, stream, file.getCanonicalPath()); // sending the file itself along as a message property and holding on to // the stream we opened exchange.getInMessage().setProperty(FileComponent.FILE_PROPERTY, file); this.openExchanges.put(exchange.getExchangeId(), stream); send(exchange); }
protected void processFile(FTPClient ftp, String file) throws Exception { InputStream in = ftp.retrieveFileStream(file); InOnly exchange = getExchangeFactory().createInOnlyExchange(); configureExchangeTarget(exchange); NormalizedMessage message = exchange.createMessage(); exchange.setInMessage(message); if (getTargetOperation() != null) { exchange.setOperation(getTargetOperation()); } marshaler.readMessage(exchange, message, in, file); if (stateless) { exchange.setProperty(FtpData.class.getName(), new FtpData(file, ftp, in)); } else { this.openExchanges.put(exchange.getExchangeId(), new FtpData(file, ftp, in)); } send(exchange); }
@Override public void invoke(InOnly mex) throws MessagingException { try { DynamicService<T> service = new DynamicService<T>(_service); OMElement payload = OMUtils.toOM(mex.getInMessage().getContent()); service.invoke(mex.getOperation().getLocalPart(), payload); } catch (Exception e) { throw new RuntimeException(e); } }
InOnly me = channel.createExchangeFactory().createInOnlyExchange(); me.setProperty(FROM_SUBSCRIPTION_MANAGER, Boolean.TRUE); NormalizedMessage in = me.createMessage(); getMessageTransformer().transform(me, exchange.getInMessage(), in); me.setInMessage(in); me.setEndpoint(endpoint); Set names = exchange.getPropertyNames(); for (Iterator iter = names.iterator(); iter.hasNext();) { String name = (String) iter.next(); me.setProperty(name, exchange.getProperty(name));
protected void sendAggregate(String processCorrelationId, String correlationId, Object aggregation, boolean timeout, boolean sync) throws Exception { InOnly me = getExchangeFactory().createInOnlyExchange(); if (processCorrelationId != null) { me.setProperty(JbiConstants.CORRELATION_ID, processCorrelationId); } me.setProperty(getService().toString() + ":" + getEndpoint() + ":correlation", correlationId); target.configureTarget(me, getContext()); NormalizedMessage nm = me.createMessage(); me.setInMessage(nm); buildAggregate(aggregation, nm, me, timeout); closeAggregation(correlationId); if (sync) { sendSync(me); } else { send(me); } }
public void sendMessages(int messageCount, boolean sync) throws MessagingException { LOGGER.info("Looking for services for interface: {}", interfaceName); ServiceEndpoint[] endpoints = context.getEndpointsForService(interfaceName); if (endpoints.length > 0) { ServiceEndpoint endpoint = endpoints[0]; LOGGER.info("Sending to endpoint: {}", endpoint); for (int i = 0; i < messageCount; i++) { InOnly exchange = context.getDeliveryChannel().createExchangeFactory().createInOnlyExchange(); NormalizedMessage message = exchange.createMessage(); exchange.setEndpoint(endpoint); exchange.setInMessage(message); // lets set the XML as a byte[], String or DOM etc String xml = "<s12:Envelope xmlns:s12='http://www.w3.org/2003/05/soap-envelope'>" + " <s12:Body><foo>Hello!</foo> </s12:Body>" + "</s12:Envelope>"; message.setContent(new StringSource(xml)); LOGGER.info("sending message: {}", i); DeliveryChannel deliveryChannel = context.getDeliveryChannel(); LOGGER.info("sync send on deliverychannel: {}", deliveryChannel); if (sync) { deliveryChannel.sendSync(exchange); } else { deliveryChannel.send(exchange); } } } else { LOGGER.warn("No endpoints available for interface: {}", interfaceName); } }
/** * sends the given DOMSource as message to the given service (inOnly) * * @param service * the service name to send the message to * @param source * the source to put in the in message content * @return true on sucessful delivering or false on failure * @throws MessagingException * on any messaging exception */ public boolean sendMessage(QName service, Source source) throws MessagingException { InOnly inOnly = getChannel().createExchangeFactoryForService(service).createInOnlyExchange(); NormalizedMessage msg = inOnly.createMessage(); msg.setContent(source); inOnly.setInMessage(msg); if (getChannel().sendSync(inOnly)) { return inOnly.getStatus() == ExchangeStatus.DONE; } else { return false; } }
String processCorrelationId = (String)exchange.getProperty(JbiConstants.CORRELATION_ID); if (processCorrelationId != null) { outExchange.setProperty(JbiConstants.CORRELATION_ID, processCorrelationId); outMsg = outExchange.createMessage(); outExchange.setMessage(outMsg, "in");
public static boolean hasInMessage(MessageExchange mex) { if (mex instanceof InOnly) { return ((InOnly) mex).getInMessage() != null; } else if (mex instanceof InOut) { return ((InOut) mex).getInMessage() != null; } return false; }
InOnly exchange = client.createInOnlyExchange(); NormalizedMessage message = exchange.getInMessage(); message.setProperty("name", "James"); message.setProperty("id", new Integer(i)); exchange.setService(service); if (sync) { client.sendSync(exchange); Exception error = exchange.getError(); if (error != null) { throw error; Fault fault = exchange.getFault(); assertEquals("Should have no fault!", null, fault);
/** * Creates a new InOnly exchange for the given service, interface and/or operation (any of which can be null). */ public InOnly createInOnlyExchange(QName service, QName interfaceName, QName operation) throws MessagingException { DeliveryChannel channel = getDeliveryChannel(); MessageExchangeFactory factory = null; if (service != null) { factory = channel.createExchangeFactoryForService(service); } else if (interfaceName != null) { factory = channel.createExchangeFactory(interfaceName); } else { factory = getExchangeFactory(); } InOnly outExchange = factory.createInOnlyExchange(); if (service != null) { outExchange.setService(service); } if (interfaceName != null) { outExchange.setInterfaceName(interfaceName); } if (operation != null) { outExchange.setOperation(operation); } return outExchange; }
public void onMessageExchange(MessageExchange exchange) throws MessagingException { // Skip done exchanges if (exchange.getStatus() == ExchangeStatus.DONE) { return; // Handle error exchanges } else if (exchange.getStatus() == ExchangeStatus.ERROR) { return; } // lets create an endpoint DeliveryChannel deliveryChannel = getDeliveryChannel(); MessageExchangeFactory rpcFactory = deliveryChannel.createExchangeFactory(requestResponseEndpoint); InOut rpc = rpcFactory.createInOutExchange(); rpc.setInMessage(exchange.getMessage("in")); boolean answer = deliveryChannel.sendSync(rpc); MessageExchangeFactory outputFactory = deliveryChannel.createExchangeFactory(outputEndpoint); InOnly inOnly = outputFactory.createInOnlyExchange(); if (answer) { inOnly.setInMessage(rpc.getOutMessage()); deliveryChannel.send(inOnly); done(exchange); } else if (!(exchange instanceof InOnly)) { inOnly.setError(rpc.getError()); Fault fault = rpc.getFault(); fail(exchange, fault); } else { // terminate the exchange done(exchange); } done(rpc); }
public void run() { try { _outstandingExchanges.put(inonly.getExchangeId(), odeMex); _ode.getChannel().send(inonly); } catch (MessagingException e) { String errmsg = "Error sending request-only message to JBI for ODE mex " + odeMex; __log.error(errmsg, e); } } });
private void sendSyncToListenerAndTarget(MessageExchange source, MessageExchange dest, ExchangeTarget listener, String message, boolean copy) throws Exception { if (listener != null) { NormalizedMessage msg = MessageUtil.copy(source.getMessage(message)); InOnly lme = getExchangeFactory().createInOnlyExchange(); if (store.hasFeature(Store.CLUSTERED)) { lme.setProperty(JbiConstants.STATELESS_CONSUMER, Boolean.TRUE); } listener.configureTarget(lme, getContext()); MessageUtil.transferToIn(msg, lme); sendSync(lme); MessageUtil.transferTo(msg, dest, message); if (copy) { copyExchangeProperties(dest, "in", message); } sendSync(dest); } else { MessageUtil.transferTo(source, dest, message); if (copy) { copyExchangeProperties(dest, "in", message); } sendSync(dest); } }
public void sendMessages(int messageCount, boolean sync) throws JBIException { ComponentContext context = getContext(); for (int i = 0; i < messageCount; i++) { InOnly exchange = context.getDeliveryChannel().createExchangeFactory().createInOnlyExchange(); NormalizedMessage msg = exchange.createMessage(); ServiceEndpoint destination = null; if (resolver != null) { destination = resolver.resolveEndpoint(getContext(), exchange, NullEndpointFilter.getInstance()); } if (destination != null) { // lets explicitly specify the destination - otherwise // we'll let the container choose for us exchange.setEndpoint(destination); } exchange.setInMessage(msg); // lets set the XML as a byte[], String or DOM etc msg.setContent(new StringSource(this.message)); if (sync) { boolean result = context.getDeliveryChannel().sendSync(exchange, 1000); if (!result) { throw new MessagingException("Message delivery using sendSync has timed out"); } } else { context.getDeliveryChannel().send(exchange); } } }
public Message createInOnlyMessage() throws MessagingException { return (Message) createInOnlyExchange().getInMessage(); }
/** * Creates a new InOnly exchange for the given service, interface and/or operation (any of which can be null). */ public InOnly createInOnlyExchange(QName service, QName interfaceName, QName operation) throws MessagingException { MessageExchangeFactory factory = null; if (service != null) { factory = getDeliveryChannel().createExchangeFactoryForService(service); } else if (interfaceName != null) { factory = getDeliveryChannel().createExchangeFactory(interfaceName); } else { factory = getExchangeFactory(); } InOnly outExchange = factory.createInOnlyExchange(); if (service != null) { outExchange.setService(service); } if (interfaceName != null) { outExchange.setInterfaceName(interfaceName); } if (operation != null) { outExchange.setOperation(operation); } return outExchange; }
public void run() { try { boolean sendOk = _ode.getChannel().sendSync(inonly, _responseTimeout); if (!sendOk) { __log.warn("Timeout while sending message for JBI message exchange: " + inonly.getExchangeId()); } onJbiMessageExchange(inonly); } catch (MessagingException e) { String errmsg = "Error sending request-only message to JBI for ODE mex " + odeMex; __log.error(errmsg, e); } } });
private void sendToListenerAndTarget(MessageExchange source, MessageExchange dest, ExchangeTarget listener, String message, boolean copy) throws Exception { if (listener != null) { NormalizedMessage msg = MessageUtil.copy(source.getMessage(message)); InOnly lme = getExchangeFactory().createInOnlyExchange(); if (store.hasFeature(Store.CLUSTERED)) { lme.setProperty(JbiConstants.STATELESS_CONSUMER, Boolean.TRUE); } listener.configureTarget(lme, getContext()); MessageUtil.transferToIn(msg, lme); send(lme); MessageUtil.transferTo(msg, dest, message); if (copy) { copyExchangeProperties(dest, "in", message); } send(dest); } else { MessageUtil.transferTo(source, dest, message); if (copy) { copyExchangeProperties(dest, "in", message); } send(dest); } }