zeroinstall.injector.model

1 """In-memory representation of interfaces and other data structures. 2 3 The objects in this module are used to build a representation of an XML interface 4 file in memory. 5 6 @see: L{reader} constructs these data-structures 7 @see: U{http://0install.net/interface-spec.html} description of the domain model 8 9 @var defaults: Default values for the 'default' attribute for <environment> bindings of 10 well-known variables. 11 """ 12 13 # Copyright (C) 2009, Thomas Leonard 14 # See the README file for details, or visit http://0install.net. 15 16 from zeroinstall import _ 17 import os, re, locale 18 from logging import info, debug, warn 19 from zeroinstall import SafeException, version 20 from zeroinstall.injector.namespaces import XMLNS_IFACE 21 from zeroinstall.injector import qdom 22 23 # Element names for bindings in feed files 24 binding_names = frozenset(['environment', 'overlay', 'executable-in-path', 'executable-in-var']) 25 26 network_offline = 'off-line' 27 network_minimal = 'minimal' 28 network_full = 'full' 29 network_levels = (network_offline, network_minimal, network_full) 30 31 stability_levels = {} # Name -> Stability 32 33 defaults = { 34 'PATH': '/bin:/usr/bin', 35 'XDG_CONFIG_DIRS': '/etc/xdg', 36 'XDG_DATA_DIRS': '/usr/local/share:/usr/share', 37 }

38 39 -class InvalidInterface(SafeException):

40 """Raised when parsing an invalid feed.""" 41 feed_url = None 42

43 - def __init__(self, message, ex = None):

44 if ex: 45 try: 46 message += "\n\n(exact error: %s)" % ex 47 except: 48 # Some Python messages have type str but contain UTF-8 sequences. 49 # (e.g. IOException). Adding these to a Unicode 'message' (e.g. 50 # after gettext translation) will cause an error. 51 import codecs 52 decoder = codecs.lookup('utf-8') 53 decex = decoder.decode(str(ex), errors = 'replace')[0] 54 message += "\n\n(exact error: %s)" % decex 55 56 SafeException.__init__(self, message)

57

58 - def __unicode__(self):

59 if hasattr(SafeException, '__unicode__'): 60 # Python >= 2.6 61 if self.feed_url: 62 return _('%s [%s]') % (SafeException.__unicode__(self), self.feed_url) 63 return SafeException.__unicode__(self) 64 else: 65 return unicode(SafeException.__str__(self))

66

67 -def _split_arch(arch):

68 """Split an arch into an (os, machine) tuple. Either or both parts may be None.""" 69 if not arch: 70 return None, None 71 elif '-' not in arch: 72 raise SafeException(_("Malformed arch '%s'") % arch) 73 else: 74 osys, machine = arch.split('-', 1) 75 if osys == '*': osys = None 76 if machine == '*': machine = None 77 return osys, machine

78

79 -def _join_arch(osys, machine):

80 if osys == machine == None: return None 81 return "%s-%s" % (osys or '*', machine or '*')

82

83 -def _best_language_match(options):

84 (language, encoding) = locale.getlocale() 85 86 if language: 87 # xml:lang uses '-', while LANG uses '_' 88 language = language.replace('_', '-') 89 else: 90 language = 'en-US' 91 92 return (options.get(language, None) or # Exact match (language+region) 93 options.get(language.split('-', 1)[0], None) or # Matching language 94 options.get('en', None)) # English

95

96 -class Stability(object):

97 """A stability rating. Each implementation has an upstream stability rating and, 98 optionally, a user-set rating.""" 99 __slots__ = ['level', 'name', 'description']

100 - def __init__(self, level, name, description):

101 self.level = level 102 self.name = name 103 self.description = description 104 assert name not in stability_levels 105 stability_levels[name] = self

106

107 - def __cmp__(self, other):

108 return cmp(self.level, other.level)

109

110 - def __str__(self):

111 return self.name

112

113 - def __repr__(self):

114 return _("<Stability: %s>") % self.description

115

116 -def process_binding(e):

117 """Internal""" 118 if e.name == 'environment': 119 mode = { 120 None: EnvironmentBinding.PREPEND, 121 'prepend': EnvironmentBinding.PREPEND, 122 'append': EnvironmentBinding.APPEND, 123 'replace': EnvironmentBinding.REPLACE, 124 }[e.getAttribute('mode')] 125 126 binding = EnvironmentBinding(e.getAttribute('name'), 127 insert = e.getAttribute('insert'), 128 default = e.getAttribute('default'), 129 value = e.getAttribute('value'), 130 mode = mode, 131 separator = e.getAttribute('separator')) 132 if not binding.name: raise InvalidInterface(_("Missing 'name' in binding")) 133 if binding.insert is None and binding.value is None: 134 raise InvalidInterface(_("Missing 'insert' or 'value' in binding")) 135 if binding.insert is not None and binding.value is not None: 136 raise InvalidInterface(_("Binding contains both 'insert' and 'value'")) 137 return binding 138 elif e.name == 'executable-in-path': 139 return ExecutableBinding(e, in_path = True) 140 elif e.name == 'executable-in-var': 141 return ExecutableBinding(e, in_path = False) 142 elif e.name == 'overlay': 143 return OverlayBinding(e.getAttribute('src'), e.getAttribute('mount-point')) 144 else: 145 raise Exception(_("Unknown binding type '%s'") % e.name)

146

147 -def process_depends(item, local_feed_dir):

148 """Internal""" 149 # Note: also called from selections 150 attrs = item.attrs 151 dep_iface = item.getAttribute('interface') 152 if not dep_iface: 153 raise InvalidInterface(_("Missing 'interface' on <%s>") % item.name) 154 if dep_iface.startswith('./'): 155 if local_feed_dir: 156 dep_iface = os.path.abspath(os.path.join(local_feed_dir, dep_iface)) 157 # (updates the element too, in case we write it out again) 158 attrs['interface'] = dep_iface 159 else: 160 raise InvalidInterface(_('Relative interface URI "%s" in non-local feed') % dep_iface) 161 dependency = InterfaceDependency(dep_iface, element = item) 162 163 for e in item.childNodes: 164 if e.uri != XMLNS_IFACE: continue 165 if e.name in binding_names: 166 dependency.bindings.append(process_binding(e)) 167 elif e.name == 'version': 168 dependency.restrictions.append( 169 VersionRangeRestriction(not_before = parse_version(e.getAttribute('not-before')), 170 before = parse_version(e.getAttribute('before')))) 171 return dependency

