Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/altercation/archblocks

Arch Linux Modular Install Script
https://github.com/altercation/archblocks

Last synced: 5 days ago
JSON representation

Arch Linux Modular Install Script

Awesome Lists containing this project

README 

        
archblocks

==========



ArchBlocks - a minimal, modular, manual install framework



## WHAT:



ArchBlocks is a very lightweight framework for creating quick, modular, *non-interactive* Arch Linux install scripts tailored to specific systems. It is accessible via a single quick curl downloadable script (from, for example, github).



## WHERE:



Example repo at https://github.com/altercation/archblocks

Arch BBS: https://bbs.archlinux.org/viewtopic.php?id=149597



## EXAMPLE:



Boot Arch install media (in the example config I expect an EFI boot, but it's trivial to make this work for non EFI):



    # curl -sfL https://raw.github.com/altercation/archblocks/master/install_tau.sh > install.sh; bash install.sh



or in short url form:



    # curl -sfL http://git.io/rQx7Xw > install.sh; bash install.sh



(this then sources the blocks of code remotely and configures the system based on the specific blocks called and variables set in in; see below)



## WHAT IT ISN'T:



ArchBlocks is not an interactive general purpose script that asks you what you'd like. You *must* customize it (or its blocks) as much as any other install script. ArchBlocks simply makes this process easier to maintain as a single project that is applicable for multiple systems.



## WHY:



Many somewhat experienced Arch users end up building lightweight install scripts to set up their systems. I've been wanting to modularize my own install scripts such that multiple, different system types (laptop/server/desktop/headless) can reuse most of the common elements easily and swap out blocks of code as needed.



AND YET it's easy to make something like this far too complex. To paraphrase the Ruby community: Arch is Simple so Our Utilities Are Simple. ArchBlocks kickstarts off a *single* "configuration" script and loads blocks from a *single* directory (remote or local, doesn't matter).



