/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

Don't modify dictionary during iteration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
transportgit.py
16
16
 
17
17
"""A Git repository implementation that uses a Bazaar transport."""
18
18
 
 
19
from cStringIO import StringIO
19
20
 
20
21
from dulwich.errors import (
21
22
    NotGitRepository,
31
32
from dulwich.pack import (
32
33
    PackData,
33
34
    Pack,
 
35
    iter_sha1,
34
36
    load_pack_index_file,
 
37
    write_pack_index_v2,
35
38
    )
36
39
from dulwich.repo import (
37
40
    BaseRepo,
38
 
    DictRefsContainer,
 
41
    RefsContainer,
 
42
    INDEX_FILENAME,
39
43
    OBJECTDIR,
40
 
    read_info_refs,
 
44
    REFSDIR,
 
45
    SYMREF,
 
46
    check_ref_format,
 
47
    read_packed_refs_with_peeled,
 
48
    read_packed_refs,
 
49
    write_packed_refs,
41
50
    )
42
51
 
43
52
from bzrlib.errors import (
 
53
    FileExists,
44
54
    NoSuchFile,
 
55
    TransportNotPossible,
45
56
    )
46
57
 
47
58
 
 
59
class TransportRefsContainer(RefsContainer):
 
60
    """Refs container that reads refs from a transport."""
 
61
 
 
62
    def __init__(self, transport):
 
63
        self.transport = transport
 
64
        self._packed_refs = None
 
65
        self._peeled_refs = None
 
66
 
 
67
    def __repr__(self):
 
68
        return "%s(%r)" % (self.__class__.__name__, self.transport)
 
69
 
 
70
    def _ensure_dir_exists(self, path):
 
71
        for n in range(path.count("/")):
 
72
            dirname = "/".join(path.split("/")[:n+1])
 
73
            try:
 
74
                self.transport.mkdir(dirname)
 
75
            except FileExists:
 
76
                pass
 
77
 
 
78
    def subkeys(self, base):
 
79
        keys = set()
 
80
        try:
 
81
            iter_files = self.transport.clone(base).iter_files_recursive()
 
82
            keys.update(("%s/%s" % (base, refname)).strip("/") for 
 
83
                    refname in iter_files if check_ref_format("%s/%s" % (base, refname)))
 
84
        except (TransportNotPossible, NoSuchFile):
 
85
            pass
 
86
        for key in self.get_packed_refs():
 
87
            if key.startswith(base):
 
88
                keys.add(key[len(base):].strip("/"))
 
89
        return keys
 
90
 
 
91
    def allkeys(self):
 
92
        keys = set()
 
93
        if self.transport.has("HEAD"):
 
94
            keys.add("HEAD")
 
95
        try:
 
96
            iter_files = list(self.transport.clone("refs").iter_files_recursive())
 
97
            for filename in iter_files:
 
98
                refname = "refs/%s" % filename
 
99
                if check_ref_format(refname):
 
100
                    keys.add(refname)
 
101
        except (TransportNotPossible, NoSuchFile):
 
102
            pass
 
103
        keys.update(self.get_packed_refs())
 
104
        return keys
 
105
 
 
106
    def get_packed_refs(self):
 
107
        """Get contents of the packed-refs file.
 
108
 
 
109
        :return: Dictionary mapping ref names to SHA1s
 
110
 
 
111
        :note: Will return an empty dictionary when no packed-refs file is
 
112
            present.
 
113
        """
 
114
        # TODO: invalidate the cache on repacking
 
115
        if self._packed_refs is None:
 
116
            # set both to empty because we want _peeled_refs to be
 
117
            # None if and only if _packed_refs is also None.
 
118
            self._packed_refs = {}
 
119
            self._peeled_refs = {}
 
120
            try:
 
121
                f = self.transport.get("packed-refs")
 
122
            except NoSuchFile:
 
123
                return {}
 
124
            try:
 
125
                first_line = iter(f).next().rstrip()
 
126
                if (first_line.startswith("# pack-refs") and " peeled" in
 
127
                        first_line):
 
128
                    for sha, name, peeled in read_packed_refs_with_peeled(f):
 
129
                        self._packed_refs[name] = sha
 
130
                        if peeled:
 
131
                            self._peeled_refs[name] = peeled
 
132
                else:
 
133
                    f.seek(0)
 
134
                    for sha, name in read_packed_refs(f):
 
135
                        self._packed_refs[name] = sha
 
136
            finally:
 
137
                f.close()
 
138
        return self._packed_refs
 
139
 
 
140
    def get_peeled(self, name):
 
141
        """Return the cached peeled value of a ref, if available.
 
142
 
 
143
        :param name: Name of the ref to peel
 
144
        :return: The peeled value of the ref. If the ref is known not point to a
 
145
            tag, this will be the SHA the ref refers to. If the ref may point to
 
146
            a tag, but no cached information is available, None is returned.
 
147
        """
 
148
        self.get_packed_refs()
 
149
        if self._peeled_refs is None or name not in self._packed_refs:
 
150
            # No cache: no peeled refs were read, or this ref is loose
 
151
            return None
 
152
        if name in self._peeled_refs:
 
153
            return self._peeled_refs[name]
 
154
        else:
 
155
            # Known not peelable
 
156
            return self[name]
 
157
 
 
158
    def read_loose_ref(self, name):
 
159
        """Read a reference file and return its contents.
 
160
 
 
161
        If the reference file a symbolic reference, only read the first line of
 
162
        the file. Otherwise, only read the first 40 bytes.
 
163
 
 
164
        :param name: the refname to read, relative to refpath
 
165
        :return: The contents of the ref file, or None if the file does not
 
166
            exist.
 
167
        :raises IOError: if any other error occurs
 
168
        """
 
169
        try:
 
170
            f = self.transport.get(name)
 
171
        except NoSuchFile:
 
172
            return None
 
173
        try:
 
174
            header = f.read(len(SYMREF))
 
175
            if header == SYMREF:
 
176
                # Read only the first line
 
177
                return header + iter(f).next().rstrip("\r\n")
 
178
            else:
 
179
                # Read only the first 40 bytes
 
180
                return header + f.read(40-len(SYMREF))
 
181
        finally:
 
182
            f.close()
 
183
 
 
184
    def _remove_packed_ref(self, name):
 
185
        if self._packed_refs is None:
 
186
            return
 
187
        # reread cached refs from disk, while holding the lock
 
188
 
 
189
        self._packed_refs = None
 
190
        self.get_packed_refs()
 
191
 
 
192
        if name not in self._packed_refs:
 
193
            return
 
194
 
 
195
        del self._packed_refs[name]
 
196
        if name in self._peeled_refs:
 
197
            del self._peeled_refs[name]
 
198
        f = self.transport.open_write_stream("packed-refs")
 
199
        try:
 
200
            write_packed_refs(f, self._packed_refs, self._peeled_refs)
 
201
        finally:
 
202
            f.close()
 
203
 
 
204
    def set_symbolic_ref(self, name, other):
 
205
        """Make a ref point at another ref.
 
206
 
 
207
        :param name: Name of the ref to set
 
208
        :param other: Name of the ref to point at
 
209
        """
 
210
        self._check_refname(name)
 
211
        self._check_refname(other)
 
212
        self._ensure_dir_exists(name)
 
213
        self.transport.put_bytes(name, SYMREF + other + '\n')
 
214
 
 
215
    def set_if_equals(self, name, old_ref, new_ref):
 
216
        """Set a refname to new_ref only if it currently equals old_ref.
 
217
 
 
218
        This method follows all symbolic references, and can be used to perform
 
219
        an atomic compare-and-swap operation.
 
220
 
 
221
        :param name: The refname to set.
 
222
        :param old_ref: The old sha the refname must refer to, or None to set
 
223
            unconditionally.
 
224
        :param new_ref: The new sha the refname will refer to.
 
225
        :return: True if the set was successful, False otherwise.
 
226
        """
 
227
        try:
 
228
            realname, _ = self._follow(name)
 
229
        except KeyError:
 
230
            realname = name
 
231
        self._ensure_dir_exists(realname)
 
232
        self.transport.put_bytes(realname, new_ref+"\n")
 
233
        return True
 
234
 
 
235
    def add_if_new(self, name, ref):
 
236
        """Add a new reference only if it does not already exist.
 
237
 
 
238
        This method follows symrefs, and only ensures that the last ref in the
 
239
        chain does not exist.
 
240
 
 
241
        :param name: The refname to set.
 
242
        :param ref: The new sha the refname will refer to.
 
243
        :return: True if the add was successful, False otherwise.
 
244
        """
 
245
        try:
 
246
            realname, contents = self._follow(name)
 
247
            if contents is not None:
 
248
                return False
 
249
        except KeyError:
 
250
            realname = name
 
251
        self._check_refname(realname)
 
252
        self._ensure_dir_exists(realname)
 
253
        self.transport.put_bytes(realname, ref+"\n")
 
254
        return True
 
255
 
 
256
    def remove_if_equals(self, name, old_ref):
 
257
        """Remove a refname only if it currently equals old_ref.
 
258
 
 
259
        This method does not follow symbolic references. It can be used to
 
260
        perform an atomic compare-and-delete operation.
 
261
 
 
262
        :param name: The refname to delete.
 
263
        :param old_ref: The old sha the refname must refer to, or None to delete
 
264
            unconditionally.
 
265
        :return: True if the delete was successful, False otherwise.
 
266
        """
 
267
        self._check_refname(name)
 
268
        # may only be packed
 
269
        try:
 
270
            self.transport.delete(name)
 
271
        except NoSuchFile:
 
272
            pass
 
273
        self._remove_packed_ref(name)
 
274
        return True
 
275
 
 
276
 
48
277
class TransportRepo(BaseRepo):
49
278
 
50
279
    def __init__(self, transport):
51
280
        self.transport = transport
52
281
        try:
53
 
            if self.transport.has(".git/info/refs"):
 
282
            if self.transport.has(".git/%s" % OBJECTDIR):
54
283
                self.bare = False
55
284
                self._controltransport = self.transport.clone('.git')
56
 
            elif self.transport.has("info/refs"):
 
285
            elif self.transport.has(OBJECTDIR) or self.transport.has(REFSDIR):
57
286
                self.bare = True
58
287
                self._controltransport = self.transport
59
288
            else:
62
291
            raise NotGitRepository(self.transport)
63
292
        object_store = TransportObjectStore(
64
293
            self._controltransport.clone(OBJECTDIR))
65
 
        refs = {}
66
 
        refs["HEAD"] = self._controltransport.get_bytes("HEAD").rstrip("\n")
67
 
        refs.update(read_info_refs(self._controltransport.get('info/refs')))
68
294
        super(TransportRepo, self).__init__(object_store, 
69
 
                DictRefsContainer(refs))
 
295
                TransportRefsContainer(self._controltransport))