172

173 -def N_(message): return message

174 175 insecure = Stability(0, N_('insecure'), _('This is a security risk')) 176 buggy = Stability(5, N_('buggy'), _('Known to have serious bugs')) 177 developer = Stability(10, N_('developer'), _('Work-in-progress - bugs likely')) 178 testing = Stability(20, N_('testing'), _('Stability unknown - please test!')) 179 stable = Stability(30, N_('stable'), _('Tested - no serious problems found')) 180 packaged = Stability(35, N_('packaged'), _('Supplied by the local package manager')) 181 preferred = Stability(40, N_('preferred'), _('Best of all - must be set manually')) 182 183 del N_

184 185 -class Restriction(object):

186 """A Restriction limits the allowed implementations of an Interface.""" 187 __slots__ = [] 188

189 - def meets_restriction(self, impl):

190 """Called by the L{solver.Solver} to check whether a particular implementation is acceptable. 191 @return: False if this implementation is not a possibility 192 @rtype: bool 193 """ 194 raise NotImplementedError(_("Abstract"))

195

196 -class VersionRestriction(Restriction):

197 """Only select implementations with a particular version number. 198 @since: 0.40""" 199

200 - def __init__(self, version):

201 """@param version: the required version number 202 @see: L{parse_version}; use this to pre-process the version number 203 """ 204 self.version = version

205

206 - def meets_restriction(self, impl):

207 return impl.version == self.version

208

209 - def __str__(self):

210 return _("(restriction: version = %s)") % format_version(self.version)

211

212 -class VersionRangeRestriction(Restriction):

213 """Only versions within the given range are acceptable""" 214 __slots__ = ['before', 'not_before'] 215

216 - def __init__(self, before, not_before):

217 """@param before: chosen versions must be earlier than this 218 @param not_before: versions must be at least this high 219 @see: L{parse_version}; use this to pre-process the versions 220 """ 221 self.before = before 222 self.not_before = not_before

223

224 - def meets_restriction(self, impl):

225 if self.not_before and impl.version < self.not_before: 226 return False 227 if self.before and impl.version >= self.before: 228 return False 229 return True

230

231 - def __str__(self):

232 if self.not_before is not None or self.before is not None: 233 range = '' 234 if self.not_before is not None: 235 range += format_version(self.not_before) + ' <= ' 236 range += 'version' 237 if self.before is not None: 238 range += ' < ' + format_version(self.before) 239 else: 240 range = 'none' 241 return _("(restriction: %s)") % range

242

243 -class Binding(object):

244 """Information about how the choice of a Dependency is made known 245 to the application being run.""" 246 247 @property

248 - def command(self):

249 """"Returns the name of the specific command needed by this binding, if any. 250 @since: 1.2""" 251 return None

252

253 -class EnvironmentBinding(Binding):

254 """Indicate the chosen implementation using an environment variable.""" 255 __slots__ = ['name', 'insert', 'default', 'mode', 'value'] 256 257 PREPEND = 'prepend' 258 APPEND = 'append' 259 REPLACE = 'replace' 260

261 - def __init__(self, name, insert, default = None, mode = PREPEND, value=None, separator=None):

262 """ 263 mode argument added in version 0.28 264 value argument added in version 0.52 265 """ 266 self.name = name 267 self.insert = insert 268 self.default = default 269 self.mode = mode 270 self.value = value 271 if separator is None: 272 self.separator = os.pathsep 273 else: 274 self.separator = separator

275 276

277 - def __str__(self):

278 return _("<environ %(name)s %(mode)s %(insert)s %(value)s>") % \ 279 {'name': self.name, 'mode': self.mode, 'insert': self.insert, 'value': self.value}

280 281 __repr__ = __str__ 282

283 - def get_value(self, path, old_value):

284 """Calculate the new value of the environment variable after applying this binding. 285 @param path: the path to the selected implementation 286 @param old_value: the current value of the environment variable 287 @return: the new value for the environment variable""" 288 289 if self.insert is not None: 290 extra = os.path.join(path, self.insert) 291 else: 292 assert self.value is not None 293 extra = self.value 294 295 if self.mode == EnvironmentBinding.REPLACE: 296 return extra 297 298 if old_value is None: 299 old_value = self.default or defaults.get(self.name, None) 300 if old_value is None: 301 return extra 302 if self.mode == EnvironmentBinding.PREPEND: 303 return extra + self.separator + old_value 304 else: 305 return old_value + self.separator + extra

306

307 - def _toxml(self, doc, prefixes):

308 """Create a DOM element for this binding. 309 @param doc: document to use to create the element 310 @return: the new element 311 """ 312 env_elem = doc.createElementNS(XMLNS_IFACE, 'environment') 313 env_elem.setAttributeNS(None, 'name', self.name) 314 if self.mode is not None: 315 env_elem.setAttributeNS(None, 'mode', self.mode) 316 if self.insert is not None: 317 env_elem.setAttributeNS(None, 'insert', self.insert) 318 else: 319 env_elem.setAttributeNS(None, 'value', self.value) 320 if self.default: 321 env_elem.setAttributeNS(None, 'default', self.default) 322 if self.separator: 323 env_elem.setAttributeNS(None, 'separator', self.separator) 324 return env_elem

325

326 -class ExecutableBinding(Binding):

327 """Make the chosen command available in $PATH. 328 @ivar in_path: True to add the named command to $PATH, False to store in named variable 329 @type in_path: bool 330 """ 331 __slots__ = ['qdom'] 332

333 - def __init__(self, qdom, in_path):

334 self.qdom = qdom 335 self.in_path = in_path

336

337 - def __str__(self):

338 return str(self.qdom)

339 340 __repr__ = __str__ 341

342 - def _toxml(self, doc, prefixes):

343 return self.qdom.toDOM(doc, prefixes)

344 345 @property

346 - def name(self):

347 return self.qdom.getAttribute('name')

348 349 @property

350 - def command(self):

351 return self.qdom.getAttribute("command") or 'run'

352

353 -class OverlayBinding(Binding):

354 """Make the chosen implementation available by overlaying it onto another part of the file-system. 355 This is to support legacy programs which use hard-coded paths.""" 356 __slots__ = ['src', 'mount_point'] 357

358 - def __init__(self, src, mount_point):

359 self.src = src 360 self.mount_point = mount_point

361

362 - def __str__(self):

363 return _("<overlay %(src)s on %(mount_point)s>") % {'src': self.src or '.', 'mount_point': self.mount_point or '/'}

364 365 __repr__ = __str__ 366

367 - def _toxml(self, doc, prefixes):

368 """Create a DOM element for this binding. 369 @param doc: document to use to create the element 370 @return: the new element 371 """ 372 env_elem = doc.createElementNS(XMLNS_IFACE, 'overlay') 373 if self.src is not None: 374 env_elem.setAttributeNS(None, 'src', self.src) 375 if self.mount_point is not None: 376 env_elem.setAttributeNS(None, 'mount-point', self.mount_point) 377 return env_elem

378

379 -class Feed(object):

380 """An interface's feeds are other interfaces whose implementations can also be 381 used as implementations of this interface.""" 382 __slots__ = ['uri', 'os', 'machine', 'user_override', 'langs']

383 - def __init__(self, uri, arch, user_override, langs = None):

384 self.uri = uri 385 # This indicates whether the feed comes from the user's overrides 386 # file. If true, writer.py will write it when saving. 387 self.user_override = user_override 388 self.os, self.machine = _split_arch(arch) 389 self.langs = langs

390

391 - def __str__(self):

392 return "<Feed from %s>" % self.uri

393 __repr__ = __str__ 394 395 arch = property(lambda self: _join_arch(self.os, self.machine))

396

397 -class Dependency(object):

398 """A Dependency indicates that an Implementation requires some additional 399 code to function. This is an abstract base class. 400 @ivar qdom: the XML element for this Dependency (since 0launch 0.51) 401 @type qdom: L{qdom.Element} 402 @ivar metadata: any extra attributes from the XML element 403 @type metadata: {str: str} 404 """ 405 __slots__ = ['qdom'] 406 407 Essential = "essential" 408 Recommended = "recommended" 409

410 - def __init__(self, element):

411 assert isinstance(element, qdom.Element), type(element) # Use InterfaceDependency instead! 412 self.qdom = element

413 414 @property

415 - def metadata(self):

416 return self.qdom.attrs

417 418 @property

419 - def importance(self):

420 return self.qdom.getAttribute("importance") or Dependency.Essential

421

422 - def get_required_commands(self):

423 """Return a list of command names needed by this dependency""" 424 return []

425

426 -class InterfaceDependency(Dependency):

427 """A Dependency on a Zero Install interface. 428 @ivar interface: the interface required by this dependency 429 @type interface: str 430 @ivar restrictions: a list of constraints on acceptable implementations 431 @type restrictions: [L{Restriction}] 432 @ivar bindings: how to make the choice of implementation known 433 @type bindings: [L{Binding}] 434 @since: 0.28 435 """ 436 __slots__ = ['interface', 'restrictions', 'bindings'] 437

438 - def __init__(self, interface, restrictions = None, element = None):

439 Dependency.__init__(self, element) 440 assert isinstance(interface, (str, unicode)) 441 assert interface 442 self.interface = interface 443 if restrictions is None: 444 self.restrictions = [] 445 else: 446 self.restrictions = restrictions 447 self.bindings = []

448

449 - def __str__(self):

450 return _("<Dependency on %(interface)s; bindings: %(bindings)s%(restrictions)s>") % {'interface': self.interface, 'bindings': self.bindings, 'restrictions': self.restrictions}

451

452 - def get_required_commands(self):

453 """Return a list of command names needed by this dependency""" 454 if self.qdom.name == 'runner': 455 commands = [self.qdom.getAttribute('command') or 'run'] 456 else: 457 commands = [] 458 for b in self.bindings: 459 c = b.command 460 if c is not None: 461 commands.append(c) 462 return commands

463 464 @property

465 - def command(self):

466 if self.qdom.name == 'runner': 467 return self.qdom.getAttribute('command') or 'run' 468 return None

469

470 -class RetrievalMethod(object):

471 """A RetrievalMethod provides a way to fetch an implementation.""" 472 __slots__ = []

473

474 -class DownloadSource(RetrievalMethod):

475 """A DownloadSource provides a way to fetch an implementation.""" 476 __slots__ = ['implementation', 'url', 'size', 'extract', 'start_offset', 'type'] 477

478 - def __init__(self, implementation, url, size, extract, start_offset = 0, type = None):

479 self.implementation = implementation 480 self.url = url 481 self.size = size 482 self.extract = extract 483 self.start_offset = start_offset 484 self.type = type # MIME type - see unpack.py

485

486 -class Recipe(RetrievalMethod):

487 """Get an implementation by following a series of steps. 488 @ivar size: the combined download sizes from all the steps 489 @type size: int 490 @ivar steps: the sequence of steps which must be performed 491 @type steps: [L{RetrievalMethod}]""" 492 __slots__ = ['steps'] 493

494 - def __init__(self):

495 self.steps = []

496 497 size = property(lambda self: sum([x.size for x in self.steps]))

498

499 -class DistributionSource(RetrievalMethod):

500 """A package that is installed using the distribution's tools (including PackageKit). 501 @ivar install: a function to call to install this package 502 @type install: (L{handler.Handler}) -> L{tasks.Blocker} 503 @ivar package_id: the package name, in a form recognised by the distribution's tools 504 @type package_id: str 505 @ivar size: the download size in bytes 506 @type size: int 507 @ivar needs_confirmation: whether the user should be asked to confirm before calling install() 508 @type needs_confirmation: bool""" 509 510 __slots__ = ['package_id', 'size', 'install', 'needs_confirmation'] 511

512 - def __init__(self, package_id, size, install, needs_confirmation = True):

513 RetrievalMethod.__init__(self) 514 self.package_id = package_id 515 self.size = size 516 self.install = install 517 self.needs_confirmation = needs_confirmation

518

519 -class Command(object):

520 """A Command is a way of running an Implementation as a program.""" 521 522 __slots__ = ['qdom', '_depends', '_local_dir', '_runner', '_bindings'] 523

524 - def __init__(self, qdom, local_dir):

525 """@param qdom: the <command> element 526 @param local_dir: the directory containing the feed (for relative dependencies), or None if not local 527 """ 528 assert qdom.name == 'command', 'not <command>: %s' % qdom 529 self.qdom = qdom 530 self._local_dir = local_dir 531 self._depends = None 532 self._bindings = None

