def fetch_feed():
yield dl.downloaded
tasks.check(dl.downloaded)
pending = PendingFeed(feed_url, stream)
if use_mirror:
# If we got the feed from a mirror, get the key from there too
key_mirror = self.feed_mirror + '/keys/'
else:
key_mirror = None
keys_downloaded = tasks.Task(
pending.download_keys(self.handler,
feed_hint=feed_url,
key_mirror=key_mirror),
_("download keys for %s") % feed_url)
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
iface = iface_cache.get_interface(pending.url)
if not iface_cache.update_interface_if_trusted(
iface, pending.sigs, pending.new_xml):
blocker = self.handler.confirm_keys(pending,
self.fetch_key_info)
if blocker:
yield blocker
tasks.check(blocker)
if not iface_cache.update_interface_if_trusted(
iface, pending.sigs, pending.new_xml):
raise NoTrustedKeys(
_("No signing keys trusted; not importing"))
def fetch_feed():
try:
yield dl.downloaded
tasks.check(dl.downloaded)
pending = PendingFeed(feed_url, stream)
if use_mirror:
# If we got the feed from a mirror, get the key from there too
key_mirror = self.config.mirror + '/keys/'
else:
key_mirror = None
keys_downloaded = tasks.Task(
pending.download_keys(self,
feed_hint=feed_url,
key_mirror=key_mirror),
_("download keys for %s") % feed_url)
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
if not self.config.iface_cache.update_feed_if_trusted(
pending.url, pending.sigs, pending.new_xml):
blocker = self.config.trust_mgr.confirm_keys(pending)
if blocker:
yield blocker
tasks.check(blocker)
if not self.config.iface_cache.update_feed_if_trusted(
pending.url, pending.sigs, pending.new_xml):
raise NoTrustedKeys(
_("No signing keys trusted; not importing"))
finally:
stream.close()
def start(self):
"""Create a temporary file and begin the download.
@precondition: L{status} == L{download_starting}"""
assert self.status == download_starting
assert self.downloaded is None
self.tempfile = tempfile.TemporaryFile(prefix='injector-dl-data-')
task = tasks.Task(self._do_download(), "download " + self.url)
self.downloaded = task.finished
def run():
keys_downloaded = tasks.Task(pending.download_keys(handler), "download keys")
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
if not iface_cache.update_interface_if_trusted(iface, pending.sigs, pending.new_xml):
blocker = handler.confirm_trust_keys(iface, pending.sigs, pending.new_xml)
if blocker:
yield blocker
tasks.check(blocker)
if not iface_cache.update_interface_if_trusted(iface, pending.sigs, pending.new_xml):
raise SafeException(_("No signing keys trusted; not importing"))
def run():
keys_downloaded = tasks.Task(
pending.download_keys(config.fetcher), "download keys")
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
if not config.iface_cache.update_feed_if_trusted(
uri, pending.sigs, pending.new_xml):
blocker = config.trust_mgr.confirm_keys(pending)
if blocker:
yield blocker
tasks.check(blocker)
if not config.iface_cache.update_feed_if_trusted(
uri, pending.sigs, pending.new_xml):
raise SafeException(
_("No signing keys trusted; not importing"))
def handle(config, options, args):
if not args:
raise UsageError()
h = config.handler
for x in args:
if not os.path.isfile(x):
raise SafeException(_("File '%s' does not exist") % x)
logging.info(_("Importing from file '%s'"), x)
signed_data = file(x)
data, sigs = gpg.check_stream(signed_data)
doc = minidom.parseString(data.read())
uri = doc.documentElement.getAttribute('uri')
if not uri:
raise SafeException(
_("Missing 'uri' attribute on root element in '%s'") % x)
logging.info(_("Importing information about interface %s"), uri)
signed_data.seek(0)
pending = PendingFeed(uri, signed_data)
def run():
keys_downloaded = tasks.Task(pending.download_keys(h),
"download keys")
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
if not config.iface_cache.update_feed_if_trusted(
uri, pending.sigs, pending.new_xml):
blocker = config.trust_mgr.confirm_keys(pending)
if blocker:
yield blocker
tasks.check(blocker)
if not config.iface_cache.update_feed_if_trusted(
uri, pending.sigs, pending.new_xml):
raise SafeException(
_("No signing keys trusted; not importing"))
task = tasks.Task(run(), "import feed")
errors = tasks.wait_for_blocker(task.finished)
if errors:
raise SafeException(
_("Errors during download: ") + '\n'.join(errors))
def _import_feed(args):
from zeroinstall.support import tasks
from zeroinstall.injector import gpg, handler
from zeroinstall.injector.iface_cache import PendingFeed
from xml.dom import minidom
handler = handler.Handler()
for x in args:
if not os.path.isfile(x):
raise SafeException(_("File '%s' does not exist") % x)
logging.info(_("Importing from file '%s'"), x)
signed_data = file(x)
data, sigs = gpg.check_stream(signed_data)
doc = minidom.parseString(data.read())
uri = doc.documentElement.getAttribute('uri')
if not uri:
raise SafeException(_("Missing 'uri' attribute on root element in '%s'") % x)
iface = iface_cache.get_interface(uri)
logging.info(_("Importing information about interface %s"), iface)
signed_data.seek(0)
pending = PendingFeed(uri, signed_data)
def run():
keys_downloaded = tasks.Task(pending.download_keys(handler), "download keys")
yield keys_downloaded.finished
tasks.check(keys_downloaded.finished)
if not iface_cache.update_interface_if_trusted(iface, pending.sigs, pending.new_xml):
blocker = handler.confirm_trust_keys(iface, pending.sigs, pending.new_xml)
if blocker:
yield blocker
tasks.check(blocker)
if not iface_cache.update_interface_if_trusted(iface, pending.sigs, pending.new_xml):
raise SafeException(_("No signing keys trusted; not importing"))
task = tasks.Task(run(), "import feed")
errors = handler.wait_for_blocker(task.finished)
if errors:
raise SafeException(_("Errors during download: ") + '\n'.join(errors))
def wait_for_blocker(self, blocker):
"""Run a recursive mainloop until blocker is triggered.
@param blocker: event to wait on
@type blocker: L{tasks.Blocker}"""
if not blocker.happened:
import gobject
def quitter():
yield blocker
self._loop.quit()
quit = tasks.Task(quitter(), "quitter")
assert self._loop is None # Avoid recursion
self._loop = gobject.MainLoop(gobject.main_context_default())
try:
debug(_("Entering mainloop, waiting for %s"), blocker)
self._loop.run()
finally:
self._loop = None
assert blocker.happened, "Someone quit the main loop!"
tasks.check(blocker)