Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib / network.py @ 8701dfb0

History | View | Annotate | Download (22.3 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
"""Logical units dealing with networks."""
23

    
24
from ganeti import constants
25
from ganeti import errors
26
from ganeti import locking
27
from ganeti import network
28
from ganeti import objects
29
from ganeti import qlang
30
from ganeti import query
31
from ganeti import utils
32
from ganeti.cmdlib.base import LogicalUnit, NoHooksLU, _QueryBase
33
from ganeti.cmdlib.common import _ShareAll, _CheckNodeGroupInstances
34

    
35

    
36
def _BuildNetworkHookEnv(name, subnet, gateway, network6, gateway6,
37
                         mac_prefix, tags):
38
  """Builds network related env variables for hooks
39

40
  This builds the hook environment from individual variables.
41

42
  @type name: string
43
  @param name: the name of the network
44
  @type subnet: string
45
  @param subnet: the ipv4 subnet
46
  @type gateway: string
47
  @param gateway: the ipv4 gateway
48
  @type network6: string
49
  @param network6: the ipv6 subnet
50
  @type gateway6: string
51
  @param gateway6: the ipv6 gateway
52
  @type mac_prefix: string
53
  @param mac_prefix: the mac_prefix
54
  @type tags: list
55
  @param tags: the tags of the network
56

57
  """
58
  env = {}
59
  if name:
60
    env["NETWORK_NAME"] = name
61
  if subnet:
62
    env["NETWORK_SUBNET"] = subnet
63
  if gateway:
64
    env["NETWORK_GATEWAY"] = gateway
65
  if network6:
66
    env["NETWORK_SUBNET6"] = network6
67
  if gateway6:
68
    env["NETWORK_GATEWAY6"] = gateway6
69
  if mac_prefix:
70
    env["NETWORK_MAC_PREFIX"] = mac_prefix
71
  if tags:
72
    env["NETWORK_TAGS"] = " ".join(tags)
73

    
74
  return env
75

    
76

    
77
class LUNetworkAdd(LogicalUnit):
78
  """Logical unit for creating networks.
79

80
  """
81
  HPATH = "network-add"
82
  HTYPE = constants.HTYPE_NETWORK
83
  REQ_BGL = False
84

    
85
  def BuildHooksNodes(self):
86
    """Build hooks nodes.
87

88
    """
89
    mn = self.cfg.GetMasterNode()
90
    return ([mn], [mn])
91

    
92
  def CheckArguments(self):
93
    if self.op.mac_prefix:
94
      self.op.mac_prefix = \
95
        utils.NormalizeAndValidateThreeOctetMacPrefix(self.op.mac_prefix)
96

    
97
  def ExpandNames(self):
98
    self.network_uuid = self.cfg.GenerateUniqueID(self.proc.GetECId())
99

    
100
    if self.op.conflicts_check:
101
      self.share_locks[locking.LEVEL_NODE] = 1
102
      self.share_locks[locking.LEVEL_NODE_ALLOC] = 1
103
      self.needed_locks = {
104
        locking.LEVEL_NODE: locking.ALL_SET,
105
        locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
106
        }
107
    else:
108
      self.needed_locks = {}
109

    
110
    self.add_locks[locking.LEVEL_NETWORK] = self.network_uuid
111

    
112
  def CheckPrereq(self):
113
    if self.op.network is None:
114
      raise errors.OpPrereqError("Network must be given",
115
                                 errors.ECODE_INVAL)
116

    
117
    try:
118
      existing_uuid = self.cfg.LookupNetwork(self.op.network_name)
119
    except errors.OpPrereqError:
120
      pass
121
    else:
122
      raise errors.OpPrereqError("Desired network name '%s' already exists as a"
123
                                 " network (UUID: %s)" %
124
                                 (self.op.network_name, existing_uuid),
125
                                 errors.ECODE_EXISTS)
126

    
127
    # Check tag validity
128
    for tag in self.op.tags:
129
      objects.TaggableObject.ValidateTag(tag)
130

    
131
  def BuildHooksEnv(self):
132
    """Build hooks env.
133

134
    """
135
    args = {
136
      "name": self.op.network_name,
137
      "subnet": self.op.network,
138
      "gateway": self.op.gateway,
139
      "network6": self.op.network6,
140
      "gateway6": self.op.gateway6,
141
      "mac_prefix": self.op.mac_prefix,
142
      "tags": self.op.tags,
143
      }
144
    return _BuildNetworkHookEnv(**args) # pylint: disable=W0142
145

    
146
  def Exec(self, feedback_fn):
147
    """Add the ip pool to the cluster.
148

149
    """
150
    nobj = objects.Network(name=self.op.network_name,
151
                           network=self.op.network,
152
                           gateway=self.op.gateway,
153
                           network6=self.op.network6,
154
                           gateway6=self.op.gateway6,
155
                           mac_prefix=self.op.mac_prefix,
156
                           uuid=self.network_uuid)
157
    # Initialize the associated address pool
158
    try:
159
      pool = network.AddressPool.InitializeNetwork(nobj)
160
    except errors.AddressPoolError, err:
161
      raise errors.OpExecError("Cannot create IP address pool for network"
162
                               " '%s': %s" % (self.op.network_name, err))
163

    
164
    # Check if we need to reserve the nodes and the cluster master IP
165
    # These may not be allocated to any instances in routed mode, as
166
    # they wouldn't function anyway.
167
    if self.op.conflicts_check:
168
      for node in self.cfg.GetAllNodesInfo().values():
169
        for ip in [node.primary_ip, node.secondary_ip]:
170
          try:
171
            if pool.Contains(ip):
172
              pool.Reserve(ip)
173
              self.LogInfo("Reserved IP address of node '%s' (%s)",
174
                           node.name, ip)
175
          except errors.AddressPoolError, err:
176
            self.LogWarning("Cannot reserve IP address '%s' of node '%s': %s",
177
                            ip, node.name, err)
178

    
179
      master_ip = self.cfg.GetClusterInfo().master_ip
180
      try:
181
        if pool.Contains(master_ip):
182
          pool.Reserve(master_ip)
183
          self.LogInfo("Reserved cluster master IP address (%s)", master_ip)
184
      except errors.AddressPoolError, err:
185
        self.LogWarning("Cannot reserve cluster master IP address (%s): %s",
186
                        master_ip, err)
187

    
188
    if self.op.add_reserved_ips:
189
      for ip in self.op.add_reserved_ips:
190
        try:
191
          pool.Reserve(ip, external=True)
192
        except errors.AddressPoolError, err:
193
          raise errors.OpExecError("Cannot reserve IP address '%s': %s" %
194
                                   (ip, err))
195

    
196
    if self.op.tags:
197
      for tag in self.op.tags:
198
        nobj.AddTag(tag)
199

    
200
    self.cfg.AddNetwork(nobj, self.proc.GetECId(), check_uuid=False)
201
    del self.remove_locks[locking.LEVEL_NETWORK]
202

    
203

    
204
class LUNetworkRemove(LogicalUnit):
205
  HPATH = "network-remove"
206
  HTYPE = constants.HTYPE_NETWORK
207
  REQ_BGL = False
208

    
209
  def ExpandNames(self):
210
    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)
