chef-workflow 0.1.1 → 0.2.0

data/lib/chef-workflow/support/general.rb

@@ -1,63 +1,55 @@
 require 'chef-workflow/support/generic'
 require 'chef-workflow/support/attr'
-require 'chef-workflow/support/vm/ec2'
-require 'chef-workflow/support/vm/vagrant'
-
-#
-# General configuration, typically global to all chef-workflow related things.
-# See `GenericSupport` for a rundown of usage.
-#
-class GeneralSupport
-  # Standard chef-workflow dir.
-  DEFAULT_CHEF_WORKFLOW_DIR   = File.join(Dir.pwd, '.chef-workflow')
-  # Location of the VM database.
-  DEFAULT_CHEF_VM_FILE        = File.join(DEFAULT_CHEF_WORKFLOW_DIR, 'vms')
-  # Location of the chef-server prison file (vagrant only).
-  DEFAULT_CHEF_SERVER_PRISON  = File.join(DEFAULT_CHEF_WORKFLOW_DIR, 'chef-server')
-
-  extend AttrSupport 
-
-  ##
-  # :attr:
-  # 
-  # configure the workflow directory
-  fancy_attr :workflow_dir
-
-  ##
-  # :attr:
-  #
-  # configure the location of the vm file
-  fancy_attr :vm_file
 
-  ##
-  # :attr:
+module ChefWorkflow
   #
-  # configure the location of the chef server prison.
-  fancy_attr :chef_server_prison
-
-  def initialize(opts={})
-    @workflow_dir       = opts[:workflow_dir]       || DEFAULT_CHEF_WORKFLOW_DIR 
-    @vm_file            = opts[:vm_file]            || DEFAULT_CHEF_VM_FILE
-    @chef_server_prison = opts[:chef_server_prison] || DEFAULT_CHEF_SERVER_PRISON
-    machine_provisioner :vagrant
-  end
-
-  def machine_provisioner(*args)
-    if args.count > 0
-      @machine_provisioner = case args.first
-                             when :ec2
-                               VM::EC2Provisioner
-                             when :vagrant
-                               VM::VagrantProvisioner
-                             else
-                               args.first
-                             end
+  # General configuration, typically global to all chef-workflow related things.
+  # See `GenericSupport` for a rundown of usage.
+  #
+  class GeneralSupport
+    extend ChefWorkflow::AttrSupport 
+    include ChefWorkflow::GenericSupport
+
+    # Standard chef-workflow dir.
+    DEFAULT_CHEF_WORKFLOW_DIR   = File.join(Dir.pwd, '.chef-workflow')
+    # Location of the VM database.
+    DEFAULT_CHEF_VM_FILE        = File.join(DEFAULT_CHEF_WORKFLOW_DIR, 'state.db')
+
+    ##
+    # :attr:
+    # 
+    # configure the workflow directory
+    fancy_attr :workflow_dir
+
+    ##
+    # :attr:
+    #
+    # configure the location of the vm file
+    fancy_attr :vm_file
+
+    def initialize(opts={})
+      @workflow_dir       = opts[:workflow_dir] || DEFAULT_CHEF_WORKFLOW_DIR 
+      @vm_file            = opts[:vm_file]      || DEFAULT_CHEF_VM_FILE
+      machine_provisioner :vagrant
     end
 
-    @machine_provisioner
+    def machine_provisioner(*args)
+      if args.count > 0
+        @machine_provisioner = case args.first
+                               when :ec2
+                                 require 'chef-workflow/support/vm/ec2'
+                                 ChefWorkflow::VM::EC2Provisioner
+                               when :vagrant
+                                 require 'chef-workflow/support/vm/vagrant'
+                                 ChefWorkflow::VM::VagrantProvisioner
+                               else
+                                 args.first
+                               end
+      end
+
+      @machine_provisioner
+    end
   end
-
-  include GenericSupport
 end
 
-GeneralSupport.configure
+ChefWorkflow::GeneralSupport.configure

data/lib/chef-workflow/support/generic.rb

@@ -1,30 +1,34 @@
-#
-# mixin for supplying a consistent interface to singleton configuration classes.
-#
+require 'singleton'
+require 'deprecated'
 
-module GenericSupport
-  #-- 
-  # it's cool; this isn't absolutely evil or anything.
-  #++
-  def self.included(klass)
-    class << klass
-      # The singleton object that is supplying the current configuration.
-      # Always reference this when working with classes that use this
-      # interface.
-      attr_reader :singleton
+module ChefWorkflow
+  #
+  # mixin for supplying a consistent interface to singleton configuration classes.
+  #
 
