matthewtodd-captain 0.1.0

data/README.rdoc

@@ -0,0 +1,65 @@
+= Captain
+
+Captain builds an Ubuntu installation CD just as you like it.
+
+It gathers packages from any number of repositories, preseeds almost all of the installer questions, and runs on any platform with <tt>mkisofs</tt> (including OSX).
+
+== Behold
+
+With no external configuration, Captain builds an i386 Jaunty CD:
+
+ $ captain
+ ...
+ $ ls
+ ubuntu-9.04-captain-i386.iso
+ $
+
+== Install
+
+Captain uses <tt>mkisofs</tt> to burn the final image.
+
+On OSX, you can get this with
+
+  port install cdrtools
+
+And then you're good to go:
+
+  gem sources --add http://gems.github.com
+  gem install matthewtodd-captain
+
+== Configure
+
+Captain looks for <tt>config/captain.rb</tt> under the current directory.
+
+Here are the defaults:
+
+ architecture          'i386'
+ include_packages      ['linux-server', 'language-support-en', 'grub']
+ install_packages      []
+ label                 'Ubuntu'
+ output_directory      '.'
+ post_install_commands []
+ repositories          ['http://us.archive.ubuntu.com/ubuntu jaunty main restricted']
+ tasks                 ['minimal', 'standard']
+ tag                   'captain'
+ version               '9.04'
+ working_directory     temporary_directory
+
+There are a few things you'll need to be careful with, for now:
+
++repositories+:: By convention, the installation system and udeb packages will be pulled from the first repository in the list. So you'll want to make sure the first repository is a full-fledged Ubuntu repository.
++tasks+:: <b>MUST include <tt>'minimal'</tt></b>, else the installer will die with the maddeningly not-at-all-the-problem <tt>"failure trying to run: chroot /target mount -t proc proc /proc"</tt>
++include_packages+:: MUST include a kernel, some language-support package, and grub; else the installer will complain.
++version+:: Could be determined automatically from, say, the <tt>Release</tt> file in the first repository. But it isn't yet, so beware of the duplication.
+
+See the examples[http://github.com/matthewtodd/captain/tree/master/examples] folder for more.
+
+== Preseeding
+
+See resources/preseed.seed.erb[http://github.com/matthewtodd/captain/blob/master/resources/preseed.seed.erb]. There may be a few controversial decisions in there that could use some configuring: there's just one monolithic disk partition, no "regular" user created, and no http mirrors included in <tt>/etc/apt/sources.list</tt>.
+
+Other than the disk partitioning, I suppose most of these things could be handled post-install, though I'm glad to accept patches / suggestions adding the configuration options you need.
+
+== Network Cache
+
+Captain caches everything it downloads from the network in <tt>$HOME/.captain</tt>.

data/Rakefile

@@ -0,0 +1,20 @@
+this_rakefile_uses_shoe = <<END
+----------------------------------------
+Please install Shoe:
+gem sources --add http://gems.github.com
+gem install matthewtodd-shoe
+----------------------------------------
+END
+
+begin
+  gem 'matthewtodd-shoe'
+rescue Gem::LoadError
+  abort this_rakefile_uses_shoe
+else
+  require 'shoe'
+end
+
+Shoe.tie('captain', '0.1.0', 'Builds an Ubuntu installation CD just as you like it.') do |spec|
+  spec.requirements = ['mkisofs']
+  spec.add_development_dependency 'cucumber'
+end

data/bin/captain

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'captain'
+
+Captain::Application.run

data/features/installer_image.feature

@@ -0,0 +1,8 @@
+Feature: Installer Image
+  In order to install a custom Ubuntu system
+  As a perennial yak-shaver
+  I want to assemble my own installer CD
+
+  Scenario: Default Configuration
+     When I run captain
+     Then I should be able to launch the resulting image "ubuntu-9.04-captain-i386.iso"

data/features/steps/captain_steps.rb

@@ -0,0 +1,17 @@
+When /^I run captain$/ do
+  @app.run
+end
+
+# Before, I had stubbed out all sorts of stuff with ShamRack. That got to be a
+# lot to maintain. So, now I just make sure I can actually boot up the
+# installation system.
+Then /^I should be able to launch the resulting image "(.+)"$/ do |image_name|
+  vmware_directory = Pathname.pwd.join(@app.output_directory)
+  config_path      = vmware_directory.join('captain.vmx')
+  hard_disk_path   = vmware_directory.join('captain.vmdk')
+  cdrom_iso_path   = vmware_directory.join(image_name)
+
+  create_a_vmware_configuration_file(config_path, hard_disk_path, cdrom_iso_path)
+  create_an_empty_hard_disk_image(hard_disk_path)
+  launch_vmware(config_path)
+end

data/features/support/env.rb

@@ -0,0 +1,11 @@
+require 'pathname'
+root = Pathname.new(__FILE__).dirname.parent.parent
+
+$LOAD_PATH.unshift(root.join('lib'))
+require 'captain'
+
+Before do
+  root.join('tmp').rmtree if root.join('tmp').directory?
+  @app = Captain::Application.new
+  @app.output_directory('tmp')
+end

data/features/support/helpers.rb

@@ -0,0 +1,46 @@
+require 'erb'
+
+module Helpers
+  def append_to_path(directory)
+    ENV['PATH'] = "#{ENV['PATH']}:#{directory}" if File.directory?(directory)
+  end
+
+  def create_a_vmware_configuration_file(path, hard_disk_path, cdrom_iso_path)
+    template = File.read(__FILE__).split('__END__').last.strip
+
+    File.open(path, 'w') do |config|
+      config.write ERB.new(template).result(binding)
+    end
+  end
+
+  def create_an_empty_hard_disk_image(path)
+    append_to_path('/Applications/Q.app/Contents/MacOS')
+    system("qemu-img create -f vmdk #{path} 2G > /dev/null") || raise('Could not create image.')
+  end
+
+  def launch_vmware(config_path)
+    append_to_path('/Library/Application Support/VMware Fusion')
+    system("vmrun -T fusion start #{config_path} gui") || raise('VMware Error.')
+  end
+end
+
+World(Helpers)
+
+__END__
+config.version = "8"
+virtualHW.version = "7"
+scsi0.present = "FALSE"
+memsize = "512"
+ide0:0.present = "TRUE"
+ide0:0.fileName = "<%= hard_disk_path %>"
+ide1:0.present = "TRUE"
+ide1:0.fileName = "<%= cdrom_iso_path %>"
+ide1:0.deviceType = "cdrom-image"
+floppy0.present = "FALSE"
+ethernet0.present = "TRUE"
+usb.present = "TRUE"
+sound.present = "FALSE"
+displayName = "Captain - Cucumber"
+guestOS = "ubuntu"
+nvram = "captain.nvram"
+workingDir = "<%= path.dirname %>"

data/lib/captain/application.rb

@@ -0,0 +1,111 @@
+require 'tmpdir'
+
+module Captain
+  class Application
+    def self.run
+      new.run
+    end
+
+    def initialize
+      load_default_configuration
+      load_configuration
+    end
+
+    def run
+      create_bundle_directory
+      create_packages
+      create_installer_and_its_supporting_files
+      create_boot_loader
+      create_ubuntu_symlink
+      create_iso_image
+    end
+
+    def method_missing(symbol, *args)
+      if args.length > 0
+        @configuration[symbol] = args.first
+      elsif @configuration.has_key?(symbol)
+        @configuration[symbol]
+      else
+        super
+      end
+    end
+
+    private
+
+    # This is a convenient way to put arbitrary content on the disk.
+    def create_bundle_directory
+      FileUtils.cp_r('bundle', working_directory) if File.directory?('bundle')
+    end
+
+    def create_packages
+      PackageList.new(repositories, architecture, tasks, include_packages.concat(install_packages)).copy_to(working_directory, self)
+    end
+
+    def create_installer_and_its_supporting_files
+      mirror, codename = installer_repository_mirror_and_codename
+
+      Remote.installer_file(mirror, codename, architecture, 'cdrom', 'vmlinuz'  ).copy_to(working_directory, 'install', 'vmlinuz')
+      Remote.installer_file(mirror, codename, architecture, 'cdrom', 'initrd.gz').copy_to(working_directory, 'install', 'initrd.gz')
+
+      Resource.template('preseed.seed.erb',          template_binding).copy_to(working_directory, 'install', 'preseed.seed')
+      Resource.template('disk_base_components.erb',  template_binding).copy_to(working_directory, '.disk', 'base_components')
+      Resource.template('disk_base_installable.erb', template_binding).copy_to(working_directory, '.disk', 'base_installable')
+      Resource.template('disk_cd_type.erb',          template_binding).copy_to(working_directory, '.disk', 'cd_type')
+      Resource.template('disk_info.erb',             template_binding).copy_to(working_directory, '.disk', 'info')
+      Resource.template('disk_udeb_include.erb',     template_binding).copy_to(working_directory, '.disk', 'udeb_include')
+    end
+
+    def create_boot_loader
+      Resource.file('isolinux.bin').copy_to(working_directory, 'isolinux', 'isolinux.bin')
+      Resource.file('isolinux.cfg').copy_to(working_directory, 'isolinux', 'isolinux.cfg')
+    end
+
+    def create_ubuntu_symlink
+      Dir.chdir(working_directory) do
+        FileUtils.symlink('.', 'ubuntu')
+      end
+    end
+
+    def create_iso_image
+      Image.new(working_directory).burn(iso_image_path)
+    end
+
+    def installer_repository_mirror_and_codename
+      repositories.first.split(' ').slice(0, 2)
+    end
+
+    def iso_image_path
+      File.join(output_directory, "#{label}-#{version}-#{tag}-#{architecture}.iso".downcase)
+    end
+
+    def template_binding
+      binding
+    end
+
+    def load_default_configuration
+      @configuration = Hash.new
+
+      architecture          'i386'
+      include_packages      ['linux-server', 'language-support-en', 'grub']
+      install_packages      []
+      label                 'Ubuntu'
+      output_directory      '.'
+      post_install_commands []
+      repositories          ['http://us.archive.ubuntu.com/ubuntu jaunty main restricted']
+      tasks                 ['minimal', 'standard']
+      tag                   'captain'
+      version               '9.04'
+      working_directory     temporary_directory
+    end
+
+    def load_configuration
+      instance_eval(File.read('config/captain.rb')) if File.exist?('config/captain.rb')
+    end
+
+    def temporary_directory
+      temporary_directory = Dir.mktmpdir('captain')
+      at_exit { FileUtils.remove_entry_secure(temporary_directory) }
+      temporary_directory
+    end
+  end
+end

data/lib/captain/image.rb

@@ -0,0 +1,28 @@
+require 'pathname'
+
+module Captain
+  class Image
+    def initialize(base_directory)
+      @base_directory = base_directory
+    end
+
+    def burn(path)
+      path = Pathname.new(path)
+      path.parent.mkpath unless path.parent.directory?
+
+      system('mkisofs',
+        '-boot-info-table',
+        '-boot-load-size', '4',
+        '-cache-inodes',
+        '-eltorito-boot', 'isolinux/isolinux.bin',
+        '-eltorito-catalog', 'isolinux/boot.cat',
+        '-full-iso9660-filenames',
+        '-joliet',
+        '-no-emul-boot',
+        '-output', path,
+        '-rational-rock',
+        '-volid', 'Name',
+        @base_directory) || raise('Error creating iso image.')
+    end
+  end
+end

data/lib/captain/package.rb

@@ -0,0 +1,68 @@
+require 'set'
+
+module Captain
+  class Package
+    attr_reader :codename
+    attr_reader :component
+    attr_reader :dependencies
+    attr_reader :filename
+    attr_reader :md5sum
+    attr_reader :mirror
+    attr_reader :name
+
+    def initialize(mirror, codename, component, manifest)
+      @mirror       = mirror
+      @codename     = codename
+      @component    = component
+      @manifest     = manifest
+
+      @dependencies = Set.new
+      @provides     = Set.new
+      @recommends   = Set.new
+      @tasks        = Set.new
+
+      @manifest.each_line do |line|
+        case line
+        when /^Depends:(.*)$/
+          @dependencies.merge(parse_list($1))
+        when /^Filename:(.*)$/
+          @filename = $1.strip
+        when /^MD5sum:(.*)$/
+          @md5sum = $1.strip
+        when /^Package:(.*)$/
+          @name = $1.strip
+        when /^Provides:(.*)$/
+          @provides.merge(parse_list($1))
+        when /^Recommends:(.*)$/
+          @recommends.merge(parse_list($1))
+        when /^Task:(.*)$/
+          @tasks.merge(parse_list($1))
+        end
+      end
+    end
+
+    def copy_to(directory)
+      Remote.package_file(mirror, filename, md5sum).copy_to(directory, filename)
+    end
+
+    def copy_manifest_to(stream)
+      # Just making sure we don't end up with extra newlines. Postel's law and all that.
+      stream.puts(@manifest.strip)
+      stream.puts
+    end
+
+    def tasks
+      @tasks
+    end
+
+    def name_and_provides
+      @name_and_provides ||= @provides.dup.add(@name)
+    end
+
+    private
+
+    def parse_list(string)
+      string.split(/[,|]/).map { |versioned| versioned.strip.split(' ').first }
+    end
+  end
+end

data/lib/captain/package_list.rb

@@ -0,0 +1,102 @@
+module Captain
+  class PackageList
+    def initialize(sources, architecture, tasks, selectors)
+      @sources      = sources
+      @architecture = architecture
+      @tasks        = tasks
+      @selectors    = selectors
+    end
+
+    def copy_to(directory, configuration)
+      each_release { |release| release.copy_to(directory, configuration) }
+    end
+
+    private
+
+    def each_release
+      winnow_down(deb_packages).concat(udeb_packages).group_by { |package| package.codename }.each do |codename, packages|
+        yield Release.new(codename, @architecture, packages)
+      end
+    end
+
+    def winnow_down(packages)
+      selected_by_task, remaining_by_task  = select_packages_by_task(packages)
+      selected_by_name, remaining_by_name  = select_packages_by_name(remaining_by_task)
+      selected_by_dependencies             = select_packages_by_dependencies(remaining_by_name, selected_by_name)
+
+      selected_by_task.concat(selected_by_name).concat(selected_by_dependencies)
+    end
+
+    def select_packages_by_task(pool)
+      pool.partition { |package| !package.tasks.intersection(@tasks).empty? }
+    end
+
+    def select_packages_by_name(pool, names=@selectors)
+      pool.partition { |package| !package.name_and_provides.intersection(names).empty? }
+    end
+
+    def select_packages_by_dependencies(pool, dependent_packages)
+      if dependent_packages.empty?
+        []
+      else
+        selected, remaining = select_packages_by_name(pool, dependencies_of(dependent_packages))
+        selected + select_packages_by_dependencies(remaining, selected)
+      end
+    end
+
+    def dependencies_of(packages)
+      # We have todo this goofy inject instead of a simple flatten because the dependencies are returned as Sets.
+      packages.map { |package| package.dependencies }.inject { |all, each| all.merge(each) }
+    end
+
+    def deb_packages
+      deb_components.map { |component| component.packages }.flatten
+    end
+
+    def deb_components
+      @sources.map do |source|
+        mirror, codename, *components = source.split(' ')
+        components.map do |component|
+          ComponentManifest.new(mirror, codename, component, @architecture)
+        end
+      end.flatten
+    end
+
+    def udeb_packages
+      mirror, codename, *components = @sources.first.split(' ')
+      ComponentManifest.new(mirror, codename, 'main/debian-installer', @architecture).packages
+    end
+
+    class ComponentManifest
+      include Enumerable
+
+      def initialize(mirror, codename, component, architecture)
+        @mirror       = mirror
+        @codename     = codename
+        @component    = component
+        @architecture = architecture
+      end
+
+      def each
+        buffer = []
+        open_stream.each_line do |line|
+          if line == "\n"
+            yield Package.new(@mirror, @codename, @component, buffer.join)
+            buffer.clear
+          else
+            buffer.push(line)
+          end
+        end
+      end
+
+      alias_method :packages, :to_a
+
+      private
+
+      def open_stream
+        Remote.component_file(@mirror, @codename, @component, @architecture, 'Packages.gz').gunzipped
+      end
+    end
+
+  end
+end

data/lib/captain/release.rb

@@ -0,0 +1,101 @@
+require 'digest'
+require 'pathname'
+require 'zlib'
+
+module Captain
+  class Release
+    attr_reader :architecture
+    attr_reader :codename
+    attr_reader :components
+
+    def initialize(codename, architecture, packages)
+      @codename     = codename
+      @architecture = architecture
+      @components   = organize_into_components(packages)
+      @packages     = packages.sort_by { |p| p.filename }
+    end
+
+    def copy_to(directory, config)
+      directory = Pathname.new(directory)
+
+      @packages.each   { |p| p.copy_to(directory) }
+      @components.each { |c| c.copy_to(directory.join('dists', @codename)) }
+
+      Resource.template('release.erb', binding).copy_to(directory.join('dists', @codename, 'Release'))
+    end
+
+    private
+
+    def organize_into_components(packages)
+      packages.group_by { |package| package.component }.map do |name, packages|
+        Component.new(name, @architecture, packages)
+      end
+    end
+
+    def deb_components
+      @components.reject { |c| c.udeb? }
+    end
+
+    class Component
+      attr_reader :name
+      attr_reader :files
+
+      def initialize(name, architecture, packages)
+        @name    = name
+        manifest = manifest(packages)
+        @files   = []
+        @files.push Manifest.new("#{name}/binary-#{architecture}/Release", Resource.template('release_component.erb', binding).contents)
+        @files.push Manifest.new("#{name}/binary-#{architecture}/Packages", manifest)
+        @files.push Manifest.new("#{name}/binary-#{architecture}/Packages.gz", gzip(manifest))
+      end
+
+      def copy_to(directory)
+        files.each { |file| file.copy_to(directory) }
+      end
+
+      def udeb?
+        name =~ /debian-installer/
+      end
+
+      private
+
+      def manifest(packages)
+        io = StringIO.new
+        packages.each { |package| package.copy_manifest_to(io) }
+        io.string
+      end
+
+      def gzip(string)
+        io = StringIO.new
+        gzip = Zlib::GzipWriter.new(io)
+        gzip.write(string)
+        gzip.close
+        io.string
+      end
+
+      class Manifest
+        attr_reader :path
+
+        def initialize(path, contents)
+          @path     = path
+          @contents = contents
+        end
+
+        def copy_to(directory)
+          file = Pathname.new(directory).join(path)
+          file.dirname.mkpath
+          file.open('w') { |io| io.write(@contents) }
+        end
+
+        def checksum(algorithm)
+          Digest(algorithm).hexdigest(@contents)
+        end
+
+        def size
+          @contents.length
+        end
+      end
+    end
+
+  end
+end

data/lib/captain/remote.rb

@@ -0,0 +1,232 @@
+require 'digest'
+require 'open-uri'
+require 'pathname'
+require 'uri'
+require 'zlib'
+
+module Captain
+  class Remote
+    def self.release_file(mirror, codename)
+      # TODO verify the Release file with GPG
+      new("#{mirror}/dists/#{codename}/Release")
+    end
+
+    def self.component_file(mirror, codename, component, architecture, *rest)
+      uri    = component_uri(mirror, codename, component, architecture, *rest)
+      path   = [component, "binary-#{architecture}", *rest].join('/')
+      md5sum = release_file(mirror, codename).grep(%r{^ \w{32}\s+\d+\s+#{path}}).first.split(' ').first
+      new(uri, Verifier::MD5.new(md5sum))
+    end
+
+    def self.installer_file(mirror, codename, architecture, *rest)
+      uri        = installer_uri(mirror, codename, architecture, *rest)
+      md5sum_uri = installer_uri(mirror, codename, architecture, 'MD5SUMS')
+      md5sum     = new(md5sum_uri).grep(%r{#{rest.join('/')}}).first.split(' ').first
+      new(uri, Verifier::MD5.new(md5sum))
+    end
+
+    def self.package_file(mirror, filename, md5sum)
+      new("#{mirror}/#{filename}", Verifier::MD5.new(md5sum))
+    end
+
+    def self.component_uri(mirror, codename, component, architecture, *rest)
+      ["#{mirror}/dists/#{codename}/#{component}/binary-#{architecture}", *rest].join('/')
+    end
+
+    def self.installer_uri(mirror, codename, architecture, *rest)
+      ["#{mirror}/dists/#{codename}/main/installer-#{architecture}/current/images", *rest].join('/')
+    end
+
+    include Enumerable
+
+    def initialize(uri, verifier=Verifier::Content.new)
+      @uri      = URI.parse(uri)
+      @verifier = verifier
+      @cache    = Cache::Persistent.new
+    end
+
+    def copy_to(*paths)
+      path = Pathname.new(File.join(paths))
+      path.dirname.mkpath
+
+      open_stream do |stream|
+        File.open(path, 'w') do |file|
+          Stream.copy(stream, file)
+        end
+      end
+    end
+
+    def each_line
+      open_stream do |stream|
+        stream.each_line do |line|
+          yield line
+        end
+      end
+    end
+    alias_method :each, :each_line
+
+    def gunzipped
+      Adapter::Gunzip.new(self)
+    end
+
+    private
+
+    def open_stream(retry_count=4)
+      @cache.open(@uri) do |cache|
+        begin
+          @verifier.verify(cache)
+          yield(cache)
+        rescue
+          begin
+            @uri.open(ProgressMeter.new(@uri).to_open_uri_hash) do |stream|
+              @verifier.verify(stream)
+              cache.populate(stream)
+              yield(cache)
+            end
+          rescue Errno::ECONNRESET, OpenURI::HTTPError, SocketError, Timeout::Error, Verifier::Error
+            retry_count -= 1
+            raise if retry_count.zero?
+            puts $!.message
+            puts "Trying again... (#{retry_count} more)"
+            retry
+          end
+        end
+      end
+    end
+
+    module Verifier
+      class Error < RuntimeError
+      end
+
+      class Content
+        def verify(stream)
+          raise(Verifier::Error.new("No content.")) unless stream.read(1)
+        ensure
+          stream.rewind
+        end
+      end
+
+      class MD5
+        def initialize(expected)
+          @expected = expected
+          raise(Verifier::Error.new("No expected MD5Sum given.")) unless @expected
+        end
+
+        def verify(stream)
+          actual = md5sum(stream)
+          raise(Verifier::Error.new("MD5Sum mismatch: expected #{@expected} but was #{actual}")) unless @expected == actual
+        end
+
+        private
+
+        def md5sum(stream)
+          digest = Digest::MD5.new
+          Stream.copy(stream, digest, :update)
+          digest.hexdigest
+        end
+      end
+    end
+
+    module Cache
+      class Persistent
+        PATH = Pathname.new(ENV['HOME']).join('.captain')
+
+        def open(uri)
+          # I didn't expect to have to use string concatenation here, but PATH
+          # gets confused when uri.path starts with a /.
+          path = PATH.join("#{uri.host}#{uri.path}")
+          if path.exist?
+            path.open('r+') { |cache| yield populatable(cache) }
+          else
+            path.dirname.mkpath
+            path.open('w+') { |cache| yield populatable(cache) }
+          end
+        end
+
+        private
+
+        def populatable(stream)
+          def stream.populate(other)
+            Stream.copy(other, self)
+          end
+          stream
+        end
+      end
+    end
+
+    class ProgressMeter
+      # For these ANSI escape sequences and more, see http://en.wikipedia.org/wiki/ANSI_escape_code
+      MOVE_CURSOR_UP_1_LINE   = "\e[1A"
+      ERASE_ENTIRE_LINE       = "\e[2K"
+      MOVE_CURSOR_TO_COLUMN_1 = "\e[1G" # columns are 1-based, oddly enough
+      OVERWRITE_PREVIOUS_LINE = "#{MOVE_CURSOR_UP_1_LINE}#{ERASE_ENTIRE_LINE}#{MOVE_CURSOR_TO_COLUMN_1}"
+
+      def initialize(uri)
+        puts uri
+        puts
+      end
+
+      def to_open_uri_hash
+        { :content_length_proc => method(:the_total_size_is), :progress_proc => method(:the_currently_downloaded_size_is) }
+      end
+
+      def the_total_size_is(size)
+        @total_size = size
+      end
+
+      def the_currently_downloaded_size_is(size)
+        @current = size
+        report
+      end
+
+      private
+
+      # TODO report percent complete
+      # TODO report time spent
+      # TODO report time remaining
+      def report
+        puts "#{OVERWRITE_PREVIOUS_LINE}  #{@current} of #{@total_size}"
+        $stdout.flush
+      end
+    end
+
+    class Stream
+      def self.copy(from, to, method = :write)
+        buffer = ''
+        to.truncate(0) if to.respond_to?(:truncate)
+        to.send(method, buffer) while from.read(16384, buffer)
+      ensure
+        from.rewind
+        to.rewind if to.respond_to?(:rewind)
+      end
+    end
+
+    module Adapter
+      class Gunzip
+        include Enumerable
+
+        def initialize(stream)
+          @stream = stream
+        end
+
+        def each_line
+          open_stream do |stream|
+            stream.each_line do |line|
+              yield line
+            end
+          end
+        end
+        alias_method :each, :each_line
+
+        private
+
+        def open_stream
+          @stream.send(:open_stream) do |stream|
+            yield Zlib::GzipReader.new(stream)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/captain/resource.rb

@@ -0,0 +1,43 @@
+require 'erb'
+require 'pathname'
+
+module Captain
+  class Resource
+    PATH = Pathname.new(File.dirname(__FILE__)).join('..', '..', 'resources')
+
+    def self.file(name)
+      new(name)
+    end
+
+    def self.template(name, binding)
+      Template.new(name, binding)
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def contents
+      PATH.join(@name).read
+    end
+
+    def copy_to(*paths)
+      path = File.join(paths)
+      FileUtils.mkpath(File.dirname(path))
+      File.open(path, 'w') { |f| f.write(contents) }
+    end
+
+    private
+
+    class Template < Resource
+      def initialize(name, binding)
+        super(name)
+        @binding = binding
+      end
+
+      def contents
+        ERB.new(super, nil, '<>').result(@binding)
+      end
+    end
+  end
+end

data/lib/captain.rb

@@ -0,0 +1,10 @@
+require 'captain/application'
+require 'captain/image'
+require 'captain/package'
+require 'captain/package_list'
+require 'captain/release'
+require 'captain/remote'
+require 'captain/resource'
+
+module Captain
+end

data/resources/disk_base_components.erb

@@ -0,0 +1 @@
+main

data/resources/disk_cd_type.erb

@@ -0,0 +1 @@
+full_cd/single

data/resources/disk_info.erb

@@ -0,0 +1 @@
+<%= label %> <%= version %> <%= tag.capitalize %>

data/resources/disk_udeb_include.erb

@@ -0,0 +1,4 @@
+netcfg
+ethdetect
+pcmcia-cs-udeb
+wireless-tools-udeb

data/resources/isolinux.cfg

@@ -0,0 +1,9 @@
+# Don't show the boot: prompt
+prompt 0
+
+# Automatically boot the linux kernel after 1 (= 10 10ths of a) second
+timeout 10
+
+label linux
+  kernel /install/vmlinuz
+  append file=/cdrom/install/preseed.seed initrd=/install/initrd.gz quiet locale=en_US console-setup/layoutcode=us netcfg/choose_interface=auto --

data/resources/preseed.seed.erb

@@ -0,0 +1,58 @@
+### Localization
+d-i debian-installer/locale string en_US
+d-i console-setup/ask_detect boolean false
+d-i console-setup/layoutcode string us
+
+### Network configuration
+d-i netcfg/dhcp_timeout string 10
+d-i netcfg/dhcp_failed note
+d-i netcfg/dhcp_options select Configure network manually
+
+### Mirror settings
+d-i mirror/country string US
+
+### Clock and time zone setup
+d-i clock-setup/utc boolean true
+d-i time/zone string UTC
+d-i clock-setup/ntp boolean false
+
+### Partitioning
+d-i partman-auto/init_automatically_partition select biggest_free
+d-i partman-auto/method string regular
+d-i partman-auto/choose_recipe select atomic
+d-i partman/confirm_write_new_label boolean true
+d-i partman/choose_partition select finish
+d-i partman/confirm boolean true
+
+### Base system installation
+
+### Account setup
+d-i passwd/root-login boolean true
+d-i passwd/make-user boolean false
+
+### Apt setup
+d-i apt-setup/use_mirror boolean false
+d-i apt-setup/services-select multiselect
+d-i debian-installer/allow_unauthenticated string true
+
+### Package selection
+tasksel tasksel/first multiselect standard
+d-i pkgsel/include string <%= install_packages.join(' ') %>
+d-i pkgsel/update-policy select none
+
+### Boot loader installation
+d-i grub-installer/only_debian boolean true
+d-i grub-installer/with_other_os boolean true
+
+### Finishing up the installation
+d-i finish-install/reboot_in_progress note
+d-i cdrom-detect/eject boolean false
+
+### X configuration
+
+### Preseeding other packages
+user-setup-udeb user-setup/encrypted-private boolean false
+
+#### Advanced options
+### Running custom commands during the installation
+d-i preseed/late_command string <%= post_install_commands.join('; ') %>

data/resources/release.erb

@@ -0,0 +1,23 @@
+Suite: <%= codename %>
+Codename: <%= codename %>
+Date: <%= Time.now.utc.strftime('%a, %e %b %Y %H:%M:%S UTC') %>
+Architectures: <%= architecture %>
+Components: <%= deb_components.map { |c| c.name }.join(' ') %>
+MD5Sum:
+<% components.each do |component| %>
+<% component.files.each do |file| %>
+  <%= file.checksum('MD5') %> <%= file.size %> <%= file.path %>
+<% end %>
+<% end %>
+SHA1:
+<% components.each do |component| %>
+<% component.files.each do |file| %>
+  <%= file.checksum('SHA1') %> <%= file.size %> <%= file.path %>
+<% end %>
+<% end %>
+SHA256:
+<% components.each do |component| %>
+<% component.files.each do |file| %>
+  <%= file.checksum('SHA256') %> <%= file.size %> <%= file.path %>
+<% end %>
+<% end %>

data/resources/release_component.erb

@@ -0,0 +1,2 @@
+Component: <%= name %>
+Architecture: <%= architecture %>

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: matthewtodd-captain
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew Todd
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-30 00:00:00 -07:00
+default_executable: captain
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: matthewtodd-shoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: matthew.todd@gmail.com
+executables: 
+- captain
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- README.rdoc
+- bin/captain
+- features/installer_image.feature
+- features/steps
+- features/steps/captain_steps.rb
+- features/support
+- features/support/env.rb
+- features/support/helpers.rb
+- lib/captain
+- lib/captain/application.rb
+- lib/captain/image.rb
+- lib/captain/package.rb
+- lib/captain/package_list.rb
+- lib/captain/release.rb
+- lib/captain/remote.rb
+- lib/captain/resource.rb
+- lib/captain.rb
+- resources/disk_base_components.erb
+- resources/disk_base_installable.erb
+- resources/disk_cd_type.erb
+- resources/disk_info.erb
+- resources/disk_udeb_include.erb
+- resources/isolinux.bin
+- resources/isolinux.cfg
+- resources/preseed.seed.erb
+- resources/release.erb
+- resources/release_component.erb
+has_rdoc: false
+homepage: 
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- captain-0.1.0
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- mkisofs
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Builds an Ubuntu installation CD just as you like it.
+test_files: []
+