image_builder 0.0.1

data/lib/image_builder/provisioners/chef_base.rb

@@ -0,0 +1,96 @@
+require_relative './provisioner_base.rb'
+
+# rubocop:disable Style/EmptyLineBetweenDefs, Style/TrivialAccessors
+
+module ImageBuilder
+  module Provisioners
+    module Chef
+      # Generic class doc comment
+      class Base < ImageBuilder::Provisioners::Base
+        attr_accessor :cookbook_paths
+        attr_accessor :config_template
+        attr_accessor :encrypted_data_bag_secret_path
+        attr_accessor :execute_command
+        attr_accessor :install_command
+        attr_accessor :json
+        attr_accessor :prevent_sudo
+        attr_accessor :run_list
+        attr_accessor :skip_install
+        attr_accessor :staging_directory
+
+        attr_reader :type
+
+        def initialize
+          @prevent_sudo = false
+          @skip_install = false
+          @encrypted_data_bag_secret_path = ENV['ENCRYPTED_DATA_BAG_SECRET']
+        end
+
+        # set attributes from something that looks like a knife.rb file
+        def self.from_file(path)
+          inst = new
+          @knife_file = ::File.expand_path(path)
+
+          # For knife hash params in knife.rb
+          knife = {} # rubocop:disable Lint/UselessAssignment
+          inst.instance_eval(IO.read(@knife_file))
+
+          inst
+        end
+
+        # Map knife.rb config options to their corresponding object attributes
+        # the :encrypted_data_bag_secret_path attribute is specific to the chef-solo
+        # provisioner, but we'll need it for all chef provisioners, since we need to
+        # upload it to the node before provisioning via the chef-client provisioner
+        def encrypted_data_bag_secret(sec)
+          @encrypted_data_bag_secret_path = sec
+        end
+
+        # While not used explicitly in the chef-client provisioner, this will give
+        # us consistent behavior across chef provisioners if we need to do a local
+        # cookbook lookup
+        def cookbook_path(path)
+          @cookbook_paths = [ENV['COOKBOOK_PATH']] << path
+          @cookbook_paths.flatten!
+          @cookbook_paths.compact!
+          @cookbook_paths.uniq!
+        end
+
+        def packer_hash
+          hash = { type: @type }
+
+          attr_to_hash(hash, :config_template)
+          attr_to_hash(hash, :execute_command)
+          attr_to_hash(hash, :install_command)
+          attr_to_hash(hash, :json)
+          attr_to_hash(hash, :prevent_sudo)
+          attr_to_hash(hash, :run_list)
+          attr_to_hash(hash, :skip_install)
+          attr_to_hash(hash, :staging_directory)
+
+          hash
+        end
+
+        protected
+
+        attr_reader :knife_file
+
+        # These attributes might be found in a knife.rb file, but may not be used for
+        # a specific provisioner.  This is only here to ensure the instance_eval in the
+        # from_file method (above) passes
+        def log_level(_lvl) end
+        def log_location(_loc) end
+        def node_name(_name) end
+        def client_key(_key) end
+        def validation_client_name(_client) end
+        def validation_key(_key) end
+        def chef_server_url(_url) end
+        def cache_type(_type) end
+        def cache_options(_opts) end
+        def cookbook_copyright(_x) end
+        def cookbook_email(_mail) end
+        def name(_name = nil) end
+      end
+    end
+  end
+end

data/lib/image_builder/provisioners/chef_client.rb

@@ -0,0 +1,115 @@
+require_relative './chef_base.rb'
+
+# rubocop:disable Style/TrivialAccessors
+
+module ImageBuilder
+  module Provisioners
+    module Chef
+      # Generic class doc comment
+      class Client < ImageBuilder::Provisioners::Chef::Base
+        attr_accessor :chef_environment
+        attr_accessor :node_name
+        attr_accessor :server_url # required
+        attr_accessor :skip_clean_client
+        attr_accessor :skip_clean_node
+        attr_accessor :validation_client_name
+        attr_accessor :validation_key_path
+
+        def initialize
+          super
+          @skip_clean_client = false
+          @skip_clean_node   = false
+          @type = 'chef-client'
+        end
+
+        # Map chef-client provisioner knife.rb config options
+        # to their corresponding object attributes
+        def node_name(name = nil)
+          @node_name = name unless name.nil? || name.strip.empty?
+          @node_name
+        end
+
+        def chef_server_url(url)
+          @server_url = url
+        end
+
+        # Since this has an attr_accessor of the same name, need to
+        # write this as a getter & setter method
+        def validation_client_name(name = nil)
+          @validation_client_name = name unless name.nil?
+          @validation_client_name
+        end
+
+        def validation_key(key)
+          @validation_key_path = fixup_key_path(key)
+        end
+
+        def packer_hash
+          hash = super
+
+          # Required attrs
+          attr_to_hash(hash, :server_url, true)
+
+          # Optional attrs
+          attr_to_hash(hash, :chef_environment)
+          attr_to_hash(hash, :node_name)
+          attr_to_hash(hash, :skip_clean_client)
+          attr_to_hash(hash, :skip_clean_node)
+          attr_to_hash(hash, :validation_client_name)
+          attr_to_hash(hash, :validation_key_path)
+
+          hash
+        end
+
+        private
+
+        # This may not come in as a valid file after reading knife.rb, try some fixups
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def fixup_key_path(path)
+          return path if path.nil? || path.empty?
+
+          unless ::File.exist?(path)
+            file_name = ::File.basename(path)
+            sec_var   = @encrypted_data_bag_secret_path
+            sec_env   = ENV['ENCRYPTED_DATA_BAG_SECRET']
+
+            # Pearson-centric env vars
+            merle_key = ENV['MERLE_VALIDATOR']
+            path = check_file(merle_key) if valid_path?(merle_key)
+
+            merle = ENV['MERLE']
+            path = check_file(::File.join(merle, file_name)) if valid_path?(merle) && path.nil?
+
+            # 'standard' location checks
+            if valid_path?(@knife_file) && path.nil?
+              dir  = ::File.dirname(@knife_file)
+              path = check_file(::File.join(dir, file_name))
+            end
+
+            if valid_path?(sec_var) && path.nil?
+              dir  = ::File.dirname(sec_var)
+              path = check_file(::File.join(dir, file_name))
+            end
+
+            if valid_path?(sec_env) && path.nil?
+              dir  = ::File.dirname(sec_env)
+              path = check_file(::File.join(dir, file_name))
+            end
+          end
+
+          path
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def check_file(path)
+          return path if ::File.exist?(path)
+          nil
+        end
+
+        def valid_path?(path)
+          !path.nil? && !path.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/image_builder/provisioners/chef_solo.rb

