*  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.

*/

* A GBean that knows how to download configurations from a Maven repository.

*

* @version $Rev: 780371 $ $Date: 2009-05-31 02:38:33 -0400 (Sun, 31 May 2009) $

*/

    private final static Log log = LogFactory.getLog(PluginInstallerGBean.class);

    private static int counter;

    private final ConfigurationManager configManager;

    private final GeronimoSourceRepository localSourceRepository;

    private final WritableListableRepository writeableRepo;

    private final ConfigurationStore configStore;

    private final ServerInfo serverInfo;

    private final Map<Object, DownloadResults> asyncKeys;

    private final ThreadPool threadPool;

    private final Collection<? extends ServerInstanceData> serverInstanceDatas;

    private final ClassLoader classLoader;

    private final Map<String, ServerInstance> servers = new HashMap<String, ServerInstance>();

    private final Collection<PersistentConfigurationList> persistentConfigurationLists;

    // This regular expression for repository filename is taken from Maven1Repository.MAVEN_1_PATTERN

    private static final Pattern MAVEN_1_PATTERN_PART = Pattern.compile("(.+)-([0-9].+)\\.([^0-9]+)");

    /**

     * GBean constructor.  Supply an existing ConfigurationManager.  Use for adding to the current server.

     *

     * @param configManager                Configuration Manager for this server

     * @param repository                   repository to install into

     * @param configStore                  configuration store to install into

     * @param serverInstanceDatas          set of server "layouts" to install config info into

     * @param serverInfo                   location of server

     * @param threadPool                   thread pool for async operations

     * @param artifactManager              artifact manager to resolve existing artifacts

     * @param persistentConfigurationLists used to start new plugins in a running server

     * @param classLoader                  classLoader @throws IOException exception if server instance cannot be loaded

     * @throws java.io.IOException from bad ServerInstance

     */

    public PluginInstallerGBean(ConfigurationManager configManager,

                                WritableListableRepository repository,

                                ConfigurationStore configStore,

                                Collection<? extends ServerInstanceData> serverInstanceDatas,

                                final ServerInfo serverInfo,

                                ThreadPool threadPool,

                                final ArtifactManager artifactManager,

                                Collection<PersistentConfigurationList> persistentConfigurationLists,

                                final ClassLoader classLoader) throws IOException {

        this.writeableRepo = repository;

        this.configStore = configStore;

        this.serverInfo = serverInfo;

        this.threadPool = threadPool;

        asyncKeys = Collections.synchronizedMap(new HashMap<Object, DownloadResults>());

        this.serverInstanceDatas = serverInstanceDatas;

        this.persistentConfigurationLists = persistentConfigurationLists == null ? Collections.<PersistentConfigurationList>emptyList() : persistentConfigurationLists;

        this.classLoader = classLoader;

        if (configManager == null) {

            throw new IllegalArgumentException("No default server instance set up");

        }

        this.configManager = configManager;

        localSourceRepository = new GeronimoSourceRepository(configManager.getRepositories(), configManager.getArtifactResolver());

        setUpServerInstances(serverInstanceDatas, serverInfo, artifactManager, servers, writeableRepo, true);

    }

    /**

     * Constructor for use in assembling a new server.

     *

     * @param serverInstanceDatas  set of server layouts

     * @param kernel               kernel for current server

     * @param classLoader          classLoader

     * @param targetRepositoryPath location of repo to install into (not in current server)

     * @param targetServerPath     location of server to install into (not current server

     * @throws IOException if layouts can't be loaded

     */

    public PluginInstallerGBean(String targetRepositoryPath,

                                String targetServerPath,

                                Collection<? extends ServerInstanceData> serverInstanceDatas,

                                final Kernel kernel,

                                final ClassLoader classLoader) throws Exception {

        final ArtifactManager artifactManager = new DefaultArtifactManager();

        FileUtils.forceMkdir(new File(targetServerPath));

        serverInfo = new BasicServerInfo(targetServerPath, false);

        File targetRepositoryFile = serverInfo.resolve(targetRepositoryPath);

        FileUtils.forceMkdir(targetRepositoryFile);

        writeableRepo = new Maven2Repository(targetRepositoryFile);

        configStore = new RepositoryConfigurationStore(writeableRepo);

        threadPool = null;

        asyncKeys = Collections.synchronizedMap(new HashMap<Object, DownloadResults>());

        this.serverInstanceDatas = serverInstanceDatas;

        this.persistentConfigurationLists = Collections.emptyList();

        this.classLoader = classLoader;

        setUpServerInstances(serverInstanceDatas, serverInfo, artifactManager, servers, writeableRepo, false);

        this.configManager = buildConfigurationManager(artifactManager, writeableRepo, kernel, configStore, classLoader, servers);

        localSourceRepository = new GeronimoSourceRepository(configManager.getRepositories(), configManager.getArtifactResolver());

    }

    private static void setUpServerInstances(Collection<? extends ServerInstanceData> serverInstanceDatas,

                                             final ServerInfo serverInfo, final ArtifactManager artifactManager,

                                             final Map<String, ServerInstance> servers,

                                             final WritableListableRepository writeableRepo,

                                             final boolean live) throws IOException {

        List<ServerInstanceData> datas = new ArrayList<ServerInstanceData>(serverInstanceDatas);

        boolean shrank = true;

        while (shrank) {

            shrank = false;

            for (Iterator<ServerInstanceData> it = datas.iterator(); it.hasNext();) {

                ServerInstanceData instance = it.next();

                String dependsOn = instance.getAttributeManagerFrom();

                if (dependsOn == null || servers.containsKey(dependsOn)) {

                    addServerInstance(instance, artifactManager, writeableRepo, serverInfo, servers, live);

                    it.remove();

                    shrank = true;

                }

            }

        }

        if (!datas.isEmpty()) {

            throw new IllegalStateException("Cannot resolve ServerInstanceDatas: " + datas);

        }

        if (serverInstanceDatas instanceof ReferenceCollection) {

            ((ReferenceCollection) serverInstanceDatas).addReferenceCollectionListener(new ReferenceCollectionListener() {

                public void memberAdded(ReferenceCollectionEvent event) {

                    ServerInstanceData instance = (ServerInstanceData) event.getMember();

                    try {

                        addServerInstance(instance, artifactManager, writeableRepo, serverInfo, servers, live);

                    } catch (IOException e) {

                        //nothing to do?? log???

                    }

                }

                public void memberRemoved(ReferenceCollectionEvent event) {

                    ServerInstanceData instance = (ServerInstanceData) event.getMember();

                    servers.remove(instance.getName());

                }

            });

        }

    }

    private static void addServerInstance(ServerInstanceData serverInstance,

                                          ArtifactManager artifactManager,

                                          WritableListableRepository targetRepo,

                                          ServerInfo serverInfo,

                                          Map<String, org.apache.geronimo.system.plugin.ServerInstance> servers,

                                          boolean live) throws IOException {

        File targetConfigDirectory = serverInfo.resolveServer(serverInstance.getConfigFile()).getParentFile();

        FileUtils.forceMkdir(targetConfigDirectory);

        org.apache.geronimo.system.plugin.ServerInstance instance = serverInstance.getServerInstance(artifactManager, targetRepo, serverInfo, servers, live);

        servers.put(instance.getServerName(), instance);

    }

    private static ConfigurationManager buildConfigurationManager(ArtifactManager artifactManager,

                                                                  WritableListableRepository targetRepo,

                                                                  Kernel kernel,

                                                                  ConfigurationStore targetStore,

                                                                  ClassLoader classloader,

                                                                  Map<String, org.apache.geronimo.system.plugin.ServerInstance> servers) throws IOException {

        for (ServerInstance instance : servers.values()) {

            if ("default".equals(instance.getServerName())) {

                KernelConfigurationManager configurationManager = new KernelConfigurationManager(kernel,

                        Collections.singleton(targetStore),

                        instance.getAttributeStore(),

                        (PersistentConfigurationList) instance.getAttributeStore(),

                        artifactManager,

                        instance.getArtifactResolver(),

                        Collections.singleton(targetRepo),

                        null,

                        classloader);

                configurationManager.setOnline(false);

                return configurationManager;

            }

        }

        throw new IllegalStateException("No default server instance found: " + servers.keySet());

    }

    /* now for tests only */

    PluginInstallerGBean(ConfigurationManager configManager, WritableListableRepository repository, ConfigurationStore configStore, ServerInfo serverInfo, ThreadPool threadPool, Collection<ServerInstance> servers) {

        this.configManager = configManager;

        localSourceRepository = new GeronimoSourceRepository(configManager.getRepositories(), configManager.getArtifactResolver());

        this.writeableRepo = repository;

        this.configStore = configStore;

        this.serverInfo = serverInfo;

        this.threadPool = threadPool;

        asyncKeys = Collections.synchronizedMap(new HashMap<Object, DownloadResults>());

        serverInstanceDatas = null;

        this.persistentConfigurationLists = Collections.emptyList();

        classLoader = null;

        for (ServerInstance instance : servers) {

            this.servers.put(instance.getServerName(), instance);

        }

        if (servers instanceof ReferenceCollection) {

            ((ReferenceCollection) servers).addReferenceCollectionListener(new ReferenceCollectionListener() {

                public void memberAdded(ReferenceCollectionEvent event) {

                    ServerInstance instance = (ServerInstance) event.getMember();

                    PluginInstallerGBean.this.servers.put(instance.getServerName(), instance);

                }

                public void memberRemoved(ReferenceCollectionEvent event) {

                    ServerInstance instance = (ServerInstance) event.getMember();

                    PluginInstallerGBean.this.servers.remove(instance.getServerName());

                }

            });

        }

    }

    /**

     * This more or less clones the current PluginInstallerGBean to create one with the same server instances (structure) but using

     * the current server as config store and assembling a server in a provided location.

     *

     * @param targetRepositoryPath     location of repository in new server (normally "repository")

     * @param relativeTargetServerPath Location of server to assemble relative to current server

     * @param pluginList               list of plugins to install

     * @throws Exception if something goes wrong

     */

    public DownloadResults installPluginList(String targetRepositoryPath, String relativeTargetServerPath, PluginListType pluginList) throws Exception {

        DownloadResults downloadPoller = new DownloadResults();

        File targetServerPath = serverInfo.resolveServer(relativeTargetServerPath);

        if (targetServerPath.exists()) {

          FileUtils.forceDelete(targetServerPath);

        }

        String targetServerPathName = targetServerPath.getAbsolutePath();

        Kernel kernel = new BasicKernel("assembly");

        try {

            PluginInstallerGBean installer = new PluginInstallerGBean(

                    targetRepositoryPath,

                    targetServerPathName,

                    serverInstanceDatas,

                    kernel,

                    classLoader);

            installer.install(pluginList, localSourceRepository, true, null, null, downloadPoller);

        } finally {

            kernel.shutdown();

        }

        return downloadPoller;

    }

    public void mergeOverrides(String server, AttributesType overrides) throws InvalidGBeanException, IOException {

        ServerInstance serverInstance = servers.get(server);

        if (serverInstance == null) {

            throw new NullPointerException("No such server: " + server + ", known servers: " + servers.keySet());

        }

        PluginAttributeStore attributeStore = serverInstance.getAttributeStore();

        for (ModuleType module: overrides.getModule()) {

            Artifact artifact = Artifact.create(module.getName());

            attributeStore.setModuleGBeans(artifact, module.getGbean(), module.isLoad(), module.getCondition());

            attributeStore.save();

        }

        if (overrides.getConfiguration().size() > 0) {

            throw new UnsupportedOperationException("Use modules, not configurations");

        }

    }

    /**

     * Lists the plugins installed in the local Geronimo server, by name and

     * ID.

     *

     * @return A Map with key type String (plugin name) and value type Artifact

     *         (config ID of the plugin).

     */

    public Map getInstalledPlugins() {

        SortedSet<Artifact> artifacts = writeableRepo.list();

        Map<String, Artifact> plugins = new HashMap<String, Artifact>();

        for (Artifact configId : artifacts) {

            File dir = writeableRepo.getLocation(configId);

            if (dir.isDirectory()) {

                File meta = new File(dir, "META-INF");

                if (!meta.isDirectory() || !meta.canRead()) {

                    continue;

                }

                File xml = new File(meta, "geronimo-plugin.xml");

                if (!xml.isFile() || !xml.canRead() || xml.length() == 0) {

                    continue;

                }

                readNameAndID(xml, plugins);

            } else {

                if (!dir.isFile() || !dir.canRead()) {

                    log.error("Cannot read artifact dir " + dir.getAbsolutePath());

                    throw new IllegalStateException("Cannot read artifact dir " + dir.getAbsolutePath());

                }

                try {

                    JarFile jar = new JarFile(dir);

                    try {

                        ZipEntry entry = jar.getEntry("META-INF/geronimo-plugin.xml");

                        if (entry == null) {

                            continue;

                        }

                        InputStream in = jar.getInputStream(entry);

                        readNameAndID(in, plugins);

                        in.close();

                    } finally {

                        jar.close();

                    }

                } catch (IOException e) {

                    log.error("Unable to read JAR file " + dir.getAbsolutePath(), e);

                }

            }

        }

        return plugins;

    }

    /**

     * Gets a ConfigurationMetadata for a configuration installed in the local

     * server.  Should load a saved one if available, or else create a new

     * default one to the best of its abilities.

     *

     * @param moduleId Identifies the configuration.  This must match a

     *                 configuration currently installed in the local server.

     *                 The configId must be fully resolved (isResolved() == true)

     */

    public PluginType getPluginMetadata(Artifact moduleId) {

        PluginType type = localSourceRepository.extractPluginMetadata(moduleId);

        if (null == type) {

            try {

                type = createDefaultMetadata(moduleId);

            } catch (InvalidConfigException e) {

                log.warn("Unable to generate metadata for " + moduleId, e);

            } catch (Exception e) {

                log.warn("Error generating metadata for " + moduleId, e);

            }

        }

        return type;

    }

    /**

     * Saves a ConfigurationMetadata for a particular plugin, if the server is

     * able to record it.  This can be used if you later re-export the plugin,

     * or just want to review the information for a particular installed

     * plugin.

     *

     * @param metadata The data to save.  The contained configId (which must

     *                 be fully resolved) identifies the configuration to save

     *                 this for.

     */

    public void updatePluginMetadata(PluginType metadata) {

        PluginArtifactType instance = metadata.getPluginArtifact().get(0);

        Artifact artifact = toArtifact(instance.getModuleId());

        File dir = writeableRepo.getLocation(artifact);

        if (dir == null) {

            log.error(artifact + " is not installed.");

            throw new IllegalArgumentException(artifact + " is not installed.");

        }

        if (!dir.isDirectory()) { // must be a packed (JAR-formatted) plugin

            try {

                File temp = new File(dir.getParentFile(), dir.getName() + ".temp");

                JarFile input = new JarFile(dir);

                Manifest manifest = input.getManifest();

                JarOutputStream out = manifest == null ? new JarOutputStream(

                        new BufferedOutputStream(new FileOutputStream(temp)))

                        : new JarOutputStream(new BufferedOutputStream(new FileOutputStream(temp)), manifest);

                Enumeration en = input.entries();

                byte[] buf = new byte[4096];

                int count;

                while (en.hasMoreElements()) {

                    JarEntry entry = (JarEntry) en.nextElement();

                    if (entry.getName().equals("META-INF/geronimo-plugin.xml")) {

                        entry = new JarEntry(entry.getName());

                        out.putNextEntry(entry);

                        PluginXmlUtil.writePluginMetadata(metadata, out);

                    } else if (entry.getName().equals("META-INF/MANIFEST.MF")) {

                        // do nothing, already passed in a manifest

                    } else {

                        out.putNextEntry(entry);

                        InputStream in = input.getInputStream(entry);

                        while ((count = in.read(buf)) > -1) {

                            out.write(buf, 0, count);

                        }

                        in.close();

                        out.closeEntry();

                    }

                }

                out.flush();

                out.close();

                input.close();

                if (!dir.delete()) {

                    log.error("Unable to delete old plugin at " + dir.getAbsolutePath());

                    throw new IOException("Unable to delete old plugin at " + dir.getAbsolutePath());

                }

                if (!temp.renameTo(dir)) {

                    log.error("Unable to move new plugin " + temp.getAbsolutePath() + " to " + dir.getAbsolutePath());

                    throw new IOException(

                            "Unable to move new plugin " + temp.getAbsolutePath() + " to " + dir.getAbsolutePath());

                }

            } catch (Exception e) {

                log.error("Unable to update plugin metadata", e);

                throw new RuntimeException("Unable to update plugin metadata", e);

            } // TODO this really should have a finally block to ensure streams are closed

        } else {

            File meta = new File(dir, "META-INF");

            if (!meta.isDirectory() || !meta.canRead()) {

                log.error(artifact + " is not a plugin.");

                throw new IllegalArgumentException(artifact + " is not a plugin.");

            }

            File xml = new File(meta, "geronimo-plugin.xml");

            FileOutputStream fos = null;

            try {

                if (!xml.isFile()) {

                    if (!xml.createNewFile()) {

                        log.error("Cannot create plugin metadata file for " + artifact);

                        throw new RuntimeException("Cannot create plugin metadata file for " + artifact);

                    }

                }

                fos = new FileOutputStream(xml);

                PluginXmlUtil.writePluginMetadata(metadata, fos);

            } catch (Exception e) {

                log.error("Unable to save plugin metadata for " + artifact, e);

            } finally {

                if (fos != null) {

                    try {

                        fos.close();

                    } catch (IOException ignored) {

                        // ignored

                    }

                }

            }

        }

    }

    /**

     * Lists the plugins available for download in a particular Geronimo repository.

     *

     * @param mavenRepository The base URL to the maven repository.  This must

     *                        contain the file geronimo-plugins.xml

     * @param username        Optional username, if the maven repo uses HTTP Basic authentication.

     *                        Set this to null if no authentication is required.

     * @param password        Optional password, if the maven repo uses HTTP Basic authentication.

     *                        Set this to null if no authentication is required.

     */

    public PluginListType listPlugins(URL mavenRepository, String username, String password) throws IOException, FailedLoginException {

        try {

            SourceRepository repo = SourceRepositoryFactory.getSourceRepository(mavenRepository.toString(), username, password);

            return repo.getPluginList();

        } catch (IllegalStateException e) {

            return null;

        }

    }

    private SourceRepository getDefaultSourceRepository(String defaultRepository,

                                                        boolean restrictToDefaultRepository) {

        if (restrictToDefaultRepository && defaultRepository == null) {

            throw new IllegalArgumentException("You must supply a default repository if you want to restrict to it");

        }

        SourceRepository defaultSourceRepository = defaultRepository == null ? null : SourceRepositoryFactory.getSourceRepository(defaultRepository);

        return defaultSourceRepository;

    }

   

    /**

     * Installs a configuration from a remote repository into the local Geronimo server,

     * including all its dependencies.  The caller will get the results when the

     * operation completes.  Note that this method does not throw exceptions on failure,

     * but instead sets the failure property of the DownloadResults.

     *

     * @param pluginsToInstall            The list of configurations to install

     * @param defaultRepository           Default repo to look for plugins in

     * @param restrictToDefaultRepository Whether to follow hints to other plugin repos.

     * @param username                    Optional username, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     * @param password                    Optional password, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     */

    public DownloadResults install(PluginListType pluginsToInstall, String defaultRepository, boolean restrictToDefaultRepository, String username, String password) {

        DownloadResults results = new DownloadResults();

        install(pluginsToInstall, defaultRepository, restrictToDefaultRepository, username, password, results);

        return results;

    }

    /**

     * Installs a configuration from a remote repository into the local Geronimo server,

     * including all its dependencies.  The method blocks until the operation completes,

     * but the caller will be notified of progress frequently along the way (using the

     * supplied DownloadPoller).  Therefore the caller is meant to create the poller and

     * then call this method in a background thread.  Note that this method does not

     * throw exceptions on failure, but instead sets the failure property of the

     * DownloadPoller.

     *

     * @param pluginsToInstall            The list of configurations to install

     * @param defaultRepository           Default repo to look for plugins in (not required)

     * @param restrictToDefaultRepository Whether to follow hints to other plugin repos.

     * @param username                    Optional username, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     * @param password                    Optional password, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     * @param poller                      Will be notified with status updates as the download proceeds

     */

    public void install(PluginListType pluginsToInstall, String defaultRepository, boolean restrictToDefaultRepository, String username, String password, DownloadPoller poller) {

        SourceRepository defaultSourceRepository = getDefaultSourceRepository(defaultRepository, restrictToDefaultRepository);

        install(pluginsToInstall, defaultSourceRepository, restrictToDefaultRepository, username, password, poller);

    }

    public void install(PluginListType pluginsToInstall, SourceRepository defaultRepository, boolean restrictToDefaultRepository, String username, String password, DownloadPoller poller) {

        install(pluginsToInstall, defaultRepository, restrictToDefaultRepository, username, password, poller, true);

    }

   

    public void install(PluginListType pluginsToInstall, SourceRepository defaultRepository, boolean restrictToDefaultRepository, String username, String password, DownloadPoller poller, boolean validatePlugins) {

        List<Artifact> downloadedArtifacts = new ArrayList<Artifact>();

        try {

            Map<Artifact, PluginType> metaMap = new HashMap<Artifact, PluginType>();

            // Step 1: validate everything

            List<PluginType> toInstall = new ArrayList<PluginType>();

            for (PluginType metadata : pluginsToInstall.getPlugin()) {

                try {

                    if (validatePlugins) {

                        validatePlugin(metadata);

                        verifyPrerequisites(metadata);

                    }

                    PluginArtifactType instance = metadata.getPluginArtifact().get(0);

                    if (instance.getModuleId() != null) {

                        metaMap.put(toArtifact(instance.getModuleId()), metadata);

                    }

                    toInstall.add(metadata);

                } catch (MissingDependencyException e) {

                    poller.addSkippedConfigID(e);

                }

            }

            // Step 2: everything is valid, do the installation

            for (PluginType metadata : toInstall) {

                // 2. Unload obsoleted configurations

                PluginArtifactType instance = metadata.getPluginArtifact().get(0);

                List<Artifact> obsoletes = new ArrayList<Artifact>();

                for (ArtifactType obs : instance.getObsoletes()) {

                    Artifact obsolete = toArtifact(obs);

                    Artifact[] list = configManager.getArtifactResolver().queryArtifacts(obsolete);

                    for (Artifact artifact : list) {

                        if (configManager.isLoaded(artifact)) {

                            if (configManager.isRunning(artifact)) {

                                configManager.stopConfiguration(artifact);

                            }

                            configManager.unloadConfiguration(artifact);

                            obsoletes.add(artifact);

                        }

                    }

                }

                // 3. Download the artifact if necessary, and its dependencies

                Set<Artifact> working = new HashSet<Artifact>();

                Stack<Artifact> parentStack = new Stack<Artifact>();

                if (instance.getModuleId() != null) {

                    Artifact entry = toArtifact(instance.getModuleId());

                    List<SourceRepository> repos = getRepos(pluginsToInstall, defaultRepository, restrictToDefaultRepository, instance);

                    downloadArtifact(entry, metaMap, repos,

                            username, password, new ResultsFileWriteMonitor(poller), working, parentStack, false, servers, true);

                    downloadedArtifacts.add(entry);

                } else {

                    List<DependencyType> deps = instance.getDependency();

                    for (DependencyType dep : deps) {

                        Artifact entry = toArtifact(dep);

                        List<SourceRepository> repos = getRepos(pluginsToInstall, defaultRepository, restrictToDefaultRepository, instance);

                        downloadArtifact(entry, metaMap, repos,

                                username, password, new ResultsFileWriteMonitor(poller), working, parentStack, false, servers, dep.isStart());

                        downloadedArtifacts.add(entry);

                    }

                }

                // 4. Uninstall obsolete configurations

                for (Artifact artifact : obsoletes) {

                    configManager.uninstallConfiguration(artifact);

                }

                // 5. Installation of this configuration finished successfully

            }

            // Step 3: Start anything that's marked accordingly

            if (configManager.isOnline()) {

                poller.setCurrentFilePercent(-1);

                for (PersistentConfigurationList persistentConfigurationList : persistentConfigurationLists) {

                    List<Artifact> artifacts = persistentConfigurationList.restore();

                    for (Artifact artifact : artifacts) {

                        if (!configManager.isRunning(artifact)) {

                            poller.setCurrentMessage("Starting " + artifact);

              if (!configManager.isLoaded(artifact)) {

                                try {

                                    configManager.loadConfiguration(artifact);

                                } catch (Exception e) {

                                    log.error("Unable to load configuration. ", e);

                                    configManager.uninstallConfiguration(artifact);

                                }

                            }

                            if (configManager.isLoaded(artifact)) {

                                configManager.startConfiguration(artifact);

                            }

                        }

                    }

                }

            }

            //ensure config.xml is saved.

            for (org.apache.geronimo.system.plugin.ServerInstance serverInstance : servers.values()) {

                serverInstance.getAttributeStore().save();

            }

        } catch (Exception e) {

            log.error("Unable to install plugin. ", e);

            poller.setFailure(e);

            //Attempt to cleanup a failed plugin installation

            for (Artifact artifact : downloadedArtifacts) {

                try {

                    configManager.uninstallConfiguration(artifact);

                } catch (Exception e2) {

                    log.warn("Warning: ",e2);

                }

            }

        } finally {

            poller.setFinished();

        }

    }

    private List<SourceRepository> getRepos(PluginListType pluginsToInstall, SourceRepository defaultRepository, boolean restrictToDefaultRepository, PluginArtifactType instance) {

        List<SourceRepository> repos = new ArrayList<SourceRepository>();

        if (defaultRepository != null) {

            repos.add(defaultRepository);

        }

        if (!restrictToDefaultRepository) {

            if (!instance.getSourceRepository().isEmpty()) {

                addRepos(repos, instance.getSourceRepository());

            }

           

            //always add the default repository location no matter if the plugin instance contains source-repository.

            addRepos(repos, pluginsToInstall.getDefaultRepository());

        }

        return repos;

    }

    private void addRepos(List<SourceRepository> repos, List<String> repoLocations) {

        for (String repoLocation : repoLocations) {

            try {

                SourceRepository repo = SourceRepositoryFactory.getSourceRepository(repoLocation);

                repos.add(repo);

            } catch (IllegalStateException e) {

                log.warn("Invalid repository: " + repoLocation, e);

            }

        }

    }

    /**

     * Installs a configuration from a remote repository into the local Geronimo server,

     * including all its dependencies.  The method returns immediately, providing a key

     * that can be used to poll the status of the download operation.  Note that the

     * installation does not throw exceptions on failure, but instead sets the failure

     * property of the DownloadResults that the caller can poll for.

     *

     * @param pluginsToInstall            The list of configurations to install

     * @param defaultRepository           Default repo to look for plugins in

     * @param restrictToDefaultRepository Whether to follow hints to other plugin repos.

     * @param username                    Optional username, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     * @param password                    Optional password, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required. @return A key that can be passed to checkOnInstall

     */

    public Object startInstall(final PluginListType pluginsToInstall, final String defaultRepository, final boolean restrictToDefaultRepository, final String username, final String password) {

        Object key = getNextKey();

        final DownloadResults results = new DownloadResults();

        Runnable work = new Runnable() {

            public void run() {

                install(pluginsToInstall, defaultRepository, restrictToDefaultRepository, username, password, results);

            }

        };

        asyncKeys.put(key, results);

        try {

            threadPool.execute("Configuration Installer", work);

        } catch (InterruptedException e) {

            log.error("Unable to start work", e);

            throw new RuntimeException("Unable to start work", e);

        }

        return key;

    }

    /**

     * Installs a configuration downloaded from a remote repository into the local Geronimo

     * server, including all its dependencies.  The method returns immediately, providing a

     * key that can be used to poll the status of the download operation.  Note that the

     * installation does not throw exceptions on failure, but instead sets the failure

     * property of the DownloadResults that the caller can poll for.

     *

     * @param carFile                     A CAR file downloaded from a remote repository.  This is a packaged

     *                                    configuration with included configuration information, but it may

     *                                    still have external dependencies that need to be downloaded

     *                                    separately.  The metadata in the CAR file includes a repository URL

     *                                    for these downloads, and the username and password arguments are

     *                                    used in conjunction with that.

     * @param defaultRepository           Default repo to look for plugins in

     * @param restrictToDefaultRepository Whether to follow hints to other plugin repos.

     * @param username                    Optional username, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required.

     * @param password                    Optional password, if the maven repo uses HTTP Basic authentication.

     *                                    Set this to null if no authentication is required. @return A key that can be passed to checkOnInstall

     */

    public Object startInstall(final File carFile, final String defaultRepository, final boolean restrictToDefaultRepository, final String username, final String password) {

        Object key = getNextKey();

        final DownloadResults results = new DownloadResults();

        Runnable work = new Runnable() {

            public void run() {

                install(carFile, defaultRepository, restrictToDefaultRepository, username, password, results);

            }

        };

        asyncKeys.put(key, results);

        try {

            threadPool.execute("Configuration Installer", work);

        } catch (InterruptedException e) {

            log.error("Unable to start work", e);

            throw new RuntimeException("Unable to start work", e);

        }

        return key;

    }

    /**

     * Gets the current progress of a download operation.  Note that once the

     * DownloadResults is returned for this operation shows isFinished = true,

     * the operation will be forgotten, so the caller should be careful not to

     * call this again after the download has finished.

     *

     * @param key Identifies the operation to check on

     */

    public DownloadResults checkOnInstall(Object key) {

        return checkOnInstall(key, true);

    }

   

    /**

     * Gets the current progress of a download operation. 

     *

     * @param key Identifies the operation to check on

     * @param remove If true and the download operation has finished, the DownloadResults

     *        will be forgotten and the next call to this function will return null.

     *        Otherwise, the DownloadResults will be retained until this function is

     *        called with the <tt>remove</tt> parameter set to true. This parameter is

     *        only used when the download operation has finished

     *        (DownloadResults.isFinished() returns true).

     */

    public DownloadResults checkOnInstall(Object key, boolean remove) {

        DownloadResults results = asyncKeys.get(key);

        if (results != null) {              

            results = results.duplicate();

            if (results.isFinished() && remove) {

                asyncKeys.remove(key);

            }

        }

        return results;

    }

    /**

     * Installs from a pre-downloaded CAR file

     *

     * @param carFile                     care file to install

     * @param defaultRepository           Default repo to look for plugins in

     * @param restrictToDefaultRepository Whether to follow hints to other plugin repos.

     * @param username                    repo username

     * @param password                    repo password

     * @param poller                      monitor for reporting progress

     */

    public void install(File carFile, String defaultRepository, boolean restrictToDefaultRepository, String username, String password, DownloadPoller poller) {

        try {

            // 1. Extract the configuration metadata

            PluginType data = GeronimoSourceRepository.extractPluginMetadata(carFile);

            if (data == null) {

                log.error("Invalid Configuration Archive " + carFile.getAbsolutePath() + " no plugin metadata found");

                throw new IllegalArgumentException(

                        "Invalid Configuration Archive " + carFile.getAbsolutePath() + " no plugin metadata found");

            }

            // 2. Validate that we can install this

            validatePlugin(data);

            verifyPrerequisites(data);

           

            PluginArtifactType instance = data.getPluginArtifact().get(0);

            // 3. Install the CAR into the repository (it shouldn't be re-downloaded)

            if (instance.getModuleId() != null) {

                Artifact pluginArtifact = toArtifact(instance.getModuleId());

                ResultsFileWriteMonitor monitor = new ResultsFileWriteMonitor(poller);

                writeableRepo.copyToRepository(carFile, pluginArtifact, monitor);

                installConfigXMLData(pluginArtifact, instance, servers, true);

                if (instance.getCopyFile() != null) {

                    extractPluginFiles(pluginArtifact, data, monitor);

                }

            }

            // 4. Use the standard logic to remove obsoletes, install dependencies, etc.

            PluginListType pluginList = new PluginListType();

            pluginList.getPlugin().add(data);

            pluginList.getDefaultRepository().addAll(instance.getSourceRepository());

           

            SourceRepository defaultSourceRepository = getDefaultSourceRepository(defaultRepository, restrictToDefaultRepository);

           

            install(pluginList, defaultSourceRepository, restrictToDefaultRepository, username, password, poller, false);

        } catch (Exception e) {

            poller.setFailure(e);

        } finally {

            poller.setFinished();

        }

    }

    /**

     * Ensures that a plugin is installable.

     *

     * @param plugin plugin to check

     * @throws org.apache.geronimo.kernel.repository.MissingDependencyException

     *          if plugin requires a dependency that is not present

     */

    public void validatePlugin(PluginType plugin) throws MissingDependencyException {

        if (plugin.getPluginArtifact().size() != 1) {

            throw new MissingDependencyException("A plugin configuration must include one plugin artifact, not " + plugin.getPluginArtifact().size(), null, (Stack<Artifact>) null);

        }

        PluginArtifactType metadata = plugin.getPluginArtifact().get(0);

        // 1. Check that it's not already installed

        if (metadata.getModuleId() != null) { // that is, it's a real configuration not a plugin list

            Artifact artifact = toArtifact(metadata.getModuleId());

            if (configManager.isInstalled(artifact)) {

                boolean upgrade = false;

                for (ArtifactType obsolete : metadata.getObsoletes()) {

                    Artifact test = toArtifact(obsolete);

                    if (test.matches(artifact)) {

                        upgrade = true;

                        break;

                    }

                }

                if (!upgrade) {

                    log.debug("Configuration " + artifact + " is already installed.");

                    throw new MissingDependencyException(

                            "Configuration " + artifact + " is already installed.", toArtifact(metadata.getModuleId()), (Stack<Artifact>) null);

                }

            }

        }

        // 2. Check that we meet the Geronimo, JVM versions

        if (metadata.getGeronimoVersion().size() > 0 && !checkGeronimoVersions(metadata.getGeronimoVersion())) {

            log.debug("Plugin " + toArtifact(metadata.getModuleId()) + " is not installable on Geronimo " + serverInfo.getVersion());

            throw new MissingDependencyException(

                    "Plugin is not installable on Geronimo " + serverInfo.getVersion(), toArtifact(metadata.getModuleId()), (Stack<Artifact>) null);

        }

        if (metadata.getJvmVersion().size() > 0 && !checkJVMVersions(metadata.getJvmVersion())) {

            log.debug("Plugin " + toArtifact(metadata.getModuleId()) + " is not installable on JVM " + System.getProperty("java.version"));

            throw new MissingDependencyException(

                    "Plugin is not installable on JVM " + System.getProperty("java.version"), toArtifact(metadata.getModuleId()), (Stack<Artifact>) null);

        }

    }

    /**

     * Ensures that a plugin's prerequisites are installed

     *

     * @param plugin plugin artifact to check

     * @return array of missing depedencies

     */

    public Dependency[] checkPrerequisites(PluginType plugin) {

        List<Dependency> missingPrereqs = getMissingPrerequisites(plugin);

        return missingPrereqs.toArray(new Dependency[missingPrereqs.size()]);

    }

    private List<Dependency> getMissingPrerequisites(PluginType plugin) {

        if (plugin.getPluginArtifact().size() != 1) {

            throw new IllegalArgumentException("A plugin configuration must include one plugin artifact, not " + plugin.getPluginArtifact().size());

        }

        PluginArtifactType metadata = plugin.getPluginArtifact().get(0);

        List<PrerequisiteType> prereqs = metadata.getPrerequisite();

        ArrayList<Dependency> missingPrereqs = new ArrayList<Dependency>();

        for (PrerequisiteType prereq : prereqs) {

            Artifact artifact = toArtifact(prereq.getId());

            try {

                if (getServerInstance("default", servers).getArtifactResolver().queryArtifacts(artifact).length == 0) {

                    missingPrereqs.add(new Dependency(artifact, ImportType.ALL));

                }

            } catch (NoServerInstanceException e) {

                throw new RuntimeException("Invalid setup, no default server instance registered");

            }

        }

        return missingPrereqs;

    }

    private void verifyPrerequisites(PluginType plugin) throws MissingDependencyException {

        List<Dependency> missingPrereqs = getMissingPrerequisites(plugin);

        if (!missingPrereqs.isEmpty()) {

            PluginArtifactType metadata = plugin.getPluginArtifact().get(0);

            Artifact moduleId = toArtifact(metadata.getModuleId());

            StringBuffer buf = new StringBuffer();

            buf.append(moduleId.toString()).append(" requires ");

            Iterator<Dependency> iter = missingPrereqs.iterator();

            while (iter.hasNext()) {

                buf.append(iter.next().getArtifact().toString());

                if (iter.hasNext()) {

                    buf.append(", ");

                }

            }

            buf.append(" to be installed");

            throw new MissingDependencyException(buf.toString(), null, (Artifact) null);

        }

    }

    public Artifact installLibrary(File libFile, String groupId) throws IOException {

        Matcher matcher = MAVEN_1_PATTERN_PART.matcher("");

        matcher.reset(libFile.getName());

        if (matcher.matches()) {

            String artifactId = matcher.group(1);

            String version = matcher.group(2);

            String type = matcher.group(3);

            Artifact artifact = new Artifact(groupId != null ? groupId : Artifact.DEFAULT_GROUP_ID, artifactId, version, type);

            writeableRepo.copyToRepository(libFile, artifact, null);

            return artifact;

        } else {

            throw new IllegalArgumentException("Filename " + libFile.getName() + " is not in the form <artifact>-<version>.<type>, for e.g. mylib-1.0.jar.");

        }

    }

    /**

     * Download (if necessary) and install something, which may be a Configuration or may

     * be just a JAR.  For each artifact processed, all its dependencies will be

     * processed as well.

     *

     * @param configID     Identifies the artifact to install

     * @param metadata     name to plugin map

     * @param repos        The URLs to contact the repositories (in order of preference)

     * @param username     The username used for repositories secured with HTTP Basic authentication

     * @param password     The password used for repositories secured with HTTP Basic authentication

     * @param monitor      The ongoing results of the download operations, with some monitoring logic

     * @param soFar        The set of dependencies already downloaded.

     * @param parentStack  chain of modules that led to this dependency

     * @param dependency   Is this a dependency or the original artifact?

     * @param servers      server layouts to install config info into

     * @param loadOverride If false prevents setting load="true" in server instances (recursively through dependencies)

     * @throws FailedLoginException       When a repository requires authentication and either no username

     *                                    and password are supplied or the username and password supplied

     *                                    are not accepted

     * @throws MissingDependencyException When a dependency cannot be located in any of the listed repositories

     * @throws NoServerInstanceException  when no server descriptor is found for a specified configuration bit

     * @throws java.io.IOException        when a IO problem occurs

     */

    private void downloadArtifact(Artifact configID, Map<Artifact, PluginType> metadata, List<SourceRepository> repos, String username, String password, ResultsFileWriteMonitor monitor, Set<Artifact> soFar, Stack<Artifact> parentStack, boolean dependency, Map<String, ServerInstance> servers, boolean loadOverride) throws IOException, FailedLoginException, MissingDependencyException, NoServerInstanceException {

        if (soFar.contains(configID)) {

            return; // Avoid endless work due to circular dependencies

        } else {

            soFar.add(configID);

        }

        // Download and install the main artifact

        boolean pluginWasInstalled = false;

        Artifact[] matches = configManager.getArtifactResolver().queryArtifacts(configID);

        PluginArtifactType instance = null;

        if (matches.length == 0) {

            // not present, needs to be downloaded

            monitor.getResults().setCurrentMessage("Downloading " + configID);

            monitor.getResults().setCurrentFilePercent(-1);

            OpenResult result = null;

            for (SourceRepository repository : repos) {

                result = repository.open(configID, monitor);

                if (result != null) {

                    break;

                }

            }

            if (result == null) {

                throw new IllegalArgumentException("Could not find " + configID + " in any repo");

            }

            // Check if the result is already in server's repository

            if (configManager.getArtifactResolver().queryArtifacts(result.getArtifact()).length > 0) {

                String msg = "Not downloading " + configID + ". Query for " + configID + " resulted in " + result.getArtifact()

                        + " which is already available in server's repository.";

                monitor.getResults().setCurrentMessage(msg);

                log.info(msg);

                result.close();

                return;

            }

            try {

                File tempFile = result.getFile();

                if (tempFile == null) {

                    log.error("Null filehandle was returned for " + configID);

                    throw new IllegalArgumentException("Null filehandle was returned for " + configID);

                }

                PluginType pluginData = metadata.get(configID);

                // Only bother with the hash if we got it from a source other than the download file itself

                HashType hash = pluginData == null ? null : pluginData.getPluginArtifact().get(0).getHash();

                if (hash != null) {

                    String actual = ConfigurationStoreUtil.getActualChecksum(tempFile, hash.getType());

                    if (!actual.equals(hash.getValue())) {

                        log.error(

                                "File download incorrect (expected " + hash.getType() + " hash " + hash.getValue() + " but got " + actual + ")");

                        throw new IOException(

                                "File download incorrect (expected " + hash.getType() + " hash " + hash.getValue() + " but got " + actual + ")");