Statistics
| Branch: | Tag: | Revision:

root / lib / cmdlib / instance.py @ 0f68f7fa

History | View | Annotate | Download (138.8 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 instances."""
23

    
24
import OpenSSL
25
import copy
26
import logging
27
import os
28

    
29
from ganeti import compat
30
from ganeti import constants
31
from ganeti import errors
32
from ganeti import ht
33
from ganeti import hypervisor
34
from ganeti import locking
35
from ganeti.masterd import iallocator
36
from ganeti import masterd
37
from ganeti import netutils
38
from ganeti import objects
39
from ganeti import opcodes
40
from ganeti import pathutils
41
from ganeti import rpc
42
from ganeti import utils
43

    
44
from ganeti.cmdlib.base import NoHooksLU, LogicalUnit, ResultWithJobs
45

    
46
from ganeti.cmdlib.common import INSTANCE_DOWN, \
47
  INSTANCE_NOT_RUNNING, CAN_CHANGE_INSTANCE_OFFLINE, CheckNodeOnline, \
48
  ShareAll, GetDefaultIAllocator, CheckInstanceNodeGroups, \
49
  LoadNodeEvacResult, CheckIAllocatorOrNode, CheckParamsNotGlobal, \
50
  IsExclusiveStorageEnabledNode, CheckHVParams, CheckOSParams, \
51
  AnnotateDiskParams, GetUpdatedParams, ExpandInstanceName, \
52
  ComputeIPolicySpecViolation, CheckInstanceState, ExpandNodeName
53
from ganeti.cmdlib.instance_storage import CreateDisks, \
54
  CheckNodesFreeDiskPerVG, WipeDisks, WipeOrCleanupDisks, WaitForSync, \
55
  IsExclusiveStorageEnabledNodeName, CreateSingleBlockDev, ComputeDisks, \
56
  CheckRADOSFreeSpace, ComputeDiskSizePerVG, GenerateDiskTemplate, \
57
  StartInstanceDisks, ShutdownInstanceDisks, AssembleInstanceDisks
58
from ganeti.cmdlib.instance_utils import BuildInstanceHookEnvByObject, \
59
  GetClusterDomainSecret, BuildInstanceHookEnv, NICListToTuple, \
60
  NICToTuple, CheckNodeNotDrained, RemoveInstance, CopyLockList, \
61
  ReleaseLocks, CheckNodeVmCapable, CheckTargetNodeIPolicy, \
62
  GetInstanceInfoText, RemoveDisks, CheckNodeFreeMemory, \
63
  CheckInstanceBridgesExist, CheckNicsBridgesExist, CheckNodeHasOS
64

    
65
import ganeti.masterd.instance
66

    
67

    
68
#: Type description for changes as returned by L{_ApplyContainerMods}'s
69
#: callbacks
70
_TApplyContModsCbChanges = \
71
  ht.TMaybeListOf(ht.TAnd(ht.TIsLength(2), ht.TItems([
72
    ht.TNonEmptyString,
73
    ht.TAny,
74
    ])))
75

    
76

    
77
def _CheckHostnameSane(lu, name):
78
  """Ensures that a given hostname resolves to a 'sane' name.
79

80
  The given name is required to be a prefix of the resolved hostname,
81
  to prevent accidental mismatches.
82

83
  @param lu: the logical unit on behalf of which we're checking
84
  @param name: the name we should resolve and check
85
  @return: the resolved hostname object
86

87
  """
88
  hostname = netutils.GetHostname(name=name)
89
  if hostname.name != name:
90
    lu.LogInfo("Resolved given name '%s' to '%s'", name, hostname.name)
91
  if not utils.MatchNameComponent(name, [hostname.name]):
92
    raise errors.OpPrereqError(("Resolved hostname '%s' does not look the"
93
                                " same as given hostname '%s'") %
94
                               (hostname.name, name), errors.ECODE_INVAL)
95
  return hostname
96

    
97

    
98
def _CheckOpportunisticLocking(op):
99
  """Generate error if opportunistic locking is not possible.
100

101
  """
102
  if op.opportunistic_locking and not op.iallocator:
103
    raise errors.OpPrereqError("Opportunistic locking is only available in"
104
                               " combination with an instance allocator",
105
                               errors.ECODE_INVAL)
106

    
107

    
108
def _CreateInstanceAllocRequest(op, disks, nics, beparams, node_whitelist):
109
  """Wrapper around IAReqInstanceAlloc.
110

111
  @param op: The instance opcode
112
  @param disks: The computed disks
113
  @param nics: The computed nics
114
  @param beparams: The full filled beparams
115
  @param node_whitelist: List of nodes which should appear as online to the
116
    allocator (unless the node is already marked offline)
117

118
  @returns: A filled L{iallocator.IAReqInstanceAlloc}
119

120
  """
121
  spindle_use = beparams[constants.BE_SPINDLE_USE]
122
  return iallocator.IAReqInstanceAlloc(name=op.instance_name,
123
                                       disk_template=op.disk_template,
124
                                       tags=op.tags,
125
                                       os=op.os_type,
126
                                       vcpus=beparams[constants.BE_VCPUS],
127
                                       memory=beparams[constants.BE_MAXMEM],
128
                                       spindle_use=spindle_use,
129
                                       disks=disks,
130
                                       nics=[n.ToDict() for n in nics],
131
                                       hypervisor=op.hypervisor,
132
                                       node_whitelist=node_whitelist)
133

    
134

    
135
def _ComputeFullBeParams(op, cluster):
136
  """Computes the full beparams.
137

138
  @param op: The instance opcode
139
  @param cluster: The cluster config object
140

141
  @return: The fully filled beparams
142

143
  """
144
  default_beparams = cluster.beparams[constants.PP_DEFAULT]
145
  for param, value in op.beparams.iteritems():
146
    if value == constants.VALUE_AUTO:
147
      op.beparams[param] = default_beparams[param]
148
  objects.UpgradeBeParams(op.beparams)
149
  utils.ForceDictType(op.beparams, constants.BES_PARAMETER_TYPES)
150
  return cluster.SimpleFillBE(op.beparams)
151

    
152

    
153
def _ComputeNics(op, cluster, default_ip, cfg, ec_id):
154
  """Computes the nics.
155

156
  @param op: The instance opcode
157
  @param cluster: Cluster configuration object
158
  @param default_ip: The default ip to assign
159
  @param cfg: An instance of the configuration object
160
  @param ec_id: Execution context ID
161

162
  @returns: The build up nics
163

164
  """
165
  nics = []
166
  for nic in op.nics:
167
    nic_mode_req = nic.get(constants.INIC_MODE, None)
168
    nic_mode = nic_mode_req
169
    if nic_mode is None or nic_mode == constants.VALUE_AUTO:
170
      nic_mode = cluster.nicparams[constants.PP_DEFAULT][constants.NIC_MODE]
171

    
172
    net = nic.get(constants.INIC_NETWORK, None)
173
    link = nic.get(constants.NIC_LINK, None)
174
    ip = nic.get(constants.INIC_IP, None)
175

    
176
    if net is None or net.lower() == constants.VALUE_NONE:
177
      net = None
178
    else:
179
      if nic_mode_req is not None or link is not None:
180
        raise errors.OpPrereqError("If network is given, no mode or link"
181
                                   " is allowed to be passed",
182
                                   errors.ECODE_INVAL)
183

    
184
    # ip validity checks
185
    if ip is None or ip.lower() == constants.VALUE_NONE:
186
      nic_ip = None
187
    elif ip.lower() == constants.VALUE_AUTO:
188
      if not op.name_check:
189
        raise errors.OpPrereqError("IP address set to auto but name checks"
190
                                   " have been skipped",
191
                                   errors.ECODE_INVAL)
192
      nic_ip = default_ip
193
    else:
194
      # We defer pool operations until later, so that the iallocator has
195
      # filled in the instance's node(s) dimara
196
      if ip.lower() == constants.NIC_IP_POOL:
197
        if net is None:
198
          raise errors.OpPrereqError("if ip=pool, parameter network"
199
                                     " must be passed too",
200
                                     errors.ECODE_INVAL)
201

    
202
      elif not netutils.IPAddress.IsValid(ip):
203
        raise errors.OpPrereqError("Invalid IP address '%s'" % ip,
204
                                   errors.ECODE_INVAL)
205

    
206
      nic_ip = ip
207

    
208
    # TODO: check the ip address for uniqueness
209
    if nic_mode == constants.NIC_MODE_ROUTED and not nic_ip:
210
      raise errors.OpPrereqError("Routed nic mode requires an ip address",
211
                                 errors.ECODE_INVAL)
212

    
213
    # MAC address verification
214
    mac = nic.get(constants.INIC_MAC, constants.VALUE_AUTO)
215
    if mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):
216
      mac = utils.NormalizeAndValidateMac(mac)
217

    
218
      try:
219
        # TODO: We need to factor this out
220
        cfg.ReserveMAC(mac, ec_id)
221
      except errors.ReservationError:
222
        raise errors.OpPrereqError("MAC address %s already in use"
223
                                   " in cluster" % mac,
224
                                   errors.ECODE_NOTUNIQUE)
225

    
226
    #  Build nic parameters
227
    nicparams = {}
228
    if nic_mode_req:
229
      nicparams[constants.NIC_MODE] = nic_mode
230
    if link:
231
      nicparams[constants.NIC_LINK] = link
232

    
233
    check_params = cluster.SimpleFillNIC(nicparams)
234
    objects.NIC.CheckParameterSyntax(check_params)
235
    net_uuid = cfg.LookupNetwork(net)
236
    name = nic.get(constants.INIC_NAME, None)
237
    if name is not None and name.lower() == constants.VALUE_NONE:
238
      name = None
239
    nic_obj = objects.NIC(mac=mac, ip=nic_ip, name=name,
240
                          network=net_uuid, nicparams=nicparams)
241
    nic_obj.uuid = cfg.GenerateUniqueID(ec_id)
242
    nics.append(nic_obj)
243

    
244
  return nics
245

    
246

    
247
def _CheckForConflictingIp(lu, ip, node):
248
  """In case of conflicting IP address raise error.
249

250
  @type ip: string
251
  @param ip: IP address
252
  @type node: string
253
  @param node: node name
254

255
  """
256
  (conf_net, _) = lu.cfg.CheckIPInNodeGroup(ip, node)
257
  if conf_net is not None:
258
    raise errors.OpPrereqError(("The requested IP address (%s) belongs to"
259
                                " network %s, but the target NIC does not." %
260
                                (ip, conf_net)),
261
                               errors.ECODE_STATE)
262

    
263
  return (None, None)
264

    
265

    
266
def _ComputeIPolicyInstanceSpecViolation(
267
  ipolicy, instance_spec, disk_template,
268
  _compute_fn=ComputeIPolicySpecViolation):
269
  """Compute if instance specs meets the specs of ipolicy.
270

271
  @type ipolicy: dict
272
  @param ipolicy: The ipolicy to verify against
273
  @param instance_spec: dict
274
  @param instance_spec: The instance spec to verify
275
  @type disk_template: string
276
  @param disk_template: the disk template of the instance
277
  @param _compute_fn: The function to verify ipolicy (unittest only)
278
  @see: L{ComputeIPolicySpecViolation}
279

280
  """
281
  mem_size = instance_spec.get(constants.ISPEC_MEM_SIZE, None)
282
  cpu_count = instance_spec.get(constants.ISPEC_CPU_COUNT, None)
283
  disk_count = instance_spec.get(constants.ISPEC_DISK_COUNT, 0)
284
  disk_sizes = instance_spec.get(constants.ISPEC_DISK_SIZE, [])
285
  nic_count = instance_spec.get(constants.ISPEC_NIC_COUNT, 0)
286
  spindle_use = instance_spec.get(constants.ISPEC_SPINDLE_USE, None)
287

    
288
  return _compute_fn(ipolicy, mem_size, cpu_count, disk_count, nic_count,
289
                     disk_sizes, spindle_use, disk_template)
290

    
291

    
292
def _CheckOSVariant(os_obj, name):
293
  """Check whether an OS name conforms to the os variants specification.
294

295
  @type os_obj: L{objects.OS}
296
  @param os_obj: OS object to check
297
  @type name: string
298
  @param name: OS name passed by the user, to check for validity
299

300
  """
301
  variant = objects.OS.GetVariant(name)
302
  if not os_obj.supported_variants:
303
    if variant:
304
      raise errors.OpPrereqError("OS '%s' doesn't support variants ('%s'"
305
                                 " passed)" % (os_obj.name, variant),
306
                                 errors.ECODE_INVAL)
307
    return
308
  if not variant:
309
    raise errors.OpPrereqError("OS name must include a variant",
310
                               errors.ECODE_INVAL)
311

    
312
  if variant not in os_obj.supported_variants:
313
    raise errors.OpPrereqError("Unsupported OS variant", errors.ECODE_INVAL)
314

    
315

    
316
class LUInstanceCreate(LogicalUnit):
317
  """Create an instance.
318

319
  """
320
  HPATH = "instance-add"
321
  HTYPE = constants.HTYPE_INSTANCE
322
  REQ_BGL = False
323

    
324
  def CheckArguments(self):
325
    """Check arguments.
326

327
    """
328
    # do not require name_check to ease forward/backward compatibility
329
    # for tools
330
    if self.op.no_install and self.op.start:
331
      self.LogInfo("No-installation mode selected, disabling startup")
332
      self.op.start = False
333
    # validate/normalize the instance name
334
    self.op.instance_name = \
335
      netutils.Hostname.GetNormalizedName(self.op.instance_name)
336

    
337
    if self.op.ip_check and not self.op.name_check:
338
      # TODO: make the ip check more flexible and not depend on the name check
339
      raise errors.OpPrereqError("Cannot do IP address check without a name"
340
                                 " check", errors.ECODE_INVAL)
341

    
342
    # check nics' parameter names
343
    for nic in self.op.nics:
344
      utils.ForceDictType(nic, constants.INIC_PARAMS_TYPES)
345
    # check that NIC's parameters names are unique and valid
346
    utils.ValidateDeviceNames("NIC", self.op.nics)
347

    
348
    # check that disk's names are unique and valid
349
    utils.ValidateDeviceNames("disk", self.op.disks)
350

    
351
    cluster = self.cfg.GetClusterInfo()
352
    if not self.op.disk_template in cluster.enabled_disk_templates:
353
      raise errors.OpPrereqError("Cannot create an instance with disk template"
354
                                 " '%s', because it is not enabled in the"
355
                                 " cluster. Enabled disk templates are: %s." %
356
                                 (self.op.disk_template,
357
                                  ",".join(cluster.enabled_disk_templates)))
358

    
359
    # check disks. parameter names and consistent adopt/no-adopt strategy
360
    has_adopt = has_no_adopt = False
361
    for disk in self.op.disks:
362
      if self.op.disk_template != constants.DT_EXT:
363
        utils.ForceDictType(disk, constants.IDISK_PARAMS_TYPES)
364
      if constants.IDISK_ADOPT in disk:
365
        has_adopt = True
366
      else:
367
        has_no_adopt = True
368
    if has_adopt and has_no_adopt:
369
      raise errors.OpPrereqError("Either all disks are adopted or none is",
370
                                 errors.ECODE_INVAL)
371
    if has_adopt:
372
      if self.op.disk_template not in constants.DTS_MAY_ADOPT:
373
        raise errors.OpPrereqError("Disk adoption is not supported for the"
374
                                   " '%s' disk template" %
375
                                   self.op.disk_template,
376
                                   errors.ECODE_INVAL)
377
      if self.op.iallocator is not None:
378
        raise errors.OpPrereqError("Disk adoption not allowed with an"
379
                                   " iallocator script", errors.ECODE_INVAL)
380
      if self.op.mode == constants.INSTANCE_IMPORT:
381
        raise errors.OpPrereqError("Disk adoption not allowed for"
382
                                   " instance import", errors.ECODE_INVAL)
383
    else:
384
      if self.op.disk_template in constants.DTS_MUST_ADOPT:
385
        raise errors.OpPrereqError("Disk template %s requires disk adoption,"
386
                                   " but no 'adopt' parameter given" %
387
                                   self.op.disk_template,
388
                                   errors.ECODE_INVAL)
389

    
390
    self.adopt_disks = has_adopt
391

    
392
    # instance name verification
393
    if self.op.name_check:
394
      self.hostname1 = _CheckHostnameSane(self, self.op.instance_name)
395
      self.op.instance_name = self.hostname1.name
396
      # used in CheckPrereq for ip ping check
397
      self.check_ip = self.hostname1.ip
398
    else:
399
      self.check_ip = None
400

    
401
    # file storage checks
402
    if (self.op.file_driver and
403
        not self.op.file_driver in constants.FILE_DRIVER):
404
      raise errors.OpPrereqError("Invalid file driver name '%s'" %
405
                                 self.op.file_driver, errors.ECODE_INVAL)
406

    
407
    # set default file_driver if unset and required
408
    if (not self.op.file_driver and
409
        self.op.disk_template in [constants.DT_FILE,
410
                                  constants.DT_SHARED_FILE]):
411
      self.op.file_driver = constants.FD_DEFAULT
412

    
413
    if self.op.disk_template == constants.DT_FILE:
414
      opcodes.RequireFileStorage()
415
    elif self.op.disk_template == constants.DT_SHARED_FILE:
416
      opcodes.RequireSharedFileStorage()
417

    
418
    ### Node/iallocator related checks
419
    CheckIAllocatorOrNode(self, "iallocator", "pnode")
420

    
421
    if self.op.pnode is not None:
422
      if self.op.disk_template in constants.DTS_INT_MIRROR:
423
        if self.op.snode is None:
424
          raise errors.OpPrereqError("The networked disk templates need"
425
                                     " a mirror node", errors.ECODE_INVAL)
426
      elif self.op.snode:
427
        self.LogWarning("Secondary node will be ignored on non-mirrored disk"
428
                        " template")
429
        self.op.snode = None
430

    
431
    _CheckOpportunisticLocking(self.op)
432

    
433
    self._cds = GetClusterDomainSecret()
434

    
435
    if self.op.mode == constants.INSTANCE_IMPORT:
436
      # On import force_variant must be True, because if we forced it at
437
      # initial install, our only chance when importing it back is that it
438
      # works again!
439
      self.op.force_variant = True
440

    
441
      if self.op.no_install:
442
        self.LogInfo("No-installation mode has no effect during import")
443

    
444
    elif self.op.mode == constants.INSTANCE_CREATE:
445
      if self.op.os_type is None:
446
        raise errors.OpPrereqError("No guest OS specified",
447
                                   errors.ECODE_INVAL)
448
      if self.op.os_type in self.cfg.GetClusterInfo().blacklisted_os:
449
        raise errors.OpPrereqError("Guest OS '%s' is not allowed for"
450
                                   " installation" % self.op.os_type,
451
                                   errors.ECODE_STATE)
452
      if self.op.disk_template is None:
453
        raise errors.OpPrereqError("No disk template specified",
454
                                   errors.ECODE_INVAL)
455

    
456
    elif self.op.mode == constants.INSTANCE_REMOTE_IMPORT:
457
      # Check handshake to ensure both clusters have the same domain secret
458
      src_handshake = self.op.source_handshake
459
      if not src_handshake:
460
        raise errors.OpPrereqError("Missing source handshake",
461
                                   errors.ECODE_INVAL)
462

    
463
      errmsg = masterd.instance.CheckRemoteExportHandshake(self._cds,
464
                                                           src_handshake)
465
      if errmsg:
466
        raise errors.OpPrereqError("Invalid handshake: %s" % errmsg,
467
                                   errors.ECODE_INVAL)
468

    
469
      # Load and check source CA
470
      self.source_x509_ca_pem = self.op.source_x509_ca
471
      if not self.source_x509_ca_pem:
472
        raise errors.OpPrereqError("Missing source X509 CA",
473
                                   errors.ECODE_INVAL)
474

    
475
      try:
476
        (cert, _) = utils.LoadSignedX509Certificate(self.source_x509_ca_pem,
477
                                                    self._cds)
478
      except OpenSSL.crypto.Error, err:
479
        raise errors.OpPrereqError("Unable to load source X509 CA (%s)" %
480
                                   (err, ), errors.ECODE_INVAL)
481

    
482
      (errcode, msg) = utils.VerifyX509Certificate(cert, None, None)
483
      if errcode is not None:
484
        raise errors.OpPrereqError("Invalid source X509 CA (%s)" % (msg, ),
485
                                   errors.ECODE_INVAL)
486

    
487
      self.source_x509_ca = cert
488

    
489
      src_instance_name = self.op.source_instance_name
490
      if not src_instance_name:
491
        raise errors.OpPrereqError("Missing source instance name",
492
                                   errors.ECODE_INVAL)
493

    
494
      self.source_instance_name = \
495
        netutils.GetHostname(name=src_instance_name).name
496

    
497
    else:
498
      raise errors.OpPrereqError("Invalid instance creation mode %r" %
499
                                 self.op.mode, errors.ECODE_INVAL)
500

    
501
  def ExpandNames(self):
502
    """ExpandNames for CreateInstance.
503

504
    Figure out the right locks for instance creation.
505

506
    """
507
    self.needed_locks = {}
508

    
509
    instance_name = self.op.instance_name
510
    # this is just a preventive check, but someone might still add this
511
    # instance in the meantime, and creation will fail at lock-add time
512
    if instance_name in self.cfg.GetInstanceList():
513
      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
514
                                 instance_name, errors.ECODE_EXISTS)
515

    
516
    self.add_locks[locking.LEVEL_INSTANCE] = instance_name
517

    
518
    if self.op.iallocator:
519
      # TODO: Find a solution to not lock all nodes in the cluster, e.g. by
520
      # specifying a group on instance creation and then selecting nodes from
521
      # that group
522
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
523
      self.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
524

    
525
      if self.op.opportunistic_locking:
526
        self.opportunistic_locks[locking.LEVEL_NODE] = True
527
    else:
528
      self.op.pnode = ExpandNodeName(self.cfg, self.op.pnode)
529
      nodelist = [self.op.pnode]
530
      if self.op.snode is not None:
531
        self.op.snode = ExpandNodeName(self.cfg, self.op.snode)
532
        nodelist.append(self.op.snode)
533
      self.needed_locks[locking.LEVEL_NODE] = nodelist
534

    
535
    # in case of import lock the source node too
536
    if self.op.mode == constants.INSTANCE_IMPORT:
537
      src_node = self.op.src_node
538
      src_path = self.op.src_path
539

    
540
      if src_path is None:
541
        self.op.src_path = src_path = self.op.instance_name
542

    
543
      if src_node is None:
544
        self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
545
        self.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
546
        self.op.src_node = None
547
        if os.path.isabs(src_path):
548
          raise errors.OpPrereqError("Importing an instance from a path"
549
                                     " requires a source node option",
550
                                     errors.ECODE_INVAL)
551
      else:
552
        self.op.src_node = src_node = ExpandNodeName(self.cfg, src_node)
553
        if self.needed_locks[locking.LEVEL_NODE] is not locking.ALL_SET:
554
          self.needed_locks[locking.LEVEL_NODE].append(src_node)
555
        if not os.path.isabs(src_path):
556
          self.op.src_path = src_path = \
557
            utils.PathJoin(pathutils.EXPORT_DIR, src_path)
558

    
559
    self.needed_locks[locking.LEVEL_NODE_RES] = \
560
      CopyLockList(self.needed_locks[locking.LEVEL_NODE])
561

    
562
    # Optimistically acquire shared group locks (we're reading the
563
    # configuration).  We can't just call GetInstanceNodeGroups, because the
564
    # instance doesn't exist yet. Therefore we lock all node groups of all
565
    # nodes we have.
566
    if self.needed_locks[locking.LEVEL_NODE] == locking.ALL_SET:
567
      # In the case we lock all nodes for opportunistic allocation, we have no
568
      # choice than to lock all groups, because they're allocated before nodes.
569
      # This is sad, but true. At least we release all those we don't need in
570
      # CheckPrereq later.
571
      self.needed_locks[locking.LEVEL_NODEGROUP] = locking.ALL_SET
572
    else:
573
      self.needed_locks[locking.LEVEL_NODEGROUP] = \
574
        list(self.cfg.GetNodeGroupsFromNodes(
575
          self.needed_locks[locking.LEVEL_NODE]))
576
    self.share_locks[locking.LEVEL_NODEGROUP] = 1
577

    
578
  def DeclareLocks(self, level):
579
    if level == locking.LEVEL_NODE_RES and \
580
      self.opportunistic_locks[locking.LEVEL_NODE]:
581
      # Even when using opportunistic locking, we require the same set of
582
      # NODE_RES locks as we got NODE locks
583
      self.needed_locks[locking.LEVEL_NODE_RES] = \
584
        self.owned_locks(locking.LEVEL_NODE)
585

    
586
  def _RunAllocator(self):
587
    """Run the allocator based on input opcode.
588

589
    """
590
    if self.op.opportunistic_locking:
591
      # Only consider nodes for which a lock is held
592
      node_whitelist = list(self.owned_locks(locking.LEVEL_NODE))
593
    else:
594
      node_whitelist = None
595

    
596
    #TODO Export network to iallocator so that it chooses a pnode
597
    #     in a nodegroup that has the desired network connected to
598
    req = _CreateInstanceAllocRequest(self.op, self.disks,
599
                                      self.nics, self.be_full,
600
                                      node_whitelist)
601
    ial = iallocator.IAllocator(self.cfg, self.rpc, req)
602

    
603
    ial.Run(self.op.iallocator)
604

    
605
    if not ial.success:
606
      # When opportunistic locks are used only a temporary failure is generated
607
      if self.op.opportunistic_locking:
608
        ecode = errors.ECODE_TEMP_NORES
609
      else:
610
        ecode = errors.ECODE_NORES
611

    
612
      raise errors.OpPrereqError("Can't compute nodes using"
613
                                 " iallocator '%s': %s" %
614
                                 (self.op.iallocator, ial.info),
615
                                 ecode)
616

    
617
    self.op.pnode = ial.result[0]
618
    self.LogInfo("Selected nodes for instance %s via iallocator %s: %s",
619
                 self.op.instance_name, self.op.iallocator,
620
                 utils.CommaJoin(ial.result))
621

    
622
    assert req.RequiredNodes() in (1, 2), "Wrong node count from iallocator"
623

    
624
    if req.RequiredNodes() == 2:
625
      self.op.snode = ial.result[1]
626

    
627
  def BuildHooksEnv(self):
628
    """Build hooks env.
629

630
    This runs on master, primary and secondary nodes of the instance.
631

632
    """
633
    env = {
634
      "ADD_MODE": self.op.mode,
635
      }
636
    if self.op.mode == constants.INSTANCE_IMPORT:
637
      env["SRC_NODE"] = self.op.src_node
638
      env["SRC_PATH"] = self.op.src_path
639
      env["SRC_IMAGES"] = self.src_images
640

    
641
    env.update(BuildInstanceHookEnv(
642
      name=self.op.instance_name,
643
      primary_node=self.op.pnode,
644
      secondary_nodes=self.secondaries,
645
      status=self.op.start,
646
      os_type=self.op.os_type,
647
      minmem=self.be_full[constants.BE_MINMEM],
648
      maxmem=self.be_full[constants.BE_MAXMEM],
649
      vcpus=self.be_full[constants.BE_VCPUS],
650
      nics=NICListToTuple(self, self.nics),
651
      disk_template=self.op.disk_template,
652
      disks=[(d[constants.IDISK_NAME], d.get("uuid", ""),
653
              d[constants.IDISK_SIZE], d[constants.IDISK_MODE])
654
             for d in self.disks],
655
      bep=self.be_full,
656
      hvp=self.hv_full,
657
      hypervisor_name=self.op.hypervisor,
658
      tags=self.op.tags,
659
      ))
660

    
661
    return env
662

    
663
  def BuildHooksNodes(self):
664
    """Build hooks nodes.
665

666
    """
667
    nl = [self.cfg.GetMasterNode(), self.op.pnode] + self.secondaries
668
    return nl, nl
669

    
670
  def _ReadExportInfo(self):
671
    """Reads the export information from disk.
672

673
    It will override the opcode source node and path with the actual
674
    information, if these two were not specified before.
675

676
    @return: the export information
677

678
    """
679
    assert self.op.mode == constants.INSTANCE_IMPORT
680

    
681
    src_node = self.op.src_node
682
    src_path = self.op.src_path
683

    
684
    if src_node is None:
685
      locked_nodes = self.owned_locks(locking.LEVEL_NODE)
686
      exp_list = self.rpc.call_export_list(locked_nodes)
687
      found = False
688
      for node in exp_list:
689
        if exp_list[node].fail_msg:
690
          continue
691
        if src_path in exp_list[node].payload:
692
          found = True
693
          self.op.src_node = src_node = node
694
          self.op.src_path = src_path = utils.PathJoin(pathutils.EXPORT_DIR,
695
                                                       src_path)
696
          break
697
      if not found:
698
        raise errors.OpPrereqError("No export found for relative path %s" %
699
                                   src_path, errors.ECODE_INVAL)
700

    
701
    CheckNodeOnline(self, src_node)
702
    result = self.rpc.call_export_info(src_node, src_path)
703
    result.Raise("No export or invalid export found in dir %s" % src_path)
704

    
705
    export_info = objects.SerializableConfigParser.Loads(str(result.payload))
706
    if not export_info.has_section(constants.INISECT_EXP):
707
      raise errors.ProgrammerError("Corrupted export config",
708
                                   errors.ECODE_ENVIRON)
709

    
710
    ei_version = export_info.get(constants.INISECT_EXP, "version")
711
    if (int(ei_version) != constants.EXPORT_VERSION):
712
      raise errors.OpPrereqError("Wrong export version %s (wanted %d)" %
713
                                 (ei_version, constants.EXPORT_VERSION),
714
                                 errors.ECODE_ENVIRON)
715
    return export_info
716

    
717
  def _ReadExportParams(self, einfo):
718
    """Use export parameters as defaults.
719

720
    In case the opcode doesn't specify (as in override) some instance
721
    parameters, then try to use them from the export information, if
722
    that declares them.
723

724
    """
725
    self.op.os_type = einfo.get(constants.INISECT_EXP, "os")
726

    
727
    if self.op.disk_template is None:
728
      if einfo.has_option(constants.INISECT_INS, "disk_template"):
729
        self.op.disk_template = einfo.get(constants.INISECT_INS,
730
                                          "disk_template")
731
        if self.op.disk_template not in constants.DISK_TEMPLATES:
732
          raise errors.OpPrereqError("Disk template specified in configuration"
733
                                     " file is not one of the allowed values:"
734
                                     " %s" %
735
                                     " ".join(constants.DISK_TEMPLATES),
736
                                     errors.ECODE_INVAL)
737
      else:
738
        raise errors.OpPrereqError("No disk template specified and the export"
739
                                   " is missing the disk_template information",
740
                                   errors.ECODE_INVAL)
741

    
742
    if not self.op.disks:
743
      disks = []
744
      # TODO: import the disk iv_name too
745
      for idx in range(constants.MAX_DISKS):
746
        if einfo.has_option(constants.INISECT_INS, "disk%d_size" % idx):
747
          disk_sz = einfo.getint(constants.INISECT_INS, "disk%d_size" % idx)
748
          disk_name = einfo.get(constants.INISECT_INS, "disk%d_name" % idx)
749
          disk = {
750
            constants.IDISK_SIZE: disk_sz,
751
            constants.IDISK_NAME: disk_name
752
            }
753
          disks.append(disk)
754
      self.op.disks = disks
755
      if not disks and self.op.disk_template != constants.DT_DISKLESS:
756
        raise errors.OpPrereqError("No disk info specified and the export"
757
                                   " is missing the disk information",
758
                                   errors.ECODE_INVAL)
759

    
760
    if not self.op.nics:
761
      nics = []
762
      for idx in range(constants.MAX_NICS):
763
        if einfo.has_option(constants.INISECT_INS, "nic%d_mac" % idx):
764
          ndict = {}
765
          for name in [constants.INIC_IP,
766
                       constants.INIC_MAC, constants.INIC_NAME]:
767
            v = einfo.get(constants.INISECT_INS, "nic%d_%s" % (idx, name))
768
            ndict[name] = v
769
          network = einfo.get(constants.INISECT_INS,
770
                              "nic%d_%s" % (idx, constants.INIC_NETWORK))
771
          # in case network is given link and mode are inherited
772
          # from nodegroup's netparams and thus should not be passed here
773
          if network:
774
            ndict[constants.INIC_NETWORK] = network
775
          else:
776
            for name in list(constants.NICS_PARAMETERS):
777
              v = einfo.get(constants.INISECT_INS, "nic%d_%s" % (idx, name))
778
              ndict[name] = v
779
          nics.append(ndict)
780
        else:
781
          break
782
      self.op.nics = nics
783

    
784
    if not self.op.tags and einfo.has_option(constants.INISECT_INS, "tags"):
785
      self.op.tags = einfo.get(constants.INISECT_INS, "tags").split()
786

    
787
    if (self.op.hypervisor is None and
788
        einfo.has_option(constants.INISECT_INS, "hypervisor")):
789
      self.op.hypervisor = einfo.get(constants.INISECT_INS, "hypervisor")
790

    
791
    if einfo.has_section(constants.INISECT_HYP):
792
      # use the export parameters but do not override the ones
793
      # specified by the user
794
      for name, value in einfo.items(constants.INISECT_HYP):
795
        if name not in self.op.hvparams:
796
          self.op.hvparams[name] = value
797

    
798
    if einfo.has_section(constants.INISECT_BEP):
799
      # use the parameters, without overriding
800
      for name, value in einfo.items(constants.INISECT_BEP):
801
        if name not in self.op.beparams:
802
          self.op.beparams[name] = value
803
        # Compatibility for the old "memory" be param
804
        if name == constants.BE_MEMORY:
805
          if constants.BE_MAXMEM not in self.op.beparams:
806
            self.op.beparams[constants.BE_MAXMEM] = value
807
          if constants.BE_MINMEM not in self.op.beparams:
808
            self.op.beparams[constants.BE_MINMEM] = value
809
    else:
810
      # try to read the parameters old style, from the main section
811
      for name in constants.BES_PARAMETERS:
812
        if (name not in self.op.beparams and
813
            einfo.has_option(constants.INISECT_INS, name)):
814
          self.op.beparams[name] = einfo.get(constants.INISECT_INS, name)
815

    
816
    if einfo.has_section(constants.INISECT_OSP):
817
      # use the parameters, without overriding
818
      for name, value in einfo.items(constants.INISECT_OSP):
819
        if name not in self.op.osparams:
820
          self.op.osparams[name] = value
821

    
822
  def _RevertToDefaults(self, cluster):
823
    """Revert the instance parameters to the default values.
824

825
    """
826
    # hvparams
827
    hv_defs = cluster.SimpleFillHV(self.op.hypervisor, self.op.os_type, {})
828
    for name in self.op.hvparams.keys():
829
      if name in hv_defs and hv_defs[name] == self.op.hvparams[name]:
830
        del self.op.hvparams[name]
831
    # beparams
832
    be_defs = cluster.SimpleFillBE({})
833
    for name in self.op.beparams.keys():
834
      if name in be_defs and be_defs[name] == self.op.beparams[name]:
835
        del self.op.beparams[name]
836
    # nic params
837
    nic_defs = cluster.SimpleFillNIC({})
838
    for nic in self.op.nics:
839
      for name in constants.NICS_PARAMETERS:
840
        if name in nic and name in nic_defs and nic[name] == nic_defs[name]:
841
          del nic[name]
842
    # osparams
843
    os_defs = cluster.SimpleFillOS(self.op.os_type, {})
844
    for name in self.op.osparams.keys():
845
      if name in os_defs and os_defs[name] == self.op.osparams[name]:
846
        del self.op.osparams[name]
847

    
848
  def _CalculateFileStorageDir(self):
849
    """Calculate final instance file storage dir.
850

851
    """
852
    # file storage dir calculation/check
853
    self.instance_file_storage_dir = None
854
    if self.op.disk_template in constants.DTS_FILEBASED:
855
      # build the full file storage dir path
856
      joinargs = []
857

    
858
      if self.op.disk_template == constants.DT_SHARED_FILE:
859
        get_fsd_fn = self.cfg.GetSharedFileStorageDir
860
      else:
861
        get_fsd_fn = self.cfg.GetFileStorageDir
862

    
863
      cfg_storagedir = get_fsd_fn()
864
      if not cfg_storagedir:
865
        raise errors.OpPrereqError("Cluster file storage dir not defined",
866
                                   errors.ECODE_STATE)
867
      joinargs.append(cfg_storagedir)
868

    
869
      if self.op.file_storage_dir is not None:
870
        joinargs.append(self.op.file_storage_dir)
871

    
872
      joinargs.append(self.op.instance_name)
873

    
874
      # pylint: disable=W0142
875
      self.instance_file_storage_dir = utils.PathJoin(*joinargs)
876

    
877
  def CheckPrereq(self): # pylint: disable=R0914
878
    """Check prerequisites.
879

880
    """
881
    # Check that the optimistically acquired groups are correct wrt the
882
    # acquired nodes
883
    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))
884
    owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))
885
    cur_groups = list(self.cfg.GetNodeGroupsFromNodes(owned_nodes))
886
    if not owned_groups.issuperset(cur_groups):
887
      raise errors.OpPrereqError("New instance %s's node groups changed since"
888
                                 " locks were acquired, current groups are"
889
                                 " are '%s', owning groups '%s'; retry the"
890
                                 " operation" %
891
                                 (self.op.instance_name,
892
                                  utils.CommaJoin(cur_groups),
893
                                  utils.CommaJoin(owned_groups)),
894
                                 errors.ECODE_STATE)
895

    
896
    self._CalculateFileStorageDir()
897

    
898
    if self.op.mode == constants.INSTANCE_IMPORT:
899
      export_info = self._ReadExportInfo()
900
      self._ReadExportParams(export_info)
901
      self._old_instance_name = export_info.get(constants.INISECT_INS, "name")
902
    else:
903
      self._old_instance_name = None
904

    
905
    if (not self.cfg.GetVGName() and
906
        self.op.disk_template not in constants.DTS_NOT_LVM):
907
      raise errors.OpPrereqError("Cluster does not support lvm-based"
908
                                 " instances", errors.ECODE_STATE)
909

    
910
    if (self.op.hypervisor is None or
911
        self.op.hypervisor == constants.VALUE_AUTO):
912
      self.op.hypervisor = self.cfg.GetHypervisorType()
913

    
914
    cluster = self.cfg.GetClusterInfo()
915
    enabled_hvs = cluster.enabled_hypervisors
916
    if self.op.hypervisor not in enabled_hvs:
917
      raise errors.OpPrereqError("Selected hypervisor (%s) not enabled in the"
918
                                 " cluster (%s)" %
919
                                 (self.op.hypervisor, ",".join(enabled_hvs)),
920
                                 errors.ECODE_STATE)
921

    
922
    # Check tag validity
923
    for tag in self.op.tags:
924
      objects.TaggableObject.ValidateTag(tag)
925

    
926
    # check hypervisor parameter syntax (locally)
927
    utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)
928
    filled_hvp = cluster.SimpleFillHV(self.op.hypervisor, self.op.os_type,
929
                                      self.op.hvparams)
930
    hv_type = hypervisor.GetHypervisorClass(self.op.hypervisor)
931
    hv_type.CheckParameterSyntax(filled_hvp)
932
    self.hv_full = filled_hvp
933
    # check that we don't specify global parameters on an instance
934
    CheckParamsNotGlobal(self.op.hvparams, constants.HVC_GLOBALS, "hypervisor",
935
                         "instance", "cluster")
936

    
937
    # fill and remember the beparams dict
938
    self.be_full = _ComputeFullBeParams(self.op, cluster)
939

    
940
    # build os parameters
941
    self.os_full = cluster.SimpleFillOS(self.op.os_type, self.op.osparams)
942

    
943
    # now that hvp/bep are in final format, let's reset to defaults,
944
    # if told to do so
945
    if self.op.identify_defaults:
946
      self._RevertToDefaults(cluster)
947

    
948
    # NIC buildup
949
    self.nics = _ComputeNics(self.op, cluster, self.check_ip, self.cfg,
950
                             self.proc.GetECId())
951

    
952
    # disk checks/pre-build
953
    default_vg = self.cfg.GetVGName()
954
    self.disks = ComputeDisks(self.op, default_vg)
955

    
956
    if self.op.mode == constants.INSTANCE_IMPORT:
957
      disk_images = []
958
      for idx in range(len(self.disks)):
959
        option = "disk%d_dump" % idx
960
        if export_info.has_option(constants.INISECT_INS, option):
961
          # FIXME: are the old os-es, disk sizes, etc. useful?
962
          export_name = export_info.get(constants.INISECT_INS, option)
963
          image = utils.PathJoin(self.op.src_path, export_name)
964
          disk_images.append(image)
965
        else:
966
          disk_images.append(False)
967

    
968
      self.src_images = disk_images
969

    
970
      if self.op.instance_name == self._old_instance_name:
971
        for idx, nic in enumerate(self.nics):
972
          if nic.mac == constants.VALUE_AUTO:
973
            nic_mac_ini = "nic%d_mac" % idx
974
            nic.mac = export_info.get(constants.INISECT_INS, nic_mac_ini)
975

    
976
    # ENDIF: self.op.mode == constants.INSTANCE_IMPORT
977

    
978
    # ip ping checks (we use the same ip that was resolved in ExpandNames)
979
    if self.op.ip_check:
980
      if netutils.TcpPing(self.check_ip, constants.DEFAULT_NODED_PORT):
981
        raise errors.OpPrereqError("IP %s of instance %s already in use" %
982
                                   (self.check_ip, self.op.instance_name),
983
                                   errors.ECODE_NOTUNIQUE)
984

    
985
    #### mac address generation
986
    # By generating here the mac address both the allocator and the hooks get
987
    # the real final mac address rather than the 'auto' or 'generate' value.
988
    # There is a race condition between the generation and the instance object
989
    # creation, which means that we know the mac is valid now, but we're not
990
    # sure it will be when we actually add the instance. If things go bad
991
    # adding the instance will abort because of a duplicate mac, and the
992
    # creation job will fail.
993
    for nic in self.nics:
994
      if nic.mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):
995
        nic.mac = self.cfg.GenerateMAC(nic.network, self.proc.GetECId())
996

    
997
    #### allocator run
998

    
999
    if self.op.iallocator is not None:
1000
      self._RunAllocator()
1001

    
1002
    # Release all unneeded node locks
1003
    keep_locks = filter(None, [self.op.pnode, self.op.snode, self.op.src_node])
1004
    ReleaseLocks(self, locking.LEVEL_NODE, keep=keep_locks)
1005
    ReleaseLocks(self, locking.LEVEL_NODE_RES, keep=keep_locks)
1006
    ReleaseLocks(self, locking.LEVEL_NODE_ALLOC)
1007
    # Release all unneeded group locks
1008
    ReleaseLocks(self, locking.LEVEL_NODEGROUP,
1009
                 keep=self.cfg.GetNodeGroupsFromNodes(keep_locks))
1010

    
1011
    assert (self.owned_locks(locking.LEVEL_NODE) ==
1012
            self.owned_locks(locking.LEVEL_NODE_RES)), \
1013
      "Node locks differ from node resource locks"
1014

    
1015
    #### node related checks
1016

    
1017
    # check primary node
1018
    self.pnode = pnode = self.cfg.GetNodeInfo(self.op.pnode)
1019
    assert self.pnode is not None, \
1020
      "Cannot retrieve locked node %s" % self.op.pnode
1021
    if pnode.offline:
1022
      raise errors.OpPrereqError("Cannot use offline primary node '%s'" %
1023
                                 pnode.name, errors.ECODE_STATE)
1024
    if pnode.drained:
1025
      raise errors.OpPrereqError("Cannot use drained primary node '%s'" %
1026
                                 pnode.name, errors.ECODE_STATE)
1027
    if not pnode.vm_capable:
1028
      raise errors.OpPrereqError("Cannot use non-vm_capable primary node"
1029
                                 " '%s'" % pnode.name, errors.ECODE_STATE)
1030

    
1031
    self.secondaries = []
1032

    
1033
    # Fill in any IPs from IP pools. This must happen here, because we need to
1034
    # know the nic's primary node, as specified by the iallocator
1035
    for idx, nic in enumerate(self.nics):
1036
      net_uuid = nic.network
1037
      if net_uuid is not None:
1038
        nobj = self.cfg.GetNetwork(net_uuid)
1039
        netparams = self.cfg.GetGroupNetParams(net_uuid, self.pnode.name)
1040
        if netparams is None:
1041
          raise errors.OpPrereqError("No netparams found for network"
1042
                                     " %s. Propably not connected to"
1043
                                     " node's %s nodegroup" %
1044
                                     (nobj.name, self.pnode.name),
1045
                                     errors.ECODE_INVAL)
1046
        self.LogInfo("NIC/%d inherits netparams %s" %
1047
                     (idx, netparams.values()))
1048
        nic.nicparams = dict(netparams)
1049
        if nic.ip is not None:
1050
          if nic.ip.lower() == constants.NIC_IP_POOL:
1051
            try:
1052
              nic.ip = self.cfg.GenerateIp(net_uuid, self.proc.GetECId())
1053
            except errors.ReservationError:
1054
              raise errors.OpPrereqError("Unable to get a free IP for NIC %d"
1055
                                         " from the address pool" % idx,
1056
                                         errors.ECODE_STATE)
1057
            self.LogInfo("Chose IP %s from network %s", nic.ip, nobj.name)
1058
          else:
1059
            try:
1060
              self.cfg.ReserveIp(net_uuid, nic.ip, self.proc.GetECId())
1061
            except errors.ReservationError:
1062
              raise errors.OpPrereqError("IP address %s already in use"
1063
                                         " or does not belong to network %s" %
1064
                                         (nic.ip, nobj.name),
1065
                                         errors.ECODE_NOTUNIQUE)
1066

    
1067
      # net is None, ip None or given
1068
      elif self.op.conflicts_check:
1069
        _CheckForConflictingIp(self, nic.ip, self.pnode.name)
1070

    
1071
    # mirror node verification
1072
    if self.op.disk_template in constants.DTS_INT_MIRROR:
1073
      if self.op.snode == pnode.name:
1074
        raise errors.OpPrereqError("The secondary node cannot be the"
1075
                                   " primary node", errors.ECODE_INVAL)
1076
      CheckNodeOnline(self, self.op.snode)
1077
      CheckNodeNotDrained(self, self.op.snode)
1078
      CheckNodeVmCapable(self, self.op.snode)
1079
      self.secondaries.append(self.op.snode)
1080

    
1081
      snode = self.cfg.GetNodeInfo(self.op.snode)
1082
      if pnode.group != snode.group:
1083
        self.LogWarning("The primary and secondary nodes are in two"
1084
                        " different node groups; the disk parameters"
1085
                        " from the first disk's node group will be"
1086
                        " used")
1087

    
1088
    if not self.op.disk_template in constants.DTS_EXCL_STORAGE:
1089
      nodes = [pnode]
1090
      if self.op.disk_template in constants.DTS_INT_MIRROR:
1091
        nodes.append(snode)
1092
      has_es = lambda n: IsExclusiveStorageEnabledNode(self.cfg, n)
1093
      if compat.any(map(has_es, nodes)):
1094
        raise errors.OpPrereqError("Disk template %s not supported with"
1095
                                   " exclusive storage" % self.op.disk_template,
1096
                                   errors.ECODE_STATE)
1097

    
1098
    nodenames = [pnode.name] + self.secondaries
1099

    
1100
    if not self.adopt_disks:
1101
      if self.op.disk_template == constants.DT_RBD:
1102
        # _CheckRADOSFreeSpace() is just a placeholder.
1103
        # Any function that checks prerequisites can be placed here.
1104
        # Check if there is enough space on the RADOS cluster.
1105
        CheckRADOSFreeSpace()
1106
      elif self.op.disk_template == constants.DT_EXT:
1107
        # FIXME: Function that checks prereqs if needed
1108
        pass
1109
      else:
1110
        # Check lv size requirements, if not adopting
1111
        req_sizes = ComputeDiskSizePerVG(self.op.disk_template, self.disks)
1112
        CheckNodesFreeDiskPerVG(self, nodenames, req_sizes)
1113

    
1114
    elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data
1115
      all_lvs = set(["%s/%s" % (disk[constants.IDISK_VG],
1116
                                disk[constants.IDISK_ADOPT])
1117
                     for disk in self.disks])
1118
      if len(all_lvs) != len(self.disks):
1119
        raise errors.OpPrereqError("Duplicate volume names given for adoption",
1120
                                   errors.ECODE_INVAL)
1121
      for lv_name in all_lvs:
1122
        try:
1123
          # FIXME: lv_name here is "vg/lv" need to ensure that other calls
1124
          # to ReserveLV uses the same syntax
1125
          self.cfg.ReserveLV(lv_name, self.proc.GetECId())
1126
        except errors.ReservationError:
1127
          raise errors.OpPrereqError("LV named %s used by another instance" %
1128
                                     lv_name, errors.ECODE_NOTUNIQUE)
1129

    
1130
      vg_names = self.rpc.call_vg_list([pnode.name])[pnode.name]
1131
      vg_names.Raise("Cannot get VG information from node %s" % pnode.name)
1132

    
1133
      node_lvs = self.rpc.call_lv_list([pnode.name],
1134
                                       vg_names.payload.keys())[pnode.name]
1135
      node_lvs.Raise("Cannot get LV information from node %s" % pnode.name)
1136
      node_lvs = node_lvs.payload
1137

    
1138
      delta = all_lvs.difference(node_lvs.keys())
1139
      if delta:
1140
        raise errors.OpPrereqError("Missing logical volume(s): %s" %
1141
                                   utils.CommaJoin(delta),
1142
                                   errors.ECODE_INVAL)
1143
      online_lvs = [lv for lv in all_lvs if node_lvs[lv][2]]
1144
      if online_lvs:
1145
        raise errors.OpPrereqError("Online logical volumes found, cannot"
1146
                                   " adopt: %s" % utils.CommaJoin(online_lvs),
1147
                                   errors.ECODE_STATE)
1148
      # update the size of disk based on what is found
1149
      for dsk in self.disks:
1150
        dsk[constants.IDISK_SIZE] = \
1151
          int(float(node_lvs["%s/%s" % (dsk[constants.IDISK_VG],
1152
                                        dsk[constants.IDISK_ADOPT])][0]))
1153

    
1154
    elif self.op.disk_template == constants.DT_BLOCK:
1155
      # Normalize and de-duplicate device paths
1156
      all_disks = set([os.path.abspath(disk[constants.IDISK_ADOPT])
1157
                       for disk in self.disks])
1158
      if len(all_disks) != len(self.disks):
1159
        raise errors.OpPrereqError("Duplicate disk names given for adoption",
1160
                                   errors.ECODE_INVAL)
1161
      baddisks = [d for d in all_disks
1162
                  if not d.startswith(constants.ADOPTABLE_BLOCKDEV_ROOT)]
1163
      if baddisks:
1164
        raise errors.OpPrereqError("Device node(s) %s lie outside %s and"
1165
                                   " cannot be adopted" %
1166
                                   (utils.CommaJoin(baddisks),
1167
                                    constants.ADOPTABLE_BLOCKDEV_ROOT),
1168
                                   errors.ECODE_INVAL)
1169

    
1170
      node_disks = self.rpc.call_bdev_sizes([pnode.name],
1171
                                            list(all_disks))[pnode.name]
1172
      node_disks.Raise("Cannot get block device information from node %s" %
1173
                       pnode.name)
1174
      node_disks = node_disks.payload
1175
      delta = all_disks.difference(node_disks.keys())
1176
      if delta:
1177
        raise errors.OpPrereqError("Missing block device(s): %s" %
1178
                                   utils.CommaJoin(delta),
1179
                                   errors.ECODE_INVAL)
1180
      for dsk in self.disks:
1181
        dsk[constants.IDISK_SIZE] = \
1182
          int(float(node_disks[dsk[constants.IDISK_ADOPT]]))
1183

    
1184
    # Verify instance specs
1185
    spindle_use = self.be_full.get(constants.BE_SPINDLE_USE, None)
1186
    ispec = {
1187
      constants.ISPEC_MEM_SIZE: self.be_full.get(constants.BE_MAXMEM, None),
1188
      constants.ISPEC_CPU_COUNT: self.be_full.get(constants.BE_VCPUS, None),
1189
      constants.ISPEC_DISK_COUNT: len(self.disks),
1190
      constants.ISPEC_DISK_SIZE: [disk[constants.IDISK_SIZE]
1191
                                  for disk in self.disks],
1192
      constants.ISPEC_NIC_COUNT: len(self.nics),
1193
      constants.ISPEC_SPINDLE_USE: spindle_use,
1194
      }
1195

    
1196
    group_info = self.cfg.GetNodeGroup(pnode.group)
1197
    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster, group_info)
1198
    res = _ComputeIPolicyInstanceSpecViolation(ipolicy, ispec,
1199
                                               self.op.disk_template)
1200
    if not self.op.ignore_ipolicy and res:
1201
      msg = ("Instance allocation to group %s (%s) violates policy: %s" %
1202
             (pnode.group, group_info.name, utils.CommaJoin(res)))
1203
      raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
1204

    
1205
    CheckHVParams(self, nodenames, self.op.hypervisor, self.op.hvparams)
1206

    
1207
    CheckNodeHasOS(self, pnode.name, self.op.os_type, self.op.force_variant)
1208
    # check OS parameters (remotely)
1209
    CheckOSParams(self, True, nodenames, self.op.os_type, self.os_full)
1210

    
1211
    CheckNicsBridgesExist(self, self.nics, self.pnode.name)
1212

    
1213
    #TODO: _CheckExtParams (remotely)
1214
    # Check parameters for extstorage
1215

    
1216
    # memory check on primary node
1217
    #TODO(dynmem): use MINMEM for checking
1218
    if self.op.start:
1219
      CheckNodeFreeMemory(self, self.pnode.name,
1220
                          "creating instance %s" % self.op.instance_name,
1221
                          self.be_full[constants.BE_MAXMEM],
1222
                          self.op.hypervisor)
1223

    
1224
    self.dry_run_result = list(nodenames)
1225

    
1226
  def Exec(self, feedback_fn):
1227
    """Create and add the instance to the cluster.
1228

1229
    """
1230
    instance = self.op.instance_name
1231
    pnode_name = self.pnode.name
1232

    
1233
    assert not (self.owned_locks(locking.LEVEL_NODE_RES) -
1234
                self.owned_locks(locking.LEVEL_NODE)), \
1235
      "Node locks differ from node resource locks"
1236
    assert not self.glm.is_owned(locking.LEVEL_NODE_ALLOC)
1237

    
1238
    ht_kind = self.op.hypervisor
1239
    if ht_kind in constants.HTS_REQ_PORT:
1240
      network_port = self.cfg.AllocatePort()
1241
    else:
1242
      network_port = None
1243

    
1244
    # This is ugly but we got a chicken-egg problem here
1245
    # We can only take the group disk parameters, as the instance
1246
    # has no disks yet (we are generating them right here).
1247
    node = self.cfg.GetNodeInfo(pnode_name)
1248
    nodegroup = self.cfg.GetNodeGroup(node.group)
1249
    disks = GenerateDiskTemplate(self,
1250
                                 self.op.disk_template,
1251
                                 instance, pnode_name,
1252
                                 self.secondaries,
1253
                                 self.disks,
1254
                                 self.instance_file_storage_dir,
1255
                                 self.op.file_driver,
1256
                                 0,
1257
                                 feedback_fn,
1258
                                 self.cfg.GetGroupDiskParams(nodegroup))
1259

    
1260
    iobj = objects.Instance(name=instance, os=self.op.os_type,
1261
                            primary_node=pnode_name,
1262
                            nics=self.nics, disks=disks,
1263
                            disk_template=self.op.disk_template,
1264
                            disks_active=False,
1265
                            admin_state=constants.ADMINST_DOWN,
1266
                            network_port=network_port,
1267
                            beparams=self.op.beparams,
1268
                            hvparams=self.op.hvparams,
1269
                            hypervisor=self.op.hypervisor,
1270
                            osparams=self.op.osparams,
1271
                            )
1272

    
1273
    if self.op.tags:
1274
      for tag in self.op.tags:
1275
        iobj.AddTag(tag)
1276

    
1277
    if self.adopt_disks:
1278
      if self.op.disk_template == constants.DT_PLAIN:
1279
        # rename LVs to the newly-generated names; we need to construct
1280
        # 'fake' LV disks with the old data, plus the new unique_id
1281
        tmp_disks = [objects.Disk.FromDict(v.ToDict()) for v in disks]
1282
        rename_to = []
1283
        for t_dsk, a_dsk in zip(tmp_disks, self.disks):
1284
          rename_to.append(t_dsk.logical_id)
1285
          t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk[constants.IDISK_ADOPT])
1286
          self.cfg.SetDiskID(t_dsk, pnode_name)
1287
        result = self.rpc.call_blockdev_rename(pnode_name,
1288
                                               zip(tmp_disks, rename_to))
1289
        result.Raise("Failed to rename adoped LVs")
1290
    else:
1291
      feedback_fn("* creating instance disks...")
1292
      try:
1293
        CreateDisks(self, iobj)
1294
      except errors.OpExecError:
1295
        self.LogWarning("Device creation failed")
1296
        self.cfg.ReleaseDRBDMinors(instance)
1297
        raise
1298

    
1299
    feedback_fn("adding instance %s to cluster config" % instance)
1300

    
1301
    self.cfg.AddInstance(iobj, self.proc.GetECId())
1302

    
1303
    # Declare that we don't want to remove the instance lock anymore, as we've
1304
    # added the instance to the config
1305
    del self.remove_locks[locking.LEVEL_INSTANCE]
1306

    
1307
    if self.op.mode == constants.INSTANCE_IMPORT:
1308
      # Release unused nodes
1309
      ReleaseLocks(self, locking.LEVEL_NODE, keep=[self.op.src_node])
1310
    else:
1311
      # Release all nodes
1312
      ReleaseLocks(self, locking.LEVEL_NODE)
1313

    
1314
    disk_abort = False
1315
    if not self.adopt_disks and self.cfg.GetClusterInfo().prealloc_wipe_disks:
1316
      feedback_fn("* wiping instance disks...")
1317
      try:
1318
        WipeDisks(self, iobj)
1319
      except errors.OpExecError, err:
1320
        logging.exception("Wiping disks failed")
1321
        self.LogWarning("Wiping instance disks failed (%s)", err)
1322
        disk_abort = True
1323

    
1324
    if disk_abort:
1325
      # Something is already wrong with the disks, don't do anything else
1326
      pass
1327
    elif self.op.wait_for_sync:
1328
      disk_abort = not WaitForSync(self, iobj)
1329
    elif iobj.disk_template in constants.DTS_INT_MIRROR:
1330
      # make sure the disks are not degraded (still sync-ing is ok)
1331
      feedback_fn("* checking mirrors status")
1332
      disk_abort = not WaitForSync(self, iobj, oneshot=True)
1333
    else:
1334
      disk_abort = False
1335

    
1336
    if disk_abort:
1337
      RemoveDisks(self, iobj)
1338
      self.cfg.RemoveInstance(iobj.name)
1339
      # Make sure the instance lock gets removed
1340
      self.remove_locks[locking.LEVEL_INSTANCE] = iobj.name
1341
      raise errors.OpExecError("There are some degraded disks for"
1342
                               " this instance")
1343

    
1344
    # instance disks are now active
1345
    iobj.disks_active = True
1346

    
1347
    # Release all node resource locks
1348
    ReleaseLocks(self, locking.LEVEL_NODE_RES)
1349

    
1350
    if iobj.disk_template != constants.DT_DISKLESS and not self.adopt_disks:
1351
      # we need to set the disks ID to the primary node, since the
1352
      # preceding code might or might have not done it, depending on
1353
      # disk template and other options
1354
      for disk in iobj.disks:
1355
        self.cfg.SetDiskID(disk, pnode_name)
1356
      if self.op.mode == constants.INSTANCE_CREATE:
1357
        if not self.op.no_install:
1358
          pause_sync = (iobj.disk_template in constants.DTS_INT_MIRROR and
1359
                        not self.op.wait_for_sync)
1360
          if pause_sync:
1361
            feedback_fn("* pausing disk sync to install instance OS")
1362
            result = self.rpc.call_blockdev_pause_resume_sync(pnode_name,
1363
                                                              (iobj.disks,
1364
                                                               iobj), True)
1365
            for idx, success in enumerate(result.payload):
1366
              if not success:
1367
                logging.warn("pause-sync of instance %s for disk %d failed",
1368
                             instance, idx)
1369

    
1370
          feedback_fn("* running the instance OS create scripts...")
1371
          # FIXME: pass debug option from opcode to backend
1372
          os_add_result = \
1373
            self.rpc.call_instance_os_add(pnode_name, (iobj, None), False,
1374
                                          self.op.debug_level)
1375
          if pause_sync:
1376
            feedback_fn("* resuming disk sync")
1377
            result = self.rpc.call_blockdev_pause_resume_sync(pnode_name,
1378
                                                              (iobj.disks,
1379
                                                               iobj), False)
1380
            for idx, success in enumerate(result.payload):
1381
              if not success:
1382
                logging.warn("resume-sync of instance %s for disk %d failed",
1383
                             instance, idx)
1384

    
1385
          os_add_result.Raise("Could not add os for instance %s"
1386
                              " on node %s" % (instance, pnode_name))
1387

    
1388
      else:
1389
        if self.op.mode == constants.INSTANCE_IMPORT:
1390
          feedback_fn("* running the instance OS import scripts...")
1391

    
1392
          transfers = []
1393

    
1394
          for idx, image in enumerate(self.src_images):
1395
            if not image:
1396
              continue
1397

    
1398
            # FIXME: pass debug option from opcode to backend
1399
            dt = masterd.instance.DiskTransfer("disk/%s" % idx,
1400
                                               constants.IEIO_FILE, (image, ),
1401
                                               constants.IEIO_SCRIPT,
1402
                                               (iobj.disks[idx], idx),
1403
                                               None)
1404
            transfers.append(dt)
1405

    
1406
          import_result = \
1407
            masterd.instance.TransferInstanceData(self, feedback_fn,
1408
                                                  self.op.src_node, pnode_name,
1409
                                                  self.pnode.secondary_ip,
1410
                                                  iobj, transfers)
1411
          if not compat.all(import_result):
1412
            self.LogWarning("Some disks for instance %s on node %s were not"
1413
                            " imported successfully" % (instance, pnode_name))
1414

    
1415
          rename_from = self._old_instance_name
1416

    
1417
        elif self.op.mode == constants.INSTANCE_REMOTE_IMPORT:
1418
          feedback_fn("* preparing remote import...")
1419
          # The source cluster will stop the instance before attempting to make
1420
          # a connection. In some cases stopping an instance can take a long
1421
          # time, hence the shutdown timeout is added to the connection
1422
          # timeout.
1423
          connect_timeout = (constants.RIE_CONNECT_TIMEOUT +
1424
                             self.op.source_shutdown_timeout)
1425
          timeouts = masterd.instance.ImportExportTimeouts(connect_timeout)
1426

    
1427
          assert iobj.primary_node == self.pnode.name
1428
          disk_results = \
1429
            masterd.instance.RemoteImport(self, feedback_fn, iobj, self.pnode,
1430
                                          self.source_x509_ca,
1431
                                          self._cds, timeouts)
1432
          if not compat.all(disk_results):
1433
            # TODO: Should the instance still be started, even if some disks
1434
            # failed to import (valid for local imports, too)?
1435
            self.LogWarning("Some disks for instance %s on node %s were not"
1436
                            " imported successfully" % (instance, pnode_name))
1437

    
1438
          rename_from = self.source_instance_name
1439

    
1440
        else:
1441
          # also checked in the prereq part
1442
          raise errors.ProgrammerError("Unknown OS initialization mode '%s'"
1443
                                       % self.op.mode)
1444

    
1445
        # Run rename script on newly imported instance
1446
        assert iobj.name == instance
1447
        feedback_fn("Running rename script for %s" % instance)
1448
        result = self.rpc.call_instance_run_rename(pnode_name, iobj,
1449
                                                   rename_from,
1450
                                                   self.op.debug_level)
1451
        if result.fail_msg:
1452
          self.LogWarning("Failed to run rename script for %s on node"
1453
                          " %s: %s" % (instance, pnode_name, result.fail_msg))
1454

    
1455
    assert not self.owned_locks(locking.LEVEL_NODE_RES)
1456

    
1457
    if self.op.start:
1458
      iobj.admin_state = constants.ADMINST_UP
1459
      self.cfg.Update(iobj, feedback_fn)
1460
      logging.info("Starting instance %s on node %s", instance, pnode_name)
1461
      feedback_fn("* starting instance...")
1462
      result = self.rpc.call_instance_start(pnode_name, (iobj, None, None),
1463
                                            False, self.op.reason)
1464
      result.Raise("Could not start instance")
1465

    
1466
    return list(iobj.all_nodes)
1467

    
1468

    
1469
class LUInstanceRename(LogicalUnit):
1470
  """Rename an instance.
1471

1472
  """
1473
  HPATH = "instance-rename"
1474
  HTYPE = constants.HTYPE_INSTANCE
1475

    
1476
  def CheckArguments(self):
1477
    """Check arguments.
1478

1479
    """
1480
    if self.op.ip_check and not self.op.name_check:
1481
      # TODO: make the ip check more flexible and not depend on the name check
1482
      raise errors.OpPrereqError("IP address check requires a name check",
1483
                                 errors.ECODE_INVAL)
1484

    
1485
  def BuildHooksEnv(self):
1486
    """Build hooks env.
1487

1488
    This runs on master, primary and secondary nodes of the instance.
1489

1490
    """
1491
    env = BuildInstanceHookEnvByObject(self, self.instance)
1492
    env["INSTANCE_NEW_NAME"] = self.op.new_name
1493
    return env
1494

    
1495
  def BuildHooksNodes(self):
1496
    """Build hooks nodes.
1497

1498
    """
1499
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
1500
    return (nl, nl)
1501

    
1502
  def CheckPrereq(self):
1503
    """Check prerequisites.
1504

1505
    This checks that the instance is in the cluster and is not running.
1506

1507
    """
1508
    self.op.instance_name = ExpandInstanceName(self.cfg,
1509
                                               self.op.instance_name)
1510
    instance = self.cfg.GetInstanceInfo(self.op.instance_name)
1511
    assert instance is not None
1512
    CheckNodeOnline(self, instance.primary_node)
1513
    CheckInstanceState(self, instance, INSTANCE_NOT_RUNNING,
1514
                       msg="cannot rename")
1515
    self.instance = instance
1516

    
1517
    new_name = self.op.new_name
1518
    if self.op.name_check:
1519
      hostname = _CheckHostnameSane(self, new_name)
1520
      new_name = self.op.new_name = hostname.name
1521
      if (self.op.ip_check and
1522
          netutils.TcpPing(hostname.ip, constants.DEFAULT_NODED_PORT)):
1523
        raise errors.OpPrereqError("IP %s of instance %s already in use" %
1524
                                   (hostname.ip, new_name),
1525
                                   errors.ECODE_NOTUNIQUE)
1526

    
1527
    instance_list = self.cfg.GetInstanceList()
1528
    if new_name in instance_list and new_name != instance.name:
1529
      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
1530
                                 new_name, errors.ECODE_EXISTS)
1531

    
1532
  def Exec(self, feedback_fn):
1533
    """Rename the instance.
1534

1535
    """
1536
    inst = self.instance
1537
    old_name = inst.name
1538

    
1539
    rename_file_storage = False
1540
    if (inst.disk_template in constants.DTS_FILEBASED and
1541
        self.op.new_name != inst.name):
1542
      old_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
1543
      rename_file_storage = True
1544

    
1545
    self.cfg.RenameInstance(inst.name, self.op.new_name)
1546
    # Change the instance lock. This is definitely safe while we hold the BGL.
1547
    # Otherwise the new lock would have to be added in acquired mode.
1548
    assert self.REQ_BGL
1549
    assert locking.BGL in self.owned_locks(locking.LEVEL_CLUSTER)
1550
    self.glm.remove(locking.LEVEL_INSTANCE, old_name)
1551
    self.glm.add(locking.LEVEL_INSTANCE, self.op.new_name)
1552

    
1553
    # re-read the instance from the configuration after rename
1554
    inst = self.cfg.GetInstanceInfo(self.op.new_name)
1555

    
1556
    if rename_file_storage:
1557
      new_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])
1558
      result = self.rpc.call_file_storage_dir_rename(inst.primary_node,
1559
                                                     old_file_storage_dir,
1560
                                                     new_file_storage_dir)
1561
      result.Raise("Could not rename on node %s directory '%s' to '%s'"
1562
                   " (but the instance has been renamed in Ganeti)" %
1563
                   (inst.primary_node, old_file_storage_dir,
1564
                    new_file_storage_dir))
1565

    
1566
    StartInstanceDisks(self, inst, None)
1567
    # update info on disks
1568
    info = GetInstanceInfoText(inst)
1569
    for (idx, disk) in enumerate(inst.disks):
1570
      for node in inst.all_nodes:
1571
        self.cfg.SetDiskID(disk, node)
1572
        result = self.rpc.call_blockdev_setinfo(node, disk, info)
1573
        if result.fail_msg:
1574
          self.LogWarning("Error setting info on node %s for disk %s: %s",
1575
                          node, idx, result.fail_msg)
1576
    try:
1577
      result = self.rpc.call_instance_run_rename(inst.primary_node, inst,
1578
                                                 old_name, self.op.debug_level)
1579
      msg = result.fail_msg
1580
      if msg:
1581
        msg = ("Could not run OS rename script for instance %s on node %s"
1582
               " (but the instance has been renamed in Ganeti): %s" %
1583
               (inst.name, inst.primary_node, msg))
1584
        self.LogWarning(msg)
1585
    finally:
1586
      ShutdownInstanceDisks(self, inst)
1587

    
1588
    return inst.name
1589

    
1590

    
1591
class LUInstanceRemove(LogicalUnit):
1592
  """Remove an instance.
1593

1594
  """
1595
  HPATH = "instance-remove"
1596
  HTYPE = constants.HTYPE_INSTANCE
1597
  REQ_BGL = False
1598

    
1599
  def ExpandNames(self):
1600
    self._ExpandAndLockInstance()
1601
    self.needed_locks[locking.LEVEL_NODE] = []
1602
    self.needed_locks[locking.LEVEL_NODE_RES] = []
1603
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
1604

    
1605
  def DeclareLocks(self, level):
1606
    if level == locking.LEVEL_NODE:
1607
      self._LockInstancesNodes()
1608
    elif level == locking.LEVEL_NODE_RES:
1609
      # Copy node locks
1610
      self.needed_locks[locking.LEVEL_NODE_RES] = \
1611
        CopyLockList(self.needed_locks[locking.LEVEL_NODE])
1612

    
1613
  def BuildHooksEnv(self):
1614
    """Build hooks env.
1615

1616
    This runs on master, primary and secondary nodes of the instance.
1617

1618
    """
1619
    env = BuildInstanceHookEnvByObject(self, self.instance)
1620
    env["SHUTDOWN_TIMEOUT"] = self.op.shutdown_timeout
1621
    return env
1622

    
1623
  def BuildHooksNodes(self):
1624
    """Build hooks nodes.
1625

1626
    """
1627
    nl = [self.cfg.GetMasterNode()]
1628
    nl_post = list(self.instance.all_nodes) + nl
1629
    return (nl, nl_post)
1630

    
1631
  def CheckPrereq(self):
1632
    """Check prerequisites.
1633

1634
    This checks that the instance is in the cluster.
1635

1636
    """
1637
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
1638
    assert self.instance is not None, \
1639
      "Cannot retrieve locked instance %s" % self.op.instance_name
1640

    
1641
  def Exec(self, feedback_fn):
1642
    """Remove the instance.
1643

1644
    """
1645
    instance = self.instance
1646
    logging.info("Shutting down instance %s on node %s",
1647
                 instance.name, instance.primary_node)
1648

    
1649
    result = self.rpc.call_instance_shutdown(instance.primary_node, instance,
1650
                                             self.op.shutdown_timeout,
1651
                                             self.op.reason)
1652
    msg = result.fail_msg
1653
    if msg:
1654
      if self.op.ignore_failures:
1655
        feedback_fn("Warning: can't shutdown instance: %s" % msg)
1656
      else:
1657
        raise errors.OpExecError("Could not shutdown instance %s on"
1658
                                 " node %s: %s" %
1659
                                 (instance.name, instance.primary_node, msg))
1660

    
1661
    assert (self.owned_locks(locking.LEVEL_NODE) ==
1662
            self.owned_locks(locking.LEVEL_NODE_RES))
1663
    assert not (set(instance.all_nodes) -
1664
                self.owned_locks(locking.LEVEL_NODE)), \
1665
      "Not owning correct locks"
1666

    
1667
    RemoveInstance(self, feedback_fn, instance, self.op.ignore_failures)
1668

    
1669

    
1670
class LUInstanceMove(LogicalUnit):
1671
  """Move an instance by data-copying.
1672

1673
  """
1674
  HPATH = "instance-move"
1675
  HTYPE = constants.HTYPE_INSTANCE
1676
  REQ_BGL = False
1677

    
1678
  def ExpandNames(self):
1679
    self._ExpandAndLockInstance()
1680
    target_node = ExpandNodeName(self.cfg, self.op.target_node)
1681
    self.op.target_node = target_node
1682
    self.needed_locks[locking.LEVEL_NODE] = [target_node]
1683
    self.needed_locks[locking.LEVEL_NODE_RES] = []
1684
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND
1685

    
1686
  def DeclareLocks(self, level):
1687
    if level == locking.LEVEL_NODE:
1688
      self._LockInstancesNodes(primary_only=True)
1689
    elif level == locking.LEVEL_NODE_RES:
1690
      # Copy node locks
1691
      self.needed_locks[locking.LEVEL_NODE_RES] = \
1692
        CopyLockList(self.needed_locks[locking.LEVEL_NODE])
1693

    
1694
  def BuildHooksEnv(self):
1695
    """Build hooks env.
1696

1697
    This runs on master, primary and secondary nodes of the instance.
1698

1699
    """
1700
    env = {
1701
      "TARGET_NODE": self.op.target_node,
1702
      "SHUTDOWN_TIMEOUT": self.op.shutdown_timeout,
1703
      }
1704
    env.update(BuildInstanceHookEnvByObject(self, self.instance))
1705
    return env
1706

    
1707
  def BuildHooksNodes(self):
1708
    """Build hooks nodes.
1709

1710
    """
1711
    nl = [
1712
      self.cfg.GetMasterNode(),
1713
      self.instance.primary_node,
1714
      self.op.target_node,
1715
      ]
1716
    return (nl, nl)
1717

    
1718
  def CheckPrereq(self):
1719
    """Check prerequisites.
1720

1721
    This checks that the instance is in the cluster.
1722

1723
    """
1724
    self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)
1725
    assert self.instance is not None, \
1726
      "Cannot retrieve locked instance %s" % self.op.instance_name
1727

    
1728
    if instance.disk_template not in constants.DTS_COPYABLE:
1729
      raise errors.OpPrereqError("Disk template %s not suitable for copying" %
1730
                                 instance.disk_template, errors.ECODE_STATE)
1731

    
1732
    node = self.cfg.GetNodeInfo(self.op.target_node)
1733
    assert node is not None, \
1734
      "Cannot retrieve locked node %s" % self.op.target_node
1735

    
1736
    self.target_node = target_node = node.name
1737

    
1738
    if target_node == instance.primary_node:
1739
      raise errors.OpPrereqError("Instance %s is already on the node %s" %
1740
                                 (instance.name, target_node),
1741
                                 errors.ECODE_STATE)
1742

    
1743
    bep = self.cfg.GetClusterInfo().FillBE(instance)
1744

    
1745
    for idx, dsk in enumerate(instance.disks):
1746
      if dsk.dev_type not in (constants.LD_LV, constants.LD_FILE):
1747
        raise errors.OpPrereqError("Instance disk %d has a complex layout,"
1748
                                   " cannot copy" % idx, errors.ECODE_STATE)
1749

    
1750
    CheckNodeOnline(self, target_node)
1751
    CheckNodeNotDrained(self, target_node)
1752
    CheckNodeVmCapable(self, target_node)
1753
    cluster = self.cfg.GetClusterInfo()
1754
    group_info = self.cfg.GetNodeGroup(node.group)
1755
    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster, group_info)
1756
    CheckTargetNodeIPolicy(self, ipolicy, instance, node, self.cfg,
1757
                           ignore=self.op.ignore_ipolicy)
1758

    
1759
    if instance.admin_state == constants.ADMINST_UP:
1760
      # check memory requirements on the secondary node
1761
      CheckNodeFreeMemory(self, target_node,
1762
                          "failing over instance %s" %
1763
                          instance.name, bep[constants.BE_MAXMEM],
1764
                          instance.hypervisor)
1765
    else:
1766
      self.LogInfo("Not checking memory on the secondary node as"
1767
                   " instance will not be started")
1768

    
1769
    # check bridge existance
1770
    CheckInstanceBridgesExist(self, instance, node=target_node)
1771

    
1772
  def Exec(self, feedback_fn):
1773
    """Move an instance.
1774

1775
    The move is done by shutting it down on its present node, copying
1776
    the data over (slow) and starting it on the new node.
1777

1778
    """
1779
    instance = self.instance
1780

    
1781
    source_node = instance.primary_node
1782
    target_node = self.target_node
1783

    
1784
    self.LogInfo("Shutting down instance %s on source node %s",
1785
                 instance.name, source_node)
1786

    
1787
    assert (self.owned_locks(locking.LEVEL_NODE) ==
1788
            self.owned_locks(locking.LEVEL_NODE_RES))
1789

    
1790
    result = self.rpc.call_instance_shutdown(source_node, instance,
1791
                                             self.op.shutdown_timeout,
1792
                                             self.op.reason)
1793
    msg = result.fail_msg
1794
    if msg:
1795
      if self.op.ignore_consistency:
1796
        self.LogWarning("Could not shutdown instance %s on node %s."
1797
                        " Proceeding anyway. Please make sure node"
1798
                        " %s is down. Error details: %s",
1799
                        instance.name, source_node, source_node, msg)
1800
      else:
1801
        raise errors.OpExecError("Could not shutdown instance %s on"
1802
                                 " node %s: %s" %
1803
                                 (instance.name, source_node, msg))
1804

    
1805
    # create the target disks
1806
    try:
1807
      CreateDisks(self, instance, target_node=target_node)
1808
    except errors.OpExecError:
1809
      self.LogWarning("Device creation failed")
1810
      self.cfg.ReleaseDRBDMinors(instance.name)
1811
      raise
1812

    
1813
    cluster_name = self.cfg.GetClusterInfo().cluster_name
1814

    
1815
    errs = []
1816
    # activate, get path, copy the data over
1817
    for idx, disk in enumerate(instance.disks):
1818
      self.LogInfo("Copying data for disk %d", idx)
1819
      result = self.rpc.call_blockdev_assemble(target_node, (disk, instance),
1820
                                               instance.name, True, idx)
1821
      if result.fail_msg:
1822
        self.LogWarning("Can't assemble newly created disk %d: %s",
1823
                        idx, result.fail_msg)
1824
        errs.append(result.fail_msg)
1825
        break
1826
      dev_path = result.payload
1827
      result = self.rpc.call_blockdev_export(source_node, (disk, instance),
1828
                                             target_node, dev_path,
1829
                                             cluster_name)
1830
      if result.fail_msg:
1831
        self.LogWarning("Can't copy data over for disk %d: %s",
1832
                        idx, result.fail_msg)
1833
        errs.append(result.fail_msg)
1834
        break
1835

    
1836
    if errs:
1837
      self.LogWarning("Some disks failed to copy, aborting")
1838
      try:
1839
        RemoveDisks(self, instance, target_node=target_node)
1840
      finally:
1841
        self.cfg.ReleaseDRBDMinors(instance.name)
1842
        raise errors.OpExecError("Errors during disk copy: %s" %
1843
                                 (",".join(errs),))
1844

    
1845
    instance.primary_node = target_node
1846
    self.cfg.Update(instance, feedback_fn)
1847

    
1848
    self.LogInfo("Removing the disks on the original node")
1849
    RemoveDisks(self, instance, target_node=source_node)
1850

    
1851
    # Only start the instance if it's marked as up
1852
    if instance.admin_state == constants.ADMINST_UP:
1853
      self.LogInfo("Starting instance %s on node %s",
1854
                   instance.name, target_node)
1855

    
1856
      disks_ok, _ = AssembleInstanceDisks(self, instance,
1857
                                          ignore_secondaries=True)
1858
      if not disks_ok:
1859
        ShutdownInstanceDisks(self, instance)
1860
        raise errors.OpExecError("Can't activate the instance's disks")
1861

    
1862
      result = self.rpc.call_instance_start(target_node,
1863
                                            (instance, None, None), False,
1864
                                            self.op.reason)
1865
      msg = result.fail_msg
1866
      if msg:
1867
        ShutdownInstanceDisks(self, instance)
1868
        raise errors.OpExecError("Could not start instance %s on node %s: %s" %
1869
                                 (instance.name, target_node, msg))
1870

    
1871

    
1872
class LUInstanceMultiAlloc(NoHooksLU):
1873
  """Allocates multiple instances at the same time.
1874

1875
  """
1876
  REQ_BGL = False
1877

    
1878
  def CheckArguments(self):
1879
    """Check arguments.
1880

1881
    """
1882
    nodes = []
1883
    for inst in self.op.instances:
1884
      if inst.iallocator is not None:
1885
        raise errors.OpPrereqError("iallocator are not allowed to be set on"
1886
                                   " instance objects", errors.ECODE_INVAL)
1887
      nodes.append(bool(inst.pnode))
1888
      if inst.disk_template in constants.DTS_INT_MIRROR:
1889
        nodes.append(bool(inst.snode))
1890

    
1891
    has_nodes = compat.any(nodes)
1892
    if compat.all(nodes) ^ has_nodes:
1893
      raise errors.OpPrereqError("There are instance objects providing"
1894
                                 " pnode/snode while others do not",
1895
                                 errors.ECODE_INVAL)
1896

    
1897
    if not has_nodes and self.op.iallocator is None:
1898
      default_iallocator = self.cfg.GetDefaultIAllocator()
1899
      if default_iallocator:
1900
        self.op.iallocator = default_iallocator
1901
      else:
1902
        raise errors.OpPrereqError("No iallocator or nodes on the instances"
1903
                                   " given and no cluster-wide default"
1904
                                   " iallocator found; please specify either"
1905
                                   " an iallocator or nodes on the instances"
1906
                                   " or set a cluster-wide default iallocator",
1907
                                   errors.ECODE_INVAL)
1908

    
1909
    _CheckOpportunisticLocking(self.op)
1910

    
1911
    dups = utils.FindDuplicates([op.instance_name for op in self.op.instances])
1912
    if dups:
1913
      raise errors.OpPrereqError("There are duplicate instance names: %s" %
1914
                                 utils.CommaJoin(dups), errors.ECODE_INVAL)
1915

    
1916
  def ExpandNames(self):
1917
    """Calculate the locks.
1918

1919
    """
1920
    self.share_locks = ShareAll()
1921
    self.needed_locks = {
1922
      # iallocator will select nodes and even if no iallocator is used,
1923
      # collisions with LUInstanceCreate should be avoided
1924
      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
1925
      }
1926

    
1927
    if self.op.iallocator:
1928
      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
1929
      self.needed_locks[locking.LEVEL_NODE_RES] = locking.ALL_SET
1930

    
1931
      if self.op.opportunistic_locking:
1932
        self.opportunistic_locks[locking.LEVEL_NODE] = True
1933
    else:
1934
      nodeslist = []
1935
      for inst in self.op.instances:
1936
        inst.pnode = ExpandNodeName(self.cfg, inst.pnode)
1937
        nodeslist.append(inst.pnode)
1938
        if inst.snode is not None:
1939
          inst.snode = ExpandNodeName(self.cfg, inst.snode)
1940
          nodeslist.append(inst.snode)
1941

    
1942
      self.needed_locks[locking.LEVEL_NODE] = nodeslist
1943
      # Lock resources of instance's primary and secondary nodes (copy to
1944
      # prevent accidential modification)
1945
      self.needed_locks[locking.LEVEL_NODE_RES] = list(nodeslist)
1946

    
1947
  def DeclareLocks(self, level):
1948
    if level == locking.LEVEL_NODE_RES and \
1949
      self.opportunistic_locks[locking.LEVEL_NODE]:
1950
      # Even when using opportunistic locking, we require the same set of
1951
      # NODE_RES locks as we got NODE locks
1952
      self.needed_locks[locking.LEVEL_NODE_RES] = \
1953
        self.owned_locks(locking.LEVEL_NODE)
1954

    
1955
  def CheckPrereq(self):
1956
    """Check prerequisite.
1957

1958
    """
1959
    if self.op.iallocator:
1960
      cluster = self.cfg.GetClusterInfo()
1961
      default_vg = self.cfg.GetVGName()
1962
      ec_id = self.proc.GetECId()
1963

    
1964
      if self.op.opportunistic_locking:
1965
        # Only consider nodes for which a lock is held
1966
        node_whitelist = list(self.owned_locks(locking.LEVEL_NODE))
1967
      else:
1968
        node_whitelist = None
1969

    
1970
      insts = [_CreateInstanceAllocRequest(op, ComputeDisks(op, default_vg),
1971
                                           _ComputeNics(op, cluster, None,
1972
                                                        self.cfg, ec_id),
1973
                                           _ComputeFullBeParams(op, cluster),
1974
                                           node_whitelist)
1975
               for op in self.op.instances]
1976

    
1977
      req = iallocator.IAReqMultiInstanceAlloc(instances=insts)
1978
      ial = iallocator.IAllocator(self.cfg, self.rpc, req)
1979

    
1980
      ial.Run(self.op.iallocator)
1981

    
1982
      if not ial.success:
1983
        raise errors.OpPrereqError("Can't compute nodes using"
1984
                                   " iallocator '%s': %s" %
1985
                                   (self.op.iallocator, ial.info),
1986
                                   errors.ECODE_NORES)
1987

    
1988
      self.ia_result = ial.result
1989

    
1990
    if self.op.dry_run:
1991
      self.dry_run_result = objects.FillDict(self._ConstructPartialResult(), {
1992
        constants.JOB_IDS_KEY: [],
1993
        })
1994

    
1995
  def _ConstructPartialResult(self):
1996
    """Contructs the partial result.
1997

1998
    """
1999
    if self.op.iallocator:
2000
      (allocatable, failed_insts) = self.ia_result
2001
      allocatable_insts = map(compat.fst, allocatable)
2002
    else:
2003
      allocatable_insts = [op.instance_name for op in self.op.instances]
2004
      failed_insts = []
2005

    
2006
    return {
2007
      opcodes.OpInstanceMultiAlloc.ALLOCATABLE_KEY: allocatable_insts,
2008
      opcodes.OpInstanceMultiAlloc.FAILED_KEY: failed_insts,
2009
      }
2010

    
2011
  def Exec(self, feedback_fn):
2012
    """Executes the opcode.
2013

2014
    """
2015
    jobs = []
2016
    if self.op.iallocator:
2017
      op2inst = dict((op.instance_name, op) for op in self.op.instances)
2018
      (allocatable, failed) = self.ia_result
2019

    
2020
      for (name, nodes) in allocatable:
2021
        op = op2inst.pop(name)
2022

    
2023
        if len(nodes) > 1:
2024
          (op.pnode, op.snode) = nodes
2025
        else:
2026
          (op.pnode,) = nodes
2027

    
2028
        jobs.append([op])
2029

    
2030
      missing = set(op2inst.keys()) - set(failed)
2031
      assert not missing, \
2032
        "Iallocator did return incomplete result: %s" % \
2033
        utils.CommaJoin(missing)
2034
    else:
2035
      jobs.extend([op] for op in self.op.instances)
2036

    
2037
    return ResultWithJobs(jobs, **self._ConstructPartialResult())
2038

    
2039

    
2040
class _InstNicModPrivate:
2041
  """Data structure for network interface modifications.
2042

2043
  Used by L{LUInstanceSetParams}.
2044

2045
  """
2046
  def __init__(self):
2047
    self.params = None
2048
    self.filled = None
2049

    
2050

    
2051
def _PrepareContainerMods(mods, private_fn):
2052
  """Prepares a list of container modifications by adding a private data field.
2053

2054
  @type mods: list of tuples; (operation, index, parameters)
2055
  @param mods: List of modifications
2056
  @type private_fn: callable or None
2057
  @param private_fn: Callable for constructing a private data field for a
2058
    modification
2059
  @rtype: list
2060

2061
  """
2062
  if private_fn is None:
2063
    fn = lambda: None
2064
  else:
2065
    fn = private_fn
2066

    
2067
  return [(op, idx, params, fn()) for (op, idx, params) in mods]
2068

    
2069

    
2070
def _CheckNodesPhysicalCPUs(lu, nodenames, requested, hypervisor_name):
2071
  """Checks if nodes have enough physical CPUs
2072

2073
  This function checks if all given nodes have the needed number of
2074
  physical CPUs. In case any node has less CPUs or we cannot get the
2075
  information from the node, this function raises an OpPrereqError
2076
  exception.
2077

2078
  @type lu: C{LogicalUnit}
2079
  @param lu: a logical unit from which we get configuration data
2080
  @type nodenames: C{list}
2081
  @param nodenames: the list of node names to check
2082
  @type requested: C{int}
2083
  @param requested: the minimum acceptable number of physical CPUs
2084
  @raise errors.OpPrereqError: if the node doesn't have enough CPUs,
2085
      or we cannot check the node
2086

2087
  """
2088
  nodeinfo = lu.rpc.call_node_info(nodenames, None, [hypervisor_name], None)
2089
  for node in nodenames:
2090
    info = nodeinfo[node]
2091
    info.Raise("Cannot get current information from node %s" % node,
2092
               prereq=True, ecode=errors.ECODE_ENVIRON)
2093
    (_, _, (hv_info, )) = info.payload
2094
    num_cpus = hv_info.get("cpu_total", None)
2095
    if not isinstance(num_cpus, int):
2096
      raise errors.OpPrereqError("Can't compute the number of physical CPUs"
2097
                                 " on node %s, result was '%s'" %
2098
                                 (node, num_cpus), errors.ECODE_ENVIRON)
2099
    if requested > num_cpus:
2100
      raise errors.OpPrereqError("Node %s has %s physical CPUs, but %s are "
2101
                                 "required" % (node, num_cpus, requested),
2102
                                 errors.ECODE_NORES)
2103

    
2104

    
2105
def GetItemFromContainer(identifier, kind, container):
2106
  """Return the item refered by the identifier.
2107

2108
  @type identifier: string
2109
  @param identifier: Item index or name or UUID
2110
  @type kind: string
2111
  @param kind: One-word item description
2112
  @type container: list
2113
  @param container: Container to get the item from
2114

2115
  """
2116
  # Index
2117
  try:
2118
    idx = int(identifier)
2119
    if idx == -1:
2120
      # Append
2121
      absidx = len(container) - 1
2122
    elif idx < 0:
2123
      raise IndexError("Not accepting negative indices other than -1")
2124
    elif idx > len(container):
2125
      raise IndexError("Got %s index %s, but there are only %s" %
2126
                       (kind, idx, len(container)))
2127
    else:
2128
      absidx = idx
2129
    return (absidx, container[idx])
2130
  except ValueError:
2131
    pass
2132

    
2133
  for idx, item in enumerate(container):
2134
    if item.uuid == identifier or item.name == identifier:
2135
      return (idx, item)
2136

    
2137
  raise errors.OpPrereqError("Cannot find %s with identifier %s" %
2138
                             (kind, identifier), errors.ECODE_NOENT)
2139

    
2140

    
2141
def _ApplyContainerMods(kind, container, chgdesc, mods,
2142
                        create_fn, modify_fn, remove_fn):
2143
  """Applies descriptions in C{mods} to C{container}.
2144

2145
  @type kind: string
2146
  @param kind: One-word item description
2147
  @type container: list
2148
  @param container: Container to modify
2149
  @type chgdesc: None or list
2150
  @param chgdesc: List of applied changes
2151
  @type mods: list
2152
  @param mods: Modifications as returned by L{_PrepareContainerMods}
2153
  @type create_fn: callable
2154
  @param create_fn: Callback for creating a new item (L{constants.DDM_ADD});
2155
    receives absolute item index, parameters and private data object as added
2156
    by L{_PrepareContainerMods}, returns tuple containing new item and changes
2157
    as list
2158
  @type modify_fn: callable
2159
  @param modify_fn: Callback for modifying an existing item
2160
    (L{constants.DDM_MODIFY}); receives absolute item index, item, parameters
2161
    and private data object as added by L{_PrepareContainerMods}, returns
2162
    changes as list
2163
  @type remove_fn: callable
2164
  @param remove_fn: Callback on removing item; receives absolute item index,
2165
    item and private data object as added by L{_PrepareContainerMods}
2166

2167
  """
2168
  for (op, identifier, params, private) in mods:
2169
    changes = None
2170

    
2171
    if op == constants.DDM_ADD:
2172
      # Calculate where item will be added
2173
      # When adding an item, identifier can only be an index
2174
      try:
2175
        idx = int(identifier)
2176
      except ValueError:
2177
        raise errors.OpPrereqError("Only possitive integer or -1 is accepted as"
2178
                                   " identifier for %s" % constants.DDM_ADD,
2179
                                   errors.ECODE_INVAL)
2180
      if idx == -1:
2181
        addidx = len(container)
2182
      else:
2183
        if idx < 0:
2184
          raise IndexError("Not accepting negative indices other than -1")
2185
        elif idx > len(container):
2186
          raise IndexError("Got %s index %s, but there are only %s" %
2187
                           (kind, idx, len(container)))
2188
        addidx = idx
2189

    
2190
      if create_fn is None:
2191
        item = params
2192
      else:
2193
        (item, changes) = create_fn(addidx, params, private)
2194

    
2195
      if idx == -1:
2196
        container.append(item)
2197
      else:
2198
        assert idx >= 0
2199
        assert idx <= len(container)
2200
        # list.insert does so before the specified index
2201
        container.insert(idx, item)
2202
    else:
2203
      # Retrieve existing item
2204
      (absidx, item) = GetItemFromContainer(identifier, kind, container)
2205

    
2206
      if op == constants.DDM_REMOVE:
2207
        assert not params
2208

    
2209
        if remove_fn is not None:
2210
          remove_fn(absidx, item, private)
2211

    
2212
        changes = [("%s/%s" % (kind, absidx), "remove")]
2213

    
2214
        assert container[absidx] == item
2215
        del container[absidx]
2216
      elif op == constants.DDM_MODIFY:
2217
        if modify_fn is not None:
2218
          changes = modify_fn(absidx, item, params, private)
2219
      else:
2220
        raise errors.ProgrammerError("Unhandled operation '%s'" % op)
2221

    
2222
    assert _TApplyContModsCbChanges(changes)
2223

    
2224
    if not (chgdesc is None or changes is None):
2225
      chgdesc.extend(changes)
2226

    
2227

    
2228
def _UpdateIvNames(base_index, disks):
2229
  """Updates the C{iv_name} attribute of disks.
2230

2231
  @type disks: list of L{objects.Disk}
2232

2233
  """
2234
  for (idx, disk) in enumerate(disks):
2235
    disk.iv_name = "disk/%s" % (base_index + idx, )
2236

    
2237

    
2238
class LUInstanceSetParams(LogicalUnit):
2239
  """Modifies an instances's parameters.
2240

2241
  """
2242
  HPATH = "instance-modify"
2243
  HTYPE = constants.HTYPE_INSTANCE
2244
  REQ_BGL = False
2245

    
2246
  @staticmethod
2247
  def _UpgradeDiskNicMods(kind, mods, verify_fn):
2248
    assert ht.TList(mods)
2249
    assert not mods or len(mods[0]) in (2, 3)
2250

    
2251
    if mods and len(mods[0]) == 2:
2252
      result = []
2253

    
2254
      addremove = 0
2255
      for op, params in mods:
2256
        if op in (constants.DDM_ADD, constants.DDM_REMOVE):
2257
          result.append((op, -1, params))
2258
          addremove += 1
2259

    
2260
          if addremove > 1:
2261
            raise errors.OpPrereqError("Only one %s add or remove operation is"
2262
                                       " supported at a time" % kind,
2263
                                       errors.ECODE_INVAL)
2264
        else:
2265
          result.append((constants.DDM_MODIFY, op, params))
2266

    
2267
      assert verify_fn(result)
2268
    else:
2269
      result = mods
2270

    
2271
    return result
2272

    
2273
  @staticmethod
2274
  def _CheckMods(kind, mods, key_types, item_fn):
2275
    """Ensures requested disk/NIC modifications are valid.
2276

2277
    """
2278
    for (op, _, params) in mods:
2279
      assert ht.TDict(params)
2280

    
2281
      # If 'key_types' is an empty dict, we assume we have an
2282
      # 'ext' template and thus do not ForceDictType
2283
      if key_types:
2284
        utils.ForceDictType(params, key_types)
2285

    
2286
      if op == constants.DDM_REMOVE:
2287
        if params:
2288
          raise errors.OpPrereqError("No settings should be passed when"
2289
                                     " removing a %s" % kind,
2290
                                     errors.ECODE_INVAL)
2291
      elif op in (constants.DDM_ADD, constants.DDM_MODIFY):
2292
        item_fn(op, params)
2293
      else:
2294
        raise errors.ProgrammerError("Unhandled operation '%s'" % op)
2295

    
2296
  def _VerifyDiskModification(self, op, params):
2297
    """Verifies a disk modification.
2298

2299
    """
2300
    if op == constants.DDM_ADD:
2301
      mode = params.setdefault(constants.IDISK_MODE, constants.DISK_RDWR)
2302
      if mode not in constants.DISK_ACCESS_SET:
2303
        raise errors.OpPrereqError("Invalid disk access mode '%s'" % mode,
2304
                                   errors.ECODE_INVAL)
2305

    
2306
      size = params.get(constants.IDISK_SIZE, None)
2307
      if size is None:
2308
        raise errors.OpPrereqError("Required disk parameter '%s' missing" %
2309
                                   constants.IDISK_SIZE, errors.ECODE_INVAL)
2310

    
2311
      try:
2312
        size = int(size)
2313
      except (TypeError, ValueError), err:
2314
        raise errors.OpPrereqError("Invalid disk size parameter: %s" % err,
2315
                                   errors.ECODE_INVAL)
2316

    
2317
      params[constants.IDISK_SIZE] = size
2318
      name = params.get(constants.IDISK_NAME, None)
2319
      if name is not None and name.lower() == constants.VALUE_NONE:
2320
        params[constants.IDISK_NAME] = None
2321

    
2322
    elif op == constants.DDM_MODIFY:
2323
      if constants.IDISK_SIZE in params:
2324
        raise errors.OpPrereqError("Disk size change not possible, use"
2325
                                   " grow-disk", errors.ECODE_INVAL)
2326

    
2327
      # Disk modification supports changing only the disk name and mode.
2328
      # Changing arbitrary parameters is allowed only for ext disk template",
2329
      if self.instance.disk_template != constants.DT_EXT:
2330
        utils.ForceDictType(params, constants.MODIFIABLE_IDISK_PARAMS_TYPES)
2331

    
2332
      name = params.get(constants.IDISK_NAME, None)
2333
      if name is not None and name.lower() == constants.VALUE_NONE:
2334
        params[constants.IDISK_NAME] = None
2335

    
2336
  @staticmethod
2337
  def _VerifyNicModification(op, params):
2338
    """Verifies a network interface modification.
2339

2340
    """
2341
    if op in (constants.DDM_ADD, constants.DDM_MODIFY):
2342
      ip = params.get(constants.INIC_IP, None)
2343
      name = params.get(constants.INIC_NAME, None)
2344
      req_net = params.get(constants.INIC_NETWORK, None)
2345
      link = params.get(constants.NIC_LINK, None)
2346
      mode = params.get(constants.NIC_MODE, None)
2347
      if name is not None and name.lower() == constants.VALUE_NONE:
2348
        params[constants.INIC_NAME] = None
2349
      if req_net is not None:
2350
        if req_net.lower() == constants.VALUE_NONE:
2351
          params[constants.INIC_NETWORK] = None
2352
          req_net = None
2353
        elif link is not None or mode is not None:
2354
          raise errors.OpPrereqError("If network is given"
2355
                                     " mode or link should not",
2356
                                     errors.ECODE_INVAL)
2357

    
2358
      if op == constants.DDM_ADD:
2359
        macaddr = params.get(constants.INIC_MAC, None)
2360
        if macaddr is None:
2361
          params[constants.INIC_MAC] = constants.VALUE_AUTO
2362

    
2363
      if ip is not None:
2364
        if ip.lower() == constants.VALUE_NONE:
2365
          params[constants.INIC_IP] = None
2366
        else:
2367
          if ip.lower() == constants.NIC_IP_POOL:
2368
            if op == constants.DDM_ADD and req_net is None:
2369
              raise errors.OpPrereqError("If ip=pool, parameter network"
2370
                                         " cannot be none",
2371
                                         errors.ECODE_INVAL)
2372
          else:
2373
            if not netutils.IPAddress.IsValid(ip):
2374
              raise errors.OpPrereqError("Invalid IP address '%s'" % ip,
2375
                                         errors.ECODE_INVAL)
2376

    
2377
      if constants.INIC_MAC in params:
2378
        macaddr = params[constants.INIC_MAC]
2379
        if macaddr not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):
2380
          macaddr = utils.NormalizeAndValidateMac(macaddr)
2381

    
2382
        if op == constants.DDM_MODIFY and macaddr == constants.VALUE_AUTO:
2383
          raise errors.OpPrereqError("'auto' is not a valid MAC address when"
2384
                                     " modifying an existing NIC",
2385
                                     errors.ECODE_INVAL)
2386

    
2387
  def CheckArguments(self):
2388
    if not (self.op.nics or self.op.disks or self.op.disk_template or
2389
            self.op.hvparams or self.op.beparams or self.op.os_name or
2390
            self.op.osparams or self.op.offline is not None or
2391
            self.op.runtime_mem or self.op.pnode):
2392
      raise errors.OpPrereqError("No changes submitted", errors.ECODE_INVAL)
2393

    
2394
    if self.op.hvparams:
2395
      CheckParamsNotGlobal(self.op.hvparams, constants.HVC_GLOBALS,
2396
                           "hypervisor", "instance", "cluster")
2397

    
2398
    self.op.disks = self._UpgradeDiskNicMods(
2399
      "disk", self.op.disks, opcodes.OpInstanceSetParams.TestDiskModifications)
2400
    self.op.nics = self._UpgradeDiskNicMods(
2401
      "NIC", self.op.nics, opcodes.OpInstanceSetParams.TestNicModifications)
2402

    
2403
    if self.op.disks and self.op.disk_template is not None:
2404
      raise errors.OpPrereqError("Disk template conversion and other disk"
2405
                                 " changes not supported at the same time",
2406
                                 errors.ECODE_INVAL)
2407

    
2408
    if (self.op.disk_template and
2409
        self.op.disk_template in constants.DTS_INT_MIRROR and
2410
        self.op.remote_node is None):
2411
      raise errors.OpPrereqError("Changing the disk template to a mirrored"
2412
                                 " one requires specifying a secondary node",
2413
                                 errors.ECODE_INVAL)
2414

    
2415
    # Check NIC modifications
2416
    self._CheckMods("NIC", self.op.nics, constants.INIC_PARAMS_TYPES,
2417
                    self._VerifyNicModification)
2418

    
2419
    if self.op.pnode:
2420
      self.op.pnode = ExpandNodeName(self.cfg, self.op.pnode)
2421

    
2422
  def ExpandNames(self):
2423
    self._ExpandAndLockInstance()
2424
    self.needed_locks[locking.LEVEL_NODEGROUP] = []
2425
    # Can't even acquire node locks in shared mode as upcoming changes in
2426
    # Ganeti 2.6 will start to modify the node object on disk conversion
2427
    self.needed_locks[locking.LEVEL_NODE] = []
2428
    self.needed_locks[locking.LEVEL_NODE_RES] = []
2429
    self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_REPLACE
2430
    # Look node group to look up the ipolicy
2431
    self.share_locks[locking.LEVEL_NODEGROUP] = 1
2432

    
2433
  def DeclareLocks(self, level):
2434
    if level == locking.LEVEL_NODEGROUP:
2435
      assert not self.needed_locks[locking.LEVEL_NODEGROUP]
2436
      # Acquire locks for the instance's nodegroups optimistically. Needs
2437
      # to be verified in CheckPrereq
2438
      self.needed_locks[locking.LEVEL_NODEGROUP] = \
2439
        self.cfg.GetInstanceNodeGroups(self.op.instance_name)
2440
    elif level == locking.LEVEL_NODE:
2441
      self._LockInstancesNodes()
2442
      if self.op.disk_template and self.op.remote_node:
2443
        self.op.remote_node = ExpandNodeName(self.cfg, self.op.remote_node)
2444
        self.needed_locks[locking.LEVEL_NODE].append(self.op.remote_node)
2445
    elif level == locking.LEVEL_NODE_RES and self.op.disk_template:
2446
      # Copy node locks
2447
      self.needed_locks[locking.LEVEL_NODE_RES] = \
2448
        CopyLockList(self.needed_locks[locking.LEVEL_NODE])
2449

    
2450
  def BuildHooksEnv(self):
2451
    """Build hooks env.
2452

2453
    This runs on the master, primary and secondaries.
2454

2455
    """
2456
    args = {}
2457
    if constants.BE_MINMEM in self.be_new:
2458
      args["minmem"] = self.be_new[constants.BE_MINMEM]
2459
    if constants.BE_MAXMEM in self.be_new:
2460
      args["maxmem"] = self.be_new[constants.BE_MAXMEM]
2461
    if constants.BE_VCPUS in self.be_new:
2462
      args["vcpus"] = self.be_new[constants.BE_VCPUS]
2463
    # TODO: export disk changes. Note: _BuildInstanceHookEnv* don't export disk
2464
    # information at all.
2465

    
2466
    if self._new_nics is not None:
2467
      nics = []
2468

    
2469
      for nic in self._new_nics:
2470
        n = copy.deepcopy(nic)
2471
        nicparams = self.cluster.SimpleFillNIC(n.nicparams)
2472
        n.nicparams = nicparams
2473
        nics.append(NICToTuple(self, n))
2474

    
2475
      args["nics"] = nics
2476

    
2477
    env = BuildInstanceHookEnvByObject(self, self.instance, override=args)
2478
    if self.op.disk_template:
2479
      env["NEW_DISK_TEMPLATE"] = self.op.disk_template
2480
    if self.op.runtime_mem:
2481
      env["RUNTIME_MEMORY"] = self.op.runtime_mem
2482

    
2483
    return env
2484

    
2485
  def BuildHooksNodes(self):
2486
    """Build hooks nodes.
2487

2488
    """
2489
    nl = [self.cfg.GetMasterNode()] + list(self.instance.all_nodes)
2490
    return (nl, nl)
2491

    
2492
  def _PrepareNicModification(self, params, private, old_ip, old_net_uuid,
2493
                              old_params, cluster, pnode):
2494

    
2495
    update_params_dict = dict([(key, params[key])
2496
                               for key in constants.NICS_PARAMETERS
2497
                               if key in params])
2498

    
2499
    req_link = update_params_dict.get(constants.NIC_LINK, None)
2500
    req_mode = update_params_dict.get(constants.NIC_MODE, None)
2501

    
2502
    new_net_uuid = None
2503
    new_net_uuid_or_name = params.get(constants.INIC_NETWORK, old_net_uuid)
2504
    if new_net_uuid_or_name:
2505
      new_net_uuid = self.cfg.LookupNetwork(new_net_uuid_or_name)
2506
      new_net_obj = self.cfg.GetNetwork(new_net_uuid)
2507

    
2508
    if old_net_uuid:
2509
      old_net_obj = self.cfg.GetNetwork(old_net_uuid)
2510

    
2511
    if new_net_uuid:
2512
      netparams = self.cfg.GetGroupNetParams(new_net_uuid, pnode)
2513
      if not netparams:
2514
        raise errors.OpPrereqError("No netparams found for the network"
2515
                                   " %s, probably not connected" %
2516
                                   new_net_obj.name, errors.ECODE_INVAL)
2517
      new_params = dict(netparams)
2518
    else:
2519
      new_params = GetUpdatedParams(old_params, update_params_dict)
2520

    
2521
    utils.ForceDictType(new_params, constants.NICS_PARAMETER_TYPES)
2522

    
2523
    new_filled_params = cluster.SimpleFillNIC(new_params)
2524
    objects.NIC.CheckParameterSyntax(new_filled_params)
2525

    
2526
    new_mode = new_filled_params[constants.NIC_MODE]
2527
    if new_mode == constants.NIC_MODE_BRIDGED:
2528
      bridge = new_filled_params[constants.NIC_LINK]
2529
      msg = self.rpc.call_bridges_exist(pnode, [bridge]).fail_msg
2530
      if msg:
2531
        msg = "Error checking bridges on node '%s': %s" % (pnode, msg)
2532
        if self.op.force:
2533
          self.warn.append(msg)
2534
        else:
2535
          raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON)
2536

    
2537
    elif new_mode == constants.NIC_MODE_ROUTED:
2538
      ip = params.get(constants.INIC_IP, old_ip)
2539
      if ip is None:
2540
        raise errors.OpPrereqError("Cannot set the NIC IP address to None"
2541
                                   " on a routed NIC", errors.ECODE_INVAL)
2542

    
2543
    elif new_mode == constants.NIC_MODE_OVS:
2544
      # TODO: check OVS link
2545
      self.LogInfo("OVS links are currently not checked for correctness")
2546

    
2547
    if constants.INIC_MAC in params:
2548
      mac = params[constants.INIC_MAC]
2549
      if mac is None:
2550
        raise errors.OpPrereqError("Cannot unset the NIC MAC address",
2551
                                   errors.ECODE_INVAL)
2552
      elif mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE):
2553
        # otherwise generate the MAC address
2554
        params[constants.INIC_MAC] = \
2555
          self.cfg.GenerateMAC(new_net_uuid, self.proc.GetECId())
2556
      else:
2557
        # or validate/reserve the current one
2558
        try:
2559
          self.cfg.ReserveMAC(mac, self.proc.GetECId())
2560
        except errors.ReservationError:
2561
          raise errors.OpPrereqError("MAC address '%s' already in use"
2562
                                     " in cluster" % mac,
2563
                                     errors.ECODE_NOTUNIQUE)
2564
    elif new_net_uuid != old_net_uuid:
2565

    
2566
      def get_net_prefix(net_uuid):
2567
        mac_prefix = None
2568
        if net_uuid:
2569
          nobj = self.cfg.GetNetwork(net_uuid)
2570
          mac_prefix = nobj.mac_prefix
2571

    
2572
        return mac_prefix
2573

    
2574
      new_prefix = get_net_prefix(new_net_uuid)
2575
      old_prefix = get_net_prefix(old_net_uuid)
2576
      if old_prefix != new_prefix:
2577
        params[constants.INIC_MAC] = \
2578
          self.cfg.GenerateMAC(new_net_uuid, self.proc.GetECId())
2579

    
2580
    # if there is a change in (ip, network) tuple
2581
    new_ip = params.get(constants.INIC_IP, old_ip)
2582
    if (new_ip, new_net_uuid) != (old_ip, old_net_uuid):
2583
      if new_ip:
2584
        # if IP is pool then require a network and generate one IP
2585
        if new_ip.lower() == constants.NIC_IP_POOL:
2586
          if new_net_uuid:
2587
            try:
2588
              new_ip = self.cfg.GenerateIp(new_net_uuid, self.proc.GetECId())
2589
            except errors.ReservationError:
2590
              raise errors.OpPrereqError("Unable to get a free IP"
2591
                                         " from the address pool",
2592
                                         errors.ECODE_STATE)
2593
            self.LogInfo("Chose IP %s from network %s",
2594
                         new_ip,
2595
                         new_net_obj.name)
2596
            params[constants.INIC_IP] = new_ip
2597
          else:
2598
            raise errors.OpPrereqError("ip=pool, but no network found",
2599
                                       errors.ECODE_INVAL)
2600
        # Reserve new IP if in the new network if any
2601
        elif new_net_uuid:
2602
          try:
2603
            self.cfg.ReserveIp(new_net_uuid, new_ip, self.proc.GetECId())
2604
            self.LogInfo("Reserving IP %s in network %s",
2605
                         new_ip, new_net_obj.name)
2606
          except errors.ReservationError:
2607
            raise errors.OpPrereqError("IP %s not available in network %s" %
2608
                                       (new_ip, new_net_obj.name),
2609
                                       errors.ECODE_NOTUNIQUE)
2610
        # new network is None so check if new IP is a conflicting IP
2611
        elif self.op.conflicts_check:
2612
          _CheckForConflictingIp(self, new_ip, pnode)
2613

    
2614
      # release old IP if old network is not None
2615
      if old_ip and old_net_uuid:
2616
        try:
2617
          self.cfg.ReleaseIp(old_net_uuid, old_ip, self.proc.GetECId())
2618
        except errors.AddressPoolError:
2619
          logging.warning("Release IP %s not contained in network %s",
2620
                          old_ip, old_net_obj.name)
2621

    
2622
    # there are no changes in (ip, network) tuple and old network is not None
2623
    elif (old_net_uuid is not None and
2624
          (req_link is not None or req_mode is not None)):
2625
      raise errors.OpPrereqError("Not allowed to change link or mode of"
2626
                                 " a NIC that is connected to a network",
2627
                                 errors.ECODE_INVAL)
2628

    
2629
    private.params = new_params
2630
    private.filled = new_filled_params
2631

    
2632
  def _PreCheckDiskTemplate(self, pnode_info):
2633
    """CheckPrereq checks related to a new disk template."""
2634
    # Arguments are passed to avoid configuration lookups
2635
    instance = self.instance
2636
    pnode = instance.primary_node
2637
    cluster = self.cluster
2638
    if instance.disk_template == self.op.disk_template:
2639
      raise errors.OpPrereqError("Instance already has disk template %s" %
2640
                                 instance.disk_template, errors.ECODE_INVAL)
2641

    
2642
    if (instance.disk_template,
2643
        self.op.disk_template) not in self._DISK_CONVERSIONS:
2644
      raise errors.OpPrereqError("Unsupported disk template conversion from"
2645
                                 " %s to %s" % (instance.disk_template,
2646
                                                self.op.disk_template),
2647
                                 errors.ECODE_INVAL)
2648
    CheckInstanceState(self, instance, INSTANCE_DOWN,
2649
                       msg="cannot change disk template")
2650
    if self.op.disk_template in constants.DTS_INT_MIRROR:
2651
      if self.op.remote_node == pnode:
2652
        raise errors.OpPrereqError("Given new secondary node %s is the same"
2653
                                   " as the primary node of the instance" %
2654
                                   self.op.remote_node, errors.ECODE_STATE)
2655
      CheckNodeOnline(self, self.op.remote_node)
2656
      CheckNodeNotDrained(self, self.op.remote_node)
2657
      # FIXME: here we assume that the old instance type is DT_PLAIN
2658
      assert instance.disk_template == constants.DT_PLAIN
2659
      disks = [{constants.IDISK_SIZE: d.size,
2660
                constants.IDISK_VG: d.logical_id[0]}
2661
               for d in instance.disks]
2662
      required = ComputeDiskSizePerVG(self.op.disk_template, disks)
2663
      CheckNodesFreeDiskPerVG(self, [self.op.remote_node], required)
2664

    
2665
      snode_info = self.cfg.GetNodeInfo(self.op.remote_node)
2666
      snode_group = self.cfg.GetNodeGroup(snode_info.group)
2667
      ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,
2668
                                                              snode_group)
2669
      CheckTargetNodeIPolicy(self, ipolicy, instance, snode_info, self.cfg,
2670
                             ignore=self.op.ignore_ipolicy)
2671
      if pnode_info.group != snode_info.group:
2672
        self.LogWarning("The primary and secondary nodes are in two"
2673
                        " different node groups; the disk parameters"
2674
                        " from the first disk's node group will be"
2675
                        " used")
2676

    
2677
    if not self.op.disk_template in constants.DTS_EXCL_STORAGE:
2678
      # Make sure none of the nodes require exclusive storage
2679
      nodes = [pnode_info]
2680
      if self.op.disk_template in constants.DTS_INT_MIRROR:
2681
        assert snode_info
2682
        nodes.append(snode_info)
2683
      has_es = lambda n: IsExclusiveStorageEnabledNode(self.cfg, n)
2684
      if compat.any(map(has_es, nodes)):
2685
        errmsg = ("Cannot convert disk template from %s to %s when exclusive"
2686
                  " storage is enabled" % (instance.disk_template,
2687
                                           self.op.disk_template))
2688
        raise errors.OpPrereqError(errmsg, errors.ECODE_STATE)
2689

    
2690
  def CheckPrereq(self):
2691
    """Check prerequisites.
2692

2693
    This only checks the instance list against the existing names.
2694

2695
    """
2696
    assert self.op.instance_name in self.owned_locks(locking.LEVEL_INSTANCE)
2697
    instance = self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
2698

    
2699
    cluster = self.cluster = self.cfg.GetClusterInfo()
2700
    assert self.instance is not None, \
2701
      "Cannot retrieve locked instance %s" % self.op.instance_name
2702

    
2703
    pnode = instance.primary_node
2704

    
2705
    self.warn = []
2706

    
2707
    if (self.op.pnode is not None and self.op.pnode != pnode and
2708
        not self.op.force):
2709
      # verify that the instance is not up
2710
      instance_info = self.rpc.call_instance_info(pnode, instance.name,
2711
                                                  instance.hypervisor)
2712
      if instance_info.fail_msg:
2713
        self.warn.append("Can't get instance runtime information: %s" %
2714
                         instance_info.fail_msg)
2715
      elif instance_info.payload:
2716
        raise errors.OpPrereqError("Instance is still running on %s" % pnode,
2717
                                   errors.ECODE_STATE)
2718

    
2719
    assert pnode in self.owned_locks(locking.LEVEL_NODE)
2720
    nodelist = list(instance.all_nodes)
2721
    pnode_info = self.cfg.GetNodeInfo(pnode)
2722
    self.diskparams = self.cfg.GetInstanceDiskParams(instance)
2723

    
2724
    #_CheckInstanceNodeGroups(self.cfg, self.op.instance_name, owned_groups)
2725
    assert pnode_info.group in self.owned_locks(locking.LEVEL_NODEGROUP)
2726
    group_info = self.cfg.GetNodeGroup(pnode_info.group)
2727

    
2728
    # dictionary with instance information after the modification
2729
    ispec = {}
2730

    
2731
    # Check disk modifications. This is done here and not in CheckArguments
2732
    # (as with NICs), because we need to know the instance's disk template
2733
    if instance.disk_template == constants.DT_EXT:
2734
      self._CheckMods("disk", self.op.disks, {},
2735
                      self._VerifyDiskModification)
2736
    else:
2737
      self._CheckMods("disk", self.op.disks, constants.IDISK_PARAMS_TYPES,
2738
                      self._VerifyDiskModification)
2739

    
2740
    # Prepare disk/NIC modifications
2741
    self.diskmod = _PrepareContainerMods(self.op.disks, None)
2742
    self.nicmod = _PrepareContainerMods(self.op.nics, _InstNicModPrivate)
2743

    
2744
    # Check the validity of the `provider' parameter
2745
    if instance.disk_template in constants.DT_EXT:
2746
      for mod in self.diskmod:
2747
        ext_provider = mod[2].get(constants.IDISK_PROVIDER, None)
2748
        if mod[0] == constants.DDM_ADD:
2749
          if ext_provider is None:
2750
            raise errors.OpPrereqError("Instance template is '%s' and parameter"
2751
                                       " '%s' missing, during disk add" %
2752
                                       (constants.DT_EXT,
2753
                                        constants.IDISK_PROVIDER),
2754
                                       errors.ECODE_NOENT)
2755
        elif mod[0] == constants.DDM_MODIFY:
2756
          if ext_provider:
2757
            raise errors.OpPrereqError("Parameter '%s' is invalid during disk"
2758
                                       " modification" %
2759
                                       constants.IDISK_PROVIDER,
2760
                                       errors.ECODE_INVAL)
2761
    else:
2762
      for mod in self.diskmod:
2763
        ext_provider = mod[2].get(constants.IDISK_PROVIDER, None)
2764
        if ext_provider is not None:
2765
          raise errors.OpPrereqError("Parameter '%s' is only valid for"
2766
                                     " instances of type '%s'" %
2767
                                     (constants.IDISK_PROVIDER,
2768
                                      constants.DT_EXT),
2769
                                     errors.ECODE_INVAL)
2770

    
2771
    # OS change
2772
    if self.op.os_name and not self.op.force:
2773
      CheckNodeHasOS(self, instance.primary_node, self.op.os_name,
2774
                     self.op.force_variant)
2775
      instance_os = self.op.os_name
2776
    else:
2777
      instance_os = instance.os
2778

    
2779
    assert not (self.op.disk_template and self.op.disks), \
2780
      "Can't modify disk template and apply disk changes at the same time"
2781

    
2782
    if self.op.disk_template:
2783
      self._PreCheckDiskTemplate(pnode_info)
2784

    
2785
    # hvparams processing
2786
    if self.op.hvparams:
2787
      hv_type = instance.hypervisor
2788
      i_hvdict = GetUpdatedParams(instance.hvparams, self.op.hvparams)
2789
      utils.ForceDictType(i_hvdict, constants.HVS_PARAMETER_TYPES)
2790
      hv_new = cluster.SimpleFillHV(hv_type, instance.os, i_hvdict)
2791

    
2792
      # local check
2793
      hypervisor.GetHypervisorClass(hv_type).CheckParameterSyntax(hv_new)
2794
      CheckHVParams(self, nodelist, instance.hypervisor, hv_new)
2795
      self.hv_proposed = self.hv_new = hv_new # the new actual values
2796
      self.hv_inst = i_hvdict # the new dict (without defaults)
2797
    else:
2798
      self.hv_proposed = cluster.SimpleFillHV(instance.hypervisor, instance.os,
2799
                                              instance.hvparams)
2800
      self.hv_new = self.hv_inst = {}
2801

    
2802
    # beparams processing
2803
    if self.op.beparams:
2804
      i_bedict = GetUpdatedParams(instance.beparams, self.op.beparams,
2805
                                  use_none=True)
2806
      objects.UpgradeBeParams(i_bedict)
2807
      utils.ForceDictType(i_bedict, constants.BES_PARAMETER_TYPES)
2808
      be_new = cluster.SimpleFillBE(i_bedict)
2809
      self.be_proposed = self.be_new = be_new # the new actual values
2810
      self.be_inst = i_bedict # the new dict (without defaults)
2811
    else:
2812
      self.be_new = self.be_inst = {}
2813
      self.be_proposed = cluster.SimpleFillBE(instance.beparams)
2814
    be_old = cluster.FillBE(instance)
2815

    
2816
    # CPU param validation -- checking every time a parameter is
2817
    # changed to cover all cases where either CPU mask or vcpus have
2818
    # changed
2819
    if (constants.BE_VCPUS in self.be_proposed and
2820
        constants.HV_CPU_MASK in self.hv_proposed):
2821
      cpu_list = \
2822
        utils.ParseMultiCpuMask(self.hv_proposed[constants.HV_CPU_MASK])
2823
      # Verify mask is consistent with number of vCPUs. Can skip this
2824
      # test if only 1 entry in the CPU mask, which means same mask
2825
      # is applied to all vCPUs.
2826
      if (len(cpu_list) > 1 and
2827
          len(cpu_list) != self.be_proposed[constants.BE_VCPUS]):
2828
        raise errors.OpPrereqError("Number of vCPUs [%d] does not match the"
2829
                                   " CPU mask [%s]" %
2830
                                   (self.be_proposed[constants.BE_VCPUS],
2831
                                    self.hv_proposed[constants.HV_CPU_MASK]),
2832
                                   errors.ECODE_INVAL)
2833

    
2834
      # Only perform this test if a new CPU mask is given
2835
      if constants.HV_CPU_MASK in self.hv_new:
2836
        # Calculate the largest CPU number requested
2837
        max_requested_cpu = max(map(max, cpu_list))
2838
        # Check that all of the instance's nodes have enough physical CPUs to
2839
        # satisfy the requested CPU mask
2840
        _CheckNodesPhysicalCPUs(self, instance.all_nodes,
2841
                                max_requested_cpu + 1, instance.hypervisor)
2842

    
2843
    # osparams processing
2844
    if self.op.osparams:
2845
      i_osdict = GetUpdatedParams(instance.osparams, self.op.osparams)
2846
      CheckOSParams(self, True, nodelist, instance_os, i_osdict)
2847
      self.os_inst = i_osdict # the new dict (without defaults)
2848
    else:
2849
      self.os_inst = {}
2850

    
2851
    #TODO(dynmem): do the appropriate check involving MINMEM
2852
    if (constants.BE_MAXMEM in self.op.beparams and not self.op.force and
2853
        be_new[constants.BE_MAXMEM] > be_old[constants.BE_MAXMEM]):
2854
      mem_check_list = [pnode]
2855
      if be_new[constants.BE_AUTO_BALANCE]:
2856
        # either we changed auto_balance to yes or it was from before
2857
        mem_check_list.extend(instance.secondary_nodes)
2858
      instance_info = self.rpc.call_instance_info(pnode, instance.name,
2859
                                                  instance.hypervisor)
2860
      nodeinfo = self.rpc.call_node_info(mem_check_list, None,
2861
                                         [instance.hypervisor], False)
2862
      pninfo = nodeinfo[pnode]
2863
      msg = pninfo.fail_msg
2864
      if msg:
2865
        # Assume the primary node is unreachable and go ahead
2866
        self.warn.append("Can't get info from primary node %s: %s" %
2867
                         (pnode, msg))
2868
      else:
2869
        (_, _, (pnhvinfo, )) = pninfo.payload
2870
        if not isinstance(pnhvinfo.get("memory_free", None), int):
2871
          self.warn.append("Node data from primary node %s doesn't contain"
2872
                           " free memory information" % pnode)
2873
        elif instance_info.fail_msg:
2874
          self.warn.append("Can't get instance runtime information: %s" %
2875
                           instance_info.fail_msg)
2876
        else:
2877
          if instance_info.payload:
2878
            current_mem = int(instance_info.payload["memory"])
2879
          else:
2880
            # Assume instance not running
2881
            # (there is a slight race condition here, but it's not very
2882
            # probable, and we have no other way to check)
2883
            # TODO: Describe race condition
2884
            current_mem = 0
2885
          #TODO(dynmem): do the appropriate check involving MINMEM
2886
          miss_mem = (be_new[constants.BE_MAXMEM] - current_mem -
2887
                      pnhvinfo["memory_free"])
2888
          if miss_mem > 0:
2889
            raise errors.OpPrereqError("This change will prevent the instance"
2890
                                       " from starting, due to %d MB of memory"
2891
                                       " missing on its primary node" %
2892
                                       miss_mem, errors.ECODE_NORES)
2893

    
2894
      if be_new[constants.BE_AUTO_BALANCE]:
2895
        for node, nres in nodeinfo.items():
2896
          if node not in instance.secondary_nodes:
2897
            continue
2898
          nres.Raise("Can't get info from secondary node %s" % node,
2899
                     prereq=True, ecode=errors.ECODE_STATE)
2900
          (_, _, (nhvinfo, )) = nres.payload
2901
          if not isinstance(nhvinfo.get("memory_free", None), int):
2902
            raise errors.OpPrereqError("Secondary node %s didn't return free"
2903
                                       " memory information" % node,
2904
                                       errors.ECODE_STATE)
2905
          #TODO(dynmem): do the appropriate check involving MINMEM
2906
          elif be_new[constants.BE_MAXMEM] > nhvinfo["memory_free"]:
2907
            raise errors.OpPrereqError("This change will prevent the instance"
2908
                                       " from failover to its secondary node"
2909
                                       " %s, due to not enough memory" % node,
2910
                                       errors.ECODE_STATE)
2911

    
2912
    if self.op.runtime_mem:
2913
      remote_info = self.rpc.call_instance_info(instance.primary_node,
2914
                                                instance.name,
2915
                                                instance.hypervisor)
2916
      remote_info.Raise("Error checking node %s" % instance.primary_node)
2917
      if not remote_info.payload: # not running already
2918
        raise errors.OpPrereqError("Instance %s is not running" %
2919
                                   instance.name, errors.ECODE_STATE)
2920

    
2921
      current_memory = remote_info.payload["memory"]
2922
      if (not self.op.force and
2923
           (self.op.runtime_mem > self.be_proposed[constants.BE_MAXMEM] or
2924
            self.op.runtime_mem < self.be_proposed[constants.BE_MINMEM])):
2925
        raise errors.OpPrereqError("Instance %s must have memory between %d"
2926
                                   " and %d MB of memory unless --force is"
2927
                                   " given" %
2928
                                   (instance.name,
2929
                                    self.be_proposed[constants.BE_MINMEM],
2930
                                    self.be_proposed[constants.BE_MAXMEM]),
2931
                                   errors.ECODE_INVAL)
2932

    
2933
      delta = self.op.runtime_mem - current_memory
2934
      if delta > 0:
2935
        CheckNodeFreeMemory(self, instance.primary_node,
2936
                            "ballooning memory for instance %s" %
2937
                            instance.name, delta, instance.hypervisor)
2938

    
2939
    if self.op.disks and instance.disk_template == constants.DT_DISKLESS:
2940
      raise errors.OpPrereqError("Disk operations not supported for"
2941
                                 " diskless instances", errors.ECODE_INVAL)
2942

    
2943
    def _PrepareNicCreate(_, params, private):
2944
      self._PrepareNicModification(params, private, None, None,
2945
                                   {}, cluster, pnode)
2946
      return (None, None)
2947

    
2948
    def _PrepareNicMod(_, nic, params, private):
2949
      self._PrepareNicModification(params, private, nic.ip, nic.network,
2950
                                   nic.nicparams, cluster, pnode)
2951
      return None
2952

    
2953
    def _PrepareNicRemove(_, params, __):
2954
      ip = params.ip
2955
      net = params.network
2956
      if net is not None and ip is not None:
2957
        self.cfg.ReleaseIp(net, ip, self.proc.GetECId())
2958

    
2959
    # Verify NIC changes (operating on copy)
2960
    nics = instance.nics[:]
2961
    _ApplyContainerMods("NIC", nics, None, self.nicmod,
2962
                        _PrepareNicCreate, _PrepareNicMod, _PrepareNicRemove)
2963
    if len(nics) > constants.MAX_NICS:
2964
      raise errors.OpPrereqError("Instance has too many network interfaces"
2965
                                 " (%d), cannot add more" % constants.MAX_NICS,
2966
                                 errors.ECODE_STATE)
2967

    
2968
    def _PrepareDiskMod(_, disk, params, __):
2969
      disk.name = params.get(constants.IDISK_NAME, None)
2970

    
2971
    # Verify disk changes (operating on a copy)
2972
    disks = copy.deepcopy(instance.disks)
2973
    _ApplyContainerMods("disk", disks, None, self.diskmod, None,
2974
                        _PrepareDiskMod, None)
2975
    utils.ValidateDeviceNames("disk", disks)
2976
    if len(disks) > constants.MAX_DISKS:
2977
      raise errors.OpPrereqError("Instance has too many disks (%d), cannot add"
2978
                                 " more" % constants.MAX_DISKS,
2979
                                 errors.ECODE_STATE)
2980
    disk_sizes = [disk.size for disk in instance.disks]
2981
    disk_sizes.extend(params["size"] for (op, idx, params, private) in
2982
                      self.diskmod if op == constants.DDM_ADD)
2983
    ispec[constants.ISPEC_DISK_COUNT] = len(disk_sizes)
2984
    ispec[constants.ISPEC_DISK_SIZE] = disk_sizes
2985

    
2986
    if self.op.offline is not None and self.op.offline:
2987
      CheckInstanceState(self, instance, CAN_CHANGE_INSTANCE_OFFLINE,
2988
                         msg="can't change to offline")
2989

    
2990
    # Pre-compute NIC changes (necessary to use result in hooks)
2991
    self._nic_chgdesc = []
2992
    if self.nicmod:
2993
      # Operate on copies as this is still in prereq
2994
      nics = [nic.Copy() for nic in instance.nics]
2995
      _ApplyContainerMods("NIC", nics, self._nic_chgdesc, self.nicmod,
2996
                          self._CreateNewNic, self._ApplyNicMods, None)
2997
      # Verify that NIC names are unique and valid
2998
      utils.ValidateDeviceNames("NIC", nics)
2999
      self._new_nics = nics
3000
      ispec[constants.ISPEC_NIC_COUNT] = len(self._new_nics)
3001
    else:
3002
      self._new_nics = None
3003
      ispec[constants.ISPEC_NIC_COUNT] = len(instance.nics)
3004

    
3005
    if not self.op.ignore_ipolicy:
3006
      ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,
3007
                                                              group_info)
3008

    
3009
      # Fill ispec with backend parameters
3010
      ispec[constants.ISPEC_SPINDLE_USE] = \
3011
        self.be_new.get(constants.BE_SPINDLE_USE, None)
3012
      ispec[constants.ISPEC_CPU_COUNT] = self.be_new.get(constants.BE_VCPUS,
3013
                                                         None)
3014

    
3015
      # Copy ispec to verify parameters with min/max values separately
3016
      if self.op.disk_template:
3017
        new_disk_template = self.op.disk_template
3018
      else:
3019
        new_disk_template = instance.disk_template
3020
      ispec_max = ispec.copy()
3021
      ispec_max[constants.ISPEC_MEM_SIZE] = \
3022
        self.be_new.get(constants.BE_MAXMEM, None)
3023
      res_max = _ComputeIPolicyInstanceSpecViolation(ipolicy, ispec_max,
3024
                                                     new_disk_template)
3025
      ispec_min = ispec.copy()
3026
      ispec_min[constants.ISPEC_MEM_SIZE] = \
3027
        self.be_new.get(constants.BE_MINMEM, None)
3028
      res_min = _ComputeIPolicyInstanceSpecViolation(ipolicy, ispec_min,
3029
                                                     new_disk_template)
3030

    
3031
      if (res_max or res_min):
3032
        # FIXME: Improve error message by including information about whether
3033
        # the upper or lower limit of the parameter fails the ipolicy.
3034
        msg = ("Instance allocation to group %s (%s) violates policy: %s" %
3035
               (group_info, group_info.name,
3036
                utils.CommaJoin(set(res_max + res_min))))
3037
        raise errors.OpPrereqError(msg, errors.ECODE_INVAL)
3038

    
3039
  def _ConvertPlainToDrbd(self, feedback_fn):
3040
    """Converts an instance from plain to drbd.
3041

3042
    """
3043
    feedback_fn("Converting template to drbd")
3044
    instance = self.instance
3045
    pnode = instance.primary_node
3046
    snode = self.op.remote_node
3047

    
3048
    assert instance.disk_template == constants.DT_PLAIN
3049

    
3050
    # create a fake disk info for _GenerateDiskTemplate
3051
    disk_info = [{constants.IDISK_SIZE: d.size, constants.IDISK_MODE: d.mode,
3052
                  constants.IDISK_VG: d.logical_id[0],
3053
                  constants.IDISK_NAME: d.name}
3054
                 for d in instance.disks]
3055
    new_disks = GenerateDiskTemplate(self, self.op.disk_template,
3056
                                     instance.name, pnode, [snode],
3057
                                     disk_info, None, None, 0, feedback_fn,
3058
                                     self.diskparams)
3059
    anno_disks = rpc.AnnotateDiskParams(constants.DT_DRBD8, new_disks,
3060
                                        self.diskparams)
3061
    p_excl_stor = IsExclusiveStorageEnabledNodeName(self.cfg, pnode)
3062
    s_excl_stor = IsExclusiveStorageEnabledNodeName(self.cfg, snode)
3063
    info = GetInstanceInfoText(instance)
3064
    feedback_fn("Creating additional volumes...")
3065
    # first, create the missing data and meta devices
3066
    for disk in anno_disks:
3067
      # unfortunately this is... not too nice
3068
      CreateSingleBlockDev(self, pnode, instance, disk.children[1],
3069
                           info, True, p_excl_stor)
3070
      for child in disk.children:
3071
        CreateSingleBlockDev(self, snode, instance, child, info, True,
3072
                             s_excl_stor)
3073
    # at this stage, all new LVs have been created, we can rename the
3074
    # old ones
3075
    feedback_fn("Renaming original volumes...")
3076
    rename_list = [(o, n.children[0].logical_id)
3077
                   for (o, n) in zip(instance.disks, new_disks)]
3078
    result = self.rpc.call_blockdev_rename(pnode, rename_list)
3079
    result.Raise("Failed to rename original LVs")
3080

    
3081
    feedback_fn("Initializing DRBD devices...")
3082
    # all child devices are in place, we can now create the DRBD devices
3083
    try:
3084
      for disk in anno_disks:
3085
        for (node, excl_stor) in [(pnode, p_excl_stor), (snode, s_excl_stor)]:
3086
          f_create = node == pnode
3087
          CreateSingleBlockDev(self, node, instance, disk, info, f_create,
3088
                               excl_stor)
3089
    except errors.GenericError, e:
3090
      feedback_fn("Initializing of DRBD devices failed;"
3091
                  " renaming back original volumes...")
3092
      for disk in new_disks:
3093
        self.cfg.SetDiskID(disk, pnode)
3094
      rename_back_list = [(n.children[0], o.logical_id)
3095
                          for (n, o) in zip(new_disks, instance.disks)]
3096
      result = self.rpc.call_blockdev_rename(pnode, rename_back_list)
3097
      result.Raise("Failed to rename LVs back after error %s" % str(e))
3098
      raise
3099

    
3100
    # at this point, the instance has been modified
3101
    instance.disk_template = constants.DT_DRBD8
3102
    instance.disks = new_disks
3103
    self.cfg.Update(instance, feedback_fn)
3104

    
3105
    # Release node locks while waiting for sync
3106
    ReleaseLocks(self, locking.LEVEL_NODE)
3107

    
3108
    # disks are created, waiting for sync
3109
    disk_abort = not WaitForSync(self, instance,
3110
                                 oneshot=not self.op.wait_for_sync)
3111
    if disk_abort:
3112
      raise errors.OpExecError("There are some degraded disks for"
3113
                               " this instance, please cleanup manually")
3114

    
3115
    # Node resource locks will be released by caller
3116

    
3117
  def _ConvertDrbdToPlain(self, feedback_fn):
3118
    """Converts an instance from drbd to plain.
3119

3120
    """
3121
    instance = self.instance
3122

    
3123
    assert len(instance.secondary_nodes) == 1
3124
    assert instance.disk_template == constants.DT_DRBD8
3125

    
3126
    pnode = instance.primary_node
3127
    snode = instance.secondary_nodes[0]
3128
    feedback_fn("Converting template to plain")
3129

    
3130
    old_disks = AnnotateDiskParams(instance, instance.disks, self.cfg)
3131
    new_disks = [d.children[0] for d in instance.disks]
3132

    
3133
    # copy over size, mode and name
3134
    for parent, child in zip(old_disks, new_disks):
3135
      child.size = parent.size
3136
      child.mode = parent.mode
3137
      child.name = parent.name
3138

    
3139
    # this is a DRBD disk, return its port to the pool
3140
    # NOTE: this must be done right before the call to cfg.Update!
3141
    for disk in old_disks:
3142
      tcp_port = disk.logical_id[2]
3143
      self.cfg.AddTcpUdpPort(tcp_port)
3144

    
3145
    # update instance structure
3146
    instance.disks = new_disks
3147
    instance.disk_template = constants.DT_PLAIN
3148
    _UpdateIvNames(0, instance.disks)
3149
    self.cfg.Update(instance, feedback_fn)
3150

    
3151
    # Release locks in case removing disks takes a while
3152
    ReleaseLocks(self, locking.LEVEL_NODE)
3153

    
3154
    feedback_fn("Removing volumes on the secondary node...")
3155
    for disk in old_disks:
3156
      self.cfg.SetDiskID(disk, snode)
3157
      msg = self.rpc.call_blockdev_remove(snode, disk).fail_msg
3158
      if msg:
3159
        self.LogWarning("Could not remove block device %s on node %s,"
3160
                        " continuing anyway: %s", disk.iv_name, snode, msg)
3161

    
3162
    feedback_fn("Removing unneeded volumes on the primary node...")
3163
    for idx, disk in enumerate(old_disks):
3164
      meta = disk.children[1]
3165
      self.cfg.SetDiskID(meta, pnode)
3166
      msg = self.rpc.call_blockdev_remove(pnode, meta).fail_msg
3167
      if msg:
3168
        self.LogWarning("Could not remove metadata for disk %d on node %s,"
3169
                        " continuing anyway: %s", idx, pnode, msg)
3170

    
3171
  def _CreateNewDisk(self, idx, params, _):
3172
    """Creates a new disk.
3173

3174
    """
3175
    instance = self.instance
3176

    
3177
    # add a new disk
3178
    if instance.disk_template in constants.DTS_FILEBASED:
3179
      (file_driver, file_path) = instance.disks[0].logical_id
3180
      file_path = os.path.dirname(file_path)
3181
    else:
3182
      file_driver = file_path = None
3183

    
3184
    disk = \
3185
      GenerateDiskTemplate(self, instance.disk_template, instance.name,
3186
                           instance.primary_node, instance.secondary_nodes,
3187
                           [params], file_path, file_driver, idx,
3188
                           self.Log, self.diskparams)[0]
3189

    
3190
    new_disks = CreateDisks(self, instance, disks=[disk])
3191

    
3192
    if self.cluster.prealloc_wipe_disks:
3193
      # Wipe new disk
3194
      WipeOrCleanupDisks(self, instance,
3195
                         disks=[(idx, disk, 0)],
3196
                         cleanup=new_disks)
3197

    
3198
    return (disk, [
3199
      ("disk/%d" % idx, "add:size=%s,mode=%s" % (disk.size, disk.mode)),
3200
      ])
3201

    
3202
  def _ModifyDisk(self, idx, disk, params, _):
3203
    """Modifies a disk.
3204

3205
    """
3206
    changes = []
3207
    if constants.IDISK_MODE in params:
3208
      disk.mode = params.get(constants.IDISK_MODE)
3209
      changes.append(("disk.mode/%d" % idx, disk.mode))
3210

    
3211
    if constants.IDISK_NAME in params:
3212
      disk.name = params.get(constants.IDISK_NAME)
3213
      changes.append(("disk.name/%d" % idx, disk.name))
3214

    
3215
    # Modify arbitrary params in case instance template is ext
3216
    for key, value in params.iteritems():
3217
      if (key not in constants.MODIFIABLE_IDISK_PARAMS and
3218
          self.instance.disk_template == constants.DT_EXT):
3219
        # stolen from GetUpdatedParams: default means reset/delete
3220
        if value.lower() == constants.VALUE_DEFAULT:
3221
          try:
3222
            del disk.params[key]
3223
          except KeyError:
3224
            pass
3225
        else:
3226
          disk.params[key] = value
3227
        changes.append(("disk.params:%s/%d" % (key, idx), value))
3228

    
3229
    return changes
3230

    
3231
  def _RemoveDisk(self, idx, root, _):
3232
    """Removes a disk.
3233

3234
    """
3235
    (anno_disk,) = AnnotateDiskParams(self.instance, [root], self.cfg)
3236
    for node, disk in anno_disk.ComputeNodeTree(self.instance.primary_node):
3237
      self.cfg.SetDiskID(disk, node)
3238
      msg = self.rpc.call_blockdev_remove(node, disk).fail_msg
3239
      if msg:
3240
        self.LogWarning("Could not remove disk/%d on node '%s': %s,"
3241
                        " continuing anyway", idx, node, msg)
3242

    
3243
    # if this is a DRBD disk, return its port to the pool
3244
    if root.dev_type in constants.LDS_DRBD:
3245
      self.cfg.AddTcpUdpPort(root.logical_id[2])
3246

    
3247
  def _CreateNewNic(self, idx, params, private):
3248
    """Creates data structure for a new network interface.
3249

3250
    """
3251
    mac = params[constants.INIC_MAC]
3252
    ip = params.get(constants.INIC_IP, None)
3253
    net = params.get(constants.INIC_NETWORK, None)
3254
    name = params.get(constants.INIC_NAME, None)
3255
    net_uuid = self.cfg.LookupNetwork(net)
3256
    #TODO: not private.filled?? can a nic have no nicparams??
3257
    nicparams = private.filled
3258
    nobj = objects.NIC(mac=mac, ip=ip, network=net_uuid, name=name,
3259
                       nicparams=nicparams)
3260
    nobj.uuid = self.cfg.GenerateUniqueID(self.proc.GetECId())
3261

    
3262
    return (nobj, [
3263
      ("nic.%d" % idx,
3264
       "add:mac=%s,ip=%s,mode=%s,link=%s,network=%s" %
3265
       (mac, ip, private.filled[constants.NIC_MODE],
3266
       private.filled[constants.NIC_LINK],
3267
       net)),
3268
      ])
3269

    
3270
  def _ApplyNicMods(self, idx, nic, params, private):
3271
    """Modifies a network interface.
3272

3273
    """
3274
    changes = []
3275

    
3276
    for key in [constants.INIC_MAC, constants.INIC_IP, constants.INIC_NAME]:
3277
      if key in params:
3278
        changes.append(("nic.%s/%d" % (key, idx), params[key]))
3279
        setattr(nic, key, params[key])
3280

    
3281
    new_net = params.get(constants.INIC_NETWORK, nic.network)
3282
    new_net_uuid = self.cfg.LookupNetwork(new_net)
3283
    if new_net_uuid != nic.network:
3284
      changes.append(("nic.network/%d" % idx, new_net))
3285
      nic.network = new_net_uuid
3286

    
3287
    if private.filled:
3288
      nic.nicparams = private.filled
3289

    
3290
      for (key, val) in nic.nicparams.items():
3291
        changes.append(("nic.%s/%d" % (key, idx), val))
3292

    
3293
    return changes
3294

    
3295
  def Exec(self, feedback_fn):
3296
    """Modifies an instance.
3297

3298
    All parameters take effect only at the next restart of the instance.
3299

3300
    """
3301
    # Process here the warnings from CheckPrereq, as we don't have a
3302
    # feedback_fn there.
3303
    # TODO: Replace with self.LogWarning
3304
    for warn in self.warn:
3305
      feedback_fn("WARNING: %s" % warn)
3306

    
3307
    assert ((self.op.disk_template is None) ^
3308
            bool(self.owned_locks(locking.LEVEL_NODE_RES))), \
3309
      "Not owning any node resource locks"
3310

    
3311
    result = []
3312
    instance = self.instance
3313

    
3314
    # New primary node
3315
    if self.op.pnode:
3316
      instance.primary_node = self.op.pnode
3317

    
3318
    # runtime memory
3319
    if self.op.runtime_mem:
3320
      rpcres = self.rpc.call_instance_balloon_memory(instance.primary_node,
3321
                                                     instance,
3322
                                                     self.op.runtime_mem)
3323
      rpcres.Raise("Cannot modify instance runtime memory")
3324
      result.append(("runtime_memory", self.op.runtime_mem))
3325

    
3326
    # Apply disk changes
3327
    _ApplyContainerMods("disk", instance.disks, result, self.diskmod,
3328
                        self._CreateNewDisk, self._ModifyDisk,
3329
                        self._RemoveDisk)
3330
    _UpdateIvNames(0, instance.disks)
3331

    
3332
    if self.op.disk_template:
3333
      if __debug__:
3334
        check_nodes = set(instance.all_nodes)
3335
        if self.op.remote_node:
3336
          check_nodes.add(self.op.remote_node)
3337
        for level in [locking.LEVEL_NODE, locking.LEVEL_NODE_RES]:
3338
          owned = self.owned_locks(level)
3339
          assert not (check_nodes - owned), \
3340
            ("Not owning the correct locks, owning %r, expected at least %r" %
3341
             (owned, check_nodes))
3342

    
3343
      r_shut = ShutdownInstanceDisks(self, instance)
3344
      if not r_shut:
3345
        raise errors.OpExecError("Cannot shutdown instance disks, unable to"
3346
                                 " proceed with disk template conversion")
3347
      mode = (instance.disk_template, self.op.disk_template)
3348
      try:
3349
        self._DISK_CONVERSIONS[mode](self, feedback_fn)
3350
      except:
3351
        self.cfg.ReleaseDRBDMinors(instance.name)
3352
        raise
3353
      result.append(("disk_template", self.op.disk_template))
3354

    
3355
      assert instance.disk_template == self.op.disk_template, \
3356
        ("Expected disk template '%s', found '%s'" %
3357
         (self.op.disk_template, instance.disk_template))
3358

    
3359
    # Release node and resource locks if there are any (they might already have
3360
    # been released during disk conversion)
3361
    ReleaseLocks(self, locking.LEVEL_NODE)
3362
    ReleaseLocks(self, locking.LEVEL_NODE_RES)
3363

    
3364
    # Apply NIC changes
3365
    if self._new_nics is not None:
3366
      instance.nics = self._new_nics
3367
      result.extend(self._nic_chgdesc)
3368

    
3369
    # hvparams changes
3370
    if self.op.hvparams:
3371
      instance.hvparams = self.hv_inst
3372
      for key, val in self.op.hvparams.iteritems():
3373
        result.append(("hv/%s" % key, val))
3374

    
3375
    # beparams changes
3376
    if self.op.beparams:
3377
      instance.beparams = self.be_inst
3378
      for key, val in self.op.beparams.iteritems():
3379
        result.append(("be/%s" % key, val))
3380

    
3381
    # OS change
3382
    if self.op.os_name:
3383
      instance.os = self.op.os_name
3384

    
3385
    # osparams changes
3386
    if self.op.osparams:
3387
      instance.osparams = self.os_inst
3388
      for key, val in self.op.osparams.iteritems():
3389
        result.append(("os/%s" % key, val))
3390

    
3391
    if self.op.offline is None:
3392
      # Ignore
3393
      pass
3394
    elif self.op.offline:
3395
      # Mark instance as offline
3396
      self.cfg.MarkInstanceOffline(instance.name)
3397
      result.append(("admin_state", constants.ADMINST_OFFLINE))
3398
    else:
3399
      # Mark instance as online, but stopped
3400
      self.cfg.MarkInstanceDown(instance.name)
3401
      result.append(("admin_state", constants.ADMINST_DOWN))
3402

    
3403
    self.cfg.Update(instance, feedback_fn, self.proc.GetECId())
3404

    
3405
    assert not (self.owned_locks(locking.LEVEL_NODE_RES) or
3406
                self.owned_locks(locking.LEVEL_NODE)), \
3407
      "All node locks should have been released by now"
3408

    
3409
    return result
3410

    
3411
  _DISK_CONVERSIONS = {
3412
    (constants.DT_PLAIN, constants.DT_DRBD8): _ConvertPlainToDrbd,
3413
    (constants.DT_DRBD8, constants.DT_PLAIN): _ConvertDrbdToPlain,
3414
    }
3415

    
3416

    
3417
class LUInstanceChangeGroup(LogicalUnit):
3418
  HPATH = "instance-change-group"
3419
  HTYPE = constants.HTYPE_INSTANCE
3420
  REQ_BGL = False
3421

    
3422
  def ExpandNames(self):
3423
    self.share_locks = ShareAll()
3424

    
3425
    self.needed_locks = {
3426
      locking.LEVEL_NODEGROUP: [],
3427
      locking.LEVEL_NODE: [],
3428
      locking.LEVEL_NODE_ALLOC: locking.ALL_SET,
3429
      }
3430

    
3431
    self._ExpandAndLockInstance()
3432

    
3433
    if self.op.target_groups:
3434
      self.req_target_uuids = map(self.cfg.LookupNodeGroup,
3435
                                  self.op.target_groups)
3436
    else:
3437
      self.req_target_uuids = None
3438

    
3439
    self.op.iallocator = GetDefaultIAllocator(self.cfg, self.op.iallocator)
3440

    
3441
  def DeclareLocks(self, level):
3442
    if level == locking.LEVEL_NODEGROUP:
3443
      assert not self.needed_locks[locking.LEVEL_NODEGROUP]
3444

    
3445
      if self.req_target_uuids:
3446
        lock_groups = set(self.req_target_uuids)
3447

    
3448
        # Lock all groups used by instance optimistically; this requires going
3449
        # via the node before it's locked, requiring verification later on
3450
        instance_groups = self.cfg.GetInstanceNodeGroups(self.op.instance_name)
3451
        lock_groups.update(instance_groups)
3452
      else:
3453
        # No target groups, need to lock all of them
3454
        lock_groups = locking.ALL_SET
3455

    
3456
      self.needed_locks[locking.LEVEL_NODEGROUP] = lock_groups
3457

    
3458
    elif level == locking.LEVEL_NODE:
3459
      if self.req_target_uuids:
3460
        # Lock all nodes used by instances
3461
        self.recalculate_locks[locking.LEVEL_NODE] = constants.LOCKS_APPEND
3462
        self._LockInstancesNodes()
3463

    
3464
        # Lock all nodes in all potential target groups
3465
        lock_groups = (frozenset(self.owned_locks(locking.LEVEL_NODEGROUP)) -
3466
                       self.cfg.GetInstanceNodeGroups(self.op.instance_name))
3467
        member_nodes = [node_name
3468
                        for group in lock_groups
3469
                        for node_name in self.cfg.GetNodeGroup(group).members]
3470
        self.needed_locks[locking.LEVEL_NODE].extend(member_nodes)
3471
      else:
3472
        # Lock all nodes as all groups are potential targets
3473
        self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
3474

    
3475
  def CheckPrereq(self):
3476
    owned_instances = frozenset(self.owned_locks(locking.LEVEL_INSTANCE))
3477
    owned_groups = frozenset(self.owned_locks(locking.LEVEL_NODEGROUP))
3478
    owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))
3479

    
3480
    assert (self.req_target_uuids is None or
3481
            owned_groups.issuperset(self.req_target_uuids))
3482
    assert owned_instances == set([self.op.instance_name])
3483

    
3484
    # Get instance information
3485
    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)
3486

    
3487
    # Check if node groups for locked instance are still correct
3488
    assert owned_nodes.issuperset(self.instance.all_nodes), \
3489
      ("Instance %s's nodes changed while we kept the lock" %
3490
       self.op.instance_name)
3491

    
3492
    inst_groups = CheckInstanceNodeGroups(self.cfg, self.op.instance_name,
3493
                                          owned_groups)
3494

    
3495
    if self.req_target_uuids:
3496
      # User requested specific target groups
3497
      self.target_uuids = frozenset(self.req_target_uuids)
3498
    else:
3499
      # All groups except those used by the instance are potential targets
3500
      self.target_uuids = owned_groups - inst_groups
3501

    
3502
    conflicting_groups = self.target_uuids & inst_groups
3503
    if conflicting_groups:
3504
      raise errors.OpPrereqError("Can't use group(s) '%s' as targets, they are"
3505
                                 " used by the instance '%s'" %
3506
                                 (utils.CommaJoin(conflicting_groups),
3507
                                  self.op.instance_name),
3508
                                 errors.ECODE_INVAL)
3509

    
3510
    if not self.target_uuids:
3511
      raise errors.OpPrereqError("There are no possible target groups",
3512
                                 errors.ECODE_INVAL)
3513

    
3514
  def BuildHooksEnv(self):
3515
    """Build hooks env.
3516

3517
    """
3518
    assert self.target_uuids
3519

    
3520
    env = {
3521
      "TARGET_GROUPS": " ".join(self.target_uuids),
3522
      }
3523

    
3524
    env.update(BuildInstanceHookEnvByObject(self, self.instance))
3525

    
3526
    return env
3527

    
3528
  def BuildHooksNodes(self):
3529
    """Build hooks nodes.
3530

3531
    """
3532
    mn = self.cfg.GetMasterNode()
3533
    return ([mn], [mn])
3534

    
3535
  def Exec(self, feedback_fn):
3536
    instances = list(self.owned_locks(locking.LEVEL_INSTANCE))
3537

    
3538
    assert instances == [self.op.instance_name], "Instance not locked"
3539

    
3540
    req = iallocator.IAReqGroupChange(instances=instances,
3541
                                      target_groups=list(self.target_uuids))
3542
    ial = iallocator.IAllocator(self.cfg, self.rpc, req)
3543

    
3544
    ial.Run(self.op.iallocator)
3545

    
3546
    if not ial.success:
3547
      raise errors.OpPrereqError("Can't compute solution for changing group of"
3548
                                 " instance '%s' using iallocator '%s': %s" %
3549
                                 (self.op.instance_name, self.op.iallocator,
3550
                                  ial.info), errors.ECODE_NORES)
3551

    
3552
    jobs = LoadNodeEvacResult(self, ial.result, self.op.early_release, False)
3553

    
3554
    self.LogInfo("Iallocator returned %s job(s) for changing group of"
3555
                 " instance '%s'", len(jobs), self.op.instance_name)
3556

    
3557
    return ResultWithJobs(jobs)