archlinux 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f95fc88d318bc67d0abe5281c5eb940ed50e024f9f064f3af4c3d6a72edbcc87
+  data.tar.gz: 55e6b4029e5920f2e659f4cf4c0e532cc1216f7570bb9064836284027697d397
+SHA512:
+  metadata.gz: cf9d3e93c200ec678bcb960dddb13c16fa534387104e22a02f64d0a66f1bd740c92bcf1fd318cbe4cd7c8864bece2ca709b5acdee667cb196ce9a106f9453542
+  data.tar.gz: d7b4b04d3412daf906d20fb94c7f4d9451dc4007dae41b3c23c3d22c857a92e0a5b2e7c4e63f709a8a32f41e255ec532c795d1328e75c5fe749c88a42c51cbe3

data/README.md

@@ -0,0 +1,110 @@
+# Archlinux
+
+> [!WARNING]
+> this can break your system, don't use it on your running system
+
+A ruby API to manage the state of an Archlinux system.
+
+* This project is early alpha
+* It aims to have a DSL like NixOS for Archlinux
+* It allow declaring the state of the system then it applies that to the current system
+* The idea is to have simple and user friendly API to declare everything, system and user related
+
+## Getting started
+
+The project is a Ruby Gem. Create a ruby file and require the gem:
+
+```ruby
+require 'bundler/inline'
+
+gemfile do
+  source "https://rubygems.org"
+
+  gem "archlinux", github: "emad-elsaid/archlinux"
+end
+```
+
+Use `linux` function to define your system state, for example:
+
+```ruby
+linux do
+  hostname 'earth'
+
+  timedate timezone: 'Europe/Berlin',
+           ntp: true
+
+  locale "en_US.UTF-8"
+  keyboard keymap: 'us',
+           layout: "us,ara",
+           model: "",
+           variant: "",
+           options: "ctrl:nocaps,caps:lctrl,ctrl:swap_lalt_lctl,grp:alt_space_toggle"
+
+  package %w[
+          linux
+          linux-firmware
+          linux-headers
+          base
+          base-devel
+          bash-completion
+          pacman-contrib
+          docker
+          locate
+          syncthing
+          ]
+
+  service %w[
+          docker
+          NetworkManager
+          ]
+
+  timer 'plocate-updatedb'
+
+  user 'smith', groups: ['wheel', 'docker'] do
+    aur %w[
+        kernel-install-mkinitcpio
+        google-chrome
+        ]
+
+    service %w[
+            ssh-agent
+            syncthing
+            ]
+
+    copy './user/.config/.', '/home/smith/.config'
+  end
+
+  firewall :syncthing
+
+  on_finalize do
+    sudo 'bootctl install'
+    sudo 'reinstall-kernels'
+  end
+
+  file '/etc/X11/xorg.conf.d/40-touchpad.conf', <<~EOT
+  Section "InputClass"
+          Identifier "libinput touchpad catchall"
+          MatchIsTouchpad "on"
+          MatchDevicePath "/dev/input/event*"
+          Driver "libinput"
+          Option "Tapping" "on"
+          Option "NaturalScrolling" "true"
+  EndSection
+  EOT
+
+  replace '/etc/mkinitcpio.conf', /^(.*)base udev(.*)$/, '\1systemd\2'
+end
+```
+
+Now you can run the script with ruby as root:
+
+```shell
+sudo ruby <script-name.rb>
+```
+
+
+It will do the following:
+- Install missing packages, remove any other package
+- Make sure services and timers are running
+- Do other configurations like locale, X11 keyboard settings, hostname
+- Ensure users are created and in specified groups

data/archlinux.gemspec

@@ -0,0 +1,9 @@
+Gem::Specification.new do |s|
+  s.authors     = ["Emad Elsaid"]
+  s.homepage    = "https://github.com/emad-elsaid/archlinux"
+  s.files       = `git ls-files`.lines.map(&:chomp)
+  s.name        = 'archlinux'
+  s.summary     = "Archlinux DSL to manage whole system state"
+  s.version     = '0.0.0'
+  s.licenses     = ["GPL-3.0-or-later"]
+end

data/lib/archlinux.rb

@@ -0,0 +1,5 @@
+require_relative 'core'
+require_relative 'utils'
+require_relative 'declarations'
+
+Signal.trap("INT") { exit } # Suppress stack trace on Ctrl-C

data/lib/core.rb

