/*
* Copyright (c) 2005-2008, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.wso2.carbon.mediation.registry;
import org.apache.synapse.registry.AbstractRegistry;
import org.apache.synapse.registry.RegistryEntry;
import org.apache.synapse.SynapseException;
import org.apache.synapse.util.SynapseBinaryDataSource;
import org.apache.axiom.om.OMNode;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.axiom.om.impl.llom.OMDocumentImpl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.registry.core.*;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.registry.core.utils.RegistryUtils;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.Collection;
import org.wso2.carbon.context.CarbonContext;
import javax.xml.stream.*;
import javax.activation.DataHandler;
import java.util.Properties;
import java.util.List;
import java.util.ArrayList;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
public class WSO2Registry extends AbstractRegistry {
private static final Log log = LogFactory.getLog(WSO2Registry.class);
public static final String CONFIG_REGISTRY_PREFIX = "conf:";
public static final String GOVERNANCE_REGISTRY_PREFIX = "gov:";
public static final String LOCAL_REGISTRY_PREFIX = "local:";
private static final String EXPIRY_TIME = "expiryTime";
private static final String CACHABLE_DURATION = "cachableDuration";
private static final String EXTENSIONS = "extensions";
private static final String ROOT = "root";
private static final int MAX_KEYS = 200;
private Registry configRegistry;
private Registry localRegistry;
private Registry governanceRegistry;
private String rootPath;
private List<RegistryExtension> extensions = new ArrayList<RegistryExtension>();
private String domain;
private int tenantId;
public WSO2Registry() {
RegistryService registryService = RegistryServiceHolder.getInstance().getRegistryService();
try {
configRegistry = registryService.getConfigSystemRegistry(
CarbonContext.getThreadLocalCarbonContext().getTenantId());
governanceRegistry = registryService.getGovernanceSystemRegistry(
CarbonContext.getThreadLocalCarbonContext().getTenantId());
localRegistry = registryService.getLocalRepository(
CarbonContext.getThreadLocalCarbonContext().getTenantId());
} catch (RegistryException e) {
handleException("Error while initializing the mediation registry adapter", e);
}
}
@Override
public void init(Properties properties) {
super.init(properties);
//Saving tenant information as instance variables to use later when registry lookup calls comes via non-carbon
//thread pools
CarbonContext cc = CarbonContext.getThreadLocalCarbonContext();
domain = cc.getTenantDomain();
tenantId = cc.getTenantId();
String root = properties.getProperty(ROOT);
if (root == null || "".equals(root)) {
rootPath = RegistryConstants.ROOT_PATH;
} else {
if (!root.startsWith(RegistryConstants.PATH_SEPARATOR)) {
root = RegistryConstants.PATH_SEPARATOR + root;
}
if (!root.endsWith(RegistryConstants.PATH_SEPARATOR)) {
root += RegistryConstants.PATH_SEPARATOR;
}
rootPath = root;
}
String extensionsProperty = properties.getProperty(EXTENSIONS);
if (extensionsProperty != null && !"".equals(extensionsProperty)) {
if (log.isDebugEnabled()) {
log.debug("Initializing mediation registry extensions");
}
String[] classNames = extensionsProperty.split(",");
for (String className : classNames) {
registerExtension(className);
}
}
}
public OMNode lookup(String key) {
setTenantInfo();
if (key == null) {
handleException("Resource cannot be found.");
}
if ("".equals(key)) {
handleException("Resource cannot be empty");
}
if (log.isDebugEnabled()) {
log.debug("==> Repository fetch of resource with key : " + key);
}
try {
Resource resource = getResource(key);
if (resource instanceof Collection) {
return null;
}
if (resource == null) { // try via available extensions
if (extensions.size() > 0) {
if (log.isDebugEnabled()) {
log.debug("Attempting to fetch the resource from the engaged extensions");
}
for (RegistryExtension extension : extensions) {
OMNode result = extension.lookup(key);
if (result != null) {
return result;
}
}
}
return null;
}
ByteArrayInputStream inputStream = null;
Object content = resource.getContent();
if (content instanceof String) {
inputStream = new ByteArrayInputStream(content.toString().getBytes());
} else if (content instanceof byte[]) {
inputStream = new ByteArrayInputStream((byte[]) content);
}
OMNode result = null;
try {
XMLStreamReader parser = XMLInputFactory.newInstance().
createXMLStreamReader(inputStream);
StAXOMBuilder builder = new StAXOMBuilder(parser);
result = builder.getDocumentElement();
} catch (OMException ignored) {
result = readNonXML(resource);
} catch (XMLStreamException ignored) {
result = readNonXML(resource);
} catch (Exception e) {
// a more general exception(e.g. a Runtime exception if the XML doc has an
// external DTD deceleration and if not connected to internet) which in case
// just log for debugging
log.error("Error while reading the resource '" + key + "'", e);
} finally {
try {
resource.discard();
if (result != null && result.getParent() != null) {
result.detach();
OMDocumentImpl parent = new OMDocumentImpl(OMAbstractFactory.getOMFactory());
parent.addChild(result);
}
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
log.error("Error while closing the input stream", e);
}
}
return result;
} catch (RegistryException e) {
handleException("Error while fetching the resource " + key, e);
}
return null;
}
public OMNode lookupFormat(String key) {
setTenantInfo();
if (key == null) {
handleException("Resource cannot be found.");
}
if ("".equals(key)) {
handleException("Resource cannot be empty");
}
if (log.isDebugEnabled()) {
log.debug("==> Repository fetch of resource with key : " + key);
}
try {
Resource resource = getResource(key);
if (resource instanceof Collection) {
return null;
}
if (resource == null) { // try via available extensions
if (extensions.size() > 0) {
if (log.isDebugEnabled()) {
log.debug("Attempting to fetch the resource from the engaged extensions");
}
for (RegistryExtension extension : extensions) {
OMNode result = extension.lookup(key);
if (result != null) {
return result;
}
}
}
return null;
}
ByteArrayInputStream inputStream = null;
Object content = resource.getContent();
if (content instanceof String) {
inputStream = new ByteArrayInputStream(content.toString().getBytes());
} else if (content instanceof byte[]) {
inputStream = new ByteArrayInputStream((byte[]) content);
}
OMNode result = null;
try {
XMLStreamReader parser = XMLInputFactory.newInstance().
createXMLStreamReader(inputStream);
StAXOMBuilder builder = new StAXOMBuilder(parser);
result = builder.getDocumentElement();
} catch (OMException ignored) {
result = readNonXML(resource);
} catch (XMLStreamException ignored) {
result = readNonXML(resource);
} catch (Exception e) {
// a more general exception(e.g. a Runtime exception if the XML doc has an
// external DTD deceleration and if not connected to internet) which in case
// just log for debugging
log.error("Error while reading the resource '" + key + "'", e);
} finally {
try {
resource.discard();
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
log.error("Error while closing the input stream", e);
}
}
return result;
} catch (RegistryException e) {
handleException("Error while fetching the resource " + key, e);
}
return null;
}
public void delete(String key) {
setTenantInfo();
try {
Registry registry = getRegistry(key);
String resolvedPath = resolvePath(key);
if (registry.resourceExists(resolvedPath)) {
registry.delete(resolvedPath);
}
} catch (RegistryException e) {
handleException("Error while deleting the resource at path :" + key, e);
}
}
public void newResource(String key, boolean isDirectory) {
setTenantInfo();
Registry registry = getRegistry(key);
String resolvedKey = resolvePath(key);
try {
Resource resource;
if (isDirectory) {
resource = registry.newCollection();
} else {
resource = registry.newResource();
}
registry.put(resolvedKey, resource);
} catch (RegistryException e) {
handleException("Error while saving a resource at " + key, e);
}
}
public void newNonEmptyResource(String key, boolean isDirectory, String mediaType, String content, String propertyName) {
setTenantInfo();
Registry registry = getRegistry(key);
String resolvedKey = resolvePath(key);
try {
Resource resource;
if (isDirectory) {
resource = registry.newCollection();
if (!propertyName.equals("")) {
resource.setProperty(propertyName, content);
}
} else {
resource = registry.newResource();
if (propertyName.equals("")){
resource.setMediaType(mediaType);
resource.setContent(content);
} else {
resource.setProperty(propertyName, content);
}
}
registry.put(resolvedKey, resource);
} catch (RegistryException e) {
handleException("Error while saving a resource at " + key, e);
}
}
/**
* Updates the content of a resource in the given path with given content
*
* @param path The resource path
* @param value The resource content to be set
*/
public void updateResource(String path, Object value) {
setTenantInfo();
Resource resource = getResource(path);
if (resource != null) {
Registry registry = getRegistry(path);
if (value instanceof OMNode) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
XMLStreamWriter xmlStreamWriter =
XMLOutputFactory.newInstance().createXMLStreamWriter(baos);
((OMNode) value).serialize(xmlStreamWriter);
resource.setContent(baos.toByteArray());
} catch (XMLStreamException e) {
handleException("Error when serializing OMNode " + value, e);
} catch (RegistryException e) {
handleException("Error when setting content " + value, e);
}
} else {
try {
resource.setContent(value);
} catch (RegistryException e) {
handleException("Error when setting content " + value, e);
}
}
try {
registry.put(resource.getPath(), resource);
resource.discard();
} catch (RegistryException e) {
handleException("Error when setting a resource in the path : " + path, e);
}
}
}
public void updateRegistryEntry(RegistryEntry entry) {
setTenantInfo();
String key = entry.getKey();
Resource resource = getResource(key);
if (resource != null) {
Registry registry = getRegistry(key);
resource.setProperty(CACHABLE_DURATION,
String.valueOf(entry.getCachableDuration()));
resource.setProperty(EXPIRY_TIME,
String.valueOf(System.currentTimeMillis() + entry.getCachableDuration()));
try {
registry.put(resource.getPath(), resource);
resource.discard();
} catch (RegistryException e) {
handleException("Error when setting a resource in the path : " + key, e);
}
}
}
public RegistryEntry getRegistryEntry(String entryKey) {
setTenantInfo();
MediationRegistryEntryImpl entry = new MediationRegistryEntryImpl();
Resource resource = getResource(entryKey);
if (resource != null) {
entry.setKey(entryKey);
entry.setName(resource.getPath());
if (resource instanceof Collection) {
entry.setType(ESBRegistryConstants.FOLDER);
} else {
entry.setType(ESBRegistryConstants.FILE);
}
entry.setDescription("Resource at : " + resource.getPath());
entry.setLastModified(resource.getLastModified().getTime());
entry.setVersion(resource.getLastModified().getTime());
// Get root's cachable duration value
long cacheTime = getCachableDuration();
String cachableDuration = resource.getProperty(CACHABLE_DURATION);
if (cachableDuration != null) {
// If the resource defines its own cachableDuration property,
// override the value from root
try {
cacheTime = Long.parseLong(cachableDuration);
} catch (NumberFormatException e) {
handleException("Couldn't pass the cachableDuration as a long", e);
}
}
entry.setCachableDuration(cacheTime);
} else {
// If the resource was found by an extension we need to set the
// following properties for cachine to work
entry.setKey(entryKey);
entry.setCachableDuration(getCachableDuration());
}
return entry;
}
public RegistryEntry[] getChildren(RegistryEntry entry) {
setTenantInfo();
if (entry == null) {
// give the children of the root
// null or key = "" stands for root
MediationRegistryEntryImpl registryEntry = new MediationRegistryEntryImpl();
registryEntry.setKey(rootPath);
entry = registryEntry;
} else {
if ("".equals(entry.getKey())) {
((MediationRegistryEntryImpl) entry).setKey(rootPath);
}
}
String parentPath;
if (!entry.getKey().endsWith(RegistryConstants.PATH_SEPARATOR)) {
parentPath = entry.getKey() + RegistryConstants.PATH_SEPARATOR;
} else {
parentPath = entry.getKey();
}
Resource resource = getResource(entry.getKey());
if (resource == null) {
return new RegistryEntry[]{new MediationRegistryEntryImpl()};
}
if (resource instanceof Collection) {
CollectionImpl collection = (CollectionImpl) resource;
String[] children = new String[0];
try {
children = collection.getChildren();
} catch (RegistryException e) {
handleException("Error when retrieving children");
}
List<RegistryEntry> entryList = new ArrayList<RegistryEntry>();
for (String child : children) {
String key;
if (child.endsWith(RegistryConstants.PATH_SEPARATOR)) {
key = child.substring(0, child.length() - 1);
} else {
key = child;
}
Resource childResource = getResource(key);
if (childResource == null) {
continue;
}
MediationRegistryEntryImpl registryEntryEmbedded = new MediationRegistryEntryImpl();
registryEntryEmbedded.setKey(parentPath + RegistryUtils.getResourceName(key));
if (childResource instanceof Collection) {
registryEntryEmbedded.setType(ESBRegistryConstants.FOLDER);
} else {
registryEntryEmbedded.setType(ESBRegistryConstants.FILE);
}
entryList.add(registryEntryEmbedded);
}
return entryList.toArray(new RegistryEntry[entryList.size()]);
} else {
((MediationRegistryEntryImpl) entry).setType(ESBRegistryConstants.FILE);
return new RegistryEntry[]{entry};
}
}
public RegistryEntry[] getDescendants(RegistryEntry entry) {
setTenantInfo();
ArrayList<RegistryEntry> list = new ArrayList<RegistryEntry>();
RegistryEntry[] entries = getChildren(entry);
if (entries != null) {
for (RegistryEntry currentEntry : entries) {
if (list.size() > MAX_KEYS) {
break;
}
fillDescendants(currentEntry, list);
}
}
RegistryEntry[] descendants = new RegistryEntry[list.size()];
for (int i = 0; i < list.size(); i++) {
descendants[i] = list.get(i);
}
return descendants;
}
private void fillDescendants(RegistryEntry parent, ArrayList<RegistryEntry> list) {
RegistryEntry[] entries = getChildren(parent);
if (entries != null) {
for (RegistryEntry entry : entries) {
if (list.size() > MAX_KEYS) {
break;
}
fillDescendants(entry, list);
}
} else {
list.add(parent);
}
}
public Resource getResource(String path) {
setTenantInfo();
Registry registry = getRegistry(path);
String key = resolvePath(path);
try {
if (registry.resourceExists(key)) {
return registry.get(key);
}
} catch (RegistryException e) {
handleException("Error while fetching the resource " + path, e);
}
return null;
}
/**
* Returns all resource properties for a given registry resource
*
* @param entryKey - Registry path of the resource
* @return Map of resource properties
*/
public Properties getResourceProperties(String entryKey) {
setTenantInfo();
Resource resource = getResource(entryKey);
if (resource != null) {
Properties properties = new Properties();
Properties resourceProperties = resource.getProperties();
if (resourceProperties != null) {
for (Object key : resourceProperties.keySet()) {
Object value = resourceProperties.get(key);
if (value instanceof List) {
if (((List) value).size() > 0) {
properties.put(key, ((List) value).get(0));
}
} else {
properties.put(key, value);
}
}
}
return properties;
}
return null;
}
private Registry getRegistry(String path) {
if (path == null || "".equals(path) || path.startsWith(GOVERNANCE_REGISTRY_PREFIX)) {
return governanceRegistry;
} else if (path.startsWith(CONFIG_REGISTRY_PREFIX)) {
return configRegistry;
} else if (path.startsWith(LOCAL_REGISTRY_PREFIX)) {
return localRegistry;
} else {
return governanceRegistry;
}
}
private String resolvePath(String path) {
if (path == null || "".equals(path)) {
path = RegistryConstants.ROOT_PATH;
}
boolean governanceReg = false;
if (path.startsWith(GOVERNANCE_REGISTRY_PREFIX)) {
path = path.substring(GOVERNANCE_REGISTRY_PREFIX.length());
governanceReg = true;
} else if (path.startsWith(CONFIG_REGISTRY_PREFIX)) {
path = path.substring(CONFIG_REGISTRY_PREFIX.length());
} else if (path.startsWith(LOCAL_REGISTRY_PREFIX)) {
path = path.substring(LOCAL_REGISTRY_PREFIX.length());
} else {
governanceReg = true;
}
if (governanceReg && rootPath != null) {
if (path.startsWith(RegistryConstants.PATH_SEPARATOR)) {
path = path.substring(1);
}
path = rootPath + path;
}
return path;
}
/**
* Helper method to handle non-XMl resources
*
* @param resource Registry resource
* @return The content as an OMNode
* @throws RegistryException if an error occurs while accessing the resource content
*/
private OMNode readNonXML(Resource resource) throws RegistryException {
if (log.isDebugEnabled()) {
log.debug("The resource at the specified path does not contain " +
"well-formed XML - Processing as text");
}
if (resource != null) {
if (resource.getMediaType() == null || resource.getMediaType().equals("text/plain")) {
// for non-xml text content or no media type defined
return OMAbstractFactory.getOMFactory().createOMText(new String((byte[]) resource.getContent()));
}
//For media types other than text/plain
ByteArrayInputStream inputStream = new ByteArrayInputStream((byte[]) resource.getContent());
try {
OMFactory omFactory = OMAbstractFactory.getOMFactory();
return omFactory.createOMText(
new DataHandler(new SynapseBinaryDataSource(inputStream, resource.getMediaType())), true);
} catch (IOException e) {
handleException("Error while getting a stream from resource content ", e);
} finally {
try {
inputStream.close();
} catch (IOException e) {
log.error("Error while closing the input stream", e);
}
}
}
return null;
}
private void registerExtension(String className) {
try {
Class clazz = this.getClass().getClassLoader().loadClass(className.trim());
RegistryExtension ext = (RegistryExtension) clazz.newInstance();
ext.init(properties);
extensions.add(ext);
} catch (Exception e) {
handleException("Error while instantiating the registry extension " +
"class : " + className, e);
}
}
private long getCachableDuration() {
String cachableDuration = (String) properties.get("cachableDuration");
return cachableDuration == null ? 0 : Long.parseLong(cachableDuration);
}
private void handleException(String msg, Exception e) {
log.error(msg, e);
throw new SynapseException(msg, e);
}
private void handleException(String msg) {
log.error(msg);
throw new SynapseException(msg);
}
/**
* Carbon Kernel mandates to set Threadlocal before calling anything in kernel
*/
private void setTenantInfo() {
// Preserve user name
String username = PrivilegedCarbonContext.getThreadLocalCarbonContext().getUsername();
//Removing the below code segment due to empty stack exception coming from kernel
//Current context does not need to be destroyed at this level.
//PrivilegedCarbonContext.destroyCurrentContext();
PrivilegedCarbonContext cc = PrivilegedCarbonContext.getThreadLocalCarbonContext();
if (cc.getTenantDomain() == null) {
cc.setTenantDomain(domain);
}
if (cc.getTenantId() == MultitenantConstants.INVALID_TENANT_ID) {
cc.setTenantId(tenantId);
}
if (username != null) { // Set back the user name
PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(username);
}
}
}