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 bzrlib/branch.py
- browse files at revision 0.200.231
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.231
- Committer: Jelmer Vernooij
- Date: 2009-02-12 02:31:01 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20090212023101-s7vcsvibldg5enz2
Partially fix pull.
- files added:
- .bzrignore
- foreign
- notes
- tests
- files removed:
- .bzrignore
- bzrlib
- contrib
- contrib/bash
- contrib/zsh
- doc
- elementtree
- notes
- patches
- urlgrabber
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
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
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
from binascii import hexlify
21
22
import bzrlib
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
from store import ImmutableStore
31
from revision import Revision
32
from errors import BzrError
33
from textui import show_status
34
35
import lock
36
37
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
## TODO: Maybe include checks for common corruption of newlines, etc?
39
40
41
42
def find_branch(f, **args):
43
if f and (f.startswith('http://') or f.startswith('https://')):
44
import remotebranch
45
return remotebranch.RemoteBranch(f, **args)
46
else:
47
return Branch(f, **args)
48
49
50
def find_branch_root(f=None):
51
"""Find the branch root enclosing f, or pwd.
52
53
f may be a filename or a URL.
54
55
It is not necessary that f exists.
56
57
Basically we keep looking up until we find the control directory or
58
run into the root."""
59
if f == None:
60
f = os.getcwd()
61
elif hasattr(os.path, 'realpath'):
62
f = os.path.realpath(f)
63
else:
64
f = os.path.abspath(f)
65
if not os.path.exists(f):
66
raise BzrError('%r does not exist' % f)
67
68
69
orig_f = f
70
71
while True:
72
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
73
return f
74
head, tail = os.path.split(f)
75
if head == f:
76
# reached the root, whatever that may be
77
raise BzrError('%r is not in a branch' % orig_f)
78
f = head
79
80
81
82
######################################################################
83
# branch objects
84
85
class Branch(object):
86
"""Branch holding a history of revisions.
87
88
base
89
Base directory of the branch.
90
"""
91
_lockmode = None
92
base = None
93
94
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
95
"""Create new branch object at a particular location.
96
97
base -- Base directory for the branch.
98
99
init -- If True, create new control files in a previously
100
unversioned directory. If False, the branch must already
101
be versioned.
102
103
find_root -- If true and init is false, find the root of the
104
existing branch containing base.
105
106
In the test suite, creation of new trees is tested using the
107
`ScratchBranch` class.
108
"""
109
if init:
110
self.base = os.path.realpath(base)
111
self._make_control()
112
elif find_root:
113
self.base = find_branch_root(base)
114
else:
115
self.base = os.path.realpath(base)
116
if not isdir(self.controlfilename('.')):
117
from errors import NotBranchError
118
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
119
['use "bzr init" to initialize a new working tree',
120
'current bzr can only operate from top-of-tree'])
121
self._check_format()
122
self._lockfile = None
123
self.lock(lock_mode)
124
125
self.text_store = ImmutableStore(self.controlfilename('text-store'))
126
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
127
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
128
129
130
def __str__(self):
131
return '%s(%r)' % (self.__class__.__name__, self.base)
132
133
134
__repr__ = __str__
135
136
137
138
def lock(self, mode='w'):
139
"""Lock the on-disk branch, excluding other processes."""
140
try:
141
import fcntl, errno
142
143
if mode == 'w':
144
lm = fcntl.LOCK_EX
145
om = os.O_WRONLY | os.O_CREAT
146
elif mode == 'r':
147
lm = fcntl.LOCK_SH
148
om = os.O_RDONLY
149
else:
150
raise BzrError("invalid locking mode %r" % mode)
151
152
try:
153
lockfile = os.open(self.controlfilename('branch-lock'), om)
154
except OSError, e:
155
if e.errno == errno.ENOENT:
156
# might not exist on branches from <0.0.4
157
self.controlfile('branch-lock', 'w').close()
158
lockfile = os.open(self.controlfilename('branch-lock'), om)
159
else:
160
raise e
161
162
fcntl.lockf(lockfile, lm)
163
def unlock():
164
fcntl.lockf(lockfile, fcntl.LOCK_UN)
165
os.close(lockfile)
166
self._lockmode = None
167
self.unlock = unlock
168
self._lockmode = mode
169
except ImportError:
170
import warnings
171
warnings.warning("please write a locking method for platform %r" % sys.platform)
172
def unlock():
173
self._lockmode = None
174
self.unlock = unlock
175
self._lockmode = mode
176
177
178
def _need_readlock(self):
179
if self._lockmode not in ['r', 'w']:
180
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
181
182
def _need_writelock(self):
183
if self._lockmode not in ['w']:
184
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
185
186
187
def abspath(self, name):
188
"""Return absolute filename for something in the branch"""
189
return os.path.join(self.base, name)
190
191
192
def relpath(self, path):
193
"""Return path relative to this branch of something inside it.
194
195
Raises an error if path is not in this branch."""
196
rp = os.path.realpath(path)
197
# FIXME: windows
198
if not rp.startswith(self.base):
199
from errors import NotBranchError
200
raise NotBranchError("path %r is not within branch %r" % (rp, self.base))
201
rp = rp[len(self.base):]
202
rp = rp.lstrip(os.sep)
203
return rp
204
205
206
def controlfilename(self, file_or_path):
207
"""Return location relative to branch."""
208
if isinstance(file_or_path, types.StringTypes):
209
file_or_path = [file_or_path]
210
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
211
212
213
def controlfile(self, file_or_path, mode='r'):
214
"""Open a control file for this branch.
215
216
There are two classes of file in the control directory: text
217
and binary. binary files are untranslated byte streams. Text
218
control files are stored with Unix newlines and in UTF-8, even
219
if the platform or locale defaults are different.
220
221
Controlfiles should almost never be opened in write mode but
222
rather should be atomically copied and replaced using atomicfile.
223
"""
224
225
fn = self.controlfilename(file_or_path)
226
227
if mode == 'rb' or mode == 'wb':
228
return file(fn, mode)
229
elif mode == 'r' or mode == 'w':
230
# open in binary mode anyhow so there's no newline translation;
231
# codecs uses line buffering by default; don't want that.
232
import codecs
233
return codecs.open(fn, mode + 'b', 'utf-8',
234
buffering=60000)
235
else:
236
raise BzrError("invalid controlfile mode %r" % mode)
237
238
239
240
def _make_control(self):
241
os.mkdir(self.controlfilename([]))
242
self.controlfile('README', 'w').write(
243
"This is a Bazaar-NG control directory.\n"
244
"Do not change any files in this directory.")
245
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
246
for d in ('text-store', 'inventory-store', 'revision-store'):
247
os.mkdir(self.controlfilename(d))
248
for f in ('revision-history', 'merged-patches',
249
'pending-merged-patches', 'branch-name',
250
'branch-lock'):
251
self.controlfile(f, 'w').write('')
252
mutter('created control directory in ' + self.base)
253
Inventory().write_xml(self.controlfile('inventory','w'))
254
255
256
def _check_format(self):
257
"""Check this branch format is supported.
258
259
The current tool only supports the current unstable format.
260
261
In the future, we might need different in-memory Branch
262
classes to support downlevel branches. But not yet.
263
"""
264
# This ignores newlines so that we can open branches created
265
# on Windows from Linux and so on. I think it might be better
266
# to always make all internal files in unix format.
267
fmt = self.controlfile('branch-format', 'r').read()
268
fmt.replace('\r\n', '')
269
if fmt != BZR_BRANCH_FORMAT:
270
raise BzrError('sorry, branch format %r not supported' % fmt,
271
['use a different bzr version',
272
'or remove the .bzr directory and "bzr init" again'])
273
274
275
def read_working_inventory(self):
276
"""Read the working inventory."""
277
self._need_readlock()
278
before = time.time()
279
# ElementTree does its own conversion from UTF-8, so open in
280
# binary.
281
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
282
mutter("loaded inventory of %d items in %f"
283
% (len(inv), time.time() - before))
284
return inv
285
286
287
def _write_inventory(self, inv):
288
"""Update the working inventory.
289
290
That is to say, the inventory describing changes underway, that
291
will be committed to the next revision.
292
"""
293
self._need_writelock()
294
## TODO: factor out to atomicfile? is rename safe on windows?
295
## TODO: Maybe some kind of clean/dirty marker on inventory?
296
tmpfname = self.controlfilename('inventory.tmp')
297
tmpf = file(tmpfname, 'wb')
298
inv.write_xml(tmpf)
299
tmpf.close()
300
inv_fname = self.controlfilename('inventory')
301
if sys.platform == 'win32':
302
os.remove(inv_fname)
303
os.rename(tmpfname, inv_fname)
304
mutter('wrote working inventory')
305
306
307
inventory = property(read_working_inventory, _write_inventory, None,
308
"""Inventory for the working copy.""")
309
310
311
def add(self, files, verbose=False, ids=None):
312
"""Make files versioned.
313
314
Note that the command line normally calls smart_add instead.
315
316
This puts the files in the Added state, so that they will be
317
recorded by the next commit.
318
319
TODO: Perhaps have an option to add the ids even if the files do
320
not (yet) exist.
321
322
TODO: Perhaps return the ids of the files? But then again it
323
is easy to retrieve them if they're needed.
324
325
TODO: Option to specify file id.
326
327
TODO: Adding a directory should optionally recurse down and
328
add all non-ignored children. Perhaps do that in a
329
higher-level method.
330
"""
331
self._need_writelock()
332
333
# TODO: Re-adding a file that is removed in the working copy
334
# should probably put it back with the previous ID.
335
if isinstance(files, types.StringTypes):
336
assert(ids is None or isinstance(ids, types.StringTypes))
337
files = [files]
338
if ids is not None:
339
ids = [ids]
340
341
if ids is None:
342
ids = [None] * len(files)
343
else:
344
assert(len(ids) == len(files))
345
346
inv = self.read_working_inventory()
347
for f,file_id in zip(files, ids):
348
if is_control_file(f):
349
raise BzrError("cannot add control file %s" % quotefn(f))
350
351
fp = splitpath(f)
352
353
if len(fp) == 0:
354
raise BzrError("cannot add top-level %r" % f)
355
356
fullpath = os.path.normpath(self.abspath(f))
357
358
try:
359
kind = file_kind(fullpath)
360
except OSError:
361
# maybe something better?
362
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
363
364
if kind != 'file' and kind != 'directory':
365
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
366
367
if file_id is None:
368
file_id = gen_file_id(f)
369
inv.add_path(f, kind=kind, file_id=file_id)
370
371
if verbose:
372
show_status('A', kind, quotefn(f))
373
374
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
375
376
self._write_inventory(inv)
377
378
379
def print_file(self, file, revno):
380
"""Print `file` to stdout."""
381
self._need_readlock()
382
tree = self.revision_tree(self.lookup_revision(revno))
383
# use inventory as it was in that revision
384
file_id = tree.inventory.path2id(file)
385
if not file_id:
386
raise BzrError("%r is not present in revision %d" % (file, revno))
387
tree.print_file(file_id)
388
389
390
def remove(self, files, verbose=False):
391
"""Mark nominated files for removal from the inventory.
392
393
This does not remove their text. This does not run on
394
395
TODO: Refuse to remove modified files unless --force is given?
396
397
TODO: Do something useful with directories.
398
399
TODO: Should this remove the text or not? Tough call; not
400
removing may be useful and the user can just use use rm, and
401
is the opposite of add. Removing it is consistent with most
402
other tools. Maybe an option.
403
"""
404
## TODO: Normalize names
405
## TODO: Remove nested loops; better scalability
406
self._need_writelock()
407
408
if isinstance(files, types.StringTypes):
409
files = [files]
410
411
tree = self.working_tree()
412
inv = tree.inventory
413
414
# do this before any modifications
415
for f in files:
416
fid = inv.path2id(f)
417
if not fid:
418
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
419
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
420
if verbose:
421
# having remove it, it must be either ignored or unknown
422
if tree.is_ignored(f):
423
new_status = 'I'
424
else:
425
new_status = '?'
426
show_status(new_status, inv[fid].kind, quotefn(f))
427
del inv[fid]
428
429
self._write_inventory(inv)
430
431
def set_inventory(self, new_inventory_list):
432
inv = Inventory()
433
for path, file_id, parent, kind in new_inventory_list:
434
name = os.path.basename(path)
435
if name == "":
436
continue
437
inv.add(InventoryEntry(file_id, name, kind, parent))
438
self._write_inventory(inv)
439
440
441
def unknowns(self):
442
"""Return all unknown files.
443
444
These are files in the working directory that are not versioned or
445
control files or ignored.
446
447
>>> b = ScratchBranch(files=['foo', 'foo~'])
448
>>> list(b.unknowns())
449
['foo']
450
>>> b.add('foo')
451
>>> list(b.unknowns())
452
[]
453
>>> b.remove('foo')
454
>>> list(b.unknowns())
455
['foo']
456
"""
457
return self.working_tree().unknowns()
458
459
460
def append_revision(self, revision_id):
461
mutter("add {%s} to revision-history" % revision_id)
462
rev_history = self.revision_history()
463
464
tmprhname = self.controlfilename('revision-history.tmp')
465
rhname = self.controlfilename('revision-history')
466
467
f = file(tmprhname, 'wt')
468
rev_history.append(revision_id)
469
f.write('\n'.join(rev_history))
470
f.write('\n')
471
f.close()
472
473
if sys.platform == 'win32':
474
os.remove(rhname)
475
os.rename(tmprhname, rhname)
476
477
478
479
def get_revision(self, revision_id):
480
"""Return the Revision object for a named revision"""
481
self._need_readlock()
482
r = Revision.read_xml(self.revision_store[revision_id])
483
assert r.revision_id == revision_id
484
return r
485
486
487
def get_inventory(self, inventory_id):
488
"""Get Inventory object by hash.
489
490
TODO: Perhaps for this and similar methods, take a revision
491
parameter which can be either an integer revno or a
492
string hash."""
493
self._need_readlock()
494
i = Inventory.read_xml(self.inventory_store[inventory_id])
495
return i
496
497
498
def get_revision_inventory(self, revision_id):
499
"""Return inventory of a past revision."""
500
self._need_readlock()
501
if revision_id == None:
502
return Inventory()
503
else:
504
return self.get_inventory(self.get_revision(revision_id).inventory_id)
505
506
507
def revision_history(self):
508
"""Return sequence of revision hashes on to this branch.
509
510
>>> ScratchBranch().revision_history()
511
[]
512
"""
513
self._need_readlock()
514
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
515
516
517
def enum_history(self, direction):
518
"""Return (revno, revision_id) for history of branch.
519
520
direction
521
'forward' is from earliest to latest
522
'reverse' is from latest to earliest
523
"""
524
rh = self.revision_history()
525
if direction == 'forward':
526
i = 1
527
for rid in rh:
528
yield i, rid
529
i += 1
530
elif direction == 'reverse':
531
i = len(rh)
532
while i > 0:
533
yield i, rh[i-1]
534
i -= 1
535
else:
536
raise ValueError('invalid history direction', direction)
537
538
539
def revno(self):
540
"""Return current revision number for this branch.
541
542
That is equivalent to the number of revisions committed to
543
this branch.
544
"""
545
return len(self.revision_history())
546
547
548
def last_patch(self):
549
"""Return last patch hash, or None if no history.
550
"""
551
ph = self.revision_history()
552
if ph:
553
return ph[-1]
554
else:
555
return None
556
557
558
def commit(self, *args, **kw):
559
"""Deprecated"""
560
from bzrlib.commit import commit
561
commit(self, *args, **kw)
562
563
564
def lookup_revision(self, revno):
565
"""Return revision hash for revision number."""
566
if revno == 0:
567
return None
568
569
try:
570
# list is 0-based; revisions are 1-based
571
return self.revision_history()[revno-1]
572
except IndexError:
573
raise BzrError("no such revision %s" % revno)
574
575
576
def revision_tree(self, revision_id):
577
"""Return Tree for a revision on this branch.
578
579
`revision_id` may be None for the null revision, in which case
580
an `EmptyTree` is returned."""
581
# TODO: refactor this to use an existing revision object
582
# so we don't need to read it in twice.
583
self._need_readlock()
584
if revision_id == None:
585
return EmptyTree()
586
else:
587
inv = self.get_revision_inventory(revision_id)
588
return RevisionTree(self.text_store, inv)
589
590
591
def working_tree(self):
592
"""Return a `Tree` for the working copy."""
593
from workingtree import WorkingTree
594
return WorkingTree(self.base, self.read_working_inventory())
595
596
597
def basis_tree(self):
598
"""Return `Tree` object for last revision.
599
600
If there are no revisions yet, return an `EmptyTree`.
601
"""
602
r = self.last_patch()
603
if r == None:
604
return EmptyTree()
605
else:
606
return RevisionTree(self.text_store, self.get_revision_inventory(r))
607
608
609
610
def rename_one(self, from_rel, to_rel):
611
"""Rename one file.
612
613
This can change the directory or the filename or both.
614
"""
615
self._need_writelock()
616
tree = self.working_tree()
617
inv = tree.inventory
618
if not tree.has_filename(from_rel):
619
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
620
if tree.has_filename(to_rel):
621
raise BzrError("can't rename: new working file %r already exists" % to_rel)
622
623
file_id = inv.path2id(from_rel)
624
if file_id == None:
625
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
626
627
if inv.path2id(to_rel):
628
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
629
630
to_dir, to_tail = os.path.split(to_rel)
631
to_dir_id = inv.path2id(to_dir)
632
if to_dir_id == None and to_dir != '':
633
raise BzrError("can't determine destination directory id for %r" % to_dir)
634
635
mutter("rename_one:")
636
mutter(" file_id {%s}" % file_id)
637
mutter(" from_rel %r" % from_rel)
638
mutter(" to_rel %r" % to_rel)
639
mutter(" to_dir %r" % to_dir)
640
mutter(" to_dir_id {%s}" % to_dir_id)
641
642
inv.rename(file_id, to_dir_id, to_tail)
643
644
print "%s => %s" % (from_rel, to_rel)
645
646
from_abs = self.abspath(from_rel)
647
to_abs = self.abspath(to_rel)
648
try:
649
os.rename(from_abs, to_abs)
650
except OSError, e:
651
raise BzrError("failed to rename %r to %r: %s"
652
% (from_abs, to_abs, e[1]),
653
["rename rolled back"])
654
655
self._write_inventory(inv)
656
657
658
659
def move(self, from_paths, to_name):
660
"""Rename files.
661
662
to_name must exist as a versioned directory.
663
664
If to_name exists and is a directory, the files are moved into
665
it, keeping their old names. If it is a directory,
666
667
Note that to_name is only the last component of the new name;
668
this doesn't change the directory.
669
"""
670
self._need_writelock()
671
## TODO: Option to move IDs only
672
assert not isinstance(from_paths, basestring)
673
tree = self.working_tree()
674
inv = tree.inventory
675
to_abs = self.abspath(to_name)
676
if not isdir(to_abs):
677
raise BzrError("destination %r is not a directory" % to_abs)
678
if not tree.has_filename(to_name):
679
raise BzrError("destination %r not in working directory" % to_abs)
680
to_dir_id = inv.path2id(to_name)
681
if to_dir_id == None and to_name != '':
682
raise BzrError("destination %r is not a versioned directory" % to_name)
683
to_dir_ie = inv[to_dir_id]
684
if to_dir_ie.kind not in ('directory', 'root_directory'):
685
raise BzrError("destination %r is not a directory" % to_abs)
686
687
to_idpath = inv.get_idpath(to_dir_id)
688
689
for f in from_paths:
690
if not tree.has_filename(f):
691
raise BzrError("%r does not exist in working tree" % f)
692
f_id = inv.path2id(f)
693
if f_id == None:
694
raise BzrError("%r is not versioned" % f)
695
name_tail = splitpath(f)[-1]
696
dest_path = appendpath(to_name, name_tail)
697
if tree.has_filename(dest_path):
698
raise BzrError("destination %r already exists" % dest_path)
699
if f_id in to_idpath:
700
raise BzrError("can't move %r to a subdirectory of itself" % f)
701
702
# OK, so there's a race here, it's possible that someone will
703
# create a file in this interval and then the rename might be
704
# left half-done. But we should have caught most problems.
705
706
for f in from_paths:
707
name_tail = splitpath(f)[-1]
708
dest_path = appendpath(to_name, name_tail)
709
print "%s => %s" % (f, dest_path)
710
inv.rename(inv.path2id(f), to_dir_id, name_tail)
711
try:
712
os.rename(self.abspath(f), self.abspath(dest_path))
713
except OSError, e:
714
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
715
["rename rolled back"])
716
717
self._write_inventory(inv)
718
719
720
721
722
class ScratchBranch(Branch):
723
"""Special test class: a branch that cleans up after itself.
724
725
>>> b = ScratchBranch()
726
>>> isdir(b.base)
727
True
728
>>> bd = b.base
729
>>> b.destroy()
730
>>> isdir(bd)
731
False
732
"""
733
def __init__(self, files=[], dirs=[]):
734
"""Make a test branch.
735
736
This creates a temporary directory and runs init-tree in it.
737
738
If any files are listed, they are created in the working copy.
739
"""
740
Branch.__init__(self, tempfile.mkdtemp(), init=True)
741
for d in dirs:
742
os.mkdir(self.abspath(d))
743
744
for f in files:
745
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
746
747
748
def __del__(self):
749
self.destroy()
750
751
def destroy(self):
752
"""Destroy the test branch, removing the scratch directory."""
753
try:
754
mutter("delete ScratchBranch %s" % self.base)
755
shutil.rmtree(self.base)
756
except OSError, e:
757
# Work around for shutil.rmtree failing on Windows when
758
# readonly files are encountered
759
mutter("hit exception in destroying ScratchBranch: %s" % e)
760
for root, dirs, files in os.walk(self.base, topdown=False):
761
for name in files:
762
os.chmod(os.path.join(root, name), 0700)
763
shutil.rmtree(self.base)
764
self.base = None
765
766
767
768
######################################################################
769
# predicates
770
771
772
def is_control_file(filename):
773
## FIXME: better check
774
filename = os.path.normpath(filename)
775
while filename != '':
776
head, tail = os.path.split(filename)
777
## mutter('check %r for control file' % ((head, tail), ))
778
if tail == bzrlib.BZRDIR:
779
return True
780
if filename == head:
781
break
782
filename = head
783
return False
784
785
786
787
def gen_file_id(name):
788
"""Return new file id.
789
790
This should probably generate proper UUIDs, but for the moment we
791
cope with just randomness because running uuidgen every time is
792
slow."""
793
import re
794
795
# get last component
796
idx = name.rfind('/')
797
if idx != -1:
798
name = name[idx+1 : ]
799
idx = name.rfind('\\')
800
if idx != -1:
801
name = name[idx+1 : ]
802
803
# make it not a hidden file
804
name = name.lstrip('.')
805
806
# remove any wierd characters; we don't escape them but rather
807
# just pull them out
808
name = re.sub(r'[^\w.]', '', name)
809
810
s = hexlify(rand_bytes(8))
811
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0