chef_instance 0.1.0

data/lib/chef_instance/install/existing.rb

@@ -0,0 +1,27 @@
+require 'chef_instance/install'
+
+module ChefInstance
+  module Install
+    # A Superclass for installing softare that already exists on the system.
+    # Useful for software copied on to the system from the outside, or
+    # available on the local disk.
+    class Existing < ChefInstance::Install::Template
+      # Construct a new Existing object.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+        @new_resource = new_resource
+        @run_context = run_context
+      end
+
+      # We don't really install since its already existing.
+      def install
+      end
+
+      # We don't really uninstall since its already existing.
+      def uninstall
+      end
+    end
+  end
+end

data/lib/chef_instance/install/package.rb

@@ -0,0 +1,66 @@
+require 'chef/resource/package'
+require 'chef_instance/install'
+
+module ChefInstance
+  module Install
+    # A Superclass template for installing packages.
+    class Package < ChefInstance::Install::Template
+      # Construct a new ChefInstance::Install::Package.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+      end
+
+      # Installs a package.
+      #
+      # - Sets up a memoized [Chef::Resource::Package]
+      # - Passes install_options to the memoized resource.
+      # - Performs a `run_action(:install)` on the resource.
+      def install
+        package_resource
+        package_options
+        package_action(:install)
+      end
+
+      # Uninstalls a package.
+      #
+      # - Sets up a memoized [Chef::Resource::Package]
+      # - Performs a `run_action(:remove)` on the resource.
+      def uninstall
+        package_resource
+        package_options
+        package_action(:remove)
+      end
+
+      private
+
+      # Sets up a memoized [Chef::Resource::Package] based on package_name
+      # @return [Chef::Resource::Package]
+      def package_resource
+        @package ||= Chef::Resource::Package.new(package_name, @run_context)
+      end
+
+      # Iterates over options[:package] to send each key as a argument
+      # to the [Chef::Resource::Package]
+      def package_options
+        options[:package].each do |k, v|
+          package_resource.send(k, v)
+        end
+      end
+
+      # Performs action on the resource.
+      # @param action [Symbol] The action to perform.
+      def package_action(action)
+        package_resource.run_action(action)
+      end
+
+      # Fetches the package_name from options.
+      # TODO: Set a default for fetch that raises an error.
+      # @return [String] the package name
+      def package_name
+        options.fetch(package_name)
+      end
+    end
+  end
+end

data/lib/chef_instance/provider_instance.rb

@@ -0,0 +1,82 @@
+require 'chef/provider'
+
+module ChefInstance
+  module Provider
+    # Provides a Superclass Chef Provider to help with Factories.
+    class Instance < Chef::Provider
+      # Construct a new ChefInstance::Provider::Instance.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+        @new_resource = new_resource
+        @run_context = run_context
+        @namespace = @new_resource.namespace
+      end
+
+      # http://docs.opscode.com/essentials_nodes_why_run.html
+      def whyrun_supported?
+        false
+      end
+
+      # Determines the state of the resource _currently_
+      # @return [Resource] @current_resource with name of @new_resource
+      def load_current_resource
+        @current_resource = Chef::Resource::Instance.new(
+          @new_resource, @run_context)
+      end
+
+      # Installs the `install_type`
+      # Creates the `service_type`
+      def action_create
+        instance(@new_resource.install_type, :install)
+        instance(@new_resource.service_type, :create)
+      end
+
+      # Destroy the `service_type`
+      # Uninstall the `install_type`
+      def action_destroy
+      end
+
+      # Disable the `service_type`
+      def action_disable
+        instance(@new_resource.service_type, :disable)
+      end
+
+      # Enable the `service_type`
+      def action_enable
+        instance(@new_resource.service_type, :enable)
+      end
+
+      private
+
+      # Lookup Class, Construct, and send an action.
+      # @param type [String] The install or service type being used.
+      # @param action [Symbol] The action being performed.
+      # @return [TrueClass, FalseClass]
+      def instance(type, action)
+        instance_class = instance_sub_class(type)
+        i = instance_class.new(@new_resource, @run_context)
+        i.send(action)
+      end
+
+      # Lookup the CONSTANT name of a class
+      # ChefInstance::Service::Init == BaseName::Type::Name
+      # @param type [String] The type to lookup.
+      # @param name [String] The name of the type to lookup.
+      # @return [Constant] The class handling type.
+      def instance_sub_class(type, name)
+        klass = "#{ @namespace }::#{ type.capitalize }::#{ name.capitalize }"
+        klass.split('::').reduce(Object) { |a, e| a.const_get(e) }
+      end
+
+      # Determine the @current_resource service provider.
+      def discover_service
+      end
+
+      # Determine how the @current_resource is installed.
+      def discover_install
+      end
+    end
+  end
+end

