/*

  * Copyright 2006-2011 The Kuali Foundation

  *

  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php

  *

  * 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.kuali.rice.kew.plugin;

 import org.apache.log4j.Logger;

 import org.kuali.rice.core.api.config.property.Config;

 import org.kuali.rice.core.api.config.property.ConfigContext;

 import org.kuali.rice.core.util.ClassLoaderUtils;

 import org.kuali.rice.kew.plugin.PluginUtils.PluginZipFileFilter;

 import java.io.File;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Set;

 /**

  * Checks for plugins added to or removed from the configured plugin directories.

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class HotDeployer implements Runnable {

         private static final Logger LOG = Logger.getLogger(HotDeployer.class);

         private PluginRegistry registry;

         private File sharedPluginDirectory;

         private List<String> pluginDirectories;

         public HotDeployer(PluginRegistry registry, File sharedPluginDirectory, List<String> pluginDirectories) {

                 this.registry = registry;

                 this.sharedPluginDirectory = sharedPluginDirectory;

                 this.pluginDirectories = pluginDirectories;

         }

         public synchronized void run() {

                 try {

                         LOG.debug("Checking for added and removed plugins...");

                         Set<PluginEnvironment> removedPlugins = getRemovedPlugins();

                         for (PluginEnvironment pluginContext : removedPlugins) {

                                 LOG.info("Detected a removed plugin '" + pluginContext.getPluginName() + "', shutting down plugin.");

                                 try {

                                         pluginContext.unload();

                                         registry.removePluginEnvironment(pluginContext.getPluginName());

                                 } catch (Exception e) {

                                         LOG.error("Failed to unload plugin '" + pluginContext.getPluginName() + "'", e);

                                 }

                         }

                         Set<PluginEnvironment> addedPlugins = getAddedPlugins();

                         for (PluginEnvironment pluginContext : addedPlugins) {

                                 try {

                                         LOG.info("Detected a new plugin.  Loading plugin...");

                                         pluginContext.load();

                                         LOG.info("...plugin '" + pluginContext.getPluginName() + "' loaded.");                                        

                                 } catch (Exception e) {

                                     // see: KULRICE-1184

                                     String pluginName= "<<unknown>>";

                                     if (pluginContext.getPlugin() != null) {

                                         pluginName = String.valueOf(pluginContext.getPluginName());

                                     }

                                         LOG.error("Failed to load plugin '" + pluginName + "'", e);

                                 } finally {

                                     // whether or not there is a load error, we want to add the environment to the registry, this prevents the registry

                                     // continuously trying to hot deploy a bad plugin

                                     registry.addPluginEnvironment(pluginContext);

                                 }

                         }

                 } catch (Exception e) {

                         LOG.warn("Failed to check for hot deploy.", e);

                 }

         }

         protected Set<PluginEnvironment> getRemovedPlugins() {

                 Set<PluginEnvironment> removedPlugins = new HashSet<PluginEnvironment>();

                 for (PluginEnvironment environment : registry.getPluginEnvironments()) {

                         if (environment.getLoader().isRemoved()) {

                                 removedPlugins.add(environment);

                         }

                 }

                 return removedPlugins;

         }

         protected Set<PluginEnvironment> getAddedPlugins() throws Exception {

                 Set<PluginEnvironment> addedPlugins = new HashSet<PluginEnvironment>();

                 Set<File> newPluginZipFiles = new HashSet<File>();

                 // for now, this implementation should watch the plugin directories for more plugins

                 // TODO somehow the code which checks for new plugins and which loads plugins initially needs to be

                 // consolidated, maybe with some sort of set of PluginLocators? or something along those lines?

                 for (String pluginDirName : pluginDirectories) {

                         File pluginDir = new File(pluginDirName);

                         if (pluginDir.exists() && pluginDir.isDirectory()) {

                                 File[] pluginDirFiles = pluginDir.listFiles(new PluginZipFileFilter());

                                 for (File pluginZip : pluginDirFiles) {

                                         int indexOf = pluginZip.getName().lastIndexOf(".zip");

                                         String pluginName = pluginZip.getName().substring(0, indexOf);

                                         // check to see if this plugin environment has already been loaded

                                         List<PluginEnvironment> currentEnvironments = registry.getPluginEnvironments();

                                         boolean pluginExists = false;

                                         for (PluginEnvironment environment : currentEnvironments) {

                                                 if (environment.getPluginName().equals(pluginName)) {

                                                         pluginExists = true;

                                                         break;

                                                 }

                                         }

                                         if (!pluginExists) {

                                                 // make sure the plugin's not in the process of being copied

                                                 long lastModified1 = pluginZip.lastModified();

                                                 Thread.sleep(100);

                                                 long lastModified2 = pluginZip.lastModified();

                                                 if (lastModified1 == lastModified2) {

                                                         newPluginZipFiles.add(pluginZip);

                                                 } else {

                                                         LOG.warn("Detected that the plugin zip is still being modified, holding off on hot deploy: " + pluginZip.getAbsolutePath());

                                                 }

                                         }

                                 }

                         }

                 }

                 ClassLoader parentClassLoader = ClassLoaderUtils.getDefaultClassLoader();

                 Config parentConfig = ConfigContext.getCurrentContextConfig();

                 for (File newPluginZipFile : newPluginZipFiles) {

                         PluginLoader loader = new ZipFilePluginLoader(newPluginZipFile, sharedPluginDirectory, parentClassLoader, parentConfig);

                         PluginEnvironment environment = new PluginEnvironment(loader, registry);

                         addedPlugins.add(environment);

                 }

                 return addedPlugins;

         }

 }