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

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.power.PowerProfile;
import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;

public class EnergyExtension implements Extension/*, ResourceVisitor */{

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

        protected PowerInterface powerInterface;
        protected PowerProfile powerProfile;

        protected ComputingResource computingResource;

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

        @Override
        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;
                else return false;

        }
        

        @Override
        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;
                }
        }
        
        @Override
        public void init(Properties properties) throws ExtensionException {
                // TODO Auto-generated method stub
        }

        @Override
        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;
        }


}