示例#1
1
    /**
     * Called for an incoming message.
     *
     * @param inMessage
     */
    public void onMessage(Message inMessage) {
      // disposable exchange, swapped with real Exchange on correlation
      inMessage.setExchange(new ExchangeImpl());
      inMessage.getExchange().put(Bus.class, bus);
      inMessage.put(Message.DECOUPLED_CHANNEL_MESSAGE, Boolean.TRUE);
      inMessage.put(Message.RESPONSE_CODE, HttpURLConnection.HTTP_OK);

      // remove server-specific properties
      // inMessage.remove(AbstractHTTPDestination.HTTP_REQUEST);
      // inMessage.remove(AbstractHTTPDestination.HTTP_RESPONSE);
      inMessage.remove(Message.ASYNC_POST_RESPONSE_DISPATCH);
      updateResponseCode(inMessage);

      // cache this inputstream since it's defer to use in case of async
      try {
        InputStream in = inMessage.getContent(InputStream.class);
        if (in != null) {
          CachedOutputStream cos = new CachedOutputStream();
          IOUtils.copy(in, cos);
          inMessage.setContent(InputStream.class, cos.getInputStream());
        }
        observer.onMessage(inMessage);
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
示例#2
0
  private Message mockMessage(
      String baseAddress, String pathInfo, String query, List<ClassResourceInfo> cris)
      throws Exception {
    Message m = new MessageImpl();
    Exchange e = new ExchangeImpl();
    e.put(Service.class, new JAXRSServiceImpl(cris));
    m.setExchange(e);
    control.reset();
    ServletDestination d = control.createMock(ServletDestination.class);
    EndpointInfo epr = new EndpointInfo();
    epr.setAddress(baseAddress);
    d.getEndpointInfo();
    EasyMock.expectLastCall().andReturn(epr).anyTimes();

    Endpoint endpoint = new EndpointImpl(null, null, epr);
    e.put(Endpoint.class, endpoint);
    endpoint.put(ServerProviderFactory.class.getName(), ServerProviderFactory.getInstance());
    e.setDestination(d);
    BindingInfo bi = control.createMock(BindingInfo.class);
    epr.setBinding(bi);
    bi.getProperties();
    EasyMock.expectLastCall().andReturn(Collections.emptyMap()).anyTimes();
    m.put(Message.REQUEST_URI, pathInfo);
    m.put(Message.QUERY_STRING, query);
    m.put(Message.HTTP_REQUEST_METHOD, "GET");
    control.replay();
    return m;
  }
示例#3
0
  protected void invokeInboundChain(Exchange ex, Endpoint ep) {
    Message m = getInBoundMessage(ex);
    Message inMsg = ep.getBinding().createMessage();
    MessageImpl.copyContent(m, inMsg);

    // Copy Response Context to Client inBound Message
    // TODO a Context Filter Strategy required.
    inMsg.putAll(m);

    inMsg.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
    inMsg.put(Message.INBOUND_MESSAGE, Boolean.TRUE);
    inMsg.setExchange(ex);

    Exception exc = inMsg.getContent(Exception.class);
    if (exc != null) {
      ex.setInFaultMessage(inMsg);
      ColocInFaultObserver observer = new ColocInFaultObserver(bus);
      observer.onMessage(inMsg);
    } else {
      // Handle Response
      ex.setInMessage(inMsg);
      PhaseManager pm = bus.getExtension(PhaseManager.class);
      SortedSet<Phase> phases = new TreeSet<Phase>(pm.getInPhases());
      ColocUtil.setPhases(phases, Phase.USER_LOGICAL, Phase.PRE_INVOKE);

      InterceptorChain chain = ColocUtil.getInInterceptorChain(ex, phases);
      inMsg.setInterceptorChain(chain);
      chain.doIntercept(inMsg);
    }
    ex.put(ClientImpl.FINISHED, Boolean.TRUE);
  }
  /**
   * Cache HTTP headers in message.
   *
   * @param message the current message
   */
  protected void setHeaders(Message message) {
    Map<String, List<String>> requestHeaders = new HashMap<String, List<String>>();
    copyRequestHeaders(message, requestHeaders);
    message.put(Message.PROTOCOL_HEADERS, requestHeaders);

    if (requestHeaders.containsKey("Authorization")) {
      List<String> authorizationLines = requestHeaders.get("Authorization");
      String credentials = authorizationLines.get(0);
      String authType = credentials.split(" ")[0];
      if ("Basic".equals(authType)) {
        String authEncoded = credentials.split(" ")[1];
        try {
          String authDecoded = new String(Base64Utility.decode(authEncoded));
          String authInfo[] = authDecoded.split(":");
          String username = (authInfo.length > 0) ? authInfo[0] : "";
          // Below line for systems that blank out password after authentication;
          // see CXF-1495 for more info
          String password = (authInfo.length > 1) ? authInfo[1] : "";
          AuthorizationPolicy policy = new AuthorizationPolicy();
          policy.setUserName(username);
          policy.setPassword(password);

          message.put(AuthorizationPolicy.class, policy);
        } catch (Base64Exception ex) {
          // ignore, we'll leave things alone.  They can try decoding it themselves
        }
      }
    }

    if (LOG.isLoggable(Level.FINE)) {
      LOG.log(Level.FINE, "Request Headers: " + requestHeaders.toString());
    }
  }
 /**
  * Mark message as a partial message.
  *
  * @param partialResponse the partial response message
  * @param the decoupled target
  * @return true iff partial responses are supported
  */
 protected final boolean markPartialResponse(
     Message partialResponse, EndpointReferenceType decoupledTarget) {
   // setup the outbound message to for 202 Accepted
   partialResponse.put(Message.RESPONSE_CODE, HttpURLConnection.HTTP_ACCEPTED);
   partialResponse.getExchange().put(EndpointReferenceType.class, decoupledTarget);
   partialResponse.put(PARTIAL_RESPONSE, Boolean.TRUE);
   return true;
 }
示例#6
0
  public void handleMessage(Message message) throws Fault {
    if (bus == null) {
      bus = message.getExchange().getBus();
      if (bus == null) {
        bus = BusFactory.getDefaultBus(false);
      }
      if (bus == null) {
        throw new Fault(new org.apache.cxf.common.i18n.Message("BUS_NOT_FOUND", BUNDLE));
      }
    }

    ServerRegistry registry = bus.getExtension(ServerRegistry.class);

    if (registry == null) {
      throw new Fault(new org.apache.cxf.common.i18n.Message("SERVER_REGISTRY_NOT_FOUND", BUNDLE));
    }

    Exchange exchange = message.getExchange();
    Endpoint senderEndpoint = exchange.getEndpoint();

    if (senderEndpoint == null) {
      throw new Fault(new org.apache.cxf.common.i18n.Message("ENDPOINT_NOT_FOUND", BUNDLE));
    }

    BindingOperationInfo boi = exchange.getBindingOperationInfo();

    if (boi == null) {
      throw new Fault(new org.apache.cxf.common.i18n.Message("OPERATIONINFO_NOT_FOUND", BUNDLE));
    }

    Server srv = isColocated(registry.getServers(), senderEndpoint, boi);

    if (srv != null) {
      if (LOG.isLoggable(Level.FINE)) {
        LOG.fine("Operation:" + boi.getName() + " dispatched as colocated call.");
      }

      InterceptorChain outChain = message.getInterceptorChain();
      outChain.abort();
      exchange.put(Bus.class, bus);
      message.put(COLOCATED, Boolean.TRUE);
      message.put(Message.WSDL_OPERATION, boi.getName());
      message.put(Message.WSDL_INTERFACE, boi.getBinding().getInterface().getName());
      invokeColocObserver(message, srv.getEndpoint());
      if (!exchange.isOneWay()) {
        invokeInboundChain(exchange, senderEndpoint);
      }
    } else {
      if (LOG.isLoggable(Level.FINE)) {
        LOG.fine("Operation:" + boi.getName() + " dispatched as remote call.");
      }

      message.put(COLOCATED, Boolean.FALSE);
    }
  }
示例#7
0
  protected Message createMessage(
      Object body,
      String httpMethod,
      MultivaluedMap<String, String> headers,
      URI currentURI,
      Exchange exchange,
      Map<String, Object> invocationContext,
      boolean proxy) {
    Message m = cfg.getConduitSelector().getEndpoint().getBinding().createMessage();
    m.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
    m.put(Message.INBOUND_MESSAGE, Boolean.FALSE);

    m.put(Message.HTTP_REQUEST_METHOD, httpMethod);
    m.put(Message.PROTOCOL_HEADERS, headers);
    if (currentURI.isAbsolute() && currentURI.getScheme().startsWith(HTTP_SCHEME)) {
      m.put(Message.ENDPOINT_ADDRESS, currentURI.toString());
    } else {
      m.put(Message.ENDPOINT_ADDRESS, state.getBaseURI().toString());
    }

    Object requestURIProperty = cfg.getRequestContext().get(Message.REQUEST_URI);
    if (requestURIProperty == null) {
      m.put(Message.REQUEST_URI, currentURI.toString());
    } else {
      m.put(Message.REQUEST_URI, requestURIProperty.toString());
    }

    m.put(Message.CONTENT_TYPE, headers.getFirst(HttpHeaders.CONTENT_TYPE));

    body = checkIfBodyEmpty(body);
    setEmptyRequestPropertyIfNeeded(m, body);

    m.setContent(List.class, getContentsList(body));

    m.put(URITemplate.TEMPLATE_PARAMETERS, getState().getTemplates());

    PhaseInterceptorChain chain = setupOutInterceptorChain(cfg);
    chain.setFaultObserver(setupInFaultObserver(cfg));
    m.setInterceptorChain(chain);

    exchange = createExchange(m, exchange);
    exchange.put(Message.REST_MESSAGE, Boolean.TRUE);
    exchange.setOneWay("true".equals(headers.getFirst(Message.ONE_WAY_REQUEST)));
    exchange.put(Retryable.class, new RetryableImpl());

    // context
    setContexts(m, exchange, invocationContext, proxy);

    // setup conduit selector
    prepareConduitSelector(m, currentURI, proxy);

    return m;
  }
示例#8
0
 private void writeResponseErrorMessage(
     Message message, OutputStream out, String name, Class<?> cls, MediaType ct) {
   message.put(Message.CONTENT_TYPE, "text/plain");
   message.put(Message.RESPONSE_CODE, 500);
   try {
     String errorMessage = JAXRSUtils.logMessageHandlerProblem(name, cls, ct);
     if (out != null) {
       out.write(errorMessage.getBytes(StandardCharsets.UTF_8));
     }
   } catch (IOException another) {
     // ignore
   }
 }
示例#9
0
  protected void handle(Message message) throws SequenceFault, RMException {
    LOG.entering(getClass().getName(), "handleMessage");
    // This message capturing mechanism will need to be changed at some point.
    // Until then, we keep this interceptor here and utilize the robust
    // option to avoid the unnecessary message capturing/caching.
    if (!MessageUtils.isTrue(message.getContextualProperty(Message.ROBUST_ONEWAY))) {
      InputStream is = message.getContent(InputStream.class);
      if (is != null) {
        CachedOutputStream saved = new CachedOutputStream();
        try {
          IOUtils.copy(is, saved);

          saved.flush();
          is.close();
          saved.lockOutputStream();

          LOG.fine("Capturing the original RM message");
          RewindableInputStream ris = RewindableInputStream.makeRewindable(saved.getInputStream());
          message.setContent(InputStream.class, ris);
          message.put(RMMessageConstants.SAVED_CONTENT, ris);
        } catch (Exception e) {
          throw new Fault(e);
        }
      }
    }
  }
示例#10
0
  public AsyncResponseImpl(Message inMessage) {
    inMessage.put(AsyncResponse.class, this);
    inMessage.getExchange().put(ContinuationCallback.class, this);
    this.inMessage = inMessage;

    initContinuation();
  }
 protected void transformXWriter(Message message, XMLStreamWriter xWriter) {
   CachedWriter writer = new CachedWriter();
   XMLStreamWriter delegate = StaxUtils.createXMLStreamWriter(writer);
   XSLTStreamWriter wrapper = new XSLTStreamWriter(getXSLTTemplate(), writer, delegate, xWriter);
   message.setContent(XMLStreamWriter.class, wrapper);
   message.put(AbstractOutDatabindingInterceptor.DISABLE_OUTPUTSTREAM_OPTIMIZATION, Boolean.TRUE);
 }
示例#12
0
 public void handleMessage(Message message) throws Fault {
   final OutputStream os = message.getContent(OutputStream.class);
   final Writer iowriter = message.getContent(Writer.class);
   if (os == null && iowriter == null) {
     return;
   }
   Logger logger = getMessageLogger(message);
   if (logger.isLoggable(Level.INFO) || writer != null) {
     // Write the output while caching it for the log message
     boolean hasLogged = message.containsKey(LOG_SETUP);
     if (!hasLogged) {
       message.put(LOG_SETUP, Boolean.TRUE);
       if (os != null) {
         final CacheAndWriteOutputStream newOut = new CacheAndWriteOutputStream(os);
         if (threshold > 0) {
           newOut.setThreshold(threshold);
         }
         if (limit > 0) {
           newOut.setCacheLimit(limit);
         }
         message.setContent(OutputStream.class, newOut);
         newOut.registerCallback(new LoggingCallback(logger, message, os));
       } else {
         message.setContent(Writer.class, new LogWriter(logger, message, iowriter));
       }
     }
   }
 }
示例#13
0
  private void recoverSourceSequence(
      Endpoint endpoint, Conduit conduit, Source s, SourceSequence ss) {
    Collection<RMMessage> ms = store.getMessages(ss.getIdentifier(), true);
    if (null == ms || 0 == ms.size()) {
      store.removeSourceSequence(ss.getIdentifier());
      return;
    }
    LOG.log(Level.FINE, "Number of messages in sequence: {0}", ms.size());

    s.addSequence(ss, false);
    // choosing an arbitrary valid source sequence as the current source sequence
    if (s.getAssociatedSequence(null) == null && !ss.isExpired() && !ss.isLastMessage()) {
      s.setCurrent(ss);
    }
    for (RMMessage m : ms) {

      Message message = new MessageImpl();
      Exchange exchange = new ExchangeImpl();
      message.setExchange(exchange);
      exchange.setOutMessage(message);
      if (null != conduit) {
        exchange.setConduit(conduit);
        message.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
      }
      exchange.put(Endpoint.class, endpoint);
      exchange.put(Service.class, endpoint.getService());
      exchange.put(Binding.class, endpoint.getBinding());
      exchange.put(Bus.class, bus);

      SequenceType st = new SequenceType();
      st.setIdentifier(ss.getIdentifier());
      st.setMessageNumber(m.getMessageNumber());
      RMProperties rmps = new RMProperties();
      rmps.setSequence(st);
      rmps.exposeAs(ss.getProtocol().getWSRMNamespace());
      if (ss.isLastMessage() && ss.getCurrentMessageNr() == m.getMessageNumber()) {
        CloseSequenceType close = new CloseSequenceType();
        close.setIdentifier(ss.getIdentifier());
        rmps.setCloseSequence(close);
      }
      RMContextUtils.storeRMProperties(message, rmps, true);
      if (null == conduit) {
        String to = m.getTo();
        AddressingProperties maps = new AddressingProperties();
        maps.setTo(RMUtils.createReference(to));
        RMContextUtils.storeMAPs(maps, message, true, false);
      }

      try {
        // RMMessage is stored in a serialized way, therefore
        // RMMessage content must be splitted into soap root message
        // and attachments
        PersistenceUtils.decodeRMContent(m, message);
        RMContextUtils.setProtocolVariation(message, ss.getProtocol());
        retransmissionQueue.addUnacknowledged(message);
      } catch (IOException e) {
        LOG.log(Level.SEVERE, "Error reading persisted message data", e);
      }
    }
  }
示例#14
0
  private void processResponse(ServerProviderFactory providerFactory, Message message) {

    if (isResponseAlreadyHandled(message)) {
      return;
    }
    MessageContentsList objs = MessageContentsList.getContentsList(message);
    if (objs == null || objs.size() == 0) {
      return;
    }

    Object responseObj = objs.get(0);

    Response response = null;
    if (responseObj instanceof Response) {
      response = (Response) responseObj;
      if (response.getStatus() == 500
          && message.getExchange().get(JAXRSUtils.EXCEPTION_FROM_MAPPER) != null) {
        message.put(Message.RESPONSE_CODE, 500);
        return;
      }
    } else {
      int status = getStatus(message, responseObj != null ? 200 : 204);
      response = JAXRSUtils.toResponseBuilder(status).entity(responseObj).build();
    }

    Exchange exchange = message.getExchange();
    OperationResourceInfo ori =
        (OperationResourceInfo) exchange.get(OperationResourceInfo.class.getName());

    serializeMessage(providerFactory, message, response, ori, true);
  }
示例#15
0
  protected void setContexts(
      Message message, Exchange exchange, Map<String, Object> context, boolean proxy) {
    Map<String, Object> reqContext = null;
    Map<String, Object> resContext = null;
    if (context == null) {
      context = new HashMap<String, Object>();
    }
    reqContext = CastUtils.cast((Map<?, ?>) context.get(REQUEST_CONTEXT));
    resContext = CastUtils.cast((Map<?, ?>) context.get(RESPONSE_CONTEXT));
    if (reqContext == null) {
      reqContext = new HashMap<String, Object>(cfg.getRequestContext());
      context.put(REQUEST_CONTEXT, reqContext);
    }
    reqContext.put(Message.PROTOCOL_HEADERS, message.get(Message.PROTOCOL_HEADERS));
    reqContext.put(Message.REQUEST_URI, message.get(Message.REQUEST_URI));
    reqContext.put(Message.ENDPOINT_ADDRESS, message.get(Message.ENDPOINT_ADDRESS));
    reqContext.put(PROXY_PROPERTY, proxy);

    if (resContext == null) {
      resContext = new HashMap<String, Object>();
      context.put(RESPONSE_CONTEXT, resContext);
    }

    message.put(Message.INVOCATION_CONTEXT, context);
    message.putAll(reqContext);
    exchange.putAll(reqContext);
  }
示例#16
0
 @Test
 public void testGetProperty() {
   Message m = new MessageImpl();
   m.put("a", "b");
   MessageContext mc = new MessageContextImpl(m);
   assertEquals("b", mc.get("a"));
   assertNull(mc.get("b"));
 }
示例#17
0
    @Override
    protected void updateResponseHeaders(Message inMessage) throws IOException {
      Headers h = new Headers(inMessage);
      String ct = getResponse().getContentType();
      inMessage.put(Message.CONTENT_TYPE, ct);

      // REVISIT if we are allowing more headers, we need to add them into the cxf's headers
      h.headerMap().put(Message.CONTENT_TYPE, Collections.singletonList(ct));
    }
 protected void updateResponseHeaders(Message message) {
   Map<String, List<String>> responseHeaders =
       CastUtils.cast((Map) message.get(Message.PROTOCOL_HEADERS));
   if (responseHeaders == null) {
     responseHeaders = new HashMap<String, List<String>>();
     message.put(Message.PROTOCOL_HEADERS, responseHeaders);
   }
   setPolicies(responseHeaders);
 }
 private Map<String, List<String>> getHeaders(Message message) {
   Map<String, List<String>> headers =
       CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS));
   if (headers == null) {
     headers = new HashMap<>();
     message.put(Message.PROTOCOL_HEADERS, headers);
   }
   return headers;
 }