@@ -0,0 +1,33 @@
+require_relative './chef_base.rb'
+
+# rubocop:disable Style/TrivialAccessors
+
+module ImageBuilder
+  module Provisioners
+    module Chef
+      # Generic class doc comment
+      class Solo < ImageBuilder::Provisioners::Chef::Base
+        attr_accessor :data_bags_path
+        attr_accessor :remote_cookbook_paths
+        attr_accessor :roles_path
+
+        def initialize
+          super
+          @type = 'chef-solo'
+        end
+
+        def packer_hash
+          hash = super
+
+          attr_to_hash(hash, :data_bags_path)
+          attr_to_hash(hash, :remote_cookbook_paths)
+          attr_to_hash(hash, :roles_path)
+          attr_to_hash(hash, :cookbook_paths)
+          attr_to_hash(hash, :encrypted_data_bag_secret_path)
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/image_builder/provisioners/file.rb

@@ -0,0 +1,26 @@
+require_relative './provisioner_base.rb'
+
+module ImageBuilder
+  module Provisioners
+    # Generic class doc comment
+    class File < ImageBuilder::Provisioners::Base
+      attr_accessor :source
+      attr_accessor :destination
+
+      attr_reader :type
+
+      def initialize
+        @type = 'file'
+      end
+
+      def packer_hash
+        hash = { type: @type }
+
+        attr_to_hash(hash, :source, true)
+        attr_to_hash(hash, :destination, true)
+
+        hash
+      end
+    end
+  end
+end

data/lib/image_builder/provisioners/provisioner_base.rb

@@ -0,0 +1,10 @@
+require_relative '../../image_builder.rb'
+
+module ImageBuilder
+  module Provisioners
+    # Generic class doc comment
+    class Base
+      include ImageBuilder
+    end
+  end
+end

data/lib/image_builder/provisioners/shell.rb

@@ -0,0 +1,47 @@
+require_relative './provisioner_base.rb'
+
+module ImageBuilder
+  module Provisioners
+    # Generic class doc comment
+    class Shell < ImageBuilder::Provisioners::Base
+      # Only one of these is allowed/required
+      attr_accessor :inline
+      attr_accessor :script
+      attr_accessor :scripts
+
+      # Optional
+      attr_accessor :binary
+      attr_accessor :environment_vars
+      attr_accessor :execute_command
+      attr_accessor :inline_shebang
+      attr_accessor :remote_path
+      attr_accessor :start_retry_timeout
+
+      attr_reader :type
+
+      def initialize
+        @type = 'shell'
+      end
+
+      def packer_hash
+        hash = { type: @type }
+
+        # Let packer enforce the validation requirements
+        # for these attributes, don't make them required
+        attr_to_hash(hash, :inline)
+        attr_to_hash(hash, :script)
+        attr_to_hash(hash, :scripts)
+
+        # Optional attrs
+        attr_to_hash(hash, :binary)
+        attr_to_hash(hash, :environment_vars)
+        attr_to_hash(hash, :execute_command)
+        attr_to_hash(hash, :inline_shebang)
+        attr_to_hash(hash, :remote_path)
+        attr_to_hash(hash, :start_retry_timeout)
+
+        hash
+      end
+    end
+  end
+end

data/lib/image_builder/version.rb

@@ -0,0 +1,4 @@
+# Generic top-level module comment
+module ImageBuilder
+  VERSION = '0.0.1'
+end

