def main(): module = AnsibleModule( argument_spec = dict( state = dict(default='present', choices=['installed', 'latest', 'removed', 'absent', 'present', 'build-dep']), update_cache = dict(default=False, aliases=['update-cache'], type='bool'), cache_valid_time = dict(type='int'), purge = dict(default=False, type='bool'), package = dict(default=None, aliases=['pkg', 'name'], type='list'), deb = dict(default=None), default_release = dict(default=None, aliases=['default-release']), install_recommends = dict(default=None, aliases=['install-recommends'], type='bool'), force = dict(default='no', type='bool'), upgrade = dict(choices=['no', 'yes', 'safe', 'full', 'dist']), dpkg_options = dict(default=DPKG_OPTIONS), autoremove = dict(type='bool', default=False, aliases=['autoclean']) ), mutually_exclusive = [['package', 'upgrade', 'deb']], required_one_of = [['package', 'upgrade', 'update_cache', 'deb']], supports_check_mode = True ) module.run_command_environ_update = APT_ENV_VARS if not HAS_PYTHON_APT: try: module.run_command('apt-get update && apt-get install python-apt -y -q --force-yes', use_unsafe_shell=True, check_rc=True) global apt, apt_pkg import apt import apt.debfile import apt_pkg except ImportError: module.fail_json(msg="Could not import python modules: apt, apt_pkg. Please install python-apt package.") global APTITUDE_CMD APTITUDE_CMD = module.get_bin_path("aptitude", False) global APT_GET_CMD APT_GET_CMD = module.get_bin_path("apt-get") p = module.params if p['upgrade'] == 'no': p['upgrade'] = None if not APTITUDE_CMD and p.get('upgrade', None) in [ 'full', 'safe', 'yes' ]: module.fail_json(msg="Could not find aptitude. Please ensure it is installed.") updated_cache = False updated_cache_time = 0 install_recommends = p['install_recommends'] dpkg_options = expand_dpkg_options(p['dpkg_options']) autoremove = p['autoremove'] # Deal with deprecated aliases if p['state'] == 'installed': p['state'] = 'present' if p['state'] == 'removed': p['state'] = 'absent' try: cache = apt.Cache() if p['default_release']: try: apt_pkg.config['APT::Default-Release'] = p['default_release'] except AttributeError: apt_pkg.Config['APT::Default-Release'] = p['default_release'] # reopen cache w/ modified config cache.open(progress=None) if p['update_cache']: # Default is: always update the cache cache_valid = False now = datetime.datetime.now() if p.get('cache_valid_time', False): try: mtime = os.stat(APT_UPDATE_SUCCESS_STAMP_PATH).st_mtime except: # Looks like the update-success-stamp is not available # Fallback: Checking the mtime of the lists try: mtime = os.stat(APT_LISTS_PATH).st_mtime except: # No mtime could be read. We update the cache to be safe mtime = False if mtime: tdelta = datetime.timedelta(seconds=p['cache_valid_time']) mtimestamp = datetime.datetime.fromtimestamp(mtime) if mtimestamp + tdelta >= now: cache_valid = True updated_cache_time = int(time.mktime(mtimestamp.timetuple())) if cache_valid is not True: cache.update() cache.open(progress=None) updated_cache = True updated_cache_time = int(time.mktime(now.timetuple())) if not p['package'] and not p['upgrade'] and not p['deb']: module.exit_json(changed=False, cache_updated=updated_cache, cache_update_time=updated_cache_time) else: updated_cache = False updated_cache_time = 0 force_yes = p['force'] if p['upgrade']: upgrade(module, p['upgrade'], force_yes, p['default_release'], dpkg_options) if p['deb']: if p['state'] != 'present': module.fail_json(msg="deb only supports state=present") install_deb(module, p['deb'], cache, install_recommends=install_recommends, force=force_yes, dpkg_options=p['dpkg_options']) packages = p['package'] latest = p['state'] == 'latest' for package in packages: if package.count('=') > 1: module.fail_json(msg="invalid package spec: %s" % package) if latest and '=' in package: module.fail_json(msg='version number inconsistent with state=latest: %s' % package) if p['state'] in ('latest', 'present', 'build-dep'): state_upgrade = False state_builddep = False if p['state'] == 'latest': state_upgrade = True if p['state'] == 'build-dep': state_builddep = True result = install(module, packages, cache, upgrade=state_upgrade, default_release=p['default_release'], install_recommends=install_recommends, force=force_yes, dpkg_options=dpkg_options, build_dep=state_builddep, autoremove=autoremove) (success, retvals) = result retvals['cache_updated']=updated_cache retvals['cache_update_time']=updated_cache_time if success: module.exit_json(**retvals) else: module.fail_json(**retvals) elif p['state'] == 'absent': remove(module, packages, cache, p['purge'], dpkg_options, autoremove) except apt.cache.LockFailedException: module.fail_json(msg="Failed to lock apt for exclusive operation") except apt.cache.FetchFailedException: module.fail_json(msg="Could not fetch updated apt files")
def __init__(self): # Determine path to system locale-config self.locale_path='' if os.path.exists('/etc/default/locale'): self.locale_path='/etc/default/locale' else: self.locale_path='/etc/locale.conf' # Prepare the APT cache if IS_DEBIAN: self.cache = apt.Cache() self.cache_updated = False # load our glade ui file in self.builder = Gtk.Builder() self.builder.set_translation_domain("mintlocale") self.builder.add_from_file('/usr/share/linuxmint/mintlocale/mintlocale.ui') self.window = self.builder.get_object("main_window") self.window.set_title(_("Language Settings")) self.window.connect("destroy", Gtk.main_quit) XApp.set_window_icon_name(self.window, "preferences-desktop-locale") self.toolbar = Gtk.Toolbar() self.toolbar.get_style_context().add_class("primary-toolbar") self.builder.get_object("box1").pack_start(self.toolbar, False, False, 0) size_group = Gtk.SizeGroup.new(Gtk.SizeGroupMode.HORIZONTAL) self.locale_button = PictureChooserButton(num_cols=2, button_picture_size=BUTTON_FLAG_SIZE, has_button_label=True) size_group.add_widget(self.locale_button) self.region_button = PictureChooserButton(num_cols=2, button_picture_size=BUTTON_FLAG_SIZE, has_button_label=True) size_group.add_widget(self.region_button) self.locale_system_wide_button = Gtk.Button() self.locale_system_wide_button.set_label(_("Apply System-Wide")) self.locale_system_wide_button.connect("clicked", self.button_system_language_clicked) size_group.add_widget(self.locale_system_wide_button) self.locale_install_button = Gtk.Button() self.locale_install_button.set_label(_("Install / Remove Languages...")) self.locale_install_button.connect("clicked", self.button_install_remove_clicked) size_group.add_widget(self.locale_install_button) self.system_label = Gtk.Label() self.install_label = Gtk.Label() page = SettingsPage() self.builder.get_object("box1").pack_start(page, True, True, 0) language_settings = page.add_section() label = Gtk.Label.new() label.set_markup("<b>%s</b>\n<small>%s</small>" % (_("Language"), _("Language, interface, date and time..."))) row = SettingsRow(label, self.locale_button) language_settings.add_row(row) label = Gtk.Label.new() label.set_markup("<b>%s</b>\n<small>%s</small>" % (_("Region"), _("Numbers, currency, addresses, measurement..."))) row = SettingsRow(label, self.region_button) language_settings.add_row(row) self.system_row = SettingsRow(self.system_label, self.locale_system_wide_button) self.system_row.set_no_show_all(True) language_settings.add_row(self.system_row) self.install_row = SettingsRow(self.install_label, self.locale_install_button) self.install_row.set_no_show_all(True) if IS_DEBIAN: language_settings.add_row(self.install_row) self.pam_environment_path = os.path.join(GLib.get_home_dir(), ".pam_environment") self.dmrc_path = os.path.join(GLib.get_home_dir(), ".dmrc") self.dmrc = configparser.ConfigParser() self.dmrc.optionxform = str # force case sensitivity on ConfigParser self.dmrc.read(self.dmrc_path) if not self.dmrc.has_section('Desktop'): self.dmrc.add_section('Desktop') current_user = GLib.get_user_name() self.current_language = None dmrc_language = None env_language = os.environ['LANG'] if self.dmrc.has_option('Desktop', 'Language'): dmrc_language = self.dmrc.get('Desktop', 'Language') if dmrc_language is not None: self.current_language = dmrc_language else: self.current_language = env_language print("User language in .dmrc: %s" % dmrc_language) print("User language in $LANG: %s" % env_language) print("Current language: %s" % self.current_language) if 'LC_NUMERIC' in os.environ: self.current_region = os.environ['LC_NUMERIC'] else: self.current_region = self.current_language if os.path.exists(self.pam_environment_path): with codecs.open(self.pam_environment_path, 'r', encoding='UTF-8') as pam_file: for line in pam_file: line = line.strip() if line.startswith("LC_NUMERIC="): self.current_region = line.split("=")[1].replace("\"", "").replace("'", "").strip() print("Current region: %s" % self.current_region) # Replace utf8 with UTF-8 (lightDM GTK greeter messes that up) self.current_language = self.current_language.replace(".utf8", ".UTF-8") self.current_region = self.current_region.replace(".utf8", ".UTF-8") self.build_lang_list() self.set_system_locale() self.set_num_installed() self.accountService = AccountsService.UserManager.get_default().get_user(current_user) self.accountService.connect('notify::is-loaded', self.accountservice_ready) self.accountService.connect('changed::', self.accountservice_changed) groups = grp.getgrall() for group in groups: (name, pw, gid, mem) = group if name in ("adm", "sudo", "wheel", "root"): for user in mem: if current_user == user: self.system_row.set_no_show_all(False) self.install_row.set_no_show_all(False) language_settings.show_all() break self.window.show_all()
def _setupVNC(): libjpeg_ver = "2.0.3" virtualGL_ver = "2.6.2" turboVNC_ver = "2.2.3" libjpeg_url = "https://svwh.dl.sourceforge.net/project/libjpeg-turbo/{0}/libjpeg-turbo-official_{0}_amd64.deb".format(libjpeg_ver) virtualGL_url = "https://svwh.dl.sourceforge.net/project/virtualgl/{0}/virtualgl_{0}_amd64.deb".format(virtualGL_ver) turboVNC_url = "https://svwh.dl.sourceforge.net/project/turbovnc/{0}/turbovnc_{0}_amd64.deb".format(turboVNC_ver) _download(libjpeg_url, "libjpeg-turbo.deb") _download(virtualGL_url, "virtualgl.deb") _download(turboVNC_url, "turbovnc.deb") cache = apt.Cache() apt.debfile.DebPackage("libjpeg-turbo.deb", cache).install() apt.debfile.DebPackage("virtualgl.deb", cache).install() apt.debfile.DebPackage("turbovnc.deb", cache).install() _installPkgs(cache, "xfce4", "xfce4-terminal") cache.commit() vnc_sec_conf_p = pathlib.Path("/etc/turbovncserver-security.conf") vnc_sec_conf_p.write_text("""\ no-remote-connections no-httpd no-x11-tcp-connections """) # Install TESLA DRIVER FOR LINUX X64 ver418.67. # Kernel module in this driver is already loaded and cannot be neither removed nor updated. # (nvidia, nvidia_uvm, nvidia_drm. See dmesg) # Existing nvidia driver for Xorg is newer than these kernel module and cannot be used with Xorg. # So overwrite them with the nvidia driver that is same version to loaded kernel module. _download("http://us.download.nvidia.com/tesla/418.67/NVIDIA-Linux-x86_64-418.67.run", "nvidia.run") pathlib.Path("nvidia.run").chmod(stat.S_IXUSR) subprocess.run(["./nvidia.run", "--no-kernel-module", "--ui=none"], input = "1\n", check = True, universal_newlines = True) #https://virtualgl.org/Documentation/HeadlessNV subprocess.run(["nvidia-xconfig", "-a", "--allow-empty-initial-configuration", "--virtual=1920x1200", "--busid", "PCI:0:4:0"], check = True ) with open("/etc/X11/xorg.conf", "r") as f: conf = f.read() conf = re.sub('(Section "Device".*?)(EndSection)', '\\1 MatchSeat "seat-1"\n\\2', conf, 1, re.DOTALL) # conf = conf + """ #Section "Files" # ModulePath "/usr/lib/xorg/modules" # ModulePath "/usr/lib/x86_64-linux-gnu/nvidia-418/xorg/" #EndSection #""" with open("/etc/X11/xorg.conf", "w") as f: f.write(conf) #!service lightdm stop subprocess.run(["/opt/VirtualGL/bin/vglserver_config", "-config", "+s", "+f"], check = True) #user_name = "colab" #!usermod -a -G vglusers $user_name #!service lightdm start # Run Xorg server # VirtualGL and OpenGL application require Xorg running with nvidia driver to get Hardware 3D Acceleration. # # Without "-seat seat-1" option, Xorg try to open /dev/tty0 but it doesn't exists. # You can create /dev/tty0 with "mknod /dev/tty0 c 4 0" but you will get permision denied error. subprocess.Popen(["Xorg", "-seat", "seat-1", "-allowMouseOpenFail", "-novtswitch", "-nolisten", "tcp"]) vncrun_py = pathlib.Path("vncrun.py") vncrun_py.write_text("""\ import subprocess, secrets, pathlib vnc_passwd = secrets.token_urlsafe()[:8] vnc_viewonly_passwd = secrets.token_urlsafe()[:8] print("✂️"*24) print("VNC password: {}".format(vnc_passwd)) print("VNC view only password: {}".format(vnc_viewonly_passwd)) print("✂️"*24) vncpasswd_input = "{0}\\n{1}".format(vnc_passwd, vnc_viewonly_passwd) vnc_user_dir = pathlib.Path.home().joinpath(".vnc") vnc_user_dir.mkdir(exist_ok=True) vnc_user_passwd = vnc_user_dir.joinpath("passwd") with vnc_user_passwd.open('wb') as f: subprocess.run( ["/opt/TurboVNC/bin/vncpasswd", "-f"], stdout=f, input=vncpasswd_input, universal_newlines=True) vnc_user_passwd.chmod(0o600) subprocess.run( ["/opt/TurboVNC/bin/vncserver"] ) #Disable screensaver because no one would want it. (pathlib.Path.home() / ".xscreensaver").write_text("mode: off\\n") """) r = subprocess.run( ["su", "-c", "python3 vncrun.py", "colab"], check = True, stdout = subprocess.PIPE, universal_newlines = True) print(r.stdout)
def __init__(self): builder = Gtk.Builder() builder.set_translation_domain("mintwelcome") builder.add_from_file( '/usr/share/linuxmint/mintwelcome/mintwelcome.ui') window = builder.get_object("main_window") window.set_icon_name("mintwelcome") window.set_position(Gtk.WindowPosition.CENTER) window.connect("destroy", Gtk.main_quit) with open("/etc/hamonikr/info") as f: config = dict([line.strip().split("=") for line in f]) codename = config['CODENAME'].capitalize() edition = config['EDITION'].replace('"', '') release = config['RELEASE'] desktop = config['DESKTOP'] release_notes = config['RELEASE_NOTES_URL'] new_features = config['NEW_FEATURES_URL'] architecture = "64-bit" if platform.machine() != "x86_64": architecture = "32-bit" # distro-specific with open("/etc/lsb-release") as f: config = dict([line.strip().split("=") for line in f]) dist_name = config['DISTRIB_ID'] if os.path.exists( "/usr/share/doc/debian-system-adjustments/copyright"): dist_name = "LMDE" # Setup the labels in the Mint badge builder.get_object("label_version").set_text("%s %s" % (dist_name, release)) builder.get_object("label_edition").set_text("%s %s" % (edition, architecture)) # Setup the main stack self.stack = Gtk.Stack() builder.get_object("center_box").pack_start(self.stack, True, True, 0) self.stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE) self.stack.set_transition_duration(150) # Action buttons builder.get_object("button_forums").connect("clicked", self.visit, "https://hamonikr.org") # builder.get_object("button_documentation").connect("clicked", self.visit, "https://hamonikr.org/board_manual") builder.get_object("button_contribute").connect( "clicked", self.visit, "https://github.com/hamonikr") builder.get_object("button_irc").connect( "clicked", self.visit, "https://hamonikr.org/how_join") builder.get_object("button_codecs").connect( "clicked", self.visit, "apt://mint-meta-codecs?refresh=yes") builder.get_object("button_new_features").connect( "clicked", self.visit, "https://docs.hamonikr.org/new-features/") builder.get_object("button_release_notes").connect( "clicked", self.visit, "https://docs.hamonikr.org/release-note/") builder.get_object("button_mintupdate").connect( "clicked", self.launch, "mintupdate") builder.get_object("button_mintinstall").connect( "clicked", self.launch, "mintinstall") builder.get_object("button_timeshift").connect("clicked", self.pkexec, "timeshift-gtk") builder.get_object("button_mintdrivers").connect( "clicked", self.pkexec, "driver-manager") builder.get_object("button_gufw").connect("clicked", self.launch, "gufw") builder.get_object("button_layout_legacy").connect( "clicked", self.on_button_layout_clicked, LAYOUT_STYLE_LEGACY) builder.get_object("button_layout_new").connect( "clicked", self.on_button_layout_clicked, LAYOUT_STYLE_NEW) # custom new features builder.get_object("button_license").connect( "clicked", self.visit, "http://pms.invesume.com:8090/hl/os/5-0") # custom recommended software builder.get_object("button_hancom").connect("clicked", self.launch, "hoffice-support") builder.get_object("button_site_compatibility_support").connect( "clicked", self.launch, "site-compatibility-support") builder.get_object("button_kakaotalk").connect("clicked", self.launch, "kakaotalk-install") builder.get_object("button_hamonikr_drive").connect( "clicked", self.visit, "https://drive.hamonikr.org/") builder.get_object("button_lutris").connect( "clicked", self.on_button_lutris_clicked) builder.get_object("button_kodi").connect("clicked", self.on_button_kodi_clicked) builder.get_object("button_korean_language").connect( "clicked", self.on_button_korean_language) ### ---------- development software start ---------- ### # Editor # builder.get_object("button_vscode").connect("clicked", self.visit, "apt://code?refresh=yes") builder.get_object("button_vscode").connect( "clicked", self.on_button_vscode_clicked) # DBMS builder.get_object("button_mysql_server").connect( "clicked", self.visit, "apt://mysql-server?refresh=yes") builder.get_object("button_postgresql").connect( "clicked", self.visit, "apt://postgresql?refresh=yes") # WEB/WAS builder.get_object("button_apache").connect( "clicked", self.visit, "apt://apache2?refresh=yes") builder.get_object("button_tomcat").connect( "clicked", self.visit, "apt://tomcat9?refresh=yes") # Development Language builder.get_object("button_default_jdk").connect( "clicked", self.visit, "apt://default-jdk?refresh=yes") builder.get_object("button_python_pip").connect( "clicked", self.visit, "apt://python3-pip?refresh=yes") # Etc... builder.get_object("button_asbru").connect( "clicked", self.visit, "apt://asbru-cm?refresh=yes") builder.get_object("button_git").connect("clicked", self.visit, "apt://git?refresh=yes") builder.get_object("button_rabbitvcs").connect( "clicked", self.visit, "apt://hamonikr-nemo-rabbitvcs?refresh=yes") builder.get_object("button_avahi").connect( "clicked", self.visit, "apt://hamonikr-avahi-service?refresh=yes") ### ---------- development software end ---------- ### # custom help builder.get_object("button_help").connect( "clicked", self.visit, "https://docs.hamonikr.org/hamonikr-5.0") builder.get_object("button_shortcut").connect("clicked", self.launch, "conky-shortcut-on-off") # builder.get_object("button_ventoy").connect("clicked", self.visit, "apt://ventoy?refresh=yes") # builder.get_object("button_systemback").connect("clicked", self.visit, "apt://systemback?refresh=yes") # builder.get_object("button_live_usb_creator").connect("clicked", self.visit, "apt://live-usb-creator?refresh=yes") # builder.get_object("button_hamonikr_cli_tools").connect("clicked", self.visit, "apt://hamonikr-cli-tools?refresh=yes") # Settings button depends on DE de_is_cinnamon = False self.theme = None if os.getenv("XDG_CURRENT_DESKTOP") in ["Cinnamon", "X-Cinnamon"]: builder.get_object("button_settings").connect( "clicked", self.launch, "cinnamon-settings") de_is_cinnamon = True self.theme = Gio.Settings(schema="org.cinnamon.desktop.interface" ).get_string("gtk-theme") elif os.getenv("XDG_CURRENT_DESKTOP") == "MATE": builder.get_object("button_settings").connect( "clicked", self.launch, "mate-control-center") elif os.getenv("XDG_CURRENT_DESKTOP") == "XFCE": builder.get_object("button_settings").connect( "clicked", self.launch, "xfce4-settings-manager") else: # Hide settings builder.get_object("box_first_steps").remove( builder.get_object("box_settings")) # Hide Desktop colors builder.get_object("box_first_steps").remove( builder.get_object("box_colors")) # Hide Cinnamon layout settings in other DEs if not de_is_cinnamon: builder.get_object("box_first_steps").remove( builder.get_object("box_cinnamon")) # Hide codecs box if they're already installed add_codecs = False cache = apt.Cache() if "mint-meta-codecs" in cache: pkg = cache["mint-meta-codecs"] if not pkg.is_installed: add_codecs = True if not add_codecs: builder.get_object("box_first_steps").remove( builder.get_object("box_codecs")) # Hide drivers if mintdrivers is absent (LMDE) if not os.path.exists("/usr/bin/mintdrivers"): builder.get_object("box_first_steps").remove( builder.get_object("box_drivers")) # Hide new features page for LMDE if dist_name == "LMDE": builder.get_object("box_documentation").remove( builder.get_object("box_new_features")) # Construct the stack switcher list_box = builder.get_object("list_navigation") page = builder.get_object("page_home") self.stack.add_named(page, "page_home") list_box.add(SidebarRow(page, _("Welcome"), "go-home-symbolic")) self.stack.set_visible_child(page) page = builder.get_object("page_first_steps") self.stack.add_named(page, "page_first_steps") list_box.add( SidebarRow(page, _("HamoniKR Settings"), "dialog-information-symbolic")) page = builder.get_object("page_second_steps") self.stack.add_named(page, "page_second_steps") list_box.add( SidebarRow(page, _("Recommended Program"), "dialog-information-symbolic")) page = builder.get_object("page_third_steps") self.stack.add_named(page, "page_third_steps") list_box.add( SidebarRow(page, _("Development Program"), "dialog-information-symbolic")) page = builder.get_object("page_help") self.stack.add_named(page, "page_help") list_box.add(SidebarRow(page, _("Help"), "help-browser-symbolic")) page = builder.get_object("page_new_feature") self.stack.add_named(page, "page_new_feature") list_box.add( SidebarRow(page, _("HamoniKR Information"), "accessories-dictionary-symbolic")) list_box.connect("row-activated", self.sidebar_row_selected_cb) # Construct the bottom toolbar box = builder.get_object("toolbar_bottom") checkbox = Gtk.CheckButton() checkbox.set_label(_("Show this dialog at startup")) if not os.path.exists(NORUN_FLAG): checkbox.set_active(True) checkbox.connect("toggled", self.on_button_toggled) box.pack_end(checkbox) scale = window.get_scale_factor() self.color = "green" self.dark_mode = False # Use HIDPI pictures if appropriate if scale == 1: surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/hamonikr_legacy.png", scale) builder.get_object("img_legacy").set_from_surface(surface) surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/hamonikr_modern.png", scale) builder.get_object("img_modern").set_from_surface(surface) else: surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/hamonikr_legacy.png", scale) builder.get_object("img_legacy").set_from_surface(surface) surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/hamonikr_modern.png", scale) builder.get_object("img_modern").set_from_surface(surface) path = "/usr/share/linuxmint/mintwelcome/colors/" if scale == 2: path = "/usr/share/linuxmint/mintwelcome/colors/hidpi/" for color in [ "green", "aqua", "blue", "brown", "grey", "orange", "pink", "purple", "red", "sand", "teal" ]: builder.get_object("img_" + color).set_from_surface( self.surface_for_path("%s/%s.png" % (path, color), scale)) builder.get_object("button_" + color).connect( "clicked", self.on_color_button_clicked, color) builder.get_object("switch_dark").connect("state-set", self.on_dark_mode_changed) window.set_default_size(800, 500) window.show_all()
import gi import subprocess import sys import threading import getpass import time if len(sys.argv) == 1 or len(sys.argv) > 4: print("Invalid number of arguments") exit() gi.require_version('Gtk', '3.0') from gi.repository import Gtk, Pango, Gdk, GdkPixbuf import apt cache = apt.Cache() class init(): stepsdone = "" def __init__(self): self.builder = Gtk.Builder() self.builder.add_from_file('/usr/lib/feren-majorupdate/gui.glade') self.win = self.builder.get_object('mainwind') self.win.connect('delete-event', Gtk.main_quit) self.pagestack = self.builder.get_object('stack1') #PangoFont = Pango.FontDescription("Tahoma 12") #self.win.modify_font(PangoFont)
def main(): module = AnsibleModule( argument_spec=dict( repo=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), mode=dict(required=False, type='raw'), update_cache = dict(aliases=['update-cache'], type='bool', default='yes'), filename=dict(required=False, default=None), # this should not be needed, but exists as a failsafe install_python_apt=dict(required=False, default="yes", type='bool'), validate_certs = dict(default='yes', type='bool'), codename = dict(required=False), ), supports_check_mode=True, ) params = module.params repo = module.params['repo'] state = module.params['state'] update_cache = module.params['update_cache'] # Note: mode is referenced in SourcesList class via the passed in module (self here) sourceslist = None if not HAVE_PYTHON_APT: if params['install_python_apt']: install_python_apt(module) else: module.fail_json(msg='%s is not installed, and install_python_apt is False' % PYTHON_APT) if isinstance(distro, aptsources_distro.Distribution): sourceslist = UbuntuSourcesList(module, add_ppa_signing_keys_callback=get_add_ppa_signing_key_callback(module)) else: module.fail_json(msg='Module apt_repository is not supported on target.') sources_before = sourceslist.dump() try: if state == 'present': sourceslist.add_source(repo) elif state == 'absent': sourceslist.remove_source(repo) except InvalidSource: err = get_exception() module.fail_json(msg='Invalid repository string: %s' % unicode(err)) sources_after = sourceslist.dump() changed = sources_before != sources_after if changed and module._diff: diff = [] for filename in set(sources_before.keys()).union(sources_after.keys()): diff.append({'before': sources_before.get(filename, ''), 'after': sources_after.get(filename, ''), 'before_header': (filename, '/dev/null')[filename not in sources_before], 'after_header': (filename, '/dev/null')[filename not in sources_after]}) else: diff = {} if changed and not module.check_mode: try: sourceslist.save() if update_cache: cache = apt.Cache() cache.update() except OSError: err = get_exception() module.fail_json(msg=unicode(err)) module.exit_json(changed=changed, repo=repo, state=state, diff=diff)
import apt import apt_pkg import os.path if __name__ == "__main__": apt_pkg.Config.Set("APT::Update::Pre-Invoke::", "touch /tmp/update-about-to-run") apt_pkg.Config.Set("APT::Update::Post-Invoke::", "touch /tmp/update-was-run") c = apt.Cache() res = c.update(apt.progress.TextFetchProgress()) print "res: ", res assert (os.path.exists("/tmp/update-about-to-run"))
def __init__(self, dbus_service): self.dbus_service = dbus_service locale.setlocale(locale.LC_ALL, "zh_CN.UTF-8") self.cache = apt.Cache()
def package_versions(): def kernelDict(): ret = os.uname() try: ver, rel = ret[2].split('-', 1) except ValueError: logging.error('kernel release not found', exc_info=True) ver, rel = '0', '0' try: t = ret[3].split()[2:] del t[4] # Delete timezone t = time.mktime(time.strptime(' '.join(t))) except ValueError: logging.error('kernel build time not found', exc_info=True) t = '0' return dict(version=ver, release=rel, buildtime=t) pkgs = {'kernel': kernelDict()} if _release_name() in (OSName.RHEVH, OSName.OVIRT, OSName.FEDORA, OSName.RHEL, OSName.POWERKVM): KEY_PACKAGES = { 'glusterfs-cli': ('glusterfs-cli', ), 'librbd1': ('librbd1', ), 'libvirt': ('libvirt', 'libvirt-daemon-kvm'), 'mom': ('mom', ), 'qemu-img': ('qemu-img', 'qemu-img-rhev', 'qemu-img-ev'), 'qemu-kvm': ('qemu-kvm', 'qemu-kvm-rhev', 'qemu-kvm-ev'), 'spice-server': ('spice-server', ), 'vdsm': ('vdsm', ), } if glusterEnabled: KEY_PACKAGES.update(GLUSTER_RPM_PACKAGES) try: ts = rpm.TransactionSet() for pkg, names in KEY_PACKAGES.iteritems(): try: mi = itertools.chain( *[ts.dbMatch('name', name) for name in names]).next() except StopIteration: logging.debug("rpm package %s not found", KEY_PACKAGES[pkg]) else: pkgs[pkg] = { 'version': mi['version'], 'release': mi['release'], 'buildtime': mi['buildtime'], } except Exception: logging.error('', exc_info=True) elif _release_name() == OSName.DEBIAN and python_apt: KEY_PACKAGES = { 'glusterfs-cli': 'glusterfs-cli', 'librbd1': 'librbd1', 'libvirt': 'libvirt0', 'mom': 'mom', 'qemu-img': 'qemu-utils', 'qemu-kvm': 'qemu-kvm', 'spice-server': 'libspice-server1', 'vdsm': 'vdsmd', } if glusterEnabled: KEY_PACKAGES.update(GLUSTER_DEB_PACKAGES) cache = apt.Cache() for pkg in KEY_PACKAGES: try: deb_pkg = KEY_PACKAGES[pkg] ver = cache[deb_pkg].installed.version # Debian just offers a version pkgs[pkg] = dict(version=ver, release="", buildtime="") except Exception: logging.error('', exc_info=True) return pkgs
#!/usr/bin/env python3 import apt import re best_golang = None for p in apt.Cache(): if re.match(r"golang-([0-9.]+)$", p.name): if ( best_golang is None or apt.apt_pkg.version_compare( best_golang.candidate.version, p.candidate.version ) < 0 ): best_golang = p print(best_golang.name)
def install(self, name): session = Prompt( placeholder=Text("<grey>(please type something</grey>")) package_name = self.data[name]["package_name"] package_manager = self.data[name]["package_manager"] url = self.data[name]["url"] req = list(self.data[name]["dependency"]) system = sys() if system.connection(): if len(req) != 0 and req[0] != None: for dep in req: if os.path.exists(system.bin + "/" + dep): pass else: if system.sudo != None: os.system(system.sudo + " " + system.pac + " install " + dep + " -y") else: os.system(system.pac + " install " + dep + " -y") if package_manager == "package_manager": if os.path.exists(system.bin + "/" + package_name): clear() logo.already_installed(name) tmp = session.prompt("$» ") else: if system.sudo != None: os.system(system.sudo + " " + system.pac + " install " + package_name + " -y") else: os.system(system.pac + " install " + package_name + " -y") # check tool is installed or not if os.path.exists(system.bin + "/" + package_name): clear() logo.installed(name) tmp = session.prompt("$» ") else: clear() logo.not_installed(name) tmp = session.prompt("$» ") elif package_manager == "git": if os.path.exists(system.home + "/" + package_name): clear() logo.already_installed(name) tmp = session.prompt("$» ") else: if system.sudo != None: os.system(system.sudo + " git clone " + url + " " + system.home + "/" + package_name) else: os.system("git clone " + url + " " + system.home + "/" + package_name) # check tool is installed or not if os.path.exists(system.home + "/" + package_name): clear() logo.installed(name) tmp = session.prompt("$» ") else: clear() logo.not_installed(name) tmp = session.prompt("$» ") elif package_manager == "wget": if os.path.exists(system.home + "/" + package_name): clear() logo.already_installed(name) tmp = session.prompt("$» ") else: if system.sudo != None: os.system(system.sudo + " wget " + url + " -o " + system.home + "/" + package_name) else: os.system("wget " + url + " -o " + system.home + "/" + package_name) # check tool is installed or not if os.path.exists(system.home + "/" + package_name): clear() logo.installed(name) tmp = session.prompt("$» ") else: clear() logo.not_installed(name) tmp = session.prompt("$» ") elif package_manager == "curl": if os.path.exists(system.home + "/" + package_name): clear() logo.already_installed(name) tmp = session.prompt("$» ") else: if system.sudo != None: os.system(system.sudo + " curl " + url + " -o " + system.home + "/" + package_name) else: os.system("curl " + url + " -o " + system.home + "/" + package_name) # check tool is installed or not if os.path.exists(system.home + "/" + package_name): clear() logo.installed(name) tmp = session.prompt("$» ") else: clear() logo.not_installed(name) tmp = session.prompt("$» ") if package_manager == "apt": import apt cache = apt.Cache() if cache[package_name].is_installed: clear() logo.already_installed(name) tmp = session.prompt("$» ") else: os.system("sudo apt install " + package_name) # if os.path.exists(system.home+"/"+package_name): # clear() # logo.already_installed(name) # tmp=session.prompt("$» ") # else: # if system.sudo != None: # print("dddd") # os.system(system.sudo+" apt " + package_name) else: clear() logo.nonet() tmp = session.prompt("$» ")
def run(self): global steps global progressbar global wTree global packages global user global home wTree.get_widget("main_button").hide() wTree.get_widget("cancel_button").set_label("gtk-cancel") wTree.get_widget("cancel_button").set_use_stock(True) totalSteps = steps if (self.rightRepositories != "local"): progressbar.set_text(_("Backing up your APT sources")) self.execute( "mv /etc/apt/sources.list /etc/apt/sources.list.swmbackup") self.execute( "cp /usr/share/solydxk/softwaremanager/sources.list /etc/apt/sources.list" ) cache = apt.Cache() os.system("apt-get update") totalSteps = steps + 2 fraction = 0 progressbar.set_fraction(fraction) for i in range(steps + 1): if (i > 0): openfile = open( "/usr/lib/solydxk/softwaremanager/tmp/steps/" + str(i), 'r') datalist = openfile.readlines() for j in range(len(datalist)): if (str.find(datalist[j], "TITLE") > -1): title = datalist[j][6:] progressbar.set_text(str.strip(title)) if (str.find(datalist[j], "INSTALL") > -1): install = datalist[j][8:] install = str.strip(install) installPackages = string.split(install) cmd = [ "sudo", "/usr/sbin/synaptic", "--hide-main-window", "--non-interactive", "--parent-window-id", self.window_id ] cmd.append("--progress-str") cmd.append("\"" + _("Please wait, this can take some time") + "\"") cmd.append("--finish-str") cmd.append("\"" + _("Installation is complete") + "\"") f = tempfile.NamedTemporaryFile() for pkg in installPackages: f.write("%s\tinstall\n" % pkg) cmd.append("--set-selections-file") cmd.append("%s" % f.name) f.flush() comnd = Popen(' '.join(cmd), shell=True) returnCode = comnd.wait() f.close() if (str.find(datalist[j], "SOURCE") > -1): source = datalist[j][7:] source = source.rstrip() self.execute("echo \"" + source + "\" >> /etc/apt/sources.list") os.system("apt-get update") if (str.find(datalist[j], "EXECUTE") > -1): execution = datalist[j][8:] execution = execution.rstrip() execution = execution.replace("<<USER>>", user) execution = execution.replace("<<HOME>>", home) self.execute(execution) fraction = float(i) / float(totalSteps) progressbar.set_fraction(fraction) if (self.rightRepositories != "local"): progressbar.set_text(_("Restoring your APT sources")) self.execute( "mv /etc/apt/sources.list.swmbackup /etc/apt/sources.list") os.system("apt-get update") progressbar.set_fraction(1) progressbar.set_text(_("Finished")) wTree.get_widget("main_button").hide() wTree.get_widget("cancel_button").set_label(_("Close")) #Everything is done, exit quietly gtk.main_quit() sys.exit(0)
def __init__(self, solydxkFile, user, home): global steps global progressbar global wTree global installation_terminal global installation_progressbar global download_progressbar global packages self.swmFile = solydxkFile self.user = user self.home = home #Make tmp folder os.system("mkdir -p /usr/lib/solydxk/softwaremanager/tmp") #Clean tmp files os.system("rm -rf /usr/lib/solydxk/softwaremanager/tmp/*") #Decompress file os.system("cp " + solydxkFile + " /usr/lib/solydxk/softwaremanager/tmp/file.swm") os.system( "tar xf /usr/lib/solydxk/softwaremanager/tmp/file.swm -C /usr/lib/solydxk/softwaremanager/tmp/" ) #Try without gzip os.system( "tar zxf /usr/lib/solydxk/softwaremanager/tmp/file.swm -C /usr/lib/solydxk/softwaremanager/tmp/" ) #Try with gzip #Extract the name self.name = commands.getoutput( "cat /usr/lib/solydxk/softwaremanager/tmp/name") self.name = str.strip(self.name) #Extract the number of steps steps = int( commands.getoutput( "ls -l /usr/lib/solydxk/softwaremanager/tmp/steps/ | wc -l")) steps = steps - 1 self.pulse = 1 / steps #Initialize APT cache = apt.Cache() #Extract repositories and packages self.repositories = [] packages = [] for i in range(steps + 1): if (i > 0): openfile = open( "/usr/lib/solydxk/softwaremanager/tmp/steps/" + str(i), 'r') datalist = openfile.readlines() for j in range(len(datalist)): if (str.find(datalist[j], "INSTALL") > -1): install = datalist[j][8:] install = str.strip(install) packages.append(install) if (str.find(datalist[j], "SOURCE") > -1): source = datalist[j][7:] source = source.rstrip() self.repositories.append(source) #openfile.close() #Set the Glade file self.gladefile = "/usr/share/solydxk/softwaremanager/softwaremanager-args.glade" wTree = gtk.glade.XML(self.gladefile, "main_window") wTree.get_widget("main_window").set_icon_from_file( "/usr/share/solydxk/softwaremanager/icon.svg") wTree.get_widget("main_window").set_title("") wTree.get_widget("main_window").connect("destroy", self.giveUp) # Get the window socket (needed for synaptic later on) vbox = wTree.get_widget("vbox1") socket = gtk.Socket() vbox.pack_start(socket) socket.show() window_id = repr(socket.get_id()) wTree.get_widget("label_repositories").set_text( _("Using the following repositories:")) #Fill in the GUI with information from the solydxkFile wTree.get_widget("main_button_label").set_text(_("Install")) wTree.get_widget("txt_name").set_text("<big><b>" + _("Install %s?") % (self.name) + "</b></big>") wTree.get_widget("txt_name").set_use_markup(True) wTree.get_widget("txt_guidance").set_text( _("The following packages will be installed:")) if (len(self.repositories) == 0): treeview = wTree.get_widget("tree_repositories") column1 = gtk.TreeViewColumn() renderer = gtk.CellRendererText() column1.pack_start(renderer, False) column1.set_attributes(renderer, text=0) treeview.append_column(column1) treeview.set_headers_visible(False) model = gtk.ListStore(str) model.append([_("Default repositories")]) treeview.set_model(model) wTree.get_widget("label_repositories").hide() wTree.get_widget("scrolledwindow_repositories").hide() treeview = wTree.get_widget("tree_packages") column1 = gtk.TreeViewColumn() renderer = gtk.CellRendererText() column1.pack_start(renderer, False) column1.set_attributes(renderer, text=0) treeview.append_column(column1) treeview.set_headers_visible(False) model = gtk.ListStore(str) for package in packages: strPackage = package try: pkg = cache[package] strPackage = str( package) + " [" + pkg.candidateVersion + "]" for dep in pkg.candidateDependencies: for o in dep.or_dependencies: dependency = cache[o.name] if not dependency.is_installed: strDependency = dependency.name + " [" + dependency.candidateVersion + "]" model.append([strDependency]) except Exception, detail: print detail pass model.append([strPackage]) treeview.set_model(model) treeview.show()
def main(): """ Run the BYOB setup script """ import os import sys import logging import subprocess # debugging logging.basicConfig(level=logging.DEBUG, handlers=[logging.StreamHandler()]) logger = logging.getLogger(__name__) #urllib vomit if sys.version_info[0] > 2: from urllib.request import urlopen # for mainstream linux kernel we need to get opencv from the repo, else it must be compiled from source; # this, to prevent a segfault at runtime for resources loading cv2 package in python3 if os.name != "nt": try: import apt aptcache = apt.Cache() if not aptcache['python3-opencv'].is_installed: logger.error('Install python3-opencv before continuing:\n\n sudo apt install python3-opencv\n') sys.exit() except: #assuming then we're rhel based try: import yum yumapp = yum.YumBase() rpmdb = yumapp.doPackageLists(patterns="python3-opencv") if not rpmdb.installed: logger.error('Install python3-opencv before continuing:\n\n sudo yum install python3-opencv\n') sys.exit() except: logger.error('Unable to determine if python3-opencv is installed; continuing anyway.\n If you get a cv2 import error, install python3-opencv') else: from urllib import urlopen # find pip try: pip_path = subprocess.check_output('where pip' if os.name == 'nt' else 'which pip', shell=True).strip().rstrip() except Exception as e: logger.debug("Error in pip package installer: {}".format(str(e))) # install pip if missing try: import pip except: if not bool('pip_path' in locals() and os.path.exists(pip_path)) and os.name != "nt": try: # NOTE: intrct -- I think this is a bad practice (instituting execution of arbitrary remote code we don't control). if os.getuid() != 0: # intrct: added this exit because otherwise this just runs in an infinite loop; I still think it's a bad idea. logger.error("pip is not installed or a module, so setup must run elevated (sudo)") sys.exit() # intrct: added check for version for proper callout materials, and # running as subprocess rather than internal due to potential early exits in remote code. if sys.version_info[0] > 2: subprocess.check_call("""{} -c 'from urllib.request import urlopen; exec(urlopen("https://bootstrap.pypa.io/get-pip.py").read())'""".format(sys.executable), shell=True) else: subprocess.check_call("""{} -c 'from urllib import urlopen; exec(urlopen("https://bootstrap.pypa.io/get-pip.py").read())'""".format(sys.executable), shell=True) except Exception as e: logger.debug("Error installing pip: {}".format(str(e))) # restart # intrct: I would like to point out a limitation that this only installs packages for the linked "python" # and not the called version of python in the original runtime. os.execv(sys.executable, ['python'] + [os.path.abspath(sys.argv[0])] + sys.argv[1:]) # find requirements for tree in os.walk('..'): if 'byob' not in tree[0]: continue elif 'requirements.txt' in tree[2]: requirements = os.path.join(tree[0], 'requirements.txt') break # install requirements try: print("Installing requirements.txt") if os.name != "nt": locals()['pip_install_1'] = subprocess.Popen('sudo --prompt=" Please enter sudo password (to install python dependencies): " {} -m pip install -r {}'.format(sys.executable, requirements), 0, None, subprocess.PIPE, subprocess.PIPE, subprocess.PIPE, shell=True) else: locals()['pip_install_1'] = subprocess.Popen('{} -m pip install -r {}'.format(sys.executable, requirements), 0, None, subprocess.PIPE, subprocess.PIPE, subprocess.PIPE, shell=True) for line in locals()['pip_install_1'].stdout: print(line.decode()) sys.stdout.flush() except Exception as e: logger.error("Error installing requirements: {}".format(e))
def setUp(self): self.ml_data = MachineLearningData() self.cache = apt.Cache()
def updateSources(self): self.buttonRefresh.setEnabled(False) cache = apt.Cache() cache.update(self.aprogress) self.buttonRefresh.setEnabled(True)
def apt_update_complete(self): self.cache = apt.Cache() self.REBOOT_REQUIRED = 0 log('apt_update_complete called') self.cache.open(None) self.cache.upgrade() available_updates = self.cache.get_changes() del self.cache # if 'osmc' isnt in the name of any available updates, then return without doing anything # SUPPRESSED FOR TESTING # if not any(['osmc' in x.shortname.lower() for x in available_updates]): # log('There are no osmc packages') # return if not available_updates: return # dont bother doing anything else if there are no updates FOR TESTING ONLY log('The following packages have newer versions and are upgradable: ') for pkg in available_updates: if pkg.is_upgradable: log('is upgradeable', pkg.shortname) if "mediacenter" in pkg.shortname: self.REBOOT_REQUIRED = 1 # display update available notification if not self.s['suppress_icon']: self.window.setProperty('OSMC_notification', 'true') # The following section implements the procedure that the user has chosen to take place when updates are detected if self.s['on_upd_detected'] == 1: # Display icon on home screen only return elif (self.s['on_upd_detected'] in [ 2, 3 ]) or (self.s['on_upd_detected'] == 4 and self.REBOOT_REQUIRED): # Download updates, then prompt # Download and display icon # Download, install, prompt if restart needed (restart is needed) self.call_child_script('fetch') return elif (self.s['on_upd_detected'] == 4 and not self.REBOOT_REQUIRED) or self.s['on_upd_detected'] == 5: # Download, install, prompt if restart needed (restart is not needed) # Download, install, auto-restart if needed self.call_child_script('commit') return elif self.s['on_upd_detected'] == 0: # show all prompts (default) if self.REBOOT_REQUIRED == 1: log("We can't upgrade from within Kodi as it needs updating itself" ) # Downloading all the debs at once require su access. So we call an external script to download the updates # to the default apt_cache. That other script provides a progress update to this parent script, # which is displayed as a background progress bar self.call_child_script('fetch') else: log("Updates are available, no reboot is required") install = DIALOG.yesno( 'OSMC Update Available', 'There are updates that are available for install.', 'Would you like to install them now?') if install: self.call_child_script('commit') # Actually installs self.window.setProperty('OSMC_notification', 'false') else: okey_dokey = DIALOG.ok( 'OSMC Update Available', 'Fair enough, then.', 'You can install them from within the OSMC settings later.' ) # create the file that will prevent further update checks until the updates have been installed with open(self.block_update_file, 'w') as f: f.write('d') # trigger the flag to skip update checks self.skip_update_check = True
def get_packages(): return apt.Cache()
def package_versions(): pkgs = {'kernel': runtime_kernel_flags().version} if _release_name() in (OSName.RHEVH, OSName.OVIRT, OSName.FEDORA, OSName.RHEL, OSName.POWERKVM): KEY_PACKAGES = { 'glusterfs-cli': ('glusterfs-cli', ), 'librbd1': ('librbd1', ), 'libvirt': ('libvirt', 'libvirt-daemon-kvm'), 'mom': ('mom', ), 'ovirt-hosted-engine-ha': ('ovirt-hosted-engine-ha', ), 'qemu-img': ('qemu-img', 'qemu-img-rhev', 'qemu-img-ev'), 'qemu-kvm': ('qemu-kvm', 'qemu-kvm-rhev', 'qemu-kvm-ev'), 'spice-server': ('spice-server', ), 'vdsm': ('vdsm', ), } if glusterEnabled: KEY_PACKAGES.update(GLUSTER_RPM_PACKAGES) try: ts = rpm.TransactionSet() for pkg, names in KEY_PACKAGES.iteritems(): try: mi = itertools.chain( *[ts.dbMatch('name', name) for name in names]).next() except StopIteration: logging.debug("rpm package %s not found", KEY_PACKAGES[pkg]) else: pkgs[pkg] = { 'version': mi['version'], 'release': mi['release'], } except Exception: logging.error('', exc_info=True) elif _release_name() == OSName.DEBIAN and python_apt: KEY_PACKAGES = { 'glusterfs-cli': 'glusterfs-cli', 'librbd1': 'librbd1', 'libvirt': 'libvirt0', 'mom': 'mom', 'qemu-img': 'qemu-utils', 'qemu-kvm': 'qemu-kvm', 'spice-server': 'libspice-server1', 'vdsm': 'vdsmd', } if glusterEnabled: KEY_PACKAGES.update(GLUSTER_DEB_PACKAGES) cache = apt.Cache() for pkg in KEY_PACKAGES: try: deb_pkg = KEY_PACKAGES[pkg] ver = cache[deb_pkg].installed.version # Debian just offers a version pkgs[pkg] = dict(version=ver, release="") except Exception: logging.error('', exc_info=True) return pkgs
def system_driver_packages(apt_cache=None, sys_path=None, freeonly=False, include_oem=True): '''Get driver packages that are available for the system. This calls system_modaliases() to determine the system's hardware and then queries apt about which packages provide drivers for those. It also adds available packages from detect_plugin_packages(). If you already have an apt.Cache() object, you should pass it as an argument for efficiency. If not given, this function creates a temporary one by itself. If freeonly is set to True, only free packages (from main and universe) are considered Return a dictionary which maps package names to information about them: driver_package → {'modalias': 'pci:...', ...} Available information keys are: 'modalias': Modalias for the device that needs this driver (not for drivers from detect plugins) 'syspath': sysfs directory for the device that needs this driver (not for drivers from detect plugins) 'plugin': Name of plugin that detected this package (only for drivers from detect plugins) 'free': Boolean flag whether driver is free, i. e. in the "main" or "universe" component. 'from_distro': Boolean flag whether the driver is shipped by the distro; if not, it comes from a (potentially less tested/trusted) third party source. 'vendor': Human readable vendor name, if available. 'model': Human readable product name, if available. 'recommended': Some drivers (nvidia, fglrx) come in multiple variants and versions; these have this flag, where exactly one has recommended == True, and all others False. ''' modaliases = system_modaliases(sys_path) if not apt_cache: apt_cache = apt.Cache() packages = {} for alias, syspath in modaliases.items(): for p in packages_for_modalias(apt_cache, alias): if freeonly and not _is_package_free(p): continue if not include_oem and fnmatch.fnmatch(p.name, 'oem-*-meta'): continue packages[p.name] = { 'modalias': alias, 'syspath': syspath, 'free': _is_package_free(p), 'from_distro': _is_package_from_distro(p), } (vendor, model) = _get_db_name(syspath, alias) if vendor is not None: packages[p.name]['vendor'] = vendor if model is not None: packages[p.name]['model'] = model # Add "recommended" flags for NVidia alternatives nvidia_packages = [p for p in packages if p.startswith('nvidia-')] if nvidia_packages: nvidia_packages.sort(key=functools.cmp_to_key(_cmp_gfx_alternatives)) recommended = nvidia_packages[-1] for p in nvidia_packages: packages[p]['recommended'] = (p == recommended) # Add "recommended" flags for fglrx alternatives fglrx_packages = [p for p in packages if p.startswith('fglrx-')] if fglrx_packages: fglrx_packages.sort(key=functools.cmp_to_key(_cmp_gfx_alternatives)) recommended = fglrx_packages[-1] for p in fglrx_packages: packages[p]['recommended'] = (p == recommended) # add available packages which need custom detection code for plugin, pkgs in detect_plugin_packages(apt_cache).items(): for p in pkgs: apt_p = apt_cache[p] packages[p] = { 'free': _is_package_free(apt_p), 'from_distro': _is_package_from_distro(apt_p), 'plugin': plugin, } return packages
def __init__(self): self.apt_cache = apt.Cache() self.pool = AppStream.Pool() self.pool.load() self.transacted = []
def system_gpgpu_driver_packages(apt_cache=None, sys_path=None): '''Get driver packages, for gpgpu purposes, that are available for the system. This calls system_modaliases() to determine the system's hardware and then queries apt about which packages provide drivers for those. Finally, it looks for the correct metapackage, by calling _get_headless_no_dkms_metapackage(). If you already have an apt.Cache() object, you should pass it as an argument for efficiency. If not given, this function creates a temporary one by itself. Return a dictionary which maps package names to information about them: driver_package → {'modalias': 'pci:...', ...} Available information keys are: 'modalias': Modalias for the device that needs this driver (not for drivers from detect plugins) 'syspath': sysfs directory for the device that needs this driver (not for drivers from detect plugins) 'plugin': Name of plugin that detected this package (only for drivers from detect plugins) 'free': Boolean flag whether driver is free, i. e. in the "main" or "universe" component. 'from_distro': Boolean flag whether the driver is shipped by the distro; if not, it comes from a (potentially less tested/trusted) third party source. 'vendor': Human readable vendor name, if available. 'model': Human readable product name, if available. 'recommended': Some drivers (nvidia, fglrx) come in multiple variants and versions; these have this flag, where exactly one has recommended == True, and all others False. ''' vendors_whitelist = ['10de'] modaliases = system_modaliases(sys_path) if not apt_cache: apt_cache = apt.Cache() packages = {} for alias, syspath in modaliases.items(): for p in packages_for_modalias(apt_cache, alias): (vendor, model) = _get_db_name(syspath, alias) vendor_id, model_id = _get_vendor_model_from_alias(alias) if (vendor_id is not None) and (vendor_id.lower() in vendors_whitelist): packages[p.name] = { 'modalias': alias, 'syspath': syspath, 'free': _is_package_free(p), 'from_distro': _is_package_from_distro(p), } if vendor is not None: packages[p.name]['vendor'] = vendor if model is not None: packages[p.name]['model'] = model metapackage = _get_headless_no_dkms_metapackage(p, apt_cache) if metapackage is not None: packages[p.name]['metapackage'] = metapackage # Add "recommended" flags for NVidia alternatives nvidia_packages = [p for p in packages if p.startswith('nvidia-')] if nvidia_packages: nvidia_packages.sort(key=functools.cmp_to_key(_cmp_gfx_alternatives)) recommended = nvidia_packages[-1] for p in nvidia_packages: packages[p]['recommended'] = (p == recommended) return packages
def __init__(self): self._progress = _NoteProgress() self._cache = apt.Cache(self._progress)
def system_device_drivers(apt_cache=None, sys_path=None, freeonly=False): '''Get by-device driver packages that are available for the system. This calls system_modaliases() to determine the system's hardware and then queries apt about which packages provide drivers for each of those. It also adds available packages from detect_plugin_packages(), using the name of the detction plugin as device name. If you already have an apt.Cache() object, you should pass it as an argument for efficiency. If not given, this function creates a temporary one by itself. If freeonly is set to True, only free packages (from main and universe) are considered Return a dictionary which maps devices to available drivers: device_name → {'modalias': 'pci:...', <device info>, 'drivers': {'pkgname': {<driver package info>}} A key (device name) is either the sysfs path (for drivers detected through modaliases) or the detect plugin name (without the full path). Available keys in <device info>: 'modalias': Modalias for the device that needs this driver (not for drivers from detect plugins) 'vendor': Human readable vendor name, if available. 'model': Human readable product name, if available. 'drivers': Driver package map for this device, see below. Installing any of the drivers in that map will make this particular device work. The keys are the package names of the driver packages; note that this can be an already installed default package such as xserver-xorg-video-nouveau which provides a free alternative to the proprietary NVidia driver; these will have the 'builtin' flag set. 'manual_install': None of the driver packages are installed, but the kernel module that it provides is available; this usually means that the user manually installed the driver from upstream. Aavailable keys in <driver package info>: 'builtin': The package is shipped by default in Ubuntu and MUST NOT be uninstalled. This usually applies to free drivers like xserver-xorg-video-nouveau. 'free': Boolean flag whether driver is free, i. e. in the "main" or "universe" component. 'from_distro': Boolean flag whether the driver is shipped by the distro; if not, it comes from a (potentially less tested/trusted) third party source. 'recommended': Some drivers (nvidia, fglrx) come in multiple variants and versions; these have this flag, where exactly one has recommended == True, and all others False. ''' result = {} if not apt_cache: apt_cache = apt.Cache() # copy the system_driver_packages() structure into the by-device structure for pkg, pkginfo in system_driver_packages(apt_cache, sys_path, freeonly=freeonly).items(): if 'syspath' in pkginfo: device_name = pkginfo['syspath'] else: device_name = pkginfo['plugin'] result.setdefault(device_name, {}) for opt_key in ('modalias', 'vendor', 'model'): if opt_key in pkginfo: result[device_name][opt_key] = pkginfo[opt_key] drivers = result[device_name].setdefault('drivers', {}) drivers[pkg] = {'free': pkginfo['free'], 'from_distro': pkginfo['from_distro']} if 'recommended' in pkginfo: drivers[pkg]['recommended'] = pkginfo['recommended'] # now determine the manual_install device flag: this is true iff all driver # packages are "manually installed" for driver, info in result.items(): for pkg in info['drivers']: if not _is_manual_install(apt_cache[pkg]): break else: info['manual_install'] = True # add OS builtin free alternatives to proprietary drivers _add_builtins(result) return result
def install_deb(m, debs, cache, force, install_recommends, allow_unauthenticated, dpkg_options): changed = False deps_to_install = [] pkgs_to_install = [] for deb_file in debs.split(','): try: pkg = apt.debfile.DebPackage(deb_file) pkg_name = get_field_of_deb(m, deb_file, "Package") pkg_version = get_field_of_deb(m, deb_file, "Version") if len(apt_pkg.get_architectures()) > 1: pkg_arch = get_field_of_deb(m, deb_file, "Architecture") pkg_key = "%s:%s" % (pkg_name, pkg_arch) else: pkg_key = pkg_name try: installed_pkg = apt.Cache()[pkg_key] installed_version = installed_pkg.installed.version if package_version_compare(pkg_version, installed_version) == 0: # Does not need to down-/upgrade, move on to next package continue except Exception: # Must not be installed, continue with installation pass # Check if package is installable if not pkg.check() and not force: m.fail_json(msg=pkg._failure_string) # add any missing deps to the list of deps we need # to install so they're all done in one shot deps_to_install.extend(pkg.missing_deps) except Exception as e: m.fail_json(msg="Unable to install package: %s" % to_native(e)) # and add this deb to the list of packages to install pkgs_to_install.append(deb_file) # install the deps through apt retvals = {} if deps_to_install: (success, retvals) = install(m=m, pkgspec=deps_to_install, cache=cache, install_recommends=install_recommends, allow_unauthenticated=allow_unauthenticated, dpkg_options=expand_dpkg_options(dpkg_options)) if not success: m.fail_json(**retvals) changed = retvals.get('changed', False) if pkgs_to_install: options = ' '.join(["--%s" % x for x in dpkg_options.split(",")]) if m.check_mode: options += " --simulate" if force: options += " --force-all" cmd = "dpkg %s -i %s" % (options, " ".join(pkgs_to_install)) with PolicyRcD(m): rc, out, err = m.run_command(cmd) if "stdout" in retvals: stdout = retvals["stdout"] + out else: stdout = out if "diff" in retvals: diff = retvals["diff"] if 'prepared' in diff: diff['prepared'] += '\n\n' + out else: diff = parse_diff(out) if "stderr" in retvals: stderr = retvals["stderr"] + err else: stderr = err if rc == 0: m.exit_json(changed=True, stdout=stdout, stderr=stderr, diff=diff) else: m.fail_json(msg="%s failed" % cmd, stdout=stdout, stderr=stderr) else: m.exit_json(changed=changed, stdout=retvals.get('stdout', ''), stderr=retvals.get('stderr', ''), diff=retvals.get('diff', ''))
def update_apt_cache(self, init=False): '''if init is true, force to update, or it will update only once''' if init or not getattr(self, 'cache'): apt_pkg.init() self.cache = apt.Cache()
def __init__(self): builder = Gtk.Builder() builder.set_translation_domain("mintwelcome") builder.add_from_file( '/usr/share/linuxmint/mintwelcome/mintwelcome.ui') window = builder.get_object("main_window") window.set_icon_name("mintwelcome") window.set_position(Gtk.WindowPosition.CENTER) window.connect("destroy", Gtk.main_quit) with open("/etc/linuxmint/info") as f: config = dict([line.strip().split("=") for line in f]) codename = config['CODENAME'].capitalize() edition = config['EDITION'].replace('"', '') release = config['RELEASE'] desktop = config['DESKTOP'] release_notes = config['RELEASE_NOTES_URL'] new_features = config['NEW_FEATURES_URL'] architecture = "64-bit" if platform.machine() != "x86_64": architecture = "32-bit" # distro-specific dist_name = "Linux Mint" if os.path.exists( "/usr/share/doc/debian-system-adjustments/copyright"): dist_name = "LMDE" # Setup the labels in the Mint badge builder.get_object("label_version").set_text("%s %s" % (dist_name, release)) builder.get_object("label_edition").set_text("%s %s" % (edition, architecture)) # Setup the main stack self.stack = Gtk.Stack() builder.get_object("center_box").pack_start(self.stack, True, True, 0) self.stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE) self.stack.set_transition_duration(150) # Action buttons builder.get_object("button_forums").connect( "clicked", self.visit, "https://forums.linuxmint.com") builder.get_object("button_documentation").connect( "clicked", self.visit, "https://linuxmint.com/documentation.php") builder.get_object("button_contribute").connect( "clicked", self.visit, "https://linuxmint.com/getinvolved.php") builder.get_object("button_irc").connect( "clicked", self.visit, "irc://irc.spotchat.org/linuxmint-help") builder.get_object("button_codecs").connect( "clicked", self.visit, "apt://mint-meta-codecs?refresh=yes") builder.get_object("button_new_features").connect( "clicked", self.visit, new_features) builder.get_object("button_release_notes").connect( "clicked", self.visit, release_notes) builder.get_object("button_mintupdate").connect( "clicked", self.launch, "mintupdate") builder.get_object("button_mintinstall").connect( "clicked", self.launch, "mintinstall") builder.get_object("button_timeshift").connect("clicked", self.pkexec, "timeshift-gtk") builder.get_object("button_mintdrivers").connect( "clicked", self.launch, "driver-manager") builder.get_object("button_gufw").connect("clicked", self.launch, "gufw") builder.get_object("button_layout_legacy").connect( "clicked", self.on_button_layout_clicked, LAYOUT_STYLE_LEGACY) builder.get_object("button_layout_new").connect( "clicked", self.on_button_layout_clicked, LAYOUT_STYLE_NEW) # Settings button depends on DE de_is_cinnamon = False self.theme = None if os.getenv("XDG_CURRENT_DESKTOP") in ["Cinnamon", "X-Cinnamon"]: builder.get_object("button_settings").connect( "clicked", self.launch, "cinnamon-settings") de_is_cinnamon = True self.theme = Gio.Settings(schema="org.cinnamon.desktop.interface" ).get_string("gtk-theme") elif os.getenv("XDG_CURRENT_DESKTOP") == "MATE": builder.get_object("button_settings").connect( "clicked", self.launch, "mate-control-center") elif os.getenv("XDG_CURRENT_DESKTOP") == "XFCE": builder.get_object("button_settings").connect( "clicked", self.launch, "xfce4-settings-manager") else: # Hide settings builder.get_object("box_first_steps").remove( builder.get_object("box_settings")) # Hide Cinnamon layout settings in other DEs if not de_is_cinnamon: builder.get_object("box_first_steps").remove( builder.get_object("box_cinnamon")) # Hide codecs box if they're already installed add_codecs = False cache = apt.Cache() if "mint-meta-codecs" in cache: pkg = cache["mint-meta-codecs"] if not pkg.is_installed: add_codecs = True if not add_codecs: builder.get_object("box_first_steps").remove( builder.get_object("box_codecs")) # Hide drivers if mintdrivers is absent (LMDE) if not os.path.exists("/usr/bin/mintdrivers"): builder.get_object("box_first_steps").remove( builder.get_object("box_drivers")) # Hide new features page for LMDE if dist_name == "LMDE": builder.get_object("box_documentation").remove( builder.get_object("box_new_features")) # Construct the stack switcher list_box = builder.get_object("list_navigation") page = builder.get_object("page_home") self.stack.add_named(page, "page_home") list_box.add(SidebarRow(page, _("Welcome"), "go-home-symbolic")) self.stack.set_visible_child(page) page = builder.get_object("page_first_steps") self.stack.add_named(page, "page_first_steps") list_box.add( SidebarRow(page, _("First Steps"), "dialog-information-symbolic")) page = builder.get_object("page_documentation") self.stack.add_named(page, "page_documentation") list_box.add( SidebarRow(page, _("Documentation"), "accessories-dictionary-symbolic")) page = builder.get_object("page_help") self.stack.add_named(page, "page_help") list_box.add(SidebarRow(page, _("Help"), "help-browser-symbolic")) page = builder.get_object("page_contribute") self.stack.add_named(page, "page_contribute") list_box.add(SidebarRow(page, _("Contribute"), "starred-symbolic")) list_box.connect("row-activated", self.sidebar_row_selected_cb) # Construct the bottom toolbar box = builder.get_object("toolbar_bottom") checkbox = Gtk.CheckButton() checkbox.set_label(_("Show this dialog at startup")) if not os.path.exists(NORUN_FLAG): checkbox.set_active(True) checkbox.connect("toggled", self.on_button_toggled) box.pack_end(checkbox) scale = window.get_scale_factor() self.color = "green" self.dark_mode = False # Use HIDPI pictures if appropriate if scale == 1: surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/legacy.png", scale) builder.get_object("img_legacy").set_from_surface(surface) surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/modern.png", scale) builder.get_object("img_modern").set_from_surface(surface) else: surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/legacy-hidpi.png", scale) builder.get_object("img_legacy").set_from_surface(surface) surface = self.surface_for_path( "/usr/share/linuxmint/mintwelcome/modern-hidpi.png", scale) builder.get_object("img_modern").set_from_surface(surface) path = "/usr/share/linuxmint/mintwelcome/colors/" if scale == 2: path = "/usr/share/linuxmint/mintwelcome/colors/hidpi/" for color in [ "green", "aqua", "blue", "brown", "grey", "orange", "pink", "purple", "red", "sand", "teal" ]: builder.get_object("img_" + color).set_from_surface( self.surface_for_path("%s/%s.png" % (path, color), scale)) builder.get_object("button_" + color).connect( "clicked", self.on_color_button_clicked, color) builder.get_object("switch_dark").connect("state-set", self.on_dark_mode_changed) window.set_default_size(800, 500) window.show_all()
def __init__(self): self.downgrade_mode = (sys.argv[1] == "downgrade" ) # whether to downgrade or remove packages glade_file = "/usr/lib/linuxmint/mintSources/mintsources.glade" self.builder = Gtk.Builder() self.builder.set_translation_domain("mintsources") self.builder.add_from_file(glade_file) self.window = self.builder.get_object("foreign_window") self.window.set_title(_("Foreign packages")) self.window.set_icon_name("software-sources") self.window.connect("destroy", Gtk.main_quit) self.builder.get_object("button_foreign_cancel").connect( "clicked", Gtk.main_quit) self.action_button = self.builder.get_object("button_foreign_action") self.action_button.connect("clicked", self.install) if self.downgrade_mode: self.action_button.set_label(_("Downgrade")) self.builder.get_object( "label_foreign_explanation" ).set_markup("%s" % _( "The version of the following packages doesn't match the one from the repositories:" )) else: self.action_button.set_label(_("Remove")) self.builder.get_object( "label_foreign_explanation" ).set_markup("%s" % _( "The packages below are installed on your computer but not present in the repositories:" )) self.action_button.set_sensitive(False) self.select_button = self.builder.get_object("button_foreign_select") self.select_button.connect("clicked", self.select_all) self.select_button.set_label(_("Select All")) self.select_button_selects_all = True self.model = Gtk.ListStore(str, bool, str, str, str, str) # PKG_ID, PKG_CHECKED, PKG_NAME, PKG_INSTALLED_VERSION, PKG_REPO_VERSION, PKG_SORT_NAME treeview = self.builder.get_object("treeview_foreign_pkgs") treeview.set_model(self.model) self.model.set_sort_column_id(PKG_SORT_NAME, Gtk.SortType.ASCENDING) cr = Gtk.CellRendererToggle() cr.connect("toggled", self.toggled) col = Gtk.TreeViewColumn("", cr) col.set_cell_data_func(cr, self.datafunction_checkbox) treeview.append_column(col) col.set_sort_column_id(PKG_CHECKED) r = Gtk.CellRendererText() col = Gtk.TreeViewColumn(_("Package"), r, markup=PKG_NAME) treeview.append_column(col) col.set_sort_column_id(PKG_NAME) r = Gtk.CellRendererText() col = Gtk.TreeViewColumn(_("Installed version"), r, markup=PKG_INSTALLED_VERSION) treeview.append_column(col) col.set_sort_column_id(PKG_INSTALLED_VERSION) if self.downgrade_mode: r = Gtk.CellRendererText() col = Gtk.TreeViewColumn(_("Repository version"), r, markup=PKG_REPO_VERSION) treeview.append_column(col) col.set_sort_column_id(PKG_REPO_VERSION) self.apt = mintcommon.APT(self.window) cache = apt.Cache() for key in cache.keys(): pkg = cache[key] if (pkg.is_installed): candidate_version = pkg.candidate.version installed_version = pkg.installed.version if not pkg.candidate.downloadable: # The candidate is not downloadable... # See if there's a version that is... best_version = None for version in pkg.versions: if version.downloadable: if best_version is None: best_version = version else: if version.policy_priority > best_version.policy_priority: best_version = version elif version.policy_priority == best_version.policy_priority: # same priorities, compare version return_code = subprocess.call([ "dpkg", "--compare-versions", version.version, "gt", best_version.version ]) if return_code == 0: best_version = version if self.downgrade_mode: if best_version is not None: for origin in best_version.origins: iter = self.model.insert_before(None, None) self.model.set_value( iter, PKG_ID, "%s=%s" % (pkg.name, best_version.version)) self.model.set_value(iter, PKG_CHECKED, False) self.model.set_value(iter, PKG_NAME, "<b>%s</b>" % pkg.name) self.model.set_value(iter, PKG_INSTALLED_VERSION, installed_version) self.model.set_value( iter, PKG_REPO_VERSION, "%s (%s)" % (best_version.version, origin.archive)) self.model.set_value( iter, PKG_SORT_NAME, "%s %s" % (best_version.source_name, pkg.name)) break else: if best_version is None: iter = self.model.insert_before(None, None) self.model.set_value(iter, PKG_ID, "%s" % (pkg.name)) self.model.set_value(iter, PKG_CHECKED, False) self.model.set_value(iter, PKG_NAME, "<b>%s</b>" % pkg.name) self.model.set_value(iter, PKG_INSTALLED_VERSION, installed_version) self.model.set_value(iter, PKG_REPO_VERSION, "") self.model.set_value(iter, PKG_SORT_NAME, "%s" % (pkg.name)) treeview.show() treeview.connect("row-activated", self.treeview_row_activated) self.window.show_all()
def _setupSSHDImpl(ngrok_token, ngrok_region): #apt-get update #apt-get upgrade cache = apt.Cache() cache.update() cache.open(None) cache.upgrade() cache.commit() subprocess.run(["unminimize"], input = "y\n", check = True, universal_newlines = True) _installPkg(cache, "openssh-server") cache.commit() #Reset host keys for i in pathlib.Path("/etc/ssh").glob("ssh_host_*_key"): i.unlink() subprocess.run( ["ssh-keygen", "-A"], check = True) #Prevent ssh session disconnection. with open("/etc/ssh/sshd_config", "a") as f: f.write("\n\nClientAliveInterval 120\n") print("ECDSA key fingerprint of host:") ret = subprocess.run( ["ssh-keygen", "-lvf", "/etc/ssh/ssh_host_ecdsa_key.pub"], stdout = subprocess.PIPE, check = True, universal_newlines = True) print(ret.stdout) _download("https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip", "ngrok.zip") shutil.unpack_archive("ngrok.zip") pathlib.Path("ngrok").chmod(stat.S_IXUSR) root_password = secrets.token_urlsafe() user_password = secrets.token_urlsafe() user_name = "colab" print("✂️"*24) print(f"root password: {root_password}") print(f"{user_name} password: {user_password}") print("✂️"*24) subprocess.run(["useradd", "-s", "/bin/bash", "-m", user_name]) subprocess.run(["chpasswd"], input = f"root:{root_password}", universal_newlines = True) subprocess.run(["chpasswd"], input = f"{user_name}:{user_password}", universal_newlines = True) subprocess.run(["service", "ssh", "restart"]) if not pathlib.Path('/root/.ngrok2/ngrok.yml').exists(): subprocess.run(["./ngrok", "authtoken", ngrok_token]) subprocess.Popen(["./ngrok", "tcp", "-region", ngrok_region, "22"]) time.sleep(2) with urllib.request.urlopen("http://*****:*****@{hostname}") print("✂️"*24) print("---") print("If you use VNC:") print("✂️"*24) print(f"ssh {ssh_common_options} -L 5901:localhost:5901 -p {port} {user_name}@{hostname}") print("✂️"*24)
def __init__(self): architecture = commands.getoutput("dpkg --print-architecture") self.downgrade_mode = (sys.argv[1] == "downgrade" ) # whether to downgrade or remove packages self.foreign_packages = [] glade_file = "/usr/lib/linuxmint/mintSources/mintSources.glade" self.builder = gtk.Builder() self.builder.add_from_file(glade_file) self.window = self.builder.get_object("foreign_window") self.window.set_title(_("Foreign packages")) self.window.set_icon_from_file( "/usr/share/icons/hicolor/scalable/apps/software-sources.svg") self.window.connect("destroy", gtk.main_quit) self.builder.get_object("button_foreign_cancel").connect( "clicked", gtk.main_quit) self.action_button = self.builder.get_object("button_foreign_action") self.action_button.connect("clicked", self.install) if self.downgrade_mode: self.action_button.set_label(_("Downgrade")) self.builder.get_object( "label_foreign_explanation" ).set_markup("<i>%s</i>" % _( "The version of the following packages doesn't match the one from the repositories:" )) else: self.action_button.set_label(_("Remove")) self.builder.get_object( "label_foreign_explanation" ).set_markup("<i>%s</i>" % _( "The packages below are installed on your computer but not present in the repositories:" )) self.action_button.set_sensitive(False) self.builder.get_object("button_foreign_cancel").set_label(_("Cancel")) self.builder.get_object("label_foreign_warning").set_markup( "<b>%s</b>" % _("WARNING")) self.builder.get_object( "label_foreign_review" ).set_markup("<i>%s</i>" % _( "Review the information below very carefully before validating the command:" )) self.model = gtk.ListStore(str, bool, str, str, str, str) treeview = self.builder.get_object("treeview_foreign_pkgs") treeview.set_model(self.model) self.model.set_sort_column_id(5, gtk.SORT_ASCENDING) r = gtk.CellRendererToggle() r.connect("toggled", self.toggled) col = gtk.TreeViewColumn("", r) col.set_cell_data_func(r, self.datafunction_checkbox) treeview.append_column(col) col.set_sort_column_id(1) r = gtk.CellRendererText() col = gtk.TreeViewColumn(_("Package"), r, markup=2) treeview.append_column(col) col.set_sort_column_id(2) r = gtk.CellRendererText() col = gtk.TreeViewColumn(_("Installed version"), r, markup=3) treeview.append_column(col) col.set_sort_column_id(3) if self.downgrade_mode: r = gtk.CellRendererText() col = gtk.TreeViewColumn(_("Repository version"), r, markup=4) treeview.append_column(col) col.set_sort_column_id(4) cache = apt.Cache() for key in cache.keys(): pkg = cache[key] if (pkg.is_installed): candidate_version = pkg.candidate.version installed_version = pkg.installed.version if not pkg.candidate.downloadable: # The candidate is not downloadable... # See if there's a version that is... best_version = None for version in pkg.versions: if version.downloadable: if best_version is None: best_version = version else: if version.policy_priority > best_version.policy_priority: best_version = version elif version.policy_priority == best_version.policy_priority: # same priorities, compare version if commands.getoutput( "dpkg --compare-versions %s gt %s && echo 'OK'" % (version.version, best_version.version)) == "OK": best_version = version if self.downgrade_mode: if best_version is not None: for origin in best_version.origins: self.model.append( ("%s=%s" % (pkg.name, best_version.version), False, "<b>%s</b>" % pkg.name, installed_version, "%s (%s)" % (best_version.version, origin.archive), "%s %s" % (best_version.source_name, pkg.name))) break else: if best_version is None: self.model.append( ("%s" % (pkg.name), False, "<b>%s</b>" % pkg.name, installed_version, "", "%s" % (pkg.name))) treeview.show() self.window.show_all() parent_window_xid = int(sys.argv[2]) try: parent = gtk.gdk.window_foreign_new(parent_window_xid) self.window.realize() self.window.window.set_transient_for(parent) except: pass