chef-metal-fog 0.4 → 0.5.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60b1659681a87e03c3e75748bf5e0a729d1d42e0
-  data.tar.gz: 7aea9de39a52c044f12f49b045bb9bad64277851
+  metadata.gz: 1dd0fd9efc928a98ed0742916d1bbbed1a2c13b3
+  data.tar.gz: a4cb6fb64e7848db44f96ef6e4385bcd1fe1247d
 SHA512:
-  metadata.gz: 6528c4091d92999bf66166df4459cd036b273c65e8372cda122a35c5efbaf0a1bc2d12fa624ef2935545b05cf1c86473ca44b535a5c837a17ac1f09f24d8f6d4
-  data.tar.gz: 64d79d629752c5c3da14a5dfbb9a91a4a96f62bd956ecaacdd8adde30a24e4d040213ae13f06b793065e077c3df7e55aec472d5e0419dd8e4bb7fb39344610bc
+  metadata.gz: 872bbb650218e9374713b63575849a25eb5dc296b0633ace402c5c19b791a5e8f68115df0546eb5297e87d586f5d3f24c22fc1c1b592784a95221358a70bf100
+  data.tar.gz: 9455469c78c3d131ef9562cea69bb6a529dafa4f98f2f3bd8541012b66bddc2db08cbbbcf83a5266f1e72925c10ddaafde8f43f3a0dab5ada29c39301fb43ee6

data/README.md

@@ -1,3 +1,3 @@
 # chef-metal-fog
 
-This is the Fog provisioner for chef-metal.  It provides EC2, DigitalOcean and Openstack functionality.
+This is the Fog driver for chef-metal.  It provides EC2, DigitalOcean and Openstack functionality.

data/lib/chef/provider/fog_key_pair.rb

@@ -1,11 +1,8 @@
 require 'chef/provider/lwrp_base'
-require 'chef_metal/provider_action_handler'
-require 'chef_metal_fog/fog_provisioner'
+require 'chef_metal_fog/fog_driver'
 
 class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
 
-  include ChefMetal::ProviderActionHandler
-
   use_inline_resources
 
   def whyrun_supported?
@@ -19,7 +16,7 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
   action :delete do
     if current_resource_exists?
       converge_by "delete #{key_description}" do
-        case new_resource.provisioner.compute_options[:provider]
+        case new_driver.compute_options[:provider]
         when 'DigitalOcean'
           compute.destroy_key_pair(@current_id)
         when 'OpenStack'
@@ -32,23 +29,29 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
   end
 
   def key_description
-    "#{new_resource.name} on #{new_resource.provisioner.provisioner_url}"
+    "#{new_resource.name} on #{new_driver.driver_url}"
   end
 
   def create_key(action)
+    if @should_create_directory
+      Cheffish.inline_resource(self, action) do
+        directory run_context.config[:private_key_write_path]
+      end
+    end
+
     if current_resource_exists?
       # If the public keys are different, update the server public key
       if !current_resource.private_key_path
         if new_resource.allow_overwrite
           ensure_keys(action)
         else
-          raise "#{key_description} already exists on the server, but the private key #{new_resource.private_key_path} does not exist!"
+          raise "#{key_description} already exists on the server, but the private key #{new_private_key_path} does not exist!"
         end
       else
         ensure_keys(action)
       end
 
-      new_fingerprints = case new_resource.provisioner.compute_options[:provider]
+      new_fingerprints = case new_driver.compute_options[:provider]
       when 'DigitalOcean'
         [Cheffish::KeyFormatter.encode(desired_key, :format => :openssh)]
       when 'OpenStack'
@@ -73,7 +76,7 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
       if !new_fingerprints.any? { |f| (f.is_a?(Proc) ? f.call : f) == @current_fingerprint }
         if new_resource.allow_overwrite
           converge_by "update #{key_description} to match local key at #{new_resource.private_key_path}" do
-            case new_resource.provisioner.compute_options[:provider]
+            case new_driver.compute_options[:provider]
             when 'DigitalOcean'
               compute.create_ssh_key(new_resource.name, Cheffish::KeyFormatter.encode(desired_key, :format => :openssh))
             when 'OpenStack'
@@ -92,7 +95,7 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
 
       # Create key
       converge_by "create #{key_description} from local key at #{new_resource.private_key_path}" do
-        case new_resource.provisioner.compute_options[:provider]
+        case new_driver.compute_options[:provider]
         when 'DigitalOcean'
           compute.create_ssh_key(new_resource.name, Cheffish::KeyFormatter.encode(desired_key, :format => :openssh))
         when 'OpenStack'
@@ -104,10 +107,15 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
     end
   end
 
+  def new_driver
+    run_context.chef_metal.driver_for(new_resource.driver)
+  end
+
   def ensure_keys(action)
     resource = new_resource
+    private_key_path = new_private_key_path
     Cheffish.inline_resource(self, action) do
-      private_key resource.private_key_path do
+      private_key private_key_path do
         public_key_path resource.public_key_path
         if resource.private_key_options
           resource.private_key_options.each_pair do |key,value|
