/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: Szilveszter Farkas (Phanatic)
  • Date: 2006-09-30 13:04:15 UTC
  • mto: (0.14.3 main)
  • mto: This revision was merged to the branch mainline in revision 86.
  • Revision ID: Szilveszter.Farkas@gmail.com-20060930130415-aba4100709e11f0a
Loads of fixes. Pyflakes cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/push.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
import sys
18
 
 
19
17
try:
20
18
    import pygtk
21
19
    pygtk.require("2.0")
22
20
except:
23
21
    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
 
22
    
 
23
import gtk
 
24
import gtk.gdk
 
25
import gtk.glade
 
26
 
 
27
import bzrlib.errors as errors
 
28
 
 
29
from olive import gladefile
 
30
from dialog import error_dialog, info_dialog
34
31
 
35
32
class OlivePush:
36
33
    """ Display Push dialog and perform the needed actions. """
37
 
    def __init__(self, gladefile, comm, dialog):
 
34
    def __init__(self, branch):
38
35
        """ Initialize the Push dialog. """
39
 
        self.gladefile = gladefile
40
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_push')
41
 
        
42
 
        # Communication object
43
 
        self.comm = comm
44
 
        # Dialog object
45
 
        self.dialog = dialog
 
36
        self.glade = gtk.glade.XML(gladefile, 'window_push')
46
37
        
47
38
        self.window = self.glade.get_widget('window_push')
 
39
 
 
40
        self.branch = branch
48
41
        
49
42
        # Dictionary for signal_autoconnect
