duck-installer 0.2.1

data/files/lib/python-duck/duck/__init__.py

@@ -0,0 +1,2 @@
+__version__ = (0, 3, 0)
+__version_string__ = ".".join(map(str, __version__))

data/files/lib/python-duck/duck/db.py

@@ -0,0 +1,48 @@
+import dbm
+import json
+import contextlib
+
+DEFAULT_DB = "/var/duck"
+DEFAULT_ENCODING = 'utf-8'
+
+
+class DBSession(object):
+    def __init__(self, db, encoding):
+        self._db = db
+        self._encoding = encoding
+
+    def get(self, key, default=None):
+        try:
+            value = self._db[key]
+        except KeyError:
+            return default
+
+        if value is None:
+            return None
+
+        value = value.decode(self._encoding)
+        value = json.loads(value)
+        return value
+
+    def set(self, key, value):
+        value = json.dumps(value)
+        value = value.encode(self._encoding)
+        self._db[key] = value
+
+    def keys(self):
+        return self._db.keys()
+
+
+class DB(object):
+    def __init__(self, path=None, encoding=None):
+        if path is None:
+            path = DEFAULT_DB
+        if encoding is None:
+            encoding = DEFAULT_ENCODING
+        self._full_path = "{0}.dbm".format(path)
+        self._encoding = encoding
+
+    @contextlib.contextmanager
+    def open(self):
+        with contextlib.closing(dbm.open(self._full_path, "c")) as db:
+            yield DBSession(db, self._encoding)

data/files/lib/python-duck/duck/log.py

@@ -0,0 +1,5 @@
+import logging
+
+
+def setup():
+    logging.basicConfig(level=logging.INFO)

data/files/sbin/duckdb

