/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to remote.py

Share more code between local and remote classes, support opening remote branches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
remote.py
23
23
from bzrlib.trace import info
24
24
from bzrlib.transport import Transport
25
25
 
 
26
from bzrlib.plugins.git import git
26
27
from bzrlib.plugins.git.branch import GitBranch
27
 
from bzrlib.plugins.git.errors import NoSuchRef
28
 
from bzrlib.plugins.git.dir import GitDir
29
28
from bzrlib.plugins.git.foreign import ForeignBranch
30
29
from bzrlib.plugins.git.repository import GitFormat, GitRepository
31
30
 
32
 
import os
33
 
import tempfile
34
31
import urllib
35
32
import urlparse
36
33
 
37
 
import dulwich as git
38
 
from dulwich.pack import PackData, Pack
39
 
 
40
 
# Don't run any tests on GitSmartTransport as it is not intended to be 
41
 
# a full implementation of Transport
42
 
def get_test_permutations():
43
 
    return []
44
 
 
45
34
 
46
35
class GitSmartTransport(Transport):
47
36
 
51
40
        assert scheme == "git"
52
41
        hostport, self._path = urllib.splithost(loc)
53
42
        (self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
54
 
        self._client = _client
55
 
 
56
 
    def _get_client(self):
57
 
        if self._client is not None:
58
 
            ret = self._client
59
 
            self._client = None
60
 
            return ret
61
 
        return git.client.TCPGitClient(self._host, self._port)
 
43
        if _client is not None:
 
44
            self._client = _client
 
45
        else:
 
46
            self._client = git.client.TCPGitClient(self._host, self._port)
62
47
 
63
48
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
64
49
        if progress is None:
65
50
            def progress(text):
66
51
                info("git: %s" % text)
67
 
        self._get_client().fetch_pack(self._path, determine_wants, 
68
 
            graph_walker, pack_data, progress)
 
52
        self._client.fetch_pack(self._path, determine_wants, graph_walker, 
 
53
                pack_data, progress)
69
54
 
70
55
    def get(self, path):
71
56
        raise NoSuchFile(path)
72
57
 
73
 
    def abspath(self, relpath):
74
 
        return urlutils.join(self.base, relpath)
75
 
 
76
58
    def clone(self, offset=None):
77
59
        """See Transport.clone()."""
78
60
        if offset is None:
83
65
        return GitSmartTransport(newurl, self._client)
84
66
 
85
67
 
86
 
class RemoteGitDir(GitDir):
 
68
class RemoteGitDir(BzrDir):
87
69
 
88
70
    def __init__(self, transport, lockfiles, format):
89
71
        self._format = format
91
73
        self.transport = transport
92
74
        self._lockfiles = lockfiles
93
75
 
 
76
    def is_supported(self):
 
77
        return True
 
78
 
94
79
    def open_repository(self):
95
80
        return RemoteGitRepository(self, self._lockfiles)
96
81
 
97
 
    def open_branch(self, _unsupported=False):
 
82
    def open_branch(self):
98
83
        repo = self.open_repository()
99
84
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
100
85
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
102
87
    def open_workingtree(self):
103
88
        raise NotLocalUrl(self.transport.base)
104
89
 
 
90
    def cloning_metadir(self, stacked=False):
 
91
        """Produce a metadir suitable for cloning with."""
 
92
        if stacked:
 
93
            return bzrlib.bzrdir.format_registry.make_bzrdir("1.6.1-rich-root")
 
94
        else:
 
95
            return bzrlib.bzrdir.format_registry.make_bzrdir("rich-root-pack")
 
96
 
105
97
 
106
98
class RemoteGitRepository(GitRepository):
107
99
 
108
100
    def __init__(self, gitdir, lockfiles):
109
101
        GitRepository.__init__(self, gitdir, lockfiles)
110
102
 
111
 
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
112
 
                   progress=None):
113
 
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
114
 
            progress)
115
 
 
116
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
117
 
        fd, path = tempfile.mkstemp(suffix=".pack")
118
 
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
119
 
        os.close(fd)
120
 
        basename = path[:-len(".pack")]
121
 
        p = PackData(path)
122
 
        p.create_index_v2(basename+".idx")
123
 
        pack = Pack(basename)
124
 
        os.remove(path)
125
 
        return (len(p), pack.iterobjects())
 
103
    def fetch_pack(self, determine_wants, graph_walker, pack_data):
 
104
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data)
126
105
 
127
106
 
128
107
class RemoteGitBranch(GitBranch):
129
108
 
130
109
    def __init__(self, bzrdir, repository, name, lockfiles):
131
110
        def determine_wants(heads):
132
 
            if not name in heads:
133
 
                raise NoSuchRef(name)
134
111
            self._ref = heads[name]
135
112
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
136
113
                             lambda x: mutter("git: %s" % x))
137
114
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
138
115
 
139
116
    def last_revision(self):
140
 
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
141
 
 
142
 
    def _synchronize_history(self, destination, revision_id):
143
 
        """See Branch._synchronize_history()."""
144
 
        destination.generate_revision_history(self.last_revision())
145
 
 
 
117
        return self._ref