#

#  bootinfo.py

#

#

#  This file is part of Cnchi.

#

def _check_linux(mount_name):

    detected_os = _("unknown")

    for os_release in OS_RELEASE_PATHS:

#  check.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

#  along with Cnchi; If not, see <http://www.gnu.org/licenses/>.

from gi.repository import GLib

#

#  cnchi.py

#

#

#  This file is part of Cnchi.

#

#  You should have received a copy of the GNU General Public License

#  along with Cnchi; If not, see <http://www.gnu.org/licenses/>.

import os

import sys

    def __init__(self):

        """ Constructor. Call base class """

        Gtk.Application.__init__(self,

                                 flags=Gio.ApplicationFlags.FLAGS_NONE)

        self.TMP_RUNNING = "/tmp/.setup-running"

    import argparse

    parser = argparse.ArgumentParser(description=desc)

    parser.add_argument(

        action="store_true")

    parser.add_argument(

        "--disable-rank-mirrors",

        action="store_true")

    parser.add_argument(

        "-v", "--verbose",

        GObject.threads_init()

        # Gdk.threads_init()

def setup_gettext():

    """ This allows to translate all py texts (not the glade ones) """

#

#  pacman_conf.py

#

#

#  This file is part of Cnchi.

#

        self.settings.put({

            'alternate_package_list': '',

            'auto_device': '/dev/sda',

            'bootloader_device': '/dev/sda',

            'bootloader_install': True,

            'bootloader_installation_successful': False,

            'country_name': '',

            'country_code': '',

            'data': '/usr/share/cnchi/data/',

            'desktop_ask': True,

            'desktops': [],

            'download_module': 'requests',

            'encrypt_home': False,

            'f2fs': False,

            'failed_download': False,

            'feature_bluetooth': False,

            'feature_cups': False,

            'feature_firewall': False,

            'feature_lts': False,

            'feature_office': False,

            'feature_smb': False,

            'fullname': '',

            'GRUB_CMDLINE_LINUX': '',

            'is_vbox': False,

            'keyboard_layout': '',

            'keyboard_variant': '',

            'require_password': True,

            'ruuid': '',

            'sentry_dsn': '',

            'timezone_human_zone': '',

            'timezone_country': '',

            'timezone_zone': '',

#

#  desktop_info.py

#

#

#  This file is part of Cnchi.

#

    'qt': ["kde", "lxqt"]

}

                "visual", "firewall", "smb"]

# Each desktop has its own available features

# TODO: Rework and simplify features logic by only storing excluded features for each each desktop.

FEATURES = {

                 "office", "smb"],

    'gnome': [

        "games", "graphic_drivers", "lts", "office", "smb"

    ],

    'kde': [

    ],

             "office", "smb"],

             "office", "smb"]}

