source: xssim/src/simulator/factory/SingleResourceFactory.java @ 104

package simulator.factory;

import qcg.qcg_broker.types.HostParametersItem;
import qcg.qcg_broker.types.hostspec.Machine;
import qcg.qcg_broker.types.hostspec.SingleResource;
import org.qcg.broker.schemas.hostparams.HostParameters;

import java.util.ArrayList;
import java.util.HashMap;

import simulator.RandomNumbers;
import simulator.hostspec.ForecastFinishTimePluginName;
import simulator.hostspec.LocalAllocationPolicyPluginName;
import simulator.hostspec.Plugins;

/**
 * This factory can create qcg.qcg_broker.types.hostspec.SingleResource
 * based on  simulator.hostspec.SingleResource description
 * 
 * @author Marcin Krystek
 *
 */
public class SingleResourceFactory {
        public static String CPU_COUNT = "cpuCount";
        public static String CPU_SPEED = "cpuSpeed";
        public static String CPU_LOAD = "cpuLoad";
        public static String MEMORY_TOTAL = "memoryTotal";
        public static String MEMORY_FREE = "memoryFree";
        public static String SWAP_TOTAL = "swapTotal";
        public static String SWAP_FREE = "swapFree";
        public static String DISK_TOTAL = "diskTotal";
        public static String DISK_FREE = "diskFree";
        
        protected simulator.hostspec.SingleResource singleRes;
        protected RandomNumbers randNumbers;
        protected HashMap <String, String>forecastFinishTimePlugin; 
        protected HashMap <String, String>localAllocationPolicyPlugin;
        
        /**
         * 
         * @param singleRes
         */
        public SingleResourceFactory(simulator.hostspec.SingleResource singleRes, RandomNumbers randNumbers){
                this.singleRes = singleRes;
                this.randNumbers = randNumbers;
                this.forecastFinishTimePlugin = new HashMap<String, String>();
                this.localAllocationPolicyPlugin = new HashMap<String, String>();
        }
        
        public HostParametersItem[] createResources() throws IllegalAccessException{
                if(singleRes == null)
                        return null;
                
                ArrayList <HostParametersItem>retList = new ArrayList<HostParametersItem>();
                
                int resCount = singleRes.getTotalResourceCount();
                int arResCount = singleRes.getARResourceCount();
                String resName;
                
                Plugins plugins = singleRes.getPlugins();
                
                int timePluginIndex = 0;
                ForecastFinishTimePluginName timePlugin;
                ForecastFinishTimePluginName timePluginName[]  = 
                                plugins.getForecastFinishTimePluginName();
                
                int allocationPluginIndex = 0;
                LocalAllocationPolicyPluginName allocationPlugin;
                LocalAllocationPolicyPluginName allocationPluginName[] = 
                                plugins.getLocalAllocationPolicyPluginName();
                
                for(int i = 0; i < resCount; i++){
                        
                        HostParametersItem item = new HostParametersItem();
                                SingleResource singleResource = new SingleResource();
                                        Machine machine = createMachine(randNumbers);
                                singleResource.setMachine(machine);

                                if(arResCount > 0)
                                        singleResource.setReservationAvailable(true);
                                else
                                        singleResource.setReservationAvailable(false);
                                arResCount--;
                        
                        resName = "single_resource_"+i;
                        singleResource = setName(singleResource, resName);
                        item.setSingleResource(singleResource);

                        retList.add(item);
                        
                        timePlugin = timePluginName[timePluginIndex];
                        forecastFinishTimePlugin.put(resName, timePlugin.getName());
                        
                        timePlugin.setResourcesCountWithThisPlugin(
                                        timePlugin.getResourcesCountWithThisPlugin() - 1);
                        if(timePlugin.getResourcesCountWithThisPlugin() == 0)
                                timePluginIndex++;
                        
                        allocationPlugin = allocationPluginName[allocationPluginIndex];
                        localAllocationPolicyPlugin.put(resName, allocationPlugin.getName());
                        
                        allocationPlugin.setResourcesCountWithThisPlugin(
                                        allocationPlugin.getResourcesCountWithThisPlugin() - 1);
                        if(allocationPlugin.getResourcesCountWithThisPlugin() == 0)
                                allocationPluginIndex++;
                        
                }
                HostParametersItem tab[] = new HostParametersItem[retList.size()];
                return retList.toArray(tab);
        }
        
