source: DCWoRMS/trunk/src/schedframe/resources/computing/profiles/energy/EnergyExtension.java @ 495

package schedframe.resources.computing.profiles.energy;

import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import schedframe.events.Event;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.extensions.Extension;
import schedframe.resources.computing.extensions.ExtensionException;
import schedframe.resources.computing.extensions.ExtensionType;
import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
import schedframe.resources.computing.profiles.energy.power.PowerProfile;
import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;

public class EnergyExtension implements Extension{

        private Log log = LogFactory.getLog(EnergyExtension.class);

        protected PowerInterface powerInterface;
        protected PowerProfile powerProfile;
        
        protected AirThroughputInterface airFlowInterface;
        protected AirThroughputProfile airFlowProfile;
        
        protected ComputingResource computingResource;

        public EnergyExtension(PowerInterface powerInterface, PowerProfile pp) {
                this.powerInterface = powerInterface;
                this.powerProfile = pp;
        }

        public EnergyExtension(PowerInterface powerInterface, PowerProfile powerProfile,
                        AirThroughputInterface airFlowInterface, AirThroughputProfile airFlowProfile) {
                super();
                this.powerInterface = powerInterface;
                this.powerProfile = powerProfile;
                this.airFlowInterface = airFlowInterface;
                this.airFlowProfile = airFlowProfile;
        }

        public boolean supportsEvent(Event event) {

                if(powerProfile == null || powerProfile.getEnergyEstimationPlugin() == null)
                        return false;
                if(event.getType().getName().equals(EnergyEventType.POWER_STATE_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.FREQUENCY_CHANGED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.TASK_STARTED.getName()))
                        return true;
                else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName()))
                        return true;
                
                if(airFlowProfile == null)
                        return false;   
                if(event.getType().getName().equals(EnergyEventType.AIRFLOW_STATE_CHANGED.getName()))
                        return true;
                
                else return false;

        }

        public void handleEvent(Event event) {
                EnergyEvent enEvent = (EnergyEvent)event;
                double power = 0;
                switch (enEvent.getType()) {
                
                case POWER_STATE_CHANGED:
                        power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        /*if(resource instanceof ComputingNode){
                                ComputingNode node = (ComputingNode)resource;
                                if(event.getData() instanceof PowerState){
                                        PowerState newState = (PowerState)event.getData();
                                        if(newState == PowerState.ON) {
                                                addToPowerUsageHistory(power+node.getPowerInterface().START_COST);
                                                addToPowerUsageHistory(DateTimeUtils.currentTimeMillis()+node.getPowerInterface().START_TIME, power);
                                        }else if(newState == PowerState.OFF){
                                                addToPowerUsageHistory(power+node.getPowerInterface().SHUTDOWN_COST);
                                                addToPowerUsageHistory(DateTimeUtils.currentTimeMillis()+node.getPowerInterface().SHUTDOWN_TIME, power);
                                        }
                                }
                        }
                        else */powerProfile.addToPowerUsageHistory(power);
                        break;
                        
                case FREQUENCY_CHANGED:
                        power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        powerProfile.addToPowerUsageHistory(power);
                        break;
                        
                case TASK_STARTED:
                        power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        powerProfile.addToPowerUsageHistory(power);
                        break;

                case TASK_FINISHED:
                        //System.out.println(this.resource.getName() + " - ENERGY EXTENSION: TASK FINISHED");
                        power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        //System.out.println(this.resource.getName() + " - ESTIMATED ENERGY:" + power);
                        powerProfile.addToPowerUsageHistory(power);
                        break;
                case AIRFLOW_STATE_CHANGED:
                        System.out.println("=====");
                        double airFlow = powerProfile.getEnergyEstimationPlugin().estimateAirThroughput(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        airFlowProfile.addToPowerUsageHistory(airFlow);
                        power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(computingResource.getName()), computingResource);
                        powerProfile.addToPowerUsageHistory(power);
                        break;
                }
        }

        public void init(Properties properties) throws ExtensionException {
                // TODO Auto-generated method stub
        }

        public ExtensionType getType() {
                return ExtensionType.ENERGY_EXTENSION;
        }

        public ComputingResource getResource() {
                return computingResource;
        }

        public void setResource(ComputingResource compRes){
                this.computingResource = compRes;
        }

        public PowerInterface getPowerInterface() {
                return powerInterface;
        }

        public PowerProfile getPowerProfile() {
                return powerProfile;
        }

        public AirThroughputInterface getAirThroughputInterface() {
                return airFlowInterface;
        }

        public AirThroughputProfile getAirFlowProfile() {
                return airFlowProfile;
        }

}