533 534 path = property(lambda self: self.qdom.attrs.get("path", None)) 535

536 - def _toxml(self, doc, prefixes):

537 return self.qdom.toDOM(doc, prefixes)

538 539 @property

540 - def requires(self):

541 if self._depends is None: 542 self._runner = None 543 depends = [] 544 for child in self.qdom.childNodes: 545 if child.name == 'requires': 546 dep = process_depends(child, self._local_dir) 547 depends.append(dep) 548 elif child.name == 'runner': 549 if self._runner: 550 raise InvalidInterface(_("Multiple <runner>s in <command>!")) 551 dep = process_depends(child, self._local_dir) 552 depends.append(dep) 553 self._runner = dep 554 self._depends = depends 555 return self._depends

556

557 - def get_runner(self):

558 self.requires # (sets _runner) 559 return self._runner

560

561 - def __str__(self):

562 return str(self.qdom)

563 564 @property

565 - def bindings(self):

566 """@since: 1.3""" 567 if self._bindings is None: 568 bindings = [] 569 for e in self.qdom.childNodes: 570 if e.uri != XMLNS_IFACE: continue 571 if e.name in binding_names: 572 bindings.append(process_binding(e)) 573 self._bindings = bindings 574 return self._bindings

575

576 -class Implementation(object):

577 """An Implementation is a package which implements an Interface. 578 @ivar download_sources: list of methods of getting this implementation 579 @type download_sources: [L{RetrievalMethod}] 580 @ivar feed: the feed owning this implementation (since 0.32) 581 @type feed: [L{ZeroInstallFeed}] 582 @ivar bindings: how to tell this component where it itself is located (since 0.31) 583 @type bindings: [Binding] 584 @ivar upstream_stability: the stability reported by the packager 585 @type upstream_stability: [insecure | buggy | developer | testing | stable | packaged] 586 @ivar user_stability: the stability as set by the user 587 @type upstream_stability: [insecure | buggy | developer | testing | stable | packaged | preferred] 588 @ivar langs: natural languages supported by this package 589 @type langs: str 590 @ivar requires: interfaces this package depends on 591 @type requires: [L{Dependency}] 592 @ivar commands: ways to execute as a program 593 @type commands: {str: Command} 594 @ivar metadata: extra metadata from the feed 595 @type metadata: {"[URI ]localName": str} 596 @ivar id: a unique identifier for this Implementation 597 @ivar version: a parsed version number 598 @ivar released: release date 599 @ivar local_path: the directory containing this local implementation, or None if it isn't local (id isn't a path) 600 @type local_path: str | None 601 @ivar requires_root_install: whether the user will need admin rights to use this 602 @type requires_root_install: bool 603 """ 604 605 # Note: user_stability shouldn't really be here 606 607 __slots__ = ['upstream_stability', 'user_stability', 'langs', 608 'requires', 'metadata', 'download_sources', 'commands', 609 'id', 'feed', 'version', 'released', 'bindings', 'machine'] 610

611 - def __init__(self, feed, id):

612 assert id 613 self.feed = feed 614 self.id = id 615 self.user_stability = None 616 self.upstream_stability = None 617 self.metadata = {} # [URI + " "] + localName -> value 618 self.requires = [] 619 self.version = None 620 self.released = None 621 self.download_sources = [] 622 self.langs = "" 623 self.machine = None 624 self.bindings = [] 625 self.commands = {}

626

627 - def get_stability(self):

628 return self.user_stability or self.upstream_stability or testing

629

630 - def __str__(self):

631 return self.id

632

633 - def __repr__(self):

634 return "v%s (%s)" % (self.get_version(), self.id)

635

636 - def __cmp__(self, other):

637 """Newer versions come first""" 638 d = cmp(other.version, self.version) 639 if d: return d 640 # If the version number is the same, just give a stable sort order, and 641 # ensure that two different implementations don't compare equal. 642 d = cmp(other.feed.url, self.feed.url) 643 if d: return d 644 return cmp(other.id, self.id)

645

646 - def get_version(self):

647 """Return the version as a string. 648 @see: L{format_version} 649 """ 650 return format_version(self.version)

651 652 arch = property(lambda self: _join_arch(self.os, self.machine)) 653 654 os = None 655 local_path = None 656 digests = None 657 requires_root_install = False 658

659 - def _get_main(self):

660 """"@deprecated: use commands["run"] instead""" 661 main = self.commands.get("run", None) 662 if main is not None: 663 return main.path 664 return None

665 - def _set_main(self, path):

666 """"@deprecated: use commands["run"] instead""" 667 if path is None: 668 if "run" in self.commands: 669 del self.commands["run"] 670 else: 671 self.commands["run"] = Command(qdom.Element(XMLNS_IFACE, 'command', {'path': path, 'name': 'run'}), None)

672 main = property(_get_main, _set_main) 673

674 - def is_available(self, stores):

675 """Is this Implementation available locally? 676 (a local implementation, an installed distribution package, or a cached ZeroInstallImplementation) 677 @rtype: bool 678 @since: 0.53 679 """ 680 raise NotImplementedError("abstract")

681

682 -class DistributionImplementation(Implementation):

683 """An implementation provided by the distribution. Information such as the version 684 comes from the package manager. 685 @ivar package_implementation: the <package-implementation> element that generated this impl (since 1.7) 686 @type package_implementation: L{qdom.Element} 687 @since: 0.28""" 688 __slots__ = ['distro', 'installed', 'package_implementation'] 689

690 - def __init__(self, feed, id, distro, package_implementation = None):

691 assert id.startswith('package:') 692 Implementation.__init__(self, feed, id) 693 self.distro = distro 694 self.installed = False 695 self.package_implementation = package_implementation 696 697 if package_implementation: 698 for child in package_implementation.childNodes: 699 if child.uri != XMLNS_IFACE: continue 700 if child.name == 'command': 701 command_name = child.attrs.get('name', None) 702 if not command_name: 703 raise InvalidInterface('Missing name for <command>') 704 self.commands[command_name] = Command(child, local_dir = None)

705 706 @property

707 - def requires_root_install(self):

708 return not self.installed

709

710 - def is_available(self, stores):

711 return self.installed

712

713 -class ZeroInstallImplementation(Implementation):

