/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: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

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()
169
115
        return SuccessfulSmartServerResponse(('ok', str(revno), last_revision))
170
116
 
171
117
 
172
 
class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
173
 
    """Base class for handling common branch request logic for requests that
174
 
    update the branch tip.
175
 
    """
176
 
 
177
 
    def do_with_locked_branch(self, branch, *args):
178
 
        try:
179
 
            return self.do_tip_change_with_locked_branch(branch, *args)
180
 
        except errors.TipChangeRejected, e:
181
 
            msg = e.msg
182
 
            if isinstance(msg, unicode):
183
 
                msg = msg.encode('utf-8')
184
 
            return FailedSmartServerResponse(('TipChangeRejected', msg))
185
 
 
186
 
 
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
 
class SmartServerBranchRequestSetLastRevision(SmartServerSetTipRequest):
198
 
 
199
 
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id):
 
118
class SmartServerBranchRequestSetLastRevision(SmartServerLockedBranchRequest):
 
119
    
 
120
    def do_with_locked_branch(self, branch, new_last_revision_id):
200
121
        if new_last_revision_id == 'null:':
201
122
            branch.set_revision_history([])
202
123
        else:
203
124
            if not branch.repository.has_revision(new_last_revision_id):
204
125
                return FailedSmartServerResponse(
205
126
                    ('NoSuchRevision', new_last_revision_id))
206
 
            branch.set_revision_history(branch._lefthand_history(
207
 
                new_last_revision_id, None, None))
 
127
            branch.generate_revision_history(new_last_revision_id)
208
128
        return SuccessfulSmartServerResponse(('ok',))
209
129
 
210
130
 
211
 
class SmartServerBranchRequestSetLastRevisionEx(SmartServerSetTipRequest):
212
 
 
213
 
    def do_tip_change_with_locked_branch(self, branch, new_last_revision_id,
 
131
class SmartServerBranchRequestSetLastRevisionEx(SmartServerLockedBranchRequest):
 
132
    
 
133
    def do_with_locked_branch(self, branch, new_last_revision_id,
214
134
            allow_divergence, allow_overwrite_descendant):
215
135
        """Set the last revision of the branch.
216
136
 
217
137
        New in 1.6.
218
 
 
 
138
        
219
139
        :param new_last_revision_id: the revision ID to set as the last
220
140
            revision of the branch.
221
141
        :param allow_divergence: A flag.  If non-zero, change the revision ID
256
176
            ('ok', new_revno, new_last_revision_id))
257
177
 
258
178
 
259
 
class SmartServerBranchRequestSetLastRevisionInfo(SmartServerSetTipRequest):
 
179
class SmartServerBranchRequestSetLastRevisionInfo(
 
180
    SmartServerLockedBranchRequest):
260
181
    """Branch.set_last_revision_info.  Sets the revno and the revision ID of
261
182
    the specified branch.
262
183
 
263
184
    New in bzrlib 1.4.
264
185
    """
265
 
 
266
 
    def do_tip_change_with_locked_branch(self, branch, new_revno,
267
 
            new_last_revision_id):
 
186
    
 
187
    def do_with_locked_branch(self, branch, new_revno, new_last_revision_id):
268
188
        try:
269
189
            branch.set_last_revision_info(int(new_revno), new_last_revision_id)
270
190
        except errors.NoSuchRevision:
273
193
        return SuccessfulSmartServerResponse(('ok',))
274
194
 
275
195
 
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
196
class SmartServerBranchRequestLockWrite(SmartServerBranchRequest):
288
 
 
 
197
    
289
198
    def do_with_branch(self, branch, branch_token='', repo_token=''):
290
199
        if branch_token == '':
291
200
            branch_token = None
331
240
        branch.dont_leave_lock_in_place()
332
241
        branch.unlock()
333
242
        return SuccessfulSmartServerResponse(('ok',))
334
 
 
 
243