Revision 1b68f268

b/lib/cmdlib.py
1551 1551
  @param nic: nic to convert to hooks tuple
1552 1552

  
1553 1553
  """
1554
  ip = nic.ip
1555
  mac = nic.mac
1556 1554
  cluster = lu.cfg.GetClusterInfo()
1557 1555
  filled_params = cluster.SimpleFillNIC(nic.nicparams)
1558 1556
  mode = filled_params[constants.NIC_MODE]
1559 1557
  link = filled_params[constants.NIC_LINK]
1560
  net = nic.network
1561 1558
  netinfo = None
1562
  if net:
1563
    net_uuid = lu.cfg.LookupNetwork(net)
1564
    if net_uuid:
1565
      nobj = lu.cfg.GetNetwork(net_uuid)
1566
      netinfo = objects.Network.ToDict(nobj)
1567
  return (ip, mac, mode, link, net, netinfo)
1559
  if nic.network:
1560
    net_uuid = lu.cfg.LookupNetwork(nic.network)
1561
    netinfo = objects.Network.ToDict(lu.cfg.GetNetwork(net_uuid))
1562

  
1563
  return (nic.ip, nic.mac, mode, link, nic.network, netinfo)
1568 1564

  
1569 1565

  
1570 1566
def _NICListToTuple(lu, nics):
......
13452 13448
    elif new_net != old_net:
13453 13449

  
13454 13450
      def get_net_prefix(net):
13451
        mac_prefix = None
13455 13452
        if net:
13456 13453
          uuid = self.cfg.LookupNetwork(net)
13457
          if uuid:
13458
            nobj = self.cfg.GetNetwork(uuid)
13459
            return nobj.mac_prefix
13460
        return None
13454
          mac_prefix = self.cfg.GetNetwork(uuid).mac_prefix
13455

  
13456
        return mac_prefix
13461 13457

  
13462 13458
      new_prefix = get_net_prefix(new_net)
13463 13459
      old_prefix = get_net_prefix(old_net)
......
16206 16202
      raise errors.OpPrereqError("Network must be given",
16207 16203
                                 errors.ECODE_INVAL)
16208 16204

  
16209
    uuid = self.cfg.LookupNetwork(self.op.network_name)
16210

  
16211
    if uuid:
16212
      raise errors.OpPrereqError(("Network with name '%s' already exists" %
16213
                                  self.op.network_name), errors.ECODE_EXISTS)
16205
    try:
16206
      existing_uuid = self.cfg.LookupNetwork(self.op.network_name)
16207
    except errors.OpPrereqError:
16208
      pass
16209
    else:
16210
      raise errors.OpPrereqError("Desired network name '%s' already exists as a"
16211
                                 " network (UUID: %s)" %
16212
                                 (self.op.network_name, existing_uuid),
16213
                                 errors.ECODE_EXISTS)
16214 16214

  
16215 16215
    # Check tag validity
16216 16216
    for tag in self.op.tags:
......
16297 16297
  def ExpandNames(self):
16298 16298
    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)
16299 16299

  
16300
    if not self.network_uuid:
16301
      raise errors.OpPrereqError(("Network '%s' not found" %
16302
                                  self.op.network_name), errors.ECODE_NOENT)
16303

  
16304 16300
    self.share_locks[locking.LEVEL_NODEGROUP] = 1
16305 16301
    self.needed_locks = {
16306 16302
      locking.LEVEL_NETWORK: [self.network_uuid],
......
16369 16365

  
16370 16366
  def ExpandNames(self):
16371 16367
    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)
16372
    if self.network_uuid is None:
16373
      raise errors.OpPrereqError(("Network '%s' not found" %
16374
                                  self.op.network_name), errors.ECODE_NOENT)
16375 16368

  
16376 16369
    self.needed_locks = {
16377 16370
      locking.LEVEL_NETWORK: [self.network_uuid],
......
16633 16626
    self.network_link = self.op.network_link
16634 16627

  
16635 16628
    self.network_uuid = self.cfg.LookupNetwork(self.network_name)
16636
    if self.network_uuid is None:
16637
      raise errors.OpPrereqError("Network '%s' does not exist" %
16638
                                 self.network_name, errors.ECODE_NOENT)
16639

  
16640 16629
    self.group_uuid = self.cfg.LookupNodeGroup(self.group_name)
16641
    if self.group_uuid is None:
16642
      raise errors.OpPrereqError("Group '%s' does not exist" %
16643
                                 self.group_name, errors.ECODE_NOENT)
16644 16630

  
16645 16631
    self.needed_locks = {
16646 16632
      locking.LEVEL_INSTANCE: [],
......
16769 16755
    self.group_name = self.op.group_name
16770 16756

  
16771 16757
    self.network_uuid = self.cfg.LookupNetwork(self.network_name)
16772
    if self.network_uuid is None:
16773
      raise errors.OpPrereqError("Network '%s' does not exist" %
16774
                                 self.network_name, errors.ECODE_NOENT)
16775

  
16776 16758
    self.group_uuid = self.cfg.LookupNodeGroup(self.group_name)
16777
    if self.group_uuid is None:
16778
      raise errors.OpPrereqError("Group '%s' does not exist" %
16779
                                 self.group_name, errors.ECODE_NOENT)
16780 16759

  
16781 16760
    self.needed_locks = {
16782 16761
      locking.LEVEL_INSTANCE: [],
b/lib/config.py
277 277
    prefix = None
278 278
    if net:
279 279
      net_uuid = self._UnlockedLookupNetwork(net)
280
      if net_uuid:
281
        nobj = self._UnlockedGetNetwork(net_uuid)
282
        if nobj.mac_prefix:
283
          prefix = nobj.mac_prefix
280
      nobj = self._UnlockedGetNetwork(net_uuid)
281
      if nobj.mac_prefix:
282
        prefix = nobj.mac_prefix
284 283

  
285 284
    return prefix
286 285

  
......
366 365

  
367 366
    """
