source: DCWoRMS/trunk/src/test/EventManager.java @ 780

package test;

import gridsim.GridSimCore;

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

import schedframe.ResourceController;
import schedframe.events.ResourceEventCommand;
import schedframe.events.scheduling.EventReason;
import schedframe.exceptions.ModuleException;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.profiles.energy.EnergyEvent;
import schedframe.resources.computing.profiles.energy.EnergyEventType;
import schedframe.scheduling.Scheduler;
import schedframe.scheduling.plugin.grid.Module;
import schedframe.scheduling.plugin.grid.ModuleType;

public class EventManager extends GridSimCore implements Module{

        protected ResourceController resourceController;
        
        public EventManager(String name) throws Exception {
                super(name, 1);
        }

        public void send(String entityName, double delay, int tag, Object data){
                super.send(entityName, delay, tag, data);
        }
        
        public void send(int destId, double delay, int tag){
                super.send(destId, delay, tag);
        }
        
        public void send(int destId, double delay, int tag, Object data){
                super.send(destId, delay, tag, data);
        }
        
        public void init(Properties properties) throws ModuleException {
        }

        public void sendToAllSchedulers(double delay, int tag, Object data){
                List<Scheduler> allSchedulers =  new ArrayList<Scheduler>();
                if (resourceController.getScheduler().getChildren() != null) {
                        LinkedList<Scheduler> toExamine = new LinkedList<Scheduler>();
                        toExamine.push(resourceController.getScheduler());
                        allSchedulers.add(resourceController.getScheduler());

                        while (!toExamine.isEmpty()) {
                                Scheduler scheduler = toExamine.pop();
                                List<Scheduler> schedulers = scheduler.getChildren();
                                int numberOfSched = schedulers.size();
                                for (int i = 0; i < numberOfSched; i++) {
                                        Scheduler schedulerChild = schedulers.get(i);
                                        toExamine.addLast(schedulerChild);
                                        allSchedulers.add(schedulerChild);
                                }
                        }
                }
                
                for(Scheduler scheduler: allSchedulers){
                        super.send(scheduler.get_id(), delay, tag, data);
                }
        }
        
        public void sendToAllResources(double delay, int tag, Object data){
                List<ComputingResource> allComputingResources = new ArrayList<ComputingResource>();

                if (resourceController.getComputingResources() != null) {
                        LinkedList<ComputingResource> toExamine = new LinkedList<ComputingResource>();
                        for(ComputingResource compRes: resourceController.getComputingResources()){
                                toExamine.push(compRes);
                                allComputingResources.add(compRes);
                        }

                        while (!toExamine.isEmpty()) {
                                ComputingResource resource = toExamine.pop();
                                List<ComputingResource> resources = resource.getChildren();
                                int numberOfRes = resources.size();
                                for (int i = 0; i < numberOfRes; i++) {
                                        ComputingResource resourceChild = resources.get(i);
                                        toExamine.addLast(resourceChild);
                                        allComputingResources.add(resourceChild);
                                }
                        }
                }
                
                ResourceEventCommand rec;
                EnergyEvent event;
                for(ComputingResource compRes: allComputingResources){
                        rec = new ResourceEventCommand(compRes);
                        event = new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller");
                        event.setReason(EventReason.SIM_INIT);
                        rec.execute(event);
                        //super.send(scheduler.get_id(), delay, tag, data);
                }

        }
        
        public void sendTo(List<String> ids){
                
        }
        
        public void dispose() throws ModuleException {
        }

        public ModuleType getType() {
                return ModuleType.EVENT_MANAGER;
        }

}