bosh-stemcell 1.5.0.pre.1113

data/lib/bosh/stemcell/builder_options.rb

@@ -0,0 +1,85 @@
+require 'rbconfig'
+require 'bosh_agent/version'
+require 'bosh/stemcell/archive_filename'
+
+module Bosh::Stemcell
+  class BuilderOptions
+    def initialize(env, options)
+      @environment = env
+      @infrastructure = options.fetch(:infrastructure)
+      @operating_system = options.fetch(:operating_system)
+
+      @stemcell_version = options.fetch(:stemcell_version)
+      @image_create_disk_size = options.fetch(:disk_size, infrastructure.default_disk_size)
+      @bosh_micro_release_tgz_path = options.fetch(:tarball)
+    end
+
+    def default
+      {
+        'stemcell_name' => "bosh-#{infrastructure.name}-#{infrastructure.hypervisor}-#{operating_system.name}",
+        'stemcell_tgz' => archive_filename.to_s,
+        'stemcell_image_name' => stemcell_image_name,
+        'stemcell_version' => stemcell_version,
+        'stemcell_hypervisor' => infrastructure.hypervisor,
+        'stemcell_infrastructure' => infrastructure.name,
+        'stemcell_operating_system' => operating_system.name,
+        'bosh_protocol_version' => Bosh::Agent::BOSH_PROTOCOL,
+        'ruby_bin' => ruby_bin,
+        'bosh_release_src_dir' => File.join(source_root, 'release/src/bosh'),
+        'bosh_agent_src_dir' => File.join(source_root, 'bosh_agent'),
+        'image_create_disk_size' => image_create_disk_size
+      }.merge(bosh_micro_options).merge(environment_variables).merge(vsphere_options)
+    end
+
+    private
+
+    attr_reader(
+      :environment,
+      :infrastructure,
+      :operating_system,
+      :stemcell_version,
+      :image_create_disk_size,
+      :bosh_micro_release_tgz_path
+    )
+
+    def vsphere_options
+      if infrastructure.name == 'vsphere'
+        { 'image_vsphere_ovf_ovftool_path' => environment['OVFTOOL'] }
+      else
+        {}
+      end
+    end
+
+    def environment_variables
+      {
+        'UBUNTU_ISO' => environment['UBUNTU_ISO'],
+        'UBUNTU_MIRROR' => environment['UBUNTU_MIRROR'],
+      }
+    end
+
+    def bosh_micro_options
+      {
+        'bosh_micro_enabled' => 'yes',
+        'bosh_micro_package_compiler_path' => File.join(source_root, 'bosh-release'),
+        'bosh_micro_manifest_yml_path' => File.join(source_root, 'release', 'micro', "#{infrastructure.name}.yml"),
+        'bosh_micro_release_tgz_path' => bosh_micro_release_tgz_path,
+      }
+    end
+
+    def archive_filename
+      ArchiveFilename.new(stemcell_version, infrastructure, operating_system, 'bosh-stemcell', false)
+    end
+
+    def stemcell_image_name
+      "#{infrastructure.name}-#{infrastructure.hypervisor}-#{operating_system.name}.raw"
+    end
+
+    def ruby_bin
+      environment['RUBY_BIN'] || File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+    def source_root
+      File.expand_path('../../../../..', __FILE__)
+    end
+  end
+end

data/lib/bosh/stemcell/disk_image.rb

@@ -0,0 +1,61 @@
+require 'bosh/core/shell'
+require 'tmpdir'
+
+module Bosh::Stemcell
+  class DiskImage
+
+    attr_reader :image_mount_point
+
+    def initialize(options)
+      @image_file_path   = options.fetch(:image_file_path)
+      @image_mount_point = options.fetch(:image_mount_point, Dir.mktmpdir)
+      @verbose           = options.fetch(:verbose, false)
+      @shell             = Bosh::Core::Shell.new
+    end
+
+    def mount
+      device_path   = stemcell_loopback_device_name
+      mount_command = "sudo mount #{device_path} #{image_mount_point}"
+      shell.run(mount_command, output_command: verbose)
+    rescue => e
+      raise e unless e.message.include?(mount_command)
+
+      sleep 0.5
+      shell.run(mount_command, output_command: verbose)
+    end
+
+    def unmount
+      shell.run("sudo umount #{image_mount_point}", output_command: verbose)
+    ensure
+      unmap_image
+    end
+
+    def while_mounted
+      mount
+      yield self
+    ensure
+      unmount
+    end
+
+    private
+
+    attr_reader :image_file_path, :verbose, :shell, :device
+
+    def stemcell_loopback_device_name
+      split_output = map_image.split(' ')
+      device_name  = split_output[2]
+
+      File.join('/dev/mapper', device_name)
+    end
+
+    def map_image
+      @device = shell.run("sudo losetup --show --find #{image_file_path}", output_command: verbose)
+      shell.run("sudo kpartx -av #{device}", output_command: verbose)
+    end
+
+    def unmap_image
+      shell.run("sudo kpartx -dv #{device}", output_command: verbose)
+      shell.run("sudo losetup -dv #{device}", output_command: verbose)
+    end
+  end
+end

