/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to olive/push.py

  • Committer: Jelmer Vernooij
  • Date: 2006-09-27 20:30:59 UTC
  • mto: (0.12.2 olive)
  • mto: This revision was merged to the branch mainline in revision 83.
  • Revision ID: jelmer@samba.org-20060927203059-85792ae0a81db524
Bunch of small fixes, cleanups and simplifications.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/push.py
21
21
    pygtk.require("2.0")
22
22
except:
23
23
    pass
24
 
try:
25
 
    import gtk
26
 
    import gtk.gdk
27
 
    import gtk.glade
28
 
except:
29
 
    sys.exit(1)
30
 
 
31
 
import olive.backend.commit as commit
32
 
import olive.backend.errors as errors
33
 
import olive.backend.info as info
 
24
        
 
25
import gtk
 
26
import gtk.gdk
 
27
import gtk.glade
 
28
 
 
29
import bzrlib.errors as errors
 
30
 
 
31
from olive import gladefile
34
32
 
35
33
class OlivePush:
36
34
    """ Display Push dialog and perform the needed actions. """
37
 
    def __init__(self, gladefile, comm, dialog):
 
35
    def __init__(self, comm):
38
36
        """ Initialize the Push dialog. """
39
 
        self.gladefile = gladefile
40
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_push')
 
37
        self.glade = gtk.glade.XML(gladefile, 'window_push')
41
38
        
42
39
        # Communication object
43
40
        self.comm = comm
44
 
        # Dialog object
45
 
        self.dialog = dialog
46
41
        
47
42
        self.window = self.glade.get_widget('window_push')
48
43
        
71
66
        self.entry_location.set_sensitive(0)
72
67
        self.check_remember.set_sensitive(0)
73
68
        self.check_create.set_sensitive(0)
74
 
                
 
69
        
75
70
        # Get stored location
76
71
        self.notbranch = False
77
72
        try:
78
 
            loc = info.get_push_location(self.comm.get_path())
 
73
            from bzrlib.branch import Branch
 
74
    
 
75
            branch = Branch.open_containing(self.comm.get_path())[0]
 
76
    
 
77
            self.entry_stored.set_text(branch.get_push_location())
79
78
        except errors.NotBranchError:
80
79
            self.notbranch = True
81
80
            return
82
 
 
83
 
        if loc is not None:
84
 
            self.entry_stored.set_text(loc)
85
81
    
86
82
    def display(self):
87
83
        """ Display the Push dialog. """
88
84
        if self.notbranch:
89
 
            self.dialog.error_dialog(_('Directory is not a branch'),
 
85
            error_dialog(_('Directory is not a branch'),
90
86
                                     _('You can perform this action only in a branch.'))
91
87
            self.close()
92
88
        else:
122
118
        self.comm.set_busy(self.window)
123
119
        if self.radio_stored.get_active():
124
120
            try:
125
 
                revs = commit.push(self.comm.get_path(),
126
 
                                   overwrite=self.check_overwrite.get_active())
 
121
                revs = do_push(self.comm.get_path(),
 
122
                               overwrite=self.check_overwrite.get_active())
127
123
            except errors.NotBranchError:
128
 
                self.dialog.error_dialog(_('Directory is not a branch'),
 
124
                error_dialog(_('Directory is not a branch'),
129
125
                                         _('You can perform this action only in a branch.'))
130
126
                return
131
 
            except errors.NoLocationKnown:
132
 
                self.dialog.error_dialog(_('Push location is unknown'),
133
 
                                         _('Please specify a location manually.'))
134
 
                return
135
 
            except errors.NonExistingParent, errmsg:
136
 
                self.dialog.error_dialog(_('Non existing parent directory'),
137
 
                                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
138
 
                return
139
 
            except errors.DivergedBranchesError:
140
 
                self.dialog.error_dialog(_('Branches have been diverged'),
 
127
            except errors.DivergedBranches:
 
128
                error_dialog(_('Branches have been diverged'),
141
129
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
142
130
                return
143
 
            except:
144
 
                raise
145
131
        elif self.radio_specific.get_active():
146
132
            location = self.entry_location.get_text()
147
133
            if location == '':
148
 
                self.dialog.error_dialog(_('No location specified'),
 
134
                error_dialog(_('No location specified'),
149
135
                                         _('Please specify a location or use the default.'))
150
136
                return
151
137
            
152
138
            try:
153
 
                revs = commit.push(self.comm.get_path(), location,
154
 
                                   self.check_remember.get_active(),
155
 
                                   self.check_overwrite.get_active(),
156
 
                                   self.check_create.get_active())
 
139
                revs = do_push(self.comm.get_path(), location,
 
140
                               self.check_remember.get_active(),
 
141
                               self.check_overwrite.get_active(),
 
142
                               self.check_create.get_active())
157
143
            except errors.NotBranchError:
158
 
                self.dialog.error_dialog(_('Directory is not a branch'),
 
144
                error_dialog(_('Directory is not a branch'),
159
145
                                         _('You can perform this action only in a branch.'))
160
146
                self.comm.set_busy(self.window, False)
161
147
                return
162
 
            except errors.NonExistingParent, errmsg:
163
 
                self.dialog.error_dialog(_('Non existing parent directory'),
164
 
                                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
165
 
                self.comm.set_busy(self.window, False)
166
 
                return
167
 
            except errors.DivergedBranchesError:
168
 
                self.dialog.error_dialog(_('Branches have been diverged'),
 
148
            except errors.DivergedBranches:
 
149
                error_dialog(_('Branches have been diverged'),
169
150
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
170
151
                self.comm.set_busy(self.window, False)
171
152
                return
172
 
            except errors.PathPrefixNotCreated:
173
 
                self.dialog.error_dialog(_('Path prefix not created'),
174
 
                                         _("The path leading up to the specified location couldn't\nbe created."))
175
 
                self.comm.set_busy(self.window, False)
176
 
                return
177
 
            except:
178
 
                raise
179
 
        else:
180
 
            # This should really never happen
181
 
            pass
182
153
        
183
154
        self.close()
184
 
        self.dialog.info_dialog(_('Push successful'),
 
155
        info_dialog(_('Push successful'),
185
156
                                _('%d revision(s) pushed.') % revs)
186
157
    
187
158
    def test(self, widget):
212
183
    
213
184
    def close(self, widget=None):
214
185
        self.window.destroy()
 
186
 
 
187
def do_push(branch, location=None, remember=False, overwrite=False,
 
188
         create_prefix=False):
 
189
    """ Update a mirror of a branch.
 
190
    
 
191
    :param branch: the source branch
 
192
    
 
193
    :param location: the location of the branch that you'd like to update
 
194
    
 
195
    :param remember: if set, the location will be stored
 
196
    
 
197
    :param overwrite: overwrite target location if it diverged
 
198
    
 
199
    :param create_prefix: create the path leading up to the branch if it doesn't exist
 
200
    
 
201
    :return: number of revisions pushed
 
202
    """
 
203
    from bzrlib.branch import Branch
 
204
    from bzrlib.bzrdir import BzrDir
 
205
    from bzrlib.transport import get_transport
 
206
        
 
207
    br_from = Branch.open_containing(branch)[0]
 
208
    
 
209
    stored_loc = br_from.get_push_location()
 
210
    if location is None:
 
211
        if stored_loc is None:
 
212
            error_dialog(_('Push location is unknown'),
 
213
                                     _('Please specify a location manually.'))
 
214
            return
 
215
        else:
 
216
            location = stored_loc
 
217
 
 
218
    transport = get_transport(location)
 
219
    location_url = transport.base
 
220
 
 
221
    if br_from.get_push_location() is None or remember:
 
222
        br_from.set_push_location(location_url)
 
223
 
 
224
    old_rh = []
 
225
 
 
226
    try:
 
227
        dir_to = BzrDir.open(location_url)
 
228
        br_to = dir_to.open_branch()
 
229
    except errors.NotBranchError:
 
230
        # create a branch.
 
231
        transport = transport.clone('..')
 
232
        if not create_prefix:
 
233
            try:
 
234
                relurl = transport.relpath(location_url)
 
235
                transport.mkdir(relurl)
 
236
            except errors.NoSuchFile:
 
237
                error_dialog(_('Non existing parent directory'),
 
238
                                         _("The parent directory (%s)\ndoesn't exist.") % location)
 
239
                return
 
240
        else:
 
241
            current = transport.base
 
242
            needed = [(transport, transport.relpath(location_url))]
 
243
            while needed:
 
244
                try:
 
245
                    transport, relpath = needed[-1]
 
246
                    transport.mkdir(relpath)
 
247
                    needed.pop()
 
248
                except errors.NoSuchFile:
 
249
                    new_transport = transport.clone('..')
 
250
                    needed.append((new_transport,
 
251
                                   new_transport.relpath(transport.base)))
 
252
                    if new_transport.base == transport.base:
 
253
                        error_dialog(_('Path prefix not created'),
 
254
                                                 _("The path leading up to the specified location couldn't\nbe created."))
 
255
                        return
 
256
        dir_to = br_from.bzrdir.clone(location_url,
 
257
            revision_id=br_from.last_revision())
 
258
        br_to = dir_to.open_branch()
 
259
        count = len(br_to.revision_history())
 
260
    else:
 
261
        old_rh = br_to.revision_history()
 
262
        try:
 
263
            try:
 
264
                tree_to = dir_to.open_workingtree()
 
265
            except errors.NotLocalUrl:
 
266
                # FIXME - what to do here? how should we warn the user?
 
267
                #warning('This transport does not update the working '
 
268
                #        'tree of: %s' % (br_to.base,))
 
269
                count = br_to.pull(br_from, overwrite)
 
270
            except errors.NoWorkingTree:
 
271
                count = br_to.pull(br_from, overwrite)
 
272
            else:
 
273
                count = tree_to.pull(br_from, overwrite)
 
274
        except errors.DivergedBranches:
 
275
            raise
 
276
    
 
277
    return count