Beispiel #1
0
def makedeb(config, iface, icon):
	pkg_name = iface.get_name().lower().replace(' ', '-')

	desc_paras = ('Description: ' + iface.description).split('\n\n')
	wrapped = [textwrap.wrap(para) for para in desc_paras]
	desc_lines = []
	for para in wrapped:
		desc_lines += [' ' + (line or '.') for line in para]
	description = '\n'.join(desc_lines)[1:]

	sig, = config.iface_cache.get_cached_signatures(iface.uri)[:1]
	key = gpg.load_key(sig.fingerprint)
	bytes = 0

	d = tempfile.mkdtemp(prefix = 'bootstrap-')
	try:
		bin_dir = d + '/usr/bin'
		apps_dir = d + '/usr/share/applications'
		icons_dir = d + '/usr/share/pixmaps'
		deb_dir = d + '/DEBIAN'
		os.makedirs(bin_dir)
		os.makedirs(apps_dir)
		os.makedirs(icons_dir)
		os.makedirs(deb_dir)

		icon_name = None
		if icon:
			icon_name = pkg_name + '.png'
			shutil.copyfile(icon, icons_dir + '/' + icon_name)
			bytes += os.path.getsize(icon)

		s = open(apps_dir + '/' + pkg_name + '.desktop', 'w')
		s.write(support.make_desktop_file(iface, icon_name))
		bytes += s.tell()
		s.close()

		control = _control_template.format(deb_name = pkg_name,
			   author = key.name,
			   description = description,
			   installed_size = (bytes + 1023) / 1024)

		s = open(deb_dir + '/control', 'w')
		s.write(control)
		s.close()

		subprocess.check_call(['fakeroot', 'dpkg-deb', '--build', '--', d, pkg_name + '.deb'])
	finally:
		shutil.rmtree(d)
Beispiel #2
0
def makerpm(config, iface, icon):
    pkg_name = iface.get_name().lower().replace(" ", "-")

    sig, = config.iface_cache.get_cached_signatures(iface.uri)[:1]
    key = gpg.load_key(sig.fingerprint)

    d = tempfile.mkdtemp(prefix="0bootstrap-")
    try:
        os.environ["HOME"] = d
        bin_dir = d + "/usr/bin"
        apps_dir = d + "/usr/share/applications"
        icons_dir = d + "/usr/share/pixmaps"
        top_dir = d + "/rpmbuild"
        rpm_sources = top_dir + "/SOURCES"
        os.makedirs(bin_dir)
        os.makedirs(apps_dir)
        os.makedirs(icons_dir)
        os.makedirs(rpm_sources)
        os.makedirs(top_dir + "/BUILD")

        icon_name = None
        if icon:
            icon_name = pkg_name + ".png"
            shutil.copyfile(icon, icons_dir + "/" + icon_name)

        s = open(apps_dir + "/" + pkg_name + ".desktop", "w")
        s.write(support.make_desktop_file(iface, icon_name))
        s.close()

        spec = _spec_template.format(
            rpm_name=pkg_name, author=key.name, summary=iface.summary, description=iface.description
        )

        s = open(d + "/" + pkg_name + ".spec", "w")
        s.write(spec)
        s.close()

        t = tarfile.open(rpm_sources + "/" + pkg_name + ".tar.gz", "w:gz")
        t.add(d + "/usr", "usr", recursive=True)
        t.close()

        subprocess.check_call(["rpmbuild", "--define", "%_topdir " + top_dir, "-bb", d + "/" + pkg_name + ".spec"])

        rpms_dir = top_dir + "/RPMS/noarch"
        rpm, = os.listdir(rpms_dir)
        shutil.copyfile(rpms_dir + "/" + rpm, pkg_name + ".rpm")
    finally:
        shutil.rmtree(d)
