Print this page
*** NO COMMENTS ***
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/gui/modules/beadmin.py
+++ new/src/gui/modules/beadmin.py
1 1 #!/usr/bin/python2.4
2 2 #
3 3 # CDDL HEADER START
4 4 #
5 5 # The contents of this file are subject to the terms of the
6 6 # Common Development and Distribution License (the "License").
7 7 # You may not use this file except in compliance with the License.
8 8 #
9 9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 # or http://www.opensolaris.org/os/licensing.
11 11 # See the License for the specific language governing permissions
12 12 # and limitations under the License.
13 13 #
14 14 # When distributing Covered Code, include this CDDL HEADER in each
15 15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 # If applicable, add the following below this CDDL HEADER, with the
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
17 17 # fields enclosed by brackets "[]" replaced with your own identifying
18 18 # information: Portions Copyright [yyyy] [name of copyright owner]
19 19 #
20 20 # CDDL HEADER END
21 21 #
22 22 # Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 23 # Use is subject to license terms.
24 24 #
25 25
26 26 import sys
27 +import os
27 28 import pango
28 29 import time
29 30 import datetime
30 31 import locale
31 32 import pkg.pkgsubprocess as subprocess
32 33 from threading import Thread
33 34
34 35 try:
35 36 import gobject
36 37 gobject.threads_init()
37 38 import gnome
38 39 import gtk
39 40 import gtk.glade
40 41 import pygtk
41 42 pygtk.require("2.0")
42 43 except ImportError:
43 44 sys.exit(1)
44 45 import pkg.gui.misc as gui_misc
45 46
46 47 nobe = False
47 48
48 49 try:
49 50 import libbe as be
50 51 except ImportError:
51 52 # All actions are disabled when libbe can't be imported.
52 53 nobe = True
53 54 import pkg.misc
54 55
55 56 #BE_LIST
56 57 (
57 58 BE_ID,
58 59 BE_MARKED,
59 60 BE_NAME,
60 61 BE_ORIG_NAME,
61 62 BE_DATE_TIME,
62 63 BE_CURRENT_PIXBUF,
63 64 BE_ACTIVE_DEFAULT,
64 65 BE_SIZE,
65 66 BE_EDITABLE
66 67 ) = range(9)
67 68
68 69 class Beadmin:
69 70 def __init__(self, parent):
70 71 self.parent = parent
71 72
72 73 if nobe:
73 74 msg = _("The <b>libbe</b> library was not "
74 75 "found on your system."
75 76 "\nAll functions for managing Boot Environments are disabled")
76 77 msgbox = gtk.MessageDialog(
77 78 buttons = gtk.BUTTONS_CLOSE,
78 79 flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_INFO,
79 80 message_format = None)
80 81 msgbox.set_markup(msg)
81 82 msgbox.set_title(_("BE management"))
82 83 msgbox.run()
83 84 msgbox.destroy()
84 85 return
85 86
86 87 self.be_list = \
87 88 gtk.ListStore(
88 89 gobject.TYPE_INT, # BE_ID
89 90 gobject.TYPE_BOOLEAN, # BE_MARKED
90 91 gobject.TYPE_STRING, # BE_NAME
|
↓ open down ↓ |
54 lines elided |
↑ open up ↑ |
91 92 gobject.TYPE_STRING, # BE_ORIG_NAME
92 93 gobject.TYPE_STRING, # BE_DATE_TIME
93 94 gtk.gdk.Pixbuf, # BE_CURRENT_PIXBUF
94 95 gobject.TYPE_BOOLEAN, # BE_ACTIVE_DEFAULT
95 96 gobject.TYPE_STRING, # BE_SIZE
96 97 gobject.TYPE_BOOLEAN, # BE_EDITABLE
97 98 )
98 99 self.progress_stop_thread = False
99 100 self.initial_active = 0
100 101 self.initial_default = 0
101 - w_tree_beadmin = gtk.glade.XML(parent.gladefile, "beadmin")
102 - w_tree_progress = gtk.glade.XML(parent.gladefile, "progressdialog")
103 - w_tree_beconfirmation = gtk.glade.XML(parent.gladefile,
102 + gladefile = os.path.join(self.parent.application_dir,
103 + "usr/share/package-manager/packagemanager.glade")
104 + w_tree_beadmin = gtk.glade.XML(gladefile, "beadmin")
105 + w_tree_progress = gtk.glade.XML(gladefile, "progressdialog")
106 + w_tree_beconfirmation = gtk.glade.XML(gladefile,
104 107 "beconfirmationdialog")
105 108 self.w_beadmin_dialog = w_tree_beadmin.get_widget("beadmin")
106 109 self.w_be_treeview = w_tree_beadmin.get_widget("betreeview")
107 110 self.w_cancel_button = w_tree_beadmin.get_widget("cancelbebutton")
108 111 self.w_ok_button = w_tree_beadmin.get_widget("okbebutton")
109 112 w_active_gtkimage = w_tree_beadmin.get_widget("activebeimage")
110 113 self.w_progress_dialog = w_tree_progress.get_widget("progressdialog")
111 114 self.w_progress_dialog.connect('delete-event', lambda stub1, stub2: True)
112 115 self.w_progressinfo_label = w_tree_progress.get_widget("progressinfo")
113 116 progress_button = w_tree_progress.get_widget("progresscancel")
114 117 self.w_progressbar = w_tree_progress.get_widget("progressbar")
115 118 self.w_beconfirmation_dialog = \
116 119 w_tree_beconfirmation.get_widget("beconfirmationdialog")
117 120 self.w_beconfirmation_textview = \
118 121 w_tree_beconfirmation.get_widget("beconfirmtext")
119 122 self.w_cancelbe_button = w_tree_beconfirmation.get_widget("cancel_be")
120 123 self.w_ok_button.set_sensitive(False)
121 124 progress_button.hide()
122 125 self.w_progressbar.set_pulse_step(0.1)
123 126 self.list_filter = self.be_list.filter_new()
124 127 self.w_be_treeview.set_model(self.list_filter)
125 128 self.__init_tree_views()
126 129 self.active_image = gui_misc.get_icon(
127 130 self.parent.icon_theme, "status_checkmark")
128 131 w_active_gtkimage.set_from_pixbuf(self.active_image)
129 132
130 133 bebuffer = self.w_beconfirmation_textview.get_buffer()
131 134 bebuffer.create_tag("bold", weight=pango.WEIGHT_BOLD)
132 135
133 136 try:
134 137 dic = \
135 138 {
136 139 "on_cancel_be_clicked": \
137 140 self.__on_cancel_be_clicked,
138 141 "on_ok_be_clicked": \
139 142 self.__on_ok_be_clicked,
140 143 "on_help_bebutton_clicked": \
141 144 self.__on_help_bebutton_clicked,
142 145 }
143 146 dic_conf = \
144 147 {
145 148 "on_cancel_be_conf_clicked": \
146 149 self.__on_cancel_be_conf_clicked,
147 150 "on_ok_be_conf_clicked": \
148 151 self.__on_ok_be_conf_clicked,
149 152 "on_beconfirmationdialog_delete_event": \
150 153 self.__on_beconfirmationdialog_delete_event,
151 154 }
152 155 w_tree_beadmin.signal_autoconnect(dic)
153 156 w_tree_beconfirmation.signal_autoconnect(dic_conf)
154 157 except AttributeError, error:
155 158 print _("GUI will not respond to any event! %s. "
156 159 "Check beadmin.py signals") \
157 160 % error
158 161 Thread(target = self.__progress_pulse).start()
159 162 Thread(target = self.__prepare_beadmin_list).start()
160 163 sel = self.w_be_treeview.get_selection()
161 164 self.w_cancel_button.grab_focus()
162 165 sel.set_mode(gtk.SELECTION_SINGLE)
163 166 self.w_beadmin_dialog.show_all()
164 167 self.w_progress_dialog.set_title(
165 168 _("Loading Boot Environment Information"))
166 169 self.w_progressinfo_label.set_text(
167 170 _("Fetching BE entries..."))
168 171 self.w_progress_dialog.show()
169 172
170 173 def __progress_pulse(self):
171 174 while not self.progress_stop_thread:
172 175 gobject.idle_add(self.w_progressbar.pulse)
173 176 time.sleep(0.1)
174 177 gobject.idle_add(self.w_progress_dialog.hide)
175 178
176 179 def __prepare_beadmin_list(self):
177 180 be_list = be.beList()
178 181 gobject.idle_add(self.__create_view_with_be, be_list)
179 182 self.progress_stop_thread = True
180 183 return
181 184
182 185 def __init_tree_views(self):
183 186 model = self.w_be_treeview.get_model()
184 187
185 188 column = gtk.TreeViewColumn()
186 189 column.set_title("")
187 190 render_pixbuf = gtk.CellRendererPixbuf()
188 191 column.pack_start(render_pixbuf, expand = True)
189 192 column.add_attribute(render_pixbuf, "pixbuf", BE_CURRENT_PIXBUF)
190 193 self.w_be_treeview.append_column(column)
191 194
192 195 name_renderer = gtk.CellRendererText()
193 196 name_renderer.connect('edited', self.__be_name_edited, model)
194 197 column = gtk.TreeViewColumn(_("Boot Environment"),
195 198 name_renderer, text = BE_NAME)
196 199 column.set_cell_data_func(name_renderer, self.__cell_data_function, None)
197 200 column.set_expand(True)
198 201 if "beVerifyBEName" in be.__dict__:
199 202 column.add_attribute(name_renderer, "editable",
200 203 BE_EDITABLE)
201 204 self.w_be_treeview.append_column(column)
202 205
203 206 datetime_renderer = gtk.CellRendererText()
204 207 datetime_renderer.set_property('xalign', 0.0)
205 208 column = gtk.TreeViewColumn(_("Created"), datetime_renderer,
206 209 text = BE_DATE_TIME)
207 210 column.set_cell_data_func(datetime_renderer,
208 211 self.__cell_data_function, None)
209 212 column.set_expand(True)
210 213 self.w_be_treeview.append_column(column)
211 214
212 215 size_renderer = gtk.CellRendererText()
213 216 size_renderer.set_property('xalign', 1.0)
214 217 column = gtk.TreeViewColumn(_("Size"), size_renderer,
215 218 text = BE_SIZE)
216 219 column.set_cell_data_func(size_renderer, self.__cell_data_function, None)
217 220 column.set_expand(False)
218 221 self.w_be_treeview.append_column(column)
219 222
220 223 radio_renderer = gtk.CellRendererToggle()
221 224 radio_renderer.connect('toggled', self.__active_pane_default, model)
222 225 column = gtk.TreeViewColumn(_("Active on Reboot"),
223 226 radio_renderer, active = BE_ACTIVE_DEFAULT)
224 227 radio_renderer.set_property("activatable", True)
225 228 radio_renderer.set_property("radio", True)
226 229 column.set_cell_data_func(radio_renderer,
227 230 self.__cell_data_default_function, None)
228 231 column.set_expand(False)
229 232 self.w_be_treeview.append_column(column)
230 233
231 234 toggle_renderer = gtk.CellRendererToggle()
232 235 toggle_renderer.connect('toggled', self.__active_pane_toggle, model)
233 236 column = gtk.TreeViewColumn(_("Delete"), toggle_renderer,
234 237 active = BE_MARKED)
235 238 toggle_renderer.set_property("activatable", True)
236 239 column.set_cell_data_func(toggle_renderer,
237 240 self.__cell_data_delete_function, None)
238 241 column.set_expand(False)
239 242 self.w_be_treeview.append_column(column)
240 243
241 244 def __on_help_bebutton_clicked(self, widget):
242 245 if self.parent != None:
243 246 gui_misc.display_help(self.parent.application_dir, "manage_be")
244 247 else:
245 248 gui_misc.display_help()
246 249
247 250 def __on_ok_be_clicked(self, widget):
248 251 self.w_progress_dialog.set_title(_("Applying changes"))
249 252 self.w_progressinfo_label.set_text(
250 253 _("Applying changes, please wait ..."))
251 254 if self.w_ok_button.get_property('sensitive') == 0:
252 255 self.progress_stop_thread = True
253 256 self.__on_beadmin_delete_event(None, None)
254 257 return
255 258 Thread(target = self.__activate).start()
256 259
257 260 def __on_cancel_be_clicked(self, widget):
258 261 self.__on_beadmin_delete_event(None, None)
259 262 return False
260 263
261 264 def __on_beconfirmationdialog_delete_event(self, widget, event):
262 265 self.__on_cancel_be_conf_clicked(widget)
263 266 return True
264 267
265 268 def __on_cancel_be_conf_clicked(self, widget):
266 269 self.w_beconfirmation_dialog.hide()
267 270
268 271 def __on_ok_be_conf_clicked(self, widget):
269 272 self.w_beconfirmation_dialog.hide()
270 273 self.progress_stop_thread = False
271 274 Thread(target = self.__on_progressdialog_progress).start()
272 275 Thread(target = self.__delete_activate_be).start()
273 276
274 277 def __on_beadmin_delete_event(self, widget, event, stub=None):
275 278 self.w_beadmin_dialog.destroy()
276 279 return True
277 280
278 281 def __activate(self):
279 282 active_text = _("Active on reboot:\n")
280 283 delete_text = _("Delete boot environments:\n")
281 284 rename_text = _("Rename boot environments:\n")
282 285 active = ""
283 286 delete = ""
284 287 rename = {}
285 288 for row in self.be_list:
286 289
287 290 if row[BE_MARKED]:
288 291 delete += row[BE_NAME] + "\n"
289 292 if row[BE_ACTIVE_DEFAULT] == True and row[BE_ID] != \
290 293 self.initial_default:
291 294 active += row[BE_NAME] + "\n"
292 295 if row[BE_NAME] != row[BE_ORIG_NAME]:
293 296 rename[row[BE_ORIG_NAME]] = row[BE_NAME]
294 297 textbuf = self.w_beconfirmation_textview.get_buffer()
295 298 textbuf.set_text("")
296 299 textiter = textbuf.get_end_iter()
297 300 if len(active) > 0:
298 301 textbuf.insert_with_tags_by_name(textiter,
299 302 active_text, "bold")
300 303 textbuf.insert_with_tags_by_name(textiter,
301 304 active)
302 305 if len(delete) > 0:
303 306 if len(active) > 0:
304 307 textbuf.insert_with_tags_by_name(textiter,
305 308 "\n")
306 309 textbuf.insert_with_tags_by_name(textiter,
307 310 delete_text, "bold")
308 311 textbuf.insert_with_tags_by_name(textiter,
309 312 delete)
310 313 if len(rename) > 0:
311 314 if len(delete) > 0 or len(active) > 0:
312 315 textbuf.insert_with_tags_by_name(textiter,
313 316 "\n")
314 317 textbuf.insert_with_tags_by_name(textiter,
315 318 rename_text, "bold")
316 319 for orig in rename:
317 320 textbuf.insert_with_tags_by_name(textiter,
318 321 orig)
319 322 textbuf.insert_with_tags_by_name(textiter,
320 323 _(" to "), "bold")
321 324 textbuf.insert_with_tags_by_name(textiter,
322 325 rename.get(orig) + "\n")
323 326 self.w_cancelbe_button.grab_focus()
324 327 gobject.idle_add(self.w_beconfirmation_dialog.show)
325 328 self.progress_stop_thread = True
326 329
327 330 def __on_progressdialog_progress(self):
328 331 # This needs to be run in gobject.idle_add, otherwise we will get
329 332 # Xlib: unexpected async reply (sequence 0x2db0)!
330 333 gobject.idle_add(self.w_progress_dialog.show)
331 334 while not self.progress_stop_thread:
332 335 gobject.idle_add(self.w_progressbar.pulse)
333 336 time.sleep(0.1)
334 337 gobject.idle_add(self.w_progress_dialog.hide)
335 338
336 339 def __delete_activate_be(self):
337 340 not_deleted = []
338 341 not_default = None
339 342 not_renamed = {}
340 343 # The while gtk.events_pending():
341 344 # gtk.main_iteration(False)
342 345 # Is not working if we are calling libbe, so it is required
343 346 # To have sleep in few places in this function
344 347 # Remove
345 348 for row in self.be_list:
346 349 if row[BE_MARKED]:
347 350 time.sleep(0.1)
348 351 result = self.__destroy_be(row[BE_NAME])
349 352 if result != 0:
350 353 not_deleted.append(row[BE_NAME])
351 354 # Rename
352 355 for row in self.be_list:
353 356 if row[BE_NAME] != row[BE_ORIG_NAME]:
354 357 time.sleep(0.1)
355 358 result = self.__rename_be(row[BE_ORIG_NAME],
356 359 row[BE_NAME])
357 360 if result !=0:
358 361 not_renamed[row[BE_ORIG_NAME]] = row[BE_NAME]
359 362 # Set active
360 363 for row in self.be_list:
361 364 if row[BE_ACTIVE_DEFAULT] == True and row[BE_ID] != \
362 365 self.initial_default:
363 366 time.sleep(0.1)
364 367 result = self.__set_default_be(row[BE_NAME])
365 368 if result != 0:
366 369 not_default = row[BE_NAME]
367 370 if len(not_deleted) == 0 and not_default == None \
368 371 and len(not_renamed) == 0:
369 372 self.progress_stop_thread = True
370 373 else:
371 374 self.progress_stop_thread = True
372 375 msg = ""
373 376 if not_default:
374 377 msg += _("<b>Couldn't change Active "
375 378 "Boot Environment to:</b>\n") + not_default
376 379 if len(not_deleted) > 0:
377 380 if not_default:
378 381 msg += "\n\n"
379 382 msg += _("<b>Couldn't delete Boot "
380 383 "Environments:</b>\n")
381 384 for row in not_deleted:
382 385 msg += row + "\n"
383 386 if len(not_renamed) > 0:
384 387 if not_default or len(not_deleted):
385 388 msg += "\n"
386 389 msg += _("<b>Couldn't rename Boot "
387 390 "Environments:</b>\n")
388 391 for orig in not_renamed:
389 392 msg += _("%s <b>to</b> %s\n") % (orig,
390 393 not_renamed.get(orig))
391 394 gobject.idle_add(self.__error_occurred, msg)
392 395 return
393 396 gobject.idle_add(self.__on_cancel_be_clicked, None)
394 397
395 398 def __rename_cell(self, model, itr, new_name):
396 399 model.set_value(itr, BE_NAME, new_name)
397 400
398 401 def __rename_be(self, orig_name, new_name):
399 402 return be.beRename(orig_name, new_name)
400 403
401 404 def __error_occurred(self, error_msg, reset=True):
402 405 gui_misc.error_occurred(self.w_beadmin_dialog,
403 406 error_msg,
404 407 _("BE error"),
405 408 gtk.MESSAGE_ERROR,
406 409 True)
407 410 if reset:
408 411 self.__on_reset_be()
409 412
410 413 def __on_reset_be(self):
411 414 self.be_list.clear()
412 415 self.w_progress_dialog.show()
413 416 self.progress_stop_thread = False
414 417 Thread(target = self.__progress_pulse).start()
415 418 Thread(target = self.__prepare_beadmin_list).start()
416 419 self.w_ok_button.set_sensitive(False)
417 420
418 421 def __active_pane_toggle(self, cell, filtered_path, filtered_model):
419 422 model = filtered_model.get_model()
420 423 path = filtered_model.convert_path_to_child_path(filtered_path)
421 424 itr = model.get_iter(path)
422 425 if itr:
423 426 modified = model.get_value(itr, BE_MARKED)
424 427 # Do not allow to set active if selected for removal
425 428 model.set_value(itr, BE_MARKED, not modified)
426 429 # Do not allow to rename if we are removing be.
427 430 model.set_value(itr, BE_EDITABLE, modified)
428 431 self.__enable_disable_ok()
429 432
430 433 def __enable_disable_ok(self):
431 434 for row in self.be_list:
432 435 if row[BE_MARKED] == True:
433 436 self.w_ok_button.set_sensitive(True)
434 437 return
435 438 if row[BE_ID] == self.initial_default:
436 439 if row[BE_ACTIVE_DEFAULT] == False:
437 440 self.w_ok_button.set_sensitive(True)
438 441 return
439 442 if row[BE_NAME] != row[BE_ORIG_NAME]:
440 443 self.w_ok_button.set_sensitive(True)
441 444 return
442 445 self.w_ok_button.set_sensitive(False)
443 446 return
444 447
445 448 def __be_name_edited(self, cell, filtered_path, new_name, filtered_model):
446 449 model = filtered_model.get_model()
447 450 path = filtered_model.convert_path_to_child_path(filtered_path)
448 451 itr = model.get_iter(path)
449 452 if itr:
450 453 if model.get_value(itr, BE_NAME) == new_name:
451 454 return
452 455 if self.__verify_be_name(new_name) != 0:
453 456 return
454 457 self.__rename_cell(model, itr, new_name)
455 458 self.__enable_disable_ok()
456 459 return
457 460
458 461 #TBD: Notify user if name clash using same logic as Repo Add and warning text
459 462 def __verify_be_name(self, new_name):
460 463 if be.beVerifyBEName(new_name) != 0:
461 464 return -1
462 465 for row in self.be_list:
463 466 if new_name == row[BE_NAME]:
464 467 return -1
465 468 return 0
466 469
467 470 def __active_pane_default(self, cell, filtered_path, filtered_model):
468 471 model = filtered_model.get_model()
469 472 path = filtered_model.convert_path_to_child_path(filtered_path)
470 473 for row in model:
471 474 row[BE_ACTIVE_DEFAULT] = False
472 475 itr = model.get_iter(path)
473 476 if itr:
474 477 modified = model.get_value(itr, BE_ACTIVE_DEFAULT)
475 478 model.set_value(itr, BE_ACTIVE_DEFAULT, not modified)
476 479 self.__enable_disable_ok()
477 480
478 481 def __create_view_with_be(self, be_list):
479 482 dates = None
480 483 i = 0
481 484 j = 0
482 485 error_code = None
483 486 be_list_loop = None
484 487 if len(be_list) > 1 and type(be_list[0]) == type(-1):
485 488 error_code = be_list[0]
486 489 if error_code != None and error_code == 0:
487 490 be_list_loop = be_list[1]
488 491 elif error_code != None and error_code != 0:
489 492 msg = _("The <b>libbe</b> library couldn't "
490 493 "prepare list of Boot Environments."
491 494 "\nAll functions for managing Boot Environments are disabled")
492 495 self.__error_occurred(msg, False)
493 496 return
494 497 else:
495 498 be_list_loop = be_list
496 499
497 500 for bee in be_list_loop:
498 501 if bee.get("orig_be_name"):
499 502 name = bee.get("orig_be_name")
500 503 active = bee.get("active")
501 504 active_boot = bee.get("active_boot")
502 505 be_size = bee.get("space_used")
503 506 be_date = bee.get("date")
504 507 converted_size = \
505 508 self.__convert_size_of_be_to_string(be_size)
506 509 active_img = None
507 510 if not be_date and j == 0:
508 511 dates = self.__get_dates_of_creation(be_list_loop)
509 512 if dates:
510 513 try:
511 514 date_time = repr(dates[i])[1:-3]
512 515 date_tmp = time.strptime(date_time, \
513 516 "%a %b %d %H:%M %Y")
514 517 date_tmp2 = \
515 518 datetime.datetime(*date_tmp[0:5])
516 519 try:
517 520 date_format = \
518 521 unicode(
519 522 _("%m/%d/%y %H:%M"),
520 523 "utf-8").encode(
521 524 locale.getpreferredencoding())
522 525 except (UnicodeError, LookupError,
523 526 locale.Error):
524 527 date_format = "%F %H:%M"
525 528 date_time = \
526 529 date_tmp2.strftime(date_format)
527 530 i += 1
528 531 except (NameError, ValueError, TypeError):
529 532 date_time = None
530 533 else:
531 534 date_tmp = time.localtime(be_date)
532 535 try:
533 536 date_format = \
534 537 unicode(
535 538 _("%m/%d/%y %H:%M"),
536 539 "utf-8").encode(
537 540 locale.getpreferredencoding())
538 541 except (UnicodeError, LookupError, locale.Error):
539 542 date_format = "%F %H:%M"
540 543 date_time = \
541 544 time.strftime(date_format, date_tmp)
542 545 if active:
543 546 active_img = self.active_image
544 547 self.initial_active = j
545 548 if active_boot:
546 549 self.initial_default = j
547 550 if date_time != None:
548 551 try:
549 552 date_time = unicode(date_time,
550 553 locale.getpreferredencoding()).encode(
551 554 "utf-8")
552 555 except (UnicodeError, LookupError, locale.Error):
553 556 pass
554 557 self.be_list.insert(j, [j, False,
555 558 name, name,
556 559 date_time, active_img,
557 560 active_boot, converted_size, active_img == None])
558 561 j += 1
559 562 self.w_be_treeview.set_cursor(self.initial_active, None,
560 563 start_editing=True)
561 564 self.w_be_treeview.scroll_to_cell(self.initial_active)
562 565
563 566 def __destroy_be(self, be_name):
564 567 return be.beDestroy(be_name, 1, True)
565 568
566 569 def __set_default_be(self, be_name):
567 570 return be.beActivate(be_name)
568 571
569 572 def __cell_data_default_function(self, column, renderer, model, itr, data):
570 573 if itr:
571 574 if model.get_value(itr, BE_MARKED):
572 575 self.__set_renderer_active(renderer, False)
573 576 else:
574 577 self.__set_renderer_active(renderer, True)
575 578
576 579 def __cell_data_delete_function(self, column, renderer, model, itr, data):
577 580 if itr:
578 581 if model.get_value(itr, BE_ACTIVE_DEFAULT) or \
579 582 (self.initial_active == model.get_value(itr, BE_ID)) or \
580 583 (model.get_value(itr, BE_NAME) !=
581 584 model.get_value(itr, BE_ORIG_NAME)):
582 585 self.__set_renderer_active(renderer, False)
583 586 else:
584 587 self.__set_renderer_active(renderer, True)
585 588
586 589 @staticmethod
587 590 def __set_renderer_active(renderer, active):
588 591 if active:
589 592 renderer.set_property("sensitive", True)
590 593 renderer.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE)
591 594 else:
592 595 renderer.set_property("sensitive", False)
593 596 renderer.set_property("mode", gtk.CELL_RENDERER_MODE_INERT)
594 597
595 598 @staticmethod
596 599 def __get_dates_of_creation(be_list):
597 600 #zfs list -H -o creation rpool/ROOT/opensolaris-1
598 601 cmd = [ "/sbin/zfs", "list", "-H", "-o","creation" ]
599 602 for bee in be_list:
600 603 if bee.get("orig_be_name"):
601 604 name = bee.get("orig_be_name")
602 605 pool = bee.get("orig_be_pool")
603 606 cmd += [pool+"/ROOT/"+name]
604 607 if len(cmd) <= 5:
605 608 return None
606 609 list_of_dates = []
607 610 try:
608 611 proc = subprocess.Popen(cmd, stdout = subprocess.PIPE,
609 612 stderr = subprocess.PIPE,)
610 613 line_out = proc.stdout.readline()
611 614 while line_out:
612 615 list_of_dates.append(line_out)
613 616 line_out = proc.stdout.readline()
614 617 except OSError:
615 618 return list_of_dates
616 619 return list_of_dates
617 620
618 621 @staticmethod
619 622 def __convert_size_of_be_to_string(be_size):
620 623 if not be_size:
621 624 be_size = 0
622 625 return pkg.misc.bytes_to_str(be_size)
623 626
624 627 @staticmethod
625 628 def __cell_data_function(column, renderer, model, itr, data):
626 629 if itr:
627 630 if model.get_value(itr, BE_CURRENT_PIXBUF):
628 631 renderer.set_property("weight", pango.WEIGHT_BOLD)
629 632 else:
630 633 renderer.set_property("weight", pango.WEIGHT_NORMAL)
|
↓ open down ↓ |
517 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX