chef-metal 0.1

data/lib/chef/provider/machine.rb

@@ -0,0 +1,60 @@
+require 'chef/provider/lwrp_base'
+require 'chef/provider/chef_node'
+require 'openssl'
+
+class Chef::Provider::Machine < Chef::Provider::LWRPBase
+
+  use_inline_resources
+
+  def whyrun_supported?
+    true
+  end
+
+  action :create do
+    node_json = node_provider.new_json
+    node_json['normal']['provisioner_options'] = new_resource.provisioner_options
+    machine = new_resource.provisioner.acquire_machine(self, node_json)
+    begin
+      machine.setup_convergence(self, new_resource)
+      # If we were asked to converge, or anything changed, or if a converge has never succeeded, converge.
+      if new_resource.converge || (new_resource.converge.nil? && resource_updated?) ||
+         !node_json['automatic'] || node_json['automatic'].size == 0
+        machine.converge(self)
+      end
+    ensure
+      machine.disconnect
+    end
+  end
+
+  action :converge do
+    node_json = node_provider.new_json
+    node_json['normal']['provisioner_options'] = new_resource.provisioner_options
+    machine = new_resource.provisioner.connect_to_machine(node_json)
+    begin
+      machine.converge(self)
+    ensure
+      machine.disconnect
+    end
+  end
+
+  action :stop do
+    node_json = node_provider.new_json
+    node_json['normal']['provisioner_options'] = new_resource.provisioner_options
+    new_resource.provisioner.stop_machine(self, node_json)
+  end
+
+  action :delete do
+    # Grab the node json by asking the provider for it
+    node_data = node_provider.current_json
+
+    # Destroy the machine
+    new_resource.provisioner.delete_machine(self, node_data)
+  end
+
+  attr_reader :node_provider
+
+  def load_current_resource
+    @node_provider = Chef::Provider::ChefNode.new(new_resource, nil)
+    @node_provider.load_current_resource
+  end
+end

data/lib/chef/provider/machine_file.rb

@@ -0,0 +1,39 @@
+require 'chef/provider/lwrp_base'
+require 'cheffish/cheffish_server_api'
+
+class Chef::Provider::MachineFile < Chef::Provider::LWRPBase
+
+  use_inline_resources
+
+  def whyrun_supported?
+    true
+  end
+
+  def machine
+    @machine ||= begin
+      if new_resource.machine.kind_of?(ChefMetal::Machine)
+        new_resource.machine
+      else
+        # TODO this is inefficient, can we cache or something?
+        node = Cheffish::CheffishServerAPI.new(new_resource.chef_server).get("/nodes/#{new_resource.machine}")
+        new_resource.provisioner.connect_to_machine(node)
+      end
+    end
+  end
+
+  action :upload do
+    if new_resource.content
+      machine.write_file(self, new_resource.path, new_resource.content)
+    else
+      machine.upload_file(self, new_resource.local_path, new_resource.path)
+    end
+  end
+
+  action :download do
+    machine.download_file(provider, new_resource.path, new_resource.local_path)
+  end
+
+  action :delete do
+    machine.delete_file(self, new_resource.path)
+  end
+end

data/lib/chef/provider/vagrant_box.rb

@@ -0,0 +1,44 @@
+require 'chef/provider/lwrp_base'
+require 'chef/mixin/shell_out'
+
+class Chef::Provider::VagrantBox < Chef::Provider::LWRPBase
+
+  use_inline_resources
+
+  include Chef::Mixin::ShellOut
+
+  def whyrun_supported?
+    true
+  end
+
+  action :create do
+    if !list_boxes.has_key?(new_resource.name)
+      if new_resource.url
+        converge_by "run 'vagrant box add #{new_resource.name} #{new_resource.url}'" do
+          shell_out("vagrant box add #{new_resource.name} #{new_resource.url}").error!
+        end
+      else
+        raise "Box #{new_resource.name} does not exist"
+      end
+    end
+  end
+
+  action :delete do
+    if list_boxes.has_key?(new_resource.name)
+      converge_by "run 'vagrant box remove #{new_resource.name} #{list_boxes[new_resource.name]}'" do
+        shell_out("vagrant box remove #{new_resource.name} #{list_boxes[new_resource.name]}").error!
+      end
+    end
+  end
+
+  def list_boxes
+    @list_boxes ||= shell_out("vagrant box list").stdout.lines.inject({}) do |result, line|
+      line =~ /^(\S+)\s+\((.+)\)\s*$/
+      result[$1] = $2
+      result
+    end
+  end
+
+  def load_current_resource
+  end
+end

data/lib/chef/provider/vagrant_cluster.rb