        public HostParameters createResources(HostParameters hostParameters) throws IllegalAccessException{
                HostParametersItem tab[] = null;
                tab = createResources();
                
                if(tab == null)
                        return hostParameters;
                
                for(int i = 0; i < tab.length; i++)
                        hostParameters.addHostParametersItem(tab[i]);
                
                return hostParameters;
        }
        
        
        protected Machine createMachine(RandomNumbers randNumbers) throws IllegalAccessException{
                Double value;
                Machine machine = new Machine();
                
                // --- CPU_COUNT
                value = randNumbers.getRandomValue(SingleResourceFactory.CPU_COUNT);
                machine.setCpuCount(value.intValue());
                
                // --- CPU_LOAD 
                value = new Double(randNumbers.getRandomValue(SingleResourceFactory.CPU_LOAD));
                qcg.qcg_broker.types.hostspec.CpuLoad cpuLoad = new qcg.qcg_broker.types.hostspec.CpuLoad();
                        value = new Double(randNumbers.getRandomValue(SingleResourceFactory.CPU_LOAD));
                        cpuLoad.setValue(value);
                machine.setCpuLoad(cpuLoad);
                
                // ---  CPU_SPEED
                value = new Double(randNumbers.getRandomValue(SingleResourceFactory.CPU_SPEED));
                machine.setCpuSpeed(value.intValue());
                
                // ---  DISK_FREE       
                qcg.qcg_broker.types.hostspec.DiskFree diskFree = new qcg.qcg_broker.types.hostspec.DiskFree();
                        value = new Double(randNumbers.getRandomValue(SingleResourceFactory.DISK_FREE));
                        diskFree.setValue(value.doubleValue());
                machine.setDiskFree(diskFree);
                
                // ---  DISK_TOTAL      
                value = new Double(randNumbers.getRandomValue(SingleResourceFactory.DISK_TOTAL));
                machine.setDiskTotal(value.intValue());
                
                // --- MEMORY_FREE
                qcg.qcg_broker.types.hostspec.MemoryFree memoryFree = new qcg.qcg_broker.types.hostspec.MemoryFree();
                        value = new Double(randNumbers.getRandomValue(SingleResourceFactory.MEMORY_FREE));
                        memoryFree.setValue(value.doubleValue());
                machine.setMemoryFree(memoryFree);
                
                // --- MEMORY_TOTAL
                value = new Double(randNumbers.getRandomValue(SingleResourceFactory.MEMORY_TOTAL));
                machine.setMemoryTotal(value.intValue());
                
                // ---  SWAP_FREE       
                qcg.qcg_broker.types.hostspec.SwapFree swapFree = new qcg.qcg_broker.types.hostspec.SwapFree();
                        value = new Double(randNumbers.getRandomValue(SingleResourceFactory.SWAP_FREE));
                        swapFree.setValue(value.doubleValue());
                machine.setSwapFree(swapFree);

                // ---  SWAP_TOTAL
                value = new Double(randNumbers.getRandomValue(SingleResourceFactory.SWAP_TOTAL));
                machine.setSwapTotal(value.intValue());


//              machine.setHostName("random_host_name");
//              machine.setCpuType("random_cpu_type");
//              machine.setOsName("random_os_name");
//              machine.setOsRelease("random_os_release");
//              machine.setOsType("random_os_type");
//              machine.setOsVersion("random_os_version");
                
                return machine;
        }
        
        
        /**
         * Name of SingleResource is name of first Machine
         * @param resource
         * @return
         */
        public static String getName(SingleResource resource){
                String ret;
                ret = resource.getResManContact();
                return ret;
        }
        
        public static SingleResource setName(SingleResource resource, String name){
                resource.setResManContact(name);
                return resource;
        }
        
        public HashMap<String, String> getForecastFinishTimePlugin(){
                return forecastFinishTimePlugin;
        }
        public HashMap<String, String> getLocalAllocationPolicyPlugin(){
                return localAllocationPolicyPlugin;
        }
}