Synnefo » snf-ganeti » ganeti-local

def _BuildSpecDict(par, mn, st, mx):

def TestIPolicyPlainInstance():

    return

  # This test assumes that the group policy is empty

  node = qa_config.AcquireNode()

  try:

    history = []

    instance = qa_instance.TestInstanceAddWithPlainDisk([node])

    try:

        (iminval, imaxval) = qa_instance.GetInstanceSpec(instance.name, par)

        # Some specs must be multiple of 4

        new_spec = _BuildSpecDict(par, imaxval + 4, imaxval + 4, imaxval + 4)

        qa_cluster.AssertClusterVerify(warnings=policyerror)

        if iminval > 0:

          # Some specs must be multiple of 4

          else:

            upper = iminval - 1

          new_spec = _BuildSpecDict(par, 0, upper, upper)

          qa_cluster.AssertClusterVerify(warnings=policyerror)

      qa_instance.TestInstanceRemove(instance)

    finally:

      instance.Release()

    # Now we replay the same policy changes, and we expect that the instance

    # cannot be created for the cases where we had a policy violation above

      if failed:

        qa_instance.TestInstanceAddWithPlainDisk([node], fail=True)

      # Instance creation with no policy violation has been tested already

  @rtype: tuple

  @return: (policy, specs), where:

      - policy is a dictionary of the policy values, instance specs excluded

        "min", "max", or "std"

  """

  (ret_policy, ret_specs) = qa_utils.ParseIPolicy(policy)

  # Sanity checks

  assert len(ret_policy) > 0

  return (ret_policy, ret_specs)

      AssertEqual(eff_policy[p], old_policy[p])

  """Change instance specs.

  @type fail: bool

  @param fail: if the change is expected to fail

  @type old_values: tuple

  @param old_values: (old_policy, old_specs), as returned by

  @return: same as L{_GetClusterIPolicy}

  """

  build_cmd = lambda opts: ["gnt-cluster", "modify"] + opts

def TestClusterModifyISpecs():

      (False, 0, 4, "a"),

      # This is to restore the old values

      (True,

      ]

    for (good, mn, st, mx) in test_values:

      cur_state = (cur_policy, cur_specs)

      # We update cur_specs, as we've copied the values to restore already

    # Get the ipolicy command

    mnode = qa_config.GetMasterNode()

  @rtype: tuple

  @return: (policy, specs), where:

      - policy is a dictionary of the policy values, instance specs excluded

        "min" or "max"

  """

  (ret_policy, ret_specs) = qa_utils.ParseIPolicy(policy)

  # Sanity checks

  assert len(ret_policy) > 0

  return (ret_policy, ret_specs)

  """Change instance specs on a group.

  @type groupname: string

  @param groupname: group name

  @type fail: bool

  @param fail: if the change is expected to fail

  @type old_values: tuple

  @param old_values: (old_policy, old_specs), as returned by

  @return: same as L{_GetGroupIPolicy}

  """

  build_cmd = lambda opts: ["gnt-group", "modify"] + opts + [groupname]

  get_policy = lambda: _GetGroupIPolicy(groupname)

def _TestGroupModifyISpecs(groupname):

  # This test is built on the assumption that the default ipolicy holds for

  # the node group under test

  old_values = _GetGroupIPolicy(groupname)

                                   old_values=old_values)

  for par in constants.ISPECS_PARAMETERS:

    # First make sure that the test works with good values

                                     old_values=mod_values)

  AssertCommand(["gnt-group", "modify", "--ipolicy-bounds-specs", "default",

                 groupname])

  AssertEqual(_GetGroupIPolicy(groupname), old_values)

"""

import operator

import os

import random

    return path

  """Helper to build policy options."""

  return ",".join(values)

  """Change instance specs for an object.

  @type get_policy_fn: function

  @param get_policy_fn: function that returns the current policy as in

  @type build_cmd_fn: function

  @param build_cmd_fn: function that return the full command line from the

      options alone

  @param fail: if the change is expected to fail

  @type old_values: tuple

  @param old_values: (old_policy, old_specs), as returned by

  """

  assert get_policy_fn is not None

  assert build_cmd_fn is not None

  if old_values:

    (old_policy, old_specs) = old_values

  else:

    (old_policy, old_specs) = get_policy_fn()

  if new_specs:

    cmd = []

      minmax_opt_items = []

      for key in ["min", "max"]:

        minmax_opt_items.append("%s:%s" % (key, keyopt))

      cmd.extend([

        "--ipolicy-bounds-specs",

        "/".join(minmax_opt_items)

        ])

    if std_opt:

      cmd.extend(["--ipolicy-std-specs", std_opt])

    AssertCommand(build_cmd_fn(cmd), fail=fail)

  else:

  return (eff_policy, eff_specs)

  @rtype: tuple

  @return: (policy, specs), where:

      - policy is a dictionary of the policy values, instance specs excluded

        "min", "max", or "std"

  """

  ispec_keys = constants.ISPECS_MINMAX_KEYS | frozenset([constants.ISPECS_STD])

  for (key, val) in policy.items():

    if key in ispec_keys:

    else:

      ret_policy[key] = val

  return (ret_policy, ret_specs)