zeroinstall/0launch-gui/properties.py

   1 import zeroinstall
   2 from zeroinstall.support import tasks
   3 from zeroinstall.injector.model import *
   4 from zeroinstall.injector.iface_cache import iface_cache
   5 from zeroinstall.injector import writer, namespaces, gpg
   6
   7 import gtk, sys, os
   8 from logging import warn
   9
  10 import help_box
  11 from dialog import DialogResponse, Template
  12 from impl_list import ImplementationList
  13 import time
  14 import dialog
  15 import compile
  16
  17 _dialogs = {}   # Interface -> Properties
  18
  19 tips = gtk.Tooltips()
  20
  21 # Response codes
  22 COMPILE = 2
  23
  24 def enumerate(items):
  25         x = 0
  26         for i in items:
  27                 yield x, i
  28                 x += 1
  29
  30 def format_para(para):
  31         lines = [l.strip() for l in para.split('\n')]
  32         return ' '.join(lines)
  33
  34 def have_source_for(policy, interface):
  35         # Note: we don't want to actually fetch the source interfaces at
  36         # this point, so we check whether:
  37         # - We have a feed of type 'src' (not fetched), or
  38         # - We have a source implementation in a regular feed
  39         have_src = False
  40         for f in interface.feeds:
  41                 if f.machine == 'src':
  42                         return True
  43         # Don't have any src feeds. Do we have a source implementation
  44         # as part of a regular feed?
  45         impls = interface.implementations.values()
  46         for f in policy.usable_feeds(interface):
  47                 try:
  48                         feed_iface = iface_cache.get_interface(f.uri)
  49                         if feed_iface.implementations:
  50                                 impls.extend(feed_iface.implementations.values())
  51                 except zeroinstall.NeedDownload:
  52                         pass    # OK, will get called again later
  53                 except Exception, ex:
  54                         warn("Failed to load feed '%s': %s", f.uri, str(ex))
  55         for x in impls:
  56                 if x.machine == 'src':
  57                         return True
  58         return False
  59
  60 class Description:
  61         def __init__(self, widgets):
  62                 description = widgets.get_widget('description')
  63                 description.connect('button-press-event', self.button_press)
  64
  65                 self.buffer = description.get_buffer()
  66                 self.heading_style = self.buffer.create_tag(underline = True, scale = 1.2)
  67                 self.link_style = self.buffer.create_tag(underline = True, foreground = 'blue')
  68                 description.set_size_request(-1, 100)
  69
  70         def button_press(self, tv, bev):
  71                 if bev.type == gtk.gdk.BUTTON_PRESS and bev.button == 1:
  72                         x, y = tv.window_to_buffer_coords(tv.get_window_type(bev.window),
  73                                                           int(bev.x), int(bev.y))
  74                         itr = tv.get_iter_at_location(x, y)
  75                         if itr and self.link_style in itr.get_tags():
  76                                 if not itr.begins_tag(self.link_style):
  77                                         itr.backward_to_tag_toggle(self.link_style)
  78                                 end = itr.copy()
  79                                 end.forward_to_tag_toggle(self.link_style)
  80                                 target = itr.get_text(end).strip()
  81                                 import browser
  82                                 browser.open_in_browser(target)
  83
  84         def set_details(self, interface):
  85                 buffer = self.buffer
  86                 heading_style = self.heading_style
  87
  88                 buffer.delete(buffer.get_start_iter(), buffer.get_end_iter())
  89
  90                 iter = buffer.get_start_iter()
  91
  92                 buffer.insert_with_tags(iter,
  93                         '%s ' % interface.get_name(), heading_style)
  94                 buffer.insert(iter, '(%s)' % interface.summary)
  95
  96                 buffer.insert(iter, '\n%s\n' % interface.uri)
  97
  98                 # (converts to local time)
  99                 if interface.last_modified:
 100                         buffer.insert(iter, '\nLast upstream change: %s' % time.ctime(interface.last_modified))
 101
 102                 if interface.last_checked:
 103                         buffer.insert(iter, '\nLast checked: %s' % time.ctime(interface.last_checked))
 104
 105                 last_check_attempt = iface_cache.get_last_check_attempt(interface.uri)
 106                 if last_check_attempt:
 107                         if interface.last_checked and interface.last_checked >= last_check_attempt:
 108                                 pass    # Don't bother reporting successful attempts
 109                         else:
 110                                 buffer.insert(iter, '\nLast check attempt: %s (failed or in progress)' %
 111                                                 time.ctime(last_check_attempt))
 112
 113                 buffer.insert_with_tags(iter, '\n\nDescription\n', heading_style)
 114
 115                 paragraphs = [format_para(p) for p in (interface.description or "-").split('\n\n')]
 116
 117                 buffer.insert(iter, '\n\n'.join(paragraphs))
 118                 buffer.insert(iter, '\n')
 119
 120                 need_gap = True
 121                 for x in interface.get_metadata(namespaces.XMLNS_IFACE, 'homepage'):
 122                         if need_gap:
 123                                 buffer.insert(iter, '\n')
 124                                 need_gap = False
 125                         buffer.insert(iter, 'Homepage: ')
 126                         buffer.insert_with_tags(iter, '%s\n' % x.content, self.link_style)
 127
 128                 buffer.insert_with_tags(iter, '\nSignatures\n', heading_style)
 129                 sigs = iface_cache.get_cached_signatures(interface.uri)
 130                 if sigs:
 131                         for sig in sigs:
 132                                 if isinstance(sig, gpg.ValidSig):
 133                                         name = '<unknown>'
 134                                         details = sig.get_details()
 135                                         for item in details:
 136                                                 if item[0] in ('pub', 'uid') and len(item) > 9:
 137                                                         name = item[9]
 138                                                         break
 139                                         buffer.insert_with_tags(iter, 'Valid signature by "%s"\n- Dated: %s\n- Fingerprint: %s\n' %
 140                                                         (name, time.ctime(sig.get_timestamp()), sig.fingerprint))
 141                                         if not sig.is_trusted():
 142                                                 if interface.uri.startswith('/'):
 143                                                         buffer.insert_with_tags(iter, 'WARNING: This key is not in the trusted list\n')
 144                                                 else:
 145                                                         buffer.insert_with_tags(iter, 'WARNING: This key is not in the trusted list (either you removed it, or '
 146                                                                                         'you trust one of the other signatures)\n')
 147                                 else:
 148                                         buffer.insert_with_tags(iter, '%s\n' % sig)
 149                 else:
 150                         buffer.insert_with_tags(iter, 'No signature information (old style interface or out-of-date cache)\n')
 151
 152 class Feeds:
 153         URI = 0
 154         ARCH = 1
 155         USED = 2
 156
 157         def __init__(self, policy, interface, widgets):
 158                 self.policy = policy
 159                 self.interface = interface
 160
 161                 self.model = gtk.ListStore(str, str, bool)
 162
 163                 self.description = Description(widgets)
 164
 165                 self.lines = self.build_model()
 166                 for line in self.lines:
 167                         self.model.append(line)
 168
 169                 add_remote_feed_button = widgets.get_widget('add_remote_feed')
 170                 add_remote_feed_button.connect('clicked', lambda b: add_remote_feed(policy, widgets.get_widget(), interface))
 171
 172                 add_local_feed_button = widgets.get_widget('add_local_feed')
 173                 add_local_feed_button.connect('clicked', lambda b: add_local_feed(policy, interface))
 174
 175                 self.remove_feed_button = widgets.get_widget('remove_feed')
 176                 def remove_feed(button):
 177                         model, iter = self.tv.get_selection().get_selected()
 178                         feed_uri = model[iter][Feeds.URI]
 179                         for x in interface.feeds:
 180                                 if x.uri == feed_uri:
 181                                         if x.user_override:
 182                                                 interface.extra_feeds.remove(x)
 183                                                 writer.save_interface(interface)
 184                                                 policy.recalculate()
 185                                                 return
 186                                         else:
 187                                                 dialog.alert(self.get_toplevel(),
 188                                                         _("Can't remove '%s' as you didn't add it.") % feed_uri)
 189                                                 return
 190                         raise Exception("Missing feed '%s'!" % feed_uri)
 191                 self.remove_feed_button.connect('clicked', remove_feed)
 192
 193                 self.tv = widgets.get_widget('feeds_list')
 194                 self.tv.set_model(self.model)
 195                 text = gtk.CellRendererText()
 196                 self.tv.append_column(gtk.TreeViewColumn('Source', text, text = Feeds.URI, sensitive = Feeds.USED))
 197                 self.tv.append_column(gtk.TreeViewColumn('Arch', text, text = Feeds.ARCH, sensitive = Feeds.USED))
 198
 199                 sel = self.tv.get_selection()
 200                 sel.set_mode(gtk.SELECTION_BROWSE)
 201                 sel.connect('changed', self.sel_changed)
 202                 sel.select_path((0,))
 203
 204         def build_model(self):
 205                 usable_feeds = frozenset(self.policy.usable_feeds(self.interface))
 206                 unusable_feeds = frozenset(self.interface.feeds) - usable_feeds
 207
 208                 out = [[self.interface.uri, None, True]]
 209
 210                 if self.interface.feeds:
 211                         for feed in usable_feeds:
 212                                 out.append([feed.uri, feed.arch, True])
 213                         for feed in unusable_feeds:
 214                                 out.append([feed.uri, feed.arch, False])
 215                 return out
 216
 217         def sel_changed(self, sel):
 218                 model, miter = sel.get_selected()
 219                 if not miter: return    # build in progress
 220                 iface = model[miter][Feeds.URI]
 221                 # Only enable removing user_override feeds
 222                 enable_remove = False
 223                 for x in self.interface.feeds:
 224                         if x.uri == iface:
 225                                 if x.user_override:
 226                                         enable_remove = True
 227                 self.remove_feed_button.set_sensitive( enable_remove )
 228                 self.description.set_details(iface_cache.get_interface(iface))
 229
 230         def updated(self):
 231                 new_lines = self.build_model()
 232                 if new_lines != self.lines:
 233                         self.lines = new_lines
 234                         self.model.clear()
 235                         for line in self.lines:
 236                                 self.model.append(line)
 237                         self.tv.get_selection().select_path((0,))
 238                 else:
 239                         self.sel_changed(self.tv.get_selection())
 240
 241 class Properties:
 242         interface = None
 243         use_list = None
 244         window = None
 245         policy = None
 246
 247         def __init__(self, policy, interface, show_versions = False):
 248                 self.policy = policy
 249
 250                 widgets = Template('interface_properties')
 251
 252                 self.interface = interface
 253
 254                 window = widgets.get_widget('interface_properties')
 255                 self.window = window
 256                 window.set_title('Properties for ' + interface.get_name())
 257                 window.set_default_size(-1, gtk.gdk.screen_height() / 3)
 258
 259                 self.compile_button = widgets.get_widget('compile')
 260                 self.compile_button.connect('clicked', lambda b: compile.compile(policy, interface))
 261                 window.set_default_response(gtk.RESPONSE_CANCEL)
 262
 263                 def response(dialog, resp):
 264                         if resp == gtk.RESPONSE_CANCEL:
 265                                 window.destroy()
 266                         elif resp == gtk.RESPONSE_HELP:
 267                                 properties_help.display()
 268                 window.connect('response', response)
 269
 270                 notebook = widgets.get_widget('interface_notebook')
 271                 assert notebook
 272
 273                 feeds = Feeds(policy, interface, widgets)
 274
 275                 stability = widgets.get_widget('preferred_stability')
 276                 stability.set_active(0)
 277                 if interface.stability_policy:
 278                         i = [stable, testing, developer].index(interface.stability_policy)
 279                         if i == -1:
 280                                 warn("Unknown stability policy %s", interface.stability_policy)
 281                                 i = 0
 282                 else:
 283                         i = 0
 284                 stability.set_active(i)
 285
 286                 def set_stability_policy(combo):
 287                         i = stability.get_active()
 288                         if i == 0:
 289                                 new_stability = None
 290                         else:
 291                                 name = stability.get_model()[i][0].lower()
 292                                 new_stability = stability_levels[name]
 293                         interface.set_stability_policy(new_stability)
 294                         writer.save_interface(interface)
 295                         policy.recalculate()
 296                 stability.connect('changed', set_stability_policy)
 297
 298                 self.use_list = ImplementationList(policy, interface, widgets)
 299
 300                 self.update_list()
 301
 302                 feeds.tv.grab_focus()
 303
 304                 def updated():
 305                         self.update_list()
 306                         feeds.updated()
 307                         self.shade_compile()
 308                 window.connect('destroy', lambda s: policy.watchers.remove(updated))
 309                 policy.watchers.append(updated)
 310                 self.shade_compile()
 311
 312                 if show_versions:
 313                         notebook.next_page()
 314
 315         def destroy(self):
 316                 self.window.destroy()
 317
 318         def shade_compile(self):
 319                 self.compile_button.set_sensitive(have_source_for(self.policy, self.interface))
 320
 321         def update_list(self):
 322                 ranked_items = self.policy.solver.details.get(self.interface, None)
 323                 if ranked_items is None:
 324                         # The Solver didn't get this far, but we should still display them!
 325                         ranked_items = self.interface.implementations.values()
 326                         ranked_items.sort()
 327                 self.use_list.set_items(ranked_items)
 328
 329 @tasks.async
 330 def add_remote_feed(policy, parent, interface):
 331         try:
 332                 d = gtk.MessageDialog(parent, 0, gtk.MESSAGE_QUESTION, gtk.BUTTONS_CANCEL,
 333                         _('Enter the URL of the new source of implementations of this interface:'))
 334                 d.add_button(gtk.STOCK_ADD, gtk.RESPONSE_OK)
 335                 d.set_default_response(gtk.RESPONSE_OK)
 336                 entry = gtk.Entry()
 337
 338                 align = gtk.VBox(False, 0)
 339                 align.set_border_width(4)
 340                 align.add(entry)
 341                 d.vbox.pack_start(align)
 342                 entry.set_activates_default(True)
 343
 344                 entry.set_text('')
 345
 346                 d.vbox.show_all()
 347
 348                 error_label = gtk.Label('')
 349                 error_label.set_padding(4, 4)
 350                 align.pack_start(error_label)
 351
 352                 d.show()
 353
 354                 def error(message):
 355                         if message:
 356                                 error_label.set_text(message)
 357                                 error_label.show()
 358                         else:
 359                                 error_label.hide()
 360
 361                 while True:
 362                         got_response = DialogResponse(d)
 363                         yield got_response
 364                         tasks.check(got_response)
 365                         resp = got_response.response
 366
 367                         error(None)
 368                         if resp == gtk.RESPONSE_OK:
 369                                 try:
 370                                         url = entry.get_text()
 371                                         if not url:
 372                                                 raise SafeException(_('Enter a URL'))
 373                                         fetch = policy.fetcher.download_and_import_feed(url, iface_cache)
 374                                         if fetch:
 375                                                 d.set_sensitive(False)
 376                                                 yield fetch
 377                                                 d.set_sensitive(True)
 378                                                 tasks.check(fetch)
 379
 380                                                 iface = iface_cache.get_interface(url)
 381
 382                                                 d.set_sensitive(True)
 383                                                 if not iface.name:
 384                                                         error('Failed to read interface')
 385                                                         return
 386                                                 if not iface.feed_for:
 387                                                         error("Feed '%s' is not a feed for '%s'." % (iface.get_name(), interface.get_name()))
 388                                                 elif interface.uri not in iface.feed_for:
 389                                                         error("This is not a feed for '%s'.\nOnly for:\n%s" %
 390                                                                 (interface.uri, '\n'.join(iface.feed_for)))
 391                                                 elif iface.uri in [f.uri for f in interface.feeds]:
 392                                                         error("Feed from '%s' has already been added!" % iface.uri)
 393                                                 else:
 394                                                         interface.extra_feeds.append(Feed(iface.uri, arch = None, user_override = True))
 395                                                         writer.save_interface(interface)
 396                                                         d.destroy()
 397                                                         policy.recalculate()
 398                                 except SafeException, ex:
 399                                         error(str(ex))
 400                         else:
 401                                 d.destroy()
 402                                 return
 403         except Exception, ex:
 404                 import traceback
 405                 traceback.print_exc()
 406                 policy.handler.report_error(ex)
 407
 408 def add_local_feed(policy, interface):
 409         sel = gtk.FileSelection(_('Select XML feed file'))
 410         sel.set_has_separator(False)
 411         def ok(b):
 412                 from xml.dom import minidom
 413                 from zeroinstall.injector import reader
 414                 feed = sel.get_filename()
 415                 try:
 416                         feed_targets = policy.get_feed_targets(feed)
 417                         if interface not in feed_targets:
 418                                 raise Exception("Not a valid feed for '%s'; this is a feed for:\n%s" %
 419                                                 (interface.uri,
 420                                                 '\n'.join([f.uri for f in feed_targets])))
 421                         if interface.get_feed(feed):
 422                                 dialog.alert(None, 'This feed is already registered.')
 423                         else:
 424                                 interface.extra_feeds.append(Feed(feed, user_override = True, arch = None))
 425
 426                         writer.save_interface(interface)
 427                         sel.destroy()
 428                         reader.update_from_cache(interface)
 429                         policy.recalculate()
 430                 except Exception, ex:
 431                         dialog.alert(None, "Error in feed file '%s':\n\n%s" % (feed, str(ex)))
 432
 433         sel.ok_button.connect('clicked', ok)
 434         sel.cancel_button.connect('clicked', lambda b: sel.destroy())
 435         sel.show()
 436
 437 def edit(policy, interface, show_versions = False):
 438         assert isinstance(interface, Interface)
 439         if interface in _dialogs:
 440                 _dialogs[interface].destroy()
 441         _dialogs[interface] = Properties(policy, interface, show_versions)
 442
 443 properties_help = help_box.HelpBox("Injector Properties Help",
 444 ('Interface properties', """
 445 This window displays information about an interface. There are two tabs at the top: \
 446 Feeds shows the places where the injector looks for implementations of the interface, while \
 447 Versions shows the list of implementations found (from all feeds) in order of preference."""),
 448
 449 ('The Feeds tab', """
 450 At the top is a list of feeds. By default, the injector uses the full name of the interface \
 451 as the default feed location (so if you ask it to run the program "http://foo/bar.xml" then it will \
 452 by default get the list of versions by downloading "http://foo/bar.xml".
 453
 454 You can add and remove feeds using the buttons on the right. The main feed may also add \
 455 some extra feeds itself. If you've checked out a developer version of a program, you can use \
 456 the 'Add Local Feed...' button to let the injector know about it, for example.
 457
 458 Below the list of feeds is a box describing the selected one:
 459
 460 - At the top is its short name.
 461 - Below that is the address (a URL or filename).
 462 - 'Last upstream change' shows the version of the cached copy of the interface file.
 463 - 'Last checked' is the last time a fresh copy of the upstream interface file was \
 464 downloaded.
 465 - Then there is a longer description of the interface."""),
 466
 467 ('The Versions tab', """
 468 This tab shows a list of all known implementations of the interface, from all the feeds. \
 469 The columns have the following meanings:
 470
 471 Version gives the version number. High-numbered versions are considered to be \
 472 better than low-numbered ones.
 473
 474 Released gives the date this entry was added to the feed.
 475
 476 Stability is 'stable' if the implementation is believed to be stable, 'buggy' if \
 477 it is known to contain serious bugs, and 'testing' if its stability is not yet \
 478 known. This information is normally supplied and updated by the author of the \
 479 software, but you can override their rating (overridden values are shown in upper-case). \
 480 You can also use the special level 'preferred'.
 481
 482 C(ached) indicates whether the implementation is already stored on your computer. \
 483 In off-line mode, only cached implementations are considered for use.
 484
 485 Arch indicates what kind of computer system the implementation is for, or 'any' \
 486 if it works with all types of system.
 487 """),
 488 ('Sort order', """
 489 The implementations are listed in the injector's currently preferred order (the one \
 490 at the top will actually be used). Usable implementations all come before unusable \
 491 ones.
 492
 493 Unusable ones are those for incompatible \
 494 architectures, those marked as 'buggy', versions explicitly marked as incompatible with \
 495 another interface you are using and, in off-line mode, uncached implementations. Unusable \
 496 implementations are shown crossed out.
 497
 498 For the usable implementations, the order is as follows:
 499
 500 - Preferred implementations come first.
 501
 502 - Then, if network use is set to 'Minimal', cached implementations come before \
 503 non-cached.
 504
 505 - Then, implementations at or above the selected stability level come before all others.
 506
 507 - Then, higher-numbered versions come before low-numbered ones.
 508
 509 - Then cached come before non-cached (for 'Full' network use mode).
 510 """),
 511
 512 ('Compiling', """
 513 If there is no binary available for your system then you may be able to compile one from \
 514 source by clicking on the Compile button. If no source is available, the Compile button will \
 515 be shown shaded.
 516 """))