public DeliveryChannel getDeliveryChannel() throws MessagingException { if (channel == null) { channel = context.getDeliveryChannel(); } return channel; }
public EndpointDeliveryChannel(ComponentContext context) throws MessagingException { this.endpoint = null; this.channel = context.getDeliveryChannel(); }
public DeliveryChannel getDeliveryChannel() throws MessagingException { return getContext().getDeliveryChannel(); }
public void run() { while (running) { try { DeliveryChannel deliveryChannel = context.getDeliveryChannel(); LOGGER.info("about to do an accept on deliveryChannel: {}", deliveryChannel); MessageExchange messageExchange = deliveryChannel.accept(); LOGGER.info("received me: {}", messageExchange); onMessageExchange(messageExchange); } catch (MessagingException e) { LOGGER.error("Failed to process inbound messages: {}", e.getMessage(), e); } } }
public AbstractJmsProcessor(JmsEndpoint endpoint) throws Exception { this.endpoint = endpoint; this.soapHelper = new SoapHelper(endpoint); this.context = new EndpointComponentContext(endpoint); this.channel = context.getDeliveryChannel(); }
public synchronized void activate() throws Exception { context = new EndpointComponentContext(this); channel = context.getDeliveryChannel(); exchangeFactory = channel.createExchangeFactory(); }
/** * Called when the Component is initialized * * @param cc * @throws JBIException */ public void init(ComponentContext cc) throws JBIException { this.context = cc; this.channel = this.context.getDeliveryChannel(); init(); if (service != null && endpoint != null) { serviceEndpoint = context.activateEndpoint(service, endpoint); } }
public EndpointDeliveryChannel(Endpoint endpoint) throws MessagingException { this.endpoint = endpoint; this.channel = endpoint.getServiceUnit().getComponent().getComponentContext().getDeliveryChannel(); }
public void init() throws Exception { channel = endpoint.getServiceUnit().getComponent().getComponentContext().getDeliveryChannel(); }
public MessageExchange createExchange(HttpServletRequest request, ComponentContext context) throws Exception { MessageExchange me = context.getDeliveryChannel().createExchangeFactory().createExchange(getDefaultMep()); NormalizedMessage in = me.createMessage(); in.setContent(new StreamSource(getRequestEncodingStream(request.getHeader(HttpHeaders.CONTENT_ENCODING), request.getInputStream()))); me.setMessage(in, "in"); return me; }
public void init() throws Exception { String url = endpoint.getLocationURI(); context = new EndpointComponentContext(endpoint); channel = context.getDeliveryChannel(); httpContext = getServerManager().createContext(url, this); }
private final void pushMessageInDeliveryChannel(Message message) { AbstractWrappedToComponentMessage wrappedMessage = (AbstractWrappedToComponentMessage) message; try { MessageExchange msgExchange = wrappedMessage.getMessageExchange(); ((MockDeliveryChannel) this.component.getContext().getDeliveryChannel()).enqueueIncomingMessage(msgExchange); } catch (MessagingException e) { throw new UncheckedException("Impossible to push a message", e); } }
public void onMessageExchange(MessageExchange exchange) throws MessagingException { NormalizedMessage inMessage = exchange.getMessage("in"); messageList.addMessage(inMessage); exchange.setStatus(ExchangeStatus.DONE); context.getDeliveryChannel().send(exchange); }
@Override public Message pollRequestFromConsumer() { try { MessageExchange msgExchange = ((MockDeliveryChannel) this.component.getContext() .getDeliveryChannel()).dequeueRequestToServer(); return new WrappedRequestFromConsumerMessage(msgExchange); } catch (MessagingException e) { throw new UncheckedException("Impossible to poll request to provider message", e); } } }
public DSBServiceServerImpl(ComponentContext componentContext) { this.componentContext = componentContext; try { this.channel = this.componentContext.getDeliveryChannel(); } catch (MessagingException e) { e.printStackTrace(); } try { this.logger = this.componentContext.getLogger("", null); } catch (MissingResourceException e) { e.printStackTrace(); } catch (JBIException e) { e.printStackTrace(); } }
public MessageExchange createExchange(HttpServletRequest request, ComponentContext context) throws Exception { MessageExchange me = context.getDeliveryChannel().createExchangeFactory().createExchange(getDefaultMep()); NormalizedMessage in = me.createMessage(); in.setContent(marshal(request.getInputStream())); me.setMessage(in, "in"); return me; }
public void start() throws Exception { InitialContext ctx = getInitialContext(); connectionFactory = getConnectionFactory(ctx); channel = endpoint.getServiceUnit().getComponent().getComponentContext().getDeliveryChannel(); destination = endpoint.getDestination(); if (destination == null) { if (endpoint.getJndiDestinationName() != null) { destination = (Destination) ctx.lookup(endpoint.getJndiDestinationName()); } else if (endpoint.getJmsProviderDestinationName() == null) { throw new IllegalStateException("No destination provided"); } } }
@Override public Message pollResponseFromProvider() { try { MessageExchange msgExchange = ((MockDeliveryChannel) this.component.getContext() .getDeliveryChannel()).dequeueResponseToClient(); assert !MEPConstants.IN_ONLY_PATTERN.equals(msgExchange.getPattern()) : "Polling response from provider while processing an in only exchange is meaningless."; return new WrappedResponseFromProviderMessage(msgExchange); } catch (MessagingException e) { throw new UncheckedException("Impossible to poll response to consumer message", e); } }
public MessageExchange createExchange(JmsContext jmsContext, ComponentContext jbiContext) throws Exception { Context ctx = (Context) jmsContext; MessageExchange exchange = jbiContext.getDeliveryChannel().createExchangeFactory().createExchange(mep); NormalizedMessage inMessage = exchange.createMessage(); populateMessage(ctx.message, inMessage); if (isCopyProperties()) { copyPropertiesFromJMS(ctx.message, inMessage); } exchange.setMessage(inMessage, "in"); return exchange; }
public void handleMessage(Message message) throws Fault { MessageExchange exchange = message .getContent(MessageExchange.class); try { if (message.get("needSetDone") != null && message.get("needSetDone").equals(Boolean.TRUE) && exchange.getStatus() == ExchangeStatus.ACTIVE) { exchange.setStatus(ExchangeStatus.DONE); message.getExchange().get(ComponentContext.class) .getDeliveryChannel().send(exchange); } } catch (Exception e) { throw new Fault(e); } }