Beispiel #3
0
def makerpm(config, iface):
	rpm_name = iface.get_name().lower().replace(' ', '-')

	sig, = config.iface_cache.get_cached_signatures(iface.uri)[:1]
	key = gpg.load_key(sig.fingerprint)

	d = tempfile.mkdtemp(prefix = '0bootstrap-')
	try:
		os.environ['HOME'] = d
		bin_dir = d + '/usr/bin'
		apps_dir = d + '/usr/share/applications'
		top_dir = d + '/rpmbuild'
		rpm_sources = top_dir + '/SOURCES'
		os.makedirs(bin_dir)
		os.makedirs(apps_dir)
		os.makedirs(rpm_sources)
		os.makedirs(top_dir + '/BUILD')

		s = open(apps_dir + '/' + rpm_name + '.desktop', 'w')
		s.write(support.make_desktop_file(iface))
		s.close()

		spec = _spec_template.format(rpm_name = rpm_name,
			   author = key.name,
			   summary = iface.summary,
			   description = iface.description,
			   TOPDIR = top_dir)

		s = open(d + '/' + rpm_name + '.spec', 'w')
		s.write(spec)
		s.close()

		t = tarfile.open(rpm_sources + '/' + rpm_name + '.tar.gz', 'w:gz')
		t.add(d + '/usr', 'usr', recursive=True)
		t.close()

		subprocess.check_call(['rpmbuild', '-ba', d + '/' + rpm_name + '.spec'])

		rpms_dir = top_dir + '/RPMS/noarch'
		rpm, = os.listdir(rpms_dir)
		shutil.copyfile(rpms_dir + '/' + rpm, './' + rpm)
	finally:
		shutil.rmtree(d)
    def __init__(self, pending, valid_sigs, parent):
        """@since: 0.42"""
        assert valid_sigs

        gtk.Dialog.__init__(self)
        self.set_has_separator(False)
        self.set_position(gtk.WIN_POS_CENTER)
        self.set_transient_for(parent)

        self.closed = tasks.Blocker(_("confirming keys with user"))

        domain = trust.domain_from_url(pending.url)
        assert domain

        def destroy(box):
            self.closed.trigger()

        self.connect('destroy', destroy)

        self.set_title(_('Confirm trust'))

        vbox = gtk.VBox(False, 4)
        vbox.set_border_width(4)
        self.vbox.pack_start(vbox, True, True, 0)

        notebook = gtk.Notebook()

        if len(valid_sigs) == 1:
            notebook.set_show_tabs(False)

        label = left(_('Checking: %s') % pending.url)
        label.set_padding(4, 4)
        vbox.pack_start(label, False, True, 0)

        currently_trusted_keys = trust.trust_db.get_keys_for_domain(domain)
        if currently_trusted_keys:
            keys = [
                gpg.load_key(fingerprint)
                for fingerprint in currently_trusted_keys
            ]
            descriptions = [
                _("%(key_name)s\n(fingerprint: %(key_fingerprint)s)") % {
                    'key_name': key.name,
                    'key_fingerprint': pretty_fp(key.fingerprint)
                } for key in keys
            ]
        else:
            descriptions = [_('None')]
        frame(vbox,
              _('Keys already approved for "%s"') % domain,
              '\n'.join(descriptions))

        label = left(
            translation.ngettext('This key signed the feed:',
                                 'These keys signed the feed:',
                                 len(valid_sigs)))

        label.set_padding(4, 4)
        vbox.pack_start(label, False, True, 0)

        vbox.pack_start(notebook, True, True, 0)

        self.add_button(gtk.STOCK_HELP, gtk.RESPONSE_HELP)
        self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        self.add_button(gtk.STOCK_ADD, gtk.RESPONSE_OK)
        self.set_default_response(gtk.RESPONSE_OK)

        trust_checkbox = {}  # Sig -> CheckButton

        def ok_sensitive():
            trust_any = False
            for toggle in trust_checkbox.values():
                if toggle.get_active():
                    trust_any = True
                    break
            self.set_response_sensitive(gtk.RESPONSE_OK, trust_any)

        first = True
        for sig in valid_sigs:
            if hasattr(sig, 'get_details'):
                name = '<unknown>'
                details = sig.get_details()
                for item in details:
                    if item[0] == 'uid' and len(item) > 9:
                        name = item[9]
                        break
            else:
                name = None
            page = gtk.VBox(False, 4)
            page.set_border_width(8)

            frame(page, _('Fingerprint'), pretty_fp(sig.fingerprint))

            if name is not None:
                frame(page, _('Claimed identity'), name)

            frame(page, _('Unreliable hints database says'),
                  make_hints_area(self.closed, valid_sigs[sig]))

            already_trusted = trust.trust_db.get_trust_domains(sig.fingerprint)
            if already_trusted:
                frame(page, _('You already trust this key for these domains'),
                      '\n'.join(already_trusted))

            trust_checkbox[sig] = gtk.CheckButton(_('_Trust this key'))
            page.pack_start(trust_checkbox[sig], False, True, 0)
            trust_checkbox[sig].connect('toggled', lambda t: ok_sensitive())

            notebook.append_page(page, gtk.Label(name or 'Signature'))

            if first:
                trust_checkbox[sig].set_active(True)
                first = False

        ok_sensitive()
        self.vbox.show_all()

        if len(valid_sigs) == 1:
            for box in trust_checkbox.values():
                box.hide()

        def response(box, resp):
            if resp == gtk.RESPONSE_HELP:
                trust_help.display()
                return
            if resp == gtk.RESPONSE_OK:
                to_trust = [
                    sig for sig in trust_checkbox
                    if trust_checkbox[sig].get_active()
                ]

                if not self._confirm_unknown_keys(to_trust, valid_sigs):
                    return

                self.trust_keys(to_trust, domain)
            self.destroy()

        self.connect('response', response)