@@ -0,0 +1,212 @@
+#!/usr/bin/python
+#
+# AutoDB is used to store duckinstaller variables.
+#
+
+import duck.db as duck_db
+import duck
+
+import argparse
+import urllib2
+import json
+import contextlib
+
+VERSION = duck.__version_string__
+
+
+def update_db(function):
+    def inner(ns):
+        with ns.db.open() as S:
+            for key, value in function(S, ns):
+                if ns.ns:
+                    key = "%s/%s" % (ns.ns, key)
+                S.set(key, value)
+
+        return 0
+
+    return inner
+
+
+def parse_text(fd):
+    for line in fd:
+        line = line.strip()
+
+        if line.startswith("#") or not line:
+            continue
+
+        key, value = line.split(" ", 2)
+        yield key, value
+
+
+def flatten_dict(doc, keys=[]):
+    result = dict()
+
+    for key, value in doc.items():
+        this_keys = keys + [key]
+
+        if isinstance(value, dict):
+            result.update(flatten_dict(value, this_keys))
+        else:
+            result["/".join(this_keys)] = value
+
+    return result
+
+
+def parse_json(fd):
+    doc = json.load(fd)
+
+    for key, value in doc.items():
+        yield key, value
+
+
+def parse_cmdline(fd):
+    cmdline = fd.read()
+
+    for c in cmdline.split(" "):
+        c = c.strip()
+
+        if not c or '=' not in c:
+            continue
+
+        key, value = c.split("=", 2)
+        yield key, value
+
+
+def read_dict(mode, fd):
+    if mode == 'cmdline':
+        return parse_cmdline(fd)
+
+    if mode == 'json':
+        return parse_json(fd)
+
+    if mode == 'text':
+        return parse_text(fd)
+
+    raise Exception("Unknown file mode: {0}".format(mode))
+
+
+def read(ns, fd):
+    value = dict(read_dict(ns.mode, fd))
+
+    if ns.flatten:
+        return flatten_dict(value)
+
+    return value
+
+
+def action_get(ns):
+    with ns.db.open() as S:
+        value = S.get(ns.key, ns.default)
+
+        if value is None:
+            ok = False
+            value = ""
+        else:
+            ok = True
+
+        if ns.sh:
+            print "DUCK_RETURN=\'%s\';" % (value,)
+            print "DUCK_OK=\"%s\"" % ("yes" if ok else "no",)
+            return 0
+
+        if not ok:
+            return 1
+
+        if ns.raw:
+            value = repr(value)
+
+        print value
+
+    return 0
+
+
+@update_db
+def action_set(S, ns):
+    if ns.json:
+        value = json.loads(ns.value)
+    elif ns.value == '-':
+        value = sys.stdin.read()
+    else:
+        value = ns.value
+
+    yield ns.key, value
+
+
+@update_db
+def action_url(S, ns):
+    with contextlib.closing(urllib2.urlopen(ns.url)) as fd:
+        for key, value in read(ns, fd).items():
+            yield key, value
+
+
+def action_list(ns):
+    with ns.db.open() as S:
+        for key in S.keys():
+            print key, repr(S.get(key))
+
+
+def main(args):
+    parser = argparse.ArgumentParser(
+        usage="usage: %(prog)s [options] <action> [action-options]")
+
+    parser.add_argument("-v", "--version", action='version', version=VERSION)
+
+    parser.add_argument(
+        "--db",
+        metavar="<path>",
+        default=None)
+
+    parser.add_argument(
+        "--ns",
+        metavar="<namespace>",
+        default=None)
+
+    parsers = parser.add_subparsers()
+
+    get_parser = parsers.add_parser("get", help="Get a value")
+    get_parser.add_argument("key")
+    get_parser.add_argument("default", nargs='?', default=None)
+    get_parser.add_argument("--sh",
+                            help=("Output return value as a shell "
+                                  "evaluable string"),
+                            default=False,
+                            action='store_true')
+    get_parser.add_argument("--raw",
+                            help=("Output raw (repr) value"),
+                            default=False,
+                            action='store_true')
+    get_parser.set_defaults(action=action_get)
+
+    set_parser = parsers.add_parser("set", help="Set a value")
+    set_parser.add_argument("--json",
+                            help="treat argument as json",
+                            default=False,
+                            action='store_true')
+    set_parser.add_argument("key")
+    set_parser.add_argument("value")
+    set_parser.set_defaults(action=action_set)
+
+    list_parser = parsers.add_parser("list", help="List all values")
+    list_parser.set_defaults(action=action_list)
+
+    url_parser = parsers.add_parser("url",
+                                    help="Read values from an url")
+    url_parser.add_argument("url", help="Fetch values from specified url")
+    url_parser.add_argument("--json", dest='mode',
+                            help="Treat input as a json document",
+                            action='store_const', const='json')
+    url_parser.add_argument("--cmdline", dest='mode',
+                            help="Treat input as a /proc/cmdline file",
+                            action='store_const', const='cmdline')
+    url_parser.add_argument("--flatten",
+                            help="Flatten a nested dictionary",
+                            default=False, action='store_true')
+    url_parser.set_defaults(action=action_url, mode='file')
+
+    ns = parser.parse_args(args)
+    ns.db = duck_db.DB(path=ns.db)
+    return ns.action(ns)
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main(sys.argv[1:]))

data/files/sbin/duckinstall

@@ -0,0 +1,21 @@
+#!/bin/bash
+. /lib/libduck.sh
+a_get_into log duck/log "$DEFAULT_LOG"
+a_get_into error_command 'duck/error-command' "$DUCK_LOGIN"
+a_get_into success_command 'duck/success-command' "$DUCK_LOGIN"
+
+info "Duck Installer $DUCK_VERSION"
+
+if [[ -f $INSTALLER_STATUS ]]; then
+    info "Not running installation, $INSTALLER_STATUS exists"
+    exec $DUCK_LOGIN
+fi
+
+info "Running installation, logging to $log and syslog"
+
+if ! run_installer 2>&1 | tee -a $log | logger -t duckinstall -s; then
+    exec $error_command
+fi
+
+touch $INSTALLER_STATUS
+exec $success_command

data/files/sbin/ducklogin

