chef-provisioning-fog 0.10

data/lib/chef/provisioning/fog_driver/providers/cloudstack.rb

@@ -0,0 +1,44 @@
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class CloudStack < FogDriver::Driver
+
+      Driver.register_provider_class('CloudStack', FogDriver::Providers::CloudStack)
+
+      def creator
+        ''
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        if id && id != ''
+          cloudstack_uri = URI.parse(id)
+          new_compute_options[:cloudstack_scheme] = cloudstack_uri.scheme
+          new_compute_options[:cloudstack_host]   = cloudstack_uri.host
+          new_compute_options[:cloudstack_port]   = cloudstack_uri.port
+          new_compute_options[:cloudstack_path]   = cloudstack_uri.path
+        end
+
+        host   = result[:driver_options][:compute_options][:cloudstack_host]
+        path   = result[:driver_options][:compute_options][:cloudstack_path]    || '/client/api'
+        port   = result[:driver_options][:compute_options][:cloudstack_port]    || 443
+        scheme = result[:driver_options][:compute_options][:cloudstack_scheme]  || 'https'
+        id = URI.scheme_list[scheme.upcase].build(:host => host, :port => port, :path => path).to_s
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/providers/digitalocean.rb

@@ -0,0 +1,122 @@
+#   fog:DigitalOcean:<client id>
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class DigitalOcean < FogDriver::Driver
+      Driver.register_provider_class('DigitalOcean', FogDriver::Providers::DigitalOcean)
+
+      def creator
+        ''
+      end
+
+      def bootstrap_options_for(action_handler, machine_spec, machine_options)
+        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+        if bootstrap_options[:key_path]
+          bootstrap_options[:key_name] ||= File.basename(bootstrap_options[:key_path])
+          # Verify that the provided key name and path are in line (or create the key pair if not!)
+          driver = self
+          Provisioning.inline_resource(action_handler) do
+            fog_key_pair bootstrap_options[:key_name] do
+              private_key_path bootstrap_options[:key_path]
+              driver driver
+            end
+          end
+        else
+          bootstrap_options[:key_name] = overwrite_default_key_willy_nilly(action_handler, machine_spec)
+        end
+
+        bootstrap_options[:tags]  = default_tags(machine_spec, bootstrap_options[:tags] || {})
+
+        if !bootstrap_options[:image_id]
+          bootstrap_options[:image_name] ||= 'CentOS 6.4 x32'
+          bootstrap_options[:image_id] = compute.images.select { |image| image.name == bootstrap_options[:image_name] }.first.id
+        end
+        if !bootstrap_options[:flavor_id]
+          bootstrap_options[:flavor_name] ||= '512MB'
+          bootstrap_options[:flavor_id] = compute.flavors.select { |flavor| flavor.name == bootstrap_options[:flavor_name] }.first.id
+        end
+        if !bootstrap_options[:region_id]
+          bootstrap_options[:region_name] ||= 'San Francisco 1'
+          bootstrap_options[:region_id] = compute.regions.select { |region| region.name == bootstrap_options[:region_name] }.first.id
+        end
+        found_key = compute.ssh_keys.select { |k| k.name == bootstrap_options[:key_name] }.first
+        if !found_key
+          raise "Could not find key named '#{bootstrap_options[:key_name]}' on #{driver_url}"
+        end
+        bootstrap_options[:ssh_key_ids] ||= [ found_key.id ]
+
+        # You don't get to specify name yourself
+        bootstrap_options[:name] = machine_spec.name
+
+        bootstrap_options
+      end
+
+      def destroy_machine(action_handler, machine_spec, machine_options)
+        server = server_for(machine_spec)
+        if server && server.state != 'archive'
+          action_handler.perform_action "destroy machine #{machine_spec.name} (#{machine_spec.location['server_id']} at #{driver_url})" do
+            server.destroy
+          end
+        end
+        machine_spec.location = nil
+        strategy = convergence_strategy_for(machine_spec, machine_options)
+        strategy.cleanup_convergence(action_handler, machine_spec)
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:digitalocean_client_id] = id if (id && id != '')
+
+        # This uses ~/.tugboat, generated by "tugboat authorize" - see https://github.com/pearkes/tugboat
+        tugboat_file = File.expand_path('~/.tugboat')
+        if File.exist?(tugboat_file)
+          tugboat_data = YAML.load(IO.read(tugboat_file))
+          new_compute_options.merge!(
+            :digitalocean_client_id => tugboat_data['authentication']['client_key'],
+            :digitalocean_api_key => tugboat_data['authentication']['api_key']
+          )
+          new_defaults[:machine_options].merge!(
+            #:ssh_username => tugboat_data['ssh']['ssh_user'],
+            :ssh_options => {
+              :port => tugboat_data['ssh']['ssh_port'],
+              # TODO we ignore ssh_key_path in favor of ssh_key / key_name stuff
+              #:key_data => [ IO.read(tugboat_data['ssh']['ssh_key_path']) ] # TODO use paths, not data?
+            }
+          )
+
+          # TODO verify that the key_name exists and matches the ssh key path
+
+          new_defaults[:machine_options][:bootstrap_options].merge!(
+            :region_id => tugboat_data['defaults']['region'].to_i,
+            :image_id => tugboat_data['defaults']['image'].to_i,
+            :size_id => tugboat_data['defaults']['size'].to_i,
+            :private_networking => tugboat_data['defaults']['private_networking'] == 'true',
+            :backups_enabled => tugboat_data['defaults']['backups_enabled'] == 'true',
+          )
+          if tugboat_data['ssh']['ssh_key_path']
+            new_defaults[:machine_options][:bootstrap_options][:key_path] = tugboat_data['ssh']['ssh_key_path']
+          end
+          ssh_key = tugboat_data['defaults']['ssh_key']
+          if ssh_key && ssh_key.size > 0
+            new_defaults[:machine_options][:bootstrap_options][:key_name] = ssh_key
+          end
+        end
+        id = result[:driver_options][:compute_options][:digitalocean_client_id]
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/providers/joyent.rb

