~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

• browse files at revision 4797.33.16
• compare with another revision
• compare with revision 2694.2.1
• download diff
• download tarball
• view history from revision 4797.33.16

Show diffs side-by-side

added

removed

bzrlib/remote.py

242

242

        self._ensure_real()

243

243

        self._real_bzrdir.destroy_repository()

244

244

 

245

 

    def create_branch(self):

 

245

    def create_branch(self, name=None):

246

246

        # as per meta1 formats - just delegate to the format object which may

247

247

        # be parameterised.

248

 

        real_branch = self._format.get_branch_format().initialize(self)

 

248

        real_branch = self._format.get_branch_format().initialize(self,

 

249

            name=name)

249

250

        if not isinstance(real_branch, RemoteBranch):

250

 

            result = RemoteBranch(self, self.find_repository(), real_branch)

 

251

            result = RemoteBranch(self, self.find_repository(), real_branch,

 

252

                                  name=name)

251

253

        else:

252

254

            result = real_branch

253

255

        # BzrDir.clone_on_transport() uses the result of create_branch but does

259

261

        self._next_open_branch_result = result

260

262

        return result

261

263

 

262

 

    def destroy_branch(self):

 

264

    def destroy_branch(self, name=None):

263

265

        """See BzrDir.destroy_branch"""

264

266

        self._ensure_real()

265

 

        self._real_bzrdir.destroy_branch()

 

267

        self._real_bzrdir.destroy_branch(name=name)

266

268

        self._next_open_branch_result = None

267

269

 

268

270

    def create_workingtree(self, revision_id=None, from_branch=None):

318

320

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

319

321

        return None, self.open_branch()

320

322

 

321

 

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

322

 

        if _unsupported:

 

323

    def open_branch(self, name=None, unsupported=False,

 

324

                    ignore_fallbacks=False):

 

325

        if unsupported:

323

326

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

324

327

        if self._next_open_branch_result is not None:

325

328

            # See create_branch for details.

330

333

        if response[0] == 'ref':

331

334

            # a branch reference, use the existing BranchReference logic.

332

335

            format = BranchReferenceFormat()

333

 

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

334

 

                ignore_fallbacks=ignore_fallbacks)

 

336

            return format.open(self, name=name, _found=True,

 

337

                location=response[1], ignore_fallbacks=ignore_fallbacks)

335

338

        branch_format_name = response[1]

336

339

        if not branch_format_name:

337

340

            branch_format_name = None

338

341

        format = RemoteBranchFormat(network_name=branch_format_name)

339

342

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

340

 

            setup_stacking=not ignore_fallbacks)

 

343

            setup_stacking=not ignore_fallbacks, name=name)

341

344

 

342

345

    def _open_repo_v1(self, path):

343

346

        verb = 'BzrDir.find_repository'

420

423

        """Return the path to be used for this bzrdir in a remote call."""

421

424

        return client.remote_path_from_transport(self.root_transport)

422

425

 

423

 

    def get_branch_transport(self, branch_format):

 

426

    def get_branch_transport(self, branch_format, name=None):

424

427

        self._ensure_real()

425

 

        return self._real_bzrdir.get_branch_transport(branch_format)

 

428

        return self._real_bzrdir.get_branch_transport(branch_format, name=name)

426

429

 

427

430

    def get_repository_transport(self, repository_format):

428

431

        self._ensure_real()

1229

1232

        return self._real_repository.add_inventory(revid, inv, parents)

1230

1233

 

1231

1234

    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,

1232

 

                               parents):

 

1235

            parents, basis_inv=None, propagate_caches=False):

1233

1236

        self._ensure_real()

1234

1237

        return self._real_repository.add_inventory_by_delta(basis_revision_id,

1235

 

            delta, new_revision_id, parents)

 

1238

            delta, new_revision_id, parents, basis_inv=basis_inv,

 

1239

            propagate_caches=propagate_caches)

1236

1240

 

1237

1241

    def add_revision(self, rev_id, rev, inv=None, config=None):

1238

1242

        self._ensure_real()

1497

1501

        return self._real_repository.get_signature_text(revision_id)

1498

1502

 

1499

1503

    @needs_read_lock

1500

 

    def get_inventory_xml(self, revision_id):

1501

 

        self._ensure_real()

1502

 

        return self._real_repository.get_inventory_xml(revision_id)

1503

 

 

1504

 

    def deserialise_inventory(self, revision_id, xml):

1505

 

        self._ensure_real()

1506

 

        return self._real_repository.deserialise_inventory(revision_id, xml)

 

1504

    def _get_inventory_xml(self, revision_id):

 

1505

        self._ensure_real()

 

1506

        return self._real_repository._get_inventory_xml(revision_id)

1507

1507

 

1508

1508

    def reconcile(self, other=None, thorough=False):

1509

1509

        self._ensure_real()

2025

2025

    def network_name(self):

2026

2026

        return self._network_name

2027

2027

 

2028

 

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

2029

 

        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)

 

2028

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

 