-      # circular references, oh my
-      attr_accessor :supported_class
+  module GenericSupport
+    def self.included(klass)
+      klass.instance_eval do
+        include Singleton
 
-      #
-      # Configure the singleton. Instance evals a block that you can set stuff on.
-      #
-      def configure(&block)
-        @singleton ||= self.supported_class.new
-        @singleton.instance_eval(&block) if block
+        def self.configure(&block)
+          instance.instance_eval(&block) if block
+        end
+
+        def self.method_missing(sym, *args)
+          instance.send(sym, *args)
+        end
+
+        def self.singleton
+          instance
+        end
+
+        class << self
+          include Deprecated
+        end
+
+        self.singleton_class.deprecated :singleton, "#{klass.name} class methods"
       end
     end
-
-    klass.supported_class = klass
   end
 end

data/lib/chef-workflow/support/ip.rb

@@ -1,129 +1,115 @@
-require 'delegate'
 require 'fileutils'
-require 'chef-workflow/support/generic'
 require 'chef-workflow/support/attr'
+require 'chef-workflow/support/db'
+require 'chef-workflow/support/generic'
 
 ENV["TEST_CHEF_SUBNET"] ||= "10.10.10.0"
 
-#
-# IP allocation database. Uses `GenericSupport`.
-#
-class IPSupport < DelegateClass(Hash)
-  extend AttrSupport
-
-  ##
-  # :attr:
-  #
-  # The subnet used for calculating assignable IP addresses. You really want to
-  # set `TEST_CHEF_SUBNET` in your environment instead of changing this.
-  #
-  fancy_attr :subnet
-
-  ##
-  # :attr:
+module ChefWorkflow
   #
-  # The location of the ip database.
+  # IP allocation database. Uses `GenericSupport`.
   #
-  fancy_attr :ip_file
+  class IPSupport
+    extend ChefWorkflow::AttrSupport
+    include ChefWorkflow::GenericSupport
 
-  def initialize(subnet=ENV["TEST_CHEF_SUBNET"], ip_file=File.join(Dir.pwd, '.chef-workflow', 'ips'))
-    @subnet = subnet
-    reset
-    @ip_file = ip_file
-    super(@ip_assignment)
-  end
+    ##
+    # :attr:
+    #
+    # The subnet used for calculating assignable IP addresses. You really want to
+    # set `TEST_CHEF_SUBNET` in your environment instead of changing this.
+    #
+    fancy_attr :subnet
 
-  #
-  # Resets (clears) the IP database.
-  #
-  def reset
-    @ip_assignment = { }
-  end
+    def initialize(subnet=ENV["TEST_CHEF_SUBNET"])
+      @subnet = subnet
+      @db = ChefWorkflow::DatabaseSupport.instance
+      create_table
+    end
 
-  #
-  # Loads the IP database from disk. Location is based on the `ip_file` accessor.
-  #
-  def load
-    if File.exist?(ip_file)
-      @ip_assignment = Marshal.load(File.binread(ip_file))
+    def create_table
+      @db.execute <<-EOF
+      create table if not exists ips (
+        id integer not null primary key autoincrement,
+        role_name varchar(255) not null,
+        ip_addr varchar(255) not null,
+        UNIQUE(role_name, ip_addr)
+      )
+      EOF
     end
-  end
 
-  #
-  # Saves the IP database to disk. Location is based on the `ip_file` accessor.
-  #
-  def write
-    FileUtils.mkdir_p(File.dirname(ip_file))
-    File.binwrite(ip_file, Marshal.dump(@ip_assignment))
-  end
+    #
+    # Gets the next unallocated IP, given an IP to start with.
+    #
+    def next_ip(arg)
+      octets = arg.split(/\./, 4).map(&:to_i)
+      octets[3] += 1
+      raise "out of ips!" if octets[3] > 255
+      return octets.map(&:to_s).join(".")
+    end
 
-  #
-  # Gets the next unallocated IP, given an IP to start with.
-  #
-  def next_ip(arg)
-    octets = arg.split(/\./, 4).map(&:to_i)
-    octets[3] += 1
-    raise "out of ips!" if octets[3] > 255
-    return octets.map(&:to_s).join(".")
-  end
+    #
+    # Gets the next un-used IP. This basically calls `next_ip` with knowledge of
+    # the database.
+    #
+    def unused_ip
+      ip = next_ip(@subnet)
 
