| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF 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.apache.tuscany.sca.node.equinox.launcher; |
| |
| import static org.osgi.framework.Constants.ACTIVATION_LAZY; |
| import static org.osgi.framework.Constants.BUNDLE_ACTIVATIONPOLICY; |
| import static org.osgi.framework.Constants.BUNDLE_CLASSPATH; |
| import static org.osgi.framework.Constants.BUNDLE_MANIFESTVERSION; |
| import static org.osgi.framework.Constants.BUNDLE_NAME; |
| import static org.osgi.framework.Constants.BUNDLE_SYMBOLICNAME; |
| import static org.osgi.framework.Constants.BUNDLE_VENDOR; |
| import static org.osgi.framework.Constants.BUNDLE_VERSION; |
| import static org.osgi.framework.Constants.DYNAMICIMPORT_PACKAGE; |
| import static org.osgi.framework.Constants.EXPORT_PACKAGE; |
| import static org.osgi.framework.Constants.REQUIRE_BUNDLE; |
| import static org.osgi.framework.Constants.RESOLUTION_DIRECTIVE; |
| import static org.osgi.framework.Constants.RESOLUTION_OPTIONAL; |
| import static org.osgi.framework.Constants.VISIBILITY_DIRECTIVE; |
| import static org.osgi.framework.Constants.VISIBILITY_REEXPORT; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.FilenameFilter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| import java.util.jar.Attributes; |
| import java.util.jar.JarFile; |
| import java.util.jar.JarInputStream; |
| import java.util.jar.JarOutputStream; |
| import java.util.jar.Manifest; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.BundleException; |
| import org.osgi.framework.Constants; |
| |
| /** |
| * Common functions and constants used by the admin components. |
| * |
| * @version $Rev$ $Date$ |
| */ |
| final class NodeLauncherUtil { |
| private static final String NODE_API_BUNDLE = "org.apache.tuscany.sca.node.api"; |
| private static final String BASE_BUNDLE = "org.apache.tuscany.sca.base"; |
| |
| private static final Logger logger = Logger.getLogger(NodeLauncherUtil.class.getName()); |
| |
| static final String META_INF_SERVICES = "META-INF.services;partial=true;mandatory:=partial"; |
| static final String LAUNCHER_EQUINOX_LIBRARIES = "org.apache.tuscany.sca.node.launcher.equinox.libraries"; |
| static final String GATEWAY_BUNDLE = "org.apache.tuscany.sca.gateway"; |
| |
| private static final String NODE_FACTORY = "org.apache.tuscany.sca.node.NodeFactory"; |
| |
| private static final String DOMAIN_MANAGER_LAUNCHER_BOOTSTRAP = |
| "org.apache.tuscany.sca.domain.manager.launcher.DomainManagerLauncherBootstrap"; |
| |
| private static final String NODE_IMPLEMENTATION_DAEMON_BOOTSTRAP = |
| "org.apache.tuscany.sca.implementation.node.launcher.NodeImplementationDaemonBootstrap"; |
| |
| private static final String TUSCANY_HOME = "TUSCANY_HOME"; |
| private static final String TUSCANY_PATH = "TUSCANY_PATH"; |
| |
| /** |
| * Creates a new node. |
| * |
| * @param configurationURI |
| * @param compositeURI |
| * @param compositeContent |
| * @param contributions |
| * @param contributionClassLoader |
| * @param bundleContext |
| * @throws LauncherException |
| */ |
| static Object node(String configurationURI, |
| String compositeURI, |
| String compositeContent, |
| Contribution[] contributions, |
| BundleContext bundleContext) throws LauncherException { |
| try { |
| |
| // Get the node runtime bundle. |
| Bundle bundle = null; |
| for (Bundle b : bundleContext.getBundles()) { |
| if (NODE_API_BUNDLE.equals(b.getSymbolicName())) { |
| bundle = b; |
| break; |
| } |
| if (b.getSymbolicName().contains(BASE_BUNDLE)) { |
| bundle = b; |
| break; |
| } |
| } |
| if (bundle == null) { |
| throw new IllegalStateException("Bundle " + NODE_API_BUNDLE + " is not installed"); |
| } |
| |
| // Use Java reflection to create the node as only the runtime class |
| // loader knows the runtime classes required by the node |
| Class<?> bootstrapClass = bundle.loadClass(NODE_FACTORY); |
| |
| Object node = createNode(bootstrapClass, configurationURI, compositeURI, compositeContent, contributions); |
| |
| // If the SCANodeFactory interface is available in the current classloader, create |
| // an SCANode proxy around the node we've just create |
| try { |
| Class<?> type = Class.forName(NODE_FACTORY); |
| type = type.getDeclaredClasses()[0]; |
| return type.getMethod("createProxy", Class.class, Object.class).invoke(null, type, node); |
| } catch (ClassNotFoundException e) { |
| // Ignore |
| } |
| return node; |
| |
| } catch (Exception e) { |
| NodeLauncher.logger.log(Level.SEVERE, "SCA Node could not be created", e); |
| throw new LauncherException(e); |
| } |
| } |
| |
| private static Object createNode(Class<?> bootstrapClass, |
| String configurationURI, |
| String compositeURI, |
| String compositeContent, |
| Contribution[] contributions) throws NoSuchMethodException, |
| IllegalAccessException, InvocationTargetException, MalformedURLException { |
| Method newInstance = bootstrapClass.getMethod("newInstance"); |
| Object nodeFactory = newInstance.invoke(null); |
| |
| Object node; |
| if (configurationURI != null) { |
| |
| // NodeFactory.createNode(URL) |
| Method create = bootstrapClass.getMethod("createNode", URL.class); |
| node = create.invoke(nodeFactory, new URL(configurationURI)); |
| |
| } else if (compositeContent != null) { |
| |
| // NodeFactory.createNode(Reader, Stringp[], String[]) |
| Method create = bootstrapClass.getMethod("createNode", Reader.class, String[].class, String[].class); |
| String[] uris = new String[contributions.length]; |
| String[] locations = new String[contributions.length]; |
| for (int i = 0; i < contributions.length; i++) { |
| uris[i] = contributions[i].getURI(); |
| locations[i] = contributions[i].getLocation(); |
| } |
| node = create.invoke(nodeFactory, compositeContent, uris, locations); |
| |
| } else { |
| |
| // NodeFactory.createNode(String, Stringp[], String[]) |
| Method create = bootstrapClass.getMethod("createNode", String.class, String[].class, String[].class); |
| String[] uris = new String[contributions.length]; |
| String[] locations = new String[contributions.length]; |
| for (int i = 0; i < contributions.length; i++) { |
| uris[i] = contributions[i].getURI(); |
| locations[i] = contributions[i].getLocation(); |
| } |
| node = create.invoke(nodeFactory, compositeURI, uris, locations); |
| } |
| return node; |
| } |
| |
| /** |
| * Creates a new node daemon. |
| * |
| * @throws LauncherException |
| */ |
| static Object nodeDaemon() throws LauncherException { |
| ClassLoader tccl = Thread.currentThread().getContextClassLoader(); |
| try { |
| |
| // Use Java reflection to create the node daemon as only the runtime class |
| // loader knows the runtime classes required by the node |
| String className = NODE_IMPLEMENTATION_DAEMON_BOOTSTRAP; |
| Class<?> bootstrapClass; |
| bootstrapClass = Class.forName(className, false, tccl); |
| Object bootstrap = bootstrapClass.getConstructor().newInstance(); |
| |
| Object nodeDaemon = bootstrapClass.getMethod("getNode").invoke(bootstrap); |
| return nodeDaemon; |
| |
| } catch (Exception e) { |
| NodeDaemonLauncher.logger.log(Level.SEVERE, "SCA Node Daemon could not be created", e); |
| throw new LauncherException(e); |
| } finally { |
| Thread.currentThread().setContextClassLoader(tccl); |
| } |
| } |
| |
| /** |
| * Creates a new domain manager. |
| * |
| * @throws LauncherException |
| */ |
| static Object domainManager(String rootDirectory) throws LauncherException { |
| ClassLoader tccl = Thread.currentThread().getContextClassLoader(); |
| try { |
| |
| // Use Java reflection to create the node daemon as only the runtime class |
| // loader knows the runtime classes required by the node |
| String className = DOMAIN_MANAGER_LAUNCHER_BOOTSTRAP; |
| Class<?> bootstrapClass; |
| bootstrapClass = Class.forName(className, false, tccl); |
| Constructor<?> constructor = bootstrapClass.getConstructor(String.class); |
| Object bootstrap = constructor.newInstance(rootDirectory); |
| |
| Object domainManager = bootstrapClass.getMethod("getNode").invoke(bootstrap); |
| return domainManager; |
| |
| } catch (Exception e) { |
| DomainManagerLauncher.logger.log(Level.SEVERE, "SCA Domain Manager could not be created", e); |
| throw new LauncherException(e); |
| } finally { |
| Thread.currentThread().setContextClassLoader(tccl); |
| } |
| } |
| |
| /** |
| * starting with -, then some digits, then . or - or _, then some digits again |
| * |
| */ |
| // Mike Edwards 13/04/2009 - this original pattern allows for any number of repeated |
| // groups of digits, so that 1.2.3.4 is legal, for example. The problem with this is |
| // that OSGi only deals with a maximum of 3 groups of digits... |
| // private static Pattern pattern = Pattern.compile("-(\\d)+((\\.|-|_)(\\d)+)*"); |
| // |
| // This updated version restricts the allowed patterns to a maximum of 3 groups of |
| // digits so that "1", "1.2" and "1.2.3" are allowed but not "1.2.3.4" etc |
| private static Pattern pattern = Pattern.compile("-(\\d)+((\\.|-|_)(\\d)+){0,2}"); |
| |
| /** |
| * Returns the version number to use for the given JAR file. |
| * |
| * @param jarFile |
| * @return |
| */ |
| static String jarVersion(URL jarFile) { |
| String name = jarFile.getFile(); |
| int index = name.lastIndexOf('/'); |
| if (index != -1) { |
| // Find the last segment |
| name = name.substring(index + 1); |
| } |
| index = name.lastIndexOf('.'); |
| if (index != -1) { |
| // Trim the extension |
| name = name.substring(0, index); |
| } |
| |
| Matcher matcher = pattern.matcher(name); |
| String version = "0.0.0"; |
| if (matcher.find()) { |
| version = matcher.group(); |
| // Remove the leading "-" character |
| version = version.substring(1); |
| // The Pattern above allows the version string to contain "-" and "_" as digit separators. |
| // OSGi only allows for "." as a separator thus any "-" and "_" characters in the version string must be replaced by "." |
| version = version.replace('-', '.'); |
| version = version.replace('_', '.'); |
| } |
| return version; |
| } |
| |
| static String artifactId(URL jarFile) { |
| String name = jarFile.getFile(); |
| int index = name.lastIndexOf('/'); |
| if (index != -1) { |
| // Find the last segment |
| name = name.substring(index + 1); |
| } |
| index = name.lastIndexOf('.'); |
| if (index != -1) { |
| // Trim the extension |
| name = name.substring(0, index); |
| } |
| |
| Matcher matcher = pattern.matcher(name); |
| if (matcher.find()) { |
| return name.substring(0, matcher.start()); |
| } else { |
| return name; |
| } |
| } |
| |
| /** |
| * Add the packages found in the given JAR to a set. |
| * |
| * @param jarFile |
| * @param packages |
| * @throws IOException |
| */ |
| private static void addPackages(URL jarFile, Set<String> packages, String version) throws IOException { |
| if (version == null) { |
| version = ";version=" + jarVersion(jarFile); |
| } else { |
| version = ";version=" + version; |
| } |
| File file = file(jarFile); |
| if (file.isDirectory()) { |
| List<String> classFiles = listClassFiles(file); |
| for (String cls : classFiles) { |
| int index = cls.lastIndexOf('/'); |
| if (index == -1) { |
| // Default package cannot be exported |
| continue; |
| } |
| String pkg = cls.substring(0, index); |
| pkg = pkg.replace('/', '.') + version; |
| // Export META-INF.services |
| if ("META-INF.services".equals(pkg)) { |
| packages.add(META_INF_SERVICES); |
| } else { |
| packages.add(pkg); |
| } |
| } |
| } else if (file.isFile()) { |
| ZipInputStream is = new ZipInputStream(new FileInputStream(file)); |
| ZipEntry entry; |
| while ((entry = is.getNextEntry()) != null) { |
| String entryName = entry.getName(); |
| // Export split packages for META-INF/services |
| if(entryName.startsWith("META-INF/services/")) { |
| packages.add("META-INF.services" + ";partial=true;mandatory:=partial"); |
| } |
| if (!entry.isDirectory() && entryName != null |
| && entryName.length() > 0 |
| && !entryName.startsWith(".") |
| && entryName.endsWith(".class") // Exclude resources from Export-Package |
| && entryName.lastIndexOf("/") > 0) { |
| String pkg = entryName.substring(0, entryName.lastIndexOf("/")).replace('/', '.') + version; |
| packages.add(pkg); |
| } |
| } |
| is.close(); |
| } |
| } |
| |
| private static List<String> listClassFiles(File directory) { |
| List<String> artifacts = new ArrayList<String>(); |
| traverse(artifacts, directory, directory); |
| // Add META-INF/services to be exported |
| if (new File(directory, "META-INF/services").isDirectory()) { |
| artifacts.add("META-INF/services/"); |
| } |
| return artifacts; |
| } |
| |
| /** |
| * Recursively traverse a root directory |
| * |
| * @param fileList |
| * @param file |
| * @param root |
| * @throws IOException |
| */ |
| private static void traverse(List<String> fileList, File file, File root) { |
| if (file.isFile() && file.getName().endsWith(".class")) { |
| fileList.add(root.toURI().relativize(file.toURI()).toString()); |
| } else if (file.isDirectory()) { |
| String uri = root.toURI().relativize(file.toURI()).toString(); |
| if (uri.endsWith("/")) { |
| uri = uri.substring(0, uri.length() - 1); |
| } |
| fileList.add(uri); |
| |
| File[] files = file.listFiles(); |
| for (File f : files) { |
| if (!f.getName().startsWith(".")) { |
| traverse(fileList, f, root); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Finds the OSGi manifest file for a JAR file, where the manifest file is held in a META-INF directory |
| * alongside the JAR |
| * @param jarURL - The URL of the JAR file |
| * @return - a Manifest object corresponding to the manifest file, or NULL if there is no OSGi manifest |
| */ |
| static private Manifest findOSGiManifest(URL jarURL) { |
| try { |
| File jarFile = new File(jarURL.toURI()); |
| File theManifestFile = new File(jarFile.getParent(), "META-INF/MANIFEST.MF"); |
| if (theManifestFile.exists()) { |
| // Create manifest object by reading the manifest file |
| Manifest manifest = new Manifest(new FileInputStream(theManifestFile)); |
| // Check that this manifest file has the necessary OSGi metadata |
| String bundleName = manifest.getMainAttributes().getValue(BUNDLE_SYMBOLICNAME); |
| if (bundleName != null) { |
| return manifest; |
| } // end if |
| } // end if |
| } catch (Exception e) { |
| // Could not read the manifest - continue |
| } |
| return null; |
| } // end findOSGiManifest |
| |
| /** |
| * Generate a manifest from a list of third-party JAR files. |
| * |
| * @param jarFiles |
| * @param bundleSymbolicName The Bundle-SymbolicName |
| * @param bundleVersion The Bundle-Version |
| * @return |
| * @throws IllegalStateException |
| */ |
| static private Manifest thirdPartyLibraryBundleManifest(Collection<URL> jarFiles, |
| String bundleSymbolicName, |
| String bundleVersion) throws IllegalStateException { |
| try { |
| |
| // List exported packages and bundle classpath entries |
| StringBuffer classpath = new StringBuffer(); |
| StringBuffer exports = new StringBuffer(); |
| StringBuffer imports = new StringBuffer(); |
| Set<String> packages = new HashSet<String>(); |
| |
| for (URL jarFile : jarFiles) { |
| addPackages(jarFile, packages, bundleVersion); |
| classpath.append("\"external:"); |
| classpath.append(file(jarFile).getPath().replace(File.separatorChar, '/')); |
| classpath.append("\","); |
| } |
| |
| Set<String> importPackages = new HashSet<String>(); |
| for (String pkg : packages) { |
| |
| String importPackage = pkg; |
| int index = pkg.indexOf(';'); |
| if (index != -1) { |
| importPackage = pkg.substring(0, index); |
| } |
| if (!importPackages.contains(importPackage)) { |
| // Exclude META-INF.services |
| if (!"META-INF.services".equals(importPackage)) { |
| imports.append(pkg); |
| imports.append(','); |
| } |
| importPackages.add(importPackage); |
| exports.append(pkg); |
| exports.append(','); |
| } else { |
| logger.warning("Duplicate package skipped: " + pkg); |
| } |
| } |
| |
| // Create a manifest |
| Manifest manifest = new Manifest(); |
| Attributes attributes = manifest.getMainAttributes(); |
| attributes.putValue("Manifest-Version", "1.0"); |
| attributes.putValue(BUNDLE_MANIFESTVERSION, "2"); |
| |
| if (bundleVersion == null) { |
| bundleVersion = "0.0.0"; |
| } |
| attributes.putValue(Constants.BUNDLE_VERSION, bundleVersion); |
| if (bundleSymbolicName == null) { |
| bundleSymbolicName = LAUNCHER_EQUINOX_LIBRARIES; |
| } |
| attributes.putValue(BUNDLE_SYMBOLICNAME, bundleSymbolicName); |
| if (exports.length() > 0) { |
| attributes.putValue(EXPORT_PACKAGE, exports.substring(0, exports.length() - 1)); |
| } |
| /* |
| if (imports.length() > 0) { |
| attributes.putValue(IMPORT_PACKAGE, imports.substring(0, imports.length() - 1)); |
| } |
| */ |
| if (classpath.length() > 0) { |
| attributes.putValue(BUNDLE_CLASSPATH, classpath.substring(0, classpath.length() - 1)); |
| } |
| // The system bundle has incomplete javax.transaction* packages exported |
| attributes.putValue(DYNAMICIMPORT_PACKAGE, "javax.transaction;version=\"1.1\",javax.transaction.xa;version=\"1.1\",*"); |
| |
| return manifest; |
| } catch (IOException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| /** |
| * Generates a library bundle from a list of third-party JARs. |
| * |
| * @param jarFiles |
| * @param bundleSymbolicName The Bundle-SymbolicName |
| * @param bundleVersion The Bundle-Version |
| * @return |
| * @throws IOException |
| */ |
| static InputStream thirdPartyLibraryBundle(Collection<URL> jarFiles, String bundleSymbolicName, String bundleVersion) |
| throws IOException { |
| ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
| Manifest mf = thirdPartyLibraryBundleManifest(jarFiles, bundleSymbolicName, bundleVersion); |
| JarOutputStream jos = new JarOutputStream(bos, mf); |
| jos.close(); |
| return new ByteArrayInputStream(bos.toByteArray()); |
| } |
| |
| static InputStream thirdPartyLibraryBundle(Collection<URL> jarFiles, Manifest manifest) throws IOException { |
| ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
| StringBuffer classpath = new StringBuffer(); |
| for (URL jarFile : jarFiles) { |
| classpath.append("\"external:"); |
| classpath.append(file(jarFile).getPath().replace(File.separatorChar, '/')); |
| classpath.append("\","); |
| } |
| |
| if (classpath.length() > 0) { |
| manifest.getMainAttributes().putValue(BUNDLE_CLASSPATH, classpath.substring(0, classpath.length() - 1)); |
| } |
| |
| JarOutputStream jos = new JarOutputStream(bos, manifest); |
| jos.close(); |
| return new ByteArrayInputStream(bos.toByteArray()); |
| } |
| |
| /** |
| * Returns the location of this bundle. |
| * |
| * @return |
| * @throws IOException |
| */ |
| static String thisBundleLocation() throws IOException, URISyntaxException { |
| String resource = NodeLauncherUtil.class.getName().replace('.', '/') + ".class"; |
| URL url = NodeLauncherUtil.class.getClassLoader().getResource(resource); |
| if (url == null) { |
| throw new FileNotFoundException(resource); |
| } |
| URI uri = toURI(url); |
| |
| String scheme = uri.getScheme(); |
| if (scheme.equals("jar")) { |
| String path = uri.toString().substring(4); |
| int i = path.indexOf("!/"); |
| path = path.substring(0, i); |
| return path; |
| } else { |
| String path = uri.toString(); |
| path = path.substring(0, path.length() - resource.length()); |
| return path; |
| } |
| } |
| |
| static URI toURI(URL url) { |
| File file = file(url); |
| if (file != null) { |
| return file.toURI(); |
| } else { |
| return createURI(url.toString()); |
| } |
| } |
| |
| /** |
| * Escape the space in URL string |
| * @param uri |
| * @return |
| */ |
| static URI createURI(String uri) { |
| if (uri == null) { |
| return null; |
| } |
| if (uri.indexOf('%') != -1) { |
| // Avoid double-escaping |
| return URI.create(uri); |
| } |
| int index = uri.indexOf(':'); |
| String scheme = null; |
| String ssp = uri; |
| if (index != -1) { |
| scheme = uri.substring(0, index); |
| ssp = uri.substring(index + 1); |
| } |
| try { |
| return new URI(scheme, ssp, null); |
| } catch (URISyntaxException e) { |
| throw new IllegalArgumentException(e); |
| } |
| } |
| |
| /** |
| * Returns the location of this bundle. |
| * |
| * @param bundle |
| * @return |
| * @throws IOException |
| */ |
| static String thisBundleLocation(Bundle bundle) throws IOException, URISyntaxException, ClassNotFoundException { |
| String resource = NodeLauncherUtil.class.getName(); |
| Class<?> clazz = bundle.loadClass(NodeLauncherUtil.class.getName()); |
| URL url = clazz.getProtectionDomain().getCodeSource().getLocation(); |
| if (url == null) { |
| throw new FileNotFoundException(resource); |
| } |
| URI uri = toURI(url); |
| |
| String scheme = uri.getScheme(); |
| if (scheme.equals("jar")) { |
| String path = uri.toString().substring(4); |
| int i = path.indexOf("!/"); |
| path = path.substring(0, i); |
| return path; |
| } else { |
| String path = uri.toString(); |
| //path = path.substring(0, path.length() - resource.length()); |
| return path; |
| } |
| } |
| |
| /** |
| * Install the given bundle. |
| * |
| * @param bundleContext |
| * @param location |
| * @throws BundleException |
| * @throws IOException |
| */ |
| static void fixupBundle(String location) throws BundleException, IOException { |
| File target = file(new URL(location)); |
| if (!target.exists()) { |
| return; |
| } |
| location = target.toURI().toString(); |
| |
| // For development mode, copy the MANIFEST.MF file to the bundle location as it's |
| // initially outside of target/classes, at the root of the project. |
| if (location.endsWith("/target/classes/")) { |
| File targetManifest = new File(target, "META-INF/MANIFEST.MF"); |
| File sourceManifest = new File(target.getParentFile().getParentFile(), "META-INF/MANIFEST.MF"); |
| if (!sourceManifest.isFile()) { |
| return; |
| } |
| targetManifest.getParentFile().mkdirs(); |
| OutputStream os = new FileOutputStream(targetManifest); |
| InputStream is = new FileInputStream(sourceManifest); |
| byte[] buf = new byte[2048]; |
| for (;;) { |
| int l = is.read(buf); |
| if (l == -1) { |
| break; |
| } |
| os.write(buf, 0, l); |
| } |
| is.close(); |
| os.close(); |
| } |
| } |
| |
| /** |
| * Returns a string representation of the given bundle. |
| * |
| * @param b |
| * @param verbose |
| * @return |
| */ |
| static String string(Bundle bundle, boolean verbose) { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(bundle.getBundleId()).append(" ").append(bundle.getSymbolicName()); |
| int s = bundle.getState(); |
| if ((s & Bundle.UNINSTALLED) != 0) { |
| sb.append(" UNINSTALLED"); |
| } |
| if ((s & Bundle.INSTALLED) != 0) { |
| sb.append(" INSTALLED"); |
| } |
| if ((s & Bundle.RESOLVED) != 0) { |
| sb.append(" RESOLVED"); |
| } |
| if ((s & Bundle.STARTING) != 0) { |
| sb.append(" STARTING"); |
| } |
| if ((s & Bundle.STOPPING) != 0) { |
| sb.append(" STOPPING"); |
| } |
| if ((s & Bundle.ACTIVE) != 0) { |
| sb.append(" ACTIVE"); |
| } |
| |
| if (verbose) { |
| sb.append(" ").append(bundle.getLocation()); |
| sb.append(" ").append(bundle.getHeaders()); |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns the name of a bundle, or null if the given file is not a bundle. |
| * |
| * @param file |
| * @return |
| * @throws IOException |
| */ |
| static String bundleName(File file) throws IOException { |
| if (!file.exists()) { |
| return null; |
| } |
| String bundleName = null; |
| if (file.isDirectory()) { |
| File mf = new File(file, "META-INF/MANIFEST.MF"); |
| if (mf.isFile()) { |
| Manifest manifest = new Manifest(new FileInputStream(mf)); |
| bundleName = manifest.getMainAttributes().getValue(BUNDLE_SYMBOLICNAME); |
| } else { |
| if (file.toURI().getPath().endsWith("/target/classes/")) { |
| // Development mode, MANIFEST.MF is outside the bundle location |
| mf = new File(file.getParentFile().getParentFile(), "META-INF/MANIFEST.MF"); |
| if (mf.isFile()) { |
| Manifest manifest = new Manifest(new FileInputStream(mf)); |
| bundleName = manifest.getMainAttributes().getValue(BUNDLE_SYMBOLICNAME); |
| } |
| } |
| } |
| } else { |
| JarFile jar = new JarFile(file, false); |
| Manifest manifest = jar.getManifest(); |
| if (manifest != null) { |
| bundleName = manifest.getMainAttributes().getValue(BUNDLE_SYMBOLICNAME); |
| } |
| jar.close(); |
| } |
| if (bundleName == null) { |
| return bundleName; |
| } |
| int sc = bundleName.indexOf(';'); |
| if (sc != -1) { |
| bundleName = bundleName.substring(0, sc); |
| } |
| return bundleName; |
| } |
| |
| /** |
| * Collect JAR files in the given directory. |
| * |
| * @param directory |
| * @param urls |
| * @param filter |
| * @throws MalformedURLException |
| */ |
| private static void collectClasspathEntries(File directory, Set<URL> urls, FilenameFilter filter, boolean recursive) |
| throws MalformedURLException { |
| File[] files = directory.listFiles(filter); |
| if (files != null) { |
| int count = 0; |
| for (File file : files) { |
| if (recursive && file.isDirectory()) { |
| collectClasspathEntries(file, urls, filter, recursive); |
| } else { |
| urls.add(file.toURI().toURL()); |
| count++; |
| } |
| } |
| if (count != 0) { |
| logger.fine("Runtime classpath: " + count |
| + " JAR" |
| + (count > 1 ? "s" : "") |
| + " from " |
| + directory.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Collect development .../ target/classes directories in the given directory. |
| * |
| * @param directory |
| * @param urls |
| * @param filter |
| * @throws MalformedURLException |
| */ |
| private static void collectTargetClassesClasspathEntries(File directory, Set<URL> urls, FilenameFilter filter) |
| throws MalformedURLException { |
| File[] files = directory.listFiles(); |
| if (files != null) { |
| int count = 0; |
| for (File file : files) { |
| if (!file.isDirectory()) { |
| continue; |
| } |
| File target = new File(file, "target"); |
| if (!target.isDirectory()) { |
| continue; |
| } |
| File classes = new File(target, "classes"); |
| if (classes.isDirectory() && filter.accept(target, "classes")) { |
| urls.add(classes.toURI().toURL()); |
| count++; |
| } |
| } |
| if (count != 0 && logger.isLoggable(Level.FINE)) { |
| logger.fine("Runtime classpath: " + count |
| + " classes folder" |
| + (count > 1 ? "s" : "") |
| + " from " |
| + directory.toString()); |
| } |
| } |
| } |
| |
| /** |
| * Collect JAR files under the given distribution directory. |
| * |
| * @param directory |
| * @param jarDirectoryURLs |
| * @param jarURLs |
| * @param filter |
| * @throws MalformedURLException |
| */ |
| private static void collectDistributionClasspathEntries(String directory, |
| Set<URL> jarDirectoryURLs, |
| Set<URL> jarURLs, |
| FilenameFilter filter) throws MalformedURLException { |
| File directoryFile = new File(directory); |
| URL directoryURL = directoryFile.toURI().toURL(); |
| if (!jarDirectoryURLs.contains(directoryURL) && directoryFile.exists()) { |
| |
| // Collect files under the given directory |
| jarDirectoryURLs.add(directoryURL); |
| collectClasspathEntries(directoryFile, jarURLs, filter, false); |
| |
| // Collect files under <directory>/modules |
| File modulesDirectory = new File(directoryFile, "modules"); |
| URL modulesDirectoryURL = modulesDirectory.toURI().toURL(); |
| if (!jarDirectoryURLs.contains(modulesDirectoryURL) && modulesDirectory.exists()) { |
| jarDirectoryURLs.add(modulesDirectoryURL); |
| collectClasspathEntries(modulesDirectory, jarURLs, filter, true); |
| } |
| |
| // Collect files under <directory>/lib |
| /* SL - this is commented out to prevent the jars in the lib dir being installed as |
| * OSGi bundles. There must have been a time (1.x?) when lib jars would have been |
| * installed but now the shaded jars live in lib and we don't want to install them |
| * |
| File libDirectory = new File(directoryFile, "lib"); |
| URL libDirectoryURL = libDirectory.toURI().toURL(); |
| if (!jarDirectoryURLs.contains(libDirectoryURL) && libDirectory.exists()) { |
| jarDirectoryURLs.add(libDirectoryURL); |
| collectClasspathEntries(libDirectory, jarURLs, filter, true); |
| } |
| */ |
| } |
| } |
| |
| private static boolean isMavenTestMode() { |
| return getProperty("surefire.test.class.path") != null || getProperty("surefire.real.class.path") != null |
| || getProperty("localRepository") != null; |
| } |
| |
| /** |
| * Determine the Tuscany runtime classpath entries. |
| * |
| * @param useDistribution |
| * @param useAppClasspath |
| * @param useModulesDirectory |
| * @return |
| */ |
| static Set<URL> runtimeClasspathEntries(boolean useDistribution, |
| boolean useAppClasspath, |
| boolean useModulesDirectory) throws FileNotFoundException, |
| URISyntaxException, MalformedURLException { |
| |
| // Build list of runtime JARs |
| Set<URL> jarDirectoryURLs = new HashSet<URL>(); |
| Set<URL> jarURLs = new HashSet<URL>(); |
| |
| // Determine the path to the launcher class |
| URI uri; |
| try { |
| uri = codeLocation(NodeLauncherUtil.class); |
| } catch (Exception e) { |
| uri = URI.create(""); |
| } |
| |
| // If the launcher class is in a JAR, add all runtime JARs from directory containing |
| // that JAR (e.g. the Tuscany modules directory) as well as the ../modules and |
| // ../lib directories |
| if (uri.getPath().endsWith(".jar")) { |
| if (useDistribution) { |
| |
| File file = new File(uri); |
| if (file.exists()) { |
| File jarDirectory = file.getParentFile(); |
| if (jarDirectory != null && jarDirectory.exists()) { |
| |
| // Collect JAR files from the directory containing the input JAR |
| // (e.g. the Tuscany modules directory) |
| URL jarDirectoryURL = jarDirectory.toURI().toURL(); |
| jarDirectoryURLs.add(jarDirectoryURL); |
| collectClasspathEntries(jarDirectory, jarURLs, new StandAloneJARFileNameFilter(), true); |
| |
| File homeDirectory = jarDirectory.getParentFile(); |
| if (homeDirectory != null && homeDirectory.exists()) { |
| collectDistributionClasspathEntries(homeDirectory.getAbsolutePath(), |
| jarDirectoryURLs, |
| jarURLs, |
| new StandAloneJARFileNameFilter()); |
| } |
| } |
| } |
| } |
| } else if (uri.getPath().endsWith("/target/classes/")) { |
| |
| // Development mode, we're running off classes in a workspace |
| // and not from Maven surefire, collect all bundles in the workspace |
| if (useModulesDirectory) { |
| if (!isMavenTestMode()) { |
| File file = new File(uri); |
| if (file.exists()) { |
| File moduleDirectory = file.getParentFile().getParentFile(); |
| if (moduleDirectory != null) { |
| File modulesDirectory = moduleDirectory.getParentFile(); |
| if (modulesDirectory != null && modulesDirectory.exists() |
| && modulesDirectory.getName().equals("modules")) { |
| collectDevelopmentClasspathEntries(modulesDirectory.getAbsolutePath(), |
| jarDirectoryURLs, |
| jarURLs, |
| new StandAloneDevelopmentClassesFileNameFilter()); |
| // Added Mike Edwards, 09/04/2009 |
| // Get hold of the Libraries that are used by the Tuscany modules |
| collectDevelopmentLibraryEntries(modulesDirectory, jarDirectoryURLs, jarURLs); |
| } // end if |
| } |
| } |
| } |
| } |
| } |
| |
| // Look for a TUSCANY_HOME system property or environment variable |
| // Add all the JARs found under $TUSCANY_HOME, $TUSCANY_HOME/modules |
| // and $TUSCANY_HOME/lib |
| if (useDistribution) { |
| String home = getProperty(TUSCANY_HOME); |
| if (home != null && home.length() != 0) { |
| logger.info(TUSCANY_HOME + ": " + home); |
| collectDistributionClasspathEntries(home, jarDirectoryURLs, jarURLs, new StandAloneJARFileNameFilter()); |
| } |
| |
| // Look for a TUSCANY_PATH system property or environment variable |
| // Add all the JARs found under $TUSCANY_PATH, $TUSCANY_PATH/modules |
| // and $TUSCANY_PATH/lib |
| String ext = getProperty(TUSCANY_PATH); |
| if (ext != null && ext.length() != 0) { |
| logger.info(TUSCANY_PATH + ": " + ext); |
| String separator = getProperty("path.separator"); |
| for (StringTokenizer tokens = new StringTokenizer(ext, separator); tokens.hasMoreTokens();) { |
| collectDistributionClasspathEntries(tokens.nextToken(), |
| jarDirectoryURLs, |
| jarURLs, |
| new StandAloneJARFileNameFilter()); |
| } |
| } |
| } |
| |
| // Add the classpath entries from the current classloader |
| if (useAppClasspath) { |
| collectClassLoaderClasspathEntries(jarURLs, NodeLauncherUtil.class.getClassLoader()); |
| } |
| |
| return jarURLs; |
| |
| } |
| |
| /** |
| * Returns the JAR files on the classpath used by the given classloader. |
| * |
| * @param classLoader |
| * @return |
| */ |
| static List<URL> jarFilesOnClasspath(ClassLoader classLoader) { |
| Set<URL> entries = new HashSet<URL>(); |
| collectClassLoaderClasspathEntries(entries, classLoader); |
| return new ArrayList<URL>(entries); |
| } |
| |
| private static String getProperty(final String prop) { |
| return AccessController.doPrivileged(new PrivilegedAction<String>() { |
| public String run() { |
| String value = System.getProperty(prop); |
| if (value == null || value.length() == 0) { |
| return System.getenv(prop); |
| } else { |
| return value; |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Collect JARs on the classpath of a URLClassLoader. |
| * |
| * @param urls |
| * @param cl |
| */ |
| private static void collectClassLoaderClasspathEntries(Set<URL> urls, ClassLoader cl) { |
| if (cl == null) { |
| return; |
| } |
| |
| int count = urls.size(); |
| // Collect JARs from the URLClassLoader's classpath |
| if (cl instanceof URLClassLoader) { |
| URL[] jarURLs = ((URLClassLoader)cl).getURLs(); |
| if (jarURLs != null) { |
| for (URL jarURL : jarURLs) { |
| urls.add(jarURL); |
| try { |
| urls.addAll(manifestClassPath(jarURL)); |
| } catch (Exception e) { |
| logger.log(Level.SEVERE, e.getMessage(), e); |
| } |
| } |
| count = urls.size() - count; |
| |
| if (count != 0 && logger.isLoggable(Level.FINE)) { |
| logger.fine("Runtime classpath: " + count |
| + " JAR" |
| + (count > 1 ? "s" : "") |
| + " from application classpath."); |
| } |
| } |
| } |
| } |
| |
| static Set<URL> manifestClassPath(URL jarFile) throws Exception { |
| Set<URL> urls = new HashSet<URL>(); |
| if (jarFile != null) { |
| Manifest mf = null; |
| if ("file".equals(jarFile.getProtocol())) { |
| File f = file(jarFile); |
| if (f.isDirectory()) { |
| File mfFile = new File(f, "META-INF/MANIFEST.MF"); |
| if (mfFile.isFile()) { |
| FileInputStream is = new FileInputStream(mfFile); |
| mf = new Manifest(is); |
| is.close(); |
| } |
| } else if (f.isFile()) { |
| JarInputStream jar = new JarInputStream(jarFile.openStream()); |
| mf = jar.getManifest(); |
| jar.close(); |
| } |
| } |
| if (mf != null) { |
| String cp = mf.getMainAttributes().getValue("Class-Path"); |
| if (cp != null) { |
| StringTokenizer st = new StringTokenizer(cp); |
| while (st.hasMoreTokens()) { |
| URL entry = new URL(jarFile.toURI().toURL(), st.nextToken()).toURI().toURL(); |
| urls.add(entry); |
| } |
| } |
| } |
| } |
| return urls; |
| } |
| |
| /** |
| * A file name filter used to filter JAR files. |
| */ |
| private static class StandAloneJARFileNameFilter implements FilenameFilter { |
| |
| public boolean accept(File dir, String name) { |
| name = name.toLowerCase(); |
| |
| if (new File(dir, name).isDirectory()) { |
| return true; |
| } |
| |
| // Filter out the Tomcat and Webapp hosts |
| if (name.startsWith("tuscany-host-tomcat") || name.startsWith("tuscany-host-webapp")) { |
| //FIXME This is temporary |
| return false; |
| } |
| |
| // Don't include the sources jar files |
| if (name.endsWith("-sources.jar")) { |
| return false; |
| } |
| |
| // Include JAR and MAR files |
| if (name.endsWith(".jar")) { |
| return true; |
| } |
| if (name.endsWith(".mar")) { |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| /** |
| * A file name filter used to filter target/classes directories. |
| */ |
| private static class StandAloneDevelopmentClassesFileNameFilter implements FilenameFilter { |
| |
| public boolean accept(File dir, String name) { |
| name = name.toLowerCase(); |
| if (dir.getName().equals("target") && name.equals("classes")) { |
| |
| // Filter out the Tomcat and Webapp hosts |
| String dirPath = dir.getAbsolutePath(); |
| if (dirPath.endsWith("host-tomcat/target") || dirPath.endsWith("host-webapp/target")) { |
| //FIXME This is temporary |
| return false; |
| } |
| return true; |
| } |
| |
| // Filter out the Tomcat and Webapp hosts |
| if (name.startsWith("tuscany-host-tomcat") || name.startsWith("tuscany-host-webapp")) { |
| //FIXME This is temporary |
| return false; |
| } |
| |
| // Include JAR and MAR files |
| if (name.endsWith(".jar")) { |
| return true; |
| } |
| if (name.endsWith(".mar")) { |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| /** |
| * A file name filter used to filter JAR files. |
| */ |
| private static class WebAppJARFileNameFilter extends StandAloneJARFileNameFilter { |
| |
| @Override |
| public boolean accept(File dir, String name) { |
| if (!super.accept(dir, name)) { |
| return false; |
| } |
| name = name.toLowerCase(); |
| |
| // Exclude servlet-api JARs |
| if (name.startsWith("servlet-api")) { |
| return false; |
| } |
| |
| // Exclude the Tomcat and Jetty hosts |
| if (name.startsWith("tuscany-host-tomcat") || name.startsWith("tuscany-host-jetty")) { |
| //FIXME This is temporary |
| return false; |
| } |
| |
| return true; |
| } |
| } |
| |
| /** |
| * A file name filter used to filter the libraries in the \java\sca\distribution\all\target\modules |
| * directory |
| */ |
| private static class DistributionLibsFileNameFilter implements FilenameFilter { |
| |
| public boolean accept(File dir, String name) { |
| name = name.toLowerCase(); |
| |
| // Include subdirectories |
| if (new File(dir, name).isDirectory()) { |
| return true; |
| } |
| |
| // Filter out the Tuscany SCA jars - since the development versions of these are used |
| // from the \target\classes directories... |
| if (name.startsWith("tuscany")) { |
| // tuscany-sdo jars don't form part of the SCA modules... |
| if (name.startsWith("tuscany-sdo")) return true; |
| return false; |
| } |
| |
| // Include JAR and MAR files |
| if (name.endsWith(".jar")) { |
| return true; |
| } |
| if (name.endsWith(".mar")) { |
| return true; |
| } |
| return false; |
| } // end accept |
| } // end DistributionLibsFileNameFilter |
| |
| /** |
| * Returns the File object representing the given URL. |
| * |
| * @param url |
| * @return |
| */ |
| static File file(URL url) { |
| if (url == null || !url.getProtocol().equals("file")) { |
| return null; |
| } else { |
| String filename = url.getFile().replace('/', File.separatorChar); |
| int pos = 0; |
| while ((pos = filename.indexOf('%', pos)) >= 0) { |
| if (pos + 2 < filename.length()) { |
| String hexStr = filename.substring(pos + 1, pos + 3); |
| char ch = (char)Integer.parseInt(hexStr, 16); |
| filename = filename.substring(0, pos) + ch + filename.substring(pos + 3); |
| } |
| } |
| return new File(filename); |
| } |
| } |
| |
| /** |
| * Returns the location of the classpath entry, JAR, WAR etc. containing the given class. |
| * |
| * @param clazz |
| * @return |
| */ |
| static private URI codeLocation(Class<?> clazz) { |
| URL url = clazz.getProtectionDomain().getCodeSource().getLocation(); |
| return toURI(url); |
| } |
| |
| /** |
| * Collect JAR files under the given distribution directory. |
| * |
| * @param directory |
| * @param jarDirectoryURLs |
| * @param jarURLs |
| * @param filter |
| * @throws MalformedURLException |
| */ |
| private static void collectDevelopmentClasspathEntries(String directory, |
| Set<URL> jarDirectoryURLs, |
| Set<URL> jarURLs, |
| FilenameFilter filter) throws MalformedURLException { |
| File directoryFile = new File(directory); |
| URL directoryURL = directoryFile.toURI().toURL(); |
| if (!jarDirectoryURLs.contains(directoryURL) && directoryFile.exists()) { |
| |
| // Collect files under the given directory |
| jarDirectoryURLs.add(directoryURL); |
| collectTargetClassesClasspathEntries(directoryFile, jarURLs, filter); |
| |
| } |
| } // end collectDevelopmentClasspathEntries |
| |
| /** |
| * Collect the dependent Library JAR files for the development use of Tuscany |
| * It is assumed that these live in the \java\sca\distribution\all\target\modules |
| * directory, where the development modules live in \java\sca\modules, but that |
| * same directory also contains prebuilt versions of the Tuscany JARs, which must be |
| * filtered out so as not to clash with the development versions of the code |
| * |
| * @param directory - the \java\sca\modules directory |
| * @param jarDirectoryURLs |
| * @param jarURLs |
| * @throws MalformedURLException |
| */ |
| private static void collectDevelopmentLibraryEntries(File modulesDirectory, |
| Set<URL> jarDirectoryURLs, |
| Set<URL> jarURLs) throws MalformedURLException { |
| // Get the \java\sca directory |
| File rootDirectory = modulesDirectory.getParentFile(); |
| // Get the \java\sca\distribution\all\target\modules |
| String sep = File.separator; |
| File libsDirectory = new File(rootDirectory, "distribution" + sep + "all" + sep + "target" + sep + "modules"); |
| URL libsURL = libsDirectory.toURI().toURL(); |
| if (!jarDirectoryURLs.contains(libsURL) && libsDirectory.exists()) { |
| // Collect files under the libs module directory |
| jarDirectoryURLs.add(libsURL); |
| collectClasspathEntries(libsDirectory, jarURLs, new DistributionLibsFileNameFilter(), true); |
| } // end if |
| } // end collectDevelopmentLibraryEntries |
| |
| /** |
| * Generate a gateway bundle that aggregate other bundles to handle split packages |
| * @param bundleSymbolicNames |
| * @throws FileNotFoundException |
| * @throws IOException |
| */ |
| static InputStream generateGatewayBundle(Collection<String> bundleSymbolicNames, String bundleVersion, boolean reexport) |
| throws IOException { |
| Manifest manifest = new Manifest(); |
| Attributes attrs = manifest.getMainAttributes(); |
| StringBuffer requireBundle = new StringBuffer(); |
| for (String name : new HashSet<String>(bundleSymbolicNames)) { |
| requireBundle.append(name).append(";").append(RESOLUTION_DIRECTIVE).append(":=") |
| .append(RESOLUTION_OPTIONAL); |
| if (reexport) { |
| requireBundle.append(";").append(VISIBILITY_DIRECTIVE).append(":=").append(VISIBILITY_REEXPORT); |
| } |
| requireBundle.append(","); |
| } |
| int len = requireBundle.length(); |
| if (len > 0 && requireBundle.charAt(len - 1) == ',') { |
| requireBundle.deleteCharAt(len - 1); |
| attrs.putValue(REQUIRE_BUNDLE, requireBundle.toString()); |
| attrs.putValue("Manifest-Version", "1.0"); |
| attrs.putValue("Implementation-Vendor", "The Apache Software Foundation"); |
| attrs.putValue("Implementation-Vendor-Id", "org.apache"); |
| if (bundleVersion != null) { |
| attrs.putValue(BUNDLE_VERSION, bundleVersion); |
| } |
| attrs.putValue(BUNDLE_MANIFESTVERSION, "2"); |
| attrs.putValue(BUNDLE_SYMBOLICNAME, GATEWAY_BUNDLE); |
| attrs.putValue(BUNDLE_NAME, "Apache Tuscany SCA Gateway Bundle"); |
| attrs.putValue(BUNDLE_VENDOR, "The Apache Software Foundation"); |
| attrs.putValue(EXPORT_PACKAGE, "META-INF.services"); |
| attrs.putValue(DYNAMICIMPORT_PACKAGE, "*"); |
| attrs.putValue(BUNDLE_ACTIVATIONPOLICY, ACTIVATION_LAZY); |
| ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
| JarOutputStream jos = new JarOutputStream(bos, manifest); |
| jos.close(); |
| return new ByteArrayInputStream(bos.toByteArray()); |
| } else { |
| return null; |
| } |
| } |
| |
| } |