data/lib/chef_instance/resource_instance.rb

@@ -0,0 +1,63 @@
+require 'chef/resource'
+
+module ChefInstance
+  module Resource
+    # Provides a Superclass Chef Resource to help with Factories.
+    class Instance < Chef::Resource
+      # Construct a new ChefInstance::Resource::Instance.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+        @provider = ChefInstance::Provider::Instance
+        @action = :create
+        @allowed_actions = [:create, :destroy, :enable, :disable, :nothing]
+      end
+
+      # A hash passed to the install type.
+      # Used to pass end-user overrides to the installer.
+      # @param arg [Hash]
+      def install_options(arg = nil)
+        set_or_return(:install_options, arg, kind_of: Hash)
+      end
+
+      # The type of installation you are doing.
+      # @param arg [Symbol]
+      def install_type(arg = nil)
+        set_or_return(:install_type,
+                      arg,
+                      kind_of: [Symbol],
+                      required: true,
+                      equal_to: [:package, :existing])
+      end
+
+      # A hash passed to the service type.
+      # Used to pass end-user overrides to the service.
+      # @param arg [Hash]
+      def service_options(arg = nil)
+        set_or_return(:service_options, arg, kind_of: Hash)
+      end
+
+      # The type of service manager you are using.
+      # @param arg [Symbol]
+      def service_type(arg = nil)
+        set_or_return(:service_type,
+                      arg,
+                      kind_of: Symbol,
+                      required: true,
+                      equal_to: [:init, :runit])
+      end
+
+      # Provide the namespace for lookups.
+      # Because the provider subclasses Chef::Provider
+      # Its `self.class` points us in the wrong direction.
+      # @param arg [String] namespace to use for lookups.
+      def namespace(arg = nil)
+        set_or_return(:namespace,
+                      arg,
+                      kind_of: String,
+                      default: 'ChefInstance')
+      end
+    end
+  end
+end

data/lib/chef_instance/service.rb

@@ -0,0 +1,64 @@
+module ChefInstance
+  module Service
+    # A Superclass template for service managers.
+    class Template
+      # Construct a new ChefInstance::Service::Template.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        @new_resource = new_resource
+        @run_context = run_context
+      end
+
+      # Create and place the service script.
+      def create
+        create_service_script
+      end
+
+      # Destroy the service script.
+      def destroy
+        destroy_service
+      end
+
+      # If enabled, disable the service.
+      def disable
+        disable_service
+      end
+
+      # Enable the service.
+      def enable
+        enable_service
+      end
+
+      private
+
+      # Iterates over options[:service] to send each key as a argument
+      # to the [Chef::Resource::Service]
+      def service_options
+        options[:service].each do |k, v|
+          service_resource.send(k, v)
+        end
+      end
+
+      # Performs action on the resource.
+      # @param action [Symbol] The action to perform.
+      def service_action(action)
+        service_resource.run_action(action)
+      end
+
+      # Sets up a memoized [Chef::Resource::Service] based on package_name
+      # @return [Chef::Resource::Service]
+      def service_resource
+        @service ||= Chef::Resource::Service.new(service_name, @run_context)
+      end
+
+      def service_name
+        new_resource.name
+      end
+
+      def options
+        @options ||= @new_resource.service_options
+      end
+    end
+  end
+end

data/lib/chef_instance/service/init.rb

@@ -0,0 +1,23 @@
+require 'chef/resource/template'
+require 'chef_instance/service'
+
+module ChefInstance
+  module Service
+    # A Superclass managing Init.
+    class Init < ChefInstance::Service::Template
+      # Construct a new ChefInstance::Service::Init.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+      end
+
+      private
+
+      # Uses a template to create a Init script for the named service.
+      def create_service_script
+        #r = Chef::Resource::Template.new
+      end
+    end
+  end
+end