-  #
-  # Gets the next un-used IP. This basically calls `next_ip` with knowledge of
-  # the database.
-  #
-  def unused_ip
-    ip = next_ip(@subnet)
+      while ip_used?(ip)
+        ip = next_ip(ip)
+      end
 
-    while ip_used?(ip)
-      ip = next_ip(ip)
+      return ip
     end
 
-    return ip
-  end
+    #
+    # Predicate to determine if an IP is in use.
+    #
+    def ip_used?(ip)
+      @db.execute("select count(*) from ips where ip_addr=?", [ip]).first.first > 0 rescue nil
+    end
 
-  #
-  # Predicate to determine if an IP is in use.
-  #
-  def ip_used?(ip)
-    @ip_assignment.values.flatten.include?(ip)
-  end
+    #
+    # Appends an IP to a role.
+    #
+    def assign_role_ip(role, ip)
+      @db.execute("insert into ips (role_name, ip_addr) values (?, ?)", [role, ip])
+    end
 
-  #
-  # Appends an IP to a role.
-  #
-  def assign_role_ip(role, ip)
-    @ip_assignment[role] ||= []
-    @ip_assignment[role].push(ip)
-  end
+    #
+    # Removes the role and all associated IPs.
+    #
+    def delete_role(role)
+      @db.execute("delete from ips where role_name=?", [role])
+    end
 
-  #
-  # Removes the role and all associated IPs.
-  #
-  def delete_role(role)
-    @ip_assignment.delete(role)
-  end
+    #
+    # Get all the known roles
+    #
+    def roles
+      @db.execute("select distinct role_name from ips").map(&:first);
+    end
 
-  #
-  # Gets all the IPs for a role, as an array of strings.
-  #
-  def get_role_ips(role)
-    @ip_assignment[role] || []
-  end
+    #
+    # Gets all the IPs for a role, as an array of strings.
+    #
+    def get_role_ips(role)
+      @db.execute("select ip_addr from ips where role_name=? order by id", [role]).map(&:first)
+    end
 
-  #
-  # Helper method for vagrant. Vagrant always occupies .1 of any subnet it
-  # configures host-only networking on. This takes care of doing that.
-  #
-  def seed_vagrant_ips
-    # vagrant requires that .1 be used by vagrant. ugh.
-    dot_one_ip = @subnet.gsub(/\.\d+$/, '.1')
-    unless ip_used?(dot_one_ip)
-      assign_role_ip("vagrant-reserved", dot_one_ip)
+    #
+    # Helper method for vagrant. Vagrant always occupies .1 of any subnet it
+    # configures host-only networking on. This takes care of doing that.
+    #
+    def seed_vagrant_ips
+      # vagrant requires that .1 be used by vagrant. ugh.
+      dot_one_ip = @subnet.gsub(/\.\d+$/, '.1')
+      unless ip_used?(dot_one_ip)
+        assign_role_ip("vagrant-reserved", dot_one_ip)
+      end
     end
-  end
 
-  include GenericSupport
+  end
 end
 
-IPSupport.configure
-IPSupport.singleton.load
+ChefWorkflow::IPSupport.configure

data/lib/chef-workflow/support/knife-plugin.rb

@@ -2,32 +2,34 @@ require 'chef/application/knife'
 require 'chef/knife'
 require 'stringio'
 
-#
-# Mixin to add methods to assist with creating knife plugins.
-#
-module KnifePluginSupport
-
-  #
-  # Given a class name for a plugin compatible with the Chef::Knife interface,
-  # initializes it and makes it available for execution. It also overrides the
-  # `ui` object to use `StringIO` objects, which allow you to choose when and
-  # if you display the output of the commands by referencing
-  # `obj.ui.stdout.string` and similar calls.
+module ChefWorkflow
   #
-  # The second argument is an array of arguments to the command, such as they
-  # would be presented to a command line tool as `ARGV`.
+  # Mixin to add methods to assist with creating knife plugins.
   #
