Revision c42be2c0

b/lib/backend.py
1489 1489
  allowing any number of instance queries to be done.
1490 1490

  
1491 1491
  @type instance_param_dict: dict of string to tuple of dictionaries, where the
1492
    dictionaries represent: L{objects.Instance}, L{objects.Node}, HvParams,
1493
    BeParams
1492
    dictionaries represent: L{objects.Instance}, L{objects.Node},
1493
    L{objects.NodeGroup}, HvParams, BeParams
1494 1494
  @param instance_param_dict: mapping of instance name to parameters necessary
1495 1495
    for console information retrieval
1496 1496

  
......
1512 1512
  for inst_name in instance_param_dict:
1513 1513
    instance = instance_param_dict[inst_name]["instance"]
1514 1514
    pnode = instance_param_dict[inst_name]["node"]
1515
    group = instance_param_dict[inst_name]["group"]
1515 1516
    hvparams = instance_param_dict[inst_name]["hvParams"]
1516 1517
    beparams = instance_param_dict[inst_name]["beParams"]
1517 1518

  
1518 1519
    instance = objects.Instance.FromDict(instance)
1519 1520
    pnode = objects.Node.FromDict(pnode)
1521
    group = objects.NodeGroup.FromDict(group)
1520 1522

  
1521 1523
    h = get_hv_fn(instance.hypervisor)
1522
    output[inst_name] = h.GetInstanceConsole(instance, pnode, hvparams,
1523
                                             beparams).ToDict()
1524
    output[inst_name] = h.GetInstanceConsole(instance, pnode, group,
1525
                                             hvparams, beparams).ToDict()
1524 1526

  
1525 1527
  return output
1526 1528

  
b/lib/cmdlib/instance_operation.py
430 430
    self.cfg.MarkInstanceUp(self.instance.uuid)
431 431

  
432 432

  
433
def GetInstanceConsole(cluster, instance, primary_node):
433
def GetInstanceConsole(cluster, instance, primary_node, node_group):
434 434
  """Returns console information for an instance.
435 435

  
436 436
  @type cluster: L{objects.Cluster}
437 437
  @type instance: L{objects.Instance}
438 438
  @type primary_node: L{objects.Node}
439
  @type node_group: L{objects.NodeGroup}
439 440
  @rtype: dict
440 441

  
441 442
  """
......
444 445
  # instance and then saving the defaults in the instance itself.
445 446
  hvparams = cluster.FillHV(instance)
446 447
  beparams = cluster.FillBE(instance)
447
  console = hyper.GetInstanceConsole(instance, primary_node, hvparams, beparams)
448
  console = hyper.GetInstanceConsole(instance, primary_node, node_group,
449
                                     hvparams, beparams)
448 450

  
449 451
  assert console.instance == instance.name
450 452
  assert console.Validate()
......
503 505
    logging.debug("Connecting to console of %s on %s", self.instance.name,
504 506
                  self.cfg.GetNodeName(node_uuid))
505 507

  
506
    return GetInstanceConsole(self.cfg.GetClusterInfo(), self.instance,
507
                              self.cfg.GetNodeInfo(self.instance.primary_node))
508
    node = self.cfg.GetNodeInfo(self.instance.primary_node)
509
    group = self.cfg.GetNodeGroup(node.group)
510
    return GetInstanceConsole(self.cfg.GetClusterInfo(),
511
                              self.instance, node, group)
b/lib/cmdlib/instance_query.py
166 166
      for inst in instance_list:
167 167
        if inst.uuid in live_data:
168 168
          # Instance is running
169
          node = lu.cfg.GetNodeInfo(inst.primary_node)
170
          group = lu.cfg.GetNodeGroup(node.group)
169 171
          consinfo[inst.uuid] = \
170
            GetInstanceConsole(cluster, inst,
171
                               lu.cfg.GetNodeInfo(inst.primary_node))
172
            GetInstanceConsole(cluster, inst, node, group)
172 173
        else:
173 174
          consinfo[inst.uuid] = None
174 175
    else:
b/lib/hypervisor/hv_base.py
268 268
    raise NotImplementedError
269 269

  
270 270
  @classmethod
271
  def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
271
  def GetInstanceConsole(cls, instance, primary_node, node_group,
272
                         hvparams, beparams):
272 273
    """Return information for connecting to the console of an instance.
273 274

  
274 275
    """
b/lib/hypervisor/hv_chroot.py
260 260

  
261 261
  @classmethod
262 262
  def GetInstanceConsole(cls, instance, primary_node, # pylint: disable=W0221
263
                         hvparams, beparams, root_dir=None):
263
                         node_group, hvparams, beparams, root_dir=None):
264 264
    """Return information for connecting to the console of an instance.
265 265

  
266 266
    """
......
269 269
      if not os.path.ismount(root_dir):
270 270
        raise HypervisorError("Instance %s is not running" % instance.name)
271 271

  
272
    ndparams = node_group.FillND(primary_node)
272 273
    return objects.InstanceConsole(instance=instance.name,
273 274
                                   kind=constants.CONS_SSH,
274 275
                                   host=primary_node.name,
276
                                   port=ndparams.get(constants.ND_SSH_PORT),
275 277
                                   user=constants.SSH_CONSOLE_USER,
276 278
                                   command=["chroot", root_dir])
277 279

  
b/lib/hypervisor/hv_fake.py
228 228
    return result
229 229

  
230 230
  @classmethod
231
  def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
231
  def GetInstanceConsole(cls, instance, primary_node, node_group,
232
                         hvparams, beparams):
232 233
    """Return information for connecting to the console of an instance.
233 234

  
234 235
    """
b/lib/hypervisor/hv_kvm.py
2452 2452
    return result
2453 2453

  
2454 2454
  @classmethod
2455
  def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
2455
  def GetInstanceConsole(cls, instance, primary_node, node_group,
2456
                         hvparams, beparams):
2456 2457
    """Return a command for connecting to the console of an instance.
2457 2458

  
2458 2459
    """
......
2462 2463
             utils.ShellQuote(cls._InstanceMonitor(instance.name)),
2463 2464
             "STDIO,%s" % cls._SocatUnixConsoleParams(),
2464 2465
             "UNIX-CONNECT:%s" % cls._InstanceSerial(instance.name)]
2466
      ndparams = node_group.FillND(primary_node)
2465 2467
      return objects.InstanceConsole(instance=instance.name,
2466 2468
                                     kind=constants.CONS_SSH,
2467 2469
                                     host=primary_node.name,
2470
                                     port=ndparams.get(constants.ND_SSH_PORT),
2468 2471
                                     user=constants.SSH_CONSOLE_USER,
2469 2472
                                     command=cmd)
2470 2473

  
b/lib/hypervisor/hv_lxc.py
407 407
    return self.GetLinuxNodeInfo()
408 408

  
409 409
  @classmethod
410
  def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
410
  def GetInstanceConsole(cls, instance, primary_node, node_group,
411
                         hvparams, beparams):
411 412
    """Return a command for connecting to the console of an instance.
412 413

  
413 414
    """
415
    ndparams = node_group.FillND(primary_node)
414 416
    return objects.InstanceConsole(instance=instance.name,
415 417
                                   kind=constants.CONS_SSH,
416 418
                                   host=primary_node.name,
419
                                   port=ndparams.get(constants.ND_SSH_PORT),
417 420
                                   user=constants.SSH_CONSOLE_USER,
418 421
                                   command=["lxc-console", "-n", instance.name])
419 422

  
b/lib/hypervisor/hv_xen.py
772 772
    instance_list = self._GetInstanceList(True, hvparams)
773 773
    return _GetNodeInfo(result.stdout, instance_list)
774 774

  
775
  def GetInstanceConsole(self, instance, primary_node, hvparams, beparams):
775
  def GetInstanceConsole(self, instance, primary_node, node_group,
776
                         hvparams, beparams):
776 777
    """Return a command for connecting to the console of an instance.
777 778

  
778 779
    """
779 780
    xen_cmd = self._GetCommand(hvparams)
781
    ndparams = node_group.FillND(primary_node)
780 782
    return objects.InstanceConsole(instance=instance.name,
781 783
                                   kind=constants.CONS_SSH,
782 784
                                   host=primary_node.name,
785
                                   port=ndparams.get(constants.ND_SSH_PORT),
783 786
                                   user=constants.SSH_CONSOLE_USER,
784 787
                                   command=[pathutils.XEN_CONSOLE_WRAPPER,
785 788
                                            xen_cmd, instance.name])
