src/at/ac/tuwien/lsdc/types/PhysicalMachine.java

   1 package at.ac.tuwien.lsdc.types;
   2
   3 import java.util.HashMap;
   4
   5 import at.ac.tuwien.lsdc.exception.ActiveApplicationsException;
   6 import at.ac.tuwien.lsdc.exception.VMsRunningException;
   7 import at.ac.tuwien.lsdc.types.VirtualMachine.VMType;
   8
   9 public class PhysicalMachine {
  10
  11         private static int count = 0;
  12
  13         private HashMap<Integer, VirtualMachine> VMs = new HashMap<Integer, VirtualMachine>();
  14
  15         private int id;
  16
  17         private final int maxSize = 50000;
  18         private final int maxRAM = 4700;
  19         private final int maxCPU = 2400;
  20
  21         private int size;
  22         private int RAM;
  23         private int CPU;
  24
  25         private final int initialSize = 850;
  26         private final int initialRAM = 300;
  27         private final int initialCPU = 500;
  28
  29         private boolean running = false;
  30
  31         public PhysicalMachine() {
  32                 id = count;
  33                 count++;
  34         }
  35
  36         public void start() {
  37                 size = initialSize;
  38                 RAM = initialRAM;
  39                 CPU = initialCPU;
  40                 running = true;
  41         }
  42
  43         public void stop() throws VMsRunningException {
  44                 if(VMs.size() > 0)
  45                         throw new VMsRunningException("PM cannot be stopped. Some VMs still running");
  46
  47                 VMs = new HashMap<Integer, VirtualMachine>();
  48                 size = 0;
  49                 RAM = 0;
  50                 CPU = 0;
  51                 running = false;
  52         }
  53
  54         public double getConsumption() {
  55                 if(CPU > initialCPU)
  56                         return 200.0 + 0.3 * (CPU - initialCPU);
  57                 else if(running)
  58                         return 200.0;
  59                 else
  60                         return 0.0;
  61         }
  62
  63         public VirtualMachine startVirtualMachine(int sz, int ram, int cpu, VMType type) {
  64                 if (checkVM(sz, ram, cpu)) {
  65                         VirtualMachine vm = new VirtualMachine(sz, ram, cpu, this, type);
  66                         VMs.put(vm.getId(), vm);
  67                         size = size + vm.getSize();
  68                         RAM = RAM + vm.getRAM();
  69                         CPU = CPU + vm.getCPU();
  70                         return vm;
  71                 } else
  72                         return null;
  73         }
  74
  75         public void stopVirtualMachine(VirtualMachine vm) throws ActiveApplicationsException {
  76                 if (VMs.containsKey(vm.getId())) {
  77                         if (vm.getApplications().size() != 0) {
  78                                 throw new ActiveApplicationsException("Applications must be migrated before stopping a VM, VM id "+vm.getId());
  79                         } else {
  80                                 VMs.remove(vm.getId());
  81                                 size = size - vm.getSize();
  82                                 RAM = RAM - vm.getRAM();
  83                                 CPU = CPU - vm.getCPU();
  84                         }
  85                 }
  86         }
  87
  88         public boolean checkVM(int size, int RAM, int CPU) {
  89                 return (size <= availableSize()) && (RAM <= availableRAM())
  90                                 && (CPU <= availableCPU());
  91         }
  92
  93         private int availableSize() {
  94                 return maxSize - size;
  95         }
  96
  97         private int availableRAM() {
  98                 return maxRAM - RAM;
  99         }
 100
 101         private int availableCPU() {
 102                 return maxCPU - CPU;
 103         }
 104
 105         public int getCurrentSize() {
 106                 return size;
 107         }
 108
 109         public int getCurrentRam() {
 110                 return RAM;
 111         }
 112
 113         public int getCurrentCpu() {
 114                 return CPU;
 115         }
 116
 117         public double getSizeUtilization() {
 118                 return ((double)(size - initialSize) / (maxSize - initialSize)) * 100;
 119         }
 120
 121         public double getRamUtilization() {
 122                 return ((double)(RAM - initialRAM) / (maxRAM - initialRAM)) * 100;
 123         }
 124
 125         public double getCpuUtilization() {
 126                 return ((double)(CPU - initialCPU) / (maxCPU - initialCPU)) * 100;
 127         }
 128
 129         public double getAverageUtilization() {
 130                 return (getSizeUtilization() + getRamUtilization() + getCpuUtilization()) / 3.0;
 131         }
 132
 133         public int getId() {
 134                 return id;
 135         }
 136
 137         public boolean isRunning() {
 138                 return running;
 139         }
 140
 141         public VirtualMachine getVirtualMachine(int id) {
 142                 return VMs.get(id);
 143         }
 144
 145         public int countCurrentlyRunningVMs() {
 146                 return VMs.values().size();
 147         }
 148 }