70
296
 
71
297
    def get_named_file(self, path):
72
298
        """Get a file from the control dir with a specific name.
83
309
        except NoSuchFile:
84
310
            return None
85
311
 
 
312
    def index_path(self):
 
313
        """Return the path to the index file."""
 
314
        return self._controltransport.local_abspath(INDEX_FILENAME)
 
315
 
86
316
    def open_index(self):
87
317
        """Open the index for this repository."""
88
 
        raise NoIndexPresent()
 
318
        from dulwich.index import Index
 
319
        if not self.has_index():
 
320
            raise NoIndexPresent()
 
321
        return Index(self.index_path())
 
322
 
 
323
    def has_index(self):
 
324
        """Check if an index is present."""
 
325
        # Bare repos must never have index files; non-bare repos may have a
 
326
        # missing index file, which is treated as empty.
 
327
        return not self.bare
89
328
 
90
329
    def __repr__(self):
91
330
        return "<TransportRepo for %r>" % self.transport
102
341
        super(TransportObjectStore, self).__init__()
103
342
        self.transport = transport
104
343
        self.pack_transport = self.transport.clone(PACKDIR)
 
344
    
 
345
    def _pack_cache_stale(self):
 
346
        return False # FIXME
 
347
 
 
348
    def _pack_names(self):
 
349
        try:
 
350
            f = self.transport.get('info/packs')
 
351
        except NoSuchFile:
 
352
            return self.pack_transport.list_dir(".")
 
353
        else:
 
354
            ret = []
 
355
            for line in f.readlines():
 
356
                line = line.rstrip("\n")
 
357
                if not line:
 
358
                    continue
 
359
                (kind, name) = line.split(" ", 1)
 
360
                if kind != "P":
 
361
                    continue
 
362
                ret.append(name)
 
363
            return ret
105
364
 
106
365
    def _load_packs(self):
107
366
        ret = []
108
 
        for line in self.transport.get('info/packs').readlines():
109
 
            line = line.rstrip("\n")
110
 
            if not line:
111
 
                continue
112
 
            (kind, name) = line.split(" ", 1)
113
 
            if kind != "P":
114
 
                continue
 
367
        for name in self._pack_names():
115
368
            if name.startswith("pack-") and name.endswith(".pack"):
116
 
                pd = PackData(name, self.pack_transport.get(name))
 
369
                try:
 
370
                    size = self.pack_transport.stat(name).st_size
 
371
                except TransportNotPossible:
 
372
                    # FIXME: This reads the whole pack file at once
 
373
                    f = self.pack_transport.get(name)
 
374
                    contents = f.read()
 
375
                    pd = PackData(name, StringIO(contents), size=len(contents))
 
376
                else:
 
377
                    pd = PackData(name, self.pack_transport.get(name),
 
378
                            size=size)
117
379
                idxname = name.replace(".pack", ".idx")
118
380
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
119
 
                ret.append(Pack.from_objects(pd, idx))
 
381
                pack = Pack.from_objects(pd, idx)
 
382
                ret.append(pack)
120
383
        return ret
121
384
 
122
385
    def _iter_loose_objects(self):
129
392
    def _split_loose_object(self, sha):
130
393
        return (sha[:2], sha[2:])
131
394
 
 
395
    def _remove_loose_object(self, sha):
 
396
        path = '%s/%s' % self._split_loose_object(sha)
 
397
        self.transport.delete(path)
 
398
 
132
399
    def _get_loose_object(self, sha):
133
400
        path = '%s/%s' % self._split_loose_object(sha)
134
401
        try:
135
 
            return ShaFile._parse_file(self.transport.get(path).read())
 
402
            return ShaFile.from_file(self.transport.get(path))
136
403
        except NoSuchFile:
137
404
            return None
138
405
 
142
409
        :param obj: Object to add
143
410
        """
