code.grnet.gr Git - ganeti-local/blob - lib/hypervisor/hv_fake.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Fake hypervisor
  23
  24 """
  25
  26 import os
  27 import os.path
  28 import logging
  29
  30 from ganeti import utils
  31 from ganeti import constants
  32 from ganeti import errors
  33 from ganeti import objects
  34 from ganeti.hypervisor import hv_base
  35
  36
  37 class FakeHypervisor(hv_base.BaseHypervisor):
  38   """Fake hypervisor interface.
  39
  40   This can be used for testing the ganeti code without having to have
  41   a real virtualisation software installed.
  42
  43   """
  44   CAN_MIGRATE = True
  45
  46   _ROOT_DIR = constants.RUN_GANETI_DIR + "/fake-hypervisor"
  47
  48   def __init__(self):
  49     hv_base.BaseHypervisor.__init__(self)
  50     utils.EnsureDirs([(self._ROOT_DIR, constants.RUN_DIRS_MODE)])
  51
  52   def ListInstances(self):
  53     """Get the list of running instances.
  54
  55     """
  56     return os.listdir(self._ROOT_DIR)
  57
  58   def GetInstanceInfo(self, instance_name):
  59     """Get instance properties.
  60
  61     @param instance_name: the instance name
  62
  63     @return: tuple of (name, id, memory, vcpus, stat, times)
  64
  65     """
  66     file_name = self._InstanceFile(instance_name)
  67     if not os.path.exists(file_name):
  68       return None
  69     try:
  70       fh = open(file_name, "r")
  71       try:
  72         inst_id = fh.readline().strip()
  73         memory = utils.TryConvert(int, fh.readline().strip())
  74         vcpus = utils.TryConvert(int, fh.readline().strip())
  75         stat = "---b-"
  76         times = "0"
  77         return (instance_name, inst_id, memory, vcpus, stat, times)
  78       finally:
  79         fh.close()
  80     except IOError, err:
  81       raise errors.HypervisorError("Failed to list instance %s: %s" %
  82                                    (instance_name, err))
  83
  84   def GetAllInstancesInfo(self):
  85     """Get properties of all instances.
  86
  87     @return: list of tuples (name, id, memory, vcpus, stat, times)
  88
  89     """
  90     data = []
  91     for file_name in os.listdir(self._ROOT_DIR):
  92       try:
  93         fh = open(utils.PathJoin(self._ROOT_DIR, file_name), "r")
  94         inst_id = "-1"
  95         memory = 0
  96         vcpus = 1
  97         stat = "-----"
  98         times = "-1"
  99         try:
 100           inst_id = fh.readline().strip()
 101           memory = utils.TryConvert(int, fh.readline().strip())
 102           vcpus = utils.TryConvert(int, fh.readline().strip())
 103           stat = "---b-"
 104           times = "0"
 105         finally:
 106           fh.close()
 107         data.append((file_name, inst_id, memory, vcpus, stat, times))
 108       except IOError, err:
 109         raise errors.HypervisorError("Failed to list instances: %s" % err)
 110     return data
 111
 112   @classmethod
 113   def _InstanceFile(cls, instance_name):
 114     """Compute the instance file for an instance name.
 115
 116     """
 117     return utils.PathJoin(cls._ROOT_DIR, instance_name)
 118
 119   def _IsAlive(self, instance_name):
 120     """Checks if an instance is alive.
 121
 122     """
 123     file_name = self._InstanceFile(instance_name)
 124     return os.path.exists(file_name)
 125
 126   def _MarkUp(self, instance, memory):
 127     """Mark the instance as running.
 128
 129     This does no checks, which should be done by its callers.
 130
 131     """
 132     file_name = self._InstanceFile(instance.name)
 133     fh = file(file_name, "w")
 134     try:
 135       fh.write("0\n%d\n%d\n" %
 136                (memory,
 137                 instance.beparams[constants.BE_VCPUS]))
 138     finally:
 139       fh.close()
 140
 141   def _MarkDown(self, instance_name):
 142     """Mark the instance as running.
 143
 144     This does no checks, which should be done by its callers.
 145
 146     """
 147     file_name = self._InstanceFile(instance_name)
 148     utils.RemoveFile(file_name)
 149
 150   def StartInstance(self, instance, block_devices, startup_paused):
 151     """Start an instance.
 152
 153     For the fake hypervisor, it just creates a file in the base dir,
 154     creating an exception if it already exists. We don't actually
 155     handle race conditions properly, since these are *FAKE* instances.
 156
 157     """
 158     if self._IsAlive(instance.name):
 159       raise errors.HypervisorError("Failed to start instance %s: %s" %
 160                                    (instance.name, "already running"))
 161     try:
 162       self._MarkUp(instance, self._InstanceStartupMemory(instance))
 163     except IOError, err:
 164       raise errors.HypervisorError("Failed to start instance %s: %s" %
 165                                    (instance.name, err))
 166
 167   def StopInstance(self, instance, force=False, retry=False, name=None):
 168     """Stop an instance.
 169
 170     For the fake hypervisor, this just removes the file in the base
 171     dir, if it exist, otherwise we raise an exception.
 172
 173     """
 174     if name is None:
 175       name = instance.name
 176     if not self._IsAlive(name):
 177       raise errors.HypervisorError("Failed to stop instance %s: %s" %
 178                                    (name, "not running"))
 179     self._MarkDown(name)
 180
 181   def RebootInstance(self, instance):
 182     """Reboot an instance.
 183
 184     For the fake hypervisor, this does nothing.
 185
 186     """
 187     return
 188
 189   def BalloonInstanceMemory(self, instance, mem):
 190     """Balloon an instance memory to a certain value.
 191
 192     @type instance: L{objects.Instance}
 193     @param instance: instance to be accepted
 194     @type mem: int
 195     @param mem: actual memory size to use for instance runtime
 196
 197     """
 198     if not self._IsAlive(instance.name):
 199       raise errors.HypervisorError("Failed to balloon memory for %s: %s" %
 200                                    (instance.name, "not running"))
 201     try:
 202       self._MarkUp(instance, mem)
 203     except EnvironmentError, err:
 204       raise errors.HypervisorError("Failed to balloon memory for %s: %s" %
 205                                    (instance.name, utils.ErrnoOrStr(err)))
 206
 207   def GetNodeInfo(self):
 208     """Return information about the node.
 209
 210     This is just a wrapper over the base GetLinuxNodeInfo method.
 211
 212     @return: a dict with the following keys (values in MiB):
 213           - memory_total: the total memory size on the node
 214           - memory_free: the available memory on the node for instances
 215           - memory_dom0: the memory used by the node itself, if available
 216
 217     """
 218     result = self.GetLinuxNodeInfo()
 219     # substract running instances
 220     all_instances = self.GetAllInstancesInfo()
 221     result["memory_free"] -= min(result["memory_free"],
 222                                  sum([row[2] for row in all_instances]))
 223     return result
 224
 225   @classmethod
 226   def GetInstanceConsole(cls, instance, hvparams, beparams):
 227     """Return information for connecting to the console of an instance.
 228
 229     """
 230     return objects.InstanceConsole(instance=instance.name,
 231                                    kind=constants.CONS_MESSAGE,
 232                                    message=("Console not available for fake"
 233                                             " hypervisor"))
 234
 235   def Verify(self):
 236     """Verify the hypervisor.
 237
 238     For the fake hypervisor, it just checks the existence of the base
 239     dir.
 240
 241     """
 242     if not os.path.exists(self._ROOT_DIR):
 243       return "The required directory '%s' does not exist." % self._ROOT_DIR
 244
 245   @classmethod
 246   def PowercycleNode(cls):
 247     """Fake hypervisor powercycle, just a wrapper over Linux powercycle.
 248
 249     """
 250     cls.LinuxPowercycle()
 251
 252   def AcceptInstance(self, instance, info, target):
 253     """Prepare to accept an instance.
 254
 255     @type instance: L{objects.Instance}
 256     @param instance: instance to be accepted
 257     @type info: string
 258     @param info: instance info, not used
 259     @type target: string
 260     @param target: target host (usually ip), on this node
 261
 262     """
 263     if self._IsAlive(instance.name):
 264       raise errors.HypervisorError("Can't accept instance, already running")
 265
 266   def MigrateInstance(self, instance, target, live):
 267     """Migrate an instance.
 268
 269     @type instance: L{objects.Instance}
 270     @param instance: the instance to be migrated
 271     @type target: string
 272     @param target: hostname (usually ip) of the target node
 273     @type live: boolean
 274     @param live: whether to do a live or non-live migration
 275
 276     """
 277     logging.debug("Fake hypervisor migrating %s to %s (live=%s)",
 278                   instance, target, live)
 279
 280   def FinalizeMigrationDst(self, instance, info, success):
 281     """Finalize the instance migration on the target node.
 282
 283     For the fake hv, this just marks the instance up.
 284
 285     @type instance: L{objects.Instance}
 286     @param instance: instance whose migration is being finalized
 287     @type info: string/data (opaque)
 288     @param info: migration information, from the source node
 289     @type success: boolean
 290     @param success: whether the migration was a success or a failure
 291
 292     """
 293     if success:
 294       self._MarkUp(instance, self._InstanceStartupMemory(instance))
 295     else:
 296       # ensure it's down
 297       self._MarkDown(instance.name)
 298
 299   def PostMigrationCleanup(self, instance):
 300     """Clean-up after a migration.
 301
 302     To be executed on the source node.
 303
 304     @type instance: L{objects.Instance}
 305     @param instance: the instance that was migrated
 306
 307     """
 308     pass
 309
 310   def FinalizeMigrationSource(self, instance, success, live):
 311     """Finalize the instance migration on the source node.
 312
 313     @type instance: L{objects.Instance}
 314     @param instance: the instance that was migrated
 315     @type success: bool
 316     @param success: whether the migration succeeded or not
 317     @type live: bool
 318     @param live: whether the user requested a live migration or not
 319
 320     """
 321     # pylint: disable=W0613
 322     if success:
 323       self._MarkDown(instance.name)
 324
 325   def GetMigrationStatus(self, instance):
 326     """Get the migration status
 327
 328     The fake hypervisor migration always succeeds.
 329
 330     @type instance: L{objects.Instance}
 331     @param instance: the instance that is being migrated
 332     @rtype: L{objects.MigrationStatus}
 333     @return: the status of the current migration (one of
 334              L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
 335              progress info that can be retrieved from the hypervisor
 336
 337     """
 338     return objects.MigrationStatus(status=constants.HV_MIGRATION_COMPLETED)