@@ -0,0 +1,72 @@
+# ==============================================================
+# CORE:
+# State of the system It should hold all the information we need to build the
+# system, packages, files, changes...etc. everything will run inside an instance
+# of this class
+# ==============================================================
+class State
+  def apply(block)
+    instance_eval &block
+  end
+
+  # Run block on prepare step. id identifies the block uniqueness in the steps.
+  # registering a block with same id multiple times replaces old block by new
+  # one. if id is nil the block location in source code is used as an id
+  def on_prepare(id=nil, &block)
+    id ||=  caller_locations(1,1).first.to_s
+    @prepare_steps ||= {}
+    @prepare_steps[id] = block
+  end
+
+  # Same as on_prepare but for install step
+  def on_install(id=nil, &block)
+    id ||=  caller_locations(1,1).first.to_s
+    @install_steps ||= {}
+    @install_steps[id] = block
+  end
+
+  # Same as on_prepare but for configure step
+  def on_configure(id=nil, &block)
+    id ||=  caller_locations(1,1).first.to_s
+    @configure_steps ||= {}
+    @configure_steps[id] = block
+  end
+
+  # Same as on_finalize but for configure step
+  def on_finalize(id=nil, &block)
+    id ||=  caller_locations(1,1).first.to_s
+    @finalize_steps ||= {}
+    @finalize_steps[id] = block
+  end
+
+  # Run all registered code blocks in the following order: Prepare, Install, Configure, Finalize
+  def run_steps
+    if @prepare_steps&.any?
+      log "=> Prepare"
+      @prepare_steps.each { |_, step| apply(step) }
+    end
+
+    if @install_steps&.any?
+      log "=> Install"
+      @install_steps.each { |_, step| apply(step) }
+    end
+
+    if @configure_steps&.any?
+      log "=> Configure"
+      @configure_steps.each { |_, step| apply(step) }
+    end
+
+    if @finalize_steps&.any?
+      log "=> Finalize"
+      @finalize_steps.each { |_, step| apply(step) }
+    end
+  end
+end
+
+# passed block will run in the context of a State instance and then a builder
+# will build this state
+def linux(&block)
+  s = State.new
+  s.apply(block)
+  s.run_steps
+end

data/lib/declarations.rb

@@ -0,0 +1,243 @@
+require 'set'
+require 'fileutils'
+
+# ==============================================================
+# DECLARATIONS:
+# Functions the user will run to declare the state of the system
+# like packages to be present, files, services, user, group...etc
+# ==============================================================
+
+# Install a package on install step and remove packages not registered with this
+# function
+def package(*names)
+  names.flatten!
+  @packages ||= Set.new
+  @packages += names.map(&:to_s)
+
+  # install step to install packages required and remove not required
+  on_install do
+    # install packages list as is
+    names = @packages.join(" ")
+    log "Installing packages", packages: @packages
+    sudo "pacman --noconfirm --needed -S #{names}" unless @packages.empty?
+
+    # expand groups to packages
+    group_packages = Set.new(`pacman --quiet -Sg #{names}`.lines.map(&:strip))
+
+    # full list of packages that should exist on the system
+    all = @packages + group_packages
+
+    # actual list on the system
+    installed = Set.new(`pacman -Q --quiet --explicit --unrequired --native`.lines.map(&:strip))
+
+    unneeded = installed - all
+    next if unneeded.empty?
+
+    log "Removing packages", packages: unneeded
+    sudo("pacman -Rs #{unneeded.join(" ")}")
+  end
+
+end
+
+# aur command to install packages from aur on install step
+def aur(*names)
+  names.flatten!
+  @aurs ||= Set.new
+  @aurs += names.map(&:to_s)
+
+  on_install do
+    names = @aurs || []
+    log "Install AUR packages", packages: names
+    cache = "./cache/aur"
+    FileUtils.mkdir_p cache
+    Dir.chdir cache do
+      names.each do |package|
+        system("git clone --depth 1 --shallow-submodules https://aur.archlinux.org/#{package}.git") unless Dir.exists?(package)
+        Dir.chdir package do
+          system("makepkg --syncdeps --install --noconfirm --needed")
+        end
+      end
+    end
+  end
+end
+
+# set timezone and NTP settings during prepare step
+def timedate(timezone: 'UTC', ntp: true)
+  @timedate = {timezone: timezone, ntp: ntp}
+
+  on_configure do
+    log "Set timedate", @timedate
+    sudo "timedatectl set-timezone #{@timedate[:timezone]}"
+    sudo "timedatectl set-ntp #{@timedate[:ntp]}"
+  end
+end
+
+# enable system service if root or user service if not during finalize step
+def service(*names)
+  names.flatten!
+  @services ||= Set.new
+  @services += names.map(&:to_s)
+
+  on_finalize do
+    log "Enable services", services: @services
+    user_flags = root? ? "" : "--user"
+
+    system "systemctl enable #{user_flags} #{@services.join(" ")}"
+
+    # Disable services that were enabled manually and not in the list we have
+    services = `systemctl list-unit-files #{user_flags} --state=enabled --type=service --no-legend --no-pager`
+    enabled_manually = services.lines.map{|l| l.strip.split(/\s+/) }.select{|l| (l[1] == 'enabled') && (l[2] == 'disabled')}
+    names_without_extension = enabled_manually.map{|l| l.first.delete_suffix(".service") }
+    to_disable = names_without_extension - @services.to_a
+
+    next if to_disable.empty?
+
+    log "Services to disable", packages: to_disable
+    # system "systemctl disable #{user_flags} #{to_disable.join(" ")}"
+  end
+end
+
+# enable system timer if root or user timer if not during finalize step
+def timer(*names)
+  names.flatten!
+  @timers ||= Set.new
+  @timers += names.map(&:to_s)
+
+  on_finalize do
+    log "Enable timers", timers: @timers
+    timers = @timers.map{ |t| "#{t}.timer" }.join(" ")
+    if root?
+      sudo "systemctl enable #{timers}"
+    else
+      system "systemctl enable --user #{timers}"
+    end
+    # disable all other timers
+  end
+end
+
+# set keyboard settings during prepare step
+def keyboard(keymap: nil, layout: nil, model: nil, variant: nil, options: nil)
+  @keyboard ||= {}
+  values = {
+    keymap: keymap,
+    layout: layout,
+    model: model,
+    variant: variant,
+    options: options
+  }.compact
+  @keyboard.merge!(values)
+
+  on_prepare do
+    next unless @keyboard[:keymap]
+
+    sudo "localectl set-keymap #{@keyboard[:keymap]}"
+
+    m = @keyboard.to_h.slice(:layout, :model, :variant, :options)
+    sudo "localectl set-x11-keymap \"#{m[:layout]}\" \"#{m[:model]}\" \"#{m[:variant]}\" \"#{m[:options]}\""
+  end
+end
+
+def locale(value)
+  @locale = value
+
+  on_prepare do
+    sudo "localectl set-locale #{@locale}"
+  end
+end
+
+# create a user and assign a set of group. if block is passes the block will run
+# in as this user. block will run during the configure step
+def user(name, groups: [], &block)
+  name = name.to_s
+
+  @user ||= {}
+  @user[name] ||= {}
+  @user[name][:groups] ||= []
+  @user[name][:groups] += groups.map(&:to_s)
+  @user[name][:state] = State.new
+  @user[name][:state].apply(block) if block_given?
+
+  on_configure do
+    @user.each do |name, conf|
+      exists = Etc.getpwnam name rescue nil
+      sudo "useradd #{name}" if exists
+      sudo "usermod --groups #{groups.join(",")} #{name}" if groups.any?
+
+      fork do
+        currentuser = Etc.getpwnam(name)
+        Process::GID.change_privilege(currentuser.gid)
+        Process::UID.change_privilege(currentuser.uid)
+        ENV['XDG_RUNTIME_DIR'] = "/run/user/#{currentuser.uid}"
+        conf[:state].run_steps
+      end
+
+      Process.wait
+    end
+  end
+end
+
+# Copy src inside dest during configure step, if src/. will copy src content to dest
+def copy(src, dest)
+  @copy ||= []
+  @copy << { src: src, dest: dest }
+
+  on_configure do
+    next unless @copy
+    next if @copy.empty?
+
+    @copy.each do |item|
+      log "Copying", item
+      FileUtils.cp_r item[:src], item[:dest]
+    end
+  end
+end
+
+# Replace a regex pattern with replacement string in a file during configure step
+def replace(file, pattern, replacement)
+  @replace ||= []
+  @replace << {file: file, pattern: pattern, replacement: replacement}
+
+  on_configure do
+    @replace.each do |params|
+      input = File.read(params[:file])
+      output = input.gsub(params[:pattern], params[:replacement])
+      File.write(params[:file], output)
+    end
+  end
+end
+
+# setup add ufw enable it and allow ports during configure step
+def firewall(*allow)
+  @firewall ||= Set.new
+  @firewall += allow.map(&:to_s)
+
+  package :ufw
+  service :ufw
+
+  on_configure do
+    sudo "ufw allow #{@firewall.join(' ')}"
+  end
+end
+
+# Write a file during configure step
+def file(path, content)
+  @files ||= {}
+  @files[path] = content
+
+  on_configure do
+    @files.each do |path, content|
+      File.write(path, content)
+    end
+  end
+end
+
+def hostname(name)
+  @hostname = name
+
+  file '/etc/hostname', "#{@hostname}\n"
+
+  on_configure do
+    log "Setting hostname", hostname: @hostname
+    sudo "hostnamectl set-hostname #{@hostname}"
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,31 @@
+require 'etc'
+
+# Prints a message to the STDOUT
+#
+# @param [String] msg a log message to print
+#
+# @param [Hash<String, Object>] args prints each key and value in separate lines after message
+def log(msg, args={})
+  puts msg
+
+  return unless args.any?
+
+  max = args.keys.map(&:to_s).max_by(&:length).length
+  args.each do |k, v|
+    vs = case v
+         when Array, Set
+           "(#{v.length}) " + v.join(", ")
+         else
+           v
+         end
+    puts "\t#{k.to_s.rjust(max)}: #{vs}"
+  end
+end
+
+def root?
+  Process.uid == Etc.getpwnam('root').uid
+end
+
+def sudo(command)
+  root? ? system(command) : system("sudo #{command}")
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: archlinux
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Emad Elsaid
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-18 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- archlinux.gemspec
+- lib/archlinux.rb
+- lib/core.rb
+- lib/declarations.rb
+- lib/utils.rb
+homepage: https://github.com/emad-elsaid/archlinux
+licenses:
+- GPL-3.0-or-later
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Archlinux DSL to manage whole system state
+test_files: []