/*

 Copyright (c) 2006, University of Tromsø

 All rights reserved.

 Redistribution and use in source and binary forms, with or without 

 modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 

    of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice, this 

    list of conditions and the following disclaimer in the documentation and/or other 

    materials provided with the distribution.

  * Neither the name of the University of Tromsø nor the names of its contributors may 

    be used to endorse or promote products derived from this software without specific 

    prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 

 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 

 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 

 SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 

 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 

 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 

 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 

 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 

 DAMAGE.

 */

 package argos.deploy;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.logging.Logger;

 import javax.management.MBeanNotificationInfo;

 import javax.management.Notification;

 import argos.annotation.Description;

 import argos.annotation.Instrument;

 import argos.annotation.NotificationInfo;

 import argos.annotation.NotificationSender;

 import argos.annotation.RemoveInstrumentation;

 import argos.config.Config;

 import argos.metadata.ServiceMetaInfo;

 import argos.naming.NamingService;

 import argos.proxy.NotificationProxy;

 /**

  * Created on 05.jul.2006

  * 

  * @author Dan Peder Eriksen

  */

 @RemoveInstrumentation

 @Description("Loads new jar files (services)")

 public class HotDeployer extends Thread {

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

         private static HotDeployer singelton = new HotDeployer();

         public static final String NEW_FILE_FOUND = "NEW_FILE_FOUND";

         public static final String DEPLOY_FILE_MISSING = "DEPLOY_FILE_MISSING";

         public static final String NOT_LOADING_FILE = "NOT_LOADING";

         public static final String FILE_UPDATED = "FILE_UPDATED";

         public static final String UNDEPLOY_FILE = "UNDEPLOY_FILE";

         public static final String DEPLOY_FILE = "deploy.xml";

         public static final int DEFAULT_SLEEP_TIME = 1000;

         private String directory;

         private int sleepTime;

         private List<File> ignored;

         private Map<String, Long> timestamps;

         private boolean running;

         @NotificationSender

         public NotificationProxy proxy;

         private long seq;

         private HotDeployer() {

                 super("HotDeployer");

                 seq = 0;

                 directory = Config.get(Config.DEFAULT_DEPLOY_FOLDER);

                 sleepTime = DEFAULT_SLEEP_TIME;

                 ignored = new ArrayList<File>();

                 timestamps = new HashMap<String, Long>();

                 running = true;

         }

         public synchronized void stopDeployer() {

                 running = false;

         }

         @Override

         public void run() {

                 try {

                         sleep(1);

                 }

                 catch(InterruptedException ignore) {}

                 ComponentManager cm = ComponentManager.getInstance();

                 NamingService naming = NamingService.getInstance();

                 List<File> deploy = new ArrayList<File>();

                 List<File> redeploy = new ArrayList<File>();

                 List<ServiceMetaInfo> stop = new ArrayList<ServiceMetaInfo>();

                 while(true) {

                         if(!running) {

                                 return;

                         }

                         long start = System.currentTimeMillis();

                         File dir = new File(directory);

                         if(dir.isDirectory()) {

                                 for(File file : dir.listFiles()) {

                                         if(file.getName().toLowerCase().endsWith(".jar")) {

                                                 if(isIgnored(file)) {

                                                         continue;

                                                 }

                                                 else {

                                                         //Make sure the file isnt still being written to

                                                         long filesize = file.length();

                                                         while(true) {

                                                                 try {

                                                                         sleep(10);

                                                                 }

                                                                 catch (InterruptedException ignore) {}

                                                                 if(!running) {

                                                                         return;

                                                                 }

                                                                 long temp = file.length();

                                                                 if(filesize == temp) {

                                                                         break;

                                                                 }

                                                                 else {

                                                                         filesize = temp;

                                                                 }

                                                         }

                                                         //Deploy/redeploy

                                                         if(!naming.isFileLoaded(file)) {

                                                                 deploy.add(file);

                                                         }

                                                         else if(naming.isNewer(file)) {

                                                                 redeploy.add(file);

                                                         }

                                                 }

                                         }

                                 }

                                 //Check for missing files

                                 stop.clear();

                                 for(File deployed : naming.getLoadedFiles()) {

                                         boolean found = false;

                                         for(File file : dir.listFiles()) {

                                                 if(deployed.equals(file)) {

                                                         found = true;

                                                         break;

                                                 }

                                         }

                                         if(!found) {

                                                 stop.add(naming.getServiceByFile(deployed));

                                         }

                                 }

                                 if(!stop.isEmpty()) {

                                         cm.stop(stop);

                                 }

                                 //Deploy

                                 boolean deployed = false;

                                 if(!redeploy.isEmpty()) {

                                         logger.info("Found updated file(s), starting redeployment.");

                                         cm.redeploy(redeploy);

                                         redeploy.clear();

                                         deployed = true;

                                 }

                                 if(!deploy.isEmpty()) {

                                         logger.info("Found new file(s), starting deployment.");

                                         cm.deploy(deploy);

                                         deploy.clear();

                                         deployed = true;

                                 }

                                 if(deployed) {

                                         double used = (System.currentTimeMillis() - start) / 1000.0;

                                         logger.info("Deployment done in " + used + "s.\r\n");

                                 }

                         }

                         else {

                                 logger.severe(dir.getName() + " is not a directory, unable to load components.");

                         }

                         try {

                                 sleep(sleepTime);

                         }

                         catch(InterruptedException ignore) {

                                 continue;

                         }

                 }

         }

         public void addIgnore(File file) {

                 ignored.add(file);

                 timestamps.put(file.getName(), file.lastModified());

                 proxy.send(new Notification(NOT_LOADING_FILE, Notification.class.getClass().getName(), seq++, file.getAbsolutePath()));

         }

         public boolean removeIgnore(File file) {

                 for(File temp : ignored) {

                         if(temp.getName().equals(file.getName())) {

                                 timestamps.remove(file.getName());

                                 return ignored.remove(temp);

                         }

                 }

                 return false;

         }

         //Returns true when a file is found in ignored and has not been updated.

         private boolean isIgnored(File file) {

                 for(File temp : ignored) {

                         if(temp.getName().equals(file.getName())) {

                                 long now = file.lastModified();

                                 long then = timestamps.get(temp.getName());

                                 if(now == then) {

                                         return true;

                                 }

                                 else {

                                         ignored.remove(temp);

                                         logger.info(file.getName() + " has been updated, loading.");

                                         return false;

                                 }

                         }

                 }

                 return false;

         }

         @Instrument

         @Description("The current directory being monitored for new components")

         public String getDirectory() {

                 return directory;

         }

         @Instrument

         public void setDirectory(String directory) {

                 this.directory = directory;

         }

         @Instrument

         @Description("How many mili seconds between each scan for new components")

         public int getSleepTime() {

                 return sleepTime;

         }

         @Instrument

         public void setSleepTime(int sleepTime) {

                 this.sleepTime = sleepTime;

         }

         public static HotDeployer getInstance() {

                 return singelton;

         }

         @NotificationInfo

         public MBeanNotificationInfo[] getNotificationInfo() {

                 MBeanNotificationInfo[] not = new MBeanNotificationInfo[5];

                 not[0] = new MBeanNotificationInfo(new String[]{NEW_FILE_FOUND}, Notification.class.getClass().getName(), "Emitted when a new file is found.");

                 not[1] = new MBeanNotificationInfo(new String[]{DEPLOY_FILE_MISSING}, Notification.class.getClass().getName(), "Emitted when the deploy file is missing from the jar.");

                 not[2] = new MBeanNotificationInfo(new String[]{NOT_LOADING_FILE}, Notification.class.getClass().getName(), "Emitted when a file is not being loaded.");

                 not[3] = new MBeanNotificationInfo(new String[]{FILE_UPDATED}, Notification.class.getClass().getName(), "Emitted when a file has been updated.");

                 not[4] = new MBeanNotificationInfo(new String[]{UNDEPLOY_FILE}, Notification.class.getClass().getName(), "Emitted when a is being undeployed.");

                 return not;

         }

 }