@@ -0,0 +1,39 @@
+require 'chef/provider/lwrp_base'
+
+class Chef::Provider::VagrantCluster < Chef::Provider::LWRPBase
+
+  use_inline_resources
+
+  def whyrun_supported?
+    true
+  end
+
+  action :create do
+    the_base_path = new_resource.path
+    ChefMetal.inline_resource(self) do
+      directory the_base_path
+      file ::File.join(the_base_path, 'Vagrantfile') do
+        content <<EOM
+Dir.glob('#{::File.join(the_base_path, '*.vm')}') do |vm_file|
+  eval(IO.read(vm_file), nil, vm_file)
+end
+EOM
+      end
+    end
+  end
+
+  action :delete do
+    the_base_path = new_resource.path
+    ChefMetal.inline_resource(self) do
+      file ::File.join(the_base_path, 'Vagrantfile') do
+        action :delete
+      end
+      directory the_base_path do
+        action :delete
+      end
+    end
+  end
+
+  def load_current_resource
+  end
+end

data/lib/chef/resource/fog_key_pair.rb

@@ -0,0 +1,34 @@
+require 'chef_metal'
+
+class Chef::Resource::FogKeyPair < Chef::Resource::LWRPBase
+  self.resource_name = 'fog_key_pair'
+
+  def initialize(*args)
+    super
+    @provisioner = ChefMetal.enclosing_provisioner
+  end
+
+  def after_created
+    # Make the credentials usable
+    provisioner.key_pairs[name] = self
+  end
+
+  actions :create, :delete, :nothing
+  default_action :create
+
+  attribute :provisioner
+  # 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
+end

data/lib/chef/resource/machine.rb

@@ -0,0 +1,56 @@
+require 'chef/resource/lwrp_base'
+require 'cheffish'
+require 'chef_metal'
+
+class Chef::Resource::Machine < Chef::Resource::LWRPBase
+  self.resource_name = 'machine'
+
+  def initialize(*args)
+    super
+    @chef_environment = Cheffish.enclosing_environment
+    @chef_server = Cheffish.enclosing_chef_server
+    @provisioner = ChefMetal.enclosing_provisioner
+    @provisioner_options = ChefMetal.enclosing_provisioner_options
+  end
+
+  def after_created
+    # Notify the provisioner of this machine's creation
+    @provisioner.resource_created(self)
+  end
+
+  actions :create, :delete, :stop, :converge, :nothing
+  default_action :create
+
+  # Provisioner attributes
+  attribute :provisioner
+  attribute :provisioner_options
+
+  # Node attributes
+  Cheffish.node_attributes(self)
+
+  # Client keys
+  # Options to generate private key (size, type, etc.) when the server doesn't have it
+  attribute :private_key_options, :kind_of => String
+
+  # Optionally pull the public key out to a file
+  attribute :public_key_path, :kind_of => String
+  attribute :public_key_format, :kind_of => String
+
+  # If you really want to force the private key to be a certain key, pass these
+  attribute :source_key
+  attribute :source_key_path, :kind_of => String
+  attribute :source_key_pass_phrase
+
+  # Client attributes
+  attribute :admin, :kind_of => [TrueClass, FalseClass]
+  attribute :validator, :kind_of => [TrueClass, FalseClass]
+
+  # Allows you to turn convergence off in the :create action by writing "converge false"
+  # or force it with "true"
+  attribute :converge, :kind_of => [TrueClass, FalseClass]
+
+  # chef client version and omnibus
+  # chef-zero boot method?
+  # chef-client -z boot method?
+  # pushy boot method?
+end

data/lib/chef/resource/machine_file.rb

@@ -0,0 +1,25 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal'
+require 'chef_metal/machine'
+require 'chef_metal/provisioner'
+
+class Chef::Resource::MachineFile < Chef::Resource::LWRPBase
+  self.resource_name = 'machine_file'
+
+  def initialize(*args)
+    super
+    @chef_server = Cheffish.enclosing_chef_server
+    @provisioner = ChefMetal.enclosing_provisioner
+  end
+
+  actions :upload, :download, :delete, :nothing
+  default_action :upload
+
+  attribute :path, :kind_of => String, :name_attribute => true
+  attribute :machine, :kind_of => [String, ChefMetal::Machine]
+  attribute :local_path, :kind_of => String
+  attribute :content
+
+  attribute :chef_server, :kind_of => Hash
+  attribute :provisioner, :kind_of => ChefMetal::Provisioner
+end

data/lib/chef/resource/vagrant_box.rb

@@ -0,0 +1,18 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal/provisioner/vagrant_provisioner'
+
+class Chef::Resource::VagrantBox < Chef::Resource::LWRPBase
+  self.resource_name = 'vagrant_box'
+
+  actions :create, :delete, :nothing
+  default_action :create
+
+  attribute :name, :kind_of => String, :name_attribute => true
+  attribute :url, :kind_of => String
+  attribute :provisioner_options, :kind_of => Hash
+
+  def after_created
+    super
+    ChefMetal.with_vagrant_box self
+  end
+end