2029

        return a_bzrdir.open_branch(name=name, 

 

2030

            ignore_fallbacks=ignore_fallbacks)

2030

2031

 

2031

 

    def _vfs_initialize(self, a_bzrdir):

 

2032

    def _vfs_initialize(self, a_bzrdir, name):

2032

2033

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

2033

2034

        # method is not available on the server.

2034

2035

        # self._custom_format is always set - the start of initialize ensures

2035

2036

        # that.

2036

2037

        if isinstance(a_bzrdir, RemoteBzrDir):

2037

2038

            a_bzrdir._ensure_real()

2038

 

            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)

 

2039

            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,

 

2040

                name)

2039

2041

        else:

2040

2042

            # We assume the bzrdir is parameterised; it may not be.

2041

 

            result = self._custom_format.initialize(a_bzrdir)

 

2043

            result = self._custom_format.initialize(a_bzrdir, name)

2042

2044

        if (isinstance(a_bzrdir, RemoteBzrDir) and

2043

2045

            not isinstance(result, RemoteBranch)):

2044

 

            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)

 

2046

            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,

 

2047

                                  name=name)

2045

2048

        return result

2046

2049

 

2047

 

    def initialize(self, a_bzrdir):

 

2050

    def initialize(self, a_bzrdir, name=None):

2048

2051

        # 1) get the network name to use.

2049

2052

        if self._custom_format:

2050

2053

            network_name = self._custom_format.network_name()

2056

2059

            network_name = reference_format.network_name()

2057

2060

        # Being asked to create on a non RemoteBzrDir:

2058

2061

        if not isinstance(a_bzrdir, RemoteBzrDir):

2059

 

            return self._vfs_initialize(a_bzrdir)

 

2062

            return self._vfs_initialize(a_bzrdir, name=name)

2060

2063

        medium = a_bzrdir._client._medium

2061

2064

        if medium._is_remote_before((1, 13)):

2062

 

            return self._vfs_initialize(a_bzrdir)

 

2065

            return self._vfs_initialize(a_bzrdir, name=name)

2063

2066

        # Creating on a remote bzr dir.

2064

2067

        # 2) try direct creation via RPC

2065

2068

        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)

 

2069

        if name is not None:

 

2070

            # XXX JRV20100304: Support creating colocated branches

 

2071

            raise errors.NoColocatedBranchSupport(self)

2066

2072

        verb = 'BzrDir.create_branch'

2067

2073

        try:

2068

2074

            response = a_bzrdir._call(verb, path, network_name)

2069

2075

        except errors.UnknownSmartMethod:

2070

2076

            # Fallback - use vfs methods

2071

2077

            medium._remember_remote_is_before((1, 13))

2072

 

            return self._vfs_initialize(a_bzrdir)

 

2078

            return self._vfs_initialize(a_bzrdir, name=name)

2073

2079

        if response[0] != 'ok':

2074

2080

            raise errors.UnexpectedSmartServerResponse(response)

2075

2081

        # Turn the response into a RemoteRepository object.

2083

2089

                a_bzrdir._client)

2084

2090

        remote_repo = RemoteRepository(repo_bzrdir, repo_format)

2085

2091

        remote_branch = RemoteBranch(a_bzrdir, remote_repo,

2086

 

            format=format, setup_stacking=False)

 

2092

            format=format, setup_stacking=False, name=name)

2087

2093

        # XXX: We know this is a new branch, so it must have revno 0, revid

2088

2094

        # NULL_REVISION. Creating the branch locked would make this be unable

2089

2095

        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225

2116

2122

    """

2117

2123

 

2118

2124

    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,

2119

 

        _client=None, format=None, setup_stacking=True):

 

2125

        _client=None, format=None, setup_stacking=True, name=None):

2120

2126

        """Create a RemoteBranch instance.

2121

2127

 

2122

2128

        :param real_branch: An optional local implementation of the branch

2128

2134

        :param setup_stacking: If True make an RPC call to determine the

2129

2135

            stacked (or not) status of the branch. If False assume the branch

2130

2136

            is not stacked.

 

2137

        :param name: Colocated branch name

2131

2138

        """

2132

2139

        # We intentionally don't call the parent class's __init__, because it

2133

2140

        # will try to assign to self.tags, which is a property in this subclass.

2153

2160

        # Fill out expected attributes of branch for bzrlib API users.

2154

2161

        self._clear_cached_state()

2155

2162

        self.base = self.bzrdir.root_transport.base

 

2163

        self._name = name

2156

2164

        self._control_files = None

2157

2165

        self._lock_mode = None

2158

2166

        self._lock_token = None

2223

2231

                    'to use vfs implementation')

2224

2232

            self.bzrdir._ensure_real()

2225

2233

            self._real_branch = self.bzrdir._real_bzrdir.open_branch(

2226

 

                ignore_fallbacks=self._real_ignore_fallbacks)

 

2234

                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)

2227

2235

            if self.repository._real_repository is None:

2228

2236

                # Give the remote repository the matching real repo.

2229

2237

                real_repo = self._real_branch.repository

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1