data/lib/bosh/stemcell/infrastructure.rb

@@ -0,0 +1,49 @@
+module Bosh::Stemcell
+  module Infrastructure
+    def self.for(name)
+      case name
+        when 'openstack'
+          OpenStack.new
+        when 'aws'
+          Aws.new
+        when 'vsphere'
+          Vsphere.new
+        else
+          raise ArgumentError.new("invalid infrastructure: #{name}")
+      end
+    end
+
+    class Base
+      attr_reader :name, :hypervisor, :default_disk_size
+
+      def initialize(options = {})
+        @name = options.fetch(:name)
+        @supports_light_stemcell = options.fetch(:supports_light_stemcell, false)
+        @hypervisor = options.fetch(:hypervisor)
+        @default_disk_size = options.fetch(:default_disk_size)
+      end
+
+      def light?
+        @supports_light_stemcell
+      end
+    end
+
+    class OpenStack < Base
+      def initialize
+        super(name: 'openstack', hypervisor: 'kvm', default_disk_size: 10240)
+      end
+    end
+
+    class Vsphere < Base
+      def initialize
+        super(name: 'vsphere', hypervisor: 'esxi', default_disk_size: 2048)
+      end
+    end
+
+    class Aws < Base
+      def initialize
+        super(name: 'aws', hypervisor: 'xen', supports_light_stemcell: true, default_disk_size: 2048)
+      end
+    end
+  end
+end

data/lib/bosh/stemcell/operating_system.rb

@@ -0,0 +1,31 @@
+module Bosh::Stemcell
+  module OperatingSystem
+    def self.for(operating_system_name)
+      case operating_system_name
+        when 'centos' then Centos.new
+        when 'ubuntu' then Ubuntu.new
+        else raise ArgumentError.new("invalid operating system: #{operating_system_name}")
+      end
+    end
+
+    class Base
+      attr_reader :name
+
+      def initialize(options = {})
+        @name = options.fetch(:name)
+      end
+    end
+
+    class Centos < Base
+      def initialize
+        super(name: 'centos')
+      end
+    end
+
+    class Ubuntu < Base
+      def initialize
+        super(name: 'ubuntu')
+      end
+    end
+  end
+end

data/lib/bosh/stemcell/stage_collection.rb

