Statistics
| Branch: | Tag: | Revision:

root / lib / backend.py @ f3e513ad

History | View | Annotate | Download (41.1 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007 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
"""Functions used by the node daemon"""
23

    
24

    
25
import os
26
import os.path
27
import shutil
28
import time
29
import tempfile
30
import stat
31
import errno
32
import re
33
import subprocess
34

    
35
from ganeti import logger
36
from ganeti import errors
37
from ganeti import utils
38
from ganeti import ssh
39
from ganeti import hypervisor
40
from ganeti import constants
41
from ganeti import bdev
42
from ganeti import objects
43
from ganeti import ssconf
44

    
45

    
46
def StartMaster():
47
  """Activate local node as master node.
48

49
  There are two needed steps for this:
50
    - run the master script
51
    - register the cron script
52

53
  """
54
  result = utils.RunCmd([constants.MASTER_SCRIPT, "-d", "start"])
55

    
56
  if result.failed:
57
    logger.Error("could not activate cluster interface with command %s,"
58
                 " error: '%s'" % (result.cmd, result.output))
59
    return False
60

    
61
  return True
62

    
63

    
64
def StopMaster():
65
  """Deactivate this node as master.
66

67
  This does two things:
68
    - run the master stop script
69
    - remove link to master cron script.
70

71
  """
72
  result = utils.RunCmd([constants.MASTER_SCRIPT, "-d", "stop"])
73

    
74
  if result.failed:
75
    logger.Error("could not deactivate cluster interface with command %s,"
76
                 " error: '%s'" % (result.cmd, result.output))
77
    return False
78

    
79
  return True
80

    
81

    
82
def AddNode(dsa, dsapub, rsa, rsapub, sshkey, sshpub):
83
  """Joins this node to the cluster.
84

85
  This does the following:
86
      - updates the hostkeys of the machine (rsa and dsa)
87
      - adds the ssh private key to the user
88
      - adds the ssh public key to the users' authorized_keys file
89

90
  """
91
  sshd_keys =  [(constants.SSH_HOST_RSA_PRIV, rsa, 0600),
92
                (constants.SSH_HOST_RSA_PUB, rsapub, 0644),
93
                (constants.SSH_HOST_DSA_PRIV, dsa, 0600),
94
                (constants.SSH_HOST_DSA_PUB, dsapub, 0644)]
95
  for name, content, mode in sshd_keys:
96
    utils.WriteFile(name, data=content, mode=mode)
97

    
98
  try:
99
    priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS,
100
                                                    mkdir=True)
101
  except errors.OpExecError, err:
102
    logger.Error("Error while processing user ssh files: %s" % err)
103
    return False
104

    
105
  for name, content in [(priv_key, sshkey), (pub_key, sshpub)]:
106
    utils.WriteFile(name, data=content, mode=0600)
107

    
108
  utils.AddAuthorizedKey(auth_keys, sshpub)
109

    
110
  utils.RunCmd([constants.SSH_INITD_SCRIPT, "restart"])
111

    
112
  return True
113

    
114

    
115
def LeaveCluster():
116
  """Cleans up the current node and prepares it to be removed from the cluster.
117

118
  """
119
  if os.path.isdir(constants.DATA_DIR):
120
    for rel_name in utils.ListVisibleFiles(constants.DATA_DIR):
121
      full_name = os.path.join(constants.DATA_DIR, rel_name)
122
      if os.path.isfile(full_name) and not os.path.islink(full_name):
123
        utils.RemoveFile(full_name)
124

    
125

    
126
  try:
127
    priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
128
  except errors.OpExecError, err:
129
    logger.Error("Error while processing ssh files: %s" % err)
130
    return
131

    
132
  f = open(pub_key, 'r')
133
  try:
134
    utils.RemoveAuthorizedKey(auth_keys, f.read(8192))
135
  finally:
136
    f.close()
137

    
138
  utils.RemoveFile(priv_key)
139
  utils.RemoveFile(pub_key)
140

    
141

    
142
def GetNodeInfo(vgname):
143
  """Gives back a hash with different informations about the node.
144

145
  Returns:
146
    { 'vg_size' : xxx,  'vg_free' : xxx, 'memory_domain0': xxx,
147
      'memory_free' : xxx, 'memory_total' : xxx }
148
    where
149
    vg_size is the size of the configured volume group in MiB
150
    vg_free is the free size of the volume group in MiB
151
    memory_dom0 is the memory allocated for domain0 in MiB
152
    memory_free is the currently available (free) ram in MiB
153
    memory_total is the total number of ram in MiB
154

155
  """
156
  outputarray = {}
157
  vginfo = _GetVGInfo(vgname)
158
  outputarray['vg_size'] = vginfo['vg_size']
159
  outputarray['vg_free'] = vginfo['vg_free']
160

    
161
  hyper = hypervisor.GetHypervisor()
162
  hyp_info = hyper.GetNodeInfo()
163
  if hyp_info is not None:
164
    outputarray.update(hyp_info)
165

    
166
  f = open("/proc/sys/kernel/random/boot_id", 'r')
167
  try:
168
    outputarray["bootid"] = f.read(128).rstrip("\n")
169
  finally:
170
    f.close()
171

    
172
  return outputarray
173

    
174

    
175
def VerifyNode(what):
176
  """Verify the status of the local node.
177

178
  Args:
179
    what - a dictionary of things to check:
180
      'filelist' : list of files for which to compute checksums
181
      'nodelist' : list of nodes we should check communication with
182
      'hypervisor': run the hypervisor-specific verify
183

184
  Requested files on local node are checksummed and the result returned.
185

186
  The nodelist is traversed, with the following checks being made
187
  for each node:
188
  - known_hosts key correct
189
  - correct resolving of node name (target node returns its own hostname
190
    by ssh-execution of 'hostname', result compared against name in list.
191

192
  """
193
  result = {}
194

    
195
  if 'hypervisor' in what:
196
    result['hypervisor'] = hypervisor.GetHypervisor().Verify()
197

    
198
  if 'filelist' in what:
199
    result['filelist'] = utils.FingerprintFiles(what['filelist'])
200

    
201
  if 'nodelist' in what:
202
    result['nodelist'] = {}
203
    for node in what['nodelist']:
204
      success, message = ssh.VerifyNodeHostname(node)
205
      if not success:
