← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/pack_repo.py

Merge bzr.dev 4157, this breaks a couple per-repository tests.

Looks like removing some of the InterRepo optimizers is revealing places
that we haven't fully finished the RemoteRepo api.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/pack_repo.py
1362
1362
        :param index_class: The index class to use.
1363
1363
        :param use_chk_index: Whether to setup and manage a CHK index.
1364
1364
        """
 
1365
        # XXX: This should call self.reset()
1365
1366
        self.repo = repo
1366
1367
        self.transport = transport
1367
1368
        self._index_transport = index_transport
1373
1374
            '.cix': 4}
1374
1375
        self.packs = []
1375
1376
        # name:Pack mapping
 
1377
        self._names = None
1376
1378
        self._packs_by_name = {}
1377
1379
        # the previous pack-names content
1378
1380
        self._packs_at_load = None
1603
1605
        return [[final_rev_count, final_pack_list]]
1604
1606
 
1605
1607
    def ensure_loaded(self):
 
1608
        """Ensure we have read names from disk.
 
1609
 
 
1610
        :return: True if the disk names had not been previously read.
 
1611
        """
1606
1612
        # NB: if you see an assertion error here, its probably access against
1607
1613
        # an unlocked repo. Naughty.
1608
1614
        if not self.repo.is_locked():
1614
1620
                name = key[0]
1615
1621
                self._names[name] = self._parse_index_sizes(value)
1616
1622
                self._packs_at_load.add((key, value))
 
1623
            result = True
 
1624
        else:
 
1625
            result = False
1617
1626
        # populate all the metadata.
1618
1627
        self.all_packs()
 
1628
        return result
1619
1629
 
1620
1630
    def _parse_index_sizes(self, value):
1621
1631
        """Parse a string of index sizes."""
1926
1936
        This should be called when we find out that something we thought was
1927
1937
        present is now missing. This happens when another process re-packs the
1928
1938
        repository, etc.
 
1939
 
 
1940
        :return: True if the in-memory list of packs has been altered at all.
1929
1941
        """
1930
 
        # This is functionally similar to _save_pack_names, but we don't write
 
1942
        # The ensure_loaded call is to handle the case where the first call
 
1943
        # made involving the collection was to reload_pack_names, where we 
 
1944
        # don't have a view of disk contents. Its a bit of a bandaid, and
 
1945
        # causes two reads of pack-names, but its a rare corner case not struck
 
1946
        # with regular push/pull etc.
 
1947
        first_read = self.ensure_loaded()
 
1948
        if first_read:
 
1949
            return True
1931
1950
        # out the new value.
1932
1951
        disk_nodes, _, _ = self._diff_pack_names()
1933
1952
        self._packs_at_load = disk_nodes
2226
2245
        return graph.CachingParentsProvider(self)
2227
2246
 
2228
2247
    def _refresh_data(self):
2229
 
        if self._write_lock_count == 1 or (
2230
 
            self.control_files._lock_count == 1 and
2231
 
            self.control_files._lock_mode == 'r'):
2232
 
            # forget what names there are
2233
 
            self._pack_collection.reset()
2234
 
            # XXX: Better to do an in-memory merge when acquiring a new lock -
2235
 
            # factor out code from _save_pack_names.
2236
 
            self._pack_collection.ensure_loaded()
 
2248
        if not self.is_locked():
 
2249
            return
 
2250
        self._pack_collection.reload_pack_names()
2237
2251
 
2238
2252
    def _start_write_group(self):
2239
2253
        self._pack_collection._start_write_group()
2264
2278
        return self._write_lock_count
2265
2279
 
2266
2280
    def lock_write(self, token=None):
2267
 
        if not self._write_lock_count and self.is_locked():
 
2281
        locked = self.is_locked()
 
2282
        if not self._write_lock_count and locked:
2268
2283
            raise errors.ReadOnlyError(self)
2269
2284
        self._write_lock_count += 1
2270
2285
        if self._write_lock_count == 1:
2272
2287
            for repo in self._fallback_repositories:
2273
2288
                # Writes don't affect fallback repos
2274
2289
                repo.lock_read()
2275
 
        self._refresh_data()
 
2290
        if not locked:
 
2291
            self._refresh_data()
2276
2292
 
2277
2293
    def lock_read(self):
 
2294
        locked = self.is_locked()
2278
2295
        if self._write_lock_count:
2279
2296
            self._write_lock_count += 1
2280
2297
        else:
2282
2299
            for repo in self._fallback_repositories:
2283
2300
                # Writes don't affect fallback repos
2284
2301
                repo.lock_read()
2285
 
        self._refresh_data()
 
2302
        if not locked:
 
2303
            self._refresh_data()
2286
2304
 
2287
2305
    def leave_lock_in_place(self):
2288
2306
        # not supported - raise an error