← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-07-22 18:09:04 UTC
  • mfrom: (2485.8.63 bzr.connection.sharing)
  • Revision ID: pqm@pqm.ubuntu.com-20070722180904-wy7y7oyi32wbghgf
Transport connection sharing

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
48
48
    workingtree_4,
49
49
    )
50
50
from bzrlib.osutils import (
51
 
    safe_unicode,
52
51
    sha_strings,
53
52
    sha_string,
54
53
    )
209
208
        t = get_transport(url)
210
209
        t.ensure_base()
211
210
 
212
 
    # TODO: Should take a Transport
213
211
    @classmethod
214
 
    def create(cls, base, format=None):
 
212
    def create(cls, base, format=None, possible_transports=None):
215
213
        """Create a new BzrDir at the url 'base'.
216
214
        
217
215
        This will call the current default formats initialize with base
219
217
 
220
218
        :param format: If supplied, the format of branch to create.  If not
221
219
            supplied, the default is used.
 
220
        :param possible_transports: If supplied, a list of transports that 
 
221
            can be reused to share a remote connection.
222
222
        """
223
223
        if cls is not BzrDir:
224
224
            raise AssertionError("BzrDir.create always creates the default"
225
225
                " format, not one of %r" % cls)
226
 
        t = get_transport(base)
 
226
        t = get_transport(base, possible_transports)
227
227
        t.ensure_base()
228
228
        if format is None:
229
229
            format = BzrDirFormat.get_default_format()
230
 
        return format.initialize(safe_unicode(base))
 
230
        return format.initialize(base, possible_transports)
231
231
 
232
232
    def create_branch(self):
233
233
        """Create a branch in this BzrDir.
266
266
        
267
267
    @staticmethod
268
268
    def create_branch_convenience(base, force_new_repo=False,
269
 
                                  force_new_tree=None, format=None):
 
269
                                  force_new_tree=None, format=None,
 
270
                                  possible_transports=None):
270
271
        """Create a new BzrDir, Branch and Repository at the url 'base'.
271
272
 
272
273
        This is a convenience function - it will use an existing repository
288
289
        :param force_new_repo: If True a new repository is always created.
289
290
        :param force_new_tree: If True or False force creation of a tree or 
290
291
                               prevent such creation respectively.
291
 
        :param format: Override for the for the bzrdir format to create
 
292
        :param format: Override for the for the bzrdir format to create.
 
293
        :param possible_transports: An optional reusable transports list.
292
294
        """
293
295
        if force_new_tree:
294
296
            # check for non local urls
295
 
            t = get_transport(safe_unicode(base))
 
297
            t = get_transport(base, possible_transports)
296
298
            if not isinstance(t, LocalTransport):
297
299
                raise errors.NotLocalUrl(base)
298
 
        bzrdir = BzrDir.create(base, format)
 
300
        bzrdir = BzrDir.create(base, format, possible_transports)
299
301
        repo = bzrdir._find_or_create_repository(force_new_repo)
300
302
        result = bzrdir.create_branch()
301
 
        if force_new_tree or (repo.make_working_trees() and 
 
303
        if force_new_tree or (repo.make_working_trees() and
302
304
                              force_new_tree is None):
303
305
            try:
304
306
                bzrdir.create_workingtree()
305
307
            except errors.NotLocalUrl:
306
308
                pass
307
309
        return result
308
 
        
 
310
 
309
311
    @staticmethod
310
312
    def create_repository(base, shared=False, format=None):
311
313
        """Create a new BzrDir and Repository at the url 'base'.
337
339
 
338
340
        :return: The WorkingTree object.
339
341
        """
340
 
        t = get_transport(safe_unicode(base))
 
342
        t = get_transport(base)
341
343
        if not isinstance(t, LocalTransport):
342
344
            raise errors.NotLocalUrl(base)
343
 
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
 
345
        bzrdir = BzrDir.create_branch_and_repo(base,
344
346
                                               force_new_repo=True,
345
347
                                               format=format).bzrdir
346
348
        return bzrdir.create_workingtree()
581
583
        raise NotImplementedError(self.open_branch)
582
584
 
583
585
    @staticmethod
584
 
    def open_containing(url):
 
586
    def open_containing(url, possible_transports=None):
585
587
        """Open an existing branch which contains url.
586
588
        
587
589
        :param url: url to search from.
588
590
        See open_containing_from_transport for more detail.