b/test/py/ganeti.backend_unittest.py
619 619
    dictMaker = lambda hyName: {
620 620
      "instance":{"hypervisor":hyName},
621 621
      "node":{},
622
      "group":{},
622 623
      "hvParams":{},
623 624
      "beParams":{},
624 625
    }
b/test/py/ganeti.hypervisor.hv_chroot_unittest.py
44 44
  def test(self):
45 45
    instance = objects.Instance(name="fake.example.com",
46 46
                                primary_node="node837-uuid")
47
    node = objects.Node(name="node837", uuid="node837-uuid")
48
    cons = hv_chroot.ChrootManager.GetInstanceConsole(instance, node, {}, {},
47
    node = objects.Node(name="node837", uuid="node837-uuid", ndparams={})
48
    group = objects.NodeGroup(name="group164", ndparams={})
49
    cons = hv_chroot.ChrootManager.GetInstanceConsole(instance, node, group,
50
                                                      {}, {},
49 51
                                                      root_dir=self.tmpdir)
50 52
    self.assertTrue(cons.Validate())
51 53
    self.assertEqual(cons.kind, constants.CONS_SSH)
b/test/py/ganeti.hypervisor.hv_fake_unittest.py
35 35
class TestConsole(unittest.TestCase):
36 36
  def test(self):
37 37
    instance = objects.Instance(name="fake.example.com")
38
    node = objects.Node(name="fakenode.example.com")
39
    cons = hv_fake.FakeHypervisor.GetInstanceConsole(instance, node, {}, {})
38
    node = objects.Node(name="fakenode.example.com", ndparams={})
39
    group = objects.NodeGroup(name="default", ndparams={})
40
    cons = hv_fake.FakeHypervisor.GetInstanceConsole(instance, node, group,
41
                                                     {}, {})
40 42
    self.assertTrue(cons.Validate())
41 43
    self.assertEqual(cons.kind, constants.CONS_MESSAGE)
42 44

  
b/test/py/ganeti.hypervisor.hv_kvm_unittest.py
200 200

  
201 201

  
202 202
class TestConsole(unittest.TestCase):
203
  def _Test(self, instance, node, hvparams):
204
    cons = hv_kvm.KVMHypervisor.GetInstanceConsole(instance, node, hvparams, {})
203
  def _Test(self, instance, node, group, hvparams):
204
    cons = hv_kvm.KVMHypervisor.GetInstanceConsole(instance, node, group,
205
                                                   hvparams, {})
205 206
    self.assertTrue(cons.Validate())
206 207
    return cons
207 208

  
208 209
  def testSerial(self):
209 210
    instance = objects.Instance(name="kvm.example.com",
210 211
                                primary_node="node6017-uuid")
211
    node = objects.Node(name="node6017", uuid="node6017-uuid")
212
    node = objects.Node(name="node6017", uuid="node6017-uuid",
213
                        ndparams={})
214
    group = objects.NodeGroup(name="group6134", ndparams={})
212 215
    hvparams = {
213 216
      constants.HV_SERIAL_CONSOLE: True,
214 217
      constants.HV_VNC_BIND_ADDRESS: None,
215 218
      constants.HV_KVM_SPICE_BIND: None,
216 219
      }
217
    cons = self._Test(instance, node, hvparams)
220
    cons = self._Test(instance, node, group, hvparams)
218 221
    self.assertEqual(cons.kind, constants.CONS_SSH)
219 222
    self.assertEqual(cons.host, node.name)
220 223
    self.assertEqual(cons.command[0], pathutils.KVM_CONSOLE_WRAPPER)
......
224 227
    instance = objects.Instance(name="kvm.example.com",
225 228
                                primary_node="node7235-uuid",
226 229
                                network_port=constants.VNC_BASE_PORT + 10)
227
    node = objects.Node(name="node7235", uuid="node7235-uuid")
230
    node = objects.Node(name="node7235", uuid="node7235-uuid",
231
                        ndparams={})
232
    group = objects.NodeGroup(name="group3632", ndparams={})
228 233
    hvparams = {
229 234
      constants.HV_SERIAL_CONSOLE: False,
230 235
      constants.HV_VNC_BIND_ADDRESS: "192.0.2.1",
231 236
      constants.HV_KVM_SPICE_BIND: None,
232 237
      }
233
    cons = self._Test(instance, node, hvparams)
238
    cons = self._Test(instance, node, group, hvparams)
234 239
    self.assertEqual(cons.kind, constants.CONS_VNC)
235 240
    self.assertEqual(cons.host, "192.0.2.1")
236 241
    self.assertEqual(cons.port, constants.VNC_BASE_PORT + 10)
......
240 245
    instance = objects.Instance(name="kvm.example.com",
241 246
                                primary_node="node7235",
242 247
                                network_port=11000)
243
    node = objects.Node(name="node7235", uuid="node7235-uuid")
248
    node = objects.Node(name="node7235", uuid="node7235-uuid",
249
                        ndparams={})
250
    group = objects.NodeGroup(name="group0132", ndparams={})
244 251
    hvparams = {
245 252
      constants.HV_SERIAL_CONSOLE: False,
246 253
      constants.HV_VNC_BIND_ADDRESS: None,
247 254
      constants.HV_KVM_SPICE_BIND: "192.0.2.1",
248 255
      }
249
    cons = self._Test(instance, node, hvparams)
256
    cons = self._Test(instance, node, group, hvparams)
250 257
    self.assertEqual(cons.kind, constants.CONS_SPICE)
251 258
    self.assertEqual(cons.host, "192.0.2.1")
252 259
    self.assertEqual(cons.port, 11000)
......
255 262
    instance = objects.Instance(name="kvm.example.com",
256 263
                                primary_node="node24325",
257 264
                                network_port=0)
258
    node = objects.Node(name="node24325", uuid="node24325-uuid")
265
    node = objects.Node(name="node24325", uuid="node24325-uuid",
266
                        ndparams={})
267
    group = objects.NodeGroup(name="group9184", ndparams={})
259 268
    hvparams = {
260 269
      constants.HV_SERIAL_CONSOLE: False,
261 270
      constants.HV_VNC_BIND_ADDRESS: None,
262 271
      constants.HV_KVM_SPICE_BIND: None,
263 272
      }
264
    cons = self._Test(instance, node, hvparams)
273
    cons = self._Test(instance, node, group, hvparams)
265 274
    self.assertEqual(cons.kind, constants.CONS_MESSAGE)
266 275

  
267 276

  
b/test/py/ganeti.hypervisor.hv_lxc_unittest.py
36 36
  def test(self):
37 37
    instance = objects.Instance(name="lxc.example.com",
38 38
                                primary_node="node199-uuid")
39
    node = objects.Node(name="node199", uuid="node199-uuid")
40
    cons = hv_lxc.LXCHypervisor.GetInstanceConsole(instance, node, {}, {})
39
    node = objects.Node(name="node199", uuid="node199-uuid",
40
                        ndparams={})
41
    group = objects.NodeGroup(name="group991", ndparams={})
42
    cons = hv_lxc.LXCHypervisor.GetInstanceConsole(instance, node, group,
43
                                                   {}, {})
41 44
    self.assertTrue(cons.Validate())
42 45
    self.assertEqual(cons.kind, constants.CONS_SSH)
43 46
    self.assertEqual(cons.host, node.name)
b/test/py/ganeti.hypervisor.hv_xen_unittest.py
53 53
    for cls in [hv_xen.XenPvmHypervisor(), hv_xen.XenHvmHypervisor()]:
54 54
      instance = objects.Instance(name="xen.example.com",
55 55
                                  primary_node="node24828-uuid")
56
      node = objects.Node(name="node24828", uuid="node24828-uuid")
57
      cons = cls.GetInstanceConsole(instance, node, hvparams, {})
56
      node = objects.Node(name="node24828", uuid="node24828-uuid",
57
                          ndparams={})
58
      group = objects.NodeGroup(name="group52341", ndparams={})
59
      cons = cls.GetInstanceConsole(instance, node, group, hvparams, {})
58 60
      self.assertTrue(cons.Validate())
59 61
      self.assertEqual(cons.kind, constants.CONS_SSH)
60 62
      self.assertEqual(cons.host, node.name)

Also available in: Unified diff