@@ -0,0 +1,59 @@
+require 'fog/joyent'
+
+#   fog:Joyent:<joyent_url>
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class Joyent < FogDriver::Driver
+
+      Driver.register_provider_class('Joyent', FogDriver::Providers::Joyent)
+
+      def creator
+        compute_options[:joyent_username]
+      end
+
+      def bootstrap_options_for(action_handler, machine_spec, machine_options)
+        bootstrap_options = symbolize_keys(machine_options[:bootstrap_options] || {})
+
+        bootstrap_options[:tags] = default_tags(machine_spec, bootstrap_options[:tags] || {})
+
+        bootstrap_options[:tags].each do |key, val|
+          bootstrap_options["tag.#{key}"] = val
+        end
+
+        bootstrap_options[:name] ||= machine_spec.name
+
+        bootstrap_options
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:joyent_url] = id if (id && id != '')
+        credential = Fog.credentials
+
+        new_compute_options[:joyent_username] ||= credential[:joyent_username]
+        new_compute_options[:joyent_password] ||= credential[:joyent_password]
+        new_compute_options[:joyent_keyname] ||= credential[:joyent_keyname]
+        new_compute_options[:joyent_keyfile] ||= credential[:joyent_keyfile]
+        new_compute_options[:joyent_url] ||= credential[:joyent_url]
+        new_compute_options[:joyent_version] ||= credential[:joyent_version]
+
+        id = result[:driver_options][:compute_options][:joyent_url]
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/providers/openstack.rb

@@ -0,0 +1,41 @@
+# fog:OpenStack:https://identifyhost:portNumber/v2.0
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class OpenStack < FogDriver::Driver
+
+      Driver.register_provider_class('OpenStack', FogDriver::Providers::OpenStack)
+
+      def creator
+        compute_options[:openstack_username]
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:openstack_auth_url] = id if (id && id != '')
+        credential = Fog.credentials
+
+        new_compute_options[:openstack_username] ||= credential[:openstack_username]
+        new_compute_options[:openstack_api_key] ||= credential[:openstack_api_key]
+        new_compute_options[:openstack_auth_url] ||= credential[:openstack_auth_url]
+        new_compute_options[:openstack_tenant] ||= credential[:openstack_tenant]
+
+        id = result[:driver_options][:compute_options][:openstack_auth_url]
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/providers/rackspace.rb

@@ -0,0 +1,42 @@
+# fog:Rackspace:https://identity.api.rackspacecloud.com/v2.0
+class Chef
+module Provisioning
+module FogDriver
+  module Providers
+    class Rackspace < FogDriver::Driver
+
+      Driver.register_provider_class('Rackspace', FogDriver::Providers::Rackspace)
+
+      def creator
+        compute_options[:rackspace_username]
+      end
+
+      def self.compute_options_for(provider, id, config)
+        new_compute_options = {}
+        new_compute_options[:provider] = provider
+        new_config = { :driver_options => { :compute_options => new_compute_options }}
+        new_defaults = {
+          :driver_options => { :compute_options => {} },
+          :machine_options => { :bootstrap_options => {} }
+        }
+        result = Cheffish::MergedConfig.new(new_config, config, new_defaults)
+
+        new_compute_options[:rackspace_auth_url] = id if (id && id != '')
+        credential = Fog.credentials
+
+        new_compute_options[:rackspace_username] ||= credential[:rackspace_username]
+        new_compute_options[:rackspace_api_key] ||= credential[:rackspace_api_key]
+        new_compute_options[:rackspace_auth_url] ||= credential[:rackspace_auth_url]
+        new_compute_options[:rackspace_region] ||= credential[:rackspace_region]
+        new_compute_options[:rackspace_endpoint] ||= credential[:rackspace_endpoint]
+
+        id = result[:driver_options][:compute_options][:rackspace_auth_url]
+
+        [result, id]
+      end
+
+    end
+  end
+end
+end
+end

