Revision ec996117 qa/qa_group.py

b/qa/qa_group.py
87 87 
  @rtype: tuple
88 88 
  @return: (policy, specs), where:
89 89 
      - policy is a dictionary of the policy values, instance specs excluded
90 
      - specs is dict of dict, specs[par][key] is a spec value, where key is
90 
      - specs is dict of dict, specs[key][par] is a spec value, where key is
91 91 
        "min" or "max"
92 92 

  		





  93
  93
  
    
  """


  		





  ......




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


  		





  99
  99
  
    

  		





  100
  100
  
    
  # Sanity checks


  		





  101
  
  
    
  assert len(ret_specs) > 0


  		





  102
  
  
    
  good = all("min" in d and "max" in d


  		





  103
  
  
    
             for d in ret_specs.values())


  		





  104
  
  
    
  assert good, "Missing item in specs: %s" % ret_specs


  		





  
  101
  
    
  assert "min" in ret_specs and "max" in ret_specs


  		





  105
  102
  
    
  assert len(ret_policy) > 0


  		





  106
  103
  
    
  return (ret_policy, ret_specs)


  		





  107
  104
  
    

  		





  108
  105
  
    

  		





  109
  
  
    
def _TestGroupSetISpecs(groupname, new_specs, fail=False, old_values=None):


  		





  
  106
  
    
def _TestGroupSetISpecs(groupname, new_specs=None, diff_specs=None,


  		





  
  107
  
    
                        fail=False, old_values=None):


  		





  110
  108
  
    
  """Change instance specs on a group.


  		





  111
  109
  
    

  		





  
  110
  
    
  At most one of new_specs or diff_specs can be specified.


  		





  
  111
  
    

  		





  112
  112
  
    
  @type groupname: string


  		





  113
  113
  
    
  @param groupname: group name


  		





  114
  
  
    
  @type new_specs: dict of dict


  		





  115
  
  
    
  @param new_specs: new_specs[par][key], where key is "min", "max", "std". It


  		





  116
  
  
    
      can be an empty dictionary.


  		





  
  114
  
    
  @type new_specs: dict


  		





  
  115
  
    
  @param new_specs: new complete specs, in the same format returned by


  		





  
  116
  
    
      L{_GetGroupIPolicy}


  		





  
  117
  
    
  @type diff_specs: dict


  		





  
  118
  
    
  @param diff_specs: diff_specs[key][par], where key is "min", "max". It


  		





  
  119
  
    
      can be an incomplete specifications or an empty dictionary.


  		





  117
  120
  
    
  @type fail: bool


  		





  118
  121
  
    
  @param fail: if the change is expected to fail


  		





  119
  122
  
    
  @type old_values: tuple


  		





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


  		





  121
  
  
    
     L{_GetGroupIPolicy}


  		





  
  124
  
    
      L{_GetGroupIPolicy}


  		





  122
  125
  
    
  @return: same as L{_GetGroupIPolicy}


  		





  123
  126
  
    

  		





  124
  127
  
    
  """


  		





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


  		





  126
  129
  
    
  get_policy = lambda: _GetGroupIPolicy(groupname)


  		





  127
  
  
    
  return qa_utils.TestSetISpecs(new_specs, get_policy_fn=get_policy,


  		





  128
  
  
    
                                build_cmd_fn=build_cmd, fail=fail,


  		





  129
  
  
    
                                old_values=old_values)


  		





  
  130
  
    
  return qa_utils.TestSetISpecs(


  		





  
  131
  
    
    new_specs=new_specs, diff_specs=diff_specs,


  		





  
  132
  
    
    get_policy_fn=get_policy, build_cmd_fn=build_cmd,


  		





  
  133
  
    
    fail=fail, old_values=old_values)


  		





  130
  134
  
    

  		





  131
  135
  
    

  		





  132
  136
  
    
def _TestGroupModifyISpecs(groupname):


  		





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


  		





  134
  138
  
    
  # the node group under test


  		





  135
  139
  
    
  old_values = _GetGroupIPolicy(groupname)


  		





  136
  
  
    
  mod_values = _TestGroupSetISpecs(groupname,


  		





  137
  
  
    
                                   dict((p, {"min": 4, "max": 4})


  		





  138
  
  
    
                                        for p in constants.ISPECS_PARAMETERS),


  		





  
  140
  
    
  samevals = dict((p, 4) for p in constants.ISPECS_PARAMETERS)


  		





  
  141
  
    
  base_specs = {"min": samevals, "max": samevals}


  		





  
  142
  
    
  mod_values = _TestGroupSetISpecs(groupname, new_specs=base_specs,


  		





  139
  143
  
    
                                   old_values=old_values)


  		





  140
  144
  
    
  for par in constants.ISPECS_PARAMETERS:


  		





  141
  145
  
    
    # First make sure that the test works with good values


  		





  142
  
  
    
    mod_values = _TestGroupSetISpecs(groupname, {par: {"min": 8, "max": 8}},


  		





  
  146
  
    
    good_specs = {"min": {par: 8}, "max": {par: 8}}


  		





  
  147
  
    
    mod_values = _TestGroupSetISpecs(groupname, diff_specs=good_specs,


  		





  143
  148
  
    
                                     old_values=mod_values)


  		





  144
  
  
    
    _TestGroupSetISpecs(groupname, {par: {"min": 8, "max": 4}},


  		





  145
  
  
    
                        fail=True, old_values=mod_values)


  		





  
  149
  
    
    bad_specs = {"min": {par: 8}, "max": {par: 4}}


  		





  
  150
  
    
    _TestGroupSetISpecs(groupname, diff_specs=bad_specs, fail=True,


  		





  
  151
  
    
                        old_values=mod_values)


  		





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


  		





  147
  153
  
    
                 groupname])


  		





  148
  154
  
    
  AssertEqual(_GetGroupIPolicy(groupname), old_values)


  		












Also available in:
  Unified diff