206
        result['nodelist'][node] = message
207
  return result
208

    
209

    
210
def GetVolumeList(vg_name):
211
  """Compute list of logical volumes and their size.
212

213
  Returns:
214
    dictionary of all partions (key) with their size:
215
    test1: 20.06MiB
216

217
  """
218
  result = utils.RunCmd(["lvs", "--noheadings", "--units=m",
219
                         "-oname,size", vg_name])
220
  if result.failed:
221
    logger.Error("Failed to list logical volumes, lvs output: %s" %
222
                 result.output)
223
    return {}
224

    
225
  lvlist = [line.split() for line in result.output.splitlines()]
226
  return dict(lvlist)
227

    
228

    
229
def ListVolumeGroups():
230
  """List the volume groups and their size.
231

232
  Returns:
233
    Dictionary with keys volume name and values the size of the volume
234

235
  """
236
  return utils.ListVolumeGroups()
237

    
238

    
239
def NodeVolumes():
240
  """List all volumes on this node.
241

242
  """
243
  result = utils.RunCmd(["lvs", "--noheadings", "--units=m", "--nosuffix",
244
                         "--separator=|",
245
                         "--options=lv_name,lv_size,devices,vg_name"])
246
  if result.failed:
247
    logger.Error("Failed to list logical volumes, lvs output: %s" %
248
                 result.output)
249
    return {}
250

    
251
  def parse_dev(dev):
252
    if '(' in dev:
253
      return dev.split('(')[0]
254
    else:
255
      return dev
256

    
257
  def map_line(line):
258
    return {
259
      'name': line[0].strip(),
260
      'size': line[1].strip(),
261
      'dev': parse_dev(line[2].strip()),
262
      'vg': line[3].strip(),
263
    }
264

    
265
  return [map_line(line.split('|')) for line in result.output.splitlines()]
266

    
267

    
268
def BridgesExist(bridges_list):
269
  """Check if a list of bridges exist on the current node.
270

271
  Returns:
272
    True if all of them exist, false otherwise
273

274
  """
275
  for bridge in bridges_list:
276
    if not utils.BridgeExists(bridge):
277
      return False
278

    
279
  return True
280

    
281

    
282
def GetInstanceList():
283
  """Provides a list of instances.
284

285
  Returns:
286
    A list of all running instances on the current node
287
    - instance1.example.com
288
    - instance2.example.com
289

290
  """
291
  try:
292
    names = hypervisor.GetHypervisor().ListInstances()
293
  except errors.HypervisorError, err:
294
    logger.Error("error enumerating instances: %s" % str(err))
295
    raise
296

    
297
  return names
298

    
299

    
300
def GetInstanceInfo(instance):
301
  """Gives back the informations about an instance as a dictionary.
302

303
  Args:
304
    instance: name of the instance (ex. instance1.example.com)
305

306
  Returns:
307
    { 'memory' : 511, 'state' : '-b---', 'time' : 3188.8, }
308
    where
309
    memory: memory size of instance (int)
310
    state: xen state of instance (string)
311
    time: cpu time of instance (float)
312

313
  """
314
  output = {}
315

    
316
  iinfo = hypervisor.GetHypervisor().GetInstanceInfo(instance)
317
  if iinfo is not None:
318
    output['memory'] = iinfo[2]
319
    output['state'] = iinfo[4]
320
    output['time'] = iinfo[5]
321

    
322
  return output
323

    
324

    
325
def GetAllInstancesInfo():
326
  """Gather data about all instances.
327

328
  This is the equivalent of `GetInstanceInfo()`, except that it
329
  computes data for all instances at once, thus being faster if one
330
  needs data about more than one instance.
331

332
  Returns: a dictionary of dictionaries, keys being the instance name,
333
    and with values:
334
    { 'memory' : 511, 'state' : '-b---', 'time' : 3188.8, }
335
    where
336
    memory: memory size of instance (int)
337
    state: xen state of instance (string)
338
    time: cpu time of instance (float)
339
    vcpus: the number of cpus
340

341
  """
342
  output = {}
343

    
344
  iinfo = hypervisor.GetHypervisor().GetAllInstancesInfo()
345
  if iinfo:
346
    for name, inst_id, memory, vcpus, state, times in iinfo:
347
      output[name] = {
348
        'memory': memory,
349
        'vcpus': vcpus,
350
        'state': state,
351
        'time': times,
352
        }
353

    
354
  return output
355

    
356

    
357
def AddOSToInstance(instance, os_disk, swap_disk):
358
  """Add an OS to an instance.
359

360
  Args:
361
    instance: the instance object
362
    os_disk: the instance-visible name of the os device
363
    swap_disk: the instance-visible name of the swap device
364

365
  """
366
  inst_os = OSFromDisk(instance.os)
367

    
368
  create_script = inst_os.create_script
369

    
370
  os_device = instance.FindDisk(os_disk)
371
  if os_device is None:
372
    logger.Error("Can't find this device-visible name '%s'" % os_disk)
373
    return False
374

    
375
  swap_device = instance.FindDisk(swap_disk)
376
  if swap_device is None:
377
    logger.Error("Can't find this device-visible name '%s'" % swap_disk)
378
    return False
379

    
380
  real_os_dev = _RecursiveFindBD(os_device)
381
  if real_os_dev is None:
382
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
383
                                  str(os_device))
384
  real_os_dev.Open()
385

    
386
  real_swap_dev = _RecursiveFindBD(swap_device)
387
  if real_swap_dev is None:
388
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
389
                                  str(swap_device))
390
  real_swap_dev.Open()
391

    
392
  logfile = "%s/add-%s-%s-%d.log" % (constants.LOG_OS_DIR, instance.os,
393
                                     instance.name, int(time.time()))
394
  if not os.path.exists(constants.LOG_OS_DIR):
395
    os.mkdir(constants.LOG_OS_DIR, 0750)
396

    
397
  command = utils.BuildShellCmd("cd %s && %s -i %s -b %s -s %s &>%s",
398
                                inst_os.path, create_script, instance.name,
399
                                real_os_dev.dev_path, real_swap_dev.dev_path,
400
                                logfile)
401

    
402
  result = utils.RunCmd(command)
403

    
404
  if result.failed:
405
    logger.Error("os create command '%s' returned error: %s"
406
                 " output: %s" %
407
                 (command, result.fail_reason, result.output))
