Java tutorial
/** * Copyright (c) 2009, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * * Licensed 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.axiom.om.OMAbstractFactory; import org.apache.axiom.om.OMException; import org.apache.axiom.om.OMNode; 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.apache.synapse.SynapseException; import org.apache.synapse.config.SynapseConfigUtils; import org.apache.synapse.registry.AbstractRegistry; import org.apache.synapse.registry.RegistryEntry; import org.wso2.carbon.mediation.registry.persistence.PersistenceManager; import org.wso2.carbon.mediation.registry.persistence.dataobject.RegistryEntryDO; import org.wso2.carbon.registry.core.RegistryConstants; import javax.net.ssl.HostnameVerifier; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLSession; import javax.xml.stream.XMLInputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamReader; import java.io.*; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.util.ArrayList; import java.util.Properties; /** * Registry implementation for ESB. This assumes that registry resources can be accessed using FILE * system or http. Registry meta data are accessed using web services. */ public class ESBRegistry extends AbstractRegistry { public static final int FILE = 100; public static final int HTTP = 101; public static final int HTTPS = 102; public static final String URL_SEPARATOR = "/"; public static final char URL_SEPARATOR_CHAR = '/'; private static final int DELETE_RETRY_SLEEP_TIME = 10; private static final long DEFAULT_CACHABLE_DURATION = 0; private static final Log log = LogFactory.getLog(ESBRegistry.class); private static final int MAX_KEYS = 200; /** * File system path corresponding to the FILE url path. This is a system depending path * used for accessing resources as files. */ private String localRegistry = null; /** * URL of the WS endpoind to get data about registry entries. */ private String metaDataService = null; /** * Specifies whether the registry is in the local host or a remote registry. * Local host means the same computer as ESB is running. */ private int registryType = ESBRegistryConstants.LOCAL_HOST_REGISTRY; /** * Contains the protocol for the registry. Allowd values are FILE, HTTP and HTTPS. */ private int registryProtocol = FILE; public ESBRegistry() { this.localRegistry = RegistryHelper.getHome(); } public void init(Properties properties) { super.init(properties); for (Object o : properties.keySet()) { if (o != null) { String name = (String) o; String value = (String) properties.get(name); addConfigProperty(name, value); } } } public OMNode lookup(String key) { if (log.isDebugEnabled()) { log.info("==> Repository fetch of resource with key : " + key); } URLConnection urlc; URL url = null; try { url = new URL(getRoot() + key); } catch (MalformedURLException e) { handleException("Invalid path '" + getRoot() + key + "' for URL", e); } if ("file".equals(url.getProtocol())) { try { url.openStream(); } catch (IOException ignored) { if (!localRegistry.endsWith(URL_SEPARATOR)) { localRegistry = localRegistry + URL_SEPARATOR; } try { url = new URL(url.getProtocol() + ":" + localRegistry + key); } catch (MalformedURLException e) { handleException("Invalid path '" + url.getProtocol() + ":" + localRegistry + key + "' for URL", e); } try { url.openStream(); } catch (IOException e) { return null; } } } try { urlc = url.openConnection(); urlc.connect(); } catch (IOException e) { return null; } InputStream input = null; try { input = urlc.getInputStream(); } catch (IOException e) { handleException("Error when getting a stream from the URL", e); } if (input == null) { return null; } BufferedInputStream inputStream = new BufferedInputStream(input); OMNode result = null; try { XMLStreamReader parser = XMLInputFactory.newInstance().createXMLStreamReader(inputStream); StAXOMBuilder builder = new StAXOMBuilder(parser); result = builder.getDocumentElement(); } catch (OMException ignored) { if (log.isDebugEnabled()) { log.debug("The resource at the provided URL isn't " + "well-formed XML,So,takes it as a text"); } try { inputStream.close(); } catch (IOException e) { log.error("Error in closing the input stream. ", e); } result = SynapseConfigUtils.readNonXML(url); } catch (XMLStreamException ignored) { if (log.isDebugEnabled()) { log.debug("The resource at the provided URL isn't " + "well-formed XML,So,takes it as a text"); } try { inputStream.close(); } catch (IOException e) { log.error("Error in closing the input stream. ", e); } result = SynapseConfigUtils.readNonXML(url); } finally { try { result.detach(); OMDocumentImpl parent = new OMDocumentImpl(OMAbstractFactory.getOMFactory()); parent.addChild(result); inputStream.close(); } catch (IOException e) { log.error("Error in closing the input stream.", e); } } return result; } public RegistryEntry getRegistryEntry(String key) { // get information from the actual resource MediationRegistryEntryImpl entryEmbedded = new MediationRegistryEntryImpl(); try { URL url = new URL(getRoot() + key); if ("file".equals(url.getProtocol())) { try { url.openStream(); } catch (IOException ignored) { if (!localRegistry.endsWith(URL_SEPARATOR)) { localRegistry = localRegistry + URL_SEPARATOR; } url = new URL(url.getProtocol() + ":" + localRegistry + key); try { url.openStream(); } catch (IOException e) { return null; } } } URLConnection urlc = url.openConnection(); entryEmbedded.setKey(key); entryEmbedded.setName(url.getFile()); entryEmbedded.setType(ESBRegistryConstants.FILE); entryEmbedded.setDescription("Resource at : " + url.toString()); entryEmbedded.setLastModified(urlc.getLastModified()); entryEmbedded.setVersion(urlc.getLastModified()); if (urlc.getExpiration() > 0) { entryEmbedded.setCachableDuration(urlc.getExpiration() - System.currentTimeMillis()); } else { entryEmbedded.setCachableDuration(getCachableDuration()); } } catch (MalformedURLException e) { handleException("Invalid URL reference " + getRoot() + key, e); } catch (IOException e) { handleException("IO Error reading from URL " + getRoot() + key, e); } // get information from the database PersistenceManager persistenceManager = PersistenceManager.getInstance(); RegistryEntryDO registryEntryDO = persistenceManager.getRegistryEntry(key); if (registryEntryDO != null) { if (registryEntryDO.getExpiryTime() != null) { entryEmbedded.setCachableDuration(registryEntryDO.getExpiryTime()); } else { entryEmbedded.setCachableDuration(0); } } return entryEmbedded; } public OMNode lookupFormat(String s) { return null; //To change body of implemented methods use File | Settings | File Templates. } /** * Updates the metadata of the given registry entry * * @param entry RegistryEntry containing the new metadata */ public void updateRegistryEntry(RegistryEntry entry) { RegistryEntryDO registryEntryDO = new RegistryEntryDO(); registryEntryDO.setRegistryKey(entry.getKey()); registryEntryDO.setExpiryTime(entry.getCachableDuration()); PersistenceManager persistenceManager = PersistenceManager.getInstance(); persistenceManager.saveOrUpdateRegistryEntry(registryEntryDO); } /** * Updates the registry resource pointed by the given key. * * @param key Key of the resource to be updated * @param value New value of the resource */ public void updateResource(String key, Object value) { if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { File file = new File(localRegistry + RegistryHelper.getSystemDependentPath(key)); if (file.exists()) { BufferedWriter writer = null; try { writer = new BufferedWriter(new FileWriter(file)); writer.write(value.toString()); writer.flush(); } catch (IOException e) { handleException("Couldn't write to registry entry: " + key, e); } finally { if (writer != null) { try { writer.close(); } catch (IOException ignored) { } } } } } else { handleException("Remote registry is not supported."); } } /** * Adds a new resource to the registry. * * @param parentName Key of the parent of the new resource * @param resourceName Name of the new resource * @param isLeaf Specifies whether the new resource is a leaf or not. In a FILE system based * registry, leaf is a FILE and non-leaf is a FOLDER. * @throws Exception if an error occurs while creating the resources */ private void addResource(String parentName, String resourceName, boolean isLeaf) throws Exception { if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { if (isLeaf) { createFile(RegistryHelper.getSystemDependentPath(parentName), resourceName); } else { createFolder(RegistryHelper.getSystemDependentPath(parentName), resourceName); } } } /** * Removes the registry resource identified by the given key. If the key points to a directory, * all its subdirectories and files in those directoris will be deleted. All the database * entries for deleted registry resources will be removed. * * @param key resource key */ private void removeResource(String key) { if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { File resource = new File(localRegistry + RegistryHelper.getSystemDependentPath(key)); if (resource.exists()) { if (resource.isFile()) { deleteFile(resource); } else if (resource.isDirectory()) { deleteDirectory(resource); } } else { throw new SynapseException("Parent folder: " + key + " does not exists."); } } } /** * Returns the registry key in URL style (with "/" as the separator) for a given FILE. * * @param file File to get the key * @return Registry key */ private String getRegsitryKey(File file) { String path = file.getAbsolutePath(); String rootPath = new File(localRegistry).getAbsolutePath(); return getURLPath(path.substring(rootPath.length() + 1)); // we have remove the preceeding "/" } private void deleteFile(File file) { boolean success = file.delete(); if (!success) { // try with this work around to overcome a known bug in windows // work around: // run garbage collector and sleep for some time and delete // if still didn't delete, // rename FILE to a temp FILE in "temp" dir and mark it to delete on exist System.gc(); try { Thread.sleep(DELETE_RETRY_SLEEP_TIME); } catch (InterruptedException e) { // ignore the exception } success = file.delete(); if (!success) { int suffix = 1; File renamedFile; File tempDir = new File("temp"); if (!tempDir.exists()) { tempDir.mkdir(); } do { String changedName = "d" + suffix + file.getName(); renamedFile = new File(tempDir, changedName); suffix++; } while (renamedFile.exists()); if (file.renameTo(renamedFile)) { renamedFile.deleteOnExit(); } else { handleException("Cannot delete the resource: " + file.getName()); } } } PersistenceManager persistenceManager = PersistenceManager.getInstance(); persistenceManager.deleteRegistryEntry(getRegsitryKey(file)); } private void deleteDirectory(File dir) { File[] children = dir.listFiles(); for (File aChildren : children) { if (aChildren != null) { if (aChildren.isFile()) { deleteFile(aChildren); } else if (aChildren.isDirectory()) { deleteDirectory(aChildren); } } } boolean success = dir.delete(); if (success) { PersistenceManager persistenceManager = PersistenceManager.getInstance(); persistenceManager.deleteRegistryEntry(getRegsitryKey(dir)); } else { handleException("Cannot delete the resource: " + dir.getName()); } } private void createFolder(String parentName, String newFolderName) throws Exception { /* search for parent. if found, create the new FOLDER in it. this depends on whether we are using a remote FILE system or not. add entry 'parentName/newFolderName' as key to the database. */ if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { File parent = new File(localRegistry + parentName); if (parent.exists()) { File newEntry = new File(parent, newFolderName); boolean success = newEntry.mkdir(); if (!success) { handleException("Couldn't create folder: " + newFolderName); } // update meta data to the database // note that we are using the registry key part (path without the local registry // root as the key in db // if the new FOLDER has a parent FOLDER, use its values for defaults for all // possible properties RegistryEntryDO registryEntryDO = new RegistryEntryDO(); registryEntryDO.setRegistryKey(parentName + URL_SEPARATOR + newFolderName); PersistenceManager persistenceManager = PersistenceManager.getInstance(); RegistryEntryDO parentEntryDO = persistenceManager.getRegistryEntry(getURLPath(parentName)); if (parentEntryDO != null) { registryEntryDO.setExpiryTime(parentEntryDO.getExpiryTime()); } else { registryEntryDO.setExpiryTime(getCachableDuration()); } persistenceManager.addRegistryEntry(registryEntryDO); } else { handleException("Parent folder: " + parentName + " does not exists."); } } } private void createFile(String parentName, String newFileName) throws Exception { /* search for parent. if found, create the new FOLDER in it. this depends on whether we are using a remote FILE system or not. */ if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { File parent = new File(localRegistry + parentName); if (parent.exists()) { File newFile = new File(parent, newFileName); boolean success = newFile.createNewFile(); if (!success) { handleException("Couldn't create resource: " + newFileName); } // update meta data to the database // note that we are using the registry key part (path without the local registry // root as the key in db // update the db only if we have some thing else to write other than the key RegistryEntryDO registryEntryDO = new RegistryEntryDO(); registryEntryDO.setRegistryKey(parentName + URL_SEPARATOR + newFileName); PersistenceManager persistenceManager = PersistenceManager.getInstance(); RegistryEntryDO parentEntryDO = persistenceManager.getRegistryEntry(getURLPath(parentName)); if (parentEntryDO != null) { registryEntryDO.setExpiryTime(parentEntryDO.getExpiryTime()); } else { registryEntryDO.setExpiryTime(getCachableDuration()); } persistenceManager.addRegistryEntry(registryEntryDO); } else { handleException("Parent folder: " + parentName + " does not exists."); } } } /** * Configure the ESB registry using registry parameters. * <p/> * root: FILE:directory - registry is on local host * directory is used to access metadata * <p/> * root: http/https:location - has to specify one of the following settings * localRegistry - location of the local registry * metadataService - url of the service to access metadata * If none of above parameters are given "registry" FOLDER is taken as the local registry. * * @param name name of the config * @param value value of the config */ private void addConfigProperty(String name, String value) { if (localRegistry == null) { // registry root should always end with "/" if (ESBRegistryConstants.LOCAL_REGISTRY_ROOT.endsWith(URL_SEPARATOR)) { localRegistry = ESBRegistryConstants.LOCAL_REGISTRY_ROOT; } else { localRegistry = ESBRegistryConstants.LOCAL_REGISTRY_ROOT + URL_SEPARATOR; } } if (name != null && value != null) { if (name.equals("root")) { // root should always end with '/' // therefore, property keys do not have to begin with '/', which could be misleading try { URL url = new URL(value); if ("file".equals(url.getProtocol())) { try { url.openStream(); } catch (IOException ignored) { if (!localRegistry.endsWith(URL_SEPARATOR)) { localRegistry = localRegistry + URL_SEPARATOR; } url = new URL(url.getProtocol() + ":" + localRegistry + url.getPath()); try { url.openStream(); } catch (IOException e) { log.error("Unable to open a connection to url : " + url, e); } } } if (url.getProtocol().equals("file")) { registryProtocol = FILE; registryType = ESBRegistryConstants.LOCAL_HOST_REGISTRY; if (url.getPath().endsWith(URL_SEPARATOR)) { localRegistry = RegistryHelper.getSystemDependentPath(url.getPath()); } else { localRegistry = RegistryHelper.getSystemDependentPath(url.getPath()) + File.separator; } } else if (url.getProtocol().equals("http")) { registryProtocol = HTTP; } else if (url.getProtocol().equals("https")) { registryProtocol = HTTPS; } if (!value.endsWith(URL_SEPARATOR)) { value = value + URL_SEPARATOR; } } catch (MalformedURLException e) { // don't set the root if this is not a valid URL handleException("Registry root should be a valid URL.", e); } } if (name.equals("localRegistry")) { registryType = ESBRegistryConstants.LOCAL_HOST_REGISTRY; // registry root always ends with "/" if (!value.endsWith(File.separator)) { value = value + File.separator; } localRegistry = value; } if (name.equals("matadataService")) { registryType = ESBRegistryConstants.REMOTE_HOST_REGISTRY; metaDataService = value; } // check if host name verification is disabled if (name.equalsIgnoreCase("disableHostNameVerification")) { if (value.equalsIgnoreCase("true")) { HostnameVerifier hv = new HostnameVerifier() { public boolean verify(String urlHostName, SSLSession session) { return true; } }; HttpsURLConnection.setDefaultHostnameVerifier(hv); } } } else { log.debug("Name and Value must need"); } } /** * Returns the root of the registry. This is always a URL. * * @return Registry root. */ public String getRoot() { String root = (String) properties.get("root"); if (root == null) { return ""; } else { return root; } } public long getCachableDuration() { String cachableDuration = (String) properties.get("cachableDuration"); return cachableDuration == null ? DEFAULT_CACHABLE_DURATION : Long.parseLong(cachableDuration); } /** * Gives the children of the given entry. If the registry is in the same host get the children * (subfolders and files) using the FILE system. If the registry is in a remote host, get * children using a WS call. Give null or registry entry with "" as the key to list the children * of the root. * * @param entry registry entry to get the children * @return children of the given entry */ public RegistryEntry[] getChildren(RegistryEntry entry) { String registryRoot = localRegistry; if (entry == null) { // give the children of the root // null or key = "" stands for root MediationRegistryEntryImpl registryEntry = new MediationRegistryEntryImpl(); registryEntry.setKey(""); entry = registryEntry; } if (registryType == ESBRegistryConstants.LOCAL_HOST_REGISTRY) { // registry is in the local FILE system. access it directly. String entryPath = RegistryHelper.getSystemDependentPath(entry.getKey()); File file = new File(registryRoot + entryPath); if (!file.isDirectory()) { return null; } try { String[] children = file.list(); RegistryEntry[] entries = new RegistryEntry[children.length]; for (int i = 0; i < children.length; i++) { MediationRegistryEntryImpl registryEntry = new MediationRegistryEntryImpl(); if (entry.getKey().equals("")) { // user asking for the children of the root registryEntry.setKey(children[i]); } else { if (entryPath.endsWith(URL_SEPARATOR)) { registryEntry.setKey(getURLPath(entry.getKey() + children[i])); } else { registryEntry.setKey(getURLPath(entry.getKey() + URL_SEPARATOR + children[i])); } } // set if the registry entry is a FILE or a FOLDER File entryFile = new File( registryRoot + RegistryHelper.getSystemDependentPath(registryEntry.getKey())); if (entryFile.isDirectory()) { registryEntry.setType(ESBRegistryConstants.FOLDER); } entries[i] = registryEntry; } return entries; } catch (Exception e) { handleException("Error in reading the URL."); } } else if (registryType == ESBRegistryConstants.REMOTE_HOST_REGISTRY) { // implement for remote registries. } return null; } public RegistryEntry[] getDescendants(RegistryEntry entry) { ArrayList<RegistryEntry> list = new ArrayList<RegistryEntry>(); RegistryEntry[] entries = getChildren(entry); if (entries != null) { for (RegistryEntry entry1 : entries) { if (list.size() > MAX_KEYS) { break; } fillDescendants(entry1, list); } } RegistryEntry[] descendants = new RegistryEntry[list.size()]; for (int i = 0; i < list.size(); i++) { descendants[i] = list.get(i); } return descendants; } public void delete(String path) { removeResource(path); } public void newResource(String path, boolean isDirectory) { String parent = getParentPath(path); String fileName = getResourceName(path); try { addResource(parent, fileName, !isDirectory); } catch (Exception e) { handleException("Error when adding a new resource", e); } } public void newNonEmptyResource(String key, boolean isDirectory, String mediaType, String content, String propertyName) { //TODO } 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); } } private String getURLPath(String filePath) { return filePath.replace(File.separatorChar, URL_SEPARATOR_CHAR); } 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); } private String getParentPath(String resourcePath) { String parentPath; if (resourcePath.equals(RegistryConstants.ROOT_PATH)) { parentPath = null; } else { if (resourcePath.lastIndexOf(RegistryConstants.PATH_SEPARATOR) == 0) { parentPath = RegistryConstants.ROOT_PATH; } else { parentPath = resourcePath.substring(0, resourcePath.lastIndexOf(RegistryConstants.PATH_SEPARATOR)); } } return parentPath; } private String getResourceName(String path) { if (path != null) { String correctedPath = path; if (path.endsWith(RegistryConstants.PATH_SEPARATOR)) { correctedPath = path.substring(0, path.lastIndexOf(RegistryConstants.PATH_SEPARATOR)); } return correctedPath.substring(correctedPath.lastIndexOf(RegistryConstants.PATH_SEPARATOR) + 1, correctedPath.length()); } return ""; } }