368 367
    net_uuid = self._UnlockedLookupNetwork(net)
369
    if net_uuid:
370
      self._UnlockedReleaseIp(net_uuid, address, ec_id)
368
    self._UnlockedReleaseIp(net_uuid, address, ec_id)
371 369

  
372 370
  @locking.ssynchronized(_config_lock, shared=1)
373 371
  def GenerateIp(self, net, ec_id):
......
411 409

  
412 410
    """
413 411
    net_uuid = self._UnlockedLookupNetwork(net)
414
    if net_uuid:
415
      return self._UnlockedReserveIp(net_uuid, address, ec_id)
412
    return self._UnlockedReserveIp(net_uuid, address, ec_id)
416 413

  
417 414
  @locking.ssynchronized(_config_lock, shared=1)
418 415
  def ReserveLV(self, lv_name, ec_id):
......
1457 1454
    for nic in instance.nics:
1458 1455
      if nic.network is not None and nic.ip is not None:
1459 1456
        net_uuid = self._UnlockedLookupNetwork(nic.network)
1460
        if net_uuid:
1461
          # Return all IP addresses to the respective address pools
1462
          self._UnlockedCommitIp(constants.RELEASE_ACTION, net_uuid, nic.ip)
1457
        # Return all IP addresses to the respective address pools
1458
        self._UnlockedCommitIp(constants.RELEASE_ACTION, net_uuid, nic.ip)
1463 1459

  
1464 1460
    del self._config_data.instances[instance_name]
1465 1461
    self._config_data.cluster.serial_no += 1
......
2477 2473
    if check_uuid:
2478 2474
      self._EnsureUUID(net, ec_id)
2479 2475

  
2480
    existing_uuid = self._UnlockedLookupNetwork(net.name)
2481
    if existing_uuid:
2482
      raise errors.OpPrereqError("Desired network name '%s' already"
2483
                                 " exists as a network (UUID: %s)" %
2484
                                 (net.name, existing_uuid),
2485
                                 errors.ECODE_EXISTS)
2486 2476
    net.serial_no = 1
2487 2477
    self._config_data.networks[net.uuid] = net
2488 2478
    self._config_data.cluster.serial_no += 1
......
2502 2492
    for net in self._config_data.networks.values():
2503 2493
      if net.name == target:
2504 2494
        return net.uuid
2505
    return None
2495
    raise errors.OpPrereqError("Network '%s' not found" % target,
2496
                               errors.ECODE_NOENT)
2506 2497

  
2507 2498
  @locking.ssynchronized(_config_lock, shared=1)
2508 2499
  def LookupNetwork(self, target):
......
2549 2540

  
2550 2541
    """
2551 2542
    net_uuid = self._UnlockedLookupNetwork(net)
2552
    if net_uuid is None:
2553
      return None
2554

  
2555 2543
    node_info = self._UnlockedGetNodeInfo(node)
2556 2544
    nodegroup_info = self._UnlockedGetNodeGroup(node_info.group)
2557 2545
    netparams = nodegroup_info.networks.get(net_uuid, None)

Also available in: Unified diff