714 """An implementation where all the information comes from Zero Install. 715 @ivar digests: a list of "algorith=value" strings (since 0.45) 716 @type digests: [str] 717 @since: 0.28""" 718 __slots__ = ['os', 'size', 'digests', 'local_path'] 719

720 - def __init__(self, feed, id, local_path):

721 """id can be a local path (string starting with /) or a manifest hash (eg "sha1=XXX")""" 722 assert not id.startswith('package:'), id 723 Implementation.__init__(self, feed, id) 724 self.size = None 725 self.os = None 726 self.digests = [] 727 self.local_path = local_path

728 729 # Deprecated 730 dependencies = property(lambda self: dict([(x.interface, x) for x in self.requires 731 if isinstance(x, InterfaceDependency)])) 732

733 - def add_download_source(self, url, size, extract, start_offset = 0, type = None):

734 """Add a download source.""" 735 self.download_sources.append(DownloadSource(self, url, size, extract, start_offset, type))

736

737 - def set_arch(self, arch):

738 self.os, self.machine = _split_arch(arch)

739 arch = property(lambda self: _join_arch(self.os, self.machine), set_arch) 740

741 - def is_available(self, stores):

742 if self.local_path is not None: 743 return os.path.exists(self.local_path) 744 if self.digests: 745 path = stores.lookup_maybe(self.digests) 746 return path is not None 747 return False # (0compile creates fake entries with no digests)

748

749 -class Interface(object):

750 """An Interface represents some contract of behaviour. 751 @ivar uri: the URI for this interface. 752 @ivar stability_policy: user's configured policy. 753 Implementations at this level or higher are preferred. 754 Lower levels are used only if there is no other choice. 755 """ 756 __slots__ = ['uri', 'stability_policy', 'extra_feeds'] 757 758 implementations = property(lambda self: self._main_feed.implementations) 759 name = property(lambda self: self._main_feed.name) 760 description = property(lambda self: self._main_feed.description) 761 summary = property(lambda self: self._main_feed.summary) 762 last_modified = property(lambda self: self._main_feed.last_modified) 763 feeds = property(lambda self: self.extra_feeds + self._main_feed.feeds) 764 metadata = property(lambda self: self._main_feed.metadata) 765 766 last_checked = property(lambda self: self._main_feed.last_checked) 767

768 - def __init__(self, uri):

769 assert uri 770 if uri.startswith('http:') or uri.startswith('https:') or os.path.isabs(uri): 771 self.uri = uri 772 else: 773 raise SafeException(_("Interface name '%s' doesn't start " 774 "with 'http:' or 'https:'") % uri) 775 self.reset()

776

777 - def _get_feed_for(self):

778 retval = {} 779 for key in self._main_feed.feed_for: 780 retval[key] = True 781 return retval

782 feed_for = property(_get_feed_for) # Deprecated (used by 0publish) 783

784 - def reset(self):

785 self.extra_feeds = [] 786 self.stability_policy = None

787

788 - def get_name(self):

789 from zeroinstall.injector.iface_cache import iface_cache 790 feed = iface_cache.get_feed(self.uri) 791 if feed: 792 return feed.get_name() 793 return '(' + os.path.basename(self.uri) + ')'

794

795 - def __repr__(self):

796 return _("<Interface %s>") % self.uri

797

798 - def set_stability_policy(self, new):

799 assert new is None or isinstance(new, Stability) 800 self.stability_policy = new

801

802 - def get_feed(self, url):

803 #import warnings 804 #warnings.warn("use iface_cache.get_feed instead", DeprecationWarning, 2) 805 for x in self.extra_feeds: 806 if x.uri == url: 807 return x 808 #return self._main_feed.get_feed(url) 809 return None

810

811 - def get_metadata(self, uri, name):

812 return self._main_feed.get_metadata(uri, name)

813 814 @property

815 - def _main_feed(self):

816 #import warnings 817 #warnings.warn("use the feed instead", DeprecationWarning, 3) 818 from zeroinstall.injector import policy 819 iface_cache = policy.get_deprecated_singleton_config().iface_cache 820 feed = iface_cache.get_feed(self.uri) 821 if feed is None: 822 return _dummy_feed 823 return feed

824

825 -def _merge_attrs(attrs, item):

826 """Add each attribute of item to a copy of attrs and return the copy. 827 @type attrs: {str: str} 828 @type item: L{qdom.Element} 829 @rtype: {str: str} 830 """ 831 new = attrs.copy() 832 for a in item.attrs: 833 new[str(a)] = item.attrs[a] 834 return new

835

836 -def _get_long(elem, attr_name):

837 val = elem.getAttribute(attr_name) 838 if val is not None: 839 try: 840 val = int(val) 841 except ValueError: 842 raise SafeException(_("Invalid value for integer attribute '%(attribute_name)s': %(value)s") % {'attribute_name': attr_name, 'value': val}) 843 return val

844

845 -class ZeroInstallFeed(object):

846 """A feed lists available implementations of an interface. 847 @ivar url: the URL for this feed 848 @ivar implementations: Implementations in this feed, indexed by ID 849 @type implementations: {str: L{Implementation}} 850 @ivar name: human-friendly name 851 @ivar summaries: short textual description (in various languages, since 0.49) 852 @type summaries: {str: str} 853 @ivar descriptions: long textual description (in various languages, since 0.49) 854 @type descriptions: {str: str} 855 @ivar last_modified: timestamp on signature 856 @ivar last_checked: time feed was last successfully downloaded and updated 857 @ivar local_path: the path of this local feed, or None if remote (since 1.7) 858 @type local_path: str | None 859 @ivar feeds: list of <feed> elements in this feed 860 @type feeds: [L{Feed}] 861 @ivar feed_for: interfaces for which this could be a feed 862 @type feed_for: set(str) 863 @ivar metadata: extra elements we didn't understand 864 """ 865 # _main is deprecated 866 __slots__ = ['url', 'implementations', 'name', 'descriptions', 'first_description', 'summaries', 'first_summary', '_package_implementations', 867 'last_checked', 'last_modified', 'feeds', 'feed_for', 'metadata', 'local_path'] 868

869 - def __init__(self, feed_element, local_path = None, distro = None):

