4 # Copyright (C) 2006, 2007, 2008 Google Inc.
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.
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.
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
30 from ganeti import utils
31 from ganeti import constants
32 from ganeti import errors
33 from ganeti import objects
34 from ganeti import pathutils
35 from ganeti.hypervisor import hv_base
38 class FakeHypervisor(hv_base.BaseHypervisor):
39 """Fake hypervisor interface.
41 This can be used for testing the ganeti code without having to have
42 a real virtualisation software installed.
46 constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
51 _ROOT_DIR = pathutils.RUN_DIR + "/fake-hypervisor"
54 hv_base.BaseHypervisor.__init__(self)
55 utils.EnsureDirs([(self._ROOT_DIR, constants.RUN_DIRS_MODE)])
57 def ListInstances(self, hvparams=None):
58 """Get the list of running instances.
61 return os.listdir(self._ROOT_DIR)
63 def GetInstanceInfo(self, instance_name, hvparams=None):
64 """Get instance properties.
66 @type instance_name: string
67 @param instance_name: the instance name
68 @type hvparams: dict of strings
69 @param hvparams: hvparams to be used with this instance
71 @return: tuple of (name, id, memory, vcpus, stat, times)
74 file_name = self._InstanceFile(instance_name)
75 if not os.path.exists(file_name):
78 fh = open(file_name, "r")
80 inst_id = fh.readline().strip()
81 memory = utils.TryConvert(int, fh.readline().strip())
82 vcpus = utils.TryConvert(int, fh.readline().strip())
85 return (instance_name, inst_id, memory, vcpus, stat, times)
89 raise errors.HypervisorError("Failed to list instance %s: %s" %
92 def GetAllInstancesInfo(self, hvparams=None):
93 """Get properties of all instances.
95 @type hvparams: dict of strings
96 @param hvparams: hypervisor parameter
97 @return: list of tuples (name, id, memory, vcpus, stat, times)
101 for file_name in os.listdir(self._ROOT_DIR):
103 fh = open(utils.PathJoin(self._ROOT_DIR, file_name), "r")
110 inst_id = fh.readline().strip()
111 memory = utils.TryConvert(int, fh.readline().strip())
112 vcpus = utils.TryConvert(int, fh.readline().strip())
117 data.append((file_name, inst_id, memory, vcpus, stat, times))
119 raise errors.HypervisorError("Failed to list instances: %s" % err)
123 def _InstanceFile(cls, instance_name):
124 """Compute the instance file for an instance name.
127 return utils.PathJoin(cls._ROOT_DIR, instance_name)
129 def _IsAlive(self, instance_name):
130 """Checks if an instance is alive.
133 file_name = self._InstanceFile(instance_name)
134 return os.path.exists(file_name)
136 def _MarkUp(self, instance, memory):
137 """Mark the instance as running.
139 This does no checks, which should be done by its callers.
142 file_name = self._InstanceFile(instance.name)
143 fh = file(file_name, "w")
145 fh.write("0\n%d\n%d\n" %
147 instance.beparams[constants.BE_VCPUS]))
151 def _MarkDown(self, instance_name):
152 """Mark the instance as running.
154 This does no checks, which should be done by its callers.
157 file_name = self._InstanceFile(instance_name)
158 utils.RemoveFile(file_name)
160 def StartInstance(self, instance, block_devices, startup_paused):
161 """Start an instance.
163 For the fake hypervisor, it just creates a file in the base dir,
164 creating an exception if it already exists. We don't actually
165 handle race conditions properly, since these are *FAKE* instances.
168 if self._IsAlive(instance.name):
169 raise errors.HypervisorError("Failed to start instance %s: %s" %
170 (instance.name, "already running"))
172 self._MarkUp(instance, self._InstanceStartupMemory(instance))
174 raise errors.HypervisorError("Failed to start instance %s: %s" %
175 (instance.name, err))
177 def StopInstance(self, instance, force=False, retry=False, name=None):
180 For the fake hypervisor, this just removes the file in the base
181 dir, if it exist, otherwise we raise an exception.
186 if not self._IsAlive(name):
187 raise errors.HypervisorError("Failed to stop instance %s: %s" %
188 (name, "not running"))
191 def RebootInstance(self, instance):
192 """Reboot an instance.
194 For the fake hypervisor, this does nothing.
199 def BalloonInstanceMemory(self, instance, mem):
200 """Balloon an instance memory to a certain value.
202 @type instance: L{objects.Instance}
203 @param instance: instance to be accepted
205 @param mem: actual memory size to use for instance runtime
208 if not self._IsAlive(instance.name):
209 raise errors.HypervisorError("Failed to balloon memory for %s: %s" %
210 (instance.name, "not running"))
212 self._MarkUp(instance, mem)
213 except EnvironmentError, err:
214 raise errors.HypervisorError("Failed to balloon memory for %s: %s" %
215 (instance.name, utils.ErrnoOrStr(err)))
217 def GetNodeInfo(self, hvparams=None):
218 """Return information about the node.
220 This is just a wrapper over the base GetLinuxNodeInfo method.
222 @type hvparams: dict of strings
223 @param hvparams: hypervisor parameters, not used in this class
225 @return: a dict with the following keys (values in MiB):
226 - memory_total: the total memory size on the node
227 - memory_free: the available memory on the node for instances
228 - memory_dom0: the memory used by the node itself, if available
231 result = self.GetLinuxNodeInfo()
232 # substract running instances
233 all_instances = self.GetAllInstancesInfo()
234 result["memory_free"] -= min(result["memory_free"],
235 sum([row[2] for row in all_instances]))
239 def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
240 """Return information for connecting to the console of an instance.
243 return objects.InstanceConsole(instance=instance.name,
244 kind=constants.CONS_MESSAGE,
245 message=("Console not available for fake"
248 def Verify(self, hvparams=None):
249 """Verify the hypervisor.
251 For the fake hypervisor, it just checks the existence of the base
254 @type hvparams: dict of strings
255 @param hvparams: hypervisor parameters to be verified against; not used
258 @return: Problem description if something is wrong, C{None} otherwise
261 if os.path.exists(self._ROOT_DIR):
264 return "The required directory '%s' does not exist" % self._ROOT_DIR
267 def PowercycleNode(cls, hvparams=None):
268 """Fake hypervisor powercycle, just a wrapper over Linux powercycle.
270 @type hvparams: dict of strings
271 @param hvparams: hypervisor params to be used on this node
274 cls.LinuxPowercycle()
276 def AcceptInstance(self, instance, info, target):
277 """Prepare to accept an instance.
279 @type instance: L{objects.Instance}
280 @param instance: instance to be accepted
282 @param info: instance info, not used
284 @param target: target host (usually ip), on this node
287 if self._IsAlive(instance.name):
288 raise errors.HypervisorError("Can't accept instance, already running")
290 def MigrateInstance(self, cluster_name, instance, target, live):
291 """Migrate an instance.
293 @type cluster_name: string
294 @param cluster_name: name of the cluster
295 @type instance: L{objects.Instance}
296 @param instance: the instance to be migrated
298 @param target: hostname (usually ip) of the target node
300 @param live: whether to do a live or non-live migration
303 logging.debug("Fake hypervisor migrating %s to %s (live=%s)",
304 instance, target, live)
306 def FinalizeMigrationDst(self, instance, info, success):
307 """Finalize the instance migration on the target node.
309 For the fake hv, this just marks the instance up.
311 @type instance: L{objects.Instance}
312 @param instance: instance whose migration is being finalized
313 @type info: string/data (opaque)
314 @param info: migration information, from the source node
315 @type success: boolean
316 @param success: whether the migration was a success or a failure
320 self._MarkUp(instance, self._InstanceStartupMemory(instance))
323 self._MarkDown(instance.name)
325 def PostMigrationCleanup(self, instance):
326 """Clean-up after a migration.
328 To be executed on the source node.
330 @type instance: L{objects.Instance}
331 @param instance: the instance that was migrated
336 def FinalizeMigrationSource(self, instance, success, live):
337 """Finalize the instance migration on the source node.
339 @type instance: L{objects.Instance}
340 @param instance: the instance that was migrated
342 @param success: whether the migration succeeded or not
344 @param live: whether the user requested a live migration or not
347 # pylint: disable=W0613
349 self._MarkDown(instance.name)
351 def GetMigrationStatus(self, instance):
352 """Get the migration status
354 The fake hypervisor migration always succeeds.
356 @type instance: L{objects.Instance}
357 @param instance: the instance that is being migrated
358 @rtype: L{objects.MigrationStatus}
359 @return: the status of the current migration (one of
360 L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
361 progress info that can be retrieved from the hypervisor
364 return objects.MigrationStatus(status=constants.HV_MIGRATION_COMPLETED)