Synnefo » snf-ganeti » ganeti-local

      if qa_config.TestEnabled("instance-import"):

        newinst = qa_config.AcquireInstance()

        try:

                  expnode, name)

          RunTest(qa_instance.TestInstanceRemove, newinst)

        finally:

import qa_error

from qa_utils import AssertIn, AssertCommand, AssertEqual

def _GetDiskStatePath(disk):

    raise

def TestInstanceAddWithPlainDisk(node):

  """gnt-instance add -t plain"""

  return _DiskTest(node["primary"], "plain")

def TestInstanceAddWithDrbdDisk(node, node2):

  """gnt-instance add -t drbd"""

  return _DiskTest("%s:%s" % (node["primary"], node2["primary"]),

                   "drbd")

def TestInstanceRemove(instance):

  """gnt-instance remove"""

  AssertCommand(["gnt-instance", "remove", "-f", instance["name"]])

  qa_config.ReleaseInstance(instance)

def TestInstanceStartup(instance):

  """gnt-instance startup"""

  AssertCommand(["gnt-instance", "startup", instance["name"]])

def TestInstanceShutdown(instance):

  """gnt-instance shutdown"""

  AssertCommand(["gnt-instance", "shutdown", instance["name"]])

def TestInstanceReboot(instance):

  """gnt-instance reboot"""

  options = qa_config.get("options", {})

    AssertCommand(["gnt-instance", "reboot", "--type=%s" % rtype, name])

  AssertCommand(["gnt-instance", "shutdown", name])

  AssertCommand(["gnt-instance", "reboot", name])

  master = qa_config.GetMasterNode()

  AssertEqual(result_output.strip(), constants.INSTST_RUNNING)

def TestInstanceReinstall(instance):

  """gnt-instance reinstall"""

  AssertCommand(["gnt-instance", "reinstall", "-f", instance["name"]])

           _ReadSsconfInstanceList())

def TestInstanceRenameAndBack(rename_source, rename_target):

  """gnt-instance rename

  """

  _CheckSsconfInstanceList(rename_source)

  # first do a rename to a different actual name, expecting it to fail

  qa_utils.AddToEtcHosts(["meeeeh-not-exists", rename_target])

  try:

    _CheckSsconfInstanceList(rename_source)

  finally:

    qa_utils.RemoveFromEtcHosts(["meeeeh-not-exists", rename_target])

  # and now rename instance to rename_target...

  AssertCommand(["gnt-instance", "rename", rename_source, rename_target])

  _CheckSsconfInstanceList(rename_target)

  # and back

  AssertCommand(["gnt-instance", "rename", rename_target, rename_source])

  _CheckSsconfInstanceList(rename_source)

def TestInstanceFailover(instance):

  """gnt-instance failover"""

  cmd = ["gnt-instance", "failover", "--force", instance["name"]]

  # failover ...

  AssertCommand(cmd)

  # ... and back

  AssertCommand(cmd)

def TestInstanceMigrate(instance):

  """gnt-instance migrate"""

  cmd = ["gnt-instance", "migrate", "--force", instance["name"]]

  # migrate ...

  AssertCommand(cmd)

  # ... and back

  AssertCommand(cmd)

  AssertCommand(["gnt-instance", "shutdown", instance["name"]])

  AssertCommand(cmd, fail=True)

  AssertCommand(["gnt-instance", "migrate", "--force", "--allow-failover",

                 instance["name"]])

  AssertCommand(["gnt-instance", "start", instance["name"]])

  AssertCommand(cmd)

  AssertCommand(["gnt-instance", "modify", "-B",

                 ("%s=%s" %

                  (constants.BE_ALWAYS_FAILOVER, constants.VALUE_TRUE)),

                 instance["name"]])

  AssertCommand(cmd, fail=True)

  AssertCommand(["gnt-instance", "migrate", "--force", "--allow-failover",

                 instance["name"]])

  AssertCommand(["gnt-instance", "modify", "-B",

                 ("%s=%s" %

                  (constants.BE_ALWAYS_FAILOVER, constants.VALUE_FALSE)),

                 instance["name"]])

  AssertCommand(cmd)

def TestInstanceInfo(instance):

  AssertCommand(["gnt-instance", "info", instance["name"]])

def TestInstanceModify(instance):

  """gnt-instance modify"""

  # Assume /sbin/init exists on all systems

    AssertCommand(["gnt-instance", "modify", arg, instance["name"]], fail=True)