# Session names for lightDM setup

               "computer. It features the Activities Overview which "

               "is an easy way to access all your basic tasks."),

                  "innovative features and a traditional desktop user experience. "

                  "Cinnamon aims to make users feel at home by providing them with "

                  "an easy-to-use and comfortable desktop experience."),

    'openbox': _("Not actually a desktop environment, Openbox is a highly "

                 "configurable window manager. It is known for its "

                 "minimalistic appearance and its flexibility. It is the most "

                       "and others, but also a whole suite of libraries to help "

                       "you create beautiful user interfaces with much less work"),

              "Environment. It is lightweight, modular, blazing-fast, and "

              "user-friendly."),

              "without any type of graphical interface. After the installation you can "

    'mate': _("MATE is an intuitive, attractive, and lightweight desktop "

              "environment which provides a more traditional desktop "

#

#  desktop.py

#

#

#  This file is part of Cnchi.

#

        self.listbox.set_selection_mode(Gtk.SelectionMode.BROWSE)

        self.listbox.set_sort_func(self.listbox_sort_by_name, None)

        self.enabled_desktops = self.settings.get("desktops")

                self.listbox.add(box)

    @staticmethod

    def listbox_sort_by_name(row1, row2, user_data):

    def store_values(self):

        """ Store desktop """

        self.settings.set('desktop', self.desktop_choice.lower())

        return True

    @staticmethod

#  download_aria2.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

class Download(object):

    """ Class to download packages using Aria2

        This class tries to previously download all necessary packages for

    def __init__(self, pacman_cache_dir, cache_dir, callback_queue):

        """ Initialize DownloadAria2 class. Gets default configuration """

# download.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

class DownloadPackages(object):

    """ Class to download packages using Aria2, requests (default) or urllib

        This class tries to previously download all necessary packages for

        Aria2 is known to use too much memory (not Aria2's fault but ours)

        so until it's fixed it it's not advised to use it """

#  download_requests.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

class Download(object):

    """ Class to download packages using requests

        This class tries to previously download all necessary packages for

    def __init__(self, pacman_cache_dir, cache_dir, callback_queue):

        """ Initialize Download class. Gets default configuration """

#  download_urllib.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

class Download(object):

    """ Class to download packages using urllib

        This class tries to previously download all necessary packages for

    def __init__(self, pacman_cache_dir, cache_dir, callback_queue):

        """ Initialize Download class. Gets default configuration """

#  encfs.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

#  along with Cnchi; If not, see <http://www.gnu.org/licenses/>.

import os

import shutil

def setup_conf_files(dest_dir):

    path = os.path.join(dest_dir, "etc/security/pam_encfs.conf")

    with open(path, 'w') as pam_encfs:

        pam_encfs.write("# If this is specified program will attempt to drop permissions before running encfs.\n")

        pam_encfs.write("drop_permissions\n\n")

        pam_encfs.write("# This specifies which options to pass to encfs for every user.\n")

        pam_encfs.write("# Same for fuse\n")

        pam_encfs.write("# you can find fuse options with encfs -H\n")

        pam_encfs.write("fuse_default allow_root,nonempty\n\n")

        # USERNAME SOURCE TARGET_PATH ENCFS_Options FUSE_Options

        pam_encfs.write("-\t/home/.encfs\t-\t-v\t-\n")

    path = os.path.join(dest_dir, "etc/security/pam_env.conf")

    with open(path, 'a') as pam_env:

        pam_env.write("ICEAUTHORITY DEFAULT=/tmp/.ICEauthority_@{PAM_USER}\n")

    path = os.path.join(dest_dir, "etc/fuse.conf")

    with open(path, 'a') as fuse_conf:

        fuse_conf.write("user_allow_other\n")

    path = os.path.join(dest_dir, "etc/pam.d/system-login")

    with open(path, 'a') as system_login:

        system_login.write("session required\tpam_encfs.so\n")

        system_login.write("session optional\tpam_mount.so\n")

    path = os.path.join(dest_dir, "etc/pam.d/system-auth")

    with open(path, "a") as system_auth:

        system_auth.write("auth sufficient\tpam_encfs.so\n")

        system_auth.write("auth optional\tpam_mount.so\n")

def setup(username, dest_dir, password):

    """ Encrypt user's home folder """

    # encfs and pam_mount packages are needed

    # Reference: https://wiki.debian.org/TransparentEncryptionForHomeFolder

    try:

#

#  features_info.py

#

#

#  This file is part of Cnchi.

#

# in desktop_info file instead of here.

ICON_NAMES = {

    'bluetooth': 'bluetooth',

    'cups': 'printer',

    'firewall': 'network-server',

    'lts': 'applications-accessories',

    'office': 'accessories-text-editor',

# See http://docs.python.org/2/library/gettext.html "22.1.3.4. Deferred translations"

    return message

TITLES = {

    'bluetooth': _("Bluetooth Support"),

    'cups': _("Printing Support"),

    'firewall': _("Uncomplicated Firewall"),

    'lamp': _("Apache (or Nginx) + Mariadb + PHP"),

    'lts': _("Kernel (LTS version)"),

    'office': _("LibreOffice"),

DESCRIPTIONS = {

    'bluetooth': _("Enables your system to make wireless connections via Bluetooth."),

    'cups': _("Installation of printer drivers and management tools."),

    'firewall': _("Control the incoming and outgoing network traffic."),

    'lts': _("Long term support (LTS) Linux kernel and modules."),

    'smb': _("SMB provides shared access to files and printers.")}

TOOLTIPS = {

             "from the community and to help expedite popular packages'\n"

             "inclusion into the [community] repository."),

    'bluetooth': _("Bluetooth is a standard for the short-range wireless\n"

    'cups': _("CUPS is the standards-based, open source printing\n"

              "system developed by Apple Inc. for OS® X and other\n"

              "UNIX®-like operating systems."),

    'firewall': _("Ufw stands for Uncomplicated Firewall, and is a program for\n"

              "Apache or Nginx) plus a database server (Mariadb)\n"

              "and PHP."),

             "This particular kernel version enjoys long-term support from upstream,\n"

             "including security fixes and some feature backports. Additionally, this\n"

             "support kernel, or who want a fallback kernel in case the latest kernel\n"

             "version causes problems, this option is the answer."),

                "personal productivity suite for Windows, Macintosh\n"

                "for all your document production and data processing\n"

                "needs: Writer, Calc, Impress, Draw, Math and Base."),

    'smb': _("In computer networking, Server Message Block (SMB)\n"

             "operates as an application-layer network protocol mainly used\n"

             "for providing shared access to files, printers, serial ports,\n"

# Delete previous _() dummy declaration

del _

#  features.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

        # This is initialized each time this screen is shown in prepare()

        self.features = None

        # Only load defaults the first time this screen is shown

        self.load_defaults = True

    @staticmethod

    def on_listbox_row_selected(listbox, listbox_row):

        """ Someone selected a different row of the listbox

            WARNING: IF LIST LAYOUT IS CHANGED THEN THIS SHOULD BE CHANGED ACCORDINGLY. """

    def fill_listbox(self):

        for listbox_row in self.listbox.get_children():

        self.listbox_rows = {}

        for feature in self.features:

            box = Gtk.Box(spacing=20)

            box.set_name(feature + "-row")

            self.listbox_rows[feature].append(image)

            box.pack_start(image, False, False, 0)

            object_name = "label_" + feature

            label = Gtk.Label.new()

            label.set_name(object_name)

        txt = desktop_info.NAMES[desktop] + " - " + _("Feature Selection")

        self.header.set_subtitle(txt)

        # Sort listbox items

        self.listbox.invalidate_sort()

            row = self.listbox_rows['cups']

            row[COL_SWITCH].set_active(True)

    def store_values(self):

        """ Get switches values and store them """

        for feature in self.features:

            self.show_info_dialog("ufw")

            self.info_already_shown["ufw"] = True

            info = Gtk.MessageDialog(

                transient_for=self.get_toplevel(),

                modal=True,

                destroy_with_parent=True,

                message_type=Gtk.MessageType.INFO,

                buttons=Gtk.ButtonsType.YES_NO)

            msg = _("Do you want to install the Nginx server instead of the Apache server?")

            info.format_secondary_markup(msg)

            response = info.run()

            info.destroy()

            if response == Gtk.ResponseType.YES:

            else:

        self.listbox_rows = {}

    def show_info_dialog(self, feature):

        """ Some features show an information dialog when this screen is accepted """

        elif feature == "ufw":

            # Ufw rules info

            txt1 = _("Uncomplicated Firewall will be installed with these rules:")

#  hardware.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

    @staticmethod

    def is_proprietary():

        """ Proprietary drivers are drivers for your hardware devices

        return False

    def is_graphic_driver(self):

class HardwareInstall(object):

    def __init__(self, use_proprietary_graphic_drivers=False):

        self.use_proprietary_graphic_drivers = use_proprietary_graphic_drivers

        for device in self.objects_found:

            drivers_available = self.objects_found[device]

            objects_selected = []

                self.objects_used.append(drivers_available[0])

    @staticmethod

        """ Run post install commands for all detected devices """

        for obj in self.objects_used:

            obj.post_install(dest_dir)

#

#  info.py

#

#

#  This file is part of Cnchi.

#

""" Set some Cnchi global constants """

CNCHI_VERSION = "0.12.47"

CNCHI_RELEASE_STAGE = "production"

if __name__ == '__main__':

#  advanced.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

            for mount_point in fs.COMMON_MOUNT_POINTS:

                combo.append_text(mount_point)

        self.bootloader_device = ""

        self.bootloader_entry = self.ui.get_object('bootloader_entry')

        self.bootloader_device_entry = self.ui.get_object('bootloader_device_entry')

        self.bootloader_entry.remove_all()

        if os.path.exists('/sys/firmware/efi'):

            self.bootloader_entry.append_text("Systemd-boot")

            if not self.select_combobox_value(self.bootloader_entry, self.bootloader):

                # Automatically select first entry

        """

        Check that all necessary mount points are specified.

        At least root (/) partition must be defined and in UEFI systems

        """

        check_parts = ["/", "/boot", "/boot/efi", "swap"]

        part_label["/"].show()

        if is_uefi:

                part_label["/boot/efi"].show()

            if self.bootloader == "systemd-boot":

                part_label["/boot"].show()

            if is_uefi:

                # /boot or /boot/efi need to be fat32 in UEFI systems

                if "fat" in fsystem:

                        has_part["/boot/efi"] = True

                        part_label["/boot/efi"].show()

                        part_label["/boot/efi"].set_state(True)

        check_ok = has_part["/"]

        if is_uefi:

                check_ok = check_ok and has_part["/boot/efi"]

            elif self.bootloader == "systemd-boot":

                # Systemd-boot (Gummiboot) needs a /boot partition

            self.settings.set('bootloader_device', self.bootloader_device)

            self.settings.set('bootloader', self.bootloader)

            msg = msg.format(self.bootloader, self.bootloader_device)

            logging.info(msg)

#  alongside.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

from gtkbasebox import GtkBaseBox

MIN_ROOT_SIZE = 6500

    @staticmethod

    def get_new_device(device_to_shrink):

            returns an empty string if no device is available """

        number = int(device_to_shrink[len("/dev/sdX"):])

        disk = device_to_shrink[:len("/dev/sdX")]

        (min_size, part_size) = get_partition_size_info(device_to_shrink)

        max_size = part_size - (MIN_ROOT_SIZE * 1000.0)

        if max_size < 0:

            txt += _("New partition {0} resulting of shrinking {1} will not have enough free space for a full installation.").format(new_device, device_to_shrink) + "\n\n"

            txt += _("Install at your own risk!")

            show.warning(self.get_toplevel(), txt)

            max_size = part_size

        icon_file = self.get_distributor_icon_file(self.oses[device_to_shrink])

        self.resize_widget.set_part_icon('existing', icon_file=icon_file)

        self.resize_widget.set_part_icon('new', icon_file=icon_file)

        self.resize_widget.set_pref_size(max_size)

        """ Gets an icon for the installed distribution """

        os_name = os_name.lower()

            icons_path = os.path.join(self.settings.get('data'), "icons/48x48")

            return icon_file

        icon_names = [

        txt = _("Choose the partition that you want to shrink:")

        self.choose_partition_label.set_markup(txt)

    def on_choose_partition_combo_changed(self, combobox):

        txt = combobox.get_active_text()

        if self.settings.get('bootloader_install'):

            self.settings.set('bootloader', "grub2")

            self.settings.set('bootloader_device', device_path)

            msg = msg.format(self.bootloader, self.bootloader_device)

            logging.info(msg)

        else:

#  ask.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

        # Automatic Install

        radio = self.ui.get_object("automatic_radiobutton")

        if len(oses_str) > 0:

        else:

        radio.set_label(txt)

        radio.set_name('auto_radio_btn')

        # Alongside Install (For now, only works with Windows)

        # if len(oses_str) > 0:

        #     radio = self.ui.get_object("alongside_radiobutton")

        #     radio.set_label(txt)

        #

        #     label = self.ui.get_object("alongside_description")

        #     txt = description_style.format(txt)

        #     label.set_markup(txt)

        #     label.set_line_wrap(True)

        # Advanced Install

        radio = self.ui.get_object("advanced_radiobutton")

        radio.set_name("advanced_radio_btn")

        label = self.ui.get_object("advanced_description")

            self.settings.set('use_lvm', use_lvm)

            self.settings.set('use_luks', use_luks)

            self.settings.set('use_luks_in_root', True)

            self.settings.set('use_home', use_home)

        else:

            # Set defaults. We don't know these yet.

            self.settings.set('use_home', False)

        if self.settings.get('use_luks'):

        if self.settings.get('use_lvm'):

            if self.settings.get('use_home'):

        elif self.settings.get('use_home'):

        if self.next_page == "installation_alongside":

            self.settings.set('partition_mode', 'alongside')

#  automatic.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

        self.devices = {}

        self.installation = None

        self.bootloader_entry = self.ui.get_object('bootloader_entry')

        self.bootloader_device_entry = self.ui.get_object('bootloader_device_entry')

        self.bootloader_devices = {}

        label.set_markup(txt)

        label = self.ui.get_object('info_label')

        label.set_markup(txt)

        label = self.ui.get_object('label_luks_password')

        self.bootloader_entry.remove_all()

        if os.path.exists('/sys/firmware/efi'):

            self.bootloader_entry.append_text("Gummiboot")

            self.bootloader_entry.set_active(0)

            self.bootloader_entry.show()

            self.settings.set('bootloader_device', self.bootloader_device)

            self.settings.set('bootloader', self.bootloader)

            msg = msg.format(self.bootloader, self.bootloader_device)

            logging.info(msg)

    def run_install(self, packages, metalinks):

        logging.info(txt, self.auto_device)

        self.settings.set('auto_device', self.auto_device)

#  auto_partition.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

    failed installation) """

    try:

    except subprocess.CalledProcessError as err:

        logging.warning("Can't close already opened LUKS devices, command %s failed: %s", err.cmd, err.output)

            else:

                part_num = 1

                devices['efi'] = "{0}{1}".format(device, part_num)

                part_num += 1

            if self.lvm:

                # LUKS and LVM

                devices['luks_root'] = devices['root']

            else:

                # LUKS and no LVM

                devices['luks_root'] = devices['root']

                if self.home:

                    # In this case we'll have two LUKS devices, one for root

                    # and the other one for /home

                    devices['luks_home'] = devices['home']

        elif self.lvm:

            # No LUKS but using LVM

            devices['lvm'] = devices['root']

        if self.lvm:

            if self.home:

        return devices

        devices = self.get_devices()

        mount_devices = {}

            mount_devices['/boot/efi'] = devices['efi']

        mount_devices['/boot'] = devices['boot']

        fs_devices = {}

            fs_devices[devices['efi']] = "vfat"

        if self.GPT and self.bootloader == "systemd-boot":

    def get_part_sizes(self, disk_size, start_part_sizes=1):

        part_sizes = {'disk': disk_size, 'boot': 256, 'efi': 0}

            part_sizes['efi'] = 200

        mem_total = check_output("grep MemTotal /proc/meminfo")

    def log_part_sizes(self, part_sizes):

        logging.debug("Total disk size: %dMiB", part_sizes['disk'])

            logging.debug("EFI System Partition (ESP) size: %dMiB", part_sizes['efi'])

        logging.debug("Boot partition size: %dMiB", part_sizes['boot'])

                sgdisk_new(device, part_num, "BIOS_BOOT", gpt_bios_grub_part_size, "EF02")

                part_num += 1

                # Create EFI System Partition (ESP)

                # GPT GUID: C12A7328-F81F-11D2-BA4B-00A0C93EC93B

                sgdisk_new(device, part_num, "UEFI_SYSTEM", part_sizes['efi'], "EF00")

            # Create Boot partition

            if self.bootloader == "systemd-boot":

            else:

            part_num += 1

            if self.lvm:

                # Create partition for lvm (will store root, swap and home (if desired) logical volumes)

                part_num += 1

            else:

                part_num += 1

                if self.home:

                    part_num += 1

            logging.debug(check_output("sgdisk --print {0}".format(device)))

        else:

        devices = self.get_devices()

            logging.debug("EFI: %s", devices['efi'])

        logging.debug("Boot: %s", devices['boot'])

        logging.debug("Swap: %s", devices['swap'])

        if self.luks:

            if self.home and not self.lvm:

        if self.lvm:

            logging.debug("Cnchi will setup LVM on device %s", devices['lvm'])

                raise InstallError(txt)

            try:

            except subprocess.CalledProcessError as err:

                txt = "Error creating LVM volume group in device {0}. Command {1} failed: {2}".format(

                    devices['lvm'], err.cmd, err.Output)

            # Fix issue 180

            # Check space we have now for creating logical volumes

            # Get column number 12: Size of volume group in kilobytes

            vg_size = int(vg_info.split(":")[11]) / 1024

            if part_sizes['lvm_pv'] > vg_size:

                logging.debug("Reajusting logical volume sizes")

                diff_size = part_sizes['lvm_pv'] - vg_size

                part_sizes = self.get_part_sizes(disk_size - diff_size, start_part_sizes)

            # Create LVM volumes

            try:

                size = str(int(part_sizes['root']))

                subprocess.check_call(cmd)

                if not self.home:

                    # Use the remainig space for our swap volume

                    subprocess.check_call(cmd)

                else:

                    size = str(int(part_sizes['swap']))

                    subprocess.check_call(cmd)

                    # Use the remaining space for our home volume

                    subprocess.check_call(cmd)

            except subprocess.CalledProcessError as err:

                txt = "Error creating LVM logical volume. Command {0} failed: {1}".format(err.cmd, err.output)

        labels = {

            'efi': 'UEFI_SYSTEM',

        fs_devices = self.get_fs_devices()

            self.mkfs(devices['boot'], fs_devices[devices['boot']], mount_points['boot'], labels['boot'])

        # Note: Make sure the "boot" partition is defined before the "efi" one!

            # Format EFI System Partition (ESP) with vfat (fat32)

            self.mkfs(devices['efi'], fs_devices[devices['efi']], mount_points['efi'], labels['efi'], "-F 32")

        luks_password="luks",

        use_lvm=True,

        use_home=True,

        callback_queue=None)

    auto.run()

#  bootloader.py

#

#  Copyright © 2013-2015 Antergos

#

#  This file is part of Cnchi.

#

        self.freeze_unfreeze_xfs()

        bootloader = self.settings.get('bootloader').lower()