/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

• browse files at revision 4170.3.4
• compare with another revision
• compare with revision 0.200.1036
• download diff
• download tarball
• view history from revision 4170.3.4

Show diffs side-by-side

added

removed

bzrlib/remote.py

12

12

#

13

13

# You should have received a copy of the GNU General Public License

14

14

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

15

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

16

16

 

17

17

# TODO: At some point, handle upgrades by just passing the whole request

18

18

# across to run on the server.

153

153

        except errors.UnknownSmartMethod:

154

154

            medium._remember_remote_is_before((1, 13))

155

155

            return self._vfs_cloning_metadir(require_stacking=require_stacking)

 

156

        except errors.UnknownErrorFromSmartServer, err:

 

157

            if err.error_tuple != ('BranchReference',):

 

158

                raise

 

159

            # We need to resolve the branch reference to determine the

 

160

            # cloning_metadir.  This causes unnecessary RPCs to open the

 

161

            # referenced branch (and bzrdir, etc) but only when the caller

 

162

            # didn't already resolve the branch reference.

 

163

            referenced_branch = self.open_branch()

 

164

            return referenced_branch.bzrdir.cloning_metadir()

156

165

        if len(response) != 3:

157

166

            raise errors.UnexpectedSmartServerResponse(response)

158

167

        control_name, repo_name, branch_info = response

256

265

        """See BzrDir._get_tree_branch()."""

257

266

        return None, self.open_branch()

258

267

 

259

 

    def open_branch(self, _unsupported=False):

 

268

    def open_branch(self, _unsupported=False, ignore_fallbacks=False):

260

269

        if _unsupported:

261

270

            raise NotImplementedError('unsupported flag support not implemented yet.')

262

271

        if self._next_open_branch_result is not None:

268

277

        if response[0] == 'ref':

269

278

            # a branch reference, use the existing BranchReference logic.

270

279

            format = BranchReferenceFormat()

271

 

            return format.open(self, _found=True, location=response[1])

 

280

            return format.open(self, _found=True, location=response[1],

 

281

                ignore_fallbacks=ignore_fallbacks)

272

282

        branch_format_name = response[1]

273

283

        if not branch_format_name:

274

284

            branch_format_name = None

275

285

        format = RemoteBranchFormat(network_name=branch_format_name)

276

 

        return RemoteBranch(self, self.find_repository(), format=format)

 

286

        return RemoteBranch(self, self.find_repository(), format=format,

 

287

            setup_stacking=not ignore_fallbacks)

277

288

 

278

289

    def _open_repo_v1(self, path):

279

290

        verb = 'BzrDir.find_repository'

417

428

        self._rich_root_data = None

418

429

 

419

430

    @property

 

431

    def fast_deltas(self):

 

432

        self._ensure_real()

 

433

        return self._custom_format.fast_deltas

 

434

 

 

435

    @property

420

436

    def rich_root_data(self):

421

437

        if self._rich_root_data is None:

422

438

            self._ensure_real()

685

701

        self._ensure_real()

686

702

        return self._real_repository._generate_text_key_index()

687

703

 

688

 

    @symbol_versioning.deprecated_method(symbol_versioning.one_four)

689

 

    def get_revision_graph(self, revision_id=None):

690

 

        """See Repository.get_revision_graph()."""

691

 

        return self._get_revision_graph(revision_id)

692

 

 

693

704

    def _get_revision_graph(self, revision_id):

694

705

        """Private method for using with old (< 1.2) servers to fallback."""

695

706

        if revision_id is None:

828

839

        if not self._lock_mode:

829

840

            self._lock_mode = 'r'

830

841

            self._lock_count = 1

831

 

            self._unstacked_provider.enable_cache(cache_misses=False)

 

842

            self._unstacked_provider.enable_cache(cache_misses=True)

832

843

            if self._real_repository is not None:

833

844

                self._real_repository.lock_read()

834

845

        else:

1188

1199

            # We already found out that the server can't understand

1189

1200

            # Repository.get_parent_map requests, so just fetch the whole

1190

1201

            # graph.

1191

 

            # XXX: Note that this will issue a deprecation warning. This is ok

1192

 

            # :- its because we're working with a deprecated server anyway, and

1193

 

            # the user will almost certainly have seen a warning about the

1194

 

            # server version already.

1195

 

            rg = self.get_revision_graph()

 

1202

            #

 

1203

            # Note that this reads the whole graph, when only some keys are

 

1204

            # wanted.  On this old server there's no way (?) to get them all

 

1205

            # in one go, and the user probably will have seen a warning about

 

1206

            # the server being old anyhow.

 

1207

            rg = self._get_revision_graph(None)

1196

1208

            # There is an api discrepency between get_parent_map and

1197

1209

            # get_revision_graph. Specifically, a "key:()" pair in

1198

1210

            # get_revision_graph just means a node has no parents. For

1229

1241

        # TODO: Manage this incrementally to avoid covering the same path

1230

1242

        # repeatedly. (The server will have to on each request, but the less

1231

1243

        # work done the better).

 

1244

        #

 

1245

        # Negative caching notes:

 

1246

        # new server sends missing when a request including the revid

 

