source: xssim/src/simulator/workload/reader/resource/Grms3ResourceReader.java @ 104

package simulator.workload.reader.resource;

import gridsim.ResourceCalendar;
import gridsim.gssim.GssimConstants;
import gridsim.gssim.ResourceUnitsManagerImpl;
import gridsim.gssim.policy.ARAllocationPolicy;
import gridsim.gssim.policy.AllocationPolicy;
import gridsim.gssim.resource.ARComputingResource;
import gridsim.gssim.resource.AbstractComputingResource;
import org.qcg.broker.schemas.exception.UnknownParameter;
import org.qcg.broker.schemas.hostparams.ComputingResource;
import org.qcg.broker.schemas.hostparams.HostParameters;
import org.qcg.broker.schemas.hostparams.wrapper.HostParametersWrapper;
import org.qcg.broker.schemas.hostparams.wrapper.QueuingSystem;
import org.qcg.broker.schemas.hostparams.wrapper.impl.HostParametersWrapperImpl;
import org.qcg.broker.schemas.hostparams.wrapper.impl.QueuingSystemImpl;
import gssim.schedframe.resources.ComputingResourceDescription;
import gssim.schedframe.resources.QueuingSystemDescription;
import gssim.schedframe.resources.QueuingSystemDescriptionES;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.ValidationException;

import schedframe.resources.ExecutingResourceDescription;
import schedframe.resources.ResourceProvider;
import schedframe.resources.providers.LocalSystem;

/**
 * 
 * @author Marcin Krystek
 *
 */
public class Grms3ResourceReader implements ResourceReader<AbstractComputingResource, ResourceCalendar>{

        protected Map <String, String>forecastFinishTimePlugin;
        protected String defForecastFinishTimePlugin;

        protected Map <String, String>localAllocationPolicyPlugin;
        protected String defLocalAllocationPolicyPlugin;
        
        protected ResourceCalendar resourceCalendar;
        
        // all resources (ComputingResources and QueuingSystems) extracted from HostParameters xml.
        protected ArrayList<ExecutingResourceDescription> resourcesDescriptions;

        private int resourceIdx;
        
        protected Grms3ResourceReader(){
                long seed = 11L * 13L * 17L * 19L * 23L + 1L; 
                double timeZone = 0.0;
                double peakLoad = 0.0; // the resource load during peak hour
                double offPeakLoad = 0.0; // the resource load during off-peak hr
                double holidayLoad = 0.0; // the resource load during holiday
                
                // incorporates weekends so the grid resource is on 7 days a week
                LinkedList<Integer> Weekends = new LinkedList<Integer>();
                Weekends.add(java.util.Calendar.SATURDAY);
                Weekends.add(java.util.Calendar.SUNDAY);

                // incorporates holidays. However, no holidays are set in this example
                LinkedList<Integer> Holidays = new LinkedList<Integer>();
                this.resourceCalendar = new ResourceCalendar(timeZone, peakLoad, offPeakLoad, 
                                                                                                                        holidayLoad, Weekends, Holidays, seed);
        }
        
        public Grms3ResourceReader(String resourceFile) throws IOException{
                this();
                resourceIdx = 0;
                forecastFinishTimePlugin = new HashMap<String, String>();
                localAllocationPolicyPlugin = new HashMap<String, String>();
                
                defForecastFinishTimePlugin = "not_defined_defaultForecastFinishTimePlugin";
                defLocalAllocationPolicyPlugin = "not_defined_defaultLocalAllocationPolicyPlugin";
                
                resourcesDescriptions = new ArrayList<ExecutingResourceDescription>();
                
                File file = new File(resourceFile);
                if(!file.exists())
                        throw new IOException(resourceFile + " does not exist.");
                if(!file.isFile())
                        throw new IOException(resourceFile + " is not a regular file.");
                
                try {
                        HostParameters resourceDesription = HostParameters.unmarshalHostParameters(new FileReader(file));
                        HostParametersWrapper wrapper = new HostParametersWrapperImpl();
                        wrapper.wrap(resourceDesription);
                        ComputingResource compResources[] = null;
                        
                        // create stand alone computing resources
                        compResources = wrapper.getStandaloneComputingResources();
                        if(compResources != null){
                                for(int i = 0; i < compResources.length; i++){
                                        resourcesDescriptions.add(new ComputingResourceDescription(compResources[i]));
                                }
                        }
                        compResources = null;
                        
                        // create queuing systems
                        QueuingSystem queuingSystem = null;
                        compResources = wrapper.getFrontends();
                        if(compResources != null){
                                for(int i = 0; i < compResources.length; i++){
                                        queuingSystem = new QueuingSystemImpl();
                                        queuingSystem.create(resourceDesription, compResources[i]);
                                        resourcesDescriptions.add(new QueuingSystemDescriptionES(queuingSystem));
                                }
                        }
                        
                        
                } catch (MarshalException e) {
                        throw new IOException(e.getMessage());
                } catch (ValidationException e) {
                        throw new IOException(e.getMessage());
                } catch (UnknownParameter e) {
                        throw new IOException(e.getMessage());
                }
                
        }
        