211

    
212
    self.share_locks[locking.LEVEL_NODEGROUP] = 1
213
    self.needed_locks = {
214
      locking.LEVEL_NETWORK: [self.network_uuid],
215
      locking.LEVEL_NODEGROUP: locking.ALL_SET,
216
      }
217

    
218
  def CheckPrereq(self):
219
    """Check prerequisites.
220

221
    This checks that the given network name exists as a network, that is
222
    empty (i.e., contains no nodes), and that is not the last group of the
223
    cluster.
224

225
    """
226
    # Verify that the network is not conncted.
227
    node_groups = [group.name
228
                   for group in self.cfg.GetAllNodeGroupsInfo().values()
229
                   if self.network_uuid in group.networks]
230

    
231
    if node_groups:
232
      self.LogWarning("Network '%s' is connected to the following"
233
                      " node groups: %s" %
234
                      (self.op.network_name,
235
                       utils.CommaJoin(utils.NiceSort(node_groups))))
236
      raise errors.OpPrereqError("Network still connected", errors.ECODE_STATE)
237

    
238
  def BuildHooksEnv(self):
239
    """Build hooks env.
240

241
    """
242
    return {
243
      "NETWORK_NAME": self.op.network_name,
244
      }
245

    
246
  def BuildHooksNodes(self):
247
    """Build hooks nodes.
248

249
    """
250
    mn = self.cfg.GetMasterNode()
251
    return ([mn], [mn])
252

    
253
  def Exec(self, feedback_fn):
254
    """Remove the network.
255

256
    """
257
    try:
258
      self.cfg.RemoveNetwork(self.network_uuid)