870 """Create a feed object from a DOM. 871 @param feed_element: the root element of a feed file 872 @type feed_element: L{qdom.Element} 873 @param local_path: the pathname of this local feed, or None for remote feeds""" 874 self.local_path = local_path 875 self.implementations = {} 876 self.name = None 877 self.summaries = {} # { lang: str } 878 self.first_summary = None 879 self.descriptions = {} # { lang: str } 880 self.first_description = None 881 self.last_modified = None 882 self.feeds = [] 883 self.feed_for = set() 884 self.metadata = [] 885 self.last_checked = None 886 self._package_implementations = [] 887 888 if distro is not None: 889 import warnings 890 warnings.warn("distro argument is now ignored", DeprecationWarning, 2) 891 892 if feed_element is None: 893 return # XXX subclass? 894 895 assert feed_element.name in ('interface', 'feed'), "Root element should be <interface>, not %s" % feed_element 896 assert feed_element.uri == XMLNS_IFACE, "Wrong namespace on root element: %s" % feed_element.uri 897 898 main = feed_element.getAttribute('main') 899 #if main: warn("Setting 'main' on the root element is deprecated. Put it on a <group> instead") 900 901 if local_path: 902 self.url = local_path 903 local_dir = os.path.dirname(local_path) 904 else: 905 assert local_path is None 906 self.url = feed_element.getAttribute('uri') 907 if not self.url: 908 raise InvalidInterface(_("<interface> uri attribute missing")) 909 local_dir = None # Can't have relative paths 910 911 min_injector_version = feed_element.getAttribute('min-injector-version') 912 if min_injector_version: 913 if parse_version(min_injector_version) > parse_version(version): 914 raise InvalidInterface(_("This feed requires version %(min_version)s or later of " 915 "Zero Install, but I am only version %(version)s. " 916 "You can get a newer version from http://0install.net") % 917 {'min_version': min_injector_version, 'version': version}) 918 919 for x in feed_element.childNodes: 920 if x.uri != XMLNS_IFACE: 921 self.metadata.append(x) 922 continue 923 if x.name == 'name': 924 self.name = x.content 925 elif x.name == 'description': 926 if self.first_description == None: 927 self.first_description = x.content 928 self.descriptions[x.attrs.get("http://www.w3.org/XML/1998/namespace lang", 'en')] = x.content 929 elif x.name == 'summary': 930 if self.first_summary == None: 931 self.first_summary = x.content 932 self.summaries[x.attrs.get("http://www.w3.org/XML/1998/namespace lang", 'en')] = x.content 933 elif x.name == 'feed-for': 934 feed_iface = x.getAttribute('interface') 935 if not feed_iface: 936 raise InvalidInterface(_('Missing "interface" attribute in <feed-for>')) 937 self.feed_for.add(feed_iface) 938 # Bug report from a Debian/stable user that --feed gets the wrong value. 939 # Can't reproduce (even in a Debian/stable chroot), but add some logging here 940 # in case it happens again. 941 debug(_("Is feed-for %s"), feed_iface) 942 elif x.name == 'feed': 943 feed_src = x.getAttribute('src') 944 if not feed_src: 945 raise InvalidInterface(_('Missing "src" attribute in <feed>')) 946 if feed_src.startswith('http:') or feed_src.startswith('https:') or local_path: 947 langs = x.getAttribute('langs') 948 if langs: langs = langs.replace('_', '-') 949 self.feeds.append(Feed(feed_src, x.getAttribute('arch'), False, langs = langs)) 950 else: 951 raise InvalidInterface(_("Invalid feed URL '%s'") % feed_src) 952 else: 953 self.metadata.append(x) 954 955 if not self.name: 956 raise InvalidInterface(_("Missing <name> in feed")) 957 if not self.summary: 958 raise InvalidInterface(_("Missing <summary> in feed")) 959 960 def process_group(group, group_attrs, base_depends, base_bindings, base_commands): 961 for item in group.childNodes: 962 if item.uri != XMLNS_IFACE: continue 963 964 if item.name not in ('group', 'implementation', 'package-implementation'): 965 continue 966 967 # We've found a group or implementation. Scan for dependencies, 968 # bindings and commands. Doing this here means that: 969 # - We can share the code for groups and implementations here. 970 # - The order doesn't matter, because these get processed first. 971 # A side-effect is that the document root cannot contain 972 # these. 973 974 depends = base_depends[:] 975 bindings = base_bindings[:] 976 commands = base_commands.copy() 977 978 for attr, command in [('main', 'run'), 979 ('self-test', 'test')]: 980 value = item.attrs.get(attr, None) 981 if value is not None: 982 commands[command] = Command(qdom.Element(XMLNS_IFACE, 'command', {'name': command, 'path': value}), None) 983 984 for child in item.childNodes: 985 if child.uri != XMLNS_IFACE: continue 986 if child.name == 'requires': 987 dep = process_depends(child, local_dir) 988 depends.append(dep) 989 elif child.name == 'command': 990 command_name = child.attrs.get('name', None) 991 if not command_name: 992 raise InvalidInterface('Missing name for <command>') 993 commands[command_name] = Command(child, local_dir) 994 elif child.name in binding_names: 995 bindings.append(process_binding(child)) 996 997 compile_command = item.attrs.get('http://zero-install.sourceforge.net/2006/namespaces/0compile command') 998 if compile_command is not None: 999 commands['compile'] = Command(qdom.Element(XMLNS_IFACE, 'command', {'name': 'compile', 'shell-command': compile_command}), None) 1000 1001 item_attrs = _merge_attrs(group_attrs, item) 1002 1003 if item.name == 'group': 1004 process_group(item, item_attrs, depends, bindings, commands) 1005 elif item.name == 'implementation': 1006 process_impl(item, item_attrs, depends, bindings, commands) 1007 elif item.name == 'package-implementation': 1008 if depends: 1009 warn("A <package-implementation> with dependencies in %s!", self.url) 1010 self._package_implementations.append((item, item_attrs)) 1011 else: 1012 assert 0