-  def init_knife_plugin(klass, args)
-    klass.options = Chef::Application::Knife.options.merge(klass.options)
-    klass.load_deps
-    cli = klass.new(args)
-    cli.ui = Chef::Knife::UI.new(
-      StringIO.new('', 'w'), 
-      StringIO.new('', 'w'),
-      StringIO.new('', 'r'),
-      cli.config
-    )
+  module KnifePluginSupport
+
+    #
+    # Given a class name for a plugin compatible with the Chef::Knife interface,
+    # initializes it and makes it available for execution. It also overrides the
+    # `ui` object to use `StringIO` objects, which allow you to choose when and
+    # if you display the output of the commands by referencing
+    # `obj.ui.stdout.string` and similar calls.
+    #
+    # The second argument is an array of arguments to the command, such as they
+    # would be presented to a command line tool as `ARGV`.
+    #
+    def init_knife_plugin(klass, args)
+      klass.options = Chef::Application::Knife.options.merge(klass.options)
+      klass.load_deps
+      cli = klass.new(args)
+      cli.ui = Chef::Knife::UI.new(
+        StringIO.new('', 'w'),
+        StringIO.new('', 'w'),
+        StringIO.new('', 'r'),
+        cli.config
+      )
 
-    return cli
+      return cli
+    end
   end
 end

data/lib/chef-workflow/support/knife.rb

@@ -3,120 +3,94 @@ require 'erb'
 require 'chef-workflow/support/generic'
 require 'chef-workflow/support/general'
 require 'chef-workflow/support/debug'
+require 'chef-workflow/support/attr'
 
-#
-# Configuration class for chef tooling and SSH interaction. Uses `GenericSupport`.
-#
-class KnifeSupport
-  include GenericSupport
-  include DebugSupport
-
-  # defaults, yo
-  DEFAULTS = {
-    :search_index_wait      => 60,
-    :cookbooks_path         => File.join(Dir.pwd, 'cookbooks'),
-    :chef_config_path       => File.join(GeneralSupport.singleton.workflow_dir, 'chef'),
-    :knife_config_path      => File.join(GeneralSupport.singleton.workflow_dir, 'chef', 'knife.rb'),
-    :roles_path             => File.join(Dir.pwd, 'roles'),
-    :environments_path      => File.join(Dir.pwd, 'environments'),
-    :data_bags_path         => File.join(Dir.pwd, 'data_bags'),
-    :ssh_user               => "vagrant",
-    :ssh_password           => "vagrant",
-    :ssh_identity_file      => nil,
-    :use_sudo               => true,
-    :test_environment       => "vagrant",
-    :test_recipes           => []
-  }
-
-  DEFAULTS[:knife_config_template] = <<-EOF
-  log_level                :info
-  log_location             STDOUT
-  node_name                'test-user'
-  client_key               File.join('<%= KnifeSupport.singleton.chef_config_path %>', 'admin.pem')
-  validation_client_name   'chef-validator'
-  validation_key           File.join('<%= KnifeSupport.singleton.chef_config_path %>', 'validation.pem')
-  chef_server_url          'http://<%= IPSupport.singleton.get_role_ips("chef-server").first %>:4000'
-  environment              '<%= KnifeSupport.singleton.test_environment %>'
-  cache_type               'BasicFile'
-  cache_options( :path => File.join('<%= KnifeSupport.singleton.chef_config_path %>', 'checksums' ))
-  cookbook_path            [ '<%= KnifeSupport.singleton.cookbooks_path %>' ]
-  EOF
-
+module ChefWorkflow
   #
-  # Helper method to allow extensions to add attributes to this class. Could
-  # probably be replaced by `AttrSupport`. Takes an attribute name and a
-  # default which will be set initially, intended to be overridden by the user
-  # if necessary.
+  # Configuration class for chef tooling and SSH interaction. Uses `GenericSupport`.
   #
-  def self.add_attribute(attr_name, default)
-    KnifeSupport.configure
+  class KnifeSupport
+    include ChefWorkflow::DebugSupport
+    extend ChefWorkflow::AttrSupport
+    include ChefWorkflow::GenericSupport
 
-    DEFAULTS[attr_name] = default # a little inelegant, but it works.
+    # defaults, yo
+    DEFAULTS = {
+      :search_index_wait      => 60,
+      :cookbooks_path         => File.join(Dir.pwd, 'cookbooks'),
+      :chef_config_path       => File.join(ChefWorkflow::GeneralSupport.workflow_dir, 'chef'),
+      :knife_config_path      => File.join(ChefWorkflow::GeneralSupport.workflow_dir, 'chef', 'knife.rb'),
+      :roles_path             => File.join(Dir.pwd, 'roles'),
+      :environments_path      => File.join(Dir.pwd, 'environments'),
+      :data_bags_path         => File.join(Dir.pwd, 'data_bags'),
+      :ssh_user               => "vagrant",
+      :ssh_password           => "vagrant",
+      :ssh_identity_file      => nil,
+      :use_sudo               => true,
+      :test_environment       => "vagrant",
+      :test_recipes           => []
+    }
 
