source: DCWoRMS/branches/coolemall/src/test/testSOP/Utility.java @ 1606

package test.testSOP;

import gridsim.dcworms.DCWormsTags;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;

import dcworms.schedframe.scheduling.ExecTask;

import schedframe.resources.computing.Node;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.scheduling.manager.resources.ClusterResourceManager;
import schedframe.scheduling.manager.tasks.JobRegistry;

public class Utility {
        public static int NUMBER_HOST_PIVOT = 1;
        public static String HOST_NUMBER_PATH = "src/test/testSOP_results/data/expectedHostNumber.txt";
        
        
        //Retrieve nodes by powerstateNames
        public static List<Node> getNodesByPowerState(List<Node> nodes, StandardPowerStateName psName) {
                ArrayList<Node> nodelist = new ArrayList<Node>();
                for (Node n : nodes) {
                        if (n.getPowerInterface().getPowerState().equals(psName)) {
                                nodelist.add(n);
                        }
                }
                return nodelist;
        }

        
        public static int getExpectedHostNumber(JobRegistry jr, ClusterResourceManager resourceManager, Log log) {
                float cpuReq = 0;
                float memReq = 0;

                synchronized(jr.getTasks()) {
                        for (ExecTask t : jr.getTasks()) {
        
                                if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED
                                                && t.getStatus() != DCWormsTags.CANCELED) {
        
                                        try {
                                                cpuReq += t.getCpuCntRequest();
                                                memReq += t.getMemoryRequest();
                                        } catch (NoSuchFieldException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                }
                        }
                }
                // Compute total capacity
                List<Node> nodes = resourceManager.getNodes();
                float cpuCapacity = 0;
                float memCapacity = 0;
                for (Node n : nodes) {
                        try {
                                cpuCapacity += n.getProcessorsNumber();
                                memCapacity += n.getTotalMemory();
                        } catch (NoSuchFieldException e) {
                                e.printStackTrace();
                        }
                }
                // log.debug("CPU capacity = "+cpuCapacity);
                // log.debug("MEM capacity = "+memCapacity);
                //log.debug("CPU req = " + cpuReq);
                //log.debug("MEM req = " + memReq);
                float averageHostCPUCapacity = cpuCapacity / (float) nodes.size();
                float averageHostMEMCapacity = memCapacity / (float) nodes.size();
                //log.debug("avgMaxHostCPUCapacity = " + averageHostCPUCapacity);
                //log.debug("averageHostMEMCapacity = " + averageHostMEMCapacity);
                int expectedHostNumberCPU = (int) (cpuReq / averageHostCPUCapacity);
                int expectedHostNumberMEM = (int) (memReq / averageHostMEMCapacity);
                int expectedHostNumber = Math.max(expectedHostNumberCPU, expectedHostNumberMEM);
                // log.debug("Expecting needing max ("+expectedHostNumberCPU+","+expectedHostNumberMEM+") Nodes");

                expectedHostNumber = expectedHostNumber + Utility.NUMBER_HOST_PIVOT;
                log.debug("Host to be on : " + expectedHostNumber);
                //
                // PrintWriter writer = null;
                // try {
                // writer = new PrintWriter(new FileWriter(HOST_NUMBER_PATH, true));
                // writer.println(String.format("%d", expectedHostNumber));
                // writer.close();
                // } catch (IOException e) {
                // e.printStackTrace();
                // } finally {
                // writer.close();
                // }
                return expectedHostNumber;
        }
        
