Revision 850c53f1

b/lib/cmdlib/cluster.py
2666 2666
      node_verify_param[constants.NV_DRBDLIST] = None
2667 2667
      node_verify_param[constants.NV_DRBDHELPER] = drbd_helper
2668 2668

  
2669
    if constants.ENABLE_FILE_STORAGE or constants.ENABLE_SHARED_FILE_STORAGE:
2669
    if cluster.IsFileStorageEnabled() or \
2670
        cluster.IsSharedFileStorageEnabled():
2670 2671
      # Load file storage paths only from master node
2671 2672
      node_verify_param[constants.NV_FILE_STORAGE_PATHS] = \
2672 2673
        self.cfg.GetMasterNodeName()
b/lib/cmdlib/common.py
270 270
    files_mc.add(pathutils.CLUSTER_CONF_FILE)
271 271

  
272 272
  # File storage
273
  if (not redist and (constants.ENABLE_FILE_STORAGE or
274
                        constants.ENABLE_SHARED_FILE_STORAGE)):
273
  if (not redist and (cluster.IsFileStorageEnabled() or
274
                        cluster.IsSharedFileStorageEnabled())):
275 275
    files_all.add(pathutils.FILE_STORAGE_PATHS_FILE)
276 276
    files_opt.add(pathutils.FILE_STORAGE_PATHS_FILE)
277 277

  
b/lib/cmdlib/instance.py
420 420
      raise errors.OpPrereqError("Invalid file driver name '%s'" %
421 421
                                 self.op.file_driver, errors.ECODE_INVAL)
422 422

  
423
    if self.op.disk_template == constants.DT_FILE:
424
      opcodes.RequireFileStorage()
425
    elif self.op.disk_template == constants.DT_SHARED_FILE:
426
      opcodes.RequireSharedFileStorage()
427

  
428 423
    ### Node/iallocator related checks
429 424
    CheckIAllocatorOrNode(self, "iallocator", "pnode")
430 425

  
b/lib/cmdlib/instance_storage.py
413 413
def GenerateDiskTemplate(
414 414
  lu, template_name, instance_uuid, primary_node_uuid, secondary_node_uuids,
415 415
  disk_info, file_storage_dir, file_driver, base_index,
416
  feedback_fn, full_disk_params, _req_file_storage=opcodes.RequireFileStorage,
417
  _req_shr_file_storage=opcodes.RequireSharedFileStorage):
416
  feedback_fn, full_disk_params):
418 417
  """Generate the entire disk layout for a given template type.
419 418

  
420 419
  """
......
422 421
  disk_count = len(disk_info)
423 422
  disks = []
424 423

  
424
  CheckDiskTemplateEnabled(lu.cfg.GetClusterInfo(), template_name)
425

  
425 426
  if template_name == constants.DT_DISKLESS:
426 427
    pass
427 428
  elif template_name == constants.DT_DRBD8:
......
457 458
    if secondary_node_uuids:
458 459
      raise errors.ProgrammerError("Wrong template configuration")
459 460

  
460
    if template_name == constants.DT_FILE:
461
      _req_file_storage()
462
    elif template_name == constants.DT_SHARED_FILE:
463
      _req_shr_file_storage()
464

  
465 461
    name_prefix = _DISK_TEMPLATE_NAME_PREFIX.get(template_name, None)
466 462
    if name_prefix is None:
467 463
      names = None
b/test/py/ganeti.cmdlib_unittest.py
1166 1166

  
1167 1167

  
1168 1168
class _FakeConfigForGenDiskTemplate:
1169
  def __init__(self):
1169
  def __init__(self, enabled_disk_templates):
1170 1170
    self._unique_id = itertools.count()
1171 1171
    self._drbd_minor = itertools.count(20)
1172 1172
    self._port = itertools.count(constants.FIRST_DRBD_PORT)
1173 1173
    self._secret = itertools.count()
1174
    self._enabled_disk_templates = enabled_disk_templates
1174 1175

  
1175 1176
  def GetVGName(self):
1176 1177
    return "testvg"
......
1191 1192
  def GetInstanceInfo(self, _):
1192 1193
    return "foobar"
1193 1194

  
1195
  def GetClusterInfo(self):
1196
    cluster = objects.Cluster()
1197
    cluster.enabled_disk_templates = self._enabled_disk_templates
1198
    return cluster
1199

  
1194 1200

  
1195 1201
class _FakeProcForGenDiskTemplate:
1196 1202
  def GetECId(self):
......
1198 1204

  
1199 1205

  
1200 1206
class TestGenerateDiskTemplate(unittest.TestCase):
1201
  def setUp(self):
1202
    nodegroup = objects.NodeGroup(name="ng")
1203
    nodegroup.UpgradeConfig()
1204 1207

  
1205
    cfg = _FakeConfigForGenDiskTemplate()
1208
  def _SetUpLUWithTemplates(self, enabled_disk_templates):
1209
    self._enabled_disk_templates = enabled_disk_templates