Beispiel #5
0
	def __init__(self, pending, valid_sigs, parent):
		"""@since: 0.42"""
		assert valid_sigs

		gtk.Dialog.__init__(self)
		self.set_has_separator(False)
		self.set_position(gtk.WIN_POS_CENTER)
		self.set_transient_for(parent)

		self.closed = tasks.Blocker(_("confirming keys with user"))

		domain = trust.domain_from_url(pending.url)
		assert domain

		def destroy(box):
			self.closed.trigger()

		self.connect('destroy', destroy)

		self.set_title(_('Confirm trust'))

		vbox = gtk.VBox(False, 4)
		vbox.set_border_width(4)
		self.vbox.pack_start(vbox, True, True, 0)

		notebook = gtk.Notebook()

		if len(valid_sigs) == 1:
			notebook.set_show_tabs(False)

		label = left(_('Checking: %s') % pending.url)
		label.set_padding(4, 4)
		vbox.pack_start(label, False, True, 0)

		currently_trusted_keys = trust.trust_db.get_keys_for_domain(domain)
		if currently_trusted_keys:
			keys = [gpg.load_key(fingerprint) for fingerprint in currently_trusted_keys]
			descriptions = [_("%(key_name)s\n(fingerprint: %(key_fingerprint)s)") % {'key_name': key.name, 'key_fingerprint': pretty_fp(key.fingerprint)}
					for key in keys]
		else:
			descriptions = [_('None')]
		frame(vbox, _('Keys already approved for "%s"') % domain, '\n'.join(descriptions))

		label = left(translation.ngettext('This key signed the feed:', 'These keys signed the feed:', len(valid_sigs)))

		label.set_padding(4, 4)
		vbox.pack_start(label, False, True, 0)

		vbox.pack_start(notebook, True, True, 0)

		self.add_button(gtk.STOCK_HELP, gtk.RESPONSE_HELP)
		self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
		self.add_button(gtk.STOCK_ADD, gtk.RESPONSE_OK)
		self.set_default_response(gtk.RESPONSE_OK)

		trust_checkbox = {}	# Sig -> CheckButton
		def ok_sensitive():
			trust_any = False
			for toggle in trust_checkbox.values():
				if toggle.get_active():
					trust_any = True
					break
			self.set_response_sensitive(gtk.RESPONSE_OK, trust_any)

		first = True
		for sig in valid_sigs:
			if hasattr(sig, 'get_details'):
				name = '<unknown>'
				details = sig.get_details()
				for item in details:
					if item[0] == 'uid' and len(item) > 9:
						name = item[9]
						break
			else:
				name = None
			page = gtk.VBox(False, 4)
			page.set_border_width(8)

			frame(page, _('Fingerprint'), pretty_fp(sig.fingerprint))

			if name is not None:
				frame(page, _('Claimed identity'), name)

			frame(page, _('Unreliable hints database says'), make_hints_area(self.closed, valid_sigs[sig]))

			already_trusted = trust.trust_db.get_trust_domains(sig.fingerprint)
			if already_trusted:
				frame(page, _('You already trust this key for these domains'),
					'\n'.join(already_trusted))

			trust_checkbox[sig] = gtk.CheckButton(_('_Trust this key'))
			page.pack_start(trust_checkbox[sig], False, True, 0)
			trust_checkbox[sig].connect('toggled', lambda t: ok_sensitive())

			notebook.append_page(page, gtk.Label(name or 'Signature'))

			if first:
				trust_checkbox[sig].set_active(True)
				first = False

		ok_sensitive()
		self.vbox.show_all()

		if len(valid_sigs) == 1:
			for box in trust_checkbox.values():
				box.hide()

		def response(box, resp):
			if resp == gtk.RESPONSE_HELP:
				trust_help.display()
				return
			if resp == gtk.RESPONSE_OK:
				to_trust = [sig for sig in trust_checkbox if trust_checkbox[sig].get_active()]

				if not self._confirm_unknown_keys(to_trust, valid_sigs):
					return

				self.trust_keys(to_trust, domain)
			self.destroy()
		self.connect('response', response)