        public static int getAllRunningTasks(JobRegistry jr) {
                int nb = 0;
                synchronized(jr.getTasks()) {
                        for (ExecTask t : jr.getTasks()) {
                                
                                if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED && t.getStatus() != DCWormsTags.CANCELED) {
                                        nb++;
                                }
                        }
                }
                return nb;
        }
        
        public static void manageHosts(JobRegistry jr, ClusterResourceManager resourceManager, Log log) {
                List<Node> nodes = resourceManager.getNodes();
                int expectedHostNumber = getExpectedHostNumber(jr, resourceManager, log);

                //Counting ON and BOOT hosts
                int nbOnHosts = 0;
                int nbBootingHosts = 0;
                for (Node n : nodes) {
                        if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
                                nbOnHosts++;
                        }
                        if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.BOOT)) {
                                nbBootingHosts++;
                        }
                }
                synchronized(jr.getTasks()) {
                        for (ExecTask t : jr.getTasks()) {
        
                                if (t.getStatus() != DCWormsTags.SUCCESS && t.getStatus() != DCWormsTags.FAILED
                                                && t.getStatus() != DCWormsTags.CANCELED) {
                                        log.debug(t.getJobId()+ " is still running");
                                }
                        }
                }
                log.debug("");
                //log.debug("There is "+(nbOnHosts+nbBootingHosts)+" powered ON("+nbOnHosts+") or BOOTING("+nbBootingHosts+")");
                int nbTotal = nbOnHosts+nbBootingHosts;
                
                PrintWriter writer = null;
                try {
                        writer = new PrintWriter(new FileWriter(HOST_NUMBER_PATH, true));
                        writer.println(String.format("%d\t%d", nbOnHosts, expectedHostNumber));
                        log.debug("Wrote in HOST_NUMBER_PATH: "+HOST_NUMBER_PATH);
                        writer.close();
                } catch (IOException e) {
                        e.printStackTrace();
                } finally {
                        writer.close();
                }
                
                //We have to power on a host
                if (nbTotal < expectedHostNumber) {
                        //log.debug("nbOnHosts < expectedHostNumber : We have to power on a host");
                        Node n = findNodeToPowerON(resourceManager, log);
//                      ArrayList<Node> nList = findNodeListToPowerON(resourceManager, log);
                        if(n != null) {
                                //log.debug("Powering ON node "+n.getName());
//                              n.getPowerInterface().setPowerState(StandardPowerStateName.ON);
                                n.getPowerInterface().turnOn();
                        }
                }
                //We have to power off hosts
                else if (nbTotal > expectedHostNumber) {
                        log.debug("nbOnHosts > expectedHostNumber : We have to power off hosts");
//                      Node n = findNodeToPowerOFF(resourceManager, log);
                        ArrayList<Node> nList = findNodeListToPowerOFF(resourceManager, log);
                        if (nList!= null) {
                                log.debug("Half the hosts nb is :"+Math.ceil((float)nList.size()/(float)2));
                                for(int i = 0 ; i<Math.ceil((float)nList.size()/(float)2) ; i++) {
                                        //log.debug("Powering OFF node " +nList.get(i).getName());
                                        nList.get(i).getPowerInterface().turnOff();
                                }
                        }
                }
                //We do nothing
                else {
                        log.debug("The right number of hosts, do nothing");
                }
        }
        
        //Find all nodes that we can power off
        private static ArrayList<Node> findNodeListToPowerOFF(ClusterResourceManager resourceManager, Log log) {
                List<Node> nodes = resourceManager.getNodes();
                ArrayList<Node> nodeList = new ArrayList<Node>();
                for (Node n : nodes) {
                        if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
                                if (nodeIsEmpty(n, log)) {
                                        nodeList.add(n);
                                }
                        }
                }
                if (nodeList.size() == 0) {
                        log.debug("findNodeToPowerOFF() : no host found");
                        return null;
                }
                else {
                        return nodeList;
                }
        }


        /**
         * Finds empty node to power off
         * @param resourceManager
         * @return
         */
        //TODO: Find best node to poweroff, sort list?
        private static Node findNodeToPowerOFF(ClusterResourceManager resourceManager, Log log) {
                List<Node> nodes = resourceManager.getNodes();
                for (Node n : nodes) {
                        if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)) {
                                if (nodeIsEmpty(n, log)) {
                                        return n;
                                }
                        }
                }
                log.debug("findNodeToPowerOFF() : no host found");
                return null;
        }

        /**
         * Find first node to power ON
         * @param resourceManager
         * @return
         */
        //TODO: Find best node to powerOn, sort list?
        private static Node findNodeToPowerON(ClusterResourceManager resourceManager, Log log) {
                List<Node> nodes = resourceManager.getNodes();
                for (Node n : nodes) {
                        if (n.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
                                return n;
                }
                //log.debug("findNodeToPowerON() : no host found");
                return null;
        }

        public static boolean nodeIsEmpty(Node n, Log log) {
                try {
                        boolean ret =  (n.getFreeMemory() == n.getTotalMemory()) && (n.getFreeProcessorsNumber() == n.getProcessorsNumber());
                        if (ret == false) {
                                //log.debug("FreeMEM: "+n.getFreeMemory()+" // TotalMEM : " +n.getTotalMemory());
                        }
                        return ret;
                } catch (NoSuchFieldException e) {
                        e.printStackTrace();
                }
                return false;
        }


        public static void deleteFile(String path, Log log) {
                //Delete migration file
                File file = new File(path);
                if (file.delete()) {
                        log.debug("Successfully deleted file "+path);
                }
                else {
                        log.debug("Failed to delete file "+path);
                }
                
        }
        
        /**
         * Executes an external python program
         * @param path path to executable
         */
        public static void executeExternalProgram(String path) {
                ProcessBuilder pb = new ProcessBuilder("python",path);
                try {
                        Process p = pb.start();
                        p.waitFor();
                } catch (IOException e) {
                        e.printStackTrace();
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
        }
}