259
    except errors.ConfigurationError:
260
      raise errors.OpExecError("Network '%s' with UUID %s disappeared" %
261
                               (self.op.network_name, self.network_uuid))
262

    
263

    
264
class LUNetworkSetParams(LogicalUnit):
265
  """Modifies the parameters of a network.
266

267
  """
268
  HPATH = "network-modify"
269
  HTYPE = constants.HTYPE_NETWORK
270
  REQ_BGL = False
271

    
272
  def CheckArguments(self):
273
    if (self.op.gateway and
274
        (self.op.add_reserved_ips or self.op.remove_reserved_ips)):
275
      raise errors.OpPrereqError("Cannot modify gateway and reserved ips"
276
                                 " at once", errors.ECODE_INVAL)
277

    
278
  def ExpandNames(self):
279
    self.network_uuid = self.cfg.LookupNetwork(self.op.network_name)
280

    
281
    self.needed_locks = {
282
      locking.LEVEL_NETWORK: [self.network_uuid],
283
      }
284

    
285
  def CheckPrereq(self):
286
    """Check prerequisites.
287

288
    """
289
    self.network = self.cfg.GetNetwork(self.network_uuid)
290
    self.gateway = self.network.gateway
291
    self.mac_prefix = self.network.mac_prefix
292
    self.network6 = self.network.network6
293
    self.gateway6 = self.network.gateway6
294
    self.tags = self.network.tags
295

    
296
    self.pool = network.AddressPool(self.network)
297

    
298
    if self.op.gateway:
299
      if self.op.gateway == constants.VALUE_NONE:
300
        self.gateway = None
301
      else:
302
        self.gateway = self.op.gateway
303
        if self.pool.IsReserved(self.gateway):
304
          raise errors.OpPrereqError("Gateway IP address '%s' is already"
305
                                     " reserved" % self.gateway,
306
                                     errors.ECODE_STATE)
307

    
308
    if self.op.mac_prefix:
309
      if self.op.mac_prefix == constants.VALUE_NONE:
310
        self.mac_prefix = None
311
      else:
312
        self.mac_prefix = \
313
          utils.NormalizeAndValidateThreeOctetMacPrefix(self.op.mac_prefix)
314

    
315
    if self.op.gateway6:
316
      if self.op.gateway6 == constants.VALUE_NONE:
317
        self.gateway6 = None
318
      else:
319
        self.gateway6 = self.op.gateway6
320

    
321
    if self.op.network6:
322
      if self.op.network6 == constants.VALUE_NONE:
323
        self.network6 = None
324
      else:
325
        self.network6 = self.op.network6
326

    
327
  def BuildHooksEnv(self):
328
    """Build hooks env.
329

330
    """
331
    args = {
332
      "name": self.op.network_name,
333
      "subnet": self.network.network,
334
      "gateway": self.gateway,
335
      "network6": self.network6,
336
      "gateway6": self.gateway6,
337
      "mac_prefix": self.mac_prefix,
338
      "tags": self.tags,
339
      }
340
    return _BuildNetworkHookEnv(**args) # pylint: disable=W0142
341

    
342
  def BuildHooksNodes(self):
343
    """Build hooks nodes.
344

345
    """
346
    mn = self.cfg.GetMasterNode()
347
    return ([mn], [mn])
348

    
349
  def Exec(self, feedback_fn):
350
    """Modifies the network.
351

352
    """
353
    #TODO: reserve/release via temporary reservation manager
354
    #      extend cfg.ReserveIp/ReleaseIp with the external flag
355
    if self.op.gateway:
356
      if self.gateway == self.network.gateway:
357
        self.LogWarning("Gateway is already %s", self.gateway)
358
      else:
359
        if self.gateway:
360
          self.pool.Reserve(self.gateway, external=True)
361
        if self.network.gateway:
362
          self.pool.Release(self.network.gateway, external=True)
363
        self.network.gateway = self.gateway
364

    
365
    if self.op.add_reserved_ips:
366
      for ip in self.op.add_reserved_ips:
367
        try:
368
          if self.pool.IsReserved(ip):
369
            self.LogWarning("IP address %s is already reserved", ip)
370
          else:
371
            self.pool.Reserve(ip, external=True)
372
        except errors.AddressPoolError, err:
373
          self.LogWarning("Cannot reserve IP address %s: %s", ip, err)
374

    
375
    if self.op.remove_reserved_ips:
376
      for ip in self.op.remove_reserved_ips:
377
        if ip == self.network.gateway:
378
          self.LogWarning("Cannot unreserve Gateway's IP")
379
          continue
380
        try:
381
          if not self.pool.IsReserved(ip):
382
            self.LogWarning("IP address %s is already unreserved", ip)
383
          else:
384
            self.pool.Release(ip, external=True)
385
        except errors.AddressPoolError, err:
386
          self.LogWarning("Cannot release IP address %s: %s", ip, err)
387

    
388
    if self.op.mac_prefix:
389
      self.network.mac_prefix = self.mac_prefix
390

    
391
    if self.op.network6:
392
      self.network.network6 = self.network6
393

    
394
    if self.op.gateway6:
395
      self.network.gateway6 = self.gateway6
396

    
397
    self.pool.Validate()
398

    
399
    self.cfg.Update(self.network, feedback_fn)
400

    
401

    
402
class _NetworkQuery(_QueryBase):
403
  FIELDS = query.NETWORK_FIELDS
404

    
405
  def ExpandNames(self, lu):
406
    lu.needed_locks = {}
407
    lu.share_locks = _ShareAll()
408

    
409
    self.do_locking = self.use_locking
410

    
411
    all_networks = lu.cfg.GetAllNetworksInfo()
412
    name_to_uuid = dict((n.name, n.uuid) for n in all_networks.values())
413

    
414
    if self.names:
415
      missing = []
416
      self.wanted = []
417

    
418
      for name in self.names:
419
        if name in name_to_uuid:
420
          self.wanted.append(name_to_uuid[name])
421
        else:
422
          missing.append(name)
423

    
424
      if missing:
425
        raise errors.OpPrereqError("Some networks do not exist: %s" % missing,
426
                                   errors.ECODE_NOENT)
427
    else:
428
      self.wanted = locking.ALL_SET
429

    
430
    if self.do_locking:
431
      lu.needed_locks[locking.LEVEL_NETWORK] = self.wanted
432
      if query.NETQ_INST in self.requested_data:
433
        lu.needed_locks[locking.LEVEL_INSTANCE] = locking.ALL_SET
434
      if query.NETQ_GROUP in self.requested_data:
435
        lu.needed_locks[locking.LEVEL_NODEGROUP] = locking.ALL_SET
436

    
437
  def DeclareLocks(self, lu, level):
438
    pass
439

    
440
  def _GetQueryData(self, lu):
441
    """Computes the list of networks and their attributes.
442

443
    """
444
    all_networks = lu.cfg.GetAllNetworksInfo()
445

    
446
    network_uuids = self._GetNames(lu, all_networks.keys(),
447
                                   locking.LEVEL_NETWORK)
448

    
449
    do_instances = query.NETQ_INST in self.requested_data
450
    do_groups = query.NETQ_GROUP in self.requested_data
451

    
452
    network_to_instances = None
453
    network_to_groups = None
454

    
455
    # For NETQ_GROUP, we need to map network->[groups]
456
    if do_groups:
457
      all_groups = lu.cfg.GetAllNodeGroupsInfo()
458
      network_to_groups = dict((uuid, []) for uuid in network_uuids)
459
      for _, group in all_groups.iteritems():
460
        for net_uuid in network_uuids:
461
          netparams = group.networks.get(net_uuid, None)
462
          if netparams:
463
            info = (group.name, netparams[constants.NIC_MODE],
464
                    netparams[constants.NIC_LINK])
465

    
466
            network_to_groups[net_uuid].append(info)
467

    
468
    if do_instances:
469
      all_instances = lu.cfg.GetAllInstancesInfo()
470
      network_to_instances = dict((uuid, []) for uuid in network_uuids)
471
      for instance in all_instances.values():
472
        for nic in instance.nics:
473
          if nic.network in network_uuids:
474
            network_to_instances[nic.network].append(instance.name)
475
            break
476

    
477
    if query.NETQ_STATS in self.requested_data:
478
      stats = \
479
        dict((uuid,
480
              self._GetStats(network.AddressPool(all_networks[uuid])))
481
             for uuid in network_uuids)
482
    else:
483
      stats = None
484

    
485
    return query.NetworkQueryData([all_networks[uuid]
486
                                   for uuid in network_uuids],
487
                                   network_to_groups,
488
                                   network_to_instances,
489
                                   stats)
490

    
491
  @staticmethod
492
  def _GetStats(pool):
493
    """Returns statistics for a network address pool.
494

495
    """
