source: xssim/src/test/rewolucja/resources/physical/base/ComputingResource.java @ 104

package test.rewolucja.resources.physical.base;

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

import test.rewolucja.energy.extension.EnergyExtension;
import test.rewolucja.energy.profile.PowerInterface;
import test.rewolucja.extensions.Extension;
import test.rewolucja.extensions.ExtensionList;
import test.rewolucja.extensions.ExtensionListImpl;
import test.rewolucja.extensions.ExtensionType;
import test.rewolucja.resources.Resource;
import test.rewolucja.resources.ResourceCharacteristics;
import test.rewolucja.resources.ResourceStatus;
import test.rewolucja.resources.ResourceType;
import test.rewolucja.resources.StructureEntityInterface;
import test.rewolucja.resources.description.ExecResourceDescription;
import test.rewolucja.resources.exception.ResourceException;
import test.rewolucja.resources.logical.LogicalResource;
import test.rewolucja.resources.properties.DefaultPropertiesBuilder;
import test.rewolucja.resources.properties.PropertiesDirector;
import test.rewolucja.resources.test.Event;
import test.rewolucja.resources.utils.validator.ResourceNameValidator;
import test.rewolucja.resources.utils.validator.ResourcePropertiesValidator;
import test.rewolucja.resources.utils.validator.ResourceStatusValidator;
import test.rewolucja.resources.utils.validator.ResourceTypeValidator;
import test.rewolucja.resources.utils.validator.ResourceValidator;

public class ComputingResource implements Resource, StructureEntityInterface<ComputingResource> {
        
        protected String name;
        protected ResourceType type;

        protected ResourceStatus status;

        protected ComputingResource parent;
        protected List<ComputingResource> children;

        protected ResourceCharacteristics resourceCharacteristic;
        //protected Properties properties;

        protected ExtensionList extensionList;
        

        public ExtensionList getExtensionList() {
                return extensionList;
        }

        /*public ComputingResource(String resourceName, ResourceType type, ResourceCharacteristics resourceCharacteristic) {
                super();
                this.type = type;
                this.name = resourceName;
                this.status = ResourceStatus.FREE;
                this.resourceCharacteristic = resourceCharacteristic;
                this.extensionList = new ExtensionListImpl(1);
        }*/

        public ComputingResource(ExecResourceDescription resDesc) {
                this.type = resDesc.getType();
                this.name = resDesc.getResourceId();
                this.status = ResourceStatus.FREE;
                this.extensionList = new ExtensionListImpl(1);
                initCharacteristics(resDesc);
                //this(resDesc.getResourceId(), resDesc.getType(), new ResourceCharacteristics(
                //              resDesc.getResourceUnits()));
        }

        protected void initCharacteristics(ExecResourceDescription resDesc){
                resourceCharacteristic = new ResourceCharacteristics(resDesc.getResourceUnits());
        }
        
        public ComputingResource getParent() {
                return parent;
        }

        public void setParent(ComputingResource newParent) {
                parent = newParent;
        }

        public List<ComputingResource> getChildren() {
                return children;
        }

        public void addChild(ComputingResource child) {
                child.setParent(this);
                if (children == null)
                        children = new ArrayList<ComputingResource>();
                children.add(child);
        }

        public String getName() {
                return name;
        }

        public ResourceType getType() {
                return type;
        }

        public ResourceCharacteristics getResourceCharacteristic() {
                return resourceCharacteristic;
        }

        public ResourceStatus getStatus() {
                return status;
        }

        public void setStatus(ResourceStatus newStatus) {
                status = newStatus;

                if(children != null)
                {
                        for(ComputingResource child: children){
                                child.setStatus(status);
                        }
                }
        }
        
        public void triggerEventUp(Event event) {
                if(parent != null)
                        parent.handleEvent(event);
        }

        public void handleEvent(Event event){
                if (extensionList != null) {
                        for (Extension extension : extensionList) {
                                if (extension.supportsEvent(event)) {
                                        extension.handleEvent(event);
                                }
                        }
                }
                triggerEventUp(event);
        }
        
        public List <? extends ComputingResource> getDescendantsByType(ResourceType type) throws ResourceException {
                List<ResourceValidator> validators = new ArrayList<ResourceValidator>();
                validators.add(new ResourceTypeValidator(type));
                return searchDescendants(validators);
        }

        public List<? extends ComputingResource> getDescendantsByTypeAndStatus(ResourceType type, ResourceStatus status) throws ResourceException {
                List<ResourceValidator> validators = new ArrayList<ResourceValidator>();
                validators.add(new ResourceStatusValidator(status));
                validators.add(new ResourceTypeValidator(type));
                return searchDescendants(validators);
        }

        public ComputingResource getDescendantsByName(String resourceName) throws ResourceException {
                List<ResourceValidator> validators = new ArrayList<ResourceValidator>();
                validators.add(new ResourceNameValidator(resourceName));
                List<? extends ComputingResource> resources = searchDescendants(validators);
                return resources.size() == 0 ? null : resources.get(0);
        }
        
        public List<? extends ComputingResource> filterDescendants(Properties properties)  {
                List<ResourceValidator> validators = new ArrayList<ResourceValidator>();
                validators.add(new ResourcePropertiesValidator(properties));
                return searchDescendants(validators);
        }
        
        protected List<? extends ComputingResource> searchDescendants(List<ResourceValidator> validators) {

                List<ComputingResource> descendants = new ArrayList<ComputingResource>();
                if (children != null) {
                        Stack<ComputingResource> toExamine = new Stack<ComputingResource>();
                        toExamine.push(this);

                        while (!toExamine.isEmpty()) {
                                ComputingResource resource = toExamine.pop();
                                List<ComputingResource> resources = resource.getChildren();
                                if (resources == null)
                                        continue;
                                int numberOfRes = resources.size();
                                for (int i = 0; i < numberOfRes; i++) {
                                        ComputingResource resourceChild = resources.get(i);
                                        if (resourceChild.match(validators)) {
                                                descendants.add(resourceChild);
                                        } else
                                                toExamine.insertElementAt(resourceChild, 0);
                                                //toExamine.push(resourceChild);
                                }
                        }
                }
                return descendants;
        }
        
        protected boolean match(List<ResourceValidator> validators){
                for(ResourceValidator validator: validators){
                        if(validator.validate(this) == false)
                                return false;
                }
                return true;
        }
        
        public Properties getProperties(){
                PropertiesDirector propDirector = new PropertiesDirector();
                propDirector.setPropertiesBuilder(new DefaultPropertiesBuilder());
                propDirector.constructProperties(this);
                return propDirector.getProperties();
        }
        
        
        public PowerInterface getPowerInterface(){
                if (extensionList != null) {
                        for (Extension extension : extensionList) {
                                if (extension.getType() == ExtensionType.ENERGY_EXTENSION) {
                                        EnergyExtension ee = (EnergyExtension)extension;
                                        return ee.getPowerInterface();
                                }
                        }
                }
                return null;
        }

        protected LogicalResource logicalResource;

        public LogicalResource getLogicalResource() {
                return logicalResource;
        }
        
        public void setLogicalResource(LogicalResource logRes) {
                logicalResource = logRes;
        }
        /*public void addLogicalResource(LogicalResource logicalResource) {
                if (logicalResources == null)
                        logicalResources = new ArrayList<LogicalResource>(1);
                logicalResources.add(logicalResource);
        }*/
}