data/lib/chef/resource/vagrant_cluster.rb

@@ -0,0 +1,16 @@
+require 'chef/resource/lwrp_base'
+require 'chef_metal'
+
+class Chef::Resource::VagrantCluster < Chef::Resource::LWRPBase
+  self.resource_name = 'vagrant_cluster'
+
+  actions :create, :delete, :nothing
+  default_action :create
+
+  attribute :path, :kind_of => String, :name_attribute => true
+
+  def after_created
+    super
+    ChefMetal.with_vagrant_cluster path
+  end
+end

data/lib/chef_metal.rb

@@ -0,0 +1,84 @@
+# Include recipe basics so require 'chef_metal' will load everything
+require 'chef_metal/recipe_dsl'
+require 'chef/resource/machine'
+require 'chef/provider/machine'
+require 'chef/resource/machine_file'
+require 'chef/provider/machine_file'
+require 'chef/resource/vagrant_cluster'
+require 'chef/provider/vagrant_cluster'
+require 'chef/resource/vagrant_box'
+require 'chef/provider/vagrant_box'
+require 'chef/resource/fog_key_pair'
+require 'chef/provider/fog_key_pair'
+require 'chef_metal/provisioner/fog_provisioner'
+
+require 'chef_metal/inline_resource'
+
+module ChefMetal
+  def self.with_provisioner(provisioner)
+    old_provisioner = ChefMetal.enclosing_provisioner
+    ChefMetal.enclosing_provisioner = provisioner
+    if block_given?
+      begin
+        yield
+      ensure
+        ChefMetal.enclosing_provisioner = old_provisioner
+      end
+    end
+  end
+
+  def self.with_provisioner_options(provisioner_options)
+    old_provisioner_options = ChefMetal.enclosing_provisioner_options
+    ChefMetal.enclosing_provisioner_options = provisioner_options
+    if block_given?
+      begin
+        yield
+      ensure
+        ChefMetal.enclosing_provisioner_options = old_provisioner_options
+      end
+    end
+  end
+
+  def self.with_vagrant_cluster(cluster_path, &block)
+    require 'chef_metal/provisioner/vagrant_provisioner'
+
+    with_provisioner(ChefMetal::Provisioner::VagrantProvisioner.new(cluster_path), &block)
+  end
+
+  def self.with_vagrant_box(box_name, provisioner_options = nil, &block)
+    require 'chef/resource/vagrant_box'
+
+    if box_name.is_a?(Chef::Resource::VagrantBox)
+      provisioner_options ||= box_name.provisioner_options || {}
+      provisioner_options['vagrant_options'] ||= {}
+      provisioner_options['vagrant_options']['vm.box'] = box_name.name
+      provisioner_options['vagrant_options']['vm.box_url'] = box_name.url if box_name.url
+    else
+      provisioner_options ||= {}
+      provisioner_options['vagrant_options'] ||= {}
+      provisioner_options['vagrant_options']['vm.box'] = box_name
+    end
+
+    with_provisioner_options(provisioner_options, &block)
+  end
+
+  def self.inline_resource(provider, &block)
+    InlineResource.new(provider).instance_eval(&block)
+  end
+
+  @@enclosing_provisioner = nil
+  def self.enclosing_provisioner
+    @@enclosing_provisioner
+  end
+  def self.enclosing_provisioner=(provisioner)
+    @@enclosing_provisioner = provisioner
+  end
+
+  @@enclosing_provisioner_options = nil
+  def self.enclosing_provisioner_options
+    @@enclosing_provisioner_options
+  end
+  def self.enclosing_provisioner_options=(provisioner_options)
+    @@enclosing_provisioner_options = provisioner_options
+  end
+end

data/lib/chef_metal/aws_credentials.rb

@@ -0,0 +1,55 @@
+module ChefMetal
+  # 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['default'] || @credentials.first[1]
+    end
+
+    def keys
+      @credentials.keys
+    end
+
+    def [](name)
+      @credentials[name]
+    end
+
+    def load_ini(credentials_ini_file)
+      require 'inifile'
+      inifile = IniFile.load(File.expand_path(credentials_ini_file))
+      inifile.each_section do |section|
+        @credentials[section] = {
+          :access_key_id => inifile[section]['aws_access_key_id'],
+          :secret_access_key => inifile[section]['aws_secret_access_key'],
+          :region => inifile[section]['region']
+        }
+      end
+    end
+
+    def load_csv(credentials_csv_file)
+      require 'csv'
+      CSV.new(File.open(credentials_csv_file), :headers => :first_row).each do |row|
+        @credentials[row['User Name']] = {
+          :user_name => row['User Name'],
+          :access_key_id => row['Access Key Id'],
+          :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