408
    return False
409

    
410
  return True
411

    
412

    
413
def RunRenameInstance(instance, old_name, os_disk, swap_disk):
414
  """Run the OS rename script for an instance.
415

416
  Args:
417
    instance: the instance object
418
    old_name: the old name of the instance
419
    os_disk: the instance-visible name of the os device
420
    swap_disk: the instance-visible name of the swap device
421

422
  """
423
  inst_os = OSFromDisk(instance.os)
424

    
425
  script = inst_os.rename_script
426

    
427
  os_device = instance.FindDisk(os_disk)
428
  if os_device is None:
429
    logger.Error("Can't find this device-visible name '%s'" % os_disk)
430
    return False
431

    
432
  swap_device = instance.FindDisk(swap_disk)
433
  if swap_device is None:
434
    logger.Error("Can't find this device-visible name '%s'" % swap_disk)
435
    return False
436

    
437
  real_os_dev = _RecursiveFindBD(os_device)
438
  if real_os_dev is None:
439
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
440
                                  str(os_device))
441
  real_os_dev.Open()
442

    
443
  real_swap_dev = _RecursiveFindBD(swap_device)
444
  if real_swap_dev is None:
445
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
446
                                  str(swap_device))
447
  real_swap_dev.Open()
448

    
449
  logfile = "%s/rename-%s-%s-%s-%d.log" % (constants.LOG_OS_DIR, instance.os,
450
                                           old_name,
451
                                           instance.name, int(time.time()))
452
  if not os.path.exists(constants.LOG_OS_DIR):
453
    os.mkdir(constants.LOG_OS_DIR, 0750)
454

    
455
  command = utils.BuildShellCmd("cd %s && %s -o %s -n %s -b %s -s %s &>%s",
456
                                inst_os.path, script, old_name, instance.name,
457
                                real_os_dev.dev_path, real_swap_dev.dev_path,
458
                                logfile)
459

    
460
  result = utils.RunCmd(command)
461

    
462
  if result.failed:
463
    logger.Error("os create command '%s' returned error: %s"
464
                 " output: %s" %
465
                 (command, result.fail_reason, result.output))
466
    return False
467

    
468
  return True
469

    
470

    
471
def _GetVGInfo(vg_name):
472
  """Get informations about the volume group.
473

474
  Args:
475
    vg_name: the volume group
476

477
  Returns:
478
    { 'vg_size' : xxx, 'vg_free' : xxx, 'pv_count' : xxx }
479
    where
480
    vg_size is the total size of the volume group in MiB
481
    vg_free is the free size of the volume group in MiB
482
    pv_count are the number of physical disks in that vg
483

484
  """
485
  retval = utils.RunCmd(["vgs", "-ovg_size,vg_free,pv_count", "--noheadings",
486
                         "--nosuffix", "--units=m", "--separator=:", vg_name])
487

    
488
  if retval.failed:
489
    errmsg = "volume group %s not present" % vg_name
490
    logger.Error(errmsg)
491
    raise errors.LVMError(errmsg)
492
  valarr = retval.stdout.strip().split(':')
493
  retdic = {
494
    "vg_size": int(round(float(valarr[0]), 0)),
495
    "vg_free": int(round(float(valarr[1]), 0)),
496
    "pv_count": int(valarr[2]),
497
    }
498
  return retdic
499

    
500

    
501
def _GatherBlockDevs(instance):
502
  """Set up an instance's block device(s).
503

504
  This is run on the primary node at instance startup. The block
505
  devices must be already assembled.
506

507
  """
508
  block_devices = []
509
  for disk in instance.disks:
510
    device = _RecursiveFindBD(disk)
511
    if device is None:
512
      raise errors.BlockDeviceError("Block device '%s' is not set up." %
513
                                    str(disk))
514
    device.Open()
515
    block_devices.append((disk, device))
516
  return block_devices
517

    
518

    
519
def StartInstance(instance, extra_args):
520
  """Start an instance.
521

522
  Args:
523
    instance - name of instance to start.
524

525
  """
526
  running_instances = GetInstanceList()
527

    
528
  if instance.name in running_instances:
529
    return True
530

    
531
  block_devices = _GatherBlockDevs(instance)
532
  hyper = hypervisor.GetHypervisor()
533

    
534
  try:
535
    hyper.StartInstance(instance, block_devices, extra_args)
536
  except errors.HypervisorError, err:
537
    logger.Error("Failed to start instance: %s" % err)
538
    return False
539

    
540
  return True
541

    
542

    
543
def ShutdownInstance(instance):
544
  """Shut an instance down.
545

546
  Args:
547
    instance - name of instance to shutdown.
548

549
  """
550
  running_instances = GetInstanceList()
551

    
552
  if instance.name not in running_instances:
553
    return True
554

    
555
  hyper = hypervisor.GetHypervisor()
556
  try:
557
    hyper.StopInstance(instance)
558
  except errors.HypervisorError, err:
559
    logger.Error("Failed to stop instance: %s" % err)
560
    return False
561

    
562
  # test every 10secs for 2min
563
  shutdown_ok = False
564

    
565
  time.sleep(1)
566
  for dummy in range(11):
567
    if instance.name not in GetInstanceList():
568
      break
569
    time.sleep(10)
570
  else:
571
    # the shutdown did not succeed
572
    logger.Error("shutdown of '%s' unsuccessful, using destroy" % instance)
573

    
574
    try:
575
      hyper.StopInstance(instance, force=True)
576
    except errors.HypervisorError, err:
577
      logger.Error("Failed to stop instance: %s" % err)
578
      return False
579

    
580
    time.sleep(1)
581
    if instance.name in GetInstanceList():
582
      logger.Error("could not shutdown instance '%s' even by destroy")
583
      return False
584

    
585
  return True
586

    
587

    
588
def RebootInstance(instance, reboot_type, extra_args):
589
  """Reboot an instance.
590

591
  Args:
592
    instance    - name of instance to reboot
593
    reboot_type - how to reboot [soft,hard,full]
594

595
  """
596
  running_instances = GetInstanceList()
597

    
598
  if instance.name not in running_instances:
599
    logger.Error("Cannot reboot instance that is not running")
600
    return False
601

    
602
  hyper = hypervisor.GetHypervisor()
603
  if reboot_type == constants.INSTANCE_REBOOT_SOFT:
604
    try:
605
      hyper.RebootInstance(instance)
606
    except errors.HypervisorError, err:
607
      logger.Error("Failed to soft reboot instance: %s" % err)
608
      return False
609
  elif reboot_type == constants.INSTANCE_REBOOT_HARD:
610
    try:
611
      ShutdownInstance(instance)
612
      StartInstance(instance, extra_args)
613
    except errors.HypervisorError, err:
614
      logger.Error("Failed to hard reboot instance: %s" % err)
615
      return False
616
  else:
617
    raise errors.ParameterError("reboot_type invalid")
618

    
619

    
620
  return True
621

    
622

    
623
def CreateBlockDevice(disk, size, on_primary, info):
624
  """Creates a block device for an instance.
625

626
  Args:
627
   bdev: a ganeti.objects.Disk object
628
   size: the size of the physical underlying devices
629
   do_open: if the device should be `Assemble()`-d and
630
            `Open()`-ed after creation
631

632
  Returns:
633
    the new unique_id of the device (this can sometime be
634
    computed only after creation), or None. On secondary nodes,
635
    it's not required to return anything.
636

637
  """
638
  clist = []
639
  if disk.children:
640
    for child in disk.children:
641
      crdev = _RecursiveAssembleBD(child, on_primary)
642
      if on_primary or disk.AssembleOnSecondary():
643
        # we need the children open in case the device itself has to
644
        # be assembled
645
        crdev.Open()
646
      else:
647
        crdev.Close()
648
      clist.append(crdev)
649
  try:
650
    device = bdev.FindDevice(disk.dev_type, disk.physical_id, clist)
651
    if device is not None:
652
      logger.Info("removing existing device %s" % disk)
653
      device.Remove()
654
  except errors.BlockDeviceError, err:
655
    pass
656

    
657
  device = bdev.Create(disk.dev_type, disk.physical_id,
658
                       clist, size)
659
  if device is None:
660
    raise ValueError("Can't create child device for %s, %s" %
661
                     (disk, size))
662
  if on_primary or disk.AssembleOnSecondary():
663
    device.Assemble()
664
    device.SetSyncSpeed(constants.SYNC_SPEED)
665
    if on_primary or disk.OpenOnSecondary():
666
      device.Open(force=True)
667

    
668
  device.SetInfo(info)
669

    
670
  physical_id = device.unique_id
671
  return physical_id
672

    
673

    
674
def RemoveBlockDevice(disk):
675
  """Remove a block device.
676

677
  This is intended to be called recursively.
678

679
  """
680
  try:
681
    # since we are removing the device, allow a partial match
682
    # this allows removal of broken mirrors
683
    rdev = _RecursiveFindBD(disk, allow_partial=True)
684
  except errors.BlockDeviceError, err:
685
    # probably can't attach
686
    logger.Info("Can't attach to device %s in remove" % disk)
687
    rdev = None
688
  if rdev is not None:
689
    result = rdev.Remove()
690
  else:
691
    result = True
692
  if disk.children:
693
    for child in disk.children:
694
      result = result and RemoveBlockDevice(child)
695
  return result
696

    
697

    
698
def _RecursiveAssembleBD(disk, as_primary):
699
  """Activate a block device for an instance.
700

701
  This is run on the primary and secondary nodes for an instance.
702

703
  This function is called recursively.
704

705
  Args:
706
    disk: a objects.Disk object
707
    as_primary: if we should make the block device read/write
708

709
  Returns:
710
    the assembled device or None (in case no device was assembled)
711

712
  If the assembly is not successful, an exception is raised.
713

714
  """
715
  children = []
716
  if disk.children:
717
    for chld_disk in disk.children:
718
      children.append(_RecursiveAssembleBD(chld_disk, as_primary))
719

    
720
  if as_primary or disk.AssembleOnSecondary():
721
    r_dev = bdev.AttachOrAssemble(disk.dev_type, disk.physical_id, children)
722
    r_dev.SetSyncSpeed(constants.SYNC_SPEED)
723
    result = r_dev
724
    if as_primary or disk.OpenOnSecondary():
725
      r_dev.Open()
726
    else:
727
      r_dev.Close()
728
  else:
729
    result = True
730
  return result
731

    
732

    
733
def AssembleBlockDevice(disk, as_primary):
734
  """Activate a block device for an instance.
735

736
  This is a wrapper over _RecursiveAssembleBD.
737

738
  Returns:
739
    a /dev path for primary nodes
740
    True for secondary nodes
741

742
  """
743
  result = _RecursiveAssembleBD(disk, as_primary)
744
  if isinstance(result, bdev.BlockDev):
745
    result = result.dev_path
746
  return result
747

    
748

    
749
def ShutdownBlockDevice(disk):
750
  """Shut down a block device.
751

752
  First, if the device is assembled (can `Attach()`), then the device
753
  is shutdown. Then the children of the device are shutdown.
754

755
  This function is called recursively. Note that we don't cache the
756
  children or such, as oppossed to assemble, shutdown of different
757
  devices doesn't require that the upper device was active.
758

759
  """
760
  r_dev = _RecursiveFindBD(disk)
761
  if r_dev is not None:
762
    result = r_dev.Shutdown()
763
  else:
764
    result = True
765
  if disk.children:
766
    for child in disk.children:
767
      result = result and ShutdownBlockDevice(child)
768
  return result
769

    
770

    
771
def MirrorAddChildren(parent_cdev, new_cdevs):
772
  """Extend a mirrored block device.
773

774
  """
775
  parent_bdev = _RecursiveFindBD(parent_cdev, allow_partial=True)
776
  if parent_bdev is None:
777
    logger.Error("Can't find parent device")
778
    return False
779
  new_bdevs = [_RecursiveFindBD(disk) for disk in new_cdevs]
780
  if new_bdevs.count(None) > 0:
781
    logger.Error("Can't find new device(s) to add")
782
    return False
783
  parent_bdev.AddChildren(new_bdevs)
784
  return True
785

    
786

    
787
def MirrorRemoveChildren(parent_cdev, new_cdevs):
788
  """Shrink a mirrored block device.
789

790
  """
791
  parent_bdev = _RecursiveFindBD(parent_cdev)
792
  if parent_bdev is None:
793
    return False
794
  new_bdevs = [_RecursiveFindBD(disk) for disk in new_cdevs]
