/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

Fix syntax errors.

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
28
from bzrlib.plugins.git.dir import GitDir
29
29
from bzrlib.plugins.git.foreign import ForeignBranch
30
30
from bzrlib.plugins.git.repository import GitFormat, GitRepository
31
31
 
32
 
import os
33
 
import tempfile
34
32
import urllib
35
33
import urlparse
36
34
 
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 []
 
35
from dulwich.pack import PackData
44
36
 
45
37
 
46
38
class GitSmartTransport(Transport):
51
43
        assert scheme == "git"
52
44
        hostport, self._path = urllib.splithost(loc)
53
45
        (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)
 
46
        if _client is not None:
 
47
            self._client = _client
 
48
        else:
 
49
            self._client = git.client.TCPGitClient(self._host, self._port)
62
50
 
63
51
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
64
52
        if progress is None:
65
53
            def progress(text):
66
54
                info("git: %s" % text)
67
 
        self._get_client().fetch_pack(self._path, determine_wants, 
68
 
            graph_walker, pack_data, progress)
 
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)
69
68
 
70
69
    def get(self, path):
71
70
        raise NoSuchFile(path)
72
71
 
73
 
    def abspath(self, relpath):
74
 
        return urlutils.join(self.base, relpath)
75
 
 
76
72
    def clone(self, offset=None):
77
73
        """See Transport.clone()."""
78
74
        if offset is None:
94
90
    def open_repository(self):
95
91
        return RemoteGitRepository(self, self._lockfiles)
96
92
 
97
 
    def open_branch(self, _unsupported=False):
 
93
    def open_branch(self):
98
94
        repo = self.open_repository()
99
95
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
100
96
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
102
98
    def open_workingtree(self):
103
99
        raise NotLocalUrl(self.transport.base)
104
100
 
 
101
    def cloning_metadir(self, stacked=False):
 
102
        """Produce a metadir suitable for cloning with."""
 
103
        if stacked:
 
104
            return bzrlib.bzrdir.format_registry.make_bzrdir("1.6.1-rich-root")
 
105
        else:
 
106
            return bzrlib.bzrdir.format_registry.make_bzrdir("rich-root-pack")
 
107
 
105
108
 
106
109
class RemoteGitRepository(GitRepository):
107
110
 
108
111
    def __init__(self, gitdir, lockfiles):
109
112
        GitRepository.__init__(self, gitdir, lockfiles)
110
113
 
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())
 
114
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
 
115
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, progress)
126
116
 
127
117
 
128
118
class RemoteGitBranch(GitBranch):
129
119
 
130
120
    def __init__(self, bzrdir, repository, name, lockfiles):
131
121
        def determine_wants(heads):
132
 
            if not name in heads:
133
 
                raise NoSuchRef(name)
134
122
            self._ref = heads[name]
135
123
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
136
124
                             lambda x: mutter("git: %s" % x))
139
127
    def last_revision(self):
140
128
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
141
129
 
142
 
    def _synchronize_history(self, destination, revision_id):
143
 
        """See Branch._synchronize_history()."""
144
 
        destination.generate_revision_history(self.last_revision())
145
 
 
 
130
 
 
131