Revision 11064155

b/lib/bdev.py
592 592 
    stripes = min(current_pvs, desired_stripes)
593 593 

  		





  594
  594
  
    
    if excl_stor:


  		





  595
  
  
    
      err_msgs = utils.LvmExclusiveCheckNodePvs(pvs_info)


  		





  
  595
  
    
      (err_msgs, _) = utils.LvmExclusiveCheckNodePvs(pvs_info)


  		





  596
  596
  
    
      if err_msgs:


  		





  597
  597
  
    
        for m in err_msgs:


  		





  598
  598
  
    
          logging.warning(m)


  		












  

    
      b/lib/utils/lvm.py
    
  






  55
  55
  
    

  		





  56
  56
  
    
  @type pvs_info: list


  		





  57
  57
  
    
  @param pvs_info: list of L{LvmPvInfo} objects


  		





  58
  
  
    
  @rtype: list


  		





  59
  
  
    
  @return: A list of error strings described the violation found, or an empty


  		





  60
  
  
    
      list if everything is ok


  		





  
  58
  
    
  @rtype: tuple


  		





  
  59
  
    
  @return: A pair composed of: 1. a list of error strings describing the


  		





  
  60
  
    
    violations found, or an empty list if everything is ok; 2. a pair


  		





  
  61
  
    
    containing the sizes of the smallest and biggest PVs, in MiB.


  		





  
  62
  
    

  		





  61
  63
  
    
  """


  		





  62
  64
  
    
  errmsgs = []


  		





  63
  65
  
    
  sizes = [pv.size for pv in pvs_info]


  		





  ......




  67
  69
  
    
  if LvmExclusiveTestBadPvSizes(small, big):


  		





  68
  70
  
    
    m = ("Sizes of PVs are too different: min=%d max=%d" % (small, big))


  		





  69
  71
  
    
    errmsgs.append(m)


  		





  70
  
  
    
  return errmsgs


  		





  
  72
  
    
  return (errmsgs, (small, big))


  		





  71
  73
  
    

  		





  72
  74
  
    

  		





  73
  75
  
    
def LvmExclusiveTestBadPvSizes(small, big):


  		












  

    
      b/test/py/ganeti.utils.lvm_unittest.py
    
  






  43
  43
  
    
  _EPS = 1e-4


  		





  44
  44
  
    

  		





  45
  45
  
    
  def testOnePv(self):


  		





  46
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([self._MED_PV])


  		





  
  46
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs([self._MED_PV])


  		





  47
  47
  
    
    self.assertFalse(errmsgs)


  		





  
  48
  
    
    self.assertEqual(small, self._MED_PV.size)


  		





  
  49
  
    
    self.assertEqual(big, self._MED_PV.size)


  		





  48
  50
  
    

  		





  49
  51
  
    
  def testEqualPvs(self):


  		





  50
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([self._MED_PV] * 2)


  		





  
  52
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  53
  
    
      [self._MED_PV] * 2)


  		





  51
  54
  
    
    self.assertFalse(errmsgs)


  		





  52
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([self._SMALL_PV] * 3)


  		





  
  55
  
    
    self.assertEqual(small, self._MED_PV.size)


  		





  
  56
  
    
    self.assertEqual(big, self._MED_PV.size)


  		





  
  57
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  58
  
    
      [self._SMALL_PV] * 3)


  		





  53
  59
  
    
    self.assertFalse(errmsgs)


  		





  
  60
  
    
    self.assertEqual(small, self._SMALL_PV.size)


  		





  
  61
  
    
    self.assertEqual(big, self._SMALL_PV.size)


  		





  54
  62
  
    

  		





  55
  63
  
    
  def testTooDifferentPvs(self):


  		





  56
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([self._MED_PV, self._BIG_PV])


  		





  
  64
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  65
  
    
      [self._MED_PV, self._BIG_PV])


  		





  57
  66
  
    
    self.assertEqual(len(errmsgs), 1)


  		





  58
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([self._MED_PV, self._SMALL_PV])


  		





  
  67
  
    
    self.assertEqual(small, self._MED_PV.size)


  		





  
  68
  
    
    self.assertEqual(big, self._BIG_PV.size)


  		





  
  69
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  70
  
    
      [self._MED_PV, self._SMALL_PV])


  		





  59
  71
  
    
    self.assertEqual(len(errmsgs), 1)


  		





  
  72
  
    
    self.assertEqual(small, self._SMALL_PV.size)


  		





  
  73
  
    
    self.assertEqual(big, self._MED_PV.size)


  		





  60
  74
  
    

  		





  61
  75
  
    
  def testBoundarySizeCases(self):


  		





  62
  76
  
    
    medpv1 = self._MED_PV.Copy()


  		





  63
  77
  
    
    medpv2 = self._MED_PV.Copy()


  		





  64
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([medpv1, medpv2, self._MED_PV])


  		





  
  78
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  79
  
    
      [medpv1, medpv2, self._MED_PV])


  		





  65
  80
  
    
    self.assertFalse(errmsgs)


  		





  
  81
  
    
    self.assertEqual(small, self._MED_PV.size)


  		





  
  82
  
    
    self.assertEqual(big, self._MED_PV.size)


  		





  66
  83
  
    
    # Just within the margins


  		





  67
  84
  
    
    medpv1.size = self._MED_PV.size * (1 - constants.PART_MARGIN + self._EPS)


  		





  68
  85
  
    
    medpv2.size = self._MED_PV.size * (1 + constants.PART_MARGIN - self._EPS)


  		





  69
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([medpv1, medpv2, self._MED_PV])


  		





  
  86
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  87
  
    
      [medpv1, medpv2, self._MED_PV])


  		





  70
  88
  
    
    self.assertFalse(errmsgs)


  		





  
  89
  
    
    self.assertEqual(small, medpv1.size)


  		





  
  90
  
    
    self.assertEqual(big, medpv2.size)


  		





  71
  91
  
    
    # Just outside the margins


  		





  72
  92
  
    
    medpv1.size = self._MED_PV.size * (1 - constants.PART_MARGIN - self._EPS)


  		





  73
  93
  
    
    medpv2.size = self._MED_PV.size * (1 + constants.PART_MARGIN)


  		





  74
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([medpv1, medpv2, self._MED_PV])


  		





  
  94
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  95
  
    
      [medpv1, medpv2, self._MED_PV])


  		





  75
  96
  
    
    self.assertTrue(errmsgs)


  		





  
  97
  
    
    self.assertEqual(small, medpv1.size)


  		





  
  98
  
    
    self.assertEqual(big, medpv2.size)


  		





  76
  99
  
    
    medpv1.size = self._MED_PV.size * (1 - constants.PART_MARGIN)


  		





  77
  100
  
    
    medpv2.size = self._MED_PV.size * (1 + constants.PART_MARGIN + self._EPS)


  		





  78
  
  
    
    errmsgs = utils.LvmExclusiveCheckNodePvs([medpv1, medpv2, self._MED_PV])


  		





  
  101
  
    
    (errmsgs, (small, big)) = utils.LvmExclusiveCheckNodePvs(


  		





  
  102
  
    
      [medpv1, medpv2, self._MED_PV])


  		





  79
  103
  
    
    self.assertTrue(errmsgs)


  		





  
  104
  
    
    self.assertEqual(small, medpv1.size)


  		





  
  105
  
    
    self.assertEqual(big, medpv2.size)


  		





  80
  106
  
    

  		





  81
  107
  
    

  		





  82
  108
  
    
if __name__ == "__main__":


  		












Also available in:
  Unified diff