496
    return {
497
      "free_count": pool.GetFreeCount(),
498
      "reserved_count": pool.GetReservedCount(),
499
      "map": pool.GetMap(),
500
      "external_reservations":
501
        utils.CommaJoin(pool.GetExternalReservations()),
502
      }
503

    
504

    
505
class LUNetworkQuery(NoHooksLU):
506
  """Logical unit for querying networks.
507

508
  """
509
  REQ_BGL = False
510

    
511
  def CheckArguments(self):
512
    self.nq = _NetworkQuery(qlang.MakeSimpleFilter("name", self.op.names),
513
                            self.op.output_fields, self.op.use_locking)
514

    
515
  def ExpandNames(self):
516
    self.nq.ExpandNames(self)
517

    
518
  def Exec(self, feedback_fn):
519
    return self.nq.OldStyleQuery(self)
520

    
521

    
522
def _FmtNetworkConflict(details):
523
  """Utility for L{_NetworkConflictCheck}.
524

525
  """
526
  return utils.CommaJoin("nic%s/%s" % (idx, ipaddr)
527
                         for (idx, ipaddr) in details)
528

    
529

    
530
def _NetworkConflictCheck(lu, check_fn, action, instances):
531
  """Checks for network interface conflicts with a network.
532

533
  @type lu: L{LogicalUnit}
534
  @type check_fn: callable receiving one parameter (L{objects.NIC}) and
535
    returning boolean
536
  @param check_fn: Function checking for conflict
537
  @type action: string
538
  @param action: Part of error message (see code)
539
  @raise errors.OpPrereqError: If conflicting IP addresses are found.
540

541
  """
542
  conflicts = []
543

    
544
  for (_, instance) in lu.cfg.GetMultiInstanceInfo(instances):
545
    instconflicts = [(idx, nic.ip)
546
                     for (idx, nic) in enumerate(instance.nics)
547
                     if check_fn(nic)]
548

    
549
    if instconflicts:
550
      conflicts.append((instance.name, instconflicts))
551

    
552
  if conflicts:
553
    lu.LogWarning("IP addresses from network '%s', which is about to %s"
554
                  " node group '%s', are in use: %s" %
555
                  (lu.network_name, action, lu.group.name,
556
                   utils.CommaJoin(("%s: %s" %
557
                                    (name, _FmtNetworkConflict(details)))
558
                                   for (name, details) in conflicts)))
559

    
560
    raise errors.OpPrereqError("Conflicting IP addresses found; "
561
                               " remove/modify the corresponding network"
562
                               " interfaces", errors.ECODE_STATE)
563

    
564

    
565
class LUNetworkConnect(LogicalUnit):
566
  """Connect a network to a nodegroup
567

568
  """
569
  HPATH = "network-connect"
570
  HTYPE = constants.HTYPE_NETWORK
571
  REQ_BGL = False
572

    
573
  def ExpandNames(self):
574
    self.network_name = self.op.network_name
575
    self.group_name = self.op.group_name
576
    self.network_mode = self.op.network_mode
577
    self.network_link = self.op.network_link
578

    
579
    self.network_uuid = self.cfg.LookupNetwork(self.network_name)
580
    self.group_uuid = self.cfg.LookupNodeGroup(self.group_name)
581

    
582
    self.needed_locks = {
583
      locking.LEVEL_INSTANCE: [],
584
      locking.LEVEL_NODEGROUP: [self.group_uuid],
585
      }
586
    self.share_locks[locking.LEVEL_INSTANCE] = 1
587

    
588
    if self.op.conflicts_check:
589
      self.needed_locks[locking.LEVEL_NETWORK] = [self.network_uuid]
590
      self.share_locks[locking.LEVEL_NETWORK] = 1
591

    
592
  def DeclareLocks(self, level):
593
    if level == locking.LEVEL_INSTANCE:
594
      assert not self.needed_locks[locking.LEVEL_INSTANCE]
595

    
596
      # Lock instances optimistically, needs verification once group lock has
597
      # been acquired
598
      if self.op.conflicts_check:
599
        self.needed_locks[locking.LEVEL_INSTANCE] = \
600
            self.cfg.GetNodeGroupInstances(self.group_uuid)
601

    
602
  def BuildHooksEnv(self):
603
    ret = {
604
      "GROUP_NAME": self.group_name,
605
      "GROUP_NETWORK_MODE": self.network_mode,
606
      "GROUP_NETWORK_LINK": self.network_link,
607
      }
608
    return ret
609

    
610
  def BuildHooksNodes(self):
611
    nodes = self.cfg.GetNodeGroup(self.group_uuid).members
612
    return (nodes, nodes)
613

    
614
  def CheckPrereq(self):
615
    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))
616

    
617
    assert self.group_uuid in owned_groups
618

    
619
    # Check if locked instances are still correct
620
    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))
621
    if self.op.conflicts_check:
622
      _CheckNodeGroupInstances(self.cfg, self.group_uuid, owned_instances)
623

    
624
    self.netparams = {
625
      constants.NIC_MODE: self.network_mode,
626
      constants.NIC_LINK: self.network_link,
627
      }
628
    objects.NIC.CheckParameterSyntax(self.netparams)
629

    
630
    self.group = self.cfg.GetNodeGroup(self.group_uuid)
631
    #if self.network_mode == constants.NIC_MODE_BRIDGED:
632
    #  _CheckNodeGroupBridgesExist(self, self.network_link, self.group_uuid)
633
    self.connected = False
634
    if self.network_uuid in self.group.networks:
635
      self.LogWarning("Network '%s' is already mapped to group '%s'" %
636
                      (self.network_name, self.group.name))
637
      self.connected = True
638

    
639
    # check only if not already connected
640
    elif self.op.conflicts_check:
641
      pool = network.AddressPool(self.cfg.GetNetwork(self.network_uuid))
642

    
643
      _NetworkConflictCheck(self, lambda nic: pool.Contains(nic.ip),
644
                            "connect to", owned_instances)
645

    
646
  def Exec(self, feedback_fn):
647
    # Connect the network and update the group only if not already connected
648
    if not self.connected:
649
      self.group.networks[self.network_uuid] = self.netparams
650
      self.cfg.Update(self.group, feedback_fn)
651

    
652

    
653
class LUNetworkDisconnect(LogicalUnit):
654
  """Disconnect a network to a nodegroup
655

656
  """
657
  HPATH = "network-disconnect"
658
  HTYPE = constants.HTYPE_NETWORK
659
  REQ_BGL = False
660

    
661
  def ExpandNames(self):
662
    self.network_name = self.op.network_name
663
    self.group_name = self.op.group_name
664

    
665
    self.network_uuid = self.cfg.LookupNetwork(self.network_name)
666
    self.group_uuid = self.cfg.LookupNodeGroup(self.group_name)
667

    
668
    self.needed_locks = {
669
      locking.LEVEL_INSTANCE: [],
670
      locking.LEVEL_NODEGROUP: [self.group_uuid],
671
      }
672
    self.share_locks[locking.LEVEL_INSTANCE] = 1
673

    
674
  def DeclareLocks(self, level):
675
    if level == locking.LEVEL_INSTANCE:
676
      assert not self.needed_locks[locking.LEVEL_INSTANCE]
677

    
678
      # Lock instances optimistically, needs verification once group lock has
679
      # been acquired
680
      self.needed_locks[locking.LEVEL_INSTANCE] = \
681
        self.cfg.GetNodeGroupInstances(self.group_uuid)
682

    
683
  def BuildHooksEnv(self):
684
    ret = {
685
      "GROUP_NAME": self.group_name,
686
      }
687
    return ret
688

    
689
  def BuildHooksNodes(self):
690
    nodes = self.cfg.GetNodeGroup(self.group_uuid).members
691
    return (nodes, nodes)
692

    
693
  def CheckPrereq(self):
694
    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))
695

    
696
    assert self.group_uuid in owned_groups
697

    
698
    # Check if locked instances are still correct
699
    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))
700
    _CheckNodeGroupInstances(self.cfg, self.group_uuid, owned_instances)
701

    
702
    self.group = self.cfg.GetNodeGroup(self.group_uuid)
703
    self.connected = True
704
    if self.network_uuid not in self.group.networks:
705
      self.LogWarning("Network '%s' is not mapped to group '%s'",
706
                      self.network_name, self.group.name)
707
      self.connected = False
708

    
709
    # We need this check only if network is not already connected
710
    else:
711
      _NetworkConflictCheck(self, lambda nic: nic.network == self.network_uuid,
712
                            "disconnect from", owned_instances)
713

    
714
  def Exec(self, feedback_fn):
715
    # Disconnect the network and update the group only if network is connected
716
    if self.connected:
717
      del self.group.networks[self.network_uuid]
718
      self.cfg.Update(self.group, feedback_fn)