src/at/ac/tuwien/lsdc/management/MachineManager.java

   1 package at.ac.tuwien.lsdc.management;
   2
   3 import java.util.Collection;
   4 import java.util.HashMap;
   5 import java.util.List;
   6
   7 import at.ac.tuwien.lsdc.exception.VMsRunningException;
   8 import at.ac.tuwien.lsdc.types.PhysicalMachine;
   9
  10 /**
  11  * This class is responsible to start and stop PMs & VMs
  12  * also it will be used to put an application on a VM
  13  * move an application and get utilization data
  14  *
  15  */
  16 public class MachineManager {
  17
  18         private HashMap<Integer, PhysicalMachine> PMs = new HashMap<Integer, PhysicalMachine>();
  19
  20         private int maxPMs;
  21
  22         public MachineManager(int maxPMs) {
  23                 this.maxPMs = maxPMs;
  24         }
  25
  26
  27         /**
  28          * Start a physical machine
  29          * @return the PM that was started, null if all machines already running
  30          */
  31         public PhysicalMachine startPhysicalMachine() {
  32                 if(PMs.size() < maxPMs) {
  33                         PhysicalMachine pm = new PhysicalMachine();
  34                         PMs.put(pm.getId(), pm);
  35                         pm.start();
  36                         return pm;
  37                 }
  38                 return null;
  39         }
  40
  41         /**
  42          * Stops a physical machine with the given id
  43          * @param id the id of the PM to stop
  44          * @throws VMsRunningException is thrown when there are still VMs running on this PM
  45          */
  46         public void stopPhysicalMachine(int id) throws VMsRunningException {
  47                 if(PMs.containsKey(id)) {
  48                         PMs.get(id).stop();
  49                         PMs.remove(id);
  50                 }
  51         }
  52
  53         /**
  54          * Returns all running physical machines
  55          * @return the currently active PMs
  56          */
  57         public Collection<PhysicalMachine> getPMs () {
  58                 return PMs.values();
  59         }
  60
  61         /**
  62          * Returns the maximum number of available physical machines
  63          * @return the maximum number of PMs
  64          */
  65         public int getMaxPMs() {
  66                 return maxPMs;
  67         }
  68
  69         /**
  70          * Gets the total power consumption summed up from each PM
  71          * @return the total power consumption
  72          */
  73         public double getTotalConsumption() {
  74                 double consumption = 0;
  75                 for (PhysicalMachine pm : PMs.values()) {
  76                         if (pm.isRunning())
  77                                 consumption = consumption + pm.getConsumption();
  78                 }
  79                 return consumption;
  80         }
  81 }