示例#20
0
 public void handleMessage(Message message) throws Fault {
   String method = (String) message.get(Message.HTTP_REQUEST_METHOD);
   if (!method.equals("POST")) {
     return;
   }
   StringBuilder sb = new StringBuilder();
   sb.append("Foo");
   message.put(StringBuilder.class, sb);
 }
示例#21
0
 private void setResponseStatus(Message message, int status) {
   message.put(Message.RESPONSE_CODE, status);
   boolean responseHeadersCopied = isResponseHeadersCopied(message);
   if (responseHeadersCopied) {
     HttpServletResponse response =
         (HttpServletResponse) message.get(AbstractHTTPDestination.HTTP_RESPONSE);
     response.setStatus(status);
   }
 }
示例#22
0
 @Test
 public void testServletConfig() {
   Message m = createMessage();
   MessageContext mc = new MessageContextImpl(m);
   ServletConfig request = EasyMock.createMock(ServletConfig.class);
   m.put(AbstractHTTPDestination.HTTP_CONFIG, request);
   assertSame(request.getClass(), mc.getServletConfig().getClass());
   assertSame(request.getClass(), mc.getContext(ServletConfig.class).getClass());
 }
示例#23
0
  /**
   * This test verifies the precedence of Authorization Information. Setting authorization
   * information on the Message takes precedence over a Basic Auth Supplier with preemptive
   * UserPass, and that followed by setting it directly on the Conduit.
   */
  @Test
  public void testAuthPolicyPrecedence() throws Exception {
    Bus bus = new ExtensionManagerBus();
    EndpointInfo ei = new EndpointInfo();
    ei.setAddress("http://nowhere.com/bar/foo");
    HTTPConduit conduit = new URLConnectionHTTPConduit(bus, ei, null);
    conduit.finalizeConfig();

    conduit.getAuthorization().setUserName("Satan");
    conduit.getAuthorization().setPassword("hell");
    Message message = getNewMessage();

    // Test call
    conduit.prepare(message);

    Map<String, List<String>> headers =
        CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS));

    assertNotNull("Authorization Header should exist", headers.get("Authorization"));

    assertEquals(
        "Unexpected Authorization Token",
        "Basic " + Base64Utility.encode("Satan:hell".getBytes()),
        headers.get("Authorization").get(0));

    // Setting a Basic Auth User Pass should override
    conduit.setAuthSupplier(new TestAuthSupplier());
    message = getNewMessage();

    // Test Call
    conduit.prepare(message);

    headers = CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS));
    List<String> authorization = headers.get("Authorization");
    assertNotNull("Authorization Token must be set", authorization);
    assertEquals("Wrong Authorization Token", "myauth", authorization.get(0));

    conduit.setAuthSupplier(null);
    // Setting authorization policy on the message should override
    // conduit setting
    AuthorizationPolicy authPolicy = new AuthorizationPolicy();
    authPolicy.setUserName("Hello");
    authPolicy.setPassword("world");
    authPolicy.setAuthorizationType("Basic");
    message = getNewMessage();
    message.put(AuthorizationPolicy.class, authPolicy);

    conduit.prepare(message);

    headers = CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS));

    assertEquals(
        "Unexpected Authorization Token",
        "Basic " + Base64Utility.encode("Hello:world".getBytes()),
        headers.get("Authorization").get(0));
  }
  private Message prepareMessage(
      Class<?> cls, String methodName, org.apache.cxf.rt.security.claims.Claim... claim)
      throws Exception {
    ClaimCollection claims = new ClaimCollection();
    claims.addAll(Arrays.asList(claim));

    Set<Principal> roles =
        SAMLUtils.parseRolesFromClaims(
            claims,
            SAMLClaim.SAML_ROLE_ATTRIBUTENAME_DEFAULT,
            SAML2Constants.ATTRNAME_FORMAT_UNSPECIFIED);

    SecurityContext sc = new SAMLSecurityContext(new SimplePrincipal("user"), roles, claims);
    Message m = new MessageImpl();
    m.setExchange(new ExchangeImpl());
    m.put(SecurityContext.class, sc);
    m.put("org.apache.cxf.resource.method", cls.getMethod(methodName, new Class[] {}));
    return m;
  }
  @Override
  public void onMessage(byte[] message, ZMQ.Socket zmqSocket) {
    getLogger().log(Level.FINE, "server received request: ", message);

    Message inMessage = new MessageImpl();
    inMessage.setContent(InputStream.class, new ByteArrayInputStream(message));
    ((MessageImpl) inMessage).setDestination(this);
    inMessage.put("socket", zmqSocket);

    incomingObserver.onMessage(inMessage);
  }