589
591
        """
590
 
        return BzrDir.open_containing_from_transport(get_transport(url))
 
592
        transport = get_transport(url, possible_transports)
 
593
        return BzrDir.open_containing_from_transport(transport)
591
594
    
592
595
    @staticmethod
593
596
    def open_containing_from_transport(a_transport):
743
746
        return self.cloning_metadir()
744
747
 
745
748
    def sprout(self, url, revision_id=None, force_new_repo=False,
746
 
               recurse='down'):
 
749
               recurse='down', possible_transports=None):
747
750
        """Create a copy of this bzrdir prepared for use as a new line of
748
751
        development.
749
752
 
757
760
        if revision_id is not None, then the clone operation may tune
758
761
            itself to download less data.
759
762
        """
760
 
        target_transport = get_transport(url)
 
763
        target_transport = get_transport(url, possible_transports)
761
764
        target_transport.ensure_base()
762
765
        cloning_format = self.cloning_metadir()
763
766
        result = cloning_format.initialize_on_transport(target_transport)
784
787
            result.create_repository()
785
788
        elif source_repository is not None and result_repo is None:
786
789
            # have source, and want to make a new target repo
787
 
            result_repo = source_repository.sprout(result, revision_id=revision_id)
 
790
            result_repo = source_repository.sprout(result,
 
791
                                                   revision_id=revision_id)
788
792
        else:
789
793
            # fetch needed content into target.
790
794
            if source_repository is not None:
791
795
                # would rather do 
792
 
                # source_repository.copy_content_into(result_repo, revision_id=revision_id)
 
796
                # source_repository.copy_content_into(result_repo,
 
797
                #                                     revision_id=revision_id)
793
798
                # so we can override the copy method
794
799
                result_repo.fetch(source_repository, revision_id=revision_id)
795
800
        if source_branch is not None:
796
801
            source_branch.sprout(result, revision_id=revision_id)
797
802
        else:
798
803
            result.create_branch()
799
 
        # TODO: jam 20060426 we probably need a test in here in the
800
 
        #       case that the newly sprouted branch is a remote one
801
 
        if result_repo is None or result_repo.make_working_trees():
 
804
        if isinstance(target_transport, LocalTransport) and (
 
805
            result_repo is None or result_repo.make_working_trees()):
802
806
            wt = result.create_workingtree()
803
807
            wt.lock_write()
804
808
            try:
958
962
        self._check_supported(format, unsupported)
959
963
        return format.open(self, _found=True)
960
964
 
961
 
    def sprout(self, url, revision_id=None, force_new_repo=False):
 
965
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
966
               possible_transports=None):
962
967
        """See BzrDir.sprout()."""
963
968
        from bzrlib.workingtree import WorkingTreeFormat2
964
969
        self._make_tail(url)
1287
1292
        """
1288
1293
        raise NotImplementedError(self.get_converter)
1289
1294
 
1290
 
    def initialize(self, url):
 
1295
    def initialize(self, url, possible_transports=None):
1291
1296
        """Create a bzr control dir at this url and return an opened copy.
1292
1297
        
1293
1298
        Subclasses should typically override initialize_on_transport
1294
1299
        instead of this method.
1295
1300
        """
1296
 
        return self.initialize_on_transport(get_transport(url))
 
1301
        return self.initialize_on_transport(get_transport(url,
 
1302
                                                          possible_transports))
1297
1303
 
1298
1304
    def initialize_on_transport(self, transport):
1299
1305
        """Initialize a new bzrdir in the base directory of a Transport."""
2217
2223
    def initialize_on_transport(self, transport):
2218
2224
        try:
2219
2225
            # hand off the request to the smart server
2220
 
            medium = transport.get_smart_medium()
 
2226
            shared_medium = transport.get_shared_medium()
2221
2227
        except errors.NoSmartMedium:
2222
2228
            # TODO: lookup the local format from a server hint.
2223
2229
            local_dir_format = BzrDirMetaFormat1()
2224
2230
            return local_dir_format.initialize_on_transport(transport)
2225
 
        client = _SmartClient(medium)
 
2231
        client = _SmartClient(shared_medium)
2226
2232
        path = client.remote_path_from_transport(transport)
2227
 
        response = _SmartClient(medium).call('BzrDirFormat.initialize', path)
 
2233
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
 
2234
                                                    path)
2228
2235
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2229
2236
        return remote.RemoteBzrDir(transport)
2230
2237