        public Grms3ResourceReader(String resourceFile, String forecastFinishTimePlugin, String localAllocationPolicyPlugin) throws IOException{
                this(resourceFile);
                defForecastFinishTimePlugin = forecastFinishTimePlugin;
                defLocalAllocationPolicyPlugin = localAllocationPolicyPlugin;
        }
        
        
        public AbstractComputingResource read() throws Exception {
                if(resourceIdx >= resourcesDescriptions.size())
                        return null;
                
                ExecutingResourceDescription executingResourceDesc = resourcesDescriptions.get(resourceIdx++);

                // get resource id
                String resourceID = executingResourceDesc.getProvider().getProviderId();
                
                // determine forecast finish time plugin
                String forecastPlugin = null;
                if(forecastFinishTimePlugin.containsKey(resourceID))
                        forecastPlugin = forecastFinishTimePlugin.get(resourceID);
                else
                        forecastPlugin = defForecastFinishTimePlugin;
                
                // determine allocation policy plugin
                String schedulingPlugin = null;
                if(localAllocationPolicyPlugin.containsKey(resourceID))
                        schedulingPlugin = localAllocationPolicyPlugin.get(resourceID);
                else
                        schedulingPlugin = defLocalAllocationPolicyPlugin;
                
                double timeZone = 0.0;
                ResourceUnitsManagerImpl resConfig = new ResourceUnitsManagerImpl(timeZone, executingResourceDesc);
                
                AbstractComputingResource gridRes = null;
                
                ResourceProvider provider = new LocalSystem(resourceID, null, null);

                if(executingResourceDesc.supportReservation()){
                        
                        ARAllocationPolicy policy = new ARAllocationPolicy(provider, 
                                                                                        GssimConstants.DEFAULT_RESOURCE_MANAGER_NAME, 
                                                                                        schedulingPlugin, 
                                                                                        forecastPlugin, 
                                                                                        executingResourceDesc);
                        
                        gridRes = new ARComputingResource(provider, 
                                                                                        1, 
                                                                                        resConfig, 
                                                                                        this.resourceCalendar, 
                                                                                        policy);
                } else {
                        AllocationPolicy policy = new AllocationPolicy(provider, 
                                                                                GssimConstants.DEFAULT_RESOURCE_MANAGER_NAME, 
                                                                                schedulingPlugin, 
                                                                                forecastPlugin, 
                                                                                executingResourceDesc);
                        
                        gridRes = new gridsim.gssim.resource.ComputingResource(
                                                                                provider, 
                                                                                1, 
                                                                                resConfig, 
                                                                                this.resourceCalendar, 
                                                                                policy);
                }
                
                return gridRes;
        }
        
        public int getNoOfResources(){
                return resourcesDescriptions.size();
        }

        public void setCalendar(ResourceCalendar calendar) {
                this.resourceCalendar = calendar;
        }
        
        public void close() {
                forecastFinishTimePlugin.clear();
                localAllocationPolicyPlugin.clear();
                resourcesDescriptions.clear();
                resourceIdx = 0;
        }
        
        
        public void loadPlugins(String fileName) {
                throw new RuntimeException("Grms3ResourceReader.loadPlugins() is not implemented.");
        }

}