data/lib/chef_instance/service/runit.rb

@@ -0,0 +1,24 @@
+require 'chef_instance/service'
+
+module ChefInstance
+  module Service
+    # A Superclass managing Runit.
+    class Runit < ChefInstance::Service::Template
+      # Construct a new ChefInstance::Service::Runit.
+      # @param new_resource [Chef::Resource]
+      # @param run_context [Chef::RunContext]
+      def initialize(new_resource, run_context = nil)
+        super
+      end
+
+      private
+
+      # Sets up a memoized [Chef::Resource::RunitService] based on package_name
+      # @return [Chef::Resource::RunitService]
+      def service_resource
+        @service ||=
+          Chef::Resource::RunitService.new(service_name, @run_context)
+      end
+    end
+  end
+end

data/lib/chef_instance/version.rb

@@ -0,0 +1,5 @@
+module ChefInstance
+  # The version of the chef_instance library.
+  # This is semver
+  VERSION = '0.1.0'
+end

data/test/spec/install/existing_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../spec_helper.rb'
+require 'chef_instance/install/existing'
+
+describe ChefInstance::Install::Existing, '' do
+  let(:node) do
+    node = Chef::Node.new
+    node.automatic[:platform] = 'ubuntu'
+    node.automatic[:platform_version] = '12.04'
+    node
+  end
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { 'package_test' }
+  let(:install) do
+    ChefInstance::Install::Existing.new(resource, run_context)
+  end
+
+  before do
+    @install_res = install
+  end
+
+  describe 'Object Ancestry Checks' do
+    it 'Is a ChefInstance::Install::Template?' do
+      @install_res.must_be_kind_of(ChefInstance::Install::Template)
+    end
+
+    it 'Is a instance of Init' do
+      @install_res.must_be_instance_of(ChefInstance::Install::Existing)
+    end
+  end
+
+  describe 'It adhears to the Install::Template contract.' do
+
+    describe 'It should..' do
+      it 'Create.' do
+        @install_res.must_respond_to(:install)
+      end
+
+      it 'Destroy.' do
+        @install_res.must_respond_to(:uninstall)
+      end
+    end
+  end
+end

data/test/spec/install/package_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper.rb'
+require 'chef_instance/install/package'
+
+describe ChefInstance::Install::Package, '' do
+  let(:node) do
+    node = Chef::Node.new
+    node.automatic[:platform] = 'ubuntu'
+    node.automatic[:platform_version] = '12.04'
+    node
+  end
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:instance_name) { 'test' }
+  let(:install_options) do
+    {
+      package: {
+        package_name: 'test',
+        version: '1.0.0'
+      }
+    }
+  end
+  let(:instance) do
+    MiniTest::Mock.new
+  end
+  let(:package_res) do
+    ChefInstance::Install::Package.new(instance, run_context)
+  end
+
+  before do
+    @package_res = package_res
+    @install_options = install_options
+  end
+
+  describe 'Object Ancestry Checks' do
+    it 'Is a ChefInstance::Install::Template?' do
+      @package_res.must_be_kind_of(ChefInstance::Install::Template)
+    end
+
+    it 'Is a instance of Init' do
+      @package_res.must_be_instance_of(ChefInstance::Install::Package)
+    end
+  end
+
+  describe 'It adhears to the Install::Template contract.' do
+    describe 'It should..' do
+      before :each do
+        @chef_package = MiniTest::Mock.new
+        @chef_package.expect(:package_name, true, %w(test))
+        @chef_package.expect(:version, true, %w(1.0.0))
+        instance.expect(:install_options, install_options)
+        instance.expect(:install_type, :package)
+      end
+
+      it 'install.' do
+        @chef_package.expect(:run_action, true, [:install])
+
+        @package_res.must_respond_to(:install)
+        @package_res.stub(:package_resource, @chef_package) do
+          @package_res.install.must_equal(true)
+        end
+
+        @chef_package.verify.must_equal(true)
+      end
+
+      it 'uninstall.' do
+        @chef_package.expect(:run_action, true, [:remove])
+        @package_res.must_respond_to(:uninstall)
+        @package_res.stub(:package_resource, @chef_package) do
+          @package_res.uninstall.must_equal(true)
+        end
+
+        @chef_package.verify.must_equal(true)
+      end
+    end
+  end
+end