795
  if new_bdevs.count(None) > 0:
796
    return False
797
  parent_bdev.RemoveChildren(new_bdevs)
798
  return True
799

    
800

    
801
def GetMirrorStatus(disks):
802
  """Get the mirroring status of a list of devices.
803

804
  Args:
805
    disks: list of `objects.Disk`
806

807
  Returns:
808
    list of (mirror_done, estimated_time) tuples, which
809
    are the result of bdev.BlockDevice.CombinedSyncStatus()
810

811
  """
812
  stats = []
813
  for dsk in disks:
814
    rbd = _RecursiveFindBD(dsk)
815
    if rbd is None:
816
      raise errors.BlockDeviceError("Can't find device %s" % str(dsk))
817
    stats.append(rbd.CombinedSyncStatus())
818
  return stats
819

    
820

    
821
def _RecursiveFindBD(disk, allow_partial=False):
822
  """Check if a device is activated.
823

824
  If so, return informations about the real device.
825

826
  Args:
827
    disk: the objects.Disk instance
828
    allow_partial: don't abort the find if a child of the
829
                   device can't be found; this is intended to be
830
                   used when repairing mirrors
831

832
  Returns:
833
    None if the device can't be found
834
    otherwise the device instance
835

836
  """
837
  children = []
838
  if disk.children:
839
    for chdisk in disk.children:
840
      children.append(_RecursiveFindBD(chdisk))
841

    
842
  return bdev.FindDevice(disk.dev_type, disk.physical_id, children)
843

    
844

    
845
def FindBlockDevice(disk):
846
  """Check if a device is activated.
847

848
  If so, return informations about the real device.
849

850
  Args:
851
    disk: the objects.Disk instance
852
  Returns:
853
    None if the device can't be found
854
    (device_path, major, minor, sync_percent, estimated_time, is_degraded)
855

856
  """
857
  rbd = _RecursiveFindBD(disk)
858
  if rbd is None:
859
    return rbd
860
  sync_p, est_t, is_degr = rbd.GetSyncStatus()
861
  return rbd.dev_path, rbd.major, rbd.minor, sync_p, est_t, is_degr
862

    
863

    
864
def UploadFile(file_name, data, mode, uid, gid, atime, mtime):
865
  """Write a file to the filesystem.
866

867
  This allows the master to overwrite(!) a file. It will only perform
868
  the operation if the file belongs to a list of configuration files.
869

870
  """
871
  if not os.path.isabs(file_name):
872
    logger.Error("Filename passed to UploadFile is not absolute: '%s'" %
873
                 file_name)
874
    return False
875

    
876
  allowed_files = [constants.CLUSTER_CONF_FILE, "/etc/hosts",
877
                   constants.SSH_KNOWN_HOSTS_FILE]
878
  allowed_files.extend(ssconf.SimpleStore().GetFileList())
879
  if file_name not in allowed_files:
880
    logger.Error("Filename passed to UploadFile not in allowed"
881
                 " upload targets: '%s'" % file_name)
882
    return False
883

    
884
  dir_name, small_name = os.path.split(file_name)
885
  fd, new_name = tempfile.mkstemp('.new', small_name, dir_name)
886
  # here we need to make sure we remove the temp file, if any error
887
  # leaves it in place
888
  try:
889
    os.chown(new_name, uid, gid)
890
    os.chmod(new_name, mode)
891
    os.write(fd, data)
892
    os.fsync(fd)
893
    os.utime(new_name, (atime, mtime))
894
    os.rename(new_name, file_name)
895
  finally:
896
    os.close(fd)
897
    utils.RemoveFile(new_name)
898
  return True
899

    
900

    
901
def _ErrnoOrStr(err):
902
  """Format an EnvironmentError exception.
903

904
  If the `err` argument has an errno attribute, it will be looked up
905
  and converted into a textual EXXXX description. Otherwise the string
906
  representation of the error will be returned.
907

908
  """
909
  if hasattr(err, 'errno'):
910
    detail = errno.errorcode[err.errno]
911
  else:
912
    detail = str(err)
913
  return detail
914

    
915
def _OSSearch(name, search_path=None):
916
  """Search for OSes with the given name in the search_path.
917

918
  Args:
919
    name: The name of the OS to look for
920
    search_path: List of dirs to search (defaults to constants.OS_SEARCH_PATH)
921

922
  Returns:
923
    The base_dir the OS resides in
924

925
  """
926

    
927
  if search_path is None:
928
    search_path = constants.OS_SEARCH_PATH
929

    
930
  for dir in search_path:
931
    t_os_dir = os.path.sep.join([dir, name])
932
    if os.path.isdir(t_os_dir):
933
        return dir
934

    
935
  return None
936

    
937
def _OSOndiskVersion(name, os_dir):
938
  """Compute and return the API version of a given OS.
939

940
  This function will try to read the API version of the os given by
941
  the 'name' parameter and residing in the 'os_dir' directory.
942

943
  Return value will be either an integer denoting the version or None in the
944
  case when this is not a valid OS name.
945

946
  """
947

    
948
  api_file = os.path.sep.join([os_dir, "ganeti_api_version"])
949

    
950
  try:
951
    st = os.stat(api_file)
952
  except EnvironmentError, err:
953
    raise errors.InvalidOS(name, os_dir, "'ganeti_api_version' file not"
954
                           " found (%s)" % _ErrnoOrStr(err))
955

    
956
  if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
957
    raise errors.InvalidOS(name, os_dir, "'ganeti_api_version' file is not"
958
                           " a regular file")
959

    
960
  try:
961
    f = open(api_file)
962
    try:
963
      api_version = f.read(256)
964
    finally:
965
      f.close()
966
  except EnvironmentError, err:
967
    raise errors.InvalidOS(name, os_dir, "error while reading the"
968
                           " API version (%s)" % _ErrnoOrStr(err))
969

    
970
  api_version = api_version.strip()
971
  try:
972
    api_version = int(api_version)
973
  except (TypeError, ValueError), err:
974
    raise errors.InvalidOS(name, os_dir,
975
                           "API version is not integer (%s)" % str(err))
976

    
977
  return api_version
