/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

Merge upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
remote.py
25
25
 
26
26
from bzrlib.plugins.git import git
27
27
from bzrlib.plugins.git.branch import GitBranch
 
28
from bzrlib.plugins.git.errors import NoSuchRef
28
29
from bzrlib.plugins.git.dir import GitDir
29
30
from bzrlib.plugins.git.foreign import ForeignBranch
30
31
from bzrlib.plugins.git.repository import GitFormat, GitRepository
31
32
 
 
33
import os
 
34
import tempfile
32
35
import urllib
33
36
import urlparse
34
37
 
35
 
from dulwich.pack import PackData
 
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 []
36
44
 
37
45
 
38
46
class GitSmartTransport(Transport):
43
51
        assert scheme == "git"
44
52
        hostport, self._path = urllib.splithost(loc)
45
53
        (self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
46
 
        if _client is not None:
47
 
            self._client = _client
48
 
        else:
49
 
            self._client = git.client.TCPGitClient(self._host, self._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)
50
62
 
51
63
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
52
64
        if progress is None:
53
65
            def progress(text):
54
66
                info("git: %s" % text)
55
 
        self._client.fetch_pack(self._path, determine_wants, graph_walker, 
56
 
                pack_data, progress)
57
 
 
58
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
59
 
        fd, path = tempfile.mkstemp(dir=self.pack_dir(), suffix=".pack")
60
 
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
61
 
        os.close(fd)
62
 
        try:
63
 
            p = PackData(path)
64
 
            for o in p.iterobjects():
65
 
                yield o
66
 
        finally:
67
 
            os.remove(path)
 
67
        self._get_client().fetch_pack(self._path, determine_wants, 
 
68
            graph_walker, pack_data, progress)
68
69
 
69
70
    def get(self, path):
70
71
        raise NoSuchFile(path)
71
72
 
 
73
    def abspath(self, relpath):
 
74
        return urlutils.join(self.base, relpath)
 
75
 
72
76
    def clone(self, offset=None):
73
77
        """See Transport.clone()."""
74
78
        if offset is None:
90
94
    def open_repository(self):
91
95
        return RemoteGitRepository(self, self._lockfiles)
92
96
 
93
 
    def open_branch(self):
 
97
    def open_branch(self, _unsupported=False):
94
98
        repo = self.open_repository()
95
99
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
96
100
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
109
113
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
110
114
            progress)
111
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())
 
126
 
112
127
 
113
128
class RemoteGitBranch(GitBranch):
114
129
 
115
130
    def __init__(self, bzrdir, repository, name, lockfiles):
116
131
        def determine_wants(heads):
 
132
            if not name in heads:
 
133
                raise NoSuchRef(name)
117
134
            self._ref = heads[name]
118
135
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
119
136
                             lambda x: mutter("git: %s" % x))
122
139
    def last_revision(self):
123
140
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
124
141
 
 
142
    def _synchronize_history(self, destination, revision_id):
 
143
        """See Branch._synchronize_history()."""
 
144
        destination.generate_revision_history(self.last_revision())
 
145