示例#26
0
 public void copyJaxWsContext(
     org.apache.cxf.message.Exchange cxfExchange, Map<String, Object> context) {
   if (cxfExchange.getOutMessage() != null) {
     org.apache.cxf.message.Message outMessage = cxfExchange.getOutMessage();
     for (Map.Entry<String, Object> entry : context.entrySet()) {
       if (outMessage.get(entry.getKey()) == null) {
         outMessage.put(entry.getKey(), entry.getValue());
       }
     }
   }
 }
示例#27
0
 @Test
 public void testHttpResponse() {
   Message m = createMessage();
   MessageContext mc = new MessageContextImpl(m);
   HttpServletResponse request = EasyMock.createMock(HttpServletResponse.class);
   m.put(AbstractHTTPDestination.HTTP_RESPONSE, request);
   HttpServletResponseFilter filter = (HttpServletResponseFilter) mc.getHttpServletResponse();
   assertSame(request.getClass(), filter.getResponse().getClass());
   filter = (HttpServletResponseFilter) mc.getContext(HttpServletResponse.class);
   assertSame(request.getClass(), filter.getResponse().getClass());
 }
示例#28
0
  // Note that some conduit selectors may update Message.ENDPOINT_ADDRESS
  // after the conduit selector has been prepared but before the actual
  // invocation thus it is also important to have baseURI and currentURI
  // synched up with the latest endpoint address, after a successful proxy
  // or web client invocation has returned
  protected void prepareConduitSelector(Message message, URI currentURI, boolean proxy) {
    try {
      cfg.prepareConduitSelector(message);

    } catch (Fault ex) {
      LOG.warning("Failure to prepare a message from conduit selector");
    }
    message.getExchange().put(ConduitSelector.class, cfg.getConduitSelector());
    message.getExchange().put(Service.class, cfg.getConduitSelector().getEndpoint().getService());

    String address = (String) message.get(Message.ENDPOINT_ADDRESS);
    // custom conduits may override the initial/current address
    if (address.startsWith(HTTP_SCHEME) && !address.equals(currentURI.toString())) {
      URI baseAddress = URI.create(address);
      currentURI = calculateNewRequestURI(baseAddress, currentURI, proxy);
      message.put(Message.ENDPOINT_ADDRESS, currentURI.toString());
      message.put(Message.REQUEST_URI, currentURI.toString());
    }
    message.put(Message.BASE_PATH, getBaseURI().toString());
  }
示例#29
0
 /** Generates a new message. */
 private Message getNewMessage() {
   Message message = new MessageImpl();
   Map<String, List<String>> headers =
       new TreeMap<String, List<String>>(String.CASE_INSENSITIVE_ORDER);
   List<String> contentTypes = new ArrayList<String>();
   contentTypes.add("text/xml");
   contentTypes.add("charset=utf8");
   headers.put("content-type", contentTypes);
   message.put(Message.PROTOCOL_HEADERS, headers);
   return message;
 }
示例#30
0
  @Test
  public void testGetPropertyFromOtherMessage() {
    Message m1 = new MessageImpl();
    Message m2 = new MessageImpl();
    m2.put("a", "b");

    Exchange ex = new ExchangeImpl();
    ex.setInMessage(m1);
    ex.setOutMessage(m2);
    MessageContext mc = new MessageContextImpl(m1);
    assertEquals("b", mc.get("a"));
    assertNull(mc.get("b"));
  }