978

    
979

    
980
def DiagnoseOS(top_dirs=None):
981
  """Compute the validity for all OSes.
982

983
  For each name in all the given top directories (if not given defaults i
984
  to constants.OS_SEARCH_PATH it will return an object. If this is a valid
985
  os, the object will be an instance of the object.OS class. If not,
986
  it will be an instance of errors.InvalidOS and this signifies that
987
  this name does not correspond to a valid OS.
988

989
  Returns:
990
    list of objects
991

992
  """
993
  if top_dirs is None:
994
    top_dirs = constants.OS_SEARCH_PATH
995

    
996
  result = []
997
  for dir in top_dirs:
998
    if os.path.isdir(dir):
999
      try:
1000
        f_names = utils.ListVisibleFiles(dir)
1001
      except EnvironmentError, err:
1002
        logger.Error("Can't list the OS directory %s: %s" % (dir,str(err)))
1003
        break
1004
      for name in f_names:
1005
        try:
1006
          os_inst = OSFromDisk(name, base_dir=dir)
1007
          result.append(os_inst)
1008
        except errors.InvalidOS, err:
1009
          result.append(err)
1010

    
1011
  return result
1012

    
1013

    
1014
def OSFromDisk(name, base_dir=None):
1015
  """Create an OS instance from disk.
1016

1017
  This function will return an OS instance if the given name is a
1018
  valid OS name. Otherwise, it will raise an appropriate
1019
  `errors.InvalidOS` exception, detailing why this is not a valid
1020
  OS.
1021

1022
  Args:
1023
    os_dir: Directory containing the OS scripts. Defaults to a search
1024
            in all the OS_SEARCH_PATH directories.
1025

1026
  """
1027

    
1028
  if base_dir is None:
1029
    base_dir = _OSSearch(name)
1030

    
1031
  if base_dir is None:
1032
    raise errors.InvalidOS(name, None, "OS dir not found in search path")
1033

    
1034
  os_dir = os.path.sep.join([base_dir, name])
1035
  api_version = _OSOndiskVersion(name, os_dir)
1036

    
1037
  if api_version != constants.OS_API_VERSION:
1038
    raise errors.InvalidOS(name, os_dir, "API version mismatch"
1039
                           " (found %s want %s)"
1040
                           % (api_version, constants.OS_API_VERSION))
1041

    
1042
  # OS Scripts dictionary, we will populate it with the actual script names
1043
  os_scripts = {'create': '', 'export': '', 'import': '', 'rename': ''}
1044

    
1045
  for script in os_scripts:
1046
    os_scripts[script] = os.path.sep.join([os_dir, script])
1047

    
1048
    try:
1049
      st = os.stat(os_scripts[script])
1050
    except EnvironmentError, err:
1051
      raise errors.InvalidOS(name, os_dir, "'%s' script missing (%s)" %
1052
                             (script, _ErrnoOrStr(err)))
1053

    
1054
    if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR:
1055
      raise errors.InvalidOS(name, os_dir, "'%s' script not executable" %
1056
                             script)
1057

    
1058
    if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
1059
      raise errors.InvalidOS(name, os_dir, "'%s' is not a regular file" %
1060
                             script)
1061

    
1062

    
1063
  return objects.OS(name=name, path=os_dir,
1064
                    create_script=os_scripts['create'],
1065
                    export_script=os_scripts['export'],
1066
                    import_script=os_scripts['import'],
1067
                    rename_script=os_scripts['rename'],
1068
                    api_version=api_version)
1069

    
1070

    
1071
def SnapshotBlockDevice(disk):
1072
  """Create a snapshot copy of a block device.
1073

1074
  This function is called recursively, and the snapshot is actually created
1075
  just for the leaf lvm backend device.
1076

1077
  Args:
1078
    disk: the disk to be snapshotted
1079

1080
  Returns:
1081
    a config entry for the actual lvm device snapshotted.
1082

1083
  """
1084
  if disk.children:
1085
    if len(disk.children) == 1:
1086
      # only one child, let's recurse on it
1087
      return SnapshotBlockDevice(disk.children[0])
1088
    else:
1089
      # more than one child, choose one that matches
1090
      for child in disk.children:
1091
        if child.size == disk.size:
1092
          # return implies breaking the loop
1093
          return SnapshotBlockDevice(child)
1094
  elif disk.dev_type == constants.LD_LV:
1095
    r_dev = _RecursiveFindBD(disk)
1096
    if r_dev is not None:
1097
      # let's stay on the safe side and ask for the full size, for now
1098
      return r_dev.Snapshot(disk.size)
1099
    else:
1100
      return None
1101
  else:
1102
    raise errors.ProgrammerError("Cannot snapshot non-lvm block device"
1103
                                 "'%s' of type '%s'" %
1104
                                 (disk.unique_id, disk.dev_type))
1105

    
1106

    
1107
def ExportSnapshot(disk, dest_node, instance):
1108
  """Export a block device snapshot to a remote node.
1109

1110
  Args:
1111
    disk: the snapshot block device
1112
    dest_node: the node to send the image to
1113
    instance: instance being exported
1114

1115
  Returns:
1116
    True if successful, False otherwise.
1117

1118
  """
1119
  inst_os = OSFromDisk(instance.os)
1120
  export_script = inst_os.export_script
1121

    
1122
  logfile = "%s/exp-%s-%s-%s.log" % (constants.LOG_OS_DIR, inst_os.name,
1123
                                     instance.name, int(time.time()))
1124
  if not os.path.exists(constants.LOG_OS_DIR):
1125
    os.mkdir(constants.LOG_OS_DIR, 0750)
1126

    
1127
  real_os_dev = _RecursiveFindBD(disk)
1128
  if real_os_dev is None:
1129
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
1130
                                  str(disk))
1131
  real_os_dev.Open()
1132

    
1133
  destdir = os.path.join(constants.EXPORT_DIR, instance.name + ".new")
1134
  destfile = disk.physical_id[1]
1135

    
1136
  # the target command is built out of three individual commands,
1137
  # which are joined by pipes; we check each individual command for
1138
  # valid parameters
1139

    
1140
  expcmd = utils.BuildShellCmd("cd %s; %s -i %s -b %s 2>%s", inst_os.path,
1141
                               export_script, instance.name,
1142
                               real_os_dev.dev_path, logfile)
1143

    
1144
  comprcmd = "gzip"
1145

    
1146
  destcmd = utils.BuildShellCmd("mkdir -p %s && cat > %s/%s",
1147
                                destdir, destdir, destfile)