1210
    cfg = _FakeConfigForGenDiskTemplate(self._enabled_disk_templates)
1206 1211
    proc = _FakeProcForGenDiskTemplate()
1207 1212

  
1208 1213
    self.lu = _FakeLU(cfg=cfg, proc=proc)
1214

  
1215
  def setUp(self):
1216
    nodegroup = objects.NodeGroup(name="ng")
1217
    nodegroup.UpgradeConfig()
1218

  
1219
    self._enabled_disk_templates = list(constants.DISK_TEMPLATES)
1220
    self._SetUpLUWithTemplates(self._enabled_disk_templates)
1209 1221
    self.nodegroup = nodegroup
1210 1222

  
1211 1223
  @staticmethod
......
1218 1230

  
1219 1231
    assert disk_template not in constants.DISK_TEMPLATES
1220 1232

  
1221
    self.assertRaises(errors.ProgrammerError, gdt, self.lu, disk_template,
1233
    self.assertRaises(errors.OpPrereqError, gdt, self.lu, disk_template,
1222 1234
                      "inst26831.example.com", "node30113.example.com", [], [],
1223 1235
                      NotImplemented, NotImplemented, 0, self.lu.LogInfo,
1224 1236
                      self.GetDiskParams())
......
1234 1246

  
1235 1247
  def _TestTrivialDisk(self, template, disk_info, base_index, exp_dev_type,
1236 1248
                       file_storage_dir=NotImplemented,
1237
                       file_driver=NotImplemented,
1238
                       req_file_storage=NotImplemented,
1239
                       req_shr_file_storage=NotImplemented):
1249
                       file_driver=NotImplemented):
1240 1250
    gdt = instance.GenerateDiskTemplate
1241 1251

  
1242 1252
    map(lambda params: utils.ForceDictType(params,
......
1248 1258
                      template, "inst25088.example.com",
1249 1259
                      "node185.example.com", ["node323.example.com"], [],
1250 1260
                      NotImplemented, NotImplemented, base_index,
1251
                      self.lu.LogInfo, self.GetDiskParams(),
1252
                      _req_file_storage=req_file_storage,
1253
                      _req_shr_file_storage=req_shr_file_storage)
1261
                      self.lu.LogInfo, self.GetDiskParams())
1254 1262

  
1255 1263
    result = gdt(self.lu, template, "inst21662.example.com",
1256 1264
                 "node21741.example.com", [],
1257 1265
                 disk_info, file_storage_dir, file_driver, base_index,
1258
                 self.lu.LogInfo, self.GetDiskParams(),
1259
                 _req_file_storage=req_file_storage,
1260
                 _req_shr_file_storage=req_shr_file_storage)
1266
                 self.lu.LogInfo, self.GetDiskParams())
1261 1267

  
1262 1268
    for (idx, disk) in enumerate(result):
1263 1269
      self.assertTrue(isinstance(disk, objects.Disk))
......
1294 1300
      ("othervg", "ec0-uq1.disk4"),
1295 1301
      ])
1296 1302

  
1297
  @staticmethod
1298
  def _AllowFileStorage():
1299
    pass
1300

  
1301
  @staticmethod
1302
  def _ForbidFileStorage():
1303
    raise errors.OpPrereqError("Disallowed in test")
1304

  
1305 1303
  def testFile(self):
1304
    # anything != DT_FILE would do here
1305
    self._SetUpLUWithTemplates([constants.DT_PLAIN])
1306 1306
    self.assertRaises(errors.OpPrereqError, self._TestTrivialDisk,
1307
                      constants.DT_FILE, [], 0, NotImplemented,
1308
                      req_file_storage=self._ForbidFileStorage)
1307
                      constants.DT_FILE, [], 0, NotImplemented)
1309 1308
    self.assertRaises(errors.OpPrereqError, self._TestTrivialDisk,
1310
                      constants.DT_SHARED_FILE, [], 0, NotImplemented,
1311
                      req_shr_file_storage=self._ForbidFileStorage)
1309
                      constants.DT_SHARED_FILE, [], 0, NotImplemented)
1312 1310

  
1313 1311
    for disk_template in [constants.DT_FILE, constants.DT_SHARED_FILE]:
1314 1312
      disk_info = [{
......
1322 1320
        constants.IDISK_MODE: constants.DISK_RDWR,
1323 1321
        }]
1324 1322

  
1323
      self._SetUpLUWithTemplates([disk_template])
1325 1324
      result = self._TestTrivialDisk(disk_template, disk_info, 2,
1326 1325
        constants.LD_FILE, file_storage_dir="/tmp",
1327
        file_driver=constants.FD_BLKTAP,
1328
        req_file_storage=self._AllowFileStorage,
1329
        req_shr_file_storage=self._AllowFileStorage)
1326
        file_driver=constants.FD_BLKTAP)
1330 1327

  
1331 1328
      self.assertEqual(map(operator.attrgetter("logical_id"), result), [
1332 1329
        (constants.FD_BLKTAP, "/tmp/disk2"),

Also available in: Unified diff