← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inter.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-13 13:31:05 UTC
  • mfrom: (1711.2.88 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060713133105-7c8e508aaa4886e2
(Adeodato Simó) use terminal_width() for status pending merges

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inter.py
29
29
    operations with another of similar type - they will always forward to
30
30
    a subclass of InterObject - i.e. 
31
31
    InterVersionedFile.get(other).method_name(parameters).
32
 
 
33
 
    If the source and target objects implement the locking protocol - 
34
 
    lock_read, lock_write, unlock, then the InterObject's lock_read,
35
 
    lock_write and unlock methods may be used (optionally in conjunction with
36
 
    the needs_read_lock and needs_write_lock decorators.)
37
32
    """
38
33
 
39
34
    # _optimisers = set()
52
47
        self.source = source
53
48
        self.target = target
54
49
 
55
 
    def _double_lock(self, lock_source, lock_target):
56
 
        """Take out two locks, rolling back the first if the second throws."""
57
 
        lock_source()
58
 
        try:
59
 
            lock_target()
60
 
        except Exception:
61
 
            # we want to ensure that we don't leave source locked by mistake.
62
 
            # and any error on target should not confuse source.
63
 
            self.source.unlock()
64
 
            raise
65
 
 
66
50
    @classmethod
67
51
    def get(klass, source, target):
68
52
        """Retrieve a Inter worker object for these objects.
79
63
                return provider(source, target)
80
64
        return klass(source, target)
81
65
 
82
 
    def lock_read(self):
83
 
        """Take out a logical read lock.
84
 
 
85
 
        This will lock the source branch and the target branch. The source gets
86
 
        a read lock and the target a read lock.
87
 
        """
88
 
        self._double_lock(self.source.lock_read, self.target.lock_read)
89
 
 
90
 
    def lock_write(self):
91
 
        """Take out a logical write lock.
92
 
 
93
 
        This will lock the source branch and the target branch. The source gets
94
 
        a read lock and the target a write lock.
95
 
        """
96
 
        self._double_lock(self.source.lock_read, self.target.lock_write)
97
 
 
98
66
    @classmethod
99
67
    def register_optimiser(klass, optimiser):
100
68
        """Register an InterObject optimiser."""
101
69
        klass._optimisers.add(optimiser)
102
70
 
103
 
    def unlock(self):
104
 
        """Release the locks on source and target."""
105
 
        try:
106
 
            self.target.unlock()
107
 
        finally:
108
 
            self.source.unlock()
109
 
 
110
71
    @classmethod
111
72
    def unregister_optimiser(klass, optimiser):
112
73
        """Unregister an InterObject optimiser."""