/*
 * 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;
        }
    }

}