data/lib/chef/provisioning/fog_driver/recipe_dsl.rb

@@ -0,0 +1,28 @@
+require 'chef/provisioning/fog_driver/driver'
+require 'chef/resource/fog_key_pair'
+require 'chef/provider/fog_key_pair'
+
+class Chef
+  module DSL
+    module Recipe
+      def with_fog_driver(provider, driver_options = nil, &block)
+        config = Cheffish::MergedConfig.new({ :driver_options => driver_options }, run_context.config)
+        driver = Driver.from_provider(provider, config)
+        run_context.chef_provisioning.with_driver(driver, &block)
+      end
+
+      def with_fog_ec2_driver(driver_options = nil, &block)
+        with_fog_driver('AWS', driver_options, &block)
+      end
+
+      def with_fog_openstack_driver(driver_options = nil, &block)
+        with_fog_driver('OpenStack', driver_options, &block)
+      end
+
+      def with_fog_rackspace_driver(driver_options = nil, &block)
+        with_fog_driver('Rackspace', driver_options, &block)
+      end
+
+    end
+  end
+end

data/lib/chef/provisioning/fog_driver/version.rb

@@ -0,0 +1,7 @@
+class Chef
+module Provisioning
+module FogDriver
+  VERSION = '0.10'
+end
+end
+end

data/lib/chef/resource/fog_key_pair.rb

@@ -0,0 +1,34 @@
+require 'chef/provisioning'
+
+class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
+  self.resource_name = 'fog_key_pair'
+
+  def initialize(*args)
+    super
+    @driver = run_context.chef_provisioning.current_driver
+  end
+
+  actions :create, :delete, :nothing
+  default_action :create
+
+  attribute :driver
+  # Private key to use as input (will be generated if it does not exist)
+  attribute :private_key_path, :kind_of => String
+  # Public key to use as input (will be generated if it does not exist)
+  attribute :public_key_path, :kind_of => String
+  # List of parameters to the private_key resource used for generation of the key
+  attribute :private_key_options, :kind_of => Hash
+
+  # TODO what is the right default for this?
+  attribute :allow_overwrite, :kind_of => [TrueClass, FalseClass], :default => false
+
+  # Proc that runs after the resource completes.  Called with (resource, private_key, public_key)
+  def after(&block)
+    block ? @after = block : @after
+  end
+
+  # We are not interested in Chef's cloning behavior here.
+  def load_prior_resource
+    Chef::Log.debug("Overloading #{resource_name}.load_prior_resource with NOOP")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+$:.unshift File.expand_path('../support', __FILE__)
+require 'fog'
+require 'chef/provisioning'
+require 'chef/provisioning/fog_driver'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+Fog.mock!

data/spec/support/aws/config-file.csv

@@ -0,0 +1,2 @@
+User Name,Access Key Id,Secret Access Key
+test,12345,abcde

data/spec/support/aws/ini-file.ini

@@ -0,0 +1,10 @@
+[default]
+  aws_access_key_id = 12345
+  aws_secret_access_key = abcde
+  aws_session_token = mysecret
+  region = us-east-1
+
+[profile test]
+  aws_access_key_id = foobar
+  aws_secret_access_key = canteloupe
+  region = us-east-1

data/spec/support/chef_metal_fog/providers/testdriver.rb

@@ -0,0 +1,16 @@
+class Chef
+module Provisioning
+class FogDriver::Providers
+  class TestDriver < Chef::Provisioning::FogDriver
+    Chef::Provisioning::FogDriver.register_provider_class('TestDriver', Chef::Provisioning::FogDriver::Providers::TestDriver)
+
+    attr_reader :config
+    def initialize(driver_url, config)
+      super
+    end
+
+    def self.compute_options_for(provider, id, config)
+      [config, 'test']
+    end
+  end
+end

data/spec/unit/fog_driver_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'chef/provisioning/fog_driver'
+
+describe Chef::Provisioning::FogDriver do
+
+  describe ".from_url" do
+    subject { Chef::Provisioning::FogDriver.from_provider('TestDriver', {}) }
+
+    it "should return the correct class" do
+      expect(subject).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::TestDriver
+    end
+
+    it "should call the target compute_options_for" do
+      expect(Chef::Provisioning::FogDriver::Providers::TestDriver).to receive(:compute_options_for)
+        .with('TestDriver', anything, {}).and_return([{}, 'test']).twice
+      subject
+    end
+
+  end
+
+  describe "when creating a new class" do
+    it "should return the correct class" do
+      test = Chef::Provisioning::FogDriver.new('fog:TestDriver:foo', {})
+      expect(test).to be_an_instance_of Chef::Provisioning::FogDriver::Providers::TestDriver
+    end
+
+    it "should populate config" do
+      test = Chef::Provisioning::FogDriver.new('fog:TestDriver:foo', {test: "chef_provisioning"})
+      expect(test.config[:test]).to eq "chef_provisioning"
+    end
+  end
+end