/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 transportgit.py

Fix branch cloning.

Show diffs side-by-side

added added

removed removed

Lines of Context:
transportgit.py
1
 
# Copyright (C) 2010 Jelmer Vernooij <jelmer@samba.org>
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
"""A Git repository implementation that uses a Bazaar transport."""
18
 
 
19
 
 
20
 
from dulwich.errors import (
21
 
    NotGitRepository,
22
 
    NoIndexPresent,
23
 
    )
24
 
from dulwich.objects import (
25
 
    ShaFile,
26
 
    )
27
 
from dulwich.object_store import (
28
 
    PackBasedObjectStore,
29
 
    PACKDIR,
30
 
    )
31
 
from dulwich.pack import (
32
 
    PackData,
33
 
    Pack,
34
 
    iter_sha1,
35
 
    load_pack_index_file,
36
 
    write_pack_index_v2,
37
 
    )
38
 
from dulwich.repo import (
39
 
    BaseRepo,
40
 
    DictRefsContainer,
41
 
    OBJECTDIR,
42
 
    read_info_refs,
43
 
    )
44
 
 
45
 
from bzrlib.errors import (
46
 
    FileExists,
47
 
    NoSuchFile,
48
 
    TransportNotPossible,
49
 
    )
50
 
 
51
 
 
52
 
class TransportRepo(BaseRepo):
53
 
 
54
 
    def __init__(self, transport):
55
 
        self.transport = transport
56
 
        try:
57
 
            if self.transport.has(".git/info/refs"):
58
 
                self.bare = False
59
 
                self._controltransport = self.transport.clone('.git')
60
 
            elif self.transport.has("info/refs"):
61
 
                self.bare = True
62
 
                self._controltransport = self.transport
63
 
            else:
64
 
                raise NotGitRepository(self.transport)
65
 
        except NoSuchFile:
66
 
            raise NotGitRepository(self.transport)
67
 
        object_store = TransportObjectStore(
68
 
            self._controltransport.clone(OBJECTDIR))
69
 
        refs = {}
70
 
        refs["HEAD"] = self._controltransport.get_bytes("HEAD").rstrip("\n")
71
 
        refs.update(read_info_refs(self._controltransport.get('info/refs')))
72
 
        super(TransportRepo, self).__init__(object_store, 
73
 
                DictRefsContainer(refs))
74
 
 
75
 
    def get_named_file(self, path):
76
 
        """Get a file from the control dir with a specific name.
77
 
 
78
 
        Although the filename should be interpreted as a filename relative to
79
 
        the control dir in a disk-baked Repo, the object returned need not be
80
 
        pointing to a file in that location.
81
 
 
82
 
        :param path: The path to the file, relative to the control dir.
83
 
        :return: An open file object, or None if the file does not exist.
84
 
        """
85
 
        try:
86
 
            return self._controltransport.get(path.lstrip('/'))
87
 
        except NoSuchFile:
88
 
            return None
89
 
 
90
 
    def open_index(self):
91
 
        """Open the index for this repository."""
92
 
        raise NoIndexPresent()
93
 
 
94
 
    def __repr__(self):
95
 
        return "<TransportRepo for %r>" % self.transport
96
 
 
97
 
 
98
 
class TransportObjectStore(PackBasedObjectStore):
99
 
    """Git-style object store that exists on disk."""
100
 
 
101
 
    def __init__(self, transport):
102
 
        """Open an object store.
103
 
 
104
 
        :param transport: Transport to open data from
105
 
        """
106
 
        super(TransportObjectStore, self).__init__()
107
 
        self.transport = transport
108
 
        self.pack_transport = self.transport.clone(PACKDIR)
109
 
    
110
 
    def _pack_cache_stale(self):
111
 
        return False # FIXME
112
 
 
113
 
    def _pack_names(self):
114
 
        try:
115
 
            f = self.transport.get('info/packs')
116
 
        except NoSuchFile:
117
 
            return self.pack_transport.list_dir(".")
118
 
        else:
119
 
            ret = []
120
 
            for line in f.readlines():
