public void registerCepPublisher(OMElement request) throws XMLStreamException {
request.build();
request.detach();
OMElement tenantId =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_TENANT_ID));
OMElement executionPlan =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_EXEC_PLAN));
OMElement hostName =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_HOST_NAME));
OMElement port =
request.getFirstChildWithName(
new QName(ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_PORT));
String key = getKey(executionPlan.getText(), tenantId.getText());
int portNumber = Integer.parseInt(port.getText());
insertToCollection(
cepPublishers,
key,
new Endpoint(portNumber, hostName.getText(), Endpoint.ENDPOINT_TYPE_CEP_PUBLISHER));
log.info(
"Registering CEP Publisher for "
+ key
+ " at "
+ hostName.getText()
+ ":"
+ port.getText());
}
public void toSOAPEnvelope(SOAPEnvelope envelope) {
SOAPBody body = envelope.getBody();
// detach if already exist.
OMElement elem =
body.getFirstChildWithName(
new QName(namespaceValue, Sandesha2Constants.WSRM_COMMON.CLOSE_SEQUENCE_RESPONSE));
if (elem != null) elem.detach();
toOMElement(body);
}
public OMElement getCEPPublisher(OMElement request) throws XMLStreamException {
request.build();
request.detach();
OMElement tenantId =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_TENANT_ID));
OMElement executionPlan =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_EXEC_PLAN));
OMElement requesterIp =
request.getFirstChildWithName(
new QName(
ManagerServiceConstants.NAMESPACE, ManagerServiceConstants.ELEMENT_REQUESTER_IP));
String key = getKey(executionPlan.getText(), tenantId.getText());
log.info("CEP Publisher requested for " + key);
Set<Endpoint> endpointSet = cepPublishers.get(key);
Endpoint selectedEndpoint = selectEndpoint(endpointSet, requesterIp.getText());
OMElement response =
factory.createOMElement(
ManagerServiceConstants.ELEMENT_CEP_PUBLISHER_RESPONSE, OMNamespace);
if (selectedEndpoint != null) {
OMElement hostNameElement =
factory.createOMElement(ManagerServiceConstants.ELEMENT_HOST_NAME, OMNamespace);
OMElement portElement =
factory.createOMElement(ManagerServiceConstants.ELEMENT_PORT, OMNamespace);
OMText hostNameText = factory.createOMText(hostNameElement, selectedEndpoint.getHostName());
OMText portText =
factory.createOMText(portElement, Integer.toString(selectedEndpoint.getPort()));
hostNameElement.addChild(hostNameText);
portElement.addChild(portText);
response.addChild(hostNameElement);
response.addChild(portElement);
log.info(
"Returning CEP Publisher:"
+ selectedEndpoint.getHostName()
+ ":"
+ selectedEndpoint.getPort());
} else {
log.warn("No CEP publishers registered " + key);
}
return response;
}
public OMParser(OMElement element) {
_element = element;
_element.build();
if (_element.getParent() != null) _element.detach();
}
public boolean dispatch(MessageContext messageContext) {
if (log.isDebugEnabled()) {
log.debug(
"Sending the message to client with message processor ["
+ messageProcessor.getName()
+ "]");
}
// The below code is just for keeping the backward compatibility with the old code.
if (targetEndpoint == null) {
targetEndpoint =
(String) messageContext.getProperty(ForwardingProcessorConstants.TARGET_ENDPOINT);
}
MessageContext outCtx = null;
SOAPEnvelope originalEnvelop = messageContext.getEnvelope();
if (targetEndpoint != null) {
Endpoint ep = messageContext.getEndpoint(targetEndpoint);
try {
// Send message to the client
while (!isSuccessful && !isTerminated) {
try {
// For each retry we need to have a fresh copy of the actual message. otherwise retry
// may not
// work as expected.
messageContext.setEnvelope(MessageHelper.cloneSOAPEnvelope(originalEnvelop));
OMElement firstChild = null; //
org.apache.axis2.context.MessageContext origAxis2Ctx =
((Axis2MessageContext) messageContext).getAxis2MessageContext();
if (JsonUtil.hasAJsonPayload(origAxis2Ctx)) {
firstChild = origAxis2Ctx.getEnvelope().getBody().getFirstElement();
} // Had to do this because MessageHelper#cloneSOAPEnvelope does not clone
// OMSourcedElemImpl correctly.
if (JsonUtil.hasAJsonPayload(firstChild)) { //
OMElement clonedFirstElement =
messageContext.getEnvelope().getBody().getFirstElement();
if (clonedFirstElement != null) {
clonedFirstElement.detach();
messageContext.getEnvelope().getBody().addChild(firstChild);
}
} // Had to do this because MessageHelper#cloneSOAPEnvelope does not clone
// OMSourcedElemImpl correctly.
origAxis2Ctx.setProperty(
HTTPConstants.NON_ERROR_HTTP_STATUS_CODES, getNonRetryStatusCodes());
outCtx = sender.send(ep, messageContext);
isSuccessful = true;
} catch (Exception e) {
// this means send has failed due to some reason so we have to retry it
if (e instanceof SynapseException) {
isSuccessful = isNonRetryErrorCode(e.getCause().getMessage());
}
if (!isSuccessful) {
log.error(
"BlockingMessageSender of message processor ["
+ this.messageProcessor.getName()
+ "] failed to send message to the endpoint");
}
}
if (isSuccessful) {
if (outCtx != null) {
if ("true"
.equals(outCtx.getProperty(ForwardingProcessorConstants.BLOCKING_SENDER_ERROR))) {
// this means send has failed due to some reason so we have to retry it
isSuccessful =
isNonRetryErrorCode(
(String) outCtx.getProperty(SynapseConstants.ERROR_MESSAGE));
if (isSuccessful) {
sendThroughReplySeq(outCtx);
} else {
// This means some error has occurred so must try to send down the fault sequence.
log.error(
"BlockingMessageSender of message processor ["
+ this.messageProcessor.getName()
+ "] failed to send message to the endpoint");
sendThroughFaultSeq(outCtx);
}
} else {
// Send the message down the reply sequence if there is one
sendThroughReplySeq(outCtx);
messageConsumer.ack();
attemptCount = 0;
isSuccessful = true;
if (log.isDebugEnabled()) {
log.debug(
"Successfully sent the message to endpoint ["
+ ep.getName()
+ "]"
+ " with message processor ["
+ messageProcessor.getName()
+ "]");
}
}
} else {
// This Means we have invoked an out only operation
// remove the message and reset the count
messageConsumer.ack();
attemptCount = 0;
isSuccessful = true;
if (log.isDebugEnabled()) {
log.debug(
"Successfully sent the message to endpoint ["
+ ep.getName()
+ "]"
+ " with message processor ["
+ messageProcessor.getName()
+ "]");
}
}
}
if (!isSuccessful) {
// Then we have to retry sending the message to the client.
prepareToRetry();
} else {
if (messageProcessor.isPaused()) {
this.messageProcessor.resumeService();
log.info(
"Resuming the service of message processor [" + messageProcessor.getName() + "]");
}
}
}
} catch (Exception e) {
log.error(
"Message processor ["
+ messageProcessor.getName()
+ "] failed to send the message to"
+ " client",
e);
}
} else {
// No Target Endpoint defined for the Message
// So we do not have a place to deliver.
// Here we log a warning and remove the message
// todo: we can improve this by implementing a target inferring mechanism
log.warn(
"Property "
+ ForwardingProcessorConstants.TARGET_ENDPOINT
+ " not found in the message context , Hence removing the message ");
messageConsumer.ack();
}
return true;
}
/**
* Builds a SOAPEnvelope from DOM Document.
*
* @param doc - The dom document that contains a SOAP message
* @param useDoom
* @return
* @throws WSSecurityException
*/
public static SOAPEnvelope getSOAPEnvelopeFromDOMDocument(Document doc, boolean useDoom)
throws WSSecurityException {
if (useDoom) {
try {
// Get processed headers
SOAPEnvelope env = (SOAPEnvelope) doc.getDocumentElement();
ArrayList processedHeaderQNames = new ArrayList();
SOAPHeader soapHeader = env.getHeader();
if (soapHeader != null) {
Iterator headerBlocs = soapHeader.getChildElements();
while (headerBlocs.hasNext()) {
OMElement element = (OMElement) headerBlocs.next();
SOAPHeaderBlock header = null;
if (element instanceof SOAPHeaderBlock) {
header = (SOAPHeaderBlock) element;
// If a header block is not an instance of SOAPHeaderBlock, it means that
// it is a header we have added in rampart eg. EncryptedHeader and should
// be converted to SOAPHeaderBlock for processing
} else {
header = soapHeader.addHeaderBlock(element.getLocalName(), element.getNamespace());
Iterator attrIter = element.getAllAttributes();
while (attrIter.hasNext()) {
OMAttribute attr = (OMAttribute) attrIter.next();
header.addAttribute(
attr.getLocalName(), attr.getAttributeValue(), attr.getNamespace());
}
Iterator nsIter = element.getAllDeclaredNamespaces();
while (nsIter.hasNext()) {
OMNamespace ns = (OMNamespace) nsIter.next();
header.declareNamespace(ns);
}
// retrieve all child nodes (including any text nodes)
// and re-attach to header block
Iterator children = element.getChildren();
while (children.hasNext()) {
OMNode child = (OMNode) children.next();
child.detach();
header.addChild(child);
}
element.detach();
soapHeader.build();
header.setProcessed();
}
if (header.isProcessed()) {
processedHeaderQNames.add(element.getQName());
}
}
}
XMLStreamReader reader = ((OMElement) doc.getDocumentElement()).getXMLStreamReader();
StAXSOAPModelBuilder stAXSOAPModelBuilder = new StAXSOAPModelBuilder(reader, null);
SOAPEnvelope envelope = stAXSOAPModelBuilder.getSOAPEnvelope();
// Set the processed flag of the processed headers
SOAPHeader header = envelope.getHeader();
for (Iterator iter = processedHeaderQNames.iterator(); iter.hasNext(); ) {
QName name = (QName) iter.next();
Iterator omKids = header.getChildrenWithName(name);
if (omKids.hasNext()) {
((SOAPHeaderBlock) omKids.next()).setProcessed();
}
}
envelope.build();
return envelope;
} catch (FactoryConfigurationError e) {
throw new WSSecurityException(e.getMessage());
}
} else {
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
XMLUtils.outputDOM(doc.getDocumentElement(), os, true);
ByteArrayInputStream bais = new ByteArrayInputStream(os.toByteArray());
StAXSOAPModelBuilder stAXSOAPModelBuilder =
new StAXSOAPModelBuilder(
XMLInputFactory.newInstance().createXMLStreamReader(bais), null);
return stAXSOAPModelBuilder.getSOAPEnvelope();
} catch (Exception e) {
throw new WSSecurityException(e.getMessage());
}
}
}
public String addWadlToRegistry(
RequestContext requestContext, Resource resource, String resourcePath, boolean skipValidation)
throws RegistryException {
String wadlName = RegistryUtils.getResourceName(resourcePath);
String version =
requestContext.getResource().getProperty(RegistryConstants.VERSION_PARAMETER_NAME);
if (version == null) {
version = CommonConstants.WADL_VERSION_DEFAULT_VALUE;
requestContext.getResource().setProperty(RegistryConstants.VERSION_PARAMETER_NAME, version);
}
OMElement wadlElement;
String wadlContent;
Object resourceContent = resource.getContent();
if (resourceContent instanceof String) {
wadlContent = (String) resourceContent;
} else {
wadlContent = new String((byte[]) resourceContent);
}
try {
XMLStreamReader reader =
XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(wadlContent));
StAXOMBuilder builder = new StAXOMBuilder(reader);
wadlElement = builder.getDocumentElement();
} catch (XMLStreamException e) {
// This exception is unexpected because the WADL already validated
String msg = "Unexpected error occured " + "while reading the WADL at " + resourcePath + ".";
log.error(msg);
throw new RegistryException(msg, e);
}
String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
String namespaceSegment =
CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");
String actualPath =
getChrootedWadlLocation(requestContext.getRegistryContext())
+ namespaceSegment
+ version
+ "/"
+ wadlName;
OMElement grammarsElement =
wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));
if (StringUtils.isNotBlank(requestContext.getSourceURL())) {
String uri = requestContext.getSourceURL();
if (!skipValidation) {
validateWADL(uri);
}
if (resource.getUUID() == null) {
resource.setUUID(UUID.randomUUID().toString());
}
String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
if (grammarsElement != null) {
// This is to avoid evaluating the grammars import when building AST
grammarsElement.detach();
wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
}
} else {
if (!skipValidation) {
File tempFile = null;
BufferedWriter bufferedWriter = null;
try {
tempFile = File.createTempFile(wadlName, null);
bufferedWriter = new BufferedWriter(new FileWriter(tempFile));
bufferedWriter.write(wadlElement.toString());
bufferedWriter.flush();
} catch (IOException e) {
String msg = "Error occurred while reading the WADL File";
log.error(msg, e);
throw new RegistryException(msg, e);
} finally {
if (bufferedWriter != null) {
try {
bufferedWriter.close();
} catch (IOException e) {
String msg = "Error occurred while closing File writer";
log.warn(msg, e);
}
}
}
validateWADL(tempFile.toURI().toString());
try {
delete(tempFile);
} catch (IOException e) {
String msg =
"An error occurred while deleting the temporary files from local file system.";
log.warn(msg, e);
throw new RegistryException(msg, e);
}
}
if (grammarsElement != null) {
grammarsElement = resolveImports(grammarsElement, null, version);
wadlElement.addChild(grammarsElement);
}
}
requestContext.setResourcePath(new ResourcePath(actualPath));
if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
}
registry.put(actualPath, resource);
addImportAssociations(actualPath);
if (getCreateService()) {
OMElement serviceElement =
RESTServiceUtils.createRestServiceArtifact(
wadlElement,
wadlName,
version,
RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
registry.addAssociation(servicePath, actualPath, CommonConstants.DEPENDS);
registry.addAssociation(actualPath, servicePath, CommonConstants.USED_BY);
String endpointPath = createEndpointElement(requestContext, wadlElement, version);
if (endpointPath != null) {
registry.addAssociation(servicePath, endpointPath, CommonConstants.DEPENDS);
registry.addAssociation(endpointPath, servicePath, CommonConstants.USED_BY);
}
}
return resource.getPath();
}
public String importWADLToRegistry(
RequestContext requestContext, String commonLocation, boolean skipValidation)
throws RegistryException {
ResourcePath resourcePath = requestContext.getResourcePath();
String wadlName = RegistryUtils.getResourceName(resourcePath.getPath());
String version =
requestContext.getResource().getProperty(RegistryConstants.VERSION_PARAMETER_NAME);
if (version == null) {
version = CommonConstants.WADL_VERSION_DEFAULT_VALUE;
requestContext.getResource().setProperty(RegistryConstants.VERSION_PARAMETER_NAME, version);
}
String uri = requestContext.getSourceURL();
if (!skipValidation) {
validateWADL(uri);
}
Registry registry = requestContext.getRegistry();
Resource resource = registry.newResource();
if (resource.getUUID() == null) {
resource.setUUID(UUID.randomUUID().toString());
}
resource.setMediaType(wadlMediaType);
resource.setProperties(requestContext.getResource().getProperties());
ByteArrayOutputStream outputStream;
OMElement wadlElement;
try {
InputStream inputStream = new URL(uri).openStream();
outputStream = new ByteArrayOutputStream();
int nextChar;
while ((nextChar = inputStream.read()) != -1) {
outputStream.write(nextChar);
}
outputStream.flush();
wadlElement = AXIOMUtil.stringToOM(new String(outputStream.toByteArray()));
// to validate XML
wadlElement.toString();
} catch (Exception e) {
// This exception is unexpected because the WADL already validated
throw new RegistryException(
"Unexpected error occured " + "while reading the WADL at" + uri, e);
}
String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
String namespaceSegment =
CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");
OMElement grammarsElement =
wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));
String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
if (grammarsElement != null) {
grammarsElement.detach();
wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
}
String actualPath;
if (commonLocation != null) {
actualPath = commonLocation + namespaceSegment + version + "/" + wadlName;
} else {
actualPath =
RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH
+ commonWADLLocation
+ namespaceSegment
+ version
+ "/"
+ wadlName;
}
if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
}
resource.setContent(wadlElement.toString());
requestContext.setResourcePath(new ResourcePath(actualPath));
registry.put(actualPath, resource);
addImportAssociations(actualPath);
if (createService) {
OMElement serviceElement =
RESTServiceUtils.createRestServiceArtifact(
wadlElement,
wadlName,
version,
RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
addDependency(servicePath, actualPath);
String endpointPath = createEndpointElement(requestContext, wadlElement, version);
if (endpointPath != null) {
addDependency(servicePath, endpointPath);
}
}
return actualPath;
}
public static Entry createEntry(OMElement elem, Properties properties) {
String customFactory = SynapsePropertiesLoader.getPropertyValue("synapse.entry.factory", "");
if (customFactory != null && !"".equals(customFactory)) {
try {
Class c = Class.forName(customFactory);
Object o = c.newInstance();
if (o instanceof IEntryFactory) {
return ((IEntryFactory) o).createEntry(elem);
}
} catch (ClassNotFoundException e) {
handleException(
"Class specified by the synapse.entry.factory "
+ "synapse property not found: "
+ customFactory,
e);
} catch (InstantiationException e) {
handleException(
"Class specified by the synapse.entry.factory "
+ "synapse property cannot be instantiated: "
+ customFactory,
e);
} catch (IllegalAccessException e) {
handleException(
"Class specified by the synapse.entry.factory "
+ "synapse property cannot be accessed: "
+ customFactory,
e);
}
}
OMAttribute key = elem.getAttribute(new QName(XMLConfigConstants.NULL_NAMESPACE, "key"));
if (key == null) {
handleException("The 'key' attribute is required for a local registry entry");
return null;
} else {
Entry entry = new Entry(key.getAttributeValue());
OMElement descriptionElem = elem.getFirstChildWithName(DESCRIPTION_Q);
if (descriptionElem != null) {
entry.setDescription(descriptionElem.getText());
descriptionElem.detach();
}
String src = elem.getAttributeValue(new QName(XMLConfigConstants.NULL_NAMESPACE, "src"));
// if a src attribute is present, this is a URL source resource,
// it would now be loaded from the URL source, as all static properties
// are initialized at startup
if (src != null) {
try {
entry.setSrc(new URL(src.trim()));
entry.setType(Entry.URL_SRC);
entry.setValue(SynapseConfigUtils.getObject(entry.getSrc(), properties));
} catch (MalformedURLException e) {
handleException("The entry with key : " + key + " refers to an invalid URL");
}
} else {
OMNode nodeValue = elem.getFirstOMChild();
OMElement elemValue = elem.getFirstElement();
if (elemValue != null) {
entry.setType(Entry.INLINE_XML);
entry.setValue(elemValue);
} else if (nodeValue != null && nodeValue instanceof OMText) {
entry.setType(Entry.INLINE_TEXT);
entry.setValue(elem.getText().trim());
}
}
return entry;
}
}