-    # HACK: no good way to hook this right now, revisit later.
-    str = ""
-    if attr_name.to_s == "knife_config_path"
-      str = <<-EOF
-        def #{attr_name}=(arg)
-          @#{attr_name} = arg
-          ENV["CHEF_CONFIG"] = arg
-        end
+    DEFAULTS[:knife_config_template] = <<-EOF
+    log_level                :info
+    log_location             STDOUT
+    node_name                'test-user'
+    client_key               File.join('<%= KnifeSupport.chef_config_path %>', 'admin.pem')
+    validation_client_name   'chef-validator'
+    validation_key           File.join('<%= KnifeSupport.chef_config_path %>', 'validation.pem')
+    chef_server_url          'http://<%= IPSupport.get_role_ips("chef-server").first %>:4000'
+    environment              '<%= KnifeSupport.test_environment %>'
+    cache_type               'BasicFile'
+    cache_options( :path => File.join('<%= KnifeSupport.chef_config_path %>', 'checksums' ))
+    cookbook_path            [ '<%= KnifeSupport.cookbooks_path %>' ]
+    EOF
 
-        def #{attr_name}(arg=nil)
-          if arg
-            @#{attr_name} = arg
-            ENV["CHEF_CONFIG"] = arg
-          end
-          
-          @#{attr_name}
-        end
-      EOF
-    else
-      str = <<-EOF
-        def #{attr_name}=(arg)
-          @#{attr_name} = arg
-        end
+    attr_reader :attributes
 
-        def #{attr_name}(arg=nil)
-          if arg
-            @#{attr_name} = arg
-          end
-          
-          @#{attr_name}
-        end
-      EOF
+    def initialize
+      @attributes = { }
+
+      DEFAULTS.each do |key, value|
+        add_attribute(key, value)
+      end
+    end
+      
+    #
+    # Helper method to allow extensions to add attributes to this class.
+    # Takes an attribute name and a default which will be set initially,
+    # intended to be overridden by the user if necessary.
+    #
+    #--
+    # FIXME Move all the user-configurable stuff to its own support system
+    #++
+    def add_attribute(attr_name, default)
+      @attributes[attr_name] = default
     end
 
-    KnifeSupport.singleton.instance_eval str
-    KnifeSupport.singleton.send(attr_name, default)
-  end
-  
-  DEFAULTS.each { |key, value| add_attribute(key, value) }
+    def method_missing(sym, *args)
+      attr_name = sym.to_s.sub(/=$/, '').to_sym
+      assignment = sym.to_s.end_with?("=")
 
-  def initialize(options={})
-    DEFAULTS.each do |key, value|
-      instance_variable_set(
-        "@#{key}", 
-        options.has_key?(key) ? options[key] : DEFAULTS[key]
-      )
+      if @attributes.has_key?(attr_name)
+        if assignment or args.count > 0
+          @attributes[attr_name] = args[0]
+        else
+          @attributes[attr_name]
+        end
+      else
+        raise "Attribute #{attr_name} does not exist"
+      end
     end
-  end
 
-  def method_missing(sym, *args)
-    if_debug(2) do
-      $stderr.puts "#{self.class.name}'s #{sym} method was referenced while trying to configure #{self.class.name}"
-      $stderr.puts "#{self.class.name} has not been configured to support this feature."
-      $stderr.puts "This is probably due to it being dynamically added from a rake task, and you're running the test suite."
-      $stderr.puts "It's probably harmless. Expect a better solution than this debug message soon."
+    #
+    # Writes out a knife.rb based on the settings in this configuration. Uses the
+    # `knife_config_path` and `chef_config_path` to determine where to write it.
+    #
+    def build_knife_config
+      FileUtils.mkdir_p(chef_config_path)
+      File.binwrite(knife_config_path, ERB.new(knife_config_template).result(binding))
     end
   end
-
-  #
-  # Writes out a knife.rb based on the settings in this configuration. Uses the
-  # `knife_config_path` and `chef_config_path` to determine where to write it.
-  #
-  def build_knife_config
-    FileUtils.mkdir_p(chef_config_path)
-    File.binwrite(knife_config_path, ERB.new(knife_config_template).result(binding))
-  end
 end
+
+ChefWorkflow::KnifeSupport.configure