144
411
        (dir, file) = self._split_loose_object(obj.id)
145
 
        self.transport.mkdir(dir)
 
412
        try:
 
413
            self.transport.mkdir(dir)
 
414
        except FileExists:
 
415
            pass
146
416
        path = "%s/%s" % (dir, file)
147
417
        if self.transport.has(path):
148
418
            return # Already there, no need to write again
149
419
        self.transport.put_bytes(path, obj.as_legacy_object())
150
420
 
 
421
    def move_in_pack(self, f):
 
422
        """Move a specific file containing a pack into the pack directory.
 
423
 
 
424
        :note: The file should be on the same file system as the
 
425
            packs directory.
 
426
 
 
427
        :param path: Path to the pack file.
 
428
        """
 
429
        f.seek(0)
 
430
        p = PackData(None, f, len(f.getvalue()))
 
431
        entries = p.sorted_entries()
 
432
        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries)
 
433
        f.seek(0)
 
434
        self.pack_transport.put_file(basename + ".pack", f)
 
435
        idxfile = self.pack_transport.open_write_stream(basename + ".idx")
 
436
        try:
 
437
            write_pack_index_v2(idxfile, entries, p.get_stored_checksum())
 
438
        finally:
 
439
            idxfile.close()
 
440
        idxfile = self.pack_transport.get(basename + ".idx")
 
441
        idx = load_pack_index_file(basename+".idx", idxfile)
 
442
        final_pack = Pack.from_objects(p, idx)
 
443
        self._add_known_pack(final_pack)
 
444
        return final_pack
 
445
 
151
446
    def add_pack(self):
152
447
        """Add a new pack to this object store. 
153
448
 
154
449
        :return: Fileobject to write to and a commit function to 
155
450
            call when the pack is finished.
156
451
        """
157
 
        raise NotImplementedError(self.add_pack)
 
452
        from cStringIO import StringIO
 
453
        f = StringIO()
 
454
        def commit():
 
455
            if len(f.getvalue()) > 0:
 
456
                return self.move_in_pack(f)
 
457
            else:
 
458
                return None
 
459
        return f, commit
 
460
 
 
461
    @classmethod
 
462
    def init(cls, transport):
 
463
        transport.mkdir('info')
 
464
        transport.mkdir(PACKDIR)
 
465
        return cls(transport)