← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/dirstate.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-29 22:03:03 UTC
  • mfrom: (5416.2.6 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100929220303-cr95h8iwtggco721
(mbp) Add 'break-lock --force'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/dirstate.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
265
265
        # return '%X.%X' % (int(st.st_mtime), st.st_mode)
266
266
 
267
267
 
268
 
def _unpack_stat(packed_stat):
269
 
    """Turn a packed_stat back into the stat fields.
270
 
 
271
 
    This is meant as a debugging tool, should not be used in real code.
272
 
    """
273
 
    (st_size, st_mtime, st_ctime, st_dev, st_ino,
274
 
     st_mode) = struct.unpack('>LLLLLL', binascii.a2b_base64(packed_stat))
275
 
    return dict(st_size=st_size, st_mtime=st_mtime, st_ctime=st_ctime,
276
 
                st_dev=st_dev, st_ino=st_ino, st_mode=st_mode)
277
 
 
278
 
 
279
268
class SHA1Provider(object):
280
269
    """An interface for getting sha1s of a file."""
281
270
 
1745
1734
                self._sha_cutoff_time()
1746
1735
            if (stat_value.st_mtime < self._cutoff_time
1747
1736
                and stat_value.st_ctime < self._cutoff_time):
1748
 
                entry[1][0] = ('f', sha1, stat_value.st_size, entry[1][0][3],
1749
 
                               packed_stat)
 
1737
                entry[1][0] = ('f', sha1, entry[1][0][2], entry[1][0][3],
 
1738
                    packed_stat)
1750
1739
                self._dirblock_state = DirState.IN_MEMORY_MODIFIED
1751
1740
 
1752
1741
    def _sha_cutoff_time(self):
2474
2463
            # the suffix is from tree_index+1:parent_count+1.
2475
2464
            new_location_suffix = [DirState.NULL_PARENT_DETAILS] * (parent_count - tree_index)
2476
2465
            # now stitch in all the entries from this tree
2477
 
            for path, entry in tree.iter_entries_by_dir():
 
2466
            for path, entry in tree.inventory.iter_entries_by_dir():
2478
2467
                # here we process each trees details for each item in the tree.
2479
2468
                # we first update any existing entries for the id at other paths,
2480
2469
                # then we either create or update the entry for the id at the
2692
2681
        if tracing:
2693
2682
            trace.mutter("set_state_from_inventory complete.")
2694
2683
 
2695
 
    def set_state_from_scratch(self, working_inv, parent_trees, parent_ghosts):
2696
 
        """Wipe the currently stored state and set it to something new.
2697
 
 
2698
 
        This is a hard-reset for the data we are working with.
2699
 
        """
2700
 
        # Technically, we really want a write lock, but until we write, we
2701
 
        # don't really need it.
2702
 
        self._requires_lock()
2703
 
        # root dir and root dir contents with no children. We have to have a
2704
 
        # root for set_state_from_inventory to work correctly.
2705
 
        empty_root = (('', '', inventory.ROOT_ID),
2706
 
                      [('d', '', 0, False, DirState.NULLSTAT)])
2707
 
        empty_tree_dirblocks = [('', [empty_root]), ('', [])]
2708
 
        self._set_data([], empty_tree_dirblocks)
2709
 
        self.set_state_from_inventory(working_inv)
2710
 
        self.set_parent_trees(parent_trees, parent_ghosts)
2711
 
 
2712
2684
    def _make_absent(self, current_old):
2713
2685
        """Mark current_old - an entry - as absent for tree 0.
2714
2686
 
3205
3177
    # If we have gotten this far, that means that we need to actually
3206
3178
    # process this entry.
3207
3179
    link_or_sha1 = None
3208
 
    worth_saving = True
3209
3180
    if minikind == 'f':
3210
3181
        executable = state._is_executable(stat_value.st_mode,
3211
3182
                                         saved_executable)
3227
3198
        else:
3228
3199
            entry[1][0] = ('f', '', stat_value.st_size,
3229
3200
                           executable, DirState.NULLSTAT)
3230
 
            worth_saving = False
3231
3201
    elif minikind == 'd':
3232
3202
        link_or_sha1 = None
3233
3203
        entry[1][0] = ('d', '', 0, False, packed_stat)
3239
3209
                state._get_block_entry_index(entry[0][0], entry[0][1], 0)
3240
3210
            state._ensure_block(block_index, entry_index,
3241
3211
                               osutils.pathjoin(entry[0][0], entry[0][1]))
3242
 
        else:
3243
 
            worth_saving = False
3244
3212
    elif minikind == 'l':
3245
3213
        link_or_sha1 = state._read_link(abspath, saved_link_or_sha1)
3246
3214
        if state._cutoff_time is None:
3252
3220
        else:
3253
3221
            entry[1][0] = ('l', '', stat_value.st_size,
3254
3222
                           False, DirState.NULLSTAT)
3255
 
    if worth_saving:
3256
 
        state._dirblock_state = DirState.IN_MEMORY_MODIFIED
 
3223
    state._dirblock_state = DirState.IN_MEMORY_MODIFIED
3257
3224
    return link_or_sha1
3258
3225
 
3259
3226