openstack/swift
Code Issues Proposed changes

Merge "Fix typos and grammer in builder.py"

Browse Source
This commit is contained in:
Jenkins 2016-08-23 22:09:12 +00:00 committed by Gerrit Code Review
commit 075b081cb1
1 changed files with 16 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
swift/common/ring/builder.py
View File

@ -407,8 +407,8 @@ class RingBuilder(object):
lot more analysis and therefore a lot more time -- I had code that did lot more analysis and therefore a lot more time -- I had code that did
that before). Because of this, it keeps rebalancing until the device that before). Because of this, it keeps rebalancing until the device
skew (number of partitions a device wants compared to what it has) gets skew (number of partitions a device wants compared to what it has) gets
below 1% or doesn't change by more than 1% (only happens with ring that below 1% or doesn't change by more than 1% (only happens with a ring
can't be balanced no matter what). that can't be balanced no matter what).
:returns: (number_of_partitions_altered, resulting_balance, :returns: (number_of_partitions_altered, resulting_balance,
number_of_removed_devices) number_of_removed_devices)
@ -494,7 +494,7 @@ class RingBuilder(object):
Build a dict of all tiers in the cluster to a list of the number of Build a dict of all tiers in the cluster to a list of the number of
parts with a replica count at each index. The values of the dict will parts with a replica count at each index. The values of the dict will
be lists of length the maximum whole replica + 1 so that the be lists of length the maximum whole replica + 1 so that the
graph[tier][3] is the number of parts with in the tier with 3 replicas graph[tier][3] is the number of parts within the tier with 3 replicas
and graph [tier][0] is the number of parts not assigned in this tier. and graph [tier][0] is the number of parts not assigned in this tier.
i.e. i.e.
@ -509,7 +509,7 @@ class RingBuilder(object):
} }
:param old_replica2part2dev: if called from rebalance, the :param old_replica2part2dev: if called from rebalance, the
old_replica2part2dev can be used to count moved moved parts. old_replica2part2dev can be used to count moved parts.
:returns: number of parts with different assignments than :returns: number of parts with different assignments than
old_replica2part2dev if provided old_replica2part2dev if provided
@ -693,7 +693,7 @@ class RingBuilder(object):
def get_balance(self): def get_balance(self):
""" """
Get the balance of the ring. The balance value is the highest Get the balance of the ring. The balance value is the highest
percentage off the desired amount of partitions a given device percentage of the desired amount of partitions a given device
wants. For instance, if the "worst" device wants (based on its wants. For instance, if the "worst" device wants (based on its
weight relative to the sum of all the devices' weights) 123 weight relative to the sum of all the devices' weights) 123
partitions and it has 124 partitions, the balance value would partitions and it has 124 partitions, the balance value would
@ -710,7 +710,7 @@ class RingBuilder(object):
dispersed. dispersed.
The required overload is the largest percentage change of any single The required overload is the largest percentage change of any single
device from its weighted replicanth to its wanted replicanth (note device from its weighted replicanth to its wanted replicanth (note:
under weighted devices have a negative percentage change) to archive under weighted devices have a negative percentage change) to archive
dispersion - that is to say a single device that must be overloaded by dispersion - that is to say a single device that must be overloaded by
5% is worse than 5 devices in a single tier overloaded by 1%. 5% is worse than 5 devices in a single tier overloaded by 1%.
@ -992,9 +992,10 @@ class RingBuilder(object):
undispersed_dev_replicas.sort( undispersed_dev_replicas.sort(
key=lambda dr: dr[0]['parts_wanted']) key=lambda dr: dr[0]['parts_wanted'])
for dev, replica in undispersed_dev_replicas: for dev, replica in undispersed_dev_replicas:
# the min part hour check is ignored iff a device has more # the min part hour check is ignored if and only if a device
# than one replica of a part assigned to it - which would have # has more than one replica of a part assigned to it - which
# only been possible on rings built with older version of code # would have only been possible on rings built with an older
# version of the code
if (self._last_part_moves[part] < self.min_part_hours and if (self._last_part_moves[part] < self.min_part_hours and
not replicas_at_tier[dev['tiers'][-1]] > 1): not replicas_at_tier[dev['tiers'][-1]] > 1):
continue continue
@ -1072,8 +1073,8 @@ class RingBuilder(object):
""" """
Gather parts that look like they should move for balance reasons. Gather parts that look like they should move for balance reasons.
A simple gather of parts that looks dispersible normally works out, A simple gathers of parts that looks dispersible normally works out,
we'll switch strategies if things don't be seem to moving... we'll switch strategies if things don't seem to move.
""" """
# pick a random starting point on the other side of the ring # pick a random starting point on the other side of the ring
quarter_turn = (self.parts // 4) quarter_turn = (self.parts // 4)
@ -1139,7 +1140,7 @@ class RingBuilder(object):
def _reassign_parts(self, reassign_parts, replica_plan): def _reassign_parts(self, reassign_parts, replica_plan):
""" """
For an existing ring data set, partitions are reassigned similarly to For an existing ring data set, partitions are reassigned similar to
the initial assignment. the initial assignment.
The devices are ordered by how many partitions they still want and The devices are ordered by how many partitions they still want and
@ -1168,7 +1169,7 @@ class RingBuilder(object):
# account how many partitions a given tier wants to shed. # account how many partitions a given tier wants to shed.
# #
# If we did not do this, we could have a zone where, at some # If we did not do this, we could have a zone where, at some
# point during assignment, number-of-parts-to-gain equals # point during an assignment, number-of-parts-to-gain equals
# number-of-parts-to-shed. At that point, no further placement # number-of-parts-to-shed. At that point, no further placement
# into that zone would occur since its parts_available_in_tier # into that zone would occur since its parts_available_in_tier
# would be 0. This would happen any time a zone had any device # would be 0. This would happen any time a zone had any device
@ -1398,7 +1399,7 @@ class RingBuilder(object):
N.B. _build_max_replicas_by_tier calculates the upper bound on the N.B. _build_max_replicas_by_tier calculates the upper bound on the
replicanths each tier may hold irrespective of the weights of the replicanths each tier may hold irrespective of the weights of the
tier; this method will calculate the minimum replicanth <= tier; this method will calculate the minimum replicanth <=
max_replicas[tier] that will still solve dispersion. However it is max_replicas[tier] that will still solve dispersion. However, it is
not guaranteed to return a fully dispersed solution if failure domains not guaranteed to return a fully dispersed solution if failure domains
are over-weighted for their device count. are over-weighted for their device count.
""" """
@ -1427,7 +1428,7 @@ class RingBuilder(object):
def place_replicas(tier, replicanths): def place_replicas(tier, replicanths):
if replicanths > num_devices[tier]: if replicanths > num_devices[tier]:
raise exceptions.RingValidationError( raise exceptions.RingValidationError(
'More than replicanths (%s) than devices (%s) ' 'More replicanths (%s) than devices (%s) '
'in tier (%s)' % (replicanths, num_devices[tier], tier)) 'in tier (%s)' % (replicanths, num_devices[tier], tier))
wanted_replicas[tier] = replicanths wanted_replicas[tier] = replicanths
sub_tiers = sorted(tier2children[tier]) sub_tiers = sorted(tier2children[tier])