public byte[] invokeBytes(String address, String transport, byte[] message) throws Exception { EndpointInfo ei = new EndpointInfo(null, "http://schemas.xmlsoap.org/soap/http"); ei.setAddress(address); ConduitInitiatorManager conduitMgr = getBus().getExtension(ConduitInitiatorManager.class); ConduitInitiator conduitInit = conduitMgr.getConduitInitiator(transport); Conduit conduit = conduitInit.getConduit(ei); TestMessageObserver obs = new TestMessageObserver(); conduit.setMessageObserver(obs); Message m = new MessageImpl(); conduit.prepare(m); OutputStream os = m.getContent(OutputStream.class); os.write(message); // TODO: shouldn't have to do this. IO caching needs cleaning // up or possibly removal... os.flush(); os.close(); return obs.getResponseStream().toByteArray(); }
public void onMessage(Message message) { LoadingByteArrayOutputStream bout = new LoadingByteArrayOutputStream(); try { IOUtils.copy(message.getContent(InputStream.class), bout); message.getExchange().put(InputStream.class, bout.createInputStream()); c.close(message); } catch (IOException e) { //ignore } } });
/** * Retrieve To EPR from the context. * * @param conduit the Conduit if available * @param message the current message * @return the retrieved EPR */ public static EndpointReferenceType retrieveTo(Conduit conduit, Message message) { EndpointReferenceType to = null; if (conduit != null) { to = conduit.getTarget(); } else { to = (EndpointReferenceType)message.get(TO_PROPERTY); } return to; }
public void handleMessage(Message message) throws Fault { if (message.getExchange().isOneWay() && !isRequestor(message) && message.get(OneWayProcessorInterceptor.class) == null && message.getExchange().get(Executor.class) == null) { partial.remove(Message.CONTENT_TYPE); partial.setExchange(message.getExchange()); Conduit conduit = message.getExchange().getDestination() .getBackChannel(message, null, null); if (conduit != null) { conduit.prepare(partial); conduit.close(partial); message.getExchange().setInMessage(message); final Object lock = new Object(); synchronized (lock) { message.getExchange().get(Bus.class).getExtension(WorkQueueManager.class) .getAutomaticWorkQueue().execute(new Runnable() { public void run() {
&& !DEFAULT_URI_RESOLVER_HANDLES.contains(base.getScheme())) { try { ConduitInitiatorManager mgr = bus.getExtension(ConduitInitiatorManager.class); ConduitInitiator ci = null; if ("http".equals(base.getScheme()) || "https".equals(base.getScheme())) { ci = mgr.getConduitInitiator("http://cxf.apache.org/transports/http"); ci = mgr.getConduitInitiatorForUri(base.toString()); EndpointInfo info = new EndpointInfo(); message.put(Message.HTTP_REQUEST_METHOD, "GET"); c.setMessageObserver(new MessageObserver() { public void onMessage(Message message) { LoadingByteArrayOutputStream bout = new LoadingByteArrayOutputStream(); c.prepare(message); c.close(message); InputStream ins = exch.get(InputStream.class); resourceOpened.addElement(ins); InputSource src = new InputSource(ins); String u = (String)message.get("http.retransmit.url"); if (u == null) { u = base.toString();
ei.setAddress((String) newDestinationURI); message.put(Message.ENDPOINT_ADDRESS, newDestinationURI); message.setExchange(cxfExchange); cxfExchange.setOutMessage(message); cxfExchange.put(CxfBcProvider.class, this); if (ei.getBinding().getOperations().size() == 1) { boi = ei.getBinding().getOperations().iterator().next(); } else { boi = findOperation(nm, message, boi, exchange); cxfExchange.put(Service.class, cxfService); cxfExchange.put(Bus.class, getBus()); PhaseManager pm = getBus().getExtension(PhaseManager.class); message.setContent(Source.class, nm.getContent()); conduit.prepare(message); message.put(org.apache.cxf.message.Message.REQUESTOR_ROLE, true); conduit.close(message); } catch (Exception e) { if (!(exchange instanceof InOnly)) {
ad.setValue(StringUtils.isEmpty(basePath) ? add : basePath); epr.setAddress(ad); c = conduitInitiator.getConduit(ei, epr); exchange.get(MessageObserver.class); if (observer != null) { c.setMessageObserver(observer); } else { getLogger().warning("MessageObserver not found"); + ei.getAddress()); if (c != null && c.getTarget() != null && c.getTarget().getAddress() != null) { replaceEndpointAddressPropertyIfNeeded(message, c.getTarget().getAddress().getValue(), c);
protected Conduit getNextConduit(Message message) { Conduit answer = null; Exchange exchange = message.getExchange(); EndpointInfo ei = endpoint.getEndpointInfo(); String address = loadBalanceStrategy.getNextAlternateAddress(); if (overrideAddress(message)) { message.put(Message.ENDPOINT_ADDRESS, address); ConduitInitiatorManager conduitInitiatorMgr = exchange.getBus() .getExtension(ConduitInitiatorManager.class); if (conduitInitiatorMgr != null) { ConduitInitiator conduitInitiator = conduitInitiatorMgr.getConduitInitiatorForUri(address); if (conduitInitiator != null) { EndpointReferenceType epr = new EndpointReferenceType(); ad.setValue(address); epr.setAddress(ad); answer = conduitInitiator.getConduit(ei, epr, exchange.getBus()); exchange.get(MessageObserver.class); if (observer != null) { answer.setMessageObserver(observer); } else { getLogger().warning("MessageObserver not found"); + ei.getAddress());
Conduit c = message.get(Conduit.class); if (c == null && message.getExchange() != null && message.getExchange().getOutMessage() != null && message.getExchange().getOutMessage() != message) { c = message.getExchange().getOutMessage().get(Conduit.class); if (c2.getTarget() == null || c2.getTarget().getAddress() == null || c2.getTarget().getAddress().getValue() == null) { continue; String conduitAddress = c2.getTarget().getAddress().getValue(); String actualAddress = ei.getAddress(); String messageAddress = (String)message.get(Message.ENDPOINT_ADDRESS); if (c2.getTarget() == null || c2.getTarget().getAddress() == null || c2.getTarget().getAddress().getValue() == null) { return c2;
private void sendErrorResponse(Message message, int responseCode) { Message outMessage = getOutMessage(message); outMessage.put(Message.RESPONSE_CODE, responseCode); // Set the response headers Map responseHeaders = (Map) message.get(Message.PROTOCOL_HEADERS); if (responseHeaders != null) { responseHeaders.put("WWW-Authenticate", Arrays.asList("Basic realm=\"" + realm + "\"")); responseHeaders.put("Content-Length", Arrays.asList("0")); } message.getInterceptorChain().abort(); try { // getConduit(message).prepare(outMessage); message.getExchange().getConduit(message).prepare(outMessage); // TEST ME OutputStream os = outMessage.getContent(OutputStream.class); String errmsg = "Error " + responseCode + ": "; os.write(errmsg.getBytes()); LOGGER.info("Sending error " + responseCode); close(outMessage); } catch (IOException e) { LOGGER.warn(e.getMessage(), e); } }
public void handleMessage(Message message) throws Fault { String method = (String)message.get(Message.HTTP_REQUEST_METHOD); String query = (String)message.get(Message.QUERY_STRING); if (!"GET".equals(method) || StringUtils.isEmpty(query)) { return; } String baseUri = (String)message.get(Message.REQUEST_URL); URI uri = null; try { uri = URI.create(baseUri); } catch (IllegalArgumentException iae) { //invalid URI, ignore and continue return; } Map<String, String> map = UrlUtils.parseQueryString(query); if (isRecognizedQuery(map, uri, message.getExchange().getEndpoint().getEndpointInfo())) { try { Conduit c = message.getExchange().getDestination().getBackChannel(message); Message mout = new MessageImpl(); mout.setExchange(message.getExchange()); message.getExchange().setOutMessage(mout); mout.put(Message.CONTENT_TYPE, "application/javascript;charset=UTF-8"); c.prepare(mout); OutputStream os = mout.getContent(OutputStream.class); writeResponse(uri, map, os, message.getExchange().getEndpoint()); } catch (IOException ioe) { throw new Fault(ioe); } } }
public Conduit getBackChannel(Message inMessage) throws IOException { Bus bus = inMessage.getExchange().getBus(); //this is a response targeting a decoupled endpoint. Treat it as a oneway so //we don't wait for a response. inMessage.getExchange().setOneWay(true); ConduitInitiator conduitInitiator = bus.getExtension(ConduitInitiatorManager.class) .getConduitInitiatorForUri(reference.getAddress().getValue()); if (conduitInitiator != null) { Conduit c = conduitInitiator.getConduit(ei, reference, bus); //ensure decoupled back channel input stream is closed c.setMessageObserver(new MessageObserver() { public void onMessage(Message m) { InputStream is = m.getContent(InputStream.class); if (is != null) { try { is.close(); } catch (Exception e) { //ignore } } } }); return c; } return null; } public MessageObserver getMessageObserver() {
Conduit c = findCompatibleConduit(message); if (c == null) { Exchange exchange = message.getExchange(); EndpointInfo ei = endpoint.getEndpointInfo(); String transportID = ei.getTransportId(); try { ConduitInitiatorManager conduitInitiatorMgr = exchange.getBus() .getExtension(ConduitInitiatorManager.class); if (conduitInitiatorMgr != null) { ConduitInitiator conduitInitiator = conduitInitiatorMgr.getConduitInitiator(transportID); if (conduitInitiator != null) { c = createConduit(message, exchange, conduitInitiator); } else { getLogger().warning("ConduitInitiator not found: " + ei.getAddress()); if (c != null && c.getTarget() != null && c.getTarget().getAddress() != null) { replaceEndpointAddressPropertyIfNeeded(message, c.getTarget().getAddress().getValue(), c); message.resetContextCache(); message.put(Conduit.class, c); return c;
/** * Called on completion of the MEP for which the Conduit was required. * * @param exchange represents the completed MEP */ public void complete(Exchange exchange) { // Clients expecting explicit InputStream responses // will need to keep low level conduits operating on InputStreams open // and will be responsible for closing the streams if (PropertyUtils.isTrue(exchange.get(KEEP_CONDUIT_ALIVE))) { return; } try { if (exchange.getInMessage() != null) { Conduit c = exchange.getOutMessage().get(Conduit.class); if (c == null) { getSelectedConduit(exchange.getInMessage()).close(exchange.getInMessage()); } else { c.close(exchange.getInMessage()); } } } catch (IOException e) { //IGNORE } } /**
EndpointInfo info = new EndpointInfo(); info.setAddress(address); Message outMessage = new MessageImpl(); Exchange exch = new ExchangeImpl(); outMessage.setExchange(exch); final Conduit c = ci.getConduit(info, BusFactory.getThreadDefaultBus(false)); //TODO verify bus outMessage.put(Message.HTTP_REQUEST_METHOD, "GET"); c.prepare(outMessage); c.setMessageObserver(createMessageObserver(c)); c.close(outMessage);
@Override public void handleMessage(Message message) throws Fault { TimeMeasure timeMeasure = message.getExchange().get(TimeMeasure.class); if (timeMeasure == null) { if (!this.errorLogged) { LOG.warn("Invalid setup - no TimeMeasure present!"); this.errorLogged = true; } return; } Throwable exception = message.getContent(Exception.class); if (exception == null) { timeMeasure.succeed(); } Conduit conduit = message.get(Conduit.class); EndpointReferenceType target = conduit.getTarget(); String url = target.getAddress().getValue(); timeMeasure.log(LOG, url); }
public Conduit getBackChannel(Message inMessage, Message partialResponse, EndpointReferenceType address) throws IOException { Bus bus = inMessage.getExchange().get(Bus.class); //this is a response targeting a decoupled endpoint. Treat it as a oneway so //we don't wait for a response. inMessage.getExchange().setOneWay(true); ConduitInitiator conduitInitiator = bus.getExtension(ConduitInitiatorManager.class) .getConduitInitiatorForUri(reference.getAddress().getValue()); if (conduitInitiator != null) { Conduit c = conduitInitiator.getConduit(ei, reference); //ensure decoupled back channel input stream is closed c.setMessageObserver(new MessageObserver() { public void onMessage(Message m) { InputStream is = m.getContent(InputStream.class); if (is != null) { try { is.close(); } catch (Exception e) { //ignore } } } }); return c; } return null; } public MessageObserver getMessageObserver() {
protected boolean replaceEndpointAddressPropertyIfNeeded(Message message, String endpointAddress, Conduit cond) { String requestURI = (String)message.get(Message.REQUEST_URI); if (requestURI != null && endpointAddress != null && !requestURI.equals(endpointAddress)) { String basePath = (String)message.get(Message.BASE_PATH); if (basePath != null && requestURI.startsWith(basePath)) { String pathInfo = requestURI.substring(basePath.length()); message.put(Message.BASE_PATH, endpointAddress); final String slash = "/"; boolean startsWithSlash = pathInfo.startsWith(slash); if (endpointAddress.endsWith(slash)) { endpointAddress = endpointAddress + (startsWithSlash ? pathInfo.substring(1) : pathInfo); } else { endpointAddress = endpointAddress + (startsWithSlash ? pathInfo : (slash + pathInfo)); } message.put(Message.ENDPOINT_ADDRESS, endpointAddress); message.put(Message.REQUEST_URI, endpointAddress); Exchange exchange = message.getExchange(); String key = String.valueOf(System.identityHashCode(exchange)); InvocationContext invocation = getInvocationContext(key); if (invocation != null) { overrideAddressProperty(invocation.getContext(), cond.getTarget().getAddress().getValue()); } return true; } } return false; }
String add = (String)message.get(Message.ENDPOINT_ADDRESS); String basePath = (String)message.get(Message.BASE_PATH); if (StringUtils.isEmpty(add) || add.equals(ei.getAddress())) { c = conduitInitiator.getConduit(ei, exchange.getBus()); replaceEndpointAddressPropertyIfNeeded(message, add, c); } else { ad.setValue(StringUtils.isEmpty(basePath) ? add : basePath); epr.setAddress(ad); c = conduitInitiator.getConduit(ei, epr, exchange.getBus()); exchange.get(MessageObserver.class); if (observer != null) { c.setMessageObserver(observer); } else { getLogger().warning("MessageObserver not found");
boolean isFault) { if (isRequestor) { Exchange exchange = message.getExchange(); boolean isOneway = exchange.isOneWay(); boolean isOutbound = ContextUtils.isOutbound(message); conduit = ContextUtils.getConduit(null, message); String s = (String)message.get(Message.ENDPOINT_ADDRESS); EndpointReferenceType reference = conduit != null ? conduit.getTarget() : ContextUtils.getNoneEndpointReference(); if (conduit != null && !StringUtils.isEmpty(s) && !Boolean.TRUE.equals(message.get(Message.PARTIAL_RESPONSE_MESSAGE))) { String inMessageID = inMAPs.getMessageID().getValue(); maps.setRelatesTo(ContextUtils.getRelatesTo(inMessageID)); && !ContextUtils.isGenericAddress(inMAPs.getFaultTo())) { Message m = message.getExchange().getInFaultMessage(); if (m == null) { m = message; Destination destination = InternalContextUtils.createDecoupledDestination(m.getExchange(), inMAPs.getFaultTo()); m.getExchange().setDestination(destination);