@@ -0,0 +1,154 @@
+require 'bosh/stemcell/infrastructure'
+require 'bosh/stemcell/operating_system'
+
+module Bosh::Stemcell
+  class StageCollection
+
+    def initialize(options)
+      @infrastructure   = options.fetch(:infrastructure)
+      @operating_system = options.fetch(:operating_system)
+    end
+
+    def operating_system_stages
+      case operating_system
+        when OperatingSystem::Centos then
+          [:base_centos, :base_yum] + hacked_centos_common
+        when OperatingSystem::Ubuntu then
+          [:base_debootstrap, :base_apt] + common_stages
+      end
+    end
+
+    def infrastructure_stages
+      case infrastructure
+        when Infrastructure::Aws then
+          aws_stages
+        when Infrastructure::OpenStack then
+          openstack_stages
+        when Infrastructure::Vsphere then
+          operating_system.instance_of?(OperatingSystem::Centos) ? hacked_centos_vsphere : vsphere_stages
+      end
+    end
+
+    private
+
+    attr_reader :infrastructure, :operating_system
+
+    def hacked_centos_common
+      [
+        # Bosh steps
+        :bosh_users,
+        :bosh_monit,
+        :bosh_ruby,
+        :bosh_agent,
+        #:bosh_sysstat,
+        #:bosh_sysctl,
+        #:bosh_ntpdate,
+        :bosh_sudoers,
+        # Micro BOSH
+        :bosh_micro,
+        # Install GRUB/kernel/etc
+        :system_grub,
+        #:system_kernel,
+      ]
+    end
+
+    def hacked_centos_vsphere
+      [
+        #:system_open_vm_tools,
+        :system_parameters,
+        :bosh_clean,
+        #:bosh_harden,
+        #:bosh_dpkg_list,
+        :image_create,
+        :image_install_grub,
+        :image_vsphere_vmx,
+        :image_vsphere_ovf,
+        :image_vsphere_prepare_stemcell,
+        :stemcell
+      ]
+    end
+
+    def common_stages
+      [
+        # Bosh steps
+        :bosh_users,
+        :bosh_monit,
+        :bosh_ruby,
+        :bosh_agent,
+        :bosh_sysstat,
+        :bosh_sysctl,
+        :bosh_ntpdate,
+        :bosh_sudoers,
+        # Micro BOSH
+        :bosh_micro,
+        # Install GRUB/kernel/etc
+        :system_grub,
+        :system_kernel,
+      ]
+    end
+
+    def aws_stages
+      [
+        # Misc
+        :system_aws_network,
+        :system_aws_clock,
+        :system_aws_modules,
+        :system_parameters,
+        # Finalisation
+        :bosh_clean,
+        :bosh_harden,
+        :bosh_harden_ssh,
+        :bosh_dpkg_list,
+        # Image/bootloader
+        :image_create,
+        :image_install_grub,
+        :image_aws_update_grub,
+        :image_aws_prepare_stemcell,
+        # Final stemcell
+        :stemcell
+      ]
+    end
+
+    def openstack_stages
+      [
+        # Misc
+        :system_openstack_network,
+        :system_openstack_clock,
+        :system_openstack_modules,
+        :system_parameters,
+        # Finalisation,
+        :bosh_clean,
+        :bosh_harden,
+        :bosh_harden_ssh,
+        :bosh_dpkg_list,
+        # Image/bootloader
+        :image_create,
+        :image_install_grub,
+        :image_openstack_qcow2,
+        :image_openstack_prepare_stemcell,
+        # Final stemcell
+        :stemcell_openstack
+      ]
+    end
+
+    def vsphere_stages
+      [
+        :system_open_vm_tools,
+        # Misc
+        :system_parameters,
+        # Finalisation
+        :bosh_clean,
+        :bosh_harden,
+        :bosh_dpkg_list,
+        # Image/bootloader
+        :image_create,
+        :image_install_grub,
+        :image_vsphere_vmx,
+        :image_vsphere_ovf,
+        :image_vsphere_prepare_stemcell,
+        # Final stemcell
+        :stemcell
+      ]
+    end
+  end
+end

data/lib/bosh/stemcell/stage_runner.rb

@@ -0,0 +1,53 @@
+require 'bosh/core/shell'
+
+module Bosh::Stemcell
+  class StageRunner
+    def initialize(options)
+      @build_path = options.fetch(:build_path)
+      @command_env = options.fetch(:command_env)
+      @settings_file = options.fetch(:settings_file)
+      @work_path = options.fetch(:work_path)
+    end
+
+    def configure_and_apply(stages)
+      configure(stages)
+      apply(stages)
+    end
+
+    def configure(stages)
+      stages.each do |stage|
+        stage_config_script = File.join(build_path, 'stages', stage.to_s, 'config.sh')
+
+        puts "=== Configuring '#{stage}' stage ==="
+        if File.exists?(stage_config_script) && File.executable?(stage_config_script)
+          run_sudo_with_command_env("#{stage_config_script} #{settings_file}")
+        end
+      end
+    end
+
+    def apply(stages)
+      work_directory = File.join(work_path, 'work')
+
+      stages.each do |stage|
+        FileUtils.mkdir_p(work_directory)
+
+        puts "=== Applying '#{stage}' stage ==="
+        puts "== Started #{Time.now.strftime('%a %b %e %H:%M:%S %Z %Y')} =="
+
+        stage_apply_script = File.join(build_path, 'stages', stage.to_s, 'apply.sh')
+
+        run_sudo_with_command_env("#{stage_apply_script} #{work_directory}")
+      end
+    end
+
+    private
+
+    attr_reader :stages, :build_path, :command_env, :settings_file, :work_path
+
+    def run_sudo_with_command_env(command)
+      shell = Bosh::Core::Shell.new
+
+      shell.run("sudo #{command_env} #{command} 2>&1")
+    end
+  end
+end

data/lib/bosh/stemcell/version.rb

@@ -0,0 +1,5 @@
+module Bosh
+  module Stemcell
+    VERSION = '1.5.0.pre.1113'
+  end
+end