199
193
self._branch = self.bzrdir.open_branch()
200
194
self.basedir = realpath(basedir)
201
self._transport = _transport
195
self._control_files = _control_files
196
self._transport = self._control_files._transport
197
# update the whole cache up front and write to disk if anything changed;
198
# in the future we might want to do this more selectively
199
# two possible ways offer themselves : in self._unlock, write the cache
200
# if needed, or, when the cache sees a change, append it to the hash
201
# cache file, and have the parser take the most recent entry for a
203
wt_trans = self.bzrdir.get_workingtree_transport(None)
204
cache_filename = wt_trans.local_abspath('stat-cache')
205
self._hashcache = hashcache.HashCache(basedir, cache_filename,
206
self.bzrdir._get_file_mode(),
207
self._content_filter_stack_provider())
210
# is this scan needed ? it makes things kinda slow.
217
self._detect_case_handling()
202
218
self._rules_searcher = None
203
219
self.views = self._make_views()
1169
1184
:return: A bzrlib.lock.LogicalLockResult.
1171
raise NotImplementedError(self.lock_read)
1186
if not self.is_locked():
1188
self.branch.lock_read()
1190
self._control_files.lock_read()
1191
return LogicalLockResult(self.unlock)
1193
self.branch.unlock()
1173
1196
def lock_tree_write(self):
1174
1197
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1176
1199
:return: A bzrlib.lock.LogicalLockResult.
1178
raise NotImplementedError(self.lock_tree_write)
1201
if not self.is_locked():
1203
self.branch.lock_read()
1205
self._control_files.lock_write()
1206
return LogicalLockResult(self.unlock)
1208
self.branch.unlock()
1180
1211
def lock_write(self):
1181
1212
"""See MutableTree.lock_write, and WorkingTree.unlock.
1183
1214
:return: A bzrlib.lock.LogicalLockResult.
1185
raise NotImplementedError(self.lock_write)
1216
if not self.is_locked():
1218
self.branch.lock_write()
1220
self._control_files.lock_write()
1221
return LogicalLockResult(self.unlock)
1223
self.branch.unlock()
1187
1226
def get_physical_lock_status(self):
1188
raise NotImplementedError(self.get_physical_lock_status)
1227
return self._control_files.get_physical_lock_status()
1229
def _reset_data(self):
1230
"""Reset transient data that cannot be revalidated."""
1231
raise NotImplementedError(self._reset_data)
1190
1233
def set_last_revision(self, new_revision):
1191
1234
"""Change the last revision in the working tree."""
1357
1400
basis_tree.unlock()
1358
1401
return conflicts
1361
def store_uncommitted(self):
1362
"""Store uncommitted changes from the tree in the branch."""
1363
target_tree = self.basis_tree()
1364
shelf_creator = shelf.ShelfCreator(self, target_tree)
1366
if not shelf_creator.shelve_all():
1368
self.branch.store_uncommitted(shelf_creator)
1369
shelf_creator.transform()
1371
shelf_creator.finalize()
1372
note('Uncommitted changes stored in branch "%s".', self.branch.nick)
1375
def restore_uncommitted(self):
1376
"""Restore uncommitted changes from the branch into the tree."""
1377
unshelver = self.branch.get_unshelver(self)
1378
if unshelver is None:
1381
merger = unshelver.make_merger()
1382
merger.ignore_zero = True
1384
self.branch.store_uncommitted(None)
1386
unshelver.finalize()
1388
1403
def revision_tree(self, revision_id):
1389
1404
"""See Tree.revision_tree.
1843
1858
def _deserialize(selt, in_file):
1844
1859
return xml5.serializer_v5.read_inventory(in_file)
1846
def break_lock(self):
1847
"""Break a lock if one is present from another instance.
1849
Uses the ui factory to ask for confirmation if the lock may be from
1852
This will probe the repository for its lock as well.
1854
self._control_files.break_lock()
1855
self.branch.break_lock()
1857
def is_locked(self):
1858
return self._control_files.is_locked()
1860
def _must_be_locked(self):
1861
if not self.is_locked():
1862
raise errors.ObjectNotLocked(self)
1864
def lock_read(self):
1865
"""Lock the tree for reading.
1867
This also locks the branch, and can be unlocked via self.unlock().
1869
:return: A bzrlib.lock.LogicalLockResult.
1871
if not self.is_locked():
1873
self.branch.lock_read()
1875
self._control_files.lock_read()
1876
return LogicalLockResult(self.unlock)
1878
self.branch.unlock()
1881
def lock_tree_write(self):
1882
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1884
:return: A bzrlib.lock.LogicalLockResult.
1886
if not self.is_locked():
1888
self.branch.lock_read()
1890
self._control_files.lock_write()
1891
return LogicalLockResult(self.unlock)
1893
self.branch.unlock()
1896
def lock_write(self):
1897
"""See MutableTree.lock_write, and WorkingTree.unlock.
1899
:return: A bzrlib.lock.LogicalLockResult.
1901
if not self.is_locked():
1903
self.branch.lock_write()
1905
self._control_files.lock_write()
1906
return LogicalLockResult(self.unlock)
1908
self.branch.unlock()
1911
def get_physical_lock_status(self):
1912
return self._control_files.get_physical_lock_status()
1914
1861
@needs_tree_write_lock
1915
1862
def _write_inventory(self, inv):
1916
1863
"""Write inventory as the current inventory."""
2112
2063
def has_id(self, file_id):
2113
2064
# files that have been deleted are excluded
2114
inv, inv_file_id = self._unpack_file_id(file_id)
2115
if not inv.has_id(inv_file_id):
2065
inv = self.inventory
2066
if not inv.has_id(file_id):
2117
path = inv.id2path(inv_file_id)
2068
path = inv.id2path(file_id)
2118
2069
return osutils.lexists(self.abspath(path))
2120
2071
def has_or_had_id(self, file_id):
2121
if file_id == self.get_root_id():
2072
if file_id == self.inventory.root.file_id:
2123
inv, inv_file_id = self._unpack_file_id(file_id)
2124
return inv.has_id(inv_file_id)
2074
return self.inventory.has_id(file_id)
2126
def all_file_ids(self):
2076
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2127
2078
"""Iterate through file_ids for this tree.
2129
2080
file_ids are in a WorkingTree if they are in the working inventory
2130
2081
and the working file exists.
2133
for path, ie in self.iter_entries_by_dir():
2083
inv = self._inventory
2084
for path, ie in inv.iter_entries():
2085
if osutils.lexists(self.abspath(path)):
2137
2088
@needs_tree_write_lock
2138
2089
def set_last_revision(self, new_revision):
2209
2160
mode=self.bzrdir._get_file_mode())
2210
2161
self._inventory_is_modified = False
2164
def get_file_sha1(self, file_id, path=None, stat_value=None):
2166
path = self._inventory.id2path(file_id)
2167
return self._hashcache.get_sha1(path, stat_value)
2212
2169
def get_file_mtime(self, file_id, path=None):
2213
2170
"""See Tree.get_file_mtime."""
2215
path = self.id2path(file_id)
2217
return os.lstat(self.abspath(path)).st_mtime
2219
if e.errno == errno.ENOENT:
2220
raise errors.FileTimestampUnavailable(path)
2172
path = self.inventory.id2path(file_id)
2173
return os.lstat(self.abspath(path)).st_mtime
2223
2175
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2224
inv, file_id = self._path2inv_file_id(path)
2176
file_id = self.path2id(path)
2225
2177
if file_id is None:
2226
2178
# For unversioned files on win32, we just assume they are not
2229
return inv[file_id].executable
2181
return self._inventory[file_id].executable
2231
2183
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2232
2184
mode = stat_result.st_mode
2233
2185
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2235
def is_executable(self, file_id, path=None):
2236
if not self._supports_executable():
2237
inv, inv_file_id = self._unpack_file_id(file_id)
2238
return inv[inv_file_id].executable
2187
if not supports_executable():
2188
def is_executable(self, file_id, path=None):
2189
return self._inventory[file_id].executable
2191
_is_executable_from_path_and_stat = \
2192
_is_executable_from_path_and_stat_from_basis
2194
def is_executable(self, file_id, path=None):
2241
2196
path = self.id2path(file_id)
2242
2197
mode = os.lstat(self.abspath(path)).st_mode
2243
2198
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2245
def _is_executable_from_path_and_stat(self, path, stat_result):
2246
if not self._supports_executable():
2247
return self._is_executable_from_path_and_stat_from_basis(path, stat_result)
2249
return self._is_executable_from_path_and_stat_from_stat(path, stat_result)
2200
_is_executable_from_path_and_stat = \
2201
_is_executable_from_path_and_stat_from_stat
2251
2203
@needs_tree_write_lock
2252
2204
def _add(self, files, ids, kinds):
2334
2283
for key, line in annotator.annotate_flat(this_key)]
2335
2284
return annotations
2337
def _put_rio(self, filename, stanzas, header):
2338
self._must_be_locked()
2339
my_file = _mod_rio.rio_file(stanzas, header)
2340
self._transport.put_file(filename, my_file,
2341
mode=self.bzrdir._get_file_mode())
2343
@needs_tree_write_lock
2344
def set_merge_modified(self, modified_hashes):
2346
for file_id, hash in modified_hashes.iteritems():
2347
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
2349
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
2351
2286
@needs_read_lock
2352
2287
def merge_modified(self):
2353
2288
"""Return a dictionary of files modified by a merge.
2409
2344
other_tree.lock_tree_write()
2411
2346
new_parents = other_tree.get_parent_ids()
2412
other_root = other_tree.root_inventory.root
2347
other_root = other_tree.inventory.root
2413
2348
other_root.parent_id = new_root_parent
2414
2349
other_root.name = osutils.basename(other_tree_path)
2415
self.root_inventory.add(other_root)
2416
add_children(self.root_inventory, other_root)
2417
self._write_inventory(self.root_inventory)
2350
self.inventory.add(other_root)
2351
add_children(self.inventory, other_root)
2352
self._write_inventory(self.inventory)
2418
2353
# normally we don't want to fetch whole repositories, but i think
2419
2354
# here we really do want to consolidate the whole thing.
2420
2355
for parent_id in other_tree.get_parent_ids():
2737
2671
raise errors.BzrRenameFailedError(from_rel,to_rel,
2738
2672
errors.NotVersionedError(path=from_rel))
2739
2673
# put entry back in the inventory so we can rename it
2740
from_entry = basis_tree.root_inventory[from_id].copy()
2741
from_inv.add(from_entry)
2674
from_entry = basis_tree.inventory[from_id].copy()
2743
from_inv, from_inv_id = self._unpack_file_id(from_id)
2744
from_entry = from_inv[from_inv_id]
2677
from_entry = inv[from_id]
2745
2678
from_parent_id = from_entry.parent_id
2746
2679
to_dir, to_tail = os.path.split(to_rel)
2747
to_inv, to_dir_id = self._path2inv_file_id(to_dir)
2680
to_dir_id = inv.path2id(to_dir)
2748
2681
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2749
2682
from_id=from_id,
2750
2683
from_tail=from_tail,
3090
3013
supports_versioned_directories = None
3092
def initialize(self, controldir, revision_id=None, from_branch=None,
3016
def find_format_string(klass, a_bzrdir):
3017
"""Return format name for the working tree object in a_bzrdir."""
3019
transport = a_bzrdir.get_workingtree_transport(None)
3020
return transport.get_bytes("format")
3021
except errors.NoSuchFile:
3022
raise errors.NoWorkingTree(base=transport.base)
3025
def find_format(klass, a_bzrdir):
3026
"""Return the format for the working tree object in a_bzrdir."""
3028
format_string = klass.find_format_string(a_bzrdir)
3029
return format_registry.get(format_string)
3031
raise errors.UnknownFormatError(format=format_string,
3032
kind="working tree")
3034
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3093
3035
accelerator_tree=None, hardlink=False):
3094
"""Initialize a new working tree in controldir.
3036
"""Initialize a new working tree in a_bzrdir.
3096
:param controldir: ControlDir to initialize the working tree in.
3038
:param a_bzrdir: BzrDir to initialize the working tree in.
3097
3039
:param revision_id: allows creating a working tree at a different
3098
3040
revision than the branch is at.
3099
3041
:param from_branch: Branch to checkout
3133
3086
"""True if this format supports stored views."""
3136
def get_controldir_for_branch(self):
3137
"""Get the control directory format for creating branches.
3139
This is to support testing of working tree formats that can not exist
3140
in the same control directory as a branch.
3142
return self._matchingbzrdir
3145
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3146
"""Base class for working trees that live in bzr meta directories."""
3149
WorkingTreeFormat.__init__(self)
3150
bzrdir.BzrFormat.__init__(self)
3153
def find_format_string(klass, controldir):
3154
"""Return format name for the working tree object in controldir."""
3156
transport = controldir.get_workingtree_transport(None)
3157
return transport.get_bytes("format")
3158
except errors.NoSuchFile:
3159
raise errors.NoWorkingTree(base=transport.base)
3162
def find_format(klass, controldir):
3163
"""Return the format for the working tree object in controldir."""
3164
format_string = klass.find_format_string(controldir)
3165
return klass._find_format(format_registry, 'working tree',
3168
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3170
WorkingTreeFormat.check_support_status(self,
3171
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3173
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3174
recommend_upgrade=recommend_upgrade, basedir=basedir)
3176
def get_controldir_for_branch(self):
3177
"""Get the control directory format for creating branches.
3179
This is to support testing of working tree formats that can not exist
3180
in the same control directory as a branch.
3182
return self._matchingbzrdir
3185
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3186
"""Base class for working trees that live in bzr meta directories."""
3189
WorkingTreeFormat.__init__(self)
3190
bzrdir.BzrFormat.__init__(self)
3193
def find_format_string(klass, controldir):
3194
"""Return format name for the working tree object in controldir."""
3196
transport = controldir.get_workingtree_transport(None)
3197
return transport.get_bytes("format")
3198
except errors.NoSuchFile:
3199
raise errors.NoWorkingTree(base=transport.base)
3202
def find_format(klass, controldir):
3203
"""Return the format for the working tree object in controldir."""
3204
format_string = klass.find_format_string(controldir)
3205
return klass._find_format(format_registry, 'working tree',
3208
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3210
WorkingTreeFormat.check_support_status(self,
3211
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3213
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3214
recommend_upgrade=recommend_upgrade, basedir=basedir)
3090
@symbol_versioning.deprecated_method(
3091
symbol_versioning.deprecated_in((2, 4, 0)))
3092
def register_format(klass, format):
3093
format_registry.register(format)
3096
@symbol_versioning.deprecated_method(
3097
symbol_versioning.deprecated_in((2, 4, 0)))
3098
def register_extra_format(klass, format):
3099
format_registry.register_extra(format)
3102
@symbol_versioning.deprecated_method(
3103
symbol_versioning.deprecated_in((2, 4, 0)))
3104
def unregister_extra_format(klass, format):
3105
format_registry.unregister_extra(format)
3108
@symbol_versioning.deprecated_method(
3109
symbol_versioning.deprecated_in((2, 4, 0)))
3110
def get_formats(klass):
3111
return format_registry._get_all()
3114
@symbol_versioning.deprecated_method(
3115
symbol_versioning.deprecated_in((2, 4, 0)))
3116
def set_default_format(klass, format):
3117
format_registry.set_default(format)
3120
@symbol_versioning.deprecated_method(
3121
symbol_versioning.deprecated_in((2, 4, 0)))
3122
def unregister_format(klass, format):
3123
format_registry.remove(format)
3217
3126
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",