/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 push.py

  • Committer: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
 
2
# Copyright (C) 2007 by Jelmer Vernooij <jelmer@samba.org>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
import sys
18
 
 
19
18
try:
20
19
    import pygtk
21
20
    pygtk.require("2.0")
22
21
except:
23
22
    pass
24
 
try:
25
 
    import gtk
26
 
    import gtk.gdk
27
 
    import gtk.glade
28
 
except:
29
 
    sys.exit(1)
30
 
 
 
23
    
 
24
import gtk
 
25
 
 
26
from errors import show_bzr_error
 
27
 
 
28
# FIXME: This needs to be public JRV 20070714
 
29
from bzrlib.builtins import _create_prefix
 
30
from bzrlib.config import LocationConfig
31
31
import bzrlib.errors as errors
32
32
 
33
 
class OlivePush:
34
 
    """ Display Push dialog and perform the needed actions. """
35
 
    def __init__(self, gladefile, comm):
 
33
from bzrlib.plugins.gtk import _i18n
 
34
from dialog import error_dialog, info_dialog, question_dialog
 
35
 
 
36
from history import UrlHistory
 
37
 
 
38
class PushDialog(gtk.Dialog):
 
39
    """ New implementation of the Push dialog. """
 
40
    def __init__(self, repository, revid, branch=None, parent=None):
36
41
        """ Initialize the Push dialog. """
37
 
        self.gladefile = gladefile
38
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_push')
39
 
        
40
 
        # Communication object
41
 
        self.comm = comm
42
 
        
43
 
        self.window = self.glade.get_widget('window_push')
44
 
        
45
 
        # Dictionary for signal_autoconnect
46
 
        dic = { "on_button_push_push_clicked": self.push,
47
 
                "on_button_push_cancel_clicked": self.close,
48
 
                "on_button_push_test_clicked": self.test,
49
 
                "on_radiobutton_push_stored_toggled": self.stored_toggled,
50
 
                "on_radiobutton_push_specific_toggled": self.specific_toggled, }
51
 
        
52
 
        # Connect the signals to the handlers
53
 
        self.glade.signal_autoconnect(dic)
54
 
        
55
 
        # Get some useful widgets
56
 
        self.radio_stored = self.glade.get_widget('radiobutton_push_stored')
57
 
        self.radio_specific = self.glade.get_widget('radiobutton_push_specific')
58
 
        self.entry_stored = self.glade.get_widget('entry_push_stored')
59
 
        self.entry_location = self.glade.get_widget('entry_push_location')
60
 
        self.check_remember = self.glade.get_widget('checkbutton_push_remember')
61
 
        self.check_overwrite = self.glade.get_widget('checkbutton_push_overwrite')
62
 
        self.check_create = self.glade.get_widget('checkbutton_push_create')
63
 
        self.label_test = self.glade.get_widget('label_push_test')
64
 
        self.image_test = self.glade.get_widget('image_push_test')
65
 
        
66
 
        # Set initial state
67
 
        self.entry_location.set_sensitive(0)
68
 
        self.check_remember.set_sensitive(0)
69
 
        self.check_create.set_sensitive(0)
70
 
        
71
 
        # Get stored location
72
 
        self.notbranch = False
73
 
        try:
74
 
            from bzrlib.branch import Branch
75
 
    
76
 
            branch = Branch.open_containing(self.comm.get_path())[0]
77
 
    
78
 
            self.entry_stored.set_text(branch.get_push_location())
79
 
        except errors.NotBranchError:
80
 
            self.notbranch = True
81
 
            return
82
 
    
83
 
    def display(self):
84
 
        """ Display the Push dialog. """
85
 
        if self.notbranch:
86
 
            error_dialog(_('Directory is not a branch'),
87
 
                                     _('You can perform this action only in a branch.'))
88
 
            self.close()
89
 
        else:
90
 
            self.window.show()
91
 
            self.width, self.height = self.window.get_size()
92
 
    
93
 
    def stored_toggled(self, widget):
94
 
        if widget.get_active():
95
 
            self.entry_stored.set_sensitive(1)
96
 
            self.entry_location.set_sensitive(0)
97
 
            self.check_remember.set_sensitive(0)
98
 
            self.check_create.set_sensitive(0)
99
 
        else:
100
 
            self.entry_stored.set_sensitive(0)
101
 
            self.entry_location.set_sensitive(1)
102
 
            self.check_remember.set_sensitive(1)
103
 
            self.check_create.set_sensitive(1)
104
 
    
105
 
    def specific_toggled(self, widget):
106
 
        if widget.get_active():
107
 
            self.entry_stored.set_sensitive(0)
108
 
            self.entry_location.set_sensitive(1)
109
 
            self.check_remember.set_sensitive(1)
110
 
            self.check_create.set_sensitive(1)
111
 
        else:
112
 
            self.entry_stored.set_sensitive(1)
113
 
            self.entry_location.set_sensitive(0)
114
 
            self.check_remember.set_sensitive(0)
115
 
            self.check_create.set_sensitive(0)
116
 
    
117
 
    def push(self, widget):
 
42
        gtk.Dialog.__init__(self, title="Push - Olive",
 
43
                                  parent=parent,
 
44
                                  flags=0,
 
45
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
46
        
 
47
        # Get arguments
 
48
        self.repository = repository
 
49
        self.revid = revid
 
50
        self.branch = branch
 
51
        
 
52
        # Create the widgets
 
53
        self._label_location = gtk.Label(_i18n("Location:"))
 
54
        self._combo = gtk.ComboBoxEntry()
 
55
        self._button_push = gtk.Button(_i18n("_Push"), use_underline=True)
 
56
        self._hbox_location = gtk.HBox()
 
57
        
 
58
        # Set callbacks
 
59
        self._button_push.connect('clicked', self._on_push_clicked)
 
60
        
 
61
        # Set properties
 
62
        self._label_location.set_alignment(0, 0.5)
 
63
        self._hbox_location.set_spacing(3)
 
64
        self.vbox.set_spacing(3)
 
65
        
 
66
        # Pack widgets
 
67
        self._hbox_location.pack_start(self._label_location, False, False)
 
68
        self._hbox_location.pack_start(self._combo, True, True)
 
69
        self.vbox.pack_start(self._hbox_location)
 
70
        self.action_area.pack_end(self._button_push)
 
71
        
 
72
        # Show the dialog
 
73
        self.vbox.show_all()
 
74
        
 
75
        # Build location history
 
76
        self._history = UrlHistory(self.branch.get_config(), 'push_history')
 
77
        self._build_history()
 
78
        
 
79
    def _build_history(self):
 
80
        """ Build up the location history. """
 
81
        self._combo_model = gtk.ListStore(str)
 
82
        for item in self._history.get_entries():
 
83
            self._combo_model.append([ item ])
 
84
        self._combo.set_model(self._combo_model)
 
85
        self._combo.set_text_column(0)
 
86
        
 
87
        if self.branch is not None:
 
88
            location = self.branch.get_push_location()
 
89
            if location is not None:
 
90
                self._combo.get_child().set_text(location)
 
91
    
 
92
    @show_bzr_error
 
93
    def _on_push_clicked(self, widget):
 
94
        """ Push button clicked handler. """
 
95
        location = self._combo.get_child().get_text()
118
96
        revs = 0
119
 
        self.comm.set_busy(self.window)
120
 
        if self.radio_stored.get_active():
121
 
            try:
122
 
                revs = do_push(self.comm.get_path(),
123
 
                               overwrite=self.check_overwrite.get_active())
124
 
            except errors.NotBranchError:
125
 
                error_dialog(_('Directory is not a branch'),
126
 
                                         _('You can perform this action only in a branch.'))
127
 
                return
128
 
            except errors.DivergedBranches:
129
 
                error_dialog(_('Branches have been diverged'),
130
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
131
 
                return
132
 
            except:
133
 
                raise
134
 
        elif self.radio_specific.get_active():
135
 
            location = self.entry_location.get_text()
136
 
            if location == '':
137
 
                error_dialog(_('No location specified'),
138
 
                                         _('Please specify a location or use the default.'))
139
 
                return
140
 
            
141
 
            try:
142
 
                revs = do_push(self.comm.get_path(), location,
143
 
                               self.check_remember.get_active(),
144
 
                               self.check_overwrite.get_active(),
145
 
                               self.check_create.get_active())
146
 
            except errors.NotBranchError:
147
 
                error_dialog(_('Directory is not a branch'),
148
 
                                         _('You can perform this action only in a branch.'))
149
 
                self.comm.set_busy(self.window, False)
150
 
                return
151
 
            except errors.DivergedBranches:
152
 
                error_dialog(_('Branches have been diverged'),
153
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
154
 
                self.comm.set_busy(self.window, False)
155
 
                return
156
 
            except:
157
 
                raise
158
 
        else:
159
 
            # This should really never happen
160
 
            pass
161
 
        
162
 
        self.close()
163
 
        info_dialog(_('Push successful'),
164
 
                                _('%d revision(s) pushed.') % revs)
165
 
    
166
 
    def test(self, widget):
167
 
        """ Test if write access possible. """
168
 
        import re
169
 
        _urlRE = re.compile(r'^(?P<proto>[^:/\\]+)://(?P<path>.*)$')
170
 
        
171
 
        if self.radio_stored.get_active():
172
 
            url = self.entry_stored.get_text()
173
 
        elif self.radio_specific.get_active():
174
 
            url = self.entry_location.get_text()
175
 
        
176
 
        m = _urlRE.match(url)
177
 
        if m:
178
 
            proto = m.groupdict()['proto']
179
 
            if (proto == 'sftp') or (proto == 'file') or (proto == 'ftp'):
180
 
                # have write acces (most probably)
181
 
                self.image_test.set_from_stock(gtk.STOCK_YES, 4)
182
 
                self.label_test.set_markup(_('<b>Write access is probably available</b>'))
183
 
            else:
184
 
                # no write access
185
 
                self.image_test.set_from_stock(gtk.STOCK_NO, 4)
186
 
                self.label_test.set_markup(_('<b>No write access</b>'))
187
 
        else:
188
 
            # couldn't determine
189
 
            self.image_test.set_from_stock(gtk.STOCK_DIALOG_QUESTION, 4)
190
 
            self.label_test.set_markup(_('<b>Could not determine</b>'))
191
 
    
192
 
    def close(self, widget=None):
193
 
        self.window.destroy()
194
 
 
195
 
def do_push(branch, location=None, remember=False, overwrite=False,
196
 
         create_prefix=False):
 
97
        if self.branch is not None and self.branch.get_push_location() is None:
 
98
            response = question_dialog(_i18n('Set default push location'),
 
99
                                       _i18n('There is no default push location set.\nSet %r as default now?') % location)
 
100
            if response == gtk.RESPONSE_OK:
 
101
                self.branch.set_push_location(location)
 
102
 
 
103
        try:
 
104
            revs = do_push(self.branch, location=location, overwrite=False)
 
105
        except errors.DivergedBranches:
 
106
            response = question_dialog(_i18n('Branches have been diverged'),
 
107
                                       _i18n('You cannot push if branches have diverged.\nOverwrite?'))
 
108
            if response == gtk.RESPONSE_YES:
 
109
                revs = do_push(self.branch, location=location, overwrite=True)
 
110
        
 
111
        self._history.add_entry(location)
 
112
        info_dialog(_i18n('Push successful'),
 
113
                    _i18n("%d revision(s) pushed.") % revs)
 
114
        
 
115
        self.response(gtk.RESPONSE_OK)
 
116
 
 
117
def do_push(br_from, location, overwrite):
197
118
    """ Update a mirror of a branch.
198
119
    
199
 
    :param branch: the source branch
 
120
    :param br_from: the source branch
200
121
    
201
122
    :param location: the location of the branch that you'd like to update
202
123
    
203
 
    :param remember: if set, the location will be stored
204
 
    
205
124
    :param overwrite: overwrite target location if it diverged
206
125
    
207
 
    :param create_prefix: create the path leading up to the branch if it doesn't exist
208
 
    
209
126
    :return: number of revisions pushed
210
127
    """
211
 
    from bzrlib.branch import Branch
212
128
    from bzrlib.bzrdir import BzrDir
213
129
    from bzrlib.transport import get_transport
214
130
        
215
 
    br_from = Branch.open_containing(branch)[0]
216
 
    
217
 
    stored_loc = br_from.get_push_location()
218
 
    if location is None:
219
 
        if stored_loc is None:
220
 
            error_dialog(_('Push location is unknown'),
221
 
                                     _('Please specify a location manually.'))
222
 
            return
223
 
        else:
224
 
            location = stored_loc
225
 
 
226
131
    transport = get_transport(location)
227
132
    location_url = transport.base
228
133
 
229
 
    if br_from.get_push_location() is None or remember:
230
 
        br_from.set_push_location(location_url)
231
 
 
232
134
    old_rh = []
233
135
 
234
136
    try:
237
139
    except errors.NotBranchError:
238
140
        # create a branch.
239
141
        transport = transport.clone('..')
240
 
        if not create_prefix:
241
 
            try:
242
 
                relurl = transport.relpath(location_url)
243
 
                transport.mkdir(relurl)
244
 
            except errors.NoSuchFile:
245
 
                error_dialog(_('Non existing parent directory'),
246
 
                                         _("The parent directory (%s)\ndoesn't exist.") % location)
 
142
        try:
 
143
            relurl = transport.relpath(location_url)
 
144
            transport.mkdir(relurl)
 
145
        except errors.NoSuchFile:
 
146
            response = question_dialog(_i18n('Non existing parent directory'),
 
147
                         _i18n("The parent directory (%s)\ndoesn't exist. Create?") % location)
 
148
            if response == gtk.RESPONSE_OK:
 
149
                _create_prefix(transport)
 
150
            else:
247
151
                return
248
 
        else:
249
 
            current = transport.base
250
 
            needed = [(transport, transport.relpath(location_url))]
251
 
            while needed:
252
 
                try:
253
 
                    transport, relpath = needed[-1]
254
 
                    transport.mkdir(relpath)
255
 
                    needed.pop()
256
 
                except errors.NoSuchFile:
257
 
                    new_transport = transport.clone('..')
258
 
                    needed.append((new_transport,
259
 
                                   new_transport.relpath(transport.base)))
260
 
                    if new_transport.base == transport.base:
261
 
                        error_dialog(_('Path prefix not created'),
262
 
                                                 _("The path leading up to the specified location couldn't\nbe created."))
263
 
                        return
264
152
        dir_to = br_from.bzrdir.clone(location_url,
265
153
            revision_id=br_from.last_revision())
266
154
        br_to = dir_to.open_branch()
268
156
    else:
269
157
        old_rh = br_to.revision_history()
270
158
        try:
271
 
            try:
272
 
                tree_to = dir_to.open_workingtree()
273
 
            except errors.NotLocalUrl:
274
 
                # FIXME - what to do here? how should we warn the user?
275
 
                #warning('This transport does not update the working '
276
 
                #        'tree of: %s' % (br_to.base,))
277
 
                count = br_to.pull(br_from, overwrite)
278
 
            except errors.NoWorkingTree:
279
 
                count = br_to.pull(br_from, overwrite)
280
 
            else:
281
 
                count = tree_to.pull(br_from, overwrite)
282
 
        except errors.DivergedBranches:
283
 
            raise
284
 
    
 
159
            tree_to = dir_to.open_workingtree()
 
160
        except errors.NotLocalUrl:
 
161
            # FIXME - what to do here? how should we warn the user?
 
162
            count = br_to.pull(br_from, overwrite)
 
163
        except errors.NoWorkingTree:
 
164
            count = br_to.pull(br_from, overwrite)
 
165
        else:
 
166
            count = tree_to.pull(br_from, overwrite)
 
167
 
285
168
    return count