bootscript 0.2.1

data/lib/bootscript/script.rb

@@ -0,0 +1,178 @@
+module Bootscript
+
+  require 'fileutils'
+  require 'erubis'
+  require 'json'
+  require 'tmpdir'
+  require 'zlib'
+  require 'archive/tar/minitar'
+  require 'zip'
+
+  # Main functional class. Models and builds a self-extracting Bash/TAR file.
+  class Script
+
+    # A Hash of data sources to be written onto the boot target's filesystem.
+    # Each (String) key is a path to the desired file on the boot target.
+    # Each value can be a String (treated as ERB), or Object with a read method.
+    # Any Ruby File objects with extension ".ERB" are also processed as ERB.
+    attr_accessor :data_map
+
+    # Standard Ruby Logger, overridden by passing :logger to {#initialize}
+    attr_reader   :log
+
+    # constructor - configures the AWS S3 connection and logging
+    # @param logger [::Logger] - a standard Ruby logger
+    def initialize(logger = nil)
+      @log      ||= logger || Bootscript.default_logger
+      @data_map = Hash.new
+      @vars     = Hash.new
+    end
+
+    # Generates the BootScript contents by interpreting the @data_map
+    # based on erb_vars. If destination has a write() method,
+    # the data is streamed there line-by-line, and the number of bytes written
+    # is returned. Otherwise, the BootScript contents are returned as a String.
+    # In the case of streaming output, the destination must be already opened.
+    # @param erb_vars [Hash] Ruby variables to interpolate into all templates
+    # @param destination [IO] a Ruby object that responds to write(String)
+    # @return [Fixnum] the number of bytes written to the destination, or
+    # @return [String] the text of the rendered script, if destination is nil
+    def generate(erb_vars = {}, destination = nil)
+      # Set state / instance variables, used by publish() and helper methods
+      @vars           = Bootscript.merge_platform_defaults(erb_vars)
+      output          = destination || StringIO.open(@script_data = "")
+      @bytes_written  = 0
+      if Bootscript.windows?(@vars)
+        @bytes_written += output.write(render_erb_text(File.read(
+          "#{File.dirname(__FILE__)}/../templates/windows_header.bat.erb"
+        )))
+      end
+      write_bootscript(output)          # streams the script part line-by-line
+      write_uuencoded_archive(output)   # streams the archive line-by-line
+      if Bootscript.windows?(@vars)
+        @bytes_written += output.write(render_erb_text(File.read(
+          "#{File.dirname(__FILE__)}/../templates/windows_footer.bat.erb"
+        )))
+      end
+      output.close unless destination   # (close StringIO if it was opened)
+      return (destination ? @bytes_written : @script_data)
+    end
+
+    private
+
+    # Streams the bootscript to destination and updates @bytes_written
+    def write_bootscript(destination)
+      # If streaming, send the top-level script line-by-line from memory
+      if Bootscript.windows?(@vars)
+        template_path = Bootscript::WINDOWS_TEMPLATE
+      else
+        template_path = Bootscript::UNIX_TEMPLATE
+      end
+      template = File.read(template_path)
+      template = strip_shell_comments(template) if @vars[:strip_comments]
+      @log.debug "Rendering boot script to #{destination}..."
+      render_erb_text(template).each_line do |ln|
+        destination.write ln
+        @bytes_written += ln.bytes.count
+      end
+    end
+
+    # Streams the uuencoded archive to destination, updating @bytes_written
+    def write_uuencoded_archive(destination)
+      @log.debug "Writing #{@vars[:platform]} archive to #{destination}..."
+      if Bootscript.windows?(@vars)
+        @bytes_written += destination.write("$archive = @'\n")
+        write_windows_archive(destination)
+        @bytes_written += destination.write("'@\n")
+      else  # :platform = 'unix'
+        @bytes_written += destination.write("begin-base64 0600 bootstrap.tbz\n")
+        write_unix_archive(destination)
+        @bytes_written += destination.write("====\n") # (base64 footer)
+      end
+    end
+
+    # Streams a uuencoded TGZ archive to destination, updating @bytes_written
+    def write_unix_archive(destination)
+      begin
+        uuencode  = UUWriter.new(destination)
+        gz        = Zlib::GzipWriter.new(uuencode)
+        tar       = Archive::Tar::Minitar::Writer.open(gz)
+        render_data_map_into(tar)
+      ensure
+        tar.close
+        gz.close
+        @bytes_written += uuencode.bytes_written
+      end
+    end
+
+    # Streams a uuencoded ZIP archive to destination, updating @bytes_written
+    def write_windows_archive(destination)
+      Dir.mktmpdir do |dir|
+        zip_path = "#{dir}/archive.zip"
+        zipfile = File.open(zip_path, 'wb')
+        Zip::OutputStream.open(zipfile) {|zip| render_data_map_into(zip)}
+        zipfile.close
+        @log.debug "zipfile = #{zip_path}, length = #{File.size zip_path}"
+        File.open(zip_path, 'rb') do |zipfile|
+          @bytes_written += destination.write([zipfile.read].pack 'm')
+        end
+      end
+    end
+
+    # renders each data map item into an 'archive', which must be either an
+    # Archive::Tar::Minitar::Writer (if unix), or a Zip::OutputStream (windows)
+    def render_data_map_into(archive)
+      full_data_map.each do |remote_path, item|
+        if item.is_a? String            # case 1: data item is a String
+          @log.debug "Rendering ERB data (#{item[0..16]}...) into archive"
+          data  = render_erb_text(item)
+          input = StringIO.open(data, 'r')
+          size  = data.bytes.count
+        elsif item.is_a?(File)          # case 2: data item is an ERB file
+          if item.path.upcase.sub(/\A.*\./,'') == 'ERB'
+            @log.debug "Rendering ERB file #{item.path} into archive"
+            data  = render_erb_text(item.read)
+            input = StringIO.open(data, 'r')
+            size  = data.bytes.count
+          else                          # case 3: data item is a regular File
+            @log.debug "Copying data from #{item.inspect} into archive"
+            input = item
+            size  = File.stat(item).size
+          end
+        else                            # case 4: Error
+          raise ArgumentError.new("cannot process item: #{item}")
+        end
+        if Bootscript.windows?(@vars)
+          archive.put_next_entry remote_path
+          archive.write input.read
+        else
+          opts = {mode: 0600, size: size, mtime: Time.now}
+          archive.add_file_simple(remote_path, opts) do |output|
+            while data = input.read(512) ; output.write data end
+          end
+        end
+      end
+    end
+
+    # merges the @data_map with the Chef built-ins, as-needed
+    def full_data_map
+      Bootscript::Chef.included?(@vars) ?
+        @data_map.merge(Bootscript::Chef.files(@vars)) : @data_map
+    end
+
+    # renders erb_text, using @vars
+    def render_erb_text(erb_text)
+      Erubis::Eruby.new(erb_text).result(@vars)
+    end
+
+    # strips all empty lines and lines beginning with # from text
+    # does NOT touch the first line of text
+    def strip_shell_comments(text)
+      lines = text.lines.to_a
+      return text if lines.count < 2
+      lines.first + lines[1..lines.count].
+        reject{|l| (l =~ /^\s*#/) || (l =~ /^\s+$/)}.join('')
+    end
+  end
+
+end

data/lib/bootscript/uu_writer.rb

@@ -0,0 +1,17 @@
+module Bootscript
+
+  class UUWriter
+
+    attr_reader :bytes_written
+
+    def initialize(output)
+      @output         = output
+      @bytes_written  = 0
+    end
+
+    def write(data)
+      @bytes_written += @output.write [data].pack('m')
+    end
+  end
+
+end

data/lib/bootscript/version.rb

@@ -0,0 +1,3 @@
+module Bootscript
+  VERSION = "0.2.1"
+end

data/lib/templates/bootscript.ps1.erb

@@ -0,0 +1,91 @@
+$startup_cmd    = '<%= startup_command %>'
+$createRAMDisk  = $<%= create_ramdisk.to_s.upcase %>
+$RAMDiskSize    = "<%= ramdisk_size %>M"
+$RAMDiskMount   = "<%= ramdisk_mount %>"
+$IMDiskURL      = "<%= imdisk_url %>"
+$IMDisk         = "C:\windows\system32\imdisk.exe"
+$IMDIskInstaller = "C:\imdiskinst.exe"
+
+function main()
+{
+  echo "Starting bootstrap..."
+  Decrypt-Archive
+  if ($createRAMDisk)
+  {
+    Download-ImDisk
+    Install-ImDisk
+    Execute-ImDisk
+    echo "RAMDisk setup complete."
+  }
+  Execute-Command($startup_cmd)
+  echo "Bootstrap complete."
+}
+
+function Download-ImDisk()
+{
+  if ((test-path  $IMDIskInstaller) -ne $true)
+  {
+    echo "Downloading ImDisk utility..."
+    $wc = new-object System.Net.WebClient
+    try   { $wc.DownloadFile($IMDiskURL, $IMDIskInstaller) }
+    catch { throw $error[0] }
+  }
+}
+
+function Install-ImDisk()
+{
+  if ((test-path  $IMDisk) -ne $true)
+  {
+    $Env:IMDISK_SILENT_SETUP = 1
+    Execute-Command("$IMDIskInstaller -y")
+  }
+}
+
+function Execute-ImDisk()
+{
+  if ((test-path  $RAMDiskMount) -ne $true)
+  {
+    echo "Setting up $RAMDiskSize RAMDisk at $RAMDiskMount..."
+    $fsArgs = '"/fs:ntfs /q /y"'
+    Execute-Command("$IMDisk -a -t vm -m $RAMDiskMount -s $RAMDiskSize -p $fsArgs")
+  }
+}
+
+function Decrypt-Archive()
+{
+  $archive_path = "C:\bootscript_archive.zip"
+  [io.file]::WriteAllBytes($archive_path,
+    [System.Convert]::FromBase64String($archive))
+  Expand-ZIPFile $archive_path "C:\"
+  Remove-Item $archive_path
+}
+
+function Expand-ZIPFile($file, $dest)
+{
+  $shell = new-object -com shell.application
+  $zip = $shell.NameSpace($file)
+  foreach($item in $zip.items())
+    { $shell.Namespace($dest).copyhere($item) }
+}
+
+function Execute-Command($cmd)
+{
+  if ($cmd -ne "")
+  {
+    Try {
+      echo "Running: $cmd"
+      $Env:_THIS_CMD = $cmd
+      $proc = Start-Process -FilePath c:\windows\system32\cmd.exe `
+        -ArgumentList "/C", "%_THIS_CMD%" `
+        -Verbose -Debug -Wait -Passthru
+      do { start-sleep -Milliseconds 500 }
+      until ($proc.HasExited)
+      echo "Finished: $cmd"
+    }
+    Catch {
+      echo "Failed: $cmd"
+      echo "Error was: $error[0]"
+      throw $error[0]
+    }
+  }
+}

data/lib/templates/bootscript.sh.erb

@@ -0,0 +1,154 @@
+#!/usr/bin/env bash
+# Top-level bootscript
+set -e  # always stop on errors
+test $UID == 0 || (echo "ERROR: must run as root"; exit 1)
+
+####################################
+####  Step 0 - Configuration
+UPDATE_OS='<%= update_os %>'
+CREATE_RAMDISK='<%= create_ramdisk %>'
+RAMDISK_SIZE='<%= ramdisk_size %>'
+RAMDISK_MOUNT='<%= ramdisk_mount %>'
+LOG="/var/log/bootscript.log"
+
+
+####################################
+####  Step 1 - Logging control
+# Log all output to the log file, in addition to STDOUT
+npipe=/tmp/$$.tmp
+trap "rm -f $npipe" EXIT
+mknod $npipe p
+tee <$npipe $LOG &
+exec 1>&-
+exec 1>$npipe 2>&1
+
+
+####################################
+####  STEP 2 - Detect linux distro
+lowercase(){
+  echo "$1" |
+  sed "y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/"
+}
+OS=`lowercase \`uname\``
+KERNEL=`uname -r`
+MACH=`uname -m`
+if [ "{$OS}" == "windowsnt" ]; then
+  OS=windows
+elif [ "{$OS}" == "darwin" ]; then
+  OS=mac
+else
+  OS=`uname`
+  if [ "${OS}" = "SunOS" ] ; then
+    OS=Solaris
+    ARCH=`uname -p`
+    OSSTR="${OS} ${REV}(${ARCH} `uname -v`)"
+  elif [ "${OS}" = "AIX" ] ; then
+    OSSTR="${OS} `oslevel` (`oslevel -r`)"
+  elif [ "${OS}" = "Linux" ] ; then
+    if [ -f /etc/redhat-release ] ; then
+      DistroBasedOn='RedHat'
+      DIST=`cat /etc/redhat-release |sed s/\ release.*//`
+      PSUEDONAME=`cat /etc/redhat-release | sed s/.*\(// | sed s/\)//`
+      REV=`cat /etc/redhat-release | sed s/.*release\ // | sed s/\ .*//`
+    elif [ -f /etc/SuSE-release ] ; then
+      DistroBasedOn='SuSe'
+      PSUEDONAME=`cat /etc/SuSE-release | tr "\n" ' '| sed s/VERSION.*//`
+      REV=`cat /etc/SuSE-release | tr "\n" ' ' | sed s/.*=\ //`
+    elif [ -f /etc/mandrake-release ] ; then
+      DistroBasedOn='Mandrake'
+      PSUEDONAME=`cat /etc/mandrake-release | sed s/.*\(// | sed s/\)//`
+      REV=`cat /etc/mandrake-release | sed s/.*release\ // | sed s/\ .*//`
+    elif [ -f /etc/debian_version ] ; then
+      DistroBasedOn='Debian'
+      DIST=`cat /etc/lsb-release | grep '^DISTRIB_ID' | awk -F=  '{ print $2 }'`
+      PSUEDONAME=`cat /etc/lsb-release | grep '^DISTRIB_CODENAME' | awk -F=  '{ print $2 }'`
+      REV=`cat /etc/lsb-release | grep '^DISTRIB_RELEASE' | awk -F=  '{ print $2 }'`
+    fi
+    if [ -f /etc/UnitedLinux-release ] ; then
+      DIST="${DIST}[`cat /etc/UnitedLinux-release | tr "\n" ' ' | sed s/VERSION.*//`]"
+    fi
+    OS=`lowercase $OS`
+    DistroBasedOn=`lowercase $DistroBasedOn`
+    readonly OS
+    readonly DIST
+    readonly DistroBasedOn
+    readonly PSUEDONAME
+    readonly REV
+    readonly KERNEL
+    readonly MACH
+  fi
+fi
+
+####################################
+####  STEP 3 - OS update
+if [ "$DistroBasedOn" == 'debian' ] ; then
+  export DEBIAN_FRONTEND=noninteractive
+  if [ "$UPDATE_OS" == 'true' ] ; then
+    echo "Upgrading all OS packages..."
+    apt-get update
+    cmd='apt-get -o Dpkg::Options::="--force-all" --force-yes -y upgrade'
+    $cmd || echo "==> WARNING: Unable to complete operating system package upgrade!"
+  fi
+fi
+
+####################################
+####  STEP 4 - Create RAMdisk
+if [ "$CREATE_RAMDISK" == 'true' ] ; then
+  if $(mount | grep "$RAMDISK_MOUNT" >/dev/null 2>&1) ; then
+    echo "RAMdisk already exists at ${RAMDISK_MOUNT}..."
+  else
+    echo "Creating $RAMDISK_SIZE RAMdisk at ${RAMDISK_MOUNT}..."
+    if [ -e $RAMDISK_MOUNT ] ; then
+      echo "ERROR: $RAMDISK_MOUNT already exists and is not a RAMdisk!"
+      exit 4
+    fi
+    mkdir -p $RAMDISK_MOUNT
+    mount -t tmpfs -o size=${RAMDISK_SIZE}M tmpfs $RAMDISK_MOUNT
+  fi
+fi
+
+
+####################################
+####  STEP 5 - Check for uudecode, and attempt to install it if needed
+if ! (which uudecode >/dev/null 2>&1) ; then
+  flavor="$OS / $Dist / $DistroBasedOn"
+  echo "uudecode not found - will attempt installation for $flavor"
+  if [ "$OS" == 'linux' ] ; then
+    if [ "$DistroBasedOn" == 'debian' ] ; then
+      apt-get -y install sharutils
+    else
+      echo "ERROR: Only Debian-derived Linux supported for now :("
+      exit 3
+    fi
+  fi
+fi
+
+
+####################################
+####  STEP 6 - Extract Archive
+# Cut the trailing part of this file and pipe it to uudecode and tar
+echo "Extracting the included tar archive..."
+SCRIPT_PATH="$( cd "$(dirname "$0")" ; pwd -P )/$(basename $0)"
+ARCHIVE=`awk '/^__ARCHIVE_FOLLOWS__/ {print NR + 1; exit 0; }' $SCRIPT_PATH`
+cd /
+tail -n+$ARCHIVE $SCRIPT_PATH | uudecode -o /dev/stdout | tar xovz
+echo "Removing ${SCRIPT_PATH}..."
+rm -f $SCRIPT_PATH  # this script removes itself!
+
+
+<% if defined? startup_command %>
+####################################
+####  STEP 7 - Execute startup command
+echo "Executing user startup command..."
+<% if defined? chef_validation_pem %>
+chmod 0744 /usr/local/sbin/chef-install.sh
+<% end %>
+exec <%= startup_command %>
+<% end %>
+exit 0  # This is reached only if there's no user startup command
+
+
+####################################
+####  Boot data archive - this gets extracted with `tail`, and
+####  piped through `uudecode` and `tar` in Step 5, above
+__ARCHIVE_FOLLOWS__

data/lib/templates/chef/attributes.json.erb

@@ -0,0 +1,7 @@
+<%=
+  if defined? chef_attributes
+    JSON.pretty_generate(chef_attributes)
+  else
+    '{}'
+  end
+%>