ProcessMessageExchangeEvent evt = new ProcessMessageExchangeEvent();
evt.setOperation(operation.getName());
evt.setPortType(partnerLink.partnerLink.partnerRolePortType.getQName());
evt.setAspect(ProcessMessageExchangeEvent.PARTNER_INPUT);
MessageExchangeDAO mexDao = _dao.getConnection().createMessageExchange(
MessageExchangeDAO.DIR_BPEL_INVOKES_PARTNERROLE);
mexDao.setCreateTime(getCurrentEventDateTime());
mexDao.setStatus(MessageExchange.Status.NEW.toString());
mexDao.setOperation(operation.getName());
mexDao.setPortType(partnerLink.partnerLink.partnerRolePortType.getQName());
mexDao.setPartnerLinkModelId(partnerLink.partnerLink.getId());
mexDao.setPartnerLink(plinkDAO);
mexDao.setProcess(_dao.getProcess());
mexDao.setInstance(_dao);
mexDao.setPattern((operation.getOutput() != null ? MessageExchangePattern.REQUEST_RESPONSE
: MessageExchangePattern.REQUEST_ONLY).toString());
mexDao.setChannel(channel == null ? null : channel.export());
// Properties used by stateful-exchange protocol.
String mySessionId = plinkDAO.getMySessionId();
String partnerSessionId = plinkDAO.getPartnerSessionId();
if ( mySessionId != null )
mexDao.setProperty(MessageExchange.PROPERTY_SEP_MYROLE_SESSIONID, mySessionId);
if ( partnerSessionId != null )
mexDao.setProperty(MessageExchange.PROPERTY_SEP_PARTNERROLE_SESSIONID, partnerSessionId);
if (__log.isDebugEnabled())
__log.debug("INVOKE PARTNER (SEP): sessionId=" + mySessionId + " partnerSessionId=" + partnerSessionId);
MessageDAO message = mexDao.createMessage(operation.getInput().getMessage().getQName());
mexDao.setRequest(message);
message.setType(operation.getInput().getMessage().getQName());
buildOutgoingMessage(message, outgoingMessage);
// Get he my-role EPR (if myrole exists) for optional use by partner
// (for callback mechanism).
EndpointReference myRoleEndpoint = partnerLink.partnerLink.hasMyRole() ? _bpelProcess
.getInitialMyRoleEPR(partnerLink.partnerLink) : null;
PartnerRoleMessageExchangeImpl mex =
createPartnerRoleMessageExchangeImpl(mexDao, partnerLink,
operation, partnerEpr, myRoleEndpoint);
mex.setProperty("activityId", ""+aid);
List<BpelProcess> p2pProcesses = null;
Endpoint partnerEndpoint = _bpelProcess.getInitialPartnerRoleEndpoint(partnerLink.partnerLink);
if (getConfigForPartnerLink(partnerLink.partnerLink).usePeer2Peer && partnerEndpoint != null)
p2pProcesses = _bpelProcess.getEngine().route(partnerEndpoint.serviceName, mex.getRequest());
if (p2pProcesses != null && !p2pProcesses.isEmpty()) {
// Creating a my mex using the same message id as partner mex to "pipe" them
MyRoleMessageExchange myRoleMex = _bpelProcess.getEngine().createMessageExchange(
mex.getMessageExchangeId(), partnerEndpoint.serviceName,
operation.getName(), mex.getMessageExchangeId());
if (myRoleMex instanceof BrokeredMyRoleMessageExchangeImpl) {
mex.setSubscriberCount(((BrokeredMyRoleMessageExchangeImpl) myRoleMex).getSubscriberCount());
}
if (BpelProcess.__log.isDebugEnabled()) {
__log.debug("Invoking in a p2p interaction, partnerrole " + mex + " - myrole " + myRoleMex);
}
Message odeRequest = myRoleMex.createMessage(operation.getInput().getMessage().getQName());
odeRequest.setMessage(outgoingMessage);
((MessageImpl)odeRequest)._dao.setHeader(message.getHeader());
if (BpelProcess.__log.isDebugEnabled()) {
__log.debug("Setting myRoleMex session ids for p2p interaction, mySession "
+ partnerSessionId + " - partnerSess " + mySessionId);
}
if ( partnerSessionId != null )
myRoleMex.setProperty(MessageExchange.PROPERTY_SEP_MYROLE_SESSIONID, partnerSessionId);
if ( mySessionId != null )
myRoleMex.setProperty(MessageExchange.PROPERTY_SEP_PARTNERROLE_SESSIONID, mySessionId);
mex.setStatus(MessageExchange.Status.REQUEST);
myRoleMex.invoke(odeRequest);
// Can't expect any sync response
scheduleInvokeCheck(mex, partnerLink.partnerLink, true);
mex.replyAsync();
} else {
// If we couldn't find the endpoint, then there is no sense
// in asking the IL to invoke.
if (partnerEpr != null) {
checkInvokeExternalPermission();
mexDao.setEPR(partnerEpr.toXML().getDocumentElement());
mex.setStatus(MessageExchange.Status.REQUEST);
// Assuming an unreliable protocol, we schedule a task to check if recovery mode will be needed
scheduleInvokeCheck(mex, partnerLink.partnerLink, false);
_bpelProcess._engine._contexts.mexContext.invokePartner(mex);
} else {
__log.error("Couldn't find endpoint for partner EPR " + DOMUtils.domToString(partnerEPR));
mex.setFailure(FailureType.UNKNOWN_ENDPOINT, "UnknownEndpoint", partnerEPR);
}
}
evt.setMexId(mexDao.getMessageExchangeId());
sendEvent(evt);
// MEX pattern is request only, at this point the status can only be a one way
if (mexDao.getPattern().equals(MessageExchangePattern.REQUEST_ONLY.toString())) {
mexDao.setStatus(MessageExchange.Status.ASYNC.toString());
// This mex can now be released
boolean succeeded = mex.getStatus() != MessageExchange.Status.FAILURE && mex.getStatus() != MessageExchange.Status.FAULT;
mexDao.release(_bpelProcess.isCleanupCategoryEnabled(succeeded, CLEANUP_CATEGORY.MESSAGES));
}
// Check if there is a synchronous response, if so, we need to inject the
// message on the response channel.
switch (mex.getStatus()) {
case NEW:
throw new AssertionError("Impossible!");
case ASYNC:
break;
case RESPONSE:
case FAULT:
case FAILURE:
invocationResponse(mex);
break;
default:
__log.error("Partner did not acknowledge message exchange: " + mex);
mex.setFailure(FailureType.NO_RESPONSE, "Partner did not acknowledge.", null);
invocationResponse(mex);
}
return mexDao.getMessageExchangeId();
}