Changeset 5bae4a1 in trunk


Ignore:
Timestamp:
2012-03-31T18:39:02Z (13 years ago)
Author:
Brian Warner <warner@…>
Branches:
master
Children:
922ed08c
Parents:
2b8a312
git-author:
Brian Warner <warner@…> (2012-03-31 06:56:41)
git-committer:
Brian Warner <warner@…> (2012-03-31 18:39:02)
Message:

Mutable repair: use new MODE_REPAIR to query all servers *and* get privkey

This fixes bug #1689. Repair was using MODE_READ to build the servermap,
which doesn't try hard enough to grab the privkey, and also doesn't guarantee
sending queries to all servers. This patch adds a new MODE_REPAIR which does
both, and does a separate, distinct mapupdate to start wth repair cycle,
instead of relying upon the (MODE_CHECK) mapupdate leftover from the
filecheck that triggered the repair.

Location:
src/allmydata/mutable
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified src/allmydata/mutable/checker.py

    r2b8a312 r5bae4a1  
    44from allmydata.check_results import CheckAndRepairResults, CheckResults
    55
    6 from allmydata.mutable.common import MODE_CHECK, CorruptShareError
     6from allmydata.mutable.common import MODE_CHECK, MODE_WRITE, CorruptShareError
    77from allmydata.mutable.servermap import ServerMap, ServermapUpdater
    88from allmydata.mutable.retrieve import Retrieve # for verifying
    99
    1010class MutableChecker:
     11    SERVERMAP_MODE = MODE_CHECK
    1112
    1213    def __init__(self, node, storage_broker, history, monitor):
     
    2728        # recoverability, etc, without verifying.
    2829        u = ServermapUpdater(self._node, self._storage_broker, self._monitor,
    29                              servermap, MODE_CHECK, add_lease=add_lease)
     30                             servermap, self.SERVERMAP_MODE,
     31                             add_lease=add_lease)
    3032        if self._history:
    3133            self._history.notify_mapupdate(u.get_status())
     
    242244
    243245class MutableCheckAndRepairer(MutableChecker):
     246    SERVERMAP_MODE = MODE_WRITE # needed to get the privkey
     247
    244248    def __init__(self, node, storage_broker, history, monitor):
    245249        MutableChecker.__init__(self, node, storage_broker, history, monitor)
     
    265269            return
    266270        self.cr_results.repair_attempted = True
    267         d = self._node.repair(self.results)
     271        d = self._node.repair(self.results, monitor=self._monitor)
    268272        def _repair_finished(repair_results):
    269273            self.cr_results.repair_successful = repair_results.get_successful()
  • TabularUnified src/allmydata/mutable/common.py

    r2b8a312 r5bae4a1  
    77                          # creation
    88MODE_READ = "MODE_READ"
     9MODE_REPAIR = "MODE_REPAIR" # query all peers, get the privkey
    910
    1011class NotWriteableError(Exception):
  • TabularUnified src/allmydata/mutable/filenode.py

    r2b8a312 r5bae4a1  
    309309    # IRepairable
    310310
    311     def repair(self, check_results, force=False):
     311    def repair(self, check_results, force=False, monitor=None):
    312312        assert ICheckResults(check_results)
    313         r = Repairer(self, check_results)
     313        r = Repairer(self, check_results, self._storage_broker,
     314                     self._history, monitor)
    314315        d = r.start(force)
    315316        return d
  • TabularUnified src/allmydata/mutable/publish.py

    r2b8a312 r5bae4a1  
    1616from foolscap.api import eventually, fireEventually
    1717
    18 from allmydata.mutable.common import MODE_WRITE, MODE_CHECK, \
     18from allmydata.mutable.common import MODE_WRITE, MODE_CHECK, MODE_REPAIR, \
    1919     UncoordinatedWriteError, NotEnoughServersError
    2020from allmydata.mutable.servermap import ServerMap
     
    188188        # serverlist computed by that process instead of computing our own.
    189189        assert self._servermap
    190         assert self._servermap.get_last_update()[0] in (MODE_WRITE, MODE_CHECK)
     190        assert self._servermap.get_last_update()[0] in (MODE_WRITE, MODE_CHECK, MODE_REPAIR)
    191191        # we will push a version that is one larger than anything present
    192192        # in the grid, according to the servermap.
     
    374374        # serverlist computed by that process instead of computing our own.
    375375        if self._servermap:
    376             assert self._servermap.get_last_update()[0] in (MODE_WRITE, MODE_CHECK)
     376            assert self._servermap.get_last_update()[0] in (MODE_WRITE, MODE_CHECK, MODE_REPAIR)
    377377            # we will push a version that is one larger than anything present
    378378            # in the grid, according to the servermap.
  • TabularUnified src/allmydata/mutable/repairer.py

    r2b8a312 r5bae4a1  
    44from allmydata.interfaces import IRepairResults, ICheckResults
    55from allmydata.mutable.publish import MutableData
     6from allmydata.mutable.common import MODE_REPAIR
     7from allmydata.mutable.servermap import ServerMap, ServermapUpdater
    68
    79class RepairResults:
     
    2426
    2527class Repairer:
    26     def __init__(self, node, check_results):
     28    def __init__(self, node, check_results, storage_broker, history, monitor):
    2729        self.node = node
    2830        self.check_results = ICheckResults(check_results)
    2931        assert check_results.storage_index == self.node.get_storage_index()
     32        self._storage_broker = storage_broker
     33        self._history = history
     34        self._monitor = monitor
    3035
    3136    def start(self, force=False):
     
    5661        #  bogus shares (bad sigs): replace the bad one with a good one
    5762
    58         smap = self.check_results.get_servermap()
     63        # first, update the servermap in MODE_REPAIR, which files all shares
     64        # and makes sure we get the privkey.
     65        u = ServermapUpdater(self.node, self._storage_broker, self._monitor,
     66                             ServerMap(), MODE_REPAIR)
     67        if self._history:
     68            self._history.notify_mapupdate(u.get_status())
     69        d = u.update()
     70        d.addCallback(self._got_full_servermap, force)
     71        return d
    5972
     73    def _got_full_servermap(self, smap, force):
    6074        best_version = smap.best_recoverable_version()
    6175        if not best_version:
  • TabularUnified src/allmydata/mutable/servermap.py

    r2b8a312 r5bae4a1  
    1313from pycryptopp.publickey import rsa
    1414
    15 from allmydata.mutable.common import MODE_CHECK, MODE_ANYTHING, MODE_WRITE, MODE_READ, \
    16      CorruptShareError
     15from allmydata.mutable.common import MODE_CHECK, MODE_ANYTHING, MODE_WRITE, \
     16     MODE_READ, MODE_REPAIR, CorruptShareError
    1717from allmydata.mutable.layout import SIGNED_PREFIX_LENGTH, MDMFSlotReadProxy
    1818
     
    427427        self._need_privkey = False
    428428
    429         if mode == MODE_WRITE and not self._node.get_privkey():
     429        if mode in (MODE_WRITE, MODE_REPAIR) and not self._node.get_privkey():
    430430            self._need_privkey = True
    431431        # check+repair: repair requires the privkey, so if we didn't happen
     
    498498        self.num_servers_to_query = k + self.EPSILON
    499499
    500         if self.mode == MODE_CHECK:
     500        if self.mode in (MODE_CHECK, MODE_REPAIR):
    501501            # We want to query all of the servers.
    502502            initial_servers_to_query = list(full_serverlist)
     
    10641064                return self._done()
    10651065
    1066         if self.mode == MODE_CHECK:
     1066        if self.mode == (MODE_CHECK, MODE_REPAIR):
    10671067            # we used self._must_query, and we know there aren't any
    10681068            # responses still waiting, so that means we must be done
Note: See TracChangeset for help on using the changeset viewer.