1013 1014 def process_impl(item, item_attrs, depends, bindings, commands): 1015 id = item.getAttribute('id') 1016 if id is None: 1017 raise InvalidInterface(_("Missing 'id' attribute on %s") % item) 1018 local_path = item_attrs.get('local-path') 1019 if local_dir and local_path: 1020 abs_local_path = os.path.abspath(os.path.join(local_dir, local_path)) 1021 impl = ZeroInstallImplementation(self, id, abs_local_path) 1022 elif local_dir and (id.startswith('/') or id.startswith('.')): 1023 # For old feeds 1024 id = os.path.abspath(os.path.join(local_dir, id)) 1025 impl = ZeroInstallImplementation(self, id, id) 1026 else: 1027 impl = ZeroInstallImplementation(self, id, None) 1028 if '=' in id: 1029 # In older feeds, the ID was the (single) digest 1030 impl.digests.append(id) 1031 if id in self.implementations: 1032 warn(_("Duplicate ID '%(id)s' in feed '%(feed)s'"), {'id': id, 'feed': self}) 1033 self.implementations[id] = impl 1034 1035 impl.metadata = item_attrs 1036 try: 1037 version_mod = item_attrs.get('version-modifier', None) 1038 if version_mod: 1039 item_attrs['version'] += version_mod 1040 del item_attrs['version-modifier'] 1041 version = item_attrs['version'] 1042 except KeyError: 1043 raise InvalidInterface(_("Missing version attribute")) 1044 impl.version = parse_version(version) 1045 1046 impl.commands = commands 1047 1048 impl.released = item_attrs.get('released', None) 1049 impl.langs = item_attrs.get('langs', '').replace('_', '-') 1050 1051 size = item.getAttribute('size') 1052 if size: 1053 impl.size = int(size) 1054 impl.arch = item_attrs.get('arch', None) 1055 try: 1056 stability = stability_levels[str(item_attrs['stability'])] 1057 except KeyError: 1058 stab = str(item_attrs['stability']) 1059 if stab != stab.lower(): 1060 raise InvalidInterface(_('Stability "%s" invalid - use lower case!') % item_attrs.stability) 1061 raise InvalidInterface(_('Stability "%s" invalid') % item_attrs['stability']) 1062 if stability >= preferred: 1063 raise InvalidInterface(_("Upstream can't set stability to preferred!")) 1064 impl.upstream_stability = stability 1065 1066 impl.bindings = bindings 1067 impl.requires = depends 1068 1069 for elem in item.childNodes: 1070 if elem.uri != XMLNS_IFACE: continue 1071 if elem.name == 'archive': 1072 url = elem.getAttribute('href') 1073 if not url: 1074 raise InvalidInterface(_("Missing href attribute on <archive>")) 1075 size = elem.getAttribute('size') 1076 if not size: 1077 raise InvalidInterface(_("Missing size attribute on <archive>")) 1078 impl.add_download_source(url = url, size = int(size), 1079 extract = elem.getAttribute('extract'), 1080 start_offset = _get_long(elem, 'start-offset'), 1081 type = elem.getAttribute('type')) 1082 elif elem.name == 'manifest-digest': 1083 for aname, avalue in elem.attrs.iteritems(): 1084 if ' ' not in aname: 1085 impl.digests.append('%s=%s' % (aname, avalue)) 1086 elif elem.name == 'recipe': 1087 recipe = Recipe() 1088 for recipe_step in elem.childNodes: 1089 if recipe_step.uri == XMLNS_IFACE and recipe_step.name == 'archive': 1090 url = recipe_step.getAttribute('href') 1091 if not url: 1092 raise InvalidInterface(_("Missing href attribute on <archive>")) 1093 size = recipe_step.getAttribute('size') 1094 if not size: 1095 raise InvalidInterface(_("Missing size attribute on <archive>")) 1096 recipe.steps.append(DownloadSource(None, url = url, size = int(size), 1097 extract = recipe_step.getAttribute('extract'), 1098 start_offset = _get_long(recipe_step, 'start-offset'), 1099 type = recipe_step.getAttribute('type'))) 1100 else: 1101 info(_("Unknown step '%s' in recipe; skipping recipe"), recipe_step.name) 1102 break 1103 else: 1104 impl.download_sources.append(recipe)

1105 1106 root_attrs = {'stability': 'testing'} 1107 root_commands = {} 1108 if main: 1109 info("Note: @main on document element is deprecated in %s", self) 1110 root_commands['run'] = Command(qdom.Element(XMLNS_IFACE, 'command', {'path': main, 'name': 'run'}), None) 1111 process_group(feed_element, root_attrs, [], [], root_commands) 1112

1113 - def get_distro_feed(self):

1114 """Does this feed contain any <pacakge-implementation> elements? 1115 i.e. is it worth asking the package manager for more information? 1116 @return: the URL of the virtual feed, or None 1117 @since: 0.49""" 1118 if self._package_implementations: 1119 return "distribution:" + self.url 1120 return None

1121

1122 - def get_package_impls(self, distro):

1123 """Find the best <pacakge-implementation> element(s) for the given distribution. 1124 @param distro: the distribution to use to rate them 1125 @type distro: L{distro.Distribution} 1126 @return: a list of tuples for the best ranked elements 1127 @rtype: [str] 1128 @since: 0.49""" 1129 best_score = 0 1130 best_impls = [] 1131 1132 for item, item_attrs in self._package_implementations: 1133 distro_names = item_attrs.get('distributions', '') 1134 for distro_name in distro_names.split(' '): 1135 score = distro.get_score(distro_name) 1136 if score > best_score: 1137 best_score = score 1138 best_impls = [] 1139 if score == best_score: 1140 best_impls.append((item, item_attrs)) 1141 return best_impls

1142

1143 - def get_name(self):

1144 return self.name or '(' + os.path.basename(self.url) + ')'

1145

1146 - def __repr__(self):

1147 return _("<Feed %s>") % self.url

1148

1149 - def set_stability_policy(self, new):

1150 assert new is None or isinstance(new, Stability) 1151 self.stability_policy = new

1152

1153 - def get_feed(self, url):

1154 for x in self.feeds: 1155 if x.uri == url: 1156 return x 1157 return None

1158

1159 - def add_metadata(self, elem):

1160 self.metadata.append(elem)

1161

1162 - def get_metadata(self, uri, name):

1163 """Return a list of interface metadata elements with this name and namespace URI.""" 1164 return [m for m in self.metadata if m.name == name and m.uri == uri]

1165 1166 @property

1167 - def summary(self):

1168 return _best_language_match(self.summaries) or self.first_summary

1169 1170 @property

1171 - def description(self):

1172 return _best_language_match(self.descriptions) or self.first_description

1173

1174 - def get_replaced_by(self):

1175 """Return the URI of the interface that replaced the one with the URI of this feed's URL. 1176 This is the value of the feed's <replaced-by interface'...'/> element. 1177 @return: the new URI, or None if it hasn't been replaced 1178 @since: 1.7""" 1179 for child in self.metadata: 1180 if child.uri == XMLNS_IFACE and child.name == 'replaced-by': 1181 new_uri = child.getAttribute('interface') 1182 if new_uri and (new_uri.startswith('http:') or new_uri.startswith('https:') or self.local_path): 1183 return new_uri 1184 return None

