/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

  • Committer: Jelmer Vernooij
  • Date: 2010-06-28 23:48:36 UTC
  • mto: (0.200.953 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20100628234836-96qxjh7g2xxedblp
Fix transportgit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
transportgit.py
67
67
    def __repr__(self):
68
68
        return "%s(%r)" % (self.__class__.__name__, self.transport)
69
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
 
70
78
    def subkeys(self, base):
71
79
        keys = set()
72
 
        path = self.refpath(base)
73
80
        try:
74
81
            iter_files = self.transport.clone(base).iter_files_recursive()
75
 
        except TransportNotPossible:
 
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):
76
85
            pass
77
 
        else:
78
 
            for refname in iter_files:
79
 
                # check_ref_format requires at least one /, so we prepend the
80
 
                # base before calling it.
81
 
                if check_ref_format("%s/%s" % (base, refname)):
82
 
                    keys.add(("%s/%s" % refname).strip("/"))
83
86
        for key in self.get_packed_refs():
84
87
            if key.startswith(base):
85
88
                keys.add(key[len(base):].strip("/"))
91
94
            keys.add("HEAD")
92
95
        path = ""
93
96
        try:
94
 
            iter_files = self.transport.clone("refs").iter_files_recursive()
95
 
        except TransportNotPossible:
96
 
            pass
97
 
        else:
98
 
            for refname in iter_files:
 
97
            iter_files = list(self.transport.clone("refs").iter_files_recursive())
 
98
            for filename in iter_files:
 
99
                refname = "refs/%s" % filename
99
100
                if check_ref_format(refname):
100
101
                    keys.add(refname)
 
102
        except (TransportNotPossible, NoSuchFile):
 
103
            pass
101
104
        keys.update(self.get_packed_refs())
102
105
        return keys
103
106
 
206
209
        """
207
210
        self._check_refname(name)
208
211
        self._check_refname(other)
 
212
        self._ensure_dir_exists(name)
209
213
        self.transport.put_bytes(name, SYMREF + other + '\n')
210
214
 
211
215
    def set_if_equals(self, name, old_ref, new_ref):
224
228
            realname, _ = self._follow(name)
225
229
        except KeyError:
226
230
            realname = name
227
 
        self.transport.put_bytes_non_atomic(realname, new_ref+"\n",
228
 
                create_parent_dir=True)
 
231
        self._ensure_dir_exists(realname)
 
232
        self.transport.put_bytes(realname, new_ref+"\n")
229
233
        return True
230
234
 
231
235
    def add_if_new(self, name, ref):
245
249
        except KeyError:
246
250
            realname = name
247
251
        self._check_refname(realname)
248
 
        self.transport.put_bytes_non_atomic(realname, ref+"\n",
249
 
                create_parent_dir=True)
 
252
        self._ensure_dir_exists(realname)
 
253
        self.transport.put_bytes(realname, ref+"\n")
250
254
        return True
251
255
 
252
256
    def remove_if_equals(self, name, old_ref):
263
267
        self._check_refname(name)
264
268
        # may only be packed
265
269
        try:
266
 
            self.transport.remove(name)
 
270
            self.transport.delete(name)
267
271
        except NoSuchFile:
268
272
            pass
269
273
        self._remove_packed_ref(name)
317
321
        return Index(self.index_path())
318
322
 
319
323
    def has_index(self):
320
 
        return self._controltransport.has(INDEX_FILENAME)
 
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
321
328
 
322
329
    def __repr__(self):
323
330
        return "<TransportRepo for %r>" % self.transport
362
369
                try:
363
370
                    size = self.pack_transport.stat(name).st_size
364
371
                except TransportNotPossible:
365
 
                    def pd():
366
 
                        # FIXME: This reads the whole pack file at once
367
 
                        f = self.pack_transport.get(name)
368
 
                        contents = f.read()
369
 
                        return PackData(name, StringIO(contents), size=len(contents))
 
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))
370
376
                else:
371
 
                    pd = lambda: PackData(name, self.pack_transport.get(name),
 
377
                    pd = PackData(name, self.pack_transport.get(name),
372
378
                            size=size)
373
379
                idxname = name.replace(".pack", ".idx")
374
 
                idx = lambda: load_pack_index_file(idxname, self.pack_transport.get(idxname))
375
 
                pack = Pack.from_lazy_objects(pd, idx)
 
380
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
 
381
                pack = Pack.from_objects(pd, idx)
376
382
                ret.append(pack)
377
383
        return ret
378
384
 
388
394
 
389
395
    def _remove_loose_object(self, sha):
390
396
        path = '%s/%s' % self._split_loose_object(sha)
391
 
        self.transport.remove(path)
 
397
        self.transport.delete(path)
392
398
 
393
399
    def _get_loose_object(self, sha):
394
400
        path = '%s/%s' % self._split_loose_object(sha)