121
 
                line = line.rstrip("\n")
122
 
                if not line:
123
 
                    continue
124
 
                (kind, name) = line.split(" ", 1)
125
 
                if kind != "P":
126
 
                    continue
127
 
                ret.append(name)
128
 
            return ret
129
 
 
130
 
    def _load_packs(self):
131
 
        ret = []
132
 
        for name in self._pack_names():
133
 
            if name.startswith("pack-") and name.endswith(".pack"):
134
 
                try:
135
 
                    size = self.pack_transport.stat(name).st_size
136
 
                except TransportNotPossible:
137
 
                    # FIXME: This reads the whole pack file at once
138
 
                    from cStringIO import StringIO
139
 
                    f = self.pack_transport.get(name)
140
 
                    contents = f.read()
141
 
                    pd = PackData(name, StringIO(contents), size=len(contents))
142
 
                else:
143
 
                    pd = PackData(name, self.pack_transport.get(name),
144
 
                            size=size)
145
 
                idxname = name.replace(".pack", ".idx")
146
 
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
147
 
                ret.append(Pack.from_objects(pd, idx))
148
 
        return ret
149
 
 
150
 
    def _iter_loose_objects(self):
151
 
        for base in self.transport.list_dir('.'):
152
 
            if len(base) != 2:
153
 
                continue
154
 
            for rest in self.transport.list_dir(base):
155
 
                yield base+rest
156
 
 
157
 
    def _split_loose_object(self, sha):
158
 
        return (sha[:2], sha[2:])
159
 
 
160
 
    def _get_loose_object(self, sha):
161
 
        path = '%s/%s' % self._split_loose_object(sha)
162
 
        try:
163
 
            return ShaFile.from_file(self.transport.get(path))
164
 
        except NoSuchFile:
165
 
            return None
166
 
 
167
 
    def add_object(self, obj):
168
 
        """Add a single object to this object store.
169
 
 
170
 
        :param obj: Object to add
171
 
        """
172
 
        (dir, file) = self._split_loose_object(obj.id)
173
 
        try:
174
 
            self.transport.mkdir(dir)
175
 
        except FileExists:
176
 
            pass
177
 
        path = "%s/%s" % (dir, file)
178
 
        if self.transport.has(path):
179
 
            return # Already there, no need to write again
180
 
        self.transport.put_bytes(path, obj.as_legacy_object())
181
 
 
182
 
    def move_in_pack(self, f):
183
 
        """Move a specific file containing a pack into the pack directory.
184
 
 
185
 
        :note: The file should be on the same file system as the
186
 
            packs directory.
187
 
 
188
 
        :param path: Path to the pack file.
189
 
        """
190
 
        f.seek(0)
191
 
        p = PackData(None, f, len(f.getvalue()))
192
 
        entries = p.sorted_entries()
193
 
        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries)
194
 
        f.seek(0)
195
 
        self.pack_transport.put_file(basename + ".pack", f)
196
 
        index_path = self.pack_transport.local_abspath(basename+".idx")
197
 
        write_pack_index_v2(index_path, entries, p.get_stored_checksum())
198
 
        idx = load_pack_index_file(basename+".idx",
199
 
                self.pack_transport.get(basename+".idx"))
200
 
        final_pack = Pack.from_objects(p, idx)
201
 
        self._add_known_pack(final_pack)
202
 
        return final_pack
203
 
 
204
 
    def add_pack(self):
205
 
        """Add a new pack to this object store. 
206
 
 
207
 
        :return: Fileobject to write to and a commit function to 
208
 
            call when the pack is finished.
209
 
        """
210
 
        from cStringIO import StringIO
211
 
        f = StringIO()
212
 
        def commit():
213
 
            if len(f.getvalue()) > 0:
214
 
                return self.move_in_pack(f)
215
 
            else:
216
 
                return None
217
 
        return f, commit
218
 
 
219
 
    @classmethod
220
 
    def init(cls, transport):
221
 
        transport.mkdir('info')
222
 
        transport.mkdir(PACKDIR)
223
 
        return cls(transport)