data/spec/aws_chroot_builder_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../lib/image_builder/builders/aws_chroot.rb'
+
+describe ImageBuilder::Builders::AWS::Chroot do
+  before(:each) do
+    @obj = ImageBuilder::Builders::AWS::Chroot.new
+  end
+
+  it 'has the expected default block device mappings as a class attribute' do
+    expected = [
+      { device_name: '/dev/sdf', virtual_name: 'ephemeral0' },
+      { device_name: '/dev/sdg', virtual_name: 'ephemeral1' },
+      { device_name: '/dev/sdh', virtual_name: 'ephemeral2' },
+      { device_name: '/dev/sdi', virtual_name: 'ephemeral3' }
+    ]
+
+    devs = ImageBuilder::Builders::AWS::Chroot.default_block_device_mappings
+
+    expect(devs).to eql expected
+    expect(devs[1][:device_name]).to eql '/dev/sdg'
+    expect(devs[1][:virtual_name]).to eql 'ephemeral1'
+  end
+
+  it 'has the correct packer type' do
+    expect(@obj.type).to eql 'amazon-chroot'
+  end
+
+  it 'implements packer_hash()' do
+    expect(@obj.respond_to? :packer_hash).to be true
+  end
+end

data/spec/aws_ebs_builder_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../lib/image_builder/builders/aws_ebs.rb'
+
+describe ImageBuilder::Builders::AWS::EBS do
+  before(:each) do
+    @obj = ImageBuilder::Builders::AWS::EBS.new
+  end
+
+  it 'has the expected default block device mappings as a class attribute' do
+    expected = [
+      { device_name: '/dev/sdf', virtual_name: 'ephemeral0' },
+      { device_name: '/dev/sdg', virtual_name: 'ephemeral1' },
+      { device_name: '/dev/sdh', virtual_name: 'ephemeral2' },
+      { device_name: '/dev/sdi', virtual_name: 'ephemeral3' }
+    ]
+
+    devs = ImageBuilder::Builders::AWS::EBS.default_block_device_mappings
+
+    expect(devs).to eql expected
+    expect(devs[1][:device_name]).to eql '/dev/sdg'
+    expect(devs[1][:virtual_name]).to eql 'ephemeral1'
+  end
+
+  it 'has the correct packer type' do
+    expect(@obj.type).to eql 'amazon-ebs'
+  end
+
+  it 'implements packer_hash()' do
+    expect(@obj.respond_to? :packer_hash).to be true
+  end
+end

data/spec/aws_instance_builder_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../lib/image_builder/builders/aws_instance.rb'
+
+describe ImageBuilder::Builders::AWS::Instance do
+  before(:each) do
+    @obj = ImageBuilder::Builders::AWS::Instance.new
+  end
+
+  it 'has the expected default block device mappings as a class attribute' do
+    expected = [
+      { device_name: '/dev/sdf', virtual_name: 'ephemeral0' },
+      { device_name: '/dev/sdg', virtual_name: 'ephemeral1' },
+      { device_name: '/dev/sdh', virtual_name: 'ephemeral2' },
+      { device_name: '/dev/sdi', virtual_name: 'ephemeral3' }
+    ]
+
+    devs = ImageBuilder::Builders::AWS::Instance.default_block_device_mappings
+
+    expect(devs).to eql expected
+    expect(devs[1][:device_name]).to eql '/dev/sdg'
+    expect(devs[1][:virtual_name]).to eql 'ephemeral1'
+  end
+
+  it 'has the correct packer type' do
+    expect(@obj.type).to eql 'amazon-instance'
+  end
+
+  it 'implements packer_hash()' do
+    expect(@obj.respond_to? :packer_hash).to be true
+  end
+end

data/spec/chef_client_provisioner_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../lib/image_builder/provisioners/chef_client.rb'
+
+describe ImageBuilder::Provisioners::Chef::Client do
+  before(:each) do
+    @obj = ImageBuilder::Provisioners::Chef::Client.new
+  end
+
+  it 'has the expected default attributes' do
+    expect(@obj.prevent_sudo).to be false
+    expect(@obj.skip_install).to be false
+    expect(@obj.skip_clean_client).to be false
+    expect(@obj.skip_clean_node).to be false
+  end
+
+  it 'loads the expected parameters from a file as a class method' do
+    # @obj.from_file(::File.join(::File.dirname(__FILE__), 'fixtures', 'test-knife.rb'))
+    obj = ImageBuilder::Provisioners::Chef::Client.from_file(::File.join(::File.dirname(__FILE__), 'fixtures', 'test-knife.rb'))
+
+    expect(obj.validation_client_name).to eql 'chef-validator'
+    expect(obj.validation_key_path).to eql '/dev/null'
+    expect(obj.server_url).to eql 'https://chef.chefserver.com/'
+    expect(obj.encrypted_data_bag_secret_path).to eql ENV['ENCRYPTED_DATA_BAG_SECRET']
+  end
+
+  it 'has the correct packer type' do
+    expect(@obj.type).to eql 'chef-client'
+  end
+
+  it 'implements packer_hash()' do
+    expect(@obj.respond_to? :packer_hash).to be true
+  end
+end