@@ -131,8 +139,8 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
 
   def desired_private_key
     @desired_private_key ||= begin
-        private_key, format = Cheffish::KeyFormatter.decode(IO.read(new_resource.private_key_path))
-        private_key
+      private_key, format = Cheffish::KeyFormatter.decode(IO.read(new_private_key_path))
+      private_key
     end
   end
 
@@ -141,19 +149,35 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
   end
 
   def compute
-    new_resource.provisioner.compute
+    new_driver.compute
   end
 
   def current_public_key
     current_resource.source_key
   end
 
+  def new_private_key_path
+    private_key_path = new_resource.private_key_path || new_resource.name
+    if private_key_path.is_a?(Symbol)
+      private_key_path
+    elsif Pathname.new(private_key_path).relative? && new_driver.config[:private_key_write_path]
+      @should_create_directory = true
+      ::File.join(new_driver.config[:private_key_write_path], private_key_path)
+    else
+      private_key_path
+    end
+  end
+
+  def new_public_key_path
+    new_resource.public_key_path
+  end
+
   def load_current_resource
-    if !new_resource.provisioner.kind_of?(ChefMetalFog::FogProvisioner)
-      raise 'ec2_key_pair only works with fog_provisioner'
+    if !new_driver.kind_of?(ChefMetalFog::FogDriver)
+      raise 'fog_key_pair only works with fog_driver'
     end
     @current_resource = Chef::Resource::FogKeyPair.new(new_resource.name, run_context)
-    case new_resource.provisioner.compute_options[:provider]
+    case new_driver.provider
     when 'DigitalOcean'
       current_key_pair = compute.ssh_keys.select { |key| key.name == new_resource.name }.first
       if current_key_pair
@@ -179,11 +203,11 @@ class Chef::Provider::FogKeyPair < Chef::Provider::LWRPBase
       end
     end
 
-    if new_resource.private_key_path && ::File.exist?(new_resource.private_key_path)
-      current_resource.private_key_path new_resource.private_key_path
+    if new_private_key_path && ::File.exist?(new_private_key_path)
+      current_resource.private_key_path new_private_key_path
     end
-    if new_resource.public_key_path && ::File.exist?(new_resource.public_key_path)
-      current_resource.public_key_path new_resource.public_key_path
+    if new_public_key_path && ::File.exist?(new_public_key_path)
+      current_resource.public_key_path new_public_key_path
     end
   end
 end

data/lib/chef/resource/fog_key_pair.rb

@@ -5,18 +5,13 @@ class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
 
   def initialize(*args)
     super
-    @provisioner = run_context.chef_metal.current_provisioner
-  end
-
-  def after_created
-    # Make the credentials usable
-    provisioner.key_pairs[name] = self
+    @driver = run_context.chef_metal.current_driver
   end
 
   actions :create, :delete, :nothing
   default_action :create
 
-  attribute :provisioner
+  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)

data/lib/chef_metal/driver_init/fog.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_fog/fog_driver'
+
+ChefMetal.register_driver_class("fog", ChefMetalFog::FogDriver)

data/lib/chef_metal_fog/aws_credentials.rb

@@ -0,0 +1,65 @@
+require 'inifile'
+require 'csv'
+
+module ChefMetalFog
+  # Reads in a credentials file in Amazon's download format and presents the credentials to you
+  class AWSCredentials
+    def initialize
+      @credentials = {}
+    end
+
+    def default
+      @credentials[ENV['AWS_DEFAULT_PROFILE'] || 'default'] || @credentials.first[1]
+    end
+
+    def keys
+      @credentials.keys
+    end
+
+    def [](name)
+      @credentials[name]
+    end
+
+    def each(&block)
+      @credentials.each(&block)
+    end
+
+    def load_ini(credentials_ini_file)
+      inifile = IniFile.load(File.expand_path(credentials_ini_file))
+      inifile.each_section do |section|
+        if section =~ /^\s*profile\s+(.+)$/ || section =~ /^\s*(default)\s*/
+          profile_name = $1.strip
+          profile = inifile[section].inject({}) do |result, pair|
+            result[pair[0].to_sym] = pair[1]
+            result
+          end
+          profile[:name] = profile_name
+          @credentials[profile_name] = profile
+        end
+      end
+    end
+
+    def load_csv(credentials_csv_file)
+      CSV.new(File.open(credentials_csv_file), :headers => :first_row).each do |row|
+        @credentials[row['User Name']] = {
+          :name => row['User Name'],
+          :user_name => row['User Name'],
+          :aws_access_key_id => row['Access Key Id'],
+          :aws_secret_access_key => row['Secret Access Key']
+        }
+      end
+    end
+
+    def load_default
+      load_ini('~/.aws/config')
+    end
+
+    def self.method_missing(name, *args, &block)
+      singleton.send(name, *args, &block)
+    end
+
+    def self.singleton
+      @aws_credentials ||= AWSCredentials.new
+    end
+  end
+end