penguins-eggs 10.1.0 → 10.1.1

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

@@ -0,0 +1,5 @@
+/**
+ * confirm
+ * @returns
+ */
+export declare function confirm(elem: JSX.Element, msg?: string): Promise<boolean>;

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

@@ -0,0 +1,30 @@
+import Utils from '../../../classes/utils.js';
+import { render } from 'ink';
+/**
+ * confirm
+ * @returns
+ */
+export async function confirm(elem, msg = "Confirm") {
+    redraw(elem);
+    const result = JSON.parse(await Utils.customConfirmAbort(msg));
+    let retval = false;
+    if (result.confirm === 'Yes') {
+        retval = true;
+    }
+    else if (result.confirm === 'Abort') {
+        process.exit();
+    }
+    return retval;
+}
+/**
+ * Occorre farglierlo rigenerare a forza
+ * anche quando NON cambiano i dati
+ * forceUpdate
+ */
+function redraw(elem) {
+    let opt = {};
+    opt.patchConsole = true;
+    opt.debug = false;
+    console.clear();
+    render(elem, opt);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/prepare.d/keyboard.tsx
+ * 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 { IKeyboard } from '../../interfaces/i_krill.js';
+import Prepare from '../prepare.js';
+/**
+ * KEYBOARD
+ */
+export declare function keyboard(this: Prepare): Promise<IKeyboard>;

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

@@ -0,0 +1,62 @@
+/**
+ * ./src/krill/prepare.d/keyboard.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Keyboard from '../../components/keyboard.js';
+import selectKeyboardOption from '../../lib/select_keyboard_option.js';
+import selectKeyboardModel from '../../lib/select_keyboard_model.js';
+import selectKeyboardVariant from '../../lib/select_keyboard_variant.js';
+import selectKeyboardLayout from '../../lib/select_keyboard_layout.js';
+/**
+ * KEYBOARD
+ */
+export async function keyboard() {
+    let keyboardModel = this.krillConfig.keyboardModel;
+    if (keyboardModel === '' || keyboardModel === undefined) {
+        keyboardModel = await this.keyboards.getModel();
+    }
+    let keyboardLayout = this.krillConfig.keyboardLayout;
+    if (keyboardLayout === '' || keyboardLayout === undefined) {
+        keyboardLayout = await this.keyboards.getLayout();
+    }
+    let keyboardVariant = this.krillConfig.keyboardVariant;
+    if (keyboardVariant === '' || keyboardVariant === undefined) {
+        keyboardVariant = await this.keyboards.getVariant();
+    }
+    let keyboardOption = this.krillConfig.keyboardOption;
+    if (keyboardOption === '' || keyboardOption === undefined) {
+        keyboardOption = await this.keyboards.getOption();
+    }
+    let keyboardElem;
+    while (true) {
+        keyboardElem = React.createElement(Keyboard, { keyboardModel: keyboardModel, keyboardLayout: keyboardLayout, keyboardVariant: keyboardVariant, keyboardOptions: keyboardOption });
+        if (await confirm(keyboardElem, "Confirm Keyboard datas?")) {
+            break;
+        }
+        else {
+            keyboardModel = 'pc105';
+            keyboardModel = await selectKeyboardModel(keyboardModel);
+            keyboardLayout = 'us';
+            keyboardLayout = await selectKeyboardLayout(keyboardLayout);
+            keyboardVariant = '';
+            keyboardVariant = await selectKeyboardVariant(keyboardLayout);
+            keyboardOption = '';
+            keyboardOption = await selectKeyboardOption(keyboardOption);
+            if (keyboardModel === '') {
+                keyboardModel = 'pc105';
+            }
+        }
+    }
+    return {
+        keyboardModel: keyboardModel,
+        keyboardLayout: keyboardLayout,
+        keyboardVariant: keyboardVariant,
+        keyboardOption: keyboardOption
+    };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * ./src/krill/prepare.d/welcome.tsx
+ * 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 { ILocation } from '../../interfaces/i_krill.js';
+import Prepare from '../prepare.js';
+/**
+ *
+ * @param this
+ * @param language
+ * @returns
+ */
+export declare function location(this: Prepare, language: string): Promise<ILocation>;

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

@@ -0,0 +1,59 @@
+/**
+ * ./src/krill/prepare.d/welcome.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Location from '../../components/location.js';
+import selectRegions from '../../lib/select_regions.js';
+import selectZones from '../../lib/select_zones.js';
+import axios from 'axios';
+import shx from 'shelljs';
+/**
+ *
+ * @param this
+ * @param language
+ * @returns
+ */
+export async function location(language) {
+    let region = this.krillConfig.region;
+    if (region === '' || region === undefined) {
+        let region = shx.exec('cut -f1 -d/ < /etc/timezone', { silent: true }).stdout.trim();
+    }
+    let zone = this.krillConfig.zone;
+    if (zone === '' || zone === undefined) {
+        zone = shx.exec('cut -f2 -d/ < /etc/timezone', { silent: true }).stdout.trim();
+    }
+    // Try to auto-configure timezone by internet
+    const url = `https://geoip.kde.org/v1/calamares`;
+    try {
+        const response = await axios.get(url);
+        if (response.statusText === 'OK') {
+            const data = JSON.stringify(response.data);
+            const obj = JSON.parse(data);
+            region = obj.time_zone.substring(0, obj.time_zone.indexOf('/'));
+            zone = obj.time_zone.substring(obj.time_zone.indexOf('/') + 1);
+        }
+    }
+    catch (error) {
+        console.error('error: ' + error);
+    }
+    let locationElem;
+    while (true) {
+        locationElem = React.createElement(Location, { language: language, region: region, zone: zone });
+        if (await confirm(locationElem, "Confirm location datas?")) {
+            break;
+        }
+        region = await selectRegions(region);
+        zone = await selectZones(region);
+    }
+    return {
+        language: language,
+        region: region,
+        zone: zone
+    };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/prepare.d/welcome.tsx
+ * 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 { INet } from '../../../interfaces/index.js';
+import Prepare from '../prepare.js';
+/**
+   * Network
+   */
+export declare function network(this: Prepare): Promise<INet>;

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

@@ -0,0 +1,68 @@
+/**
+ * ./src/krill/prepare.d/welcome.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Network from '../../components/network.js';
+import Utils from '../../../classes/utils.js';
+import selectInterface from '../../lib/select_interface.js';
+import selectAddressType from '../../lib/select_address_type.js';
+import getAddress from '../../lib/get_address.js';
+import getNetmask from '../../lib/get_netmask.js';
+import getGateway from '../../lib/get_gateway.js';
+import getDomain from '../../lib/get_domain.js';
+import getDns from '../../lib/get_dns.js';
+import fs from 'fs';
+/**
+   * Network
+   */
+export async function network() {
+    const i = {};
+    const ifaces = fs.readdirSync('/sys/class/net/');
+    i.iface = await Utils.iface();
+    i.addressType = 'dhcp';
+    i.address = Utils.address();
+    i.netmask = Utils.netmask();
+    i.gateway = Utils.gateway();
+    i.dns = Utils.getDns();
+    i.domain = Utils.getDomain();
+    let dnsString = '';
+    for (let c = 0; c < i.dns.length; c++) {
+        dnsString += i.dns[c].trim();
+        if (c < i.dns.length - 1) {
+            dnsString += '; ';
+        }
+    }
+    let networkElem;
+    while (true) {
+        networkElem = React.createElement(Network, { iface: i.iface, addressType: i.addressType, address: i.address, netmask: i.netmask, gateway: i.gateway, domain: i.domain, dns: dnsString });
+        if (await confirm(networkElem, "Confirm Network datas?")) {
+            break;
+        }
+        i.iface = await selectInterface(i.iface, ifaces);
+        i.addressType = await selectAddressType();
+        if (i.addressType === 'static') {
+            i.address = await getAddress(i.address);
+            i.netmask = await getNetmask(i.netmask);
+            i.gateway = await getGateway(i.gateway);
+            i.domain = await getDomain(i.domain);
+            if (i.domain.at(0) !== '.') {
+                i.domain = '.' + i.domain;
+            }
+            i.dns = (await getDns(dnsString)).split(';');
+            dnsString = '';
+            for (let c = 0; c < i.dns.length; c++) {
+                dnsString += i.dns[c].trim();
+                if (c < i.dns.length - 1) {
+                    dnsString += '; ';
+                }
+            }
+        }
+    }
+    return i;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/prepare.d/partitions.tsx
+ * 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 { IPartitions } from '../../interfaces/i_krill.js';
+import Prepare from '../prepare.js';
+/**
+ * PARTITIONS
+ */
+export declare function partitions(this: Prepare, installationDevice?: string, crypted?: boolean, pve?: boolean, btrfs?: boolean): Promise<IPartitions>;

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

@@ -0,0 +1,86 @@
+/**
+ * ./src/krill/prepare.d/partitions.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Partitions from '../../components/partitions.js';
+import { SwapChoice, InstallationMode } from '../krill_enums.js';
+import selectFileSystemType from '../../lib/select_filesystem_type.js';
+import selectInstallationDevice from '../../lib/select_installation_device.js';
+import selectReplacedPartition from '../../lib/select_replaced_partition.js';
+import selectUserSwapChoice from '../../lib/select_user_swap_choice.js';
+import shx from 'shelljs';
+import selectInstallationMode from '../../lib/select_installation_mode.js';
+/**
+ * PARTITIONS
+ */
+export async function partitions(installationDevice = "", crypted = false, pve = false, btrfs = false) {
+    // Calamares won't use any devices with iso9660 filesystem on it.
+    const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
+    let driveList = [];
+    drives.forEach((element) => {
+        if (!element.includes('zram')) {
+            driveList.push('/dev/' + element);
+        }
+    });
+    installationDevice = driveList[0]; // Solo per selezionare il default
+    let replacedPartition = this.krillConfig.replacedPartition;
+    let installationMode = this.krillConfig.installationMode;
+    let knownInstallationModes = Object.values(InstallationMode);
+    let knownSwapChoices = Object.values(SwapChoice);
+    if (!knownInstallationModes.includes(installationMode)) {
+        installationMode = InstallationMode.EraseDisk;
+    }
+    if (crypted) {
+        installationMode = InstallationMode.Luks;
+    }
+    let filesystemType = 'ext4';
+    let userSwapChoice = {};
+    if (knownSwapChoices.includes(this.krillConfig.userSwapChoice))
+        userSwapChoice = this.krillConfig.userSwapChoice;
+    else {
+        userSwapChoice = SwapChoice.Small;
+    }
+    let partitionsElem;
+    while (true) {
+        partitionsElem = React.createElement(Partitions, { installationDevice: installationDevice, installationMode: installationMode, filesystemType: filesystemType, userSwapChoice: userSwapChoice, replacedPartition: replacedPartition });
+        if (await confirm(partitionsElem, "Confirm Partitions datas?")) {
+            break;
+        }
+        else {
+            installationDevice = driveList[0]; // Solo per selezionare il default
+            installationMode = InstallationMode.EraseDisk;
+            if (crypted) {
+                installationMode = InstallationMode.Luks;
+            }
+            installationDevice = await selectInstallationDevice();
+            installationMode = await selectInstallationMode();
+            if (installationMode === InstallationMode.Replace) {
+                replacedPartition = await selectReplacedPartition();
+                filesystemType = await selectFileSystemType();
+                userSwapChoice = SwapChoice.File;
+            }
+            else if (installationMode === InstallationMode.EraseDisk) {
+                replacedPartition = "";
+                filesystemType = await selectFileSystemType();
+                userSwapChoice = await selectUserSwapChoice(userSwapChoice);
+            }
+            else if (installationMode === InstallationMode.Luks) {
+                replacedPartition = "";
+                userSwapChoice = SwapChoice.File;
+            }
+        }
+    }
+    return {
+        installationDevice: installationDevice,
+        installationMode: installationMode,
+        filesystemType: filesystemType,
+        userSwapChoice: userSwapChoice,
+        replacedPartition: replacedPartition
+    };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * ./src/krill/prepare.d/keyboard.tsx
+ * 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 { IKeyboard } from '../../interfaces/i_krill.js';
+import Prepare from '../prepare.js';
+import { ILocation, IPartitions, IUsers } from '../../interfaces/i_krill.js';
+/**
+ * SUMMARY
+ */
+export declare function summary(this: Prepare, location: ILocation, keyboard: IKeyboard, partitions: IPartitions, users: IUsers): Promise<void>;

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

@@ -0,0 +1,69 @@
+/**
+ * ./src/krill/prepare.d/keyboard.tsx
+ * 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 React from 'react';
+import { render } from 'ink';
+import { confirm } from './confirm.js';
+import Summary from '../../components/summary.js';
+import { InstallationMode } from '../krill_enums.js';
+/**
+ * SUMMARY
+ */
+export async function summary(location, keyboard, partitions, users) {
+    let summaryElem;
+    let message = `Double check: data on disk: ${partitions.installationDevice} will be completely erased!`;
+    let erase = `Disk ${partitions.installationDevice} will be formatted as: ${partitions.filesystemType}`;
+    if (partitions.installationMode === InstallationMode.Replace) {
+        message = `Double check: data on partition ${partitions.replacedPartition} will be completely erased!`;
+        erase = `Partition ${partitions.replacedPartition} will be formatted as: ${partitions.filesystemType}`;
+    }
+    if (this.unattended && this.nointeractive) {
+        message = `Unattended installation will start in 5 seconds...\npress CTRL-C to abort!`;
+    }
+    while (true) {
+        summaryElem = React.createElement(Summary, { username: users.username, password: users.password, rootPassword: users.rootPassword, hostname: users.hostname, region: location.region, zone: location.zone, language: location.language, keyboardModel: keyboard.keyboardModel, keyboardLayout: keyboard.keyboardLayout, installationDevice: partitions.installationDevice, filesystemType: partitions.filesystemType, message: message, erase: erase });
+        if (this.unattended && this.nointeractive) {
+            redraw(summaryElem);
+            await sleep(5000);
+            break;
+        }
+        else if (this.unattended && !this.nointeractive) {
+            if (await confirm(summaryElem, "Read the Summary, confirm or abort")) {
+                break;
+            }
+            else {
+                process.exit(0);
+            }
+        }
+        else if (await confirm(summaryElem, "Confirm Summary datas?")) {
+            break;
+        }
+    }
+}
+/**
+ * Occorre farglierlo rigenerare a forza
+ * anche quando NON cambiano i dati
+ * forceUpdate
+ */
+function redraw(elem) {
+    let opt = {};
+    opt.patchConsole = true;
+    opt.debug = false;
+    console.clear();
+    render(elem, opt);
+}
+/**
+ *
+ * @param ms
+ * @returns
+ */
+function sleep(ms = 0) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

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

@@ -0,0 +1,6 @@
+import { IUsers } from '../../interfaces/i_krill.js';
+import Prepare from '../prepare.js';
+/**
+ * USERS
+ */
+export declare function users(this: Prepare): Promise<IUsers>;

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

@@ -0,0 +1,63 @@
+/**
+ * ./src/krill/prepare.d/users.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Users from '../../components/users.js';
+import getUsername from '../../lib/get_username.js';
+import getUserfullname from '../../lib/get_userfullname.js';
+import getPassword from '../../lib/get_password.js';
+import getHostname from '../../lib/get_hostname.js';
+import shx from 'shelljs';
+/**
+ * USERS
+ */
+export async function users() {
+    let username = this.krillConfig.name;
+    if (username === '' || username === undefined) {
+        username = 'artisan';
+    }
+    let fullname = this.krillConfig.fullname;
+    if (fullname === '' || fullname === undefined) {
+        fullname = username;
+    }
+    let password = this.krillConfig.password;
+    if (password === '' || password === undefined) {
+        password = 'evolution';
+    }
+    let rootPassword = this.krillConfig.rootPassword;
+    if (rootPassword === '' || rootPassword === undefined) {
+        rootPassword = 'evolution';
+    }
+    let hostname = this.krillConfig.hostname;
+    if (hostname === '' || hostname === undefined) {
+        hostname = shx.exec('cat /etc/hostname').trim();
+    }
+    let autologin = true;
+    let sameUserPassword = true;
+    let usersElem;
+    while (true) {
+        usersElem = React.createElement(Users, { username: username, fullname: fullname, hostname: hostname, password: password, rootPassword: rootPassword, autologin: autologin, sameUserPassword: sameUserPassword });
+        if (await confirm(usersElem, "Confirm Users datas?")) {
+            break;
+        }
+        username = await getUsername(username);
+        fullname = await getUserfullname(fullname);
+        password = await getPassword(username, password);
+        rootPassword = await getPassword('root', password);
+        hostname = await getHostname(hostname);
+    }
+    return {
+        username: username,
+        fullname: fullname,
+        password: password,
+        rootPassword: rootPassword,
+        autologin: autologin,
+        hostname: hostname
+    };
+}

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

@@ -0,0 +1,6 @@
+import Prepare from '../prepare.js';
+import { IWelcome } from '../../interfaces/i_krill.js';
+/**
+ * WELCOME
+ */
+export declare function welcome(this: Prepare): Promise<IWelcome>;

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

@@ -0,0 +1,30 @@
+/**
+ * ./src/krill/prepare.d/welcome.tsx
+ * 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 React from 'react';
+import { confirm } from './confirm.js';
+import Welcome from '../../components/welcome.js';
+import selectLanguages from '../../lib/select_languages.js';
+/**
+ * WELCOME
+ */
+export async function welcome() {
+    let language = this.krillConfig.language;
+    if (language === '' || language === undefined) {
+        language = await this.locales.getDefault(); // 'en_US.UTF-8'
+    }
+    let welcomeElem;
+    while (true) {
+        welcomeElem = React.createElement(Welcome, { language: language });
+        if (await confirm(welcomeElem, "Confirm Welcome datas?")) {
+            break;
+        }
+        language = await selectLanguages(language);
+    }
+    return { language: language };
+}

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

@@ -0,0 +1,89 @@
+/**
+ * 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
+ */
+import { IKrillConfig } from '../interfaces/i_krill_config.js';
+import Keyboards from '../../classes/keyboards.js';
+import Locales from '../../classes/locales.js';
+import { welcome } from './prepare.d/welcome.js';
+import { location } from './prepare.d/location.js';
+import { keyboard } from './prepare.d/keyboard.js';
+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';
+/**
+ * Main Krill installer class - Simplified refactoring
+ */
+export default class Krill {
+    welcome: typeof welcome;
+    location: typeof location;
+    keyboard: typeof keyboard;
+    partitions: typeof partitions;
+    users: typeof users;
+    network: typeof network;
+    summary: typeof summary;
+    krillConfig: IKrillConfig;
+    locales: Locales;
+    keyboards: Keyboards;
+    unattended: boolean;
+    nointeractive: boolean;
+    chroot: boolean;
+    halt: boolean;
+    /**
+     * Constructor
+     */
+    constructor(unattended?: boolean, nointeractive?: boolean, halt?: boolean, chroot?: boolean);
+    /**
+     * 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>;
+    /**
+     * 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;
+}