(I've previously written extensive additions to AIF before it was frozen in carbonite, and that experience convinced me of the value of a non-interactive, simple install script based approach).



## NO REALLY, WHY NOT JUST MONOLITHIC INSTALL SCRIPTS, WHY MODULAR:



There is install code that may be impacted by changes to Arch, or I sometimes want to improve the way I handle some part of the installation. This may impact multiple systems. Rather than update and maintain five different manual install scripts, modular is better approach. A simple example is the various `NETWORK_*` blocks. I can keep using the default network setup method in most of my scripts and use a light weight / minimal network install method by just swapping out a block. This minimal install script can be revised and all systems that I install with it in future will make use of the revision.



## BUT INSTALLING ARCH IS EASY



It is. It's mostly the filesystem and bootloader varieties which create complexity for me. This addresses that.



Another benefit of this modular approach is I can include post-flight app installation a per machine basis (my server gets nginx, my laptop gets dwarffortress). All automated.



## DETAILS:



Each system I install gets a single config file (the "tau" script in the example above is a laptop). This script loads a few very lightweight helper functions (maintained in a lib file for reuse across "config" scripts) and then loads blocks from the (surprise) blocks directory (local or remote). These blocks are almost all just simple blocks of bash script. The only exceptions should be very clear from the example: there are a few functions that are very specific to the filesytem configuration that must be sprinkled throughout the code. These functions and their intended sequence in the script are easily identified by name such as FILESYSTEM_PRE_BASEINSTALL (in this case FILESYSTEM_PRE_BASEINSTALL is either a null function or does something as defined in the FILESYSTEM block).



A config/install script (the only script you need to manually execute) looks like this (actual script I use to install Arch on a Thinkpad x220):



    # RESPOSITORY ------------------------------------------------------------

    REMOTE=https://raw.github.com/altercation/archblocks/dev

    

    # CONFIG -----------------------------------------------------------------

    HOSTNAME=tau

    USERNAME=es

    USERSHELL=/bin/bash

    FONT=Lat2-Terminus16

    FONT_MAP=8859-1_to_uni

    LANGUAGE=en_US.UTF-8

    KEYMAP=us

    TIMEZONE=US/Pacific

    MODULES="dm_mod dm_crypt aes_x86_64 ext2 ext4 vfat intel_agp drm i915"

    HOOKS="base udev autodetect pata scsi sata usb usbinput consolefont encrypt filesystems fsck"

    KERNEL_PARAMS="quiet" # set/used in FILESYSTEM,INIT,BOOTLOADER blocks (this gets added to)

    INSTALL_DRIVE=/dev/sda # this overrides any default value set in FILESYSTEM block

    

    # BLOCKS -----------------------------------------------------------------

    TIME=common/time_ntp_utc

    FILESYSTEM=filesystem/gpt_luks_passphrase_ext4

    BOOTLOADER=bootloader/efi_gummiboot

    NETWORK=network/wired_wireless_minimal

    AUDIO=common/audio_alsa

    POWER=common/power_acpi

    XORG=xorg/xorg_wacom_fonts

    VIDEO=xorg/video_mesa_default

    DESKTOP=xorg/desktop_xmonad_minimal

    HARDWARE=hardware/laptop/lenovo_thinkpad_x220

    APPSETS="appsets/cli_utils appsets/edu_utils appsets/vim_core appsets/mutt_core appsets/git_default appsets/server_utils"

    PACKAGES="git"

    AURPACKAGES=

    

    # EXECUTE ----------------------------------------------------------------

    . <(curl -fsL "${REMOTE}/blocks/_lib/helpers.sh"); _loadblock "_lib/core"



The blocks subdirectory (the only subdirectory used) contains blocks of simple bash script and looks something like this (note the variants in items like NETWORK... I am working on alternates for FILESYSTEM and BOOTLOADER as well, but the principle should be clear)::



    ├── blocks

    │   ├── _lib

    │   │   ├── core.sh <---------------------------- 2. this is the main script,

    │   │   │                                            no need to customize unless

    │   │   │                                            you want to.

    │   │   └── helpers.sh <------------------------- 3. helper function library

    │   │

    │   ├── appsets

    │   │   ├── aurhelper_aura.sh

    │   │   └── server_utils.sh

    │   │

    │   ├── bootloader

    │   │   ├── bios_grub2.sh

    │   │   └── efi_gummiboot.sh

    │   │

    │   ├── common

    │   │   ├── audio_alsa.sh

    │   │   ├── host_default.sh

    │   │   ├── init_systemd.sh

    │   │   ├── install_pacstrap.sh

    │   │   ├── locale_default.sh

    │   │   ├── postflight_rootpass.sh

    │   │   ├── postflight_sudouser.sh

    │   │   ├── power_acpi.sh

    │   │   ├── ramdisk_default.sh

    │   │   └── time_ntp_utc.sh

    │   │

    │   ├── filesystem

    │   │   ├── gpt_luks_passphrase_ext4.sh

    │   │   └── mbr_default.sh

    │   │

    │   ├── hardware

    │   │   ├── desktop

    │   │   ├── laptop

    │   │   │   └── lenovo_thinkpad_x220.sh <-------- 4. custom, per-hardware tweaks

    │   │   ├── peripheral

    │   │   └── server

    │   │

    │   ├── init

    │   │   └── systemd_pure.sh

    │   │

    │   ├── network

    │   │   ├── wired_wireless_default.sh

    │   │   └── wired_wireless_minimal.sh

    │   │

    │   └── xorg

    │       ├── desktop_xmonad_minimal.sh

    │       ├── video_mesa_default.sh

    │       ├── xorg_default.sh

    │       └── xorg_wacom_fonts.sh

    │

    └── example.sh <--------------------------------- 1. this is the initial installer

    

That's it, really. Nothing fancy. Comprehensible, reusable, modular.



If you want to use something like this, fork away.