def TestInstanceStoppedModify(instance):

  """gnt-instance modify (stopped instance)"""

  name = instance["name"]

  AssertCommand(["gnt-instance", "modify", "--online", name])

def TestInstanceConvertDisk(instance, snode):

  """gnt-instance modify -t"""

  name = instance["name"]

                 "-n", snode["primary"], name])

def TestInstanceGrowDisk(instance):

  """gnt-instance grow-disk"""

  name = instance["name"]

  qa_utils.GenericQueryFieldsTest("gnt-instance", query.INSTANCE_FIELDS.keys())

def TestInstanceConsole(instance):

  """gnt-instance console"""

  AssertCommand(["gnt-instance", "console", "--show-cmd", instance["name"]])

def TestReplaceDisks(instance, pnode, snode, othernode):

  """gnt-instance replace-disks"""

  # pylint: disable=W0613

  AssertCommand(["gnt-instance", "start", instance["name"]])

def TestInstanceExport(instance, node):

  """gnt-backup export -n ..."""

  name = instance["name"]

  return qa_utils.ResolveInstanceName(name)

def TestInstanceExportWithRemove(instance, node):

  """gnt-backup export --remove-instance"""

  AssertCommand(["gnt-backup", "export", "-n", node["primary"],

                 "--remove-instance", instance["name"]])

def TestInstanceExportNoTarget(instance):

  """gnt-backup export (without target node, should fail)"""

  AssertCommand(["gnt-backup", "export", instance["name"]], fail=True)

  """gnt-backup import"""

  cmd = (["gnt-backup", "import",

          "--disk-template=plain",

import qa_error

from qa_utils import (AssertEqual, AssertIn, AssertMatch, StartLocalCommand)

_rapi_ca = None

        ])

def TestInstance(instance):

  """Testing getting instance(s) info via remote API.

    raise

def TestRapiInstanceRemove(instance, use_client):

  """Test removing instance via RAPI"""

  if use_client:

  qa_config.ReleaseInstance(instance)

def TestRapiInstanceMigrate(instance):

  """Test migrating instance via RAPI"""

  # Move to secondary node

  _WaitForRapiJob(_rapi_client.MigrateInstance(instance["name"]))

  # And back to previous primary

  _WaitForRapiJob(_rapi_client.MigrateInstance(instance["name"]))

def TestRapiInstanceFailover(instance):

  """Test failing over instance via RAPI"""

  # Move to secondary node

  _WaitForRapiJob(_rapi_client.FailoverInstance(instance["name"]))

  # And back to previous primary

  _WaitForRapiJob(_rapi_client.FailoverInstance(instance["name"]))

def TestRapiInstanceShutdown(instance):

  """Test stopping an instance via RAPI"""

  _WaitForRapiJob(_rapi_client.ShutdownInstance(instance["name"]))

def TestRapiInstanceStartup(instance):

  """Test starting an instance via RAPI"""

  _WaitForRapiJob(_rapi_client.StartupInstance(instance["name"]))

def TestRapiInstanceRenameAndBack(rename_source, rename_target):

  """Test renaming instance via RAPI

  """

  _WaitForRapiJob(_rapi_client.RenameInstance(rename_source, rename_target))

  _WaitForRapiJob(_rapi_client.RenameInstance(rename_target, rename_source))

def TestRapiInstanceReinstall(instance):

  """Test reinstalling an instance via RAPI"""

  _WaitForRapiJob(_rapi_client.ReinstallInstance(instance["name"]))

def TestRapiInstanceReplaceDisks(instance):

  """Test replacing instance disks via RAPI"""

  _WaitForRapiJob(_rapi_client.ReplaceInstanceDisks(instance["name"],

    mode=constants.REPLACE_DISK_SEC, disks="0"))

def TestRapiInstanceModify(instance):

  """Test modifying instance via RAPI"""

  def _ModifyInstance(**kwargs):

    })

def TestRapiInstanceConsole(instance):

  """Test getting instance console information via RAPI"""

  result = _rapi_client.GetInstanceConsole(instance["name"])

  AssertEqual(console.instance, qa_utils.ResolveInstanceName(instance["name"]))

def TestRapiStoppedInstanceConsole(instance):

  """Test getting stopped instance's console information via RAPI"""

  try:

      si,

      ]

    AssertEqual(StartLocalCommand(cmd).wait(), 0)