← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/branch.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-18 22:34:21 UTC
  • mto: (3606.5.6 1.6)
  • mto: This revision was merged to the branch mainline in revision 3641.
  • Revision ID: john@arbash-meinel.com-20080818223421-todjny24vj4faj4t
Add tests for the fetching behavior.

The proper parameter passed is 'unordered' add an assert for it, and
fix callers that were passing 'unsorted' instead.
Add tests that we make the right get_record_stream call based
on the value of _fetch_uses_deltas.
Fix the fetch request for signatures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/branch.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Server-side branch related request implmentations."""
18
18
 
32
32
 
33
33
    def do(self, path, *args):
34
34
        """Execute a request for a branch at path.
35
 
 
 
35
    
36
36
        All Branch requests take a path to the branch as their first argument.
37
37
 
38
38
        If the branch is a branch reference, NotBranchError is raised.
45
45
        bzrdir = BzrDir.open_from_transport(transport)
46
46
        if bzrdir.get_branch_reference() is not None:
47
47
            raise errors.NotBranchError(transport.base)
48
 
        branch = bzrdir.open_branch(ignore_fallbacks=True)
 
48
        branch = bzrdir.open_branch()
49
49
        return self.do_with_branch(branch, *args)
50
50
 
51
51
 
74
74
 
75
75
 
76
76
class SmartServerBranchGetConfigFile(SmartServerBranchRequest):
77
 
 
 
77
    
78
78
    def do_with_branch(self, branch):
79
79
        """Return the content of branch.conf
80
 
 
 
80
        
81
81
        The body is not utf8 decoded - its the literal bytestream from disk.
82
82
        """
 
83
        # This was at one time called by RemoteBranchLockableFiles
 
84
        # intercepting access to this file; as of 1.5 it is not called by the
 
85
        # client but retained for compatibility.  It may be called again to
 
86
        # allow the client to get the configuration without needing vfs
 
87
        # access.
83
88
        try:
84
89
            content = branch._transport.get_bytes('branch.conf')
85
90
        except errors.NoSuchFile:
87
92
        return SuccessfulSmartServerResponse( ('ok', ), content)
88
93
 
89
94
 
90
 
class SmartServerBranchGetParent(SmartServerBranchRequest):
91
 
 
92
 
    def do_with_branch(self, branch):
93
 
        """Return the parent of branch."""
94
 
        parent = branch._get_parent_location() or ''
95
 
        return SuccessfulSmartServerResponse((parent,))
96
 
 
97
 
 
98
 
class SmartServerBranchGetTagsBytes(SmartServerBranchRequest):
99
 
 
100
 
    def do_with_branch(self, branch):
101
 
        """Return the _get_tags_bytes for a branch."""
102
 
        bytes = branch._get_tags_bytes()
103
 
        return SuccessfulSmartServerResponse((bytes,))
104
 
 
105
 
 
106
 
class SmartServerBranchSetTagsBytes(SmartServerLockedBranchRequest):
107
 
 
108
 
    def __init__(self, backing_transport, root_client_path='/', jail_root=None):
109
 
        SmartServerLockedBranchRequest.__init__(
110
 
            self, backing_transport, root_client_path, jail_root)
111
 
        self.locked = False
112
 
        
113
 
    def do_with_locked_branch(self, branch):
114
 
        """Call _set_tags_bytes for a branch.
115
 
 
116
 
        New in 1.18.
117
 
        """
118
 
        # We need to keep this branch locked until we get a body with the tags
119
 
        # bytes.
120
 
        self.branch = branch
121
 
        self.branch.lock_write()
122
 
        self.locked = True
123
 
 
124
 
    def do_body(self, bytes):
125
 
        self.branch._set_tags_bytes(bytes)
126
 
        return SuccessfulSmartServerResponse(())
127
 
 
128
 
    def do_end(self):
129
 
        # TODO: this request shouldn't have to do this housekeeping manually.
130
 
        # Some of this logic probably belongs in a base class.
131
 
        if not self.locked:
132
 
            # We never acquired the branch successfully in the first place, so
133
 
            # there's nothing more to do.
134
 
            return
135
 
        try:
136
 
            return SmartServerLockedBranchRequest.do_end(self)
137
 
        finally:
138
 
            # Only try unlocking if we locked successfully in the first place
139
 
            self.branch.unlock()
140
 
 
141
 
 
142
 
class SmartServerBranchRequestGetStackedOnURL(SmartServerBranchRequest):
143
 
 
144
 
    def do_with_branch(self, branch):
145
 
        stacked_on_url = branch.get_stacked_on_url()
146
 
        return SuccessfulSmartServerResponse(('ok', stacked_on_url))
147
 
 
148
 
 
149
95
class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
150
96
 
151
97
    def do_with_branch(self, branch):
159
105
 
160
106
 
161
107
class SmartServerBranchRequestLastRevisionInfo(SmartServerBranchRequest):
162
 
 
 
108
    
163
109
    def do_with_branch(self, branch):
164
110
        """Return branch.last_revision_info().
165
 
 
 
111
        
166
112
        The revno is encoded in decimal, the revision_id is encoded as utf8.
167
113
        """
168
114
        revno, last_revision = branch.last_revision_info()
184
130
            return FailedSmartServerResponse(('TipChangeRejected', msg))
185
131
 
186
132
 
187
 
class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
188
 
    """Set an option in the branch configuration."""
189
 
 
190
 
    def do_with_locked_branch(self, branch, value, name, section):
191
 
        if not section:
192
 
            section = None
193
 
        branch._get_config().set_option(value.decode('utf8'), name, section)
194
 
        return SuccessfulSmartServerResponse(())
195
 
 
196
 
 
197
133
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
198
 
 
 
134
    
199
135
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
200
136
        if new_last_revision_id == 'null:':
201
137
            branch.set_revision_history([])
203
139
            if not branch.repository.has_revision(new_last_revision_id):
204
140
                return FailedSmartServerResponse(
205
141
                    ('NoSuchRevision', new_last_revision_id))
206
 
            branch.set_revision_history(branch._lefthand_history(
207
 
                new_last_revision_id, None, None))
 
142
            branch.generate_revision_history(new_last_revision_id)
208
143
        return SuccessfulSmartServerResponse(('ok',))
209
144
 
210
145
 
211
146
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
212
 
 
 
147
    
213
148
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
214
149
            allow_divergence, allow_overwrite_descendant):
215
150
        """Set the last revision of the branch.
216
151
 
217
152
        New in 1.6.
218
 
 
 
153
        
219
154
        :param new_last_revision_id: the revision ID to set as the last
220
155
            revision of the branch.
221
156
        :param allow_divergence: A flag.  If non-zero, change the revision ID
262
197
 
263
198
    New in bzrlib 1.4.
264
199
    """
265
 
 
 
200
    
266
201
    def do_tip_change_with_locked_branch(self, branch, new_revno,
267
202
            new_last_revision_id):
268
203
        try:
273
208
        return SuccessfulSmartServerResponse(('ok',))
274
209
 
275
210
 
276
 
class SmartServerBranchRequestSetParentLocation(SmartServerLockedBranchRequest):
277
 
    """Set the parent location for a branch.
278
 
    
279
 
    Takes a location to set, which must be utf8 encoded.
280
 
    """
281
 
 
282
 
    def do_with_locked_branch(self, branch, location):
283
 
        branch._set_parent_location(location)
284
 
        return SuccessfulSmartServerResponse(())
285
 
 
286
 
 
287
211
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
288
 
 
 
212
    
289
213
    def do_with_branch(self, branch, branch_token='', repo_token=''):
290
214
        if branch_token == '':
291
215
            branch_token = None
292
216
        if repo_token == '':
293
217
            repo_token = None
294
218
        try:
295
 
            repo_token = branch.repository.lock_write(
296
 
                token=repo_token).repository_token
 
219
            repo_token = branch.repository.lock_write(token=repo_token)
297
220
            try:
298
 
                branch_token = branch.lock_write(
299
 
                    token=branch_token).branch_token
 
221
                branch_token = branch.lock_write(token=branch_token)
300
222
            finally:
301
223
                # this leaves the repository with 1 lock
302
224
                branch.repository.unlock()
333
255
        branch.dont_leave_lock_in_place()
334
256
        branch.unlock()
335
257
        return SuccessfulSmartServerResponse(('ok',))
336
 
 
 
258