/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 bzrlib/smart/branch.py

  • Committer: Andrew Bennetts
  • Date: 2008-04-08 06:38:34 UTC
  • mfrom: (2892.2.1 smart-set-last-revision)
  • mto: This revision was merged to the branch mainline in revision 3355.
  • Revision ID: andrew.bennetts@canonical.com-20080408063834-o4mid7woclibs6yj
Merge 'Add Branch.set_last_revision_info smart method'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
 
1
# Copyright (C) 2006 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
"""Server-side branch related request implmentations."""
 
18
 
 
19
 
 
20
from bzrlib import errors
 
21
from bzrlib.bzrdir import BzrDir
 
22
from bzrlib.smart.request import (
 
23
    FailedSmartServerResponse,
 
24
    SmartServerRequest,
 
25
    SuccessfulSmartServerResponse,
 
26
    )
 
27
 
 
28
 
 
29
class SmartServerBranchRequest(SmartServerRequest):
 
30
    """Base class for handling common branch request logic.
 
31
    """
 
32
 
 
33
    def do(self, path, *args):
 
34
        """Execute a request for a branch at path.
 
35
    
 
36
        All Branch requests take a path to the branch as their first argument.
 
37
 
 
38
        If the branch is a branch reference, NotBranchError is raised.
 
39
 
 
40
        :param path: The path for the repository as received from the
 
41
            client.
 
42
        :return: A SmartServerResponse from self.do_with_branch().
 
43
        """
 
44
        transport = self.transport_from_client_path(path)
 
45
        bzrdir = BzrDir.open_from_transport(transport)
 
46
        if bzrdir.get_branch_reference() is not None:
 
47
            raise errors.NotBranchError(transport.base)
 
48
        branch = bzrdir.open_branch()
 
49
        return self.do_with_branch(branch, *args)
 
50
 
 
51
 
 
52
class SmartServerLockedBranchRequest(SmartServerBranchRequest):
 
53
    """Base class for handling common branch request logic for requests that
 
54
    need a write lock.
 
55
    """
 
56
 
 
57
    def do_with_branch(self, branch, branch_token, repo_token, *args):
 
58
        """Execute a request for a branch.
 
59
 
 
60
        A write lock will be acquired with the given tokens for the branch and
 
61
        repository locks.  The lock will be released once the request is
 
62
        processed.  The physical lock state won't be changed.
 
63
        """
 
64
        # XXX: write a test for LockContention
 
65
        branch.repository.lock_write(token=repo_token)
 
66
        try:
 
67
            branch.lock_write(token=branch_token)
 
68
            try:
 
69
                return self.do_with_locked_branch(branch, *args)
 
70
            finally:
 
71
                branch.unlock()
 
72
        finally:
 
73
            branch.repository.unlock()
 
74
 
 
75
 
 
76
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
 
77
    
 
78
    def do_with_branch(self, branch):
 
79
        """Return the content of branch.control_files.get('branch.conf').
 
80
        
 
81
        The body is not utf8 decoded - its the literal bytestream from disk.
 
82
        """
 
83
        try:
 
84
            content = branch.control_files.get('branch.conf').read()
 
85
        except errors.NoSuchFile:
 
86
            content = ''
 
87
        return SuccessfulSmartServerResponse( ('ok', ), content)
 
88
 
 
89
 
 
90
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
 
91
 
 
92
    def do_with_branch(self, branch):
 
93
        """Get the revision history for the branch.
 
94
 
 
95
        The revision list is returned as the body content,
 
96
        with each revision utf8 encoded and \x00 joined.
 
97
        """
 
98
        return SuccessfulSmartServerResponse(
 
99
            ('ok', ), ('\x00'.join(branch.revision_history())))
 
100
 
 
101
 
 
102
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
 
103
    
 
104
    def do_with_branch(self, branch):
 
105
        """Return branch.last_revision_info().
 
106
        
 
107
        The revno is encoded in decimal, the revision_id is encoded as utf8.
 
108
        """
 
109
        revno, last_revision = branch.last_revision_info()
 
110
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
 
111
 
 
112
 
 
113
class SmartServerBranchRequestSetLastRevision(SmartServerLockedBranchRequest):
 
114
    
 
115
    def do_with_locked_branch(self, branch, new_last_revision_id):
 
116
        if new_last_revision_id == 'null:':
 
117
            branch.set_revision_history([])
 
118
        else:
 
119
            if not branch.repository.has_revision(new_last_revision_id):
 
120
                return FailedSmartServerResponse(
 
121
                    ('NoSuchRevision', new_last_revision_id))
 
122
            branch.generate_revision_history(new_last_revision_id)
 
123
        return SuccessfulSmartServerResponse(('ok',))
 
124
 
 
125
 
 
126
class SmartServerBranchRequestSetLastRevisionInfo(
 
127
    SmartServerLockedBranchRequest):
 
128
    
 
129
    def do_with_locked_branch(self, branch, new_revno, new_last_revision_id):
 
130
        branch.set_last_revision_info(int(new_revno), new_last_revision_id)
 
131
        return SuccessfulSmartServerResponse(('ok',))
 
132
 
 
133
 
 
134
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
 
135
    
 
136
    def do_with_branch(self, branch, branch_token='', repo_token=''):
 
137
        if branch_token == '':
 
138
            branch_token = None
 
139
        if repo_token == '':
 
140
            repo_token = None
 
141
        try:
 
142
            repo_token = branch.repository.lock_write(token=repo_token)
 
143
            try:
 
144
                branch_token = branch.lock_write(token=branch_token)
 
145
            finally:
 
146
                # this leaves the repository with 1 lock
 
147
                branch.repository.unlock()
 
148
        except errors.LockContention:
 
149
            return FailedSmartServerResponse(('LockContention',))
 
150
        except errors.TokenMismatch:
 
151
            return FailedSmartServerResponse(('TokenMismatch',))
 
152
        except errors.UnlockableTransport:
 
153
            return FailedSmartServerResponse(('UnlockableTransport',))
 
154
        except errors.LockFailed, e:
 
155
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
 
156
        if repo_token is None:
 
157
            repo_token = ''
 
158
        else:
 
159
            branch.repository.leave_lock_in_place()
 
160
        branch.leave_lock_in_place()
 
161
        branch.unlock()
 
162
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
 
163
 
 
164
 
 
165
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
 
166
 
 
167
    def do_with_branch(self, branch, branch_token, repo_token):
 
168
        try:
 
169
            branch.repository.lock_write(token=repo_token)
 
170
            try:
 
171
                branch.lock_write(token=branch_token)
 
172
            finally:
 
173
                branch.repository.unlock()
 
174
        except errors.TokenMismatch:
 
175
            return FailedSmartServerResponse(('TokenMismatch',))
 
176
        if repo_token:
 
177
            branch.repository.dont_leave_lock_in_place()
 
178
        branch.dont_leave_lock_in_place()
 
179
        branch.unlock()
 
180
        return SuccessfulSmartServerResponse(('ok',))
 
181