1185

1186 -class DummyFeed(object):

1187 """Temporary class used during API transition.""" 1188 last_modified = None 1189 name = '-' 1190 last_checked = property(lambda self: None) 1191 implementations = property(lambda self: {}) 1192 feeds = property(lambda self: []) 1193 summary = property(lambda self: '-') 1194 description = property(lambda self: '')

1195 - def get_name(self): return self.name

1196 - def get_feed(self, url): return None

1197 - def get_metadata(self, uri, name): return []

1198 _dummy_feed = DummyFeed()

1199 1200 -def unescape(uri):

1201 """Convert each %20 to a space, etc. 1202 @rtype: str""" 1203 uri = uri.replace('#', '/') 1204 if '%' not in uri: return uri 1205 return re.sub('%[0-9a-fA-F][0-9a-fA-F]', 1206 lambda match: chr(int(match.group(0)[1:], 16)), 1207 uri).decode('utf-8')

1208

1209 -def escape(uri):

1210 """Convert each space to %20, etc 1211 @rtype: str""" 1212 return re.sub('[^-_.a-zA-Z0-9]', 1213 lambda match: '%%%02x' % ord(match.group(0)), 1214 uri.encode('utf-8'))

1215

1216 -def _pretty_escape(uri):

1217 """Convert each space to %20, etc 1218 : is preserved and / becomes #. This makes for nicer strings, 1219 and may replace L{escape} everywhere in future. 1220 @rtype: str""" 1221 if os.name == "posix": 1222 # Only preserve : on Posix systems 1223 preserveRegex = '[^-_.a-zA-Z0-9:/]' 1224 else: 1225 # Other OSes may not allow the : character in file names 1226 preserveRegex = '[^-_.a-zA-Z0-9/]' 1227 return re.sub(preserveRegex, 1228 lambda match: '%%%02x' % ord(match.group(0)), 1229 uri.encode('utf-8')).replace('/', '#')

1230

1231 -def canonical_iface_uri(uri):

1232 """If uri is a relative path, convert to an absolute one. 1233 A "file:///foo" URI is converted to "/foo". 1234 An "alias:prog" URI expands to the URI in the 0alias script 1235 Otherwise, return it unmodified. 1236 @rtype: str 1237 @raise SafeException: if uri isn't valid 1238 """ 1239 if uri.startswith('http://') or uri.startswith('https://'): 1240 if uri.count("/") < 3: 1241 raise SafeException(_("Missing / after hostname in URI '%s'") % uri) 1242 return uri 1243 elif uri.startswith('file:///'): 1244 path = uri[7:] 1245 elif uri.startswith('file:'): 1246 if uri[5] == '/': 1247 raise SafeException(_('Use file:///path for absolute paths, not {uri}').format(uri = uri)) 1248 path = os.path.abspath(uri[5:]) 1249 elif uri.startswith('alias:'): 1250 from zeroinstall import alias, support 1251 alias_prog = uri[6:] 1252 if not os.path.isabs(alias_prog): 1253 full_path = support.find_in_path(alias_prog) 1254 if not full_path: 1255 raise alias.NotAnAliasScript("Not found in $PATH: " + alias_prog) 1256 else: 1257 full_path = alias_prog 1258 return alias.parse_script(full_path).uri 1259 else: 1260 path = os.path.realpath(uri) 1261 1262 if os.path.isfile(path): 1263 return path 1264 raise SafeException(_("Bad interface name '%(uri)s'.\n" 1265 "(doesn't start with 'http:', and " 1266 "doesn't exist as a local file '%(interface_uri)s' either)") % 1267 {'uri': uri, 'interface_uri': path})

1268 1269 _version_mod_to_value = { 1270 'pre': -2, 1271 'rc': -1, 1272 '': 0, 1273 'post': 1, 1274 } 1275 1276 # Reverse mapping 1277 _version_value_to_mod = {} 1278 for x in _version_mod_to_value: _version_value_to_mod[_version_mod_to_value[x]] = x 1279 del x 1280 1281 _version_re = re.compile('-([a-z]*)')

1282 1283 -def parse_version(version_string):

1284 """Convert a version string to an internal representation. 1285 The parsed format can be compared quickly using the standard Python functions. 1286 - Version := DottedList ("-" Mod DottedList?)* 1287 - DottedList := (Integer ("." Integer)*) 1288 @rtype: tuple (opaque) 1289 @raise SafeException: if the string isn't a valid version 1290 @since: 0.24 (moved from L{reader}, from where it is still available):""" 1291 if version_string is None: return None 1292 parts = _version_re.split(version_string) 1293 if parts[-1] == '': 1294 del parts[-1] # Ends with a modifier 1295 else: 1296 parts.append('') 1297 if not parts: 1298 raise SafeException(_("Empty version string!")) 1299 l = len(parts) 1300 try: 1301 for x in range(0, l, 2): 1302 part = parts[x] 1303 if part: 1304 parts[x] = map(int, parts[x].split('.')) 1305 else: 1306 parts[x] = [] # (because ''.split('.') == [''], not []) 1307 for x in range(1, l, 2): 1308 parts[x] = _version_mod_to_value[parts[x]] 1309 return parts 1310 except ValueError as ex: 1311 raise SafeException(_("Invalid version format in '%(version_string)s': %(exception)s") % {'version_string': version_string, 'exception': ex}) 1312 except KeyError as ex: 1313 raise SafeException(_("Invalid version modifier in '%(version_string)s': %(exception)s") % {'version_string': version_string, 'exception': ex})

1314

1315 -def format_version(version):

1316 """Format a parsed version for display. Undoes the effect of L{parse_version}. 1317 @see: L{Implementation.get_version} 1318 @rtype: str 1319 @since: 0.24""" 1320 version = version[:] 1321 l = len(version) 1322 for x in range(0, l, 2): 1323 version[x] = '.'.join(map(str, version[x])) 1324 for x in range(1, l, 2): 1325 version[x] = '-' + _version_value_to_mod[version[x]] 1326 if version[-1] == '-': del version[-1] 1327 return ''.join(version)

1328

Source Code for Module zeroinstall.injector.model