penguins-eggs 10.0.60 → 10.1.1

package/dist/krill/classes/prepare.d/partitions.js

@@ -34,7 +34,7 @@ export async function partitions(installationDevice = "", crypted = false, pve =
     let knownInstallationModes = Object.values(InstallationMode);
     let knownSwapChoices = Object.values(SwapChoice);
     if (!knownInstallationModes.includes(installationMode)) {
-        installationMode = InstallationMode.Standard;
+        installationMode = InstallationMode.EraseDisk;
     }
     if (crypted) {
         installationMode = InstallationMode.Luks;
@@ -54,7 +54,7 @@ export async function partitions(installationDevice = "", crypted = false, pve =
         }
         else {
             installationDevice = driveList[0]; // Solo per selezionare il default
-            installationMode = InstallationMode.Standard;
+            installationMode = InstallationMode.EraseDisk;
             if (crypted) {
                 installationMode = InstallationMode.Luks;
             }
@@ -65,7 +65,7 @@ export async function partitions(installationDevice = "", crypted = false, pve =
                 filesystemType = await selectFileSystemType();
                 userSwapChoice = SwapChoice.File;
             }
-            else if (installationMode === InstallationMode.Standard) {
+            else if (installationMode === InstallationMode.EraseDisk) {
                 replacedPartition = "";
                 filesystemType = await selectFileSystemType();
                 userSwapChoice = await selectUserSwapChoice(userSwapChoice);

package/dist/krill/classes/prepare.d.ts

@@ -1,10 +1,10 @@
 /**
- * ./src/krill/prepare.tsx
+ * Krill Installer - Simplified Refactoring
+ * ./src/krill/prepare.ts
  * penguins-eggs v.10.0.0 / ecmascript 2020
  * author: Piero Proietti
  * email: piero.proietti@gmail.com
  * license: MIT
- * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
  */
 import { IKrillConfig } from '../interfaces/i_krill_config.js';
 import Keyboards from '../../classes/keyboards.js';
@@ -17,7 +17,7 @@ import { users } from './prepare.d/users.js';
 import { network } from './prepare.d/network.js';
 import { summary } from './prepare.d/summary.js';
 /**
- *
+ * Main Krill installer class - Simplified refactoring
  */
 export default class Krill {
     welcome: typeof welcome;
@@ -35,30 +35,55 @@ export default class Krill {
     chroot: boolean;
     halt: boolean;
     /**
-     * constructor
-     * @param unattended
-     * @param nointeractive
-     * @param halt
+     * Constructor
      */
     constructor(unattended?: boolean, nointeractive?: boolean, halt?: boolean, chroot?: boolean);
     /**
-     *
-     * @param krillConfig
-     * @param ip
-     * @param random
-     * @param domain
-     * @param suspend
-     * @param small
-     * @param none
-     * @param crypted
-     * @param pve
-     * @param btrfs
-     * @param testing
-     * @param verbose
+     * Main prepare method - Simplified and cleaner
      */
     prepare(krillConfig?: IKrillConfig, ip?: boolean, random?: boolean, domain?: string, suspend?: boolean, small?: boolean, none?: boolean, crypted?: boolean, pve?: boolean, btrfs?: boolean, testing?: boolean, verbose?: boolean): Promise<void>;
     /**
-     * return true if pv exist
+     * Check system requirements (disks, LVM)
+     */
+    private checkSystemRequirements;
+    /**
+     * Setup configuration files and auto-configure timezone
+     */
+    private setupConfiguration;
+    /**
+     * Auto-configure timezone from internet
+     */
+    private autoConfigureTimezone;
+    /**
+     * Stop system services
+     */
+    private stopSystemServices;
+    /**
+     * Build default configurations
+     */
+    private buildConfigurations;
+    /**
+     * Generate hostname based on options
+     */
+    private generateHostname;
+    /**
+     * Apply options for unattended installation
+     */
+    private applyUnattendedOptions;
+    /**
+     * Run interactive mode with UI
+     */
+    private runInteractiveMode;
+    /**
+     * Perform installation or testing
+     */
+    private performInstallation;
+    /**
+     * Create script to remove LVM partitions
+     */
+    private createLvmRemovalScript;
+    /**
+     * Check if Physical Volumes exist
      */
     private pvExist;
 }

package/dist/krill/classes/prepare.js

@@ -1,21 +1,23 @@
 /**
- * ./src/krill/prepare.tsx
+ * Krill Installer - Simplified Refactoring
+ * ./src/krill/prepare.ts
  * penguins-eggs v.10.0.0 / ecmascript 2020
  * author: Piero Proietti
  * email: piero.proietti@gmail.com
  * license: MIT
- * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
  */
 import os from 'os';
-import axios from 'axios';
-import shx from 'shelljs';
 import fs from 'fs';
+import shx from 'shelljs';
+import axios from 'axios';
+import { SwapChoice, InstallationMode, FsType } from './krill_enums.js';
 import Keyboards from '../../classes/keyboards.js';
 import Locales from '../../classes/locales.js';
 import Systemctl from '../../classes/systemctl.js';
 import Utils from '../../classes/utils.js';
-// libraries
 import { exec } from '../../lib/utils.js';
+import Sequence from './sequence.js';
+// UI Components
 import { welcome } from './prepare.d/welcome.js';
 import { location } from './prepare.d/location.js';
 import { keyboard } from './prepare.d/keyboard.js';
@@ -23,13 +25,12 @@ import { partitions } from './prepare.d/partitions.js';
 import { users } from './prepare.d/users.js';
 import { network } from './prepare.d/network.js';
 import { summary } from './prepare.d/summary.js';
-import Sequence from './sequence.js';
-import { SwapChoice, InstallationMode } from './krill_enums.js';
 const config_file = '/etc/penguins-eggs.d/krill.yaml';
 /**
- *
+ * Main Krill installer class - Simplified refactoring
  */
 export default class Krill {
+    // UI Components
     welcome = welcome;
     location = location;
     keyboard = keyboard;
@@ -37,18 +38,17 @@ export default class Krill {
     users = users;
     network = network;
     summary = summary;
+    // Configuration
     krillConfig = {};
     locales = new Locales();
     keyboards = new Keyboards();
+    // Installation flags
     unattended = false;
     nointeractive = false;
     chroot = false;
     halt = false;
     /**
-     * constructor
-     * @param unattended
-     * @param nointeractive
-     * @param halt
+     * Constructor
      */
     constructor(unattended = false, nointeractive = false, halt = false, chroot = false) {
         this.unattended = unattended;
@@ -57,129 +57,146 @@ export default class Krill {
         this.halt = halt;
     }
     /**
-     *
-     * @param krillConfig
-     * @param ip
-     * @param random
-     * @param domain
-     * @param suspend
-     * @param small
-     * @param none
-     * @param crypted
-     * @param pve
-     * @param btrfs
-     * @param testing
-     * @param verbose
+     * Main prepare method - Simplified and cleaner
      */
     async prepare(krillConfig = {}, ip = false, random = false, domain = '', suspend = false, small = false, none = false, crypted = false, pve = false, btrfs = false, testing = false, verbose = false) {
+        try {
+            // System validation
+            await this.checkSystemRequirements();
+            // Configuration setup
+            this.krillConfig = krillConfig;
+            await this.setupConfiguration();
+            // Stop services
+            await this.stopSystemServices(verbose, testing);
+            // Build configurations
+            const configs = await this.buildConfigurations(ip, random, suspend, small, none);
+            // Interactive or unattended mode
+            const finalConfigs = this.unattended
+                ? this.applyUnattendedOptions(configs, crypted, pve, btrfs)
+                : await this.runInteractiveMode(crypted, pve, btrfs);
+            // Install
+            await this.performInstallation(finalConfigs, domain, testing, verbose);
+        }
+        catch (error) {
+            await Utils.pressKeyToExit(`${error.message}\nkrill installer refuses to continue`);
+            process.exit();
+        }
+    }
+    /**
+     * Check system requirements (disks, LVM)
+     */
+    async checkSystemRequirements() {
         // Check disk presence
         const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
         if (drives[0] === '') {
-            await Utils.pressKeyToExit(`No disk to install the system in this machine.\nkrill installer refuses to continue`);
-            process.exit();
+            throw new Error('No disk to install the system in this machine.');
         }
-        // Check Lvm2 presence
+        // Check LVM presence
         if (await this.pvExist()) {
-            // Create removeLvmPartitions
-            let scriptName = "removeLvmPartitions";
-            let cmds = "#!/bin/bash\n";
-            cmds += `# remove LV (Logical Volumes)\n`;
-            cmds += `vg=$(vgs --noheadings -o vg_name| awk '{$1=$1};1')\n`;
-            cmds += `lvs -o lv_name --noheadings | awk '{$1=$1};1' | while read -r lv; do\n`;
-            cmds += ` lvremove -y /dev/mapper/$vg-$lv\n`;
-            cmds += `done\n`;
-            cmds += `\n`;
-            cmds += `# remove VG (Volume groups)\n`;
-            cmds += `vgremove --force $(vgs --noheadings -o vg_name $vg)\n`;
-            cmds += `\n`;
-            cmds += `# remove PV (Phisical Volumes) \n`;
-            cmds += `pv=$(pvs --noheading -o pv_name | awk '{$1=$1};1')\n`;
-            cmds += `pvremove --force --force $pv\n`;
-            cmds += `# wipe PV (Phisical Volumes) \n`;
-            cmds += `wipefs -a $pv\n`;
-            cmds += `# clean device\n`;
-            cmds += `sgdisk --zap-all $pv\n`;
-            cmds += `dd if=/dev/zero of=$pv bs=1M count=10\n`;
-            fs.writeFileSync(scriptName, cmds);
-            await exec(`chmod +x ${scriptName}`);
-            await Utils.pressKeyToExit(`There is a lvm2 volume in the system, remove it manually before installation.\nkrill installer refuses to continue`);
-            process.exit();
-        }
-        /**
-        * stop udisks2.service
-        */
-        const systemdCtl = new Systemctl(verbose);
-        if (await systemdCtl.isActive('udisks2.service') && !testing) {
-            await systemdCtl.stop('udisks2.service');
+            await this.createLvmRemovalScript();
+            throw new Error('There is a lvm2 volume in the system, remove it manually before installation.');
         }
-        let oWelcome = {};
-        let oLocation = {};
-        let oKeyboard = {};
-        let oPartitions = {};
-        let oUsers = {};
-        let oNetwork = {};
-        /**
-         * load default values
-         */
+    }
+    /**
+     * Setup configuration files and auto-configure timezone
+     */
+    async setupConfiguration() {
+        // Check config file
         if (!fs.existsSync(config_file)) {
-            console.log(`cannot find configuration file ${config_file},`);
-            process.exit(1);
+            throw new Error(`Cannot find configuration file ${config_file}`);
         }
-        this.krillConfig = krillConfig;
-        /**
-         * test calamares/krill configuration presence
-         */
+        // Check calamares/krill configuration
         let configRoot = '/etc/penguins-eggs.d/krill/';
         if (fs.existsSync('/etc/calamares/settings.conf')) {
             configRoot = '/etc/calamares/';
         }
         if (!fs.existsSync(configRoot + 'settings.conf')) {
-            console.log(`Cannot find calamares/krill configuration file, please create it running:`);
-            console.log(`sudo eggs calamares`);
-            process.exit(1);
+            throw new Error('Cannot find calamares/krill configuration file, please create it running: sudo eggs calamares');
         }
-        oWelcome = { language: this.krillConfig.language };
-        // Try to auto-configure timezone by internet
-        const url = `https://geoip.kde.org/v1/calamares`;
+        // Auto-configure timezone
+        await this.autoConfigureTimezone();
+    }
+    /**
+     * Auto-configure timezone from internet
+     */
+    async autoConfigureTimezone() {
         try {
-            const response = await axios.get(url);
+            const response = await axios.get('https://geoip.kde.org/v1/calamares');
             if (response.statusText === 'OK') {
-                const data = JSON.stringify(response.data);
-                const obj = JSON.parse(data);
-                this.krillConfig.region = obj.time_zone.substring(0, obj.time_zone.indexOf('/'));
-                this.krillConfig.zone = obj.time_zone.substring(obj.time_zone.indexOf('/') + 1);
+                const timeZone = response.data.time_zone;
+                this.krillConfig.region = timeZone.substring(0, timeZone.indexOf('/'));
+                this.krillConfig.zone = timeZone.substring(timeZone.indexOf('/') + 1);
             }
         }
         catch (error) {
-            console.error('error: ' + error);
+            console.error('Error auto-configuring timezone:', error);
+        }
+    }
+    /**
+     * Stop system services
+     */
+    async stopSystemServices(verbose, testing) {
+        const systemdCtl = new Systemctl(verbose);
+        if (await systemdCtl.isActive('udisks2.service') && !testing) {
+            await systemdCtl.stop('udisks2.service');
         }
-        oLocation = {
+    }
+    /**
+     * Build default configurations
+     */
+    async buildConfigurations(ip, random, suspend, small, none) {
+        // Generate hostname
+        const hostname = this.generateHostname(ip, random);
+        // Build configuration objects
+        const oWelcome = { language: this.krillConfig.language };
+        const oLocation = {
             language: this.krillConfig.language,
             region: this.krillConfig.region,
             zone: this.krillConfig.zone
         };
-        oKeyboard = {
+        const oKeyboard = {
             keyboardModel: this.krillConfig.keyboardModel,
             keyboardLayout: this.krillConfig.keyboardLayout,
             keyboardVariant: this.krillConfig.keyboardVariant,
             keyboardOption: this.krillConfig.keyboardOption
         };
-        oPartitions = {
+        let userSwapChoice = this.krillConfig.userSwapChoice;
+        if (suspend)
+            userSwapChoice = SwapChoice.Suspend;
+        else if (small)
+            userSwapChoice = SwapChoice.Small;
+        else if (none)
+            userSwapChoice = SwapChoice.None;
+        const oPartitions = {
             installationDevice: this.krillConfig.installationDevice,
             installationMode: this.krillConfig.installationMode,
             filesystemType: this.krillConfig.filesystemType,
-            userSwapChoice: this.krillConfig.userSwapChoice,
+            userSwapChoice,
             replacedPartition: this.krillConfig.replacedPartition
         };
-        if (suspend) {
-            oPartitions.userSwapChoice = SwapChoice.Suspend;
-        }
-        else if (small) {
-            oPartitions.userSwapChoice = SwapChoice.Small;
-        }
-        else if (none) {
-            oPartitions.userSwapChoice = SwapChoice.None;
-        }
+        const oUsers = {
+            username: this.krillConfig.name,
+            fullname: this.krillConfig.fullname,
+            password: this.krillConfig.password,
+            rootPassword: this.krillConfig.rootPassword,
+            autologin: this.krillConfig.autologin,
+            hostname
+        };
+        const oNetwork = {
+            iface: await Utils.iface(),
+            addressType: this.krillConfig.addressType,
+            address: Utils.address(),
+            netmask: Utils.netmask(),
+            gateway: Utils.gateway(),
+            dns: Utils.getDns(),
+            domain: Utils.getDomain()
+        };
+        return { oWelcome, oLocation, oKeyboard, oPartitions, oUsers, oNetwork };
+    }
+    /**
+     * Generate hostname based on options
+     */
+    generateHostname(ip, random) {
         let hostname = this.krillConfig.hostname;
         if (hostname === '') {
             hostname = shx.exec('cat /etc/hostname', { silent: true }).trim();
@@ -193,89 +210,50 @@ export default class Krill {
             const sl = shx.exec(`tr -dc a-z </dev/urandom | head -c 2 ; echo ''`, { silent: true }).trim();
             hostname = `${os.hostname()}-${fl}${n}${sl}`;
         }
-        oUsers = {
-            username: this.krillConfig.name,
-            fullname: this.krillConfig.fullname,
-            password: this.krillConfig.password,
-            rootPassword: this.krillConfig.rootPassword,
-            autologin: this.krillConfig.autologin,
-            hostname: hostname
-        };
-        oNetwork =
-            {
-                iface: await Utils.iface(),
-                addressType: this.krillConfig.addressType,
-                address: Utils.address(),
-                netmask: Utils.netmask(),
-                gateway: Utils.gateway(),
-                dns: Utils.getDns(),
-                domain: Utils.getDomain()
-            };
-        /**
-         * Defaults
-         */
-        /**
-         * random = false,
-         * domain = '',
-         * pve = false
-         * */
-        if (ip) {
-            oUsers.hostname = 'ip-' + Utils.address().replaceAll('.', '-');
-        }
-        // Luks
-        if (crypted) {
-            oPartitions.installationMode = InstallationMode.Luks;
-        }
-        // fs
-        if (btrfs) {
-            oPartitions.filesystemType = 'btrfs';
-        }
-        // swap
-        if (none) {
-            oPartitions.userSwapChoice = SwapChoice.None;
-        }
-        if (small) {
-            oPartitions.userSwapChoice = SwapChoice.Small;
-        }
-        if (suspend) {
-            oPartitions.userSwapChoice = SwapChoice.Suspend;
-        }
-        if (pve) {
+        return hostname;
+    }
+    /**
+     * Apply options for unattended installation
+     */
+    applyUnattendedOptions(configs, crypted, pve, btrfs) {
+        const { oPartitions, oUsers } = configs;
+        // Set defaults for unattended
+        oPartitions.installationMode = InstallationMode.EraseDisk;
+        // Apply options
+        if (btrfs)
+            oPartitions.filesystemType = FsType.btrfs;
+        if (crypted || pve)
             oPartitions.installationMode = InstallationMode.Luks;
-        }
-        /**
-         * interactive
-         */
-        if (!this.unattended) {
-            oWelcome = await this.welcome();
-            oLocation = await this.location(oWelcome.language);
-            oKeyboard = await this.keyboard();
-            oPartitions = await this.partitions(this.krillConfig.installationDevice, crypted, pve, btrfs);
-            oUsers = await this.users();
-            oNetwork = await this.network();
-        }
-        else {
-            /**
-             * this variables ALWAYS need to be initializated
-             */
-            // oPartitions.installationDevice
-            if (oPartitions.installationDevice === '') {
-                // No RAID considerated
-                const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
-                if (drives.length > 0) {
-                    oPartitions.installationDevice = `/dev/` + drives[0];
-                }
-                else {
-                    console.log("Unable to find installation drive");
-                    process.exit(1);
-                }
+        // Set default installation device if empty
+        if (oPartitions.installationDevice === '') {
+            const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
+            if (drives.length > 0) {
+                oPartitions.installationDevice = `/dev/` + drives[0];
+            }
+            else {
+                throw new Error("Unable to find installation drive");
             }
         }
+        return configs;
+    }
+    /**
+     * Run interactive mode with UI
+     */
+    async runInteractiveMode(crypted, pve, btrfs) {
+        const oWelcome = await this.welcome();
+        const oLocation = await this.location(oWelcome.language);
+        const oKeyboard = await this.keyboard();
+        const oPartitions = await this.partitions(this.krillConfig.installationDevice, crypted, pve, btrfs);
+        const oUsers = await this.users();
+        const oNetwork = await this.network();
+        return { oWelcome, oLocation, oKeyboard, oPartitions, oUsers, oNetwork };
+    }
+    /**
+     * Perform installation or testing
+     */
+    async performInstallation(configs, domain, testing, verbose) {
+        const { oLocation, oKeyboard, oPartitions, oUsers, oNetwork } = configs;
         await this.summary(oLocation, oKeyboard, oPartitions, oUsers);
-        /**
-         * INSTALL
-         */
-        const sequence = new Sequence(oLocation, oKeyboard, oPartitions, oUsers, oNetwork);
         if (testing) {
             console.log();
             Utils.titles("install --testing");
@@ -285,30 +263,52 @@ export default class Krill {
             process.exit();
         }
         else {
+            const sequence = new Sequence(oLocation, oKeyboard, oPartitions, oUsers, oNetwork);
             await sequence.start(domain, this.unattended, this.nointeractive, this.chroot, this.halt, verbose);
         }
     }
     /**
-     * return true if pv exist
+     * Create script to remove LVM partitions
+     */
+    async createLvmRemovalScript() {
+        const scriptName = "removeLvmPartitions";
+        let cmds = "#!/bin/bash\n";
+        cmds += `# remove LV (Logical Volumes)\n`;
+        cmds += `vg=$(vgs --noheadings -o vg_name| awk '{$1=$1};1')\n`;
+        cmds += `lvs -o lv_name --noheadings | awk '{$1=$1};1' | while read -r lv; do\n`;
+        cmds += ` lvremove -y /dev/mapper/$vg-$lv\n`;
+        cmds += `done\n`;
+        cmds += `\n`;
+        cmds += `# remove VG (Volume groups)\n`;
+        cmds += `vgremove --force $(vgs --noheadings -o vg_name $vg)\n`;
+        cmds += `\n`;
+        cmds += `# remove PV (Physical Volumes) \n`;
+        cmds += `pv=$(pvs --noheading -o pv_name | awk '{$1=$1};1')\n`;
+        cmds += `pvremove --force --force $pv\n`;
+        cmds += `# wipe PV (Physical Volumes) \n`;
+        cmds += `wipefs -a $pv\n`;
+        cmds += `# clean device\n`;
+        cmds += `sgdisk --zap-all $pv\n`;
+        cmds += `dd if=/dev/zero of=$pv bs=1M count=10\n`;
+        fs.writeFileSync(scriptName, cmds);
+        await exec(`chmod +x ${scriptName}`);
+    }
+    /**
+     * Check if Physical Volumes exist
      */
     async pvExist() {
-        let exist = false;
         const check = `#!/bin/sh\npvdisplay |grep "PV Name" >/dev/null && echo 1|| echo 0`;
-        if (shx.exec(check, { silent: true }).stdout.trim() === '1') {
-            exist = true;
-        }
-        return exist;
+        return shx.exec(check, { silent: true }).stdout.trim() === '1';
     }
 }
 /**
- *
- * @param mask
+ * Utility function for netmask conversion
  */
 function netmask2CIDR(mask) {
     const countCharOccurences = (string, char) => string.split(char).length - 1;
     const decimalToBinary = (dec) => (dec >>> 0).toString(2);
     const getNetMaskParts = (nmask) => nmask.split('.').map(Number);
-    const netmask2CIDR = (netmask) => countCharOccurences(getNetMaskParts(netmask)
+    return countCharOccurences(getNetMaskParts(mask)
         .map(part => decimalToBinary(part))
         .join(''), '1');
 }

package/dist/krill/classes/sequence.d/add_user.js

@@ -6,6 +6,8 @@
  * license: MIT
  * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
  */
+import fs from 'fs';
+import yaml from 'js-yaml';
 import { exec } from '../../../lib/utils.js';
 /**
  *
@@ -35,10 +37,26 @@ export default async function addUser(name = 'live', password = 'evolution', ful
     await exec(cmd, this.echo);
     let group = 'wheel';
     if (this.distro.familyId === 'debian') {
-        group = 'sudo';
+        /**
+         * look to calamares/modules/users.yml for groups
+         */
+        let usersConf = '/etc/calamares/modules/users.conf';
+        if (!fs.existsSync(usersConf)) {
+            usersConf = '/etc/penguins-eggs.d/krill/modules/users.conf';
+        }
+        if (fs.existsSync(usersConf)) {
+            const o = yaml.load(fs.readFileSync(usersConf, 'utf8'));
+            for (const group of o.defaultGroups) {
+                cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+        }
+        else {
+            group = 'sudo';
+        }
+        cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
+        await exec(cmd, this.echo);
     }
-    cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
-    await exec(cmd, this.echo);
     // add autologin group in archlinux
     await exec(cmd, this.echo);
     if (this.distro.familyId === 'archlinux') {

package/dist/krill/classes/sequence.d/partition.js

@@ -54,13 +54,13 @@ export default async function partition() {
     if (installationMode === InstallationMode.Replace) {
         retVal = true;
     }
-    else if (installationMode === InstallationMode.Standard && !this.efi) {
+    else if (installationMode === InstallationMode.EraseDisk && !this.efi) {
         retVal = await this.partitionBiosStandard(installDevice, p);
     }
     else if (installationMode === InstallationMode.Luks && !this.efi) {
         retVal = await this.partitionBiosLuks(installDevice, p);
     }
-    else if (installationMode === InstallationMode.Standard && this.efi) {
+    else if (installationMode === InstallationMode.EraseDisk && this.efi) {
         retVal = await this.partitionUefiStandard(installDevice, p);
     }
     else if (installationMode === InstallationMode.Luks && this.efi) {