1148
  remotecmd = ssh.BuildSSHCmd(dest_node, constants.GANETI_RUNAS, destcmd)
1149

    
1150

    
1151

    
1152
  # all commands have been checked, so we're safe to combine them
1153
  command = '|'.join([expcmd, comprcmd, utils.ShellQuoteArgs(remotecmd)])
1154

    
1155
  result = utils.RunCmd(command)
1156

    
1157
  if result.failed:
1158
    logger.Error("os snapshot export command '%s' returned error: %s"
1159
                 " output: %s" %
1160
                 (command, result.fail_reason, result.output))
1161
    return False
1162

    
1163
  return True
1164

    
1165

    
1166
def FinalizeExport(instance, snap_disks):
1167
  """Write out the export configuration information.
1168

1169
  Args:
1170
    instance: instance configuration
1171
    snap_disks: snapshot block devices
1172

1173
  Returns:
1174
    False in case of error, True otherwise.
1175

1176
  """
1177
  destdir = os.path.join(constants.EXPORT_DIR, instance.name + ".new")
1178
  finaldestdir = os.path.join(constants.EXPORT_DIR, instance.name)
1179

    
1180
  config = objects.SerializableConfigParser()
1181

    
1182
  config.add_section(constants.INISECT_EXP)
1183
  config.set(constants.INISECT_EXP, 'version', '0')
1184
  config.set(constants.INISECT_EXP, 'timestamp', '%d' % int(time.time()))
1185
  config.set(constants.INISECT_EXP, 'source', instance.primary_node)
1186
  config.set(constants.INISECT_EXP, 'os', instance.os)
1187
  config.set(constants.INISECT_EXP, 'compression', 'gzip')
1188

    
1189
  config.add_section(constants.INISECT_INS)
1190
  config.set(constants.INISECT_INS, 'name', instance.name)
1191
  config.set(constants.INISECT_INS, 'memory', '%d' % instance.memory)
1192
  config.set(constants.INISECT_INS, 'vcpus', '%d' % instance.vcpus)
1193
  config.set(constants.INISECT_INS, 'disk_template', instance.disk_template)
1194
  for nic_count, nic in enumerate(instance.nics):
1195
    config.set(constants.INISECT_INS, 'nic%d_mac' %
1196
               nic_count, '%s' % nic.mac)
1197
    config.set(constants.INISECT_INS, 'nic%d_ip' % nic_count, '%s' % nic.ip)
1198
  # TODO: redundant: on load can read nics until it doesn't exist
1199
  config.set(constants.INISECT_INS, 'nic_count' , '%d' % nic_count)
1200

    
1201
  for disk_count, disk in enumerate(snap_disks):
1202
    config.set(constants.INISECT_INS, 'disk%d_ivname' % disk_count,
1203
               ('%s' % disk.iv_name))
1204
    config.set(constants.INISECT_INS, 'disk%d_dump' % disk_count,
1205
               ('%s' % disk.physical_id[1]))
1206
    config.set(constants.INISECT_INS, 'disk%d_size' % disk_count,
1207
               ('%d' % disk.size))
1208
  config.set(constants.INISECT_INS, 'disk_count' , '%d' % disk_count)
1209

    
1210
  cff = os.path.join(destdir, constants.EXPORT_CONF_FILE)
1211
  cfo = open(cff, 'w')
1212
  try:
1213
    config.write(cfo)
1214
  finally:
1215
    cfo.close()
1216

    
1217
  shutil.rmtree(finaldestdir, True)
1218
  shutil.move(destdir, finaldestdir)
1219

    
1220
  return True
1221

    
1222

    
1223
def ExportInfo(dest):
1224
  """Get export configuration information.
1225

1226
  Args:
1227
    dest: directory containing the export
1228

1229
  Returns:
1230
    A serializable config file containing the export info.
1231

1232
  """
1233
  cff = os.path.join(dest, constants.EXPORT_CONF_FILE)
1234

    
1235
  config = objects.SerializableConfigParser()
1236
  config.read(cff)
1237

    
1238
  if (not config.has_section(constants.INISECT_EXP) or
1239
      not config.has_section(constants.INISECT_INS)):
1240
    return None
1241

    
1242
  return config
1243

    
1244

    
1245
def ImportOSIntoInstance(instance, os_disk, swap_disk, src_node, src_image):
1246
  """Import an os image into an instance.
1247

1248
  Args:
1249
    instance: the instance object
1250
    os_disk: the instance-visible name of the os device
1251
    swap_disk: the instance-visible name of the swap device
1252
    src_node: node holding the source image
1253
    src_image: path to the source image on src_node
1254

1255
  Returns:
1256
    False in case of error, True otherwise.
1257

1258
  """
1259
  inst_os = OSFromDisk(instance.os)
1260
  import_script = inst_os.import_script
1261

    
1262
  os_device = instance.FindDisk(os_disk)
1263
  if os_device is None:
1264
    logger.Error("Can't find this device-visible name '%s'" % os_disk)
1265
    return False
1266

    
1267
  swap_device = instance.FindDisk(swap_disk)
1268
  if swap_device is None:
1269
    logger.Error("Can't find this device-visible name '%s'" % swap_disk)
1270
    return False
1271

    
1272
  real_os_dev = _RecursiveFindBD(os_device)
1273
  if real_os_dev is None:
1274
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
1275
                                  str(os_device))
1276
  real_os_dev.Open()
1277

    
1278
  real_swap_dev = _RecursiveFindBD(swap_device)
1279
  if real_swap_dev is None:
1280
    raise errors.BlockDeviceError("Block device '%s' is not set up" %
1281
                                  str(swap_device))
1282
  real_swap_dev.Open()
1283

    
1284
  logfile = "%s/import-%s-%s-%s.log" % (constants.LOG_OS_DIR, instance.os,
1285
                                        instance.name, int(time.time()))
1286
  if not os.path.exists(constants.LOG_OS_DIR):
1287
    os.mkdir(constants.LOG_OS_DIR, 0750)
1288

    
1289
  destcmd = utils.BuildShellCmd('cat %s', src_image)
1290
  remotecmd = ssh.BuildSSHCmd(src_node, constants.GANETI_RUNAS, destcmd)
1291

    
1292
  comprcmd = "gunzip"
