source: DCWoRMS/branches/coolemall/src/schedframe/resources/computing/Node.java @ 1247

package schedframe.resources.computing;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import schedframe.resources.ResourceStatus;
import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.description.ComputingResourceDescription;
import schedframe.resources.computing.extensions.ExtensionType;
import schedframe.resources.computing.profiles.energy.EnergyExtension;
import schedframe.resources.computing.profiles.energy.power.ui.NodePowerInterface;
import schedframe.resources.computing.properties.NodePropertiesBuilder;
import schedframe.resources.computing.properties.PropertiesDirector;
import schedframe.resources.units.Cost;
import schedframe.resources.units.Memory;
import schedframe.resources.units.StandardResourceUnitName;

public class Node extends ComputingResource{
        

        public Node (ComputingResourceDescription resDesc) {
                super(resDesc);
                
                //extensionList.add(new EnergyExtension(this, resDesc.getPowerInterface(), resDesc.getEnergyEstimationPlugin()));
                //PowerInterface pi = PowerInterfaceFactory.createPowerInterface(this, resDesc.getPowerProfile());
                //AirThroughputInterface ai = AirThroughputInterfaceFactory.createAirThroughputInterface(this, resDesc.getAirThroughputProfile());
                //accept(new EnergyExtension(pi, resDesc.getPowerProfile()));
                //accept(new EnergyExtension(pi, resDesc.getPowerProfile(), ai, resDesc.getAirThroughputProfile()));    
        }       
        
        public NodePowerInterface getPowerInterface(){
                NodePowerInterface powerInterface = null;
                if(extensionList.isExtensionAvailable(ExtensionType.ENERGY_EXTENSION)){
                        EnergyExtension ee = (EnergyExtension)extensionList.getExtension(ExtensionType.ENERGY_EXTENSION);
                        powerInterface = (NodePowerInterface)ee.getPowerInterface();
                }
                return powerInterface;
        }

        @SuppressWarnings("unchecked")
        public List<Processor> getProcessors(){
                return (List<Processor>) getDescendantsByType(StandardResourceType.Processor);
        }
        
        @SuppressWarnings("unchecked")
        public List<Processor> getFreeProcessors(){
                return (List<Processor>) getDescendantsByTypeAndStatus(StandardResourceType.Processor, ResourceStatus.FREE);
        }

        public List<Core> getCores(){
                List<Core> cores = new ArrayList<Core>();
                for(Processor proc: getProcessors()){
                        cores.addAll(proc.getCores());
                }
                return cores;
        }

        public List<Core> getFreeCores(){
                List<Core> freeCores = new ArrayList<Core>();
                for(Processor proc: getProcessors()){
                        freeCores.addAll(proc.getFreeCores());
                }
                return freeCores;
        }
        
        public int getProcessorsNumber() {
                return getProcessors().size();
        }

        public int getFreeProcessorsNumber() {
                return getFreeProcessors().size();
        }
        
        
        //MEMORY 
        public int getFreeMemory() throws NoSuchFieldException {
                return getMemory().getFreeAmount();
        }
        
        public int getTotalMemory() throws NoSuchFieldException {
                return getMemory().getAmount();
        }

        public boolean isMemRequirementSatisfied(int memoryReq) throws NoSuchFieldException {
                if (getFreeMemory() < memoryReq)
                        return false;
                return true;
        }
        
        public Memory getMemory() throws NoSuchFieldException {
                return (Memory) ((ComputingResourceCharacteristics)resourceCharacteristic).getResourceUnit(StandardResourceUnitName.MEMORY);
        }
        
        //COST
        public int getProcessingCost() throws NoSuchFieldException {
                return getCost().getAmount();
        }
        
        private Cost getCost() throws NoSuchFieldException {
                return (Cost) ((ComputingResourceCharacteristics)resourceCharacteristic).getResourceUnit(StandardResourceUnitName.COST);
        }

        
        public Properties getProperties(){
                PropertiesDirector propDirector = new PropertiesDirector();
                propDirector.setPropertiesBuilder(new NodePropertiesBuilder());
                propDirector.constructProperties(this);
                return propDirector.getProperties();
        }
        
        
        /*private void accept(EnergyExtension e){
                extensionList.add(e);
                e.setResource(this);
        }*/
}