/** {@inheritDoc} */
public InvocationResponse invoke(MessageContext messageContext) throws AxisFault {
if (log.isDebugEnabled()) {
log.debug(
"Starting Activation Handler invocation. Incoming Message: "
+ messageContext.getEnvelope().toString());
}
AxisService service = messageContext.getAxisService();
int tenantId = getTenantId(messageContext);
if (service != null && "ActivationService".equals(service.getName())) {
log.debug("Granted access to the Activation Service");
if (tenantId > 0) {
TenantAxisUtils.getTenantAxisConfiguration(
getTenantDomain(), messageContext.getConfigurationContext());
log.debug("Loaded Tenant Configuration");
}
return InvocationResponse.CONTINUE;
}
if (tenantId == MultitenantConstants.SUPER_TENANT_ID) {
log.debug("Granted access for super tenant");
return InvocationResponse.CONTINUE;
}
if (ActivationManager.activationRecorded(tenantId)) {
if (ActivationManager.getActivation(tenantId)) {
TenantAxisUtils.getTenantAxisConfiguration(
getTenantDomain(), messageContext.getConfigurationContext());
log.debug("Loaded Tenant Configuration");
return InvocationResponse.CONTINUE;
} else {
if (log.isWarnEnabled()) {
String serviceName = Util.getServiceName();
log.warn("Failed attempt to access " + serviceName + " by tenant " + tenantId);
}
return InvocationResponse.ABORT;
}
}
String serviceName = Util.getServiceName();
try {
if (CloudServicesUtil.isCloudServiceActive(serviceName, tenantId)) {
log.debug("Successful attempt to access " + serviceName + " by tenant " + tenantId);
ActivationManager.setActivation(tenantId, true);
TenantAxisUtils.getTenantAxisConfiguration(
getTenantDomain(), messageContext.getConfigurationContext());
log.debug("Loaded Tenant Configuration");
return InvocationResponse.CONTINUE;
}
} catch (Exception e) {
throw new AxisFault("Failed to determine Activation status.", e);
}
log.warn("Failed attempt to access " + serviceName + " by tenant " + tenantId);
ActivationManager.setActivation(tenantId, false);
return InvocationResponse.ABORT;
}
/**
* Loads a throttle metadata for a particular throttle type
*
* @param messageContext - The messageContext
* @param throttleType - The type of throttle
* @return IPBaseThrottleConfiguration - The IPBaseThrottleConfiguration - load from
* AxisConfiguration
* @throws ThrottleException Throws if the throttle type is unsupported
*/
public Throttle loadThrottle(MessageContext messageContext, int throttleType)
throws ThrottleException {
Throttle throttle = null;
ConfigurationContext configContext = messageContext.getConfigurationContext();
// the Parameter which hold throttle ipbase object
// to get throttles map from the configuration context
Map throttles = (Map) configContext.getPropertyNonReplicable(ThrottleConstants.THROTTLES_MAP);
if (throttles == null) {
if (debugOn) {
log.debug("Couldn't find throttles object map .. thottlling will not be occurred ");
}
return null;
}
switch (throttleType) {
case ThrottleConstants.GLOBAL_THROTTLE:
{
throttle = (Throttle) throttles.get(ThrottleConstants.GLOBAL_THROTTLE_KEY);
break;
}
case ThrottleConstants.OPERATION_BASED_THROTTLE:
{
AxisOperation axisOperation = messageContext.getAxisOperation();
if (axisOperation != null) {
QName opName = axisOperation.getName();
if (opName != null) {
AxisService service = (AxisService) axisOperation.getParent();
if (service != null) {
String currentServiceName = service.getName();
if (currentServiceName != null) {
throttle = (Throttle) throttles.get(currentServiceName + opName.getLocalPart());
}
}
}
} else {
if (debugOn) {
log.debug("Couldn't find axis operation ");
}
return null;
}
break;
}
case ThrottleConstants.SERVICE_BASED_THROTTLE:
{
AxisService axisService = messageContext.getAxisService();
if (axisService != null) {
throttle = (Throttle) throttles.get(axisService.getName());
} else {
if (debugOn) {
log.debug("Couldn't find axis service ");
}
return null;
}
break;
}
default:
{
throw new ThrottleException("Unsupported Throttle type");
}
}
return throttle;
}
/**
* Based on the Axis2 client code. Sends the Axis2 Message context out and returns the Axis2
* message context for the response.
*
* <p>Here Synapse works as a Client to the service. It would expect 200 ok, 202 ok and 500
* internal server error as possible responses.
*
* @param endpoint the endpoint being sent to, maybe null
* @param synapseOutMessageContext the outgoing synapse message
* @throws AxisFault on errors
*/
public static void send(
EndpointDefinition endpoint, org.apache.synapse.MessageContext synapseOutMessageContext)
throws AxisFault {
boolean separateListener = false;
boolean wsSecurityEnabled = false;
String wsSecPolicyKey = null;
String inboundWsSecPolicyKey = null;
String outboundWsSecPolicyKey = null;
boolean wsRMEnabled = false;
String wsRMPolicyKey = null;
boolean wsAddressingEnabled = false;
String wsAddressingVersion = null;
if (endpoint != null) {
separateListener = endpoint.isUseSeparateListener();
wsSecurityEnabled = endpoint.isSecurityOn();
wsSecPolicyKey = endpoint.getWsSecPolicyKey();
inboundWsSecPolicyKey = endpoint.getInboundWsSecPolicyKey();
outboundWsSecPolicyKey = endpoint.getOutboundWsSecPolicyKey();
wsRMEnabled = endpoint.isReliableMessagingOn();
wsRMPolicyKey = endpoint.getWsRMPolicyKey();
wsAddressingEnabled = endpoint.isAddressingOn() || wsRMEnabled;
wsAddressingVersion = endpoint.getAddressingVersion();
}
if (log.isDebugEnabled()) {
String to;
if (endpoint != null && endpoint.getAddress() != null) {
to = endpoint.getAddress(synapseOutMessageContext);
} else {
to = synapseOutMessageContext.getTo().toString();
}
log.debug(
"Sending [add = "
+ wsAddressingEnabled
+ "] [sec = "
+ wsSecurityEnabled
+ "] [rm = "
+ wsRMEnabled
+ (endpoint != null
? "] [mtom = "
+ endpoint.isUseMTOM()
+ "] [swa = "
+ endpoint.isUseSwa()
+ "] [format = "
+ endpoint.getFormat()
+ "] [force soap11="
+ endpoint.isForceSOAP11()
+ "] [force soap12="
+ endpoint.isForceSOAP12()
+ "] [pox="
+ endpoint.isForcePOX()
+ "] [get="
+ endpoint.isForceGET()
+ "] [encoding="
+ endpoint.getCharSetEncoding()
: "")
+ "] [to="
+ to
+ "]");
}
// save the original message context without altering it, so we can tie the response
MessageContext originalInMsgCtx =
((Axis2MessageContext) synapseOutMessageContext).getAxis2MessageContext();
// TODO Temp hack: ESB removes the session id from request in a random manner.
Map headers = (Map) originalInMsgCtx.getProperty(MessageContext.TRANSPORT_HEADERS);
String session = (String) synapseOutMessageContext.getProperty("LB_COOKIE_HEADER");
if (session != null) {
headers.put("Cookie", session);
}
// create a new MessageContext to be sent out as this should not corrupt the original
// we need to create the response to the original message later on
String preserveAddressingProperty =
(String) synapseOutMessageContext.getProperty(SynapseConstants.PRESERVE_WS_ADDRESSING);
MessageContext axisOutMsgCtx = cloneForSend(originalInMsgCtx, preserveAddressingProperty);
if (log.isDebugEnabled()) {
log.debug(
"Message [Original Request Message ID : "
+ synapseOutMessageContext.getMessageID()
+ "]"
+ " [New Cloned Request Message ID : "
+ axisOutMsgCtx.getMessageID()
+ "]");
}
// set all the details of the endpoint only to the cloned message context
// so that we can use the original message context for resending through different endpoints
if (endpoint != null) {
if (SynapseConstants.FORMAT_POX.equals(endpoint.getFormat())) {
axisOutMsgCtx.setDoingREST(true);
axisOutMsgCtx.setProperty(
org.apache.axis2.Constants.Configuration.MESSAGE_TYPE,
org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML);
axisOutMsgCtx.setProperty(
Constants.Configuration.CONTENT_TYPE,
org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML);
Object o =
axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS);
Map _headers = (Map) o;
if (_headers != null) {
_headers.remove(HTTP.CONTENT_TYPE);
_headers.put(
HTTP.CONTENT_TYPE,
org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_XML);
}
} else if (SynapseConstants.FORMAT_GET.equals(endpoint.getFormat())) {
axisOutMsgCtx.setDoingREST(true);
axisOutMsgCtx.setProperty(
Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_GET);
axisOutMsgCtx.setProperty(
org.apache.axis2.Constants.Configuration.MESSAGE_TYPE,
org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_X_WWW_FORM);
} else if (SynapseConstants.FORMAT_SOAP11.equals(endpoint.getFormat())) {
axisOutMsgCtx.setDoingREST(false);
axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE);
// We need to set this explicitly here in case the request was not a POST
axisOutMsgCtx.setProperty(
Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_POST);
if (axisOutMsgCtx.getSoapAction() == null && axisOutMsgCtx.getWSAAction() != null) {
axisOutMsgCtx.setSoapAction(axisOutMsgCtx.getWSAAction());
}
if (!axisOutMsgCtx.isSOAP11()) {
SOAPUtils.convertSOAP12toSOAP11(axisOutMsgCtx);
}
Object o =
axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS);
Map _headers = (Map) o;
if (_headers != null) {
_headers.remove(HTTP.CONTENT_TYPE);
_headers.put(
HTTP.CONTENT_TYPE, org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_TEXT_XML);
}
} else if (SynapseConstants.FORMAT_SOAP12.equals(endpoint.getFormat())) {
axisOutMsgCtx.setDoingREST(false);
axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE);
// We need to set this explicitly here in case the request was not a POST
axisOutMsgCtx.setProperty(
Constants.Configuration.HTTP_METHOD, Constants.Configuration.HTTP_METHOD_POST);
if (axisOutMsgCtx.getSoapAction() == null && axisOutMsgCtx.getWSAAction() != null) {
axisOutMsgCtx.setSoapAction(axisOutMsgCtx.getWSAAction());
}
if (axisOutMsgCtx.isSOAP11()) {
SOAPUtils.convertSOAP11toSOAP12(axisOutMsgCtx);
}
Object o =
axisOutMsgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS);
Map _headers = (Map) o;
if (_headers != null) {
_headers.remove(HTTP.CONTENT_TYPE);
_headers.put(
HTTP.CONTENT_TYPE,
org.apache.axis2.transport.http.HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML);
}
} else if (SynapseConstants.FORMAT_REST.equals(endpoint.getFormat())) {
/*format=rest is kept only backword compatibility. We no longer needed that.*/
/* Remove Message Type for GET and DELETE Request */
if (originalInMsgCtx.getProperty(Constants.Configuration.HTTP_METHOD) != null) {
if (originalInMsgCtx
.getProperty(Constants.Configuration.HTTP_METHOD)
.toString()
.equals(Constants.Configuration.HTTP_METHOD_GET)
|| originalInMsgCtx
.getProperty(Constants.Configuration.HTTP_METHOD)
.toString()
.equals(Constants.Configuration.HTTP_METHOD_DELETE)) {
axisOutMsgCtx.removeProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE);
}
}
axisOutMsgCtx.setDoingREST(true);
} else {
processWSDL2RESTRequestMessageType(originalInMsgCtx, axisOutMsgCtx);
}
if (endpoint.isUseMTOM()) {
axisOutMsgCtx.setDoingMTOM(true);
// fix / workaround for AXIS2-1798
axisOutMsgCtx.setProperty(
org.apache.axis2.Constants.Configuration.ENABLE_MTOM,
org.apache.axis2.Constants.VALUE_TRUE);
axisOutMsgCtx.setDoingMTOM(true);
} else if (endpoint.isUseSwa()) {
axisOutMsgCtx.setDoingSwA(true);
// fix / workaround for AXIS2-1798
axisOutMsgCtx.setProperty(
org.apache.axis2.Constants.Configuration.ENABLE_SWA,
org.apache.axis2.Constants.VALUE_TRUE);
axisOutMsgCtx.setDoingSwA(true);
}
if (endpoint.getCharSetEncoding() != null) {
axisOutMsgCtx.setProperty(
Constants.Configuration.CHARACTER_SET_ENCODING, endpoint.getCharSetEncoding());
// Need to Clean this up. TargetRequest line 176 contains a code block which over writes the
// Content-Type returned by the message formatter with the Content-Type in
// TRANSPORT_HEADERS. Because of that, even when
// the Character set encoding is set by the message formatter, it will be replaced by the
// Content-Type header in TRANSPORT_HEADERS.
// So Im setting a property to check in TargetRequest before over writing the header.
axisOutMsgCtx.setProperty("EndpointCharEncodingSet", "true");
}
// HTTP Endpoint : use the specified HTTP method and remove REST_URL_POSTFIX, it's not
// supported in HTTP Endpoint
if (endpoint.isHTTPEndpoint()) {
axisOutMsgCtx.setProperty(
Constants.Configuration.HTTP_METHOD,
synapseOutMessageContext.getProperty(Constants.Configuration.HTTP_METHOD));
axisOutMsgCtx.removeProperty(NhttpConstants.REST_URL_POSTFIX);
}
// add rest request' suffix URI
String restSuffix = (String) axisOutMsgCtx.getProperty(NhttpConstants.REST_URL_POSTFIX);
boolean isRest = SynapseConstants.FORMAT_REST.equals(endpoint.getFormat());
if (!isRest && !endpoint.isForceSOAP11() && !endpoint.isForceSOAP12()) {
isRest = isRequestRest(originalInMsgCtx);
}
if (endpoint.getAddress() != null) {
String address = endpoint.getAddress(synapseOutMessageContext);
if (isRest && restSuffix != null && !"".equals(restSuffix)) {
String url;
if (!address.endsWith("/")
&& !restSuffix.startsWith("/")
&& !restSuffix.startsWith("?")) {
url = address + "/" + restSuffix;
} else if (address.endsWith("/") && restSuffix.startsWith("/")) {
url = address + restSuffix.substring(1);
} else if (address.endsWith("/") && restSuffix.startsWith("?")) {
url = address.substring(0, address.length() - 1) + restSuffix;
} else {
url = address + restSuffix;
}
axisOutMsgCtx.setTo(new EndpointReference(url));
} else {
axisOutMsgCtx.setTo(new EndpointReference(address));
}
axisOutMsgCtx.setProperty(NhttpConstants.ENDPOINT_PREFIX, address);
synapseOutMessageContext.setProperty(SynapseConstants.ENDPOINT_PREFIX, address);
} else {
// Supporting RESTful invocation
if (isRest && restSuffix != null && !"".equals(restSuffix)) {
EndpointReference epr = axisOutMsgCtx.getTo();
if (epr != null) {
String address = epr.getAddress();
String url;
if (!address.endsWith("/")
&& !restSuffix.startsWith("/")
&& !restSuffix.startsWith("?")) {
url = address + "/" + restSuffix;
} else {
url = address + restSuffix;
}
axisOutMsgCtx.setTo(new EndpointReference(url));
}
}
}
if (endpoint.isUseSeparateListener()) {
axisOutMsgCtx.getOptions().setUseSeparateListener(true);
}
} else {
processWSDL2RESTRequestMessageType(originalInMsgCtx, axisOutMsgCtx);
}
// only put whttp:location for the REST (GET) requests, otherwise causes issues for POX messages
if (axisOutMsgCtx.isDoingREST()
&& HTTPConstants.MEDIA_TYPE_X_WWW_FORM.equals(
axisOutMsgCtx.getProperty(Constants.Configuration.MESSAGE_TYPE))) {
if (axisOutMsgCtx.getProperty(WSDL2Constants.ATTR_WHTTP_LOCATION) == null
&& axisOutMsgCtx.getEnvelope().getBody().getFirstElement() != null) {
axisOutMsgCtx.setProperty(
WSDL2Constants.ATTR_WHTTP_LOCATION,
axisOutMsgCtx.getEnvelope().getBody().getFirstElement().getQName().getLocalPart());
}
}
if (wsAddressingEnabled) {
if (wsAddressingVersion != null
&& SynapseConstants.ADDRESSING_VERSION_SUBMISSION.equals(wsAddressingVersion)) {
axisOutMsgCtx.setProperty(
AddressingConstants.WS_ADDRESSING_VERSION,
AddressingConstants.Submission.WSA_NAMESPACE);
} else if (wsAddressingVersion != null
&& SynapseConstants.ADDRESSING_VERSION_FINAL.equals(wsAddressingVersion)) {
axisOutMsgCtx.setProperty(
AddressingConstants.WS_ADDRESSING_VERSION, AddressingConstants.Final.WSA_NAMESPACE);
}
axisOutMsgCtx.setProperty(
AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.FALSE);
} else {
axisOutMsgCtx.setProperty(
AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.TRUE);
}
// remove the headers if we don't need to preserve them.
// determine weather we need to preserve the processed headers
String preserveHeaderProperty =
(String) synapseOutMessageContext.getProperty(SynapseConstants.PRESERVE_PROCESSED_HEADERS);
if (preserveHeaderProperty == null || !Boolean.parseBoolean(preserveHeaderProperty)) {
// default behaviour is to remove the headers
MessageHelper.removeProcessedHeaders(
axisOutMsgCtx,
(preserveAddressingProperty != null && Boolean.parseBoolean(preserveAddressingProperty)));
}
ConfigurationContext axisCfgCtx = axisOutMsgCtx.getConfigurationContext();
AxisConfiguration axisCfg = axisCfgCtx.getAxisConfiguration();
AxisService anoymousService =
AnonymousServiceFactory.getAnonymousService(
synapseOutMessageContext.getConfiguration(),
axisCfg,
wsAddressingEnabled,
wsRMEnabled,
wsSecurityEnabled);
// mark the anon services created to be used in the client side of synapse as hidden
// from the server side of synapse point of view
anoymousService.getParent().addParameter(SynapseConstants.HIDDEN_SERVICE_PARAM, "true");
ServiceGroupContext sgc =
new ServiceGroupContext(axisCfgCtx, (AxisServiceGroup) anoymousService.getParent());
ServiceContext serviceCtx = sgc.getServiceContext(anoymousService);
boolean outOnlyMessage =
"true".equals(synapseOutMessageContext.getProperty(SynapseConstants.OUT_ONLY));
// get a reference to the DYNAMIC operation of the Anonymous Axis2 service
AxisOperation axisAnonymousOperation =
anoymousService.getOperation(
outOnlyMessage
? new QName(AnonymousServiceFactory.OUT_ONLY_OPERATION)
: new QName(AnonymousServiceFactory.OUT_IN_OPERATION));
Options clientOptions = MessageHelper.cloneOptions(originalInMsgCtx.getOptions());
clientOptions.setUseSeparateListener(separateListener);
// if RM is requested,
if (wsRMEnabled) {
// if a WS-RM policy is specified, use it
if (wsRMPolicyKey != null) {
Object property = synapseOutMessageContext.getEntry(wsRMPolicyKey);
if (property instanceof OMElement) {
OMElement policyOMElement = (OMElement) property;
RMAssertionBuilder builder = new RMAssertionBuilder();
SandeshaPolicyBean sandeshaPolicyBean =
(SandeshaPolicyBean) builder.build(policyOMElement, null);
Parameter policyParam =
new Parameter(Sandesha2Constants.SANDESHA_PROPERTY_BEAN, sandeshaPolicyBean);
anoymousService.addParameter(policyParam);
}
}
}
// if security is enabled,
if (wsSecurityEnabled) {
// if a WS-Sec policy is specified, use it
if (wsSecPolicyKey != null) {
clientOptions.setProperty(
SynapseConstants.RAMPART_POLICY,
MessageHelper.getPolicy(synapseOutMessageContext, wsSecPolicyKey));
} else {
if (inboundWsSecPolicyKey != null) {
clientOptions.setProperty(
SynapseConstants.RAMPART_IN_POLICY,
MessageHelper.getPolicy(synapseOutMessageContext, inboundWsSecPolicyKey));
}
if (outboundWsSecPolicyKey != null) {
clientOptions.setProperty(
SynapseConstants.RAMPART_OUT_POLICY,
MessageHelper.getPolicy(synapseOutMessageContext, outboundWsSecPolicyKey));
}
}
// temporary workaround for https://issues.apache.org/jira/browse/WSCOMMONS-197
if (axisOutMsgCtx.getEnvelope().getHeader() == null) {
SOAPFactory fac =
axisOutMsgCtx.isSOAP11()
? OMAbstractFactory.getSOAP11Factory()
: OMAbstractFactory.getSOAP12Factory();
fac.createSOAPHeader(axisOutMsgCtx.getEnvelope());
}
}
OperationClient mepClient = axisAnonymousOperation.createClient(serviceCtx, clientOptions);
mepClient.addMessageContext(axisOutMsgCtx);
axisOutMsgCtx.setAxisMessage(
axisAnonymousOperation.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
// set the SEND_TIMEOUT for transport sender
if (endpoint != null && endpoint.getTimeoutDuration() > 0) {
axisOutMsgCtx.setProperty(SynapseConstants.SEND_TIMEOUT, endpoint.getTimeoutDuration());
}
// always set a callback as we decide if the send it blocking or non blocking within
// the MEP client. This does not cause an overhead, as we simply create a 'holder'
// object with a reference to the outgoing synapse message context
// synapseOutMessageContext
AsyncCallback callback = new AsyncCallback(axisOutMsgCtx, synapseOutMessageContext);
if (!outOnlyMessage) {
if (endpoint != null) {
// set the timeout time and the timeout action to the callback, so that the
// TimeoutHandler can detect timed out callbacks and take approprite action.
callback.setTimeOutOn(System.currentTimeMillis() + endpoint.getTimeoutDuration());
callback.setTimeOutAction(endpoint.getTimeoutAction());
} else {
callback.setTimeOutOn(System.currentTimeMillis());
}
}
mepClient.setCallback(callback);
//
// if (Utils.isClientThreadNonBlockingPropertySet(axisOutMsgCtx)) {
// SynapseCallbackReceiver synapseCallbackReceiver = (SynapseCallbackReceiver)
// axisOutMsgCtx.getAxisOperation().getMessageReceiver();
// synapseCallbackReceiver.addCallback(axisOutMsgCtx.getMessageID(), new
// FaultCallback(axisOutMsgCtx, synapseOutMessageContext));
// }
// this is a temporary fix for converting messages from HTTP 1.1 chunking to HTTP 1.0.
// Without this HTTP transport can block & become unresponsive because we are streaming
// HTTP 1.1 messages and HTTP 1.0 require the whole message to caculate the content length
if (originalInMsgCtx.isPropertyTrue(NhttpConstants.FORCE_HTTP_1_0)) {
synapseOutMessageContext.getEnvelope().toString();
}
// with the nio transport, this causes the listener not to write a 202
// Accepted response, as this implies that Synapse does not yet know if
// a 202 or 200 response would be written back.
originalInMsgCtx
.getOperationContext()
.setProperty(org.apache.axis2.Constants.RESPONSE_WRITTEN, "SKIP");
// if the transport out is explicitly set use it
Object o = originalInMsgCtx.getProperty("TRANSPORT_OUT_DESCRIPTION");
if (o != null && o instanceof TransportOutDescription) {
axisOutMsgCtx.setTransportOut((TransportOutDescription) o);
clientOptions.setTransportOut((TransportOutDescription) o);
clientOptions.setProperty("TRANSPORT_OUT_DESCRIPTION", o);
}
mepClient.execute(true);
if (wsRMEnabled) {
Object rm11 = clientOptions.getProperty(SandeshaClientConstants.RM_SPEC_VERSION);
if ((rm11 != null) && rm11.equals(Sandesha2Constants.SPEC_VERSIONS.v1_1)) {
ServiceClient serviceClient =
new ServiceClient(
axisOutMsgCtx.getConfigurationContext(), axisOutMsgCtx.getAxisService());
serviceClient.setTargetEPR(
new EndpointReference(endpoint.getAddress(synapseOutMessageContext)));
serviceClient.setOptions(clientOptions);
serviceClient
.getOptions()
.setTo(new EndpointReference(endpoint.getAddress(synapseOutMessageContext)));
SandeshaClient.terminateSequence(serviceClient);
}
}
}
public InvocationResponse invoke(MessageContext messageContext) throws AxisFault {
int tenantID = PublisherUtil.getTenantId(messageContext);
Map<Integer, EventingConfigData> tenantSpecificEventConfig =
TenantEventConfigData.getTenantSpecificEventingConfigData();
EventingConfigData eventingConfigData = tenantSpecificEventConfig.get(tenantID);
if (eventingConfigData != null && eventingConfigData.isMessageTracingEnable()) {
if (log.isDebugEnabled()) {
log.debug("Message tracing enabled.");
}
AxisService service = messageContext.getAxisService();
// Temporary fix for track API manager calls
if (service == null
|| (SystemFilter.isFilteredOutService(service.getAxisServiceGroup())
&& !AgentUtil.allowedServices(service.getName()))
|| service.isClientSide()) {
return InvocationResponse.CONTINUE;
} else {
String activityUUID = HandlerUtils.getUniqueId();
Object transportHeaders = messageContext.getProperty(MessageContext.TRANSPORT_HEADERS);
if (transportHeaders != null) {
String aid = (String) ((Map) transportHeaders).get(MessageTracerConstants.ACTIVITY_ID);
if (aid != null) {
if (aid.equals(MessageTracerConstants.EMPTY_STRING)) {
((Map) messageContext.getProperty(MessageContext.TRANSPORT_HEADERS))
.put(MessageTracerConstants.ACTIVITY_ID, activityUUID);
if (log.isDebugEnabled()) {
log.debug("Propagated AID was empty, IN generating new AID");
}
} else {
activityUUID = aid;
if (log.isDebugEnabled()) {
log.debug("IN using propagated AID");
}
}
} else {
((Map) messageContext.getProperty(MessageContext.TRANSPORT_HEADERS))
.put(MessageTracerConstants.ACTIVITY_ID, activityUUID);
if (log.isDebugEnabled()) {
log.debug("Propagated AID was null, IN generating new AID");
}
}
} else {
Map<String, String> headers = new TreeMap<String, String>();
headers.put(MessageTracerConstants.ACTIVITY_ID, activityUUID);
messageContext.setProperty(MessageContext.TRANSPORT_HEADERS, headers);
if (log.isDebugEnabled()) {
log.debug("Transport headers absent, IN generating new AID");
}
}
messageContext.setProperty(MessageTracerConstants.TENANT_ID, tenantID);
TracingInfo tracingInfo = new TracingInfo();
tracingInfo.setActivityId(activityUUID);
tracingInfo.setServer(AgentUtil.getServerName());
tracingInfo.setMessageDirection(BAMDataPublisherConstants.IN_DIRECTION);
tracingInfo.setHost(PublisherUtil.getHostAddress());
tracingInfo.setServiceName(messageContext.getAxisService().getName());
tracingInfo.setOperationName(messageContext.getAxisOperation().getName().getLocalPart());
MessageContext inMessageContext =
messageContext.getOperationContext().getMessageContext(WSDL2Constants.MESSAGE_LABEL_IN);
if (inMessageContext != null) {
Object requestProperty =
inMessageContext.getProperty(HTTPConstants.MC_HTTP_SERVLETREQUEST);
AgentUtil.extractInfoFromHttpHeaders(tracingInfo, requestProperty);
}
try {
if (eventingConfigData.isDumpBodyEnable()) {
try {
Class cls =
Class.forName(
MessageTracerConstants
.ORG_APACHE_SYNAPSE_TRANSPORT_PASSTHRU_UTIL_RELAY_UTILS_CLASS_NAME);
Class[] paramClasses = new Class[] {MessageContext.class, Boolean.TYPE};
Method method =
cls.getMethod(MessageTracerConstants.BUILD_MESSAGE_METHOD_NAME, paramClasses);
method.invoke(null, messageContext, false);
} catch (ClassNotFoundException ignore) {
// ignore
} catch (Exception e) {
throw new AxisFault("Error in building input message: " + e.getMessage(), e);
}
SOAPEnvelope soapEnvelope = messageContext.getEnvelope();
SOAPBody body = soapEnvelope.getBody();
if (body != null) {
tracingInfo.setPayload(body.toString());
}
SOAPHeader header = soapEnvelope.getHeader();
if (header != null) {
tracingInfo.setHeader(header.toString());
}
}
tracingInfo.setTimestamp(System.currentTimeMillis());
if (MessageContext.IN_FLOW == messageContext.getFLOW()) {
tracingInfo.setStatus(MessageTracerConstants.STATUS_SUCCESS);
} else if (MessageContext.IN_FAULT_FLOW == messageContext.getFLOW()) {
tracingInfo.setStatus(MessageTracerConstants.STATUS_FAULT);
}
publisher.publish(tenantID, tracingInfo);
} catch (OMException e) {
log.error("Unable to get SOAP details " + e.getMessage(), e);
}
}
}
return InvocationResponse.CONTINUE;
}
@Override
public Handler.InvocationResponse invoke(MessageContext messageContext) throws AxisFault {
SystemStatisticsUtil systemStatisticsUtil;
SystemStatistics systemStatistics;
try {
int tenantID = PublisherUtil.getTenantId(messageContext);
Map<Integer, EventConfigNStreamDef> tenantSpecificEventConfig =
TenantEventConfigData.getTenantSpecificEventingConfigData();
EventConfigNStreamDef eventingConfigData = tenantSpecificEventConfig.get(tenantID);
// Check service stats enable -- if true -- go
if (eventingConfigData != null && eventingConfigData.isServiceStatsEnable()) {
systemStatisticsUtil = StatisticsServiceComponent.getSystemStatisticsUtil();
systemStatistics = systemStatisticsUtil.getSystemStatistics(messageContext);
AxisOperation axisOperation = messageContext.getAxisOperation();
AxisService axisService = messageContext.getAxisService();
if (axisService == null
|| SystemFilter.isFilteredOutService(axisService.getAxisServiceGroup())
|| axisService.isClientSide()) {
return Handler.InvocationResponse.CONTINUE;
}
MessageContext inMessageContext = MessageContext.getCurrentMessageContext();
// If already set in the activity handlers get it or create new publish data
/*
PublishData publishData = (PublishData) messageContext.getProperty(
BAMDataPublisherConstants.PUBLISH_DATA);
EventData eventData;
if (publishData != null) {
eventData = publishData.getEventData();
} else {
publishData = new PublishData();
eventData = new EventData();
Date date = new Date();
Timestamp timestamp = new Timestamp(date.getTime());
eventData.setTimestamp(timestamp);
if (axisOperation != null) {
eventData.setOperationName(axisOperation.getName().getLocalPart());
} else {
eventData.setOperationName(null);
}
if (axisService != null) {
eventData.setServiceName(messageContext.getAxisService().getName());
} else {
eventData.setServiceName(null);
}
//This is a hack for setting message id when sending request to a non-existing operation.
if (eventingConfigData.isMsgDumpingEnable() && axisService != null &&
axisOperation == null) {
eventData.setOutMessageId(new ActivityOutHandler().getUniqueId());
}
}
*/
PublishData publishData = new PublishData();
EventData eventData = new EventData();
/* Date date = new Date();
Timestamp timestamp = new Timestamp(date.getTime());
eventData.setTimestamp(timestamp);*/
if (axisOperation != null) {
eventData.setOperationName(axisOperation.getName().getLocalPart());
} else {
eventData.setOperationName(null);
}
if (axisService != null) {
eventData.setServiceName(messageContext.getAxisService().getName());
} else {
eventData.setServiceName(null);
}
// This is a hack for setting message id when sending request to a non-existing operation.
/* if (eventingConfigData.isMsgDumpingEnable() && axisService != null &&
axisOperation == null) {
eventData.setOutMessageId(new ActivityOutHandler().getUniqueId());
}*/
// Skip resetting same info if already set by activity in/out handlers
/* if (!eventingConfigData.isMsgDumpingEnable()) {
Timestamp timestamp = null;
if (inMessageContext != null) {
timestamp = new Timestamp(Long.parseLong(inMessageContext.getProperty(
StatisticsConstants.REQUEST_RECEIVED_TIME).toString()));
Object requestProperty = inMessageContext.getProperty(
HTTPConstants.MC_HTTP_SERVLETREQUEST);
ServiceAgentUtil.extractInfoFromHttpHeaders(eventData, requestProperty);
} else {
Date date = new Date();
timestamp = new Timestamp(date.getTime());
}
eventData.setTimestamp(timestamp);
}*/
Timestamp timestamp = null;
if (inMessageContext != null) {
timestamp =
new Timestamp(
Long.parseLong(
inMessageContext
.getProperty(StatisticsConstants.REQUEST_RECEIVED_TIME)
.toString()));
Object requestProperty =
inMessageContext.getProperty(HTTPConstants.MC_HTTP_SERVLETREQUEST);
ServiceAgentUtil.extractInfoFromHttpHeaders(eventData, requestProperty);
} else {
Date date = new Date();
timestamp = new Timestamp(date.getTime());
}
eventData.setTimestamp(timestamp);
eventData.setSystemStatistics(systemStatistics);
publishData.setEventData(eventData);
// Skip if bam server info already set at activity handlers
if (!eventingConfigData.isMsgDumpingEnable()) {
BAMServerInfo bamServerInfo = ServiceAgentUtil.addBAMServerInfo(eventingConfigData);
publishData.setBamServerInfo(bamServerInfo);
}
Event event = ServiceAgentUtil.makeEventList(publishData, eventingConfigData);
EventPublisher publisher = new EventPublisher();
publisher.publish(event, eventingConfigData);
}
} catch (Throwable ignore) {
log.error(
"Error at SystemStatisticsOutHandler. "
+ "But continuing message processing for message id: "
+ messageContext.getMessageID(),
ignore);
}
return Handler.InvocationResponse.CONTINUE;
}
private void send(MessageContext msgctx) throws AxisFault {
// create the responseMessageContext and set that its related to the current outgoing
// message, so that it could be tied back to the original request even if the response
// envelope does not contain addressing headers
MessageContext responseMessageContext = new MessageContext();
responseMessageContext.setMessageID(msgctx.getMessageID());
responseMessageContext.setProperty(
SynapseConstants.RELATES_TO_FOR_POX, msgctx.getMessageID());
responseMessageContext.setOptions(options);
responseMessageContext.setServerSide(true);
addMessageContext(responseMessageContext);
responseMessageContext.setProperty("synapse.send", "true");
AxisEngine.send(msgctx);
// did the engine receive a immediate synchronous response?
// e.g. sometimes the transport sender may listen for a syncronous reply
if (msgctx.getProperty(MessageContext.TRANSPORT_IN) != null) {
responseMessageContext.setOperationContext(msgctx.getOperationContext());
responseMessageContext.setAxisMessage(
msgctx
.getOperationContext()
.getAxisOperation()
.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE));
responseMessageContext.setAxisService(msgctx.getAxisService());
responseMessageContext.setProperty(
MessageContext.TRANSPORT_OUT, msgctx.getProperty(MessageContext.TRANSPORT_OUT));
responseMessageContext.setProperty(
org.apache.axis2.Constants.OUT_TRANSPORT_INFO,
msgctx.getProperty(org.apache.axis2.Constants.OUT_TRANSPORT_INFO));
responseMessageContext.setProperty(
org.apache.synapse.SynapseConstants.ISRESPONSE_PROPERTY, Boolean.TRUE);
responseMessageContext.setTransportIn(msgctx.getTransportIn());
responseMessageContext.setTransportOut(msgctx.getTransportOut());
// If request is REST assume that the responseMessageContext is REST too
responseMessageContext.setDoingREST(msgctx.isDoingREST());
responseMessageContext.setProperty(
MessageContext.TRANSPORT_IN, msgctx.getProperty(MessageContext.TRANSPORT_IN));
responseMessageContext.setTransportIn(msgctx.getTransportIn());
responseMessageContext.setTransportOut(msgctx.getTransportOut());
// Options object reused above so soapAction needs to be removed so
// that soapAction+wsa:Action on response don't conflict
responseMessageContext.setSoapAction("");
if (responseMessageContext.getEnvelope() == null) {
// If request is REST we assume the responseMessageContext is
// REST, so set the variable
Options options = responseMessageContext.getOptions();
if (options != null) {
RelatesTo relatesTo = options.getRelatesTo();
if (relatesTo != null) {
relatesTo.setValue(msgctx.getMessageID());
} else {
options.addRelatesTo(new RelatesTo(msgctx.getMessageID()));
}
}
SOAPEnvelope resenvelope = TransportUtils.createSOAPMessage(responseMessageContext);
if (resenvelope != null) {
responseMessageContext.setEnvelope(resenvelope);
AxisEngine.receive(responseMessageContext);
if (responseMessageContext.getReplyTo() != null) {
sc.setTargetEPR(responseMessageContext.getReplyTo());
}
complete(msgctx);
} else {
throw new AxisFault(Messages.getMessage("blockingInvocationExpectsResponse"));
}
}
}
}