1293
  impcmd = utils.BuildShellCmd("(cd %s; %s -i %s -b %s -s %s &>%s)",
1294
                               inst_os.path, import_script, instance.name,
1295
                               real_os_dev.dev_path, real_swap_dev.dev_path,
1296
                               logfile)
1297

    
1298
  command = '|'.join([utils.ShellQuoteArgs(remotecmd), comprcmd, impcmd])
1299

    
1300
  result = utils.RunCmd(command)
1301

    
1302
  if result.failed:
1303
    logger.Error("os import command '%s' returned error: %s"
1304
                 " output: %s" %
1305
                 (command, result.fail_reason, result.output))
1306
    return False
1307

    
1308
  return True
1309

    
1310

    
1311
def ListExports():
1312
  """Return a list of exports currently available on this machine.
1313

1314
  """
1315
  if os.path.isdir(constants.EXPORT_DIR):
1316
    return utils.ListVisibleFiles(constants.EXPORT_DIR)
1317
  else:
1318
    return []
1319

    
1320

    
1321
def RemoveExport(export):
1322
  """Remove an existing export from the node.
1323

1324
  Args:
1325
    export: the name of the export to remove
1326

1327
  Returns:
1328
    False in case of error, True otherwise.
1329

1330
  """
1331
  target = os.path.join(constants.EXPORT_DIR, export)
1332

    
1333
  shutil.rmtree(target)
1334
  # TODO: catch some of the relevant exceptions and provide a pretty
1335
  # error message if rmtree fails.
1336

    
1337
  return True
1338

    
1339

    
1340
def RenameBlockDevices(devlist):
1341
  """Rename a list of block devices.
1342

1343
  The devlist argument is a list of tuples (disk, new_logical,
1344
  new_physical). The return value will be a combined boolean result
1345
  (True only if all renames succeeded).
1346

1347
  """
1348
  result = True
1349
  for disk, unique_id in devlist:
1350
    dev = _RecursiveFindBD(disk)
1351
    if dev is None:
1352
      result = False
1353
      continue
1354
    try:
1355
      dev.Rename(unique_id)
1356
    except errors.BlockDeviceError, err:
1357
      logger.Error("Can't rename device '%s' to '%s': %s" %
1358
                   (dev, unique_id, err))
1359
      result = False
1360
  return result
1361

    
1362

    
1363
class HooksRunner(object):
1364
  """Hook runner.
1365

1366
  This class is instantiated on the node side (ganeti-noded) and not on
1367
  the master side.
1368

1369
  """
1370
  RE_MASK = re.compile("^[a-zA-Z0-9_-]+$")
1371

    
1372
  def __init__(self, hooks_base_dir=None):
1373
    """Constructor for hooks runner.
1374

1375
    Args:
1376
      - hooks_base_dir: if not None, this overrides the
1377
        constants.HOOKS_BASE_DIR (useful for unittests)
1378
      - logs_base_dir: if not None, this overrides the
1379
        constants.LOG_HOOKS_DIR (useful for unittests)
1380
      - logging: enable or disable logging of script output
1381

1382
    """
1383
    if hooks_base_dir is None:
1384
      hooks_base_dir = constants.HOOKS_BASE_DIR
1385
    self._BASE_DIR = hooks_base_dir
1386

    
1387
  @staticmethod
1388
  def ExecHook(script, env):
1389
    """Exec one hook script.
1390

1391
    Args:
1392
     - phase: the phase
1393
     - script: the full path to the script
1394
     - env: the environment with which to exec the script
1395

1396
    """
1397
    # exec the process using subprocess and log the output
1398
    fdstdin = None
1399
    try:
1400
      fdstdin = open("/dev/null", "r")
1401
      child = subprocess.Popen([script], stdin=fdstdin, stdout=subprocess.PIPE,
1402
                               stderr=subprocess.STDOUT, close_fds=True,
1403
                               shell=False, cwd="/",env=env)
1404
      output = ""
1405
      try:
1406
        output = child.stdout.read(4096)
1407
        child.stdout.close()
1408
      except EnvironmentError, err:
1409
        output += "Hook script error: %s" % str(err)
1410

    
1411
      while True:
1412
        try:
1413
          result = child.wait()
1414
          break
1415
        except EnvironmentError, err:
1416
          if err.errno == errno.EINTR:
1417
            continue
1418
          raise
1419
    finally:
1420
      # try not to leak fds
1421
      for fd in (fdstdin, ):
1422
        if fd is not None:
1423
          try:
1424
            fd.close()
1425
          except EnvironmentError, err:
1426
            # just log the error
1427
            #logger.Error("While closing fd %s: %s" % (fd, err))
1428
            pass
1429

    
1430
    return result == 0, output
1431

    
1432
  def RunHooks(self, hpath, phase, env):
1433
    """Run the scripts in the hooks directory.
1434

1435
    This method will not be usually overriden by child opcodes.
1436

1437
    """
1438
    if phase == constants.HOOKS_PHASE_PRE:
1439
      suffix = "pre"
1440
    elif phase == constants.HOOKS_PHASE_POST:
1441
      suffix = "post"
1442
    else:
1443
      raise errors.ProgrammerError("Unknown hooks phase: '%s'" % phase)
1444
    rr = []
1445

    
1446
    subdir = "%s-%s.d" % (hpath, suffix)
1447
    dir_name = "%s/%s" % (self._BASE_DIR, subdir)
1448
    try:
1449
      dir_contents = utils.ListVisibleFiles(dir_name)
1450
    except OSError, err:
1451
      # must log
1452
      return rr
1453

    
1454
    # we use the standard python sort order,
1455
    # so 00name is the recommended naming scheme
1456
    dir_contents.sort()
1457
    for relname in dir_contents:
1458
      fname = os.path.join(dir_name, relname)
1459
      if not (os.path.isfile(fname) and os.access(fname, os.X_OK) and
1460
          self.RE_MASK.match(relname) is not None):
1461
        rrval = constants.HKR_SKIP
1462
        output = ""
1463
      else:
1464
        result, output = self.ExecHook(fname, env)
1465
        if not result:
1466
          rrval = constants.HKR_FAIL
1467
        else:
1468
          rrval = constants.HKR_SUCCESS
1469
      rr.append(("%s/%s" % (subdir, relname), rrval, output))
1470

    
1471
    return rr