1247

        # 'include-missing:' is present in the request.

 

1248

        # missing keys are serialised as missing:X, and we then call

 

1249

        # provider.note_missing(X) for-all X

1232

1250

        parents_map = self._unstacked_provider.get_cached_map()

1233

1251

        if parents_map is None:

1234

1252

            # Repository is not locked, so there's no cache.

1235

1253

            parents_map = {}

 

1254

        # start_set is all the keys in the cache

1236

1255

        start_set = set(parents_map)

 

1256

        # result set is all the references to keys in the cache

1237

1257

        result_parents = set()

1238

1258

        for parents in parents_map.itervalues():

1239

1259

            result_parents.update(parents)

1240

1260

        stop_keys = result_parents.difference(start_set)

 

1261

        # We don't need to send ghosts back to the server as a position to

 

1262

        # stop either.

 

1263

        stop_keys.difference_update(self._unstacked_provider.missing_keys)

1241

1264

        included_keys = start_set.intersection(result_parents)

1242

1265

        start_set.difference_update(included_keys)

1243

1266

        recipe = ('manual', start_set, stop_keys, len(parents_map))

1248

1271

                raise ValueError(

1249

1272

                    "key %r not a plain string" % (key,))

1250

1273

        verb = 'Repository.get_parent_map'

1251

 

        args = (path,) + tuple(keys)

 

1274

        args = (path, 'include-missing:') + tuple(keys)

1252

1275

        try:

1253

1276

            response = self._call_with_body_bytes_expecting_body(

1254

1277

                verb, args, body)

1264

1287

            # To avoid having to disconnect repeatedly, we keep track of the

1265

1288

            # fact the server doesn't understand remote methods added in 1.2.

1266

1289

            medium._remember_remote_is_before((1, 2))

1267

 

            return self.get_revision_graph(None)

 

1290

            # Recurse just once and we should use the fallback code.

 

1291

            return self._get_parent_map_rpc(keys)

1268

1292

        response_tuple, response_handler = response

1269

1293

        if response_tuple[0] not in ['ok']:

1270

1294

            response_handler.cancel_read_body()

1281

1305

                if len(d) > 1:

1282

1306

                    revision_graph[d[0]] = d[1:]

1283

1307

                else:

1284

 

                    # No parents - so give the Graph result (NULL_REVISION,).

1285

 

                    revision_graph[d[0]] = (NULL_REVISION,)

 

1308

                    # No parents:

 

1309

                    if d[0].startswith('missing:'):

 

1310

                        revid = d[0][8:]

 

1311

                        self._unstacked_provider.note_missing_key(revid)

 

1312

                    else:

 

1313

                        # no parents - so give the Graph result

 

1314

                        # (NULL_REVISION,).

 

1315

                        revision_graph[d[0]] = (NULL_REVISION,)

1286

1316

            return revision_graph

1287

1317

 

1288

1318

    @needs_read_lock

1291

1321

        return self._real_repository.get_signature_text(revision_id)

1292

1322

 

1293

1323

    @needs_read_lock

1294

 

    @symbol_versioning.deprecated_method(symbol_versioning.one_three)

1295

 

    def get_revision_graph_with_ghosts(self, revision_ids=None):

1296

 

        self._ensure_real()

1297

 

        return self._real_repository.get_revision_graph_with_ghosts(

1298

 

            revision_ids=revision_ids)

1299

 

 

1300

 

    @needs_read_lock

1301

1324

    def get_inventory_xml(self, revision_id):

1302

1325

        self._ensure_real()

1303

1326

        return self._real_repository.get_inventory_xml(revision_id)

1315

1338

        return self._real_repository.all_revision_ids()

1316

1339

 

1317

1340

    @needs_read_lock

1318

 

    def get_deltas_for_revisions(self, revisions):

 

1341

    def get_deltas_for_revisions(self, revisions, specific_fileids=None):

1319

1342

        self._ensure_real()

1320

 

        return self._real_repository.get_deltas_for_revisions(revisions)

 

1343

        return self._real_repository.get_deltas_for_revisions(revisions,

 

1344

            specific_fileids=specific_fileids)

1321

1345

 

1322

1346

    @needs_read_lock

1323

 

    def get_revision_delta(self, revision_id):

 

1347

    def get_revision_delta(self, revision_id, specific_fileids=None):

1324

1348

        self._ensure_real()

1325

 

        return self._real_repository.get_revision_delta(revision_id)

 

1349

        return self._real_repository.get_revision_delta(revision_id,

 

1350

            specific_fileids=specific_fileids)

1326

1351

 

1327

1352

    @needs_read_lock

1328

1353

    def revision_trees(self, revision_ids):

1736

1761

    def network_name(self):

1737

1762

        return self._network_name

1738

1763

 

1739

 

    def open(self, a_bzrdir):

1740

 

        return a_bzrdir.open_branch()

 

1764

    def open(self, a_bzrdir, ignore_fallbacks=False):

 

1765

        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)

1741

1766

 

1742

1767

    def _vfs_initialize(self, a_bzrdir):

1743

1768

        # Initialisation when using a local bzrdir object, or a non-vfs init

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0