← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

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 SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
 
127
    
 
128
    def do_with_branch(self, branch, branch_token='', repo_token=''):
 
129
        if branch_token == '':
 
130
            branch_token = None
 
131
        if repo_token == '':
 
132
            repo_token = None
 
133
        try:
 
134
            repo_token = branch.repository.lock_write(token=repo_token)
 
135
            try:
 
136
                branch_token = branch.lock_write(token=branch_token)
 
137
            finally:
 
138
                # this leaves the repository with 1 lock
 
139
                branch.repository.unlock()
 
140
        except errors.LockContention:
 
141
            return FailedSmartServerResponse(('LockContention',))
 
142
        except errors.TokenMismatch:
 
143
            return FailedSmartServerResponse(('TokenMismatch',))
 
144
        except errors.UnlockableTransport:
 
145
            return FailedSmartServerResponse(('UnlockableTransport',))
 
146
        except errors.LockFailed, e:
 
147
            return FailedSmartServerResponse(('LockFailed', str(e.lock), str(e.why)))
 
148
        if repo_token is None:
 
149
            repo_token = ''
 
150
        else:
 
151
            branch.repository.leave_lock_in_place()
 
152
        branch.leave_lock_in_place()
 
153
        branch.unlock()
 
154
        return SuccessfulSmartServerResponse(('ok', branch_token, repo_token))
 
155
 
 
156
 
 
157
class SmartServerBranchRequestUnlock(SmartServerBranchRequest):
 
158
 
 
159
    def do_with_branch(self, branch, branch_token, repo_token):
 
160
        try:
 
161
            branch.repository.lock_write(token=repo_token)
 
162
            try:
 
163
                branch.lock_write(token=branch_token)
 
164
            finally:
 
165
                branch.repository.unlock()
 
166
        except errors.TokenMismatch:
 
167
            return FailedSmartServerResponse(('TokenMismatch',))
 
168
        if repo_token:
 
169
            branch.repository.dont_leave_lock_in_place()
 
170
        branch.dont_leave_lock_in_place()
 
171
        branch.unlock()
 
172
        return SuccessfulSmartServerResponse(('ok',))
 
173