axisservicecomponent.java

提供ESB 应用mule源代码 提供ESB 应用mule源代码

            msgContext.setProperty("transport.url", endpointUri.toString());

            soapAction = getSoapAction(context);
            if (soapAction != null)
            {
                msgContext.setUseSOAPAction(true);
                msgContext.setSOAPActionURI(soapAction);
            }
            msgContext.setSession(new AxisMuleSession(context.getSession()));

            if (logger.isDebugEnabled())
            {
                logger.debug("Invoking Axis Engine.");
            }
            AxisServiceProxy.setProperties(RequestContext.getEvent().getEndpoint().getProperties());
            engine.invoke(msgContext);
            if (logger.isDebugEnabled())
            {
                logger.debug("Return from Axis Engine.");
            }
            if (RequestContext.getExceptionPayload() instanceof Exception)
            {
                throw (Exception)RequestContext.getExceptionPayload().getException();
            }
            // remove temporary file used for soap message with attachment
            if (request instanceof File)
            {
                ((File)request).delete();
            }
            responseMsg = msgContext.getResponseMessage();
            if (responseMsg == null)
            {
                throw new Exception(Messages.getMessage("noResponse01"));
            }
        }
        catch (AxisFault fault)
        {
            logger.error(fault.toString() + " target service is: " + msgContext.getTargetService()
                            + ". MuleEvent is: " + context.toString(), fault);
            processAxisFault(fault);
            configureResponseFromAxisFault(response, fault);
            responseMsg = msgContext.getResponseMessage();
            if (responseMsg == null)
            {
                responseMsg = new Message(fault);
            }
        }
        catch (Exception e)
        {
            responseMsg = msgContext.getResponseMessage();
            response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "500");
            responseMsg = convertExceptionToAxisFault(e, responseMsg);
        }

        contentType = responseMsg.getContentType(msgContext.getSOAPConstants());

        sendResponse(contentType, response, responseMsg);

        if (logger.isDebugEnabled())
        {
            logger.debug("Response sent.");
        }
    }

    private EndpointURI getEndpoint(MuleEventContext context) throws EndpointException
    {
        String endpoint = context.getEndpointURI().getAddress();
        String request = context.getMessage().getStringProperty(HttpConnector.HTTP_REQUEST_PROPERTY, null);
        if (request != null)
        {
            int i = endpoint.indexOf("/", endpoint.indexOf("://") + 3);
            if (i > -1)
            {
                endpoint = endpoint.substring(0, i);
            }
            endpoint += request;
            return new MuleEndpointURI(endpoint);
        }
        return context.getEndpointURI();
    }

    private void configureResponseFromAxisFault(WriterMessageAdapter response, AxisFault fault)
    {
        int status = getHttpResponseStatus(fault);
        if (status == 401)
        {
            response.setProperty(HttpConstants.HEADER_WWW_AUTHENTICATE, "Basic realm=\"AXIS\"");
        }
        response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, String.valueOf(status));
    }

    private Message convertExceptionToAxisFault(Exception exception, Message responseMsg)
    {
        logger.error(exception.getMessage(), exception);
        if (responseMsg == null)
        {
            AxisFault fault = AxisFault.makeFault(exception);
            processAxisFault(fault);
            responseMsg = new Message(fault);
        }
        return responseMsg;
    }

    protected int getHttpResponseStatus(AxisFault af)
    {
        return af.getFaultCode().getLocalPart().startsWith("Server.Unauth") ? 401 : '\u01F4';
    }

    private void sendResponse(String contentType,
                              WriterMessageAdapter response,
                              Message responseMsg) throws Exception
    {
        if (responseMsg == null)
        {
            response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "204");
            if (logger.isDebugEnabled())
            {
                logger.debug("NO AXIS MESSAGE TO RETURN!");
            }
        }
        else
        {
            if (logger.isDebugEnabled())
            {
                logger.debug("Returned Content-Type:" + contentType);
            }
                response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, contentType);
                ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
                responseMsg.writeTo(baos);
                response.write(baos.toString());
        }
    }

    private void populateMessageContext(MessageContext msgContext,
                                        MuleEventContext context,
                                        EndpointURI endpointUri) throws AxisFault, ConfigurationException
    {
        MuleMessage msg = context.getMessage();

        if (logger.isDebugEnabled())
        {
            logger.debug("MessageContext:" + msgContext);
            logger.debug("HEADER_CONTENT_TYPE:"
                            + msg.getStringProperty(HttpConstants.HEADER_CONTENT_TYPE, null));
            logger.debug("HEADER_CONTENT_LOCATION:"
                            + msg.getStringProperty(HttpConstants.HEADER_CONTENT_LOCATION, null));
            logger.debug("Constants.MC_HOME_DIR:" + String.valueOf(getHomeDir()));
            logger.debug("Constants.MC_RELATIVE_PATH:" + endpointUri.getPath());
            logger.debug("HTTPConstants.HEADER_AUTHORIZATION:" + msg.getStringProperty("Authorization", null));
            logger.debug("Constants.MC_REMOTE_ADDR:" + endpointUri.getHost());
        }

        msgContext.setTransportName(transportName);
        msgContext.setProperty("home.dir", getHomeDir());
        msgContext.setProperty("path", endpointUri.getPath());
        msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLET, this);
        msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLETLOCATION, endpointUri.getPath());
        // determine service name
        String serviceName = getServiceName(context, endpointUri);
        // Validate Service path against request path
        SOAPService service = msgContext.getAxisEngine().getConfig().getService(
            new QName(serviceName.substring(1)));

        // if using jms or vm we can skip this
        if (!("vm".equalsIgnoreCase(endpointUri.getScheme()) || "jms".equalsIgnoreCase(endpointUri.getScheme())))
        {            
            // Component Name is set by Mule so if its null we can skip this check
            if (service.getOption(AxisConnector.SERVICE_PROPERTY_COMPONENT_NAME) != null)
            {
                String servicePath = (String)service.getOption("servicePath");
                if (StringUtils.isEmpty(endpointUri.getPath()))
                {
                    if (!("/" + endpointUri.getAddress()).startsWith(servicePath + serviceName))
                    {
                        throw new AxisFault("Failed to find service: " + "/" + endpointUri.getAddress());
                    }
                }
                else if (!endpointUri.getPath().startsWith(servicePath + serviceName))
                {
                    throw new AxisFault("Failed to find service: " + endpointUri.getPath());
                }
            }
        }

        msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLETPATHINFO, serviceName);
        msgContext.setProperty("serviceName", serviceName);

        msgContext.setProperty("Authorization", msg.getStringProperty("Authorization", null));
        msgContext.setProperty("remoteaddr", endpointUri.getHost());
        ServletEndpointContextImpl sec = new ServletEndpointContextImpl();
        msgContext.setProperty("servletEndpointContext", sec);
    }

    private String getSoapAction(MuleEventContext context) throws AxisFault
    {
        String soapAction = context.getMessage().getStringProperty(SoapConstants.SOAP_ACTION_PROPERTY_CAPS, null);
        if (logger.isDebugEnabled())
        {
            logger.debug("Header Soap Action:" + soapAction);
        }

        if (StringUtils.isEmpty(soapAction))
        {
            soapAction = context.getEndpointURI().getAddress();
        }
        return soapAction;
    }

    protected String getServiceName(MuleEventContext context, EndpointURI endpointUri) throws AxisFault
    {
        String serviceName = endpointUri.getPath();
        if (StringUtils.isEmpty(serviceName))
        {
            serviceName = getSoapAction(context);
            serviceName = serviceName.replaceAll("\"", "");
            int i = serviceName.indexOf("/", serviceName.indexOf("//"));
            if (i < -1)
            {
                serviceName = serviceName.substring(i + 2);
            }

        }

        int i = serviceName.lastIndexOf('/');
        if (i > -1)
        {
            serviceName = serviceName.substring(i);
        }
        i = serviceName.lastIndexOf('?');
        if (i > -1)
        {
            serviceName = serviceName.substring(0, i);
        }
        return serviceName;
    }

    public String getTransportName()
    {
        return transportName;
    }

    public void setTransportName(String transportName)
    {
        this.transportName = transportName;
    }

    public boolean isEnableList()
    {
        return enableList;
    }

    public void setEnableList(boolean enableList)
    {
        this.enableList = enableList;
    }

    public String getHomeDir()
    {
        if (homeDir == null)
        {
            //TODO fix homeDir = RegistryContext.getConfiguration().getWorkingDirectory() + DEFAULT_AXIS_HOME;
            homeDir = DEFAULT_AXIS_HOME;
        }
        return homeDir;
    }

    public void setHomeDir(String homeDir)
    {
        this.homeDir = homeDir;
    }

    public AxisServer getAxis()
    {
        return axis;
    }

    public void setAxis(AxisServer axisServer)
    {
        this.axis = axisServer;
    }
}