@@ -0,0 +1,3 @@
+#!/bin/bash
+read -p "(press 'enter' to login)"
+exec /bin/login -f root

data/fixes/clear-persistent-udev

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Remove any persistent udev rules
+# If the host system runs it's own udev daemon, there is a chance that installation
+# hooks will trigger the generation of persistent files.
+
+set -e
+
+case "$1" in
+  "final") rm -f /etc/udev/rules.d/*; ;;
+esac

data/fixes/kernel-boot-fix

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Make sure that the kernel does not generate an initramfs.
+# Clear /boot before packages are being configured.
+
+set -e
+
+status_code=0
+
+case "$1" in
+    "pre-packages-configure")
+        echo "Disabling generation of an initramfs"
+
+        rm -rf /etc/kernel/postinst.d
+        rm -rf /etc/kernel/postrm.d
+
+        dpkg --get-selections | while read name _; do
+            case "$name" in
+                linux-image-*-dbg) continue ;;
+                linux-image-*)  ;;
+                *) continue ;;
+            esac
+
+            version=${name#linux-image-*}
+
+            path="/var/lib/dpkg/info/$name.postinst"
+
+            [[ ! -f $path ]] && continue
+
+            if ! grep -E 'my \$initrd\s+=\s+"YES";' $path; then
+                echo "initrd already disabled: $name"
+                continue
+            fi
+
+            cp -a $path $path.original
+
+            echo "Disabling initrd for: $name"
+
+            if ! sed -r -i 's/my \$initrd\s+=\s+"YES";/my $initrd = "";/' $path; then
+                echo "failed to patch: $path"
+                exit 1
+            fi
+
+            echo "Generating modules.dep"
+            depmod $version
+        done
+        ;;
+    "final")
+        echo "Clearing /boot"
+        rm -rf /boot
+        ;;
+esac
+
+exit 0

data/fixes/squeeze-fix

@@ -0,0 +1,14 @@
+#!/bin/sh
+# fix for dash hooks that does not run properly on it's own.
+# http://wiki.debian.org/Multistrap#Steps_for_Squeeze_and_later
+
+set -e
+
+case "$1" in
+    "pre-bootstrap-configure")
+        mkdir -p /usr/share/man/man1
+        ;;
+    *) ;;
+esac
+
+exit 0

data/lib/duck.rb

@@ -0,0 +1,191 @@
+require 'optparse'
+require 'fileutils'
+require 'yaml'
+require 'find'
+require 'logger'
+
+require 'duck/logging'
+require 'duck/build'
+require 'duck/enter'
+require 'duck/pack'
+require 'duck/qemu'
+
+module Duck
+  class << self
+    include Logging
+  end
+
+  # environment to prevent tasks from being interactive.
+  DEFAULT_SHELL = '/bin/bash'
+  CONFIG_NAME = 'duck.yaml'
+  CONFIG_ARRAYS = [:files, :packages, :transports, :preferences, :fixes, :services, :sources]
+
+  ACTTIONS = {
+    :build => Duck::Build,
+    :enter => Duck::Enter,
+    :pack => Duck::Pack,
+    :qemu => Duck::Qemu,
+  }
+
+  def self.resource_path(path)
+    File.expand_path File.join('..', '..', path), __FILE__
+  end
+
+  def self.parse_options(args)
+    o = Hash.new
+
+    working_directory = Dir.pwd
+
+    o[:temp] = File.join working_directory, 'tmp'
+    o[:target] = File.join o[:temp], 'initrd'
+    o[:initrd] = File.join o[:temp], 'initrd.gz'
+    o[:gpg_homedir] = File.join o[:temp], 'gpg'
+    o[:kernel] = File.join working_directory, 'vmlinuz'
+    o[:no_minimize] = false
+    o[:append] = nil
+    o[:keep_minimized] = false
+    o[:shell] = DEFAULT_SHELL
+    o[:_configs] = []
+    o[:_roots] = []
+
+    CONFIG_ARRAYS.each do |array|
+      o[array] = []
+    end
+
+    action_names = [:build, :pack]
+
+    opts = OptionParser.new do |opts|
+      opts.banner = 'Usage: duck [action] [options]'
+
+      opts.on('-t <dir>', '--target <dir>',
+              'Build in the specified target directory') do |dir|
+        o[:target] = dir
+      end
+
+      opts.on('--no-minimize',
+              'Do not minimize the installation right before packing') do |dir|
+        o[:no_minimize] = true
+      end
+
+      opts.on('--keep-minimized',
+              'Keep the minimized version of the initrd around') do |dir|
+        o[:keep_minimized] = true
+      end
+
+      opts.on('--debug',
+              'Switch on debug logging') do |dir|
+        Logging::set_level Logger::DEBUG
+      end
+
+      opts.on('-o <file>', '--output <file>',
+              'Output the resulting initrd in the specified path') do |path|
+        o[:initrd] = path
+      end
+
+      opts.on('-k <kernel>', '--kernel <kernel>',
+              'Specify kernel to use when running qemu') do |path|
+        o[:kernel] = path
+      end
+
+      opts.on('-a <append>', '--append <append>',
+              'Specify kernel options to append') do |append|
+        o[:append] = append
+      end
+
+      opts.on('-c <path>', '--config <path>',
+              'Use the specified configuration path') do |path|
+        o[:_configs] << path
+      end
+
+      opts.on('-s <shell>', '--shell <shell>',
+              'Set the shell to use when chrooting') do |shell|
+        o[:shell] = shell
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        return nil
+      end
+    end
+
+    args = opts.parse! args
+
+    unless args.empty?
+      action_names = args.map{|a| a.to_sym}
+    end
+
+    # add default configuration if none is specified.
+    if o[:_configs].empty?
+      o[:_configs] << File.join(working_directory, CONFIG_NAME)
+    end
+
+    o[:_configs] = [resource_path(CONFIG_NAME)] + o[:_configs]
+
+    o[:_configs].uniq!
+    o[:_configs].reject!{|i| not File.file? i}
+    return action_names, o
+  end
+
+  def self.deep_symbolize(o)
+    return o.map{|i| deep_symbolize(i)} if o.is_a? Array
+    return o unless o.is_a? Hash
+    c = o.clone
+    c.keys.each {|k| c[k.to_sym] = deep_symbolize(c.delete(k))}
+    return c
+  end
+
+  def self.prepare_options(o)
+    raise "No configuration found" if o[:_configs].empty?
+
+    [:target].each do |s|
+      next if File.directory? o[s]
+      log.info "Creating directory '#{s}' on #{o[s]}"
+      FileUtils.mkdir_p o[s]
+    end
+
+    unless File.directory? o[:gpg_homedir]
+      log.info "Creating directory GPG home directory on #{o[:gpg_homedir]}"
+      FileUtils.mkdir_p o[:gpg_homedir]
+      FileUtils.chmod 0700, o[:gpg_homedir]
+    end
+
+    o[:_configs].each do |config_path|
+      log.info "Loading configuration from #{config_path}"
+      config = deep_symbolize YAML.load_file(config_path)
+      root = File.dirname config_path
+      # Special keys treated as accumulated arrays over all configurations.
+
+      CONFIG_ARRAYS.each do |n|
+        o[n] += (config.delete(n) || []).map{|i| [root, i]}
+      end
+
+      # Merge (overwrite) the rest.
+      o.merge! config
+      o[:_roots] << root
+    end
+  end
+
+  def self.main(args)
+    action_names, o = parse_options args
+    return 0 if o.nil?
+    prepare_options o
+
+    action_names.each do |action_name|
+      action_class = ACTTIONS[action_name]
+
+      if action_class.nil?
+        log.error "No such action: #{action_name}"
+        return 1
+      end
+
+      action_instance = action_class.new o
+      action_instance.execute
+    end
+
+    return 0
+  end
+end
+
+if __FILE__ == $0
+    exit Duck::main(ARGV)
+end