50
43
        dic = { "on_button_push_push_clicked": self.push,
71
64
        self.entry_location.set_sensitive(0)
72
65
        self.check_remember.set_sensitive(0)
73
66
        self.check_create.set_sensitive(0)
74
 
                
75
 
        # Get stored location
76
 
        self.notbranch = False
77
 
        try:
78
 
            loc = info.get_push_location(self.comm.get_path())
79
 
        except errors.NotBranchError:
80
 
            self.notbranch = True
81
 
            return
82
 
 
83
 
        if loc is not None:
84
 
            self.entry_stored.set_text(loc)
 
67
        
 
68
        self.entry_stored.set_text(branch.get_push_location())
85
69
    
86
70
    def display(self):
87
71
        """ Display the Push dialog. """
88
 
        if self.notbranch:
89
 
            self.dialog.error_dialog(_('Directory is not a branch'),
90
 
                                     _('You can perform this action only in a branch.'))
91
 
            self.close()
92
 
        else:
93
 
            self.window.show()
94
 
            self.width, self.height = self.window.get_size()
 
72
        self.window.show()
 
73
        self.width, self.height = self.window.get_size()
95
74
    
96
75
    def stored_toggled(self, widget):
97
76
        if widget.get_active():
119
98
    
120
99
    def push(self, widget):
121
100
        revs = 0
122
 
        self.comm.set_busy(self.window)
123
101
        if self.radio_stored.get_active():
124
102
            try:
125
 
                revs = commit.push(self.comm.get_path(),
126
 
                                   overwrite=self.check_overwrite.get_active())
 
103
                revs = do_push(self.branch,
 
104
                               overwrite=self.check_overwrite.get_active())
127
105
            except errors.NotBranchError:
128
 
                self.dialog.error_dialog(_('Directory is not a branch'),
129
 
                                         _('You can perform this action only in a branch.'))
130
 
                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'),
141
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
142
 
                return
143
 
            except:
144
 
                raise
 
106
                error_dialog(_('Directory is not a branch'),
 
107
                             _('You can perform this action only in a branch.'))
 
108
                return
 
109
            except errors.DivergedBranches:
 
110
                error_dialog(_('Branches have been diverged'),
 
111
                             _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
 
112
                return
145
113
        elif self.radio_specific.get_active():
146
114
            location = self.entry_location.get_text()
147
115
            if location == '':
148
 
                self.dialog.error_dialog(_('No location specified'),
149
 
                                         _('Please specify a location or use the default.'))
 
116
                error_dialog(_('No location specified'),
 
117
                             _('Please specify a location or use the default.'))
150
118
                return
151
119
            
152
120
            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())
 
121
                revs = do_push(self.branch, location,
 
122
                               self.check_remember.get_active(),
 
123
                               self.check_overwrite.get_active(),
 
124
                               self.check_create.get_active())
157
125
            except errors.NotBranchError:
158
 
                self.dialog.error_dialog(_('Directory is not a branch'),
159
 
                                         _('You can perform this action only in a branch.'))
160
 
                self.comm.set_busy(self.window, False)
161
 
                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'),
169
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
170
 
                self.comm.set_busy(self.window, False)
171
 
                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
 
126
                error_dialog(_('Directory is not a branch'),
 
127
                             _('You can perform this action only in a branch.'))
 
128
                return
 
129
            except errors.DivergedBranches:
 
130
                error_dialog(_('Branches have been diverged'),
 
131
                             _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
 
132
                return
182
133
        
183
134
        self.close()
184
 
        self.dialog.info_dialog(_('Push successful'),
185
 
                                _('%d revision(s) pushed.') % revs)
 
135
        info_dialog(_('Push successful'),
 
136
                    _('%d revision(s) pushed.') % revs)
186
137
    
187
138
    def test(self, widget):
188
139
        """ Test if write access possible. """
212
163
    
213
164
    def close(self, widget=None):
214
165
        self.window.destroy()
 
166
 
 
167
def do_push(branch, location=None, remember=False, overwrite=False,
 
168
         create_prefix=False):
 
169
    """ Update a mirror of a branch.
 
170
    
 
171
    :param branch: the source branch
 
172
    
 
173
    :param location: the location of the branch that you'd like to update
 
174
    
 
175
    :param remember: if set, the location will be stored
 
176
    
 
177
    :param overwrite: overwrite target location if it diverged
 
178
    
 
179
    :param create_prefix: create the path leading up to the branch if it doesn't exist
 
180
    
 
181
    :return: number of revisions pushed
 
182
    """
 
183
    from bzrlib.branch import Branch
 
184
    from bzrlib.bzrdir import BzrDir
 
185
    from bzrlib.transport import get_transport
 
186
        
 
187
    br_from = Branch.open_containing(branch)[0]
 
188
    
 
189
    stored_loc = br_from.get_push_location()
 
190
    if location is None:
 
191
        if stored_loc is None:
 
192
            error_dialog(_('Push location is unknown'),
 
193
                                     _('Please specify a location manually.'))
 
194
            return
 
195
        else:
 
196
            location = stored_loc
 
197
 
 
198
    transport = get_transport(location)
 
199
    location_url = transport.base
 
200
 
 
201
    if br_from.get_push_location() is None or remember:
 
202
        br_from.set_push_location(location_url)
 
203
 
 
204
    old_rh = []
 
205
 
 
206
    try:
 
207
        dir_to = BzrDir.open(location_url)
 
208
        br_to = dir_to.open_branch()
 
209
    except errors.NotBranchError:
 
210
        # create a branch.
 
211
        transport = transport.clone('..')
 
212
        if not create_prefix:
 
213
            try:
 
214
                relurl = transport.relpath(location_url)
 
215
                transport.mkdir(relurl)
 
216
            except errors.NoSuchFile:
 
217
                error_dialog(_('Non existing parent directory'),
 
218
                             _("The parent directory (%s)\ndoesn't exist.") % location)
 
219
                return
 
220
        else:
 
221
            current = transport.base
 
222
            needed = [(transport, transport.relpath(location_url))]
 
223
            while needed:
 
224
                try:
 
225
                    transport, relpath = needed[-1]
 
226
                    transport.mkdir(relpath)
 
227
                    needed.pop()
 
228
                except errors.NoSuchFile:
 
229
                    new_transport = transport.clone('..')
 
230
                    needed.append((new_transport,
 
231
                                   new_transport.relpath(transport.base)))
 
232
                    if new_transport.base == transport.base:
 
233
                        error_dialog(_('Path prefix not created'),
 
234
                                     _("The path leading up to the specified location couldn't\nbe created."))
 
235
                        return
 
236
        dir_to = br_from.bzrdir.clone(location_url,
 
237
            revision_id=br_from.last_revision())
 
238
        br_to = dir_to.open_branch()
 
239
        count = len(br_to.revision_history())
 
240
    else:
 
241
        old_rh = br_to.revision_history()
 
242
        try:
 
243
            tree_to = dir_to.open_workingtree()
 
244
        except errors.NotLocalUrl:
 
245
            # FIXME - what to do here? how should we warn the user?
 
246
            #warning('This transport does not update the working '
 
247
            #        'tree of: %s' % (br_to.base,))
 
248
            count = br_to.pull(br_from, overwrite)
 
249
        except errors.NoWorkingTree:
 
250
            count = br_to.pull(br_from, overwrite)
 
251
        else:
 
252
            count = tree_to.pull(br_from, overwrite)
 
253
 
 
254
    return count