/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

Fix formatting, remove catch-all for exceptions when opening local repositories.

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
 
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
129
 
    the specified branch.
130
 
 
131
 
    New in bzrlib 1.4.
132
 
    """
133
 
    
134
 
    def do_with_locked_branch(self, branch, new_revno, new_last_revision_id):
135
 
        try:
136
 
            branch.set_last_revision_info(int(new_revno), new_last_revision_id)
137
 
        except errors.NoSuchRevision:
138
 
            return FailedSmartServerResponse(
139
 
                ('NoSuchRevision', new_last_revision_id))
140
 
        return SuccessfulSmartServerResponse(('ok',))
141
 
 
142
 
 
143
 
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
144
 
    
145
 
    def do_with_branch(self, branch, branch_token='', repo_token=''):
146
 
        if branch_token == '':
147
 
            branch_token = None
148
 
        if repo_token == '':
149
 
            repo_token = None
150
 
        try:
151
 
            repo_token = branch.repository.lock_write(token=repo_token)
152
 
            try:
153
 
                branch_token = branch.lock_write(token=branch_token)
154
 
            finally:
155
 
                # this leaves the repository with 1 lock
156
 
                branch.repository.unlock()
157
 
        except errors.LockContention:
158
 
            return FailedSmartServerResponse(('LockContention',))
159
 
        except errors.TokenMismatch:
160
 
            return FailedSmartServerResponse(('TokenMismatch',))
161
 
        except errors.UnlockableTransport:
162
 
            return FailedSmartServerResponse(('UnlockableTransport',))
163
 
        except errors.LockFailed, e:
164
 
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
165
 
        if repo_token is None:
166
 
            repo_token = ''
167
 
        else:
168
 
            branch.repository.leave_lock_in_place()
169
 
        branch.leave_lock_in_place()
170
 
        branch.unlock()
171
 
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
172
 
 
173
 
 
174
 
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
175
 
 
176
 
    def do_with_branch(self, branch, branch_token, repo_token):
177
 
        try:
178
 
            branch.repository.lock_write(token=repo_token)
179
 
            try:
180
 
                branch.lock_write(token=branch_token)
181
 
            finally:
182
 
                branch.repository.unlock()
183
 
        except errors.TokenMismatch:
184
 
            return FailedSmartServerResponse(('TokenMismatch',))
185
 
        if repo_token:
186
 
            branch.repository.dont_leave_lock_in_place()
187
 
        branch.dont_leave_lock_in_place()
188
 
        branch.unlock()
189
 
        return SuccessfulSmartServerResponse(('ok',))
190