poolparty 1.3.15 → 1.4.0

data/lib/poolparty/resource.rb

@@ -1,296 +0,0 @@
-module PoolParty
-  class Resource < Base
-    
-    attr_accessor :exists
-    attr_accessor :meta_notifies, :meta_not_if, :meta_only_if, :meta_subscribes
-    attr_accessor :graph_index
-    
-    default_options(
-      :cloud          => nil,
-      :name           => to_s.top_level_class,
-      :ignore_failure => nil,
-      :provider       => nil
-    )
-    
-    def initialize(opts={}, extra_opts={}, exists=true, &block)
-      @exists ||= exists
-      super(opts, extra_opts, &block)
-      after_loaded_requires_parent
-      valid?
-    end
-    
-    # Dependency resolver methods
-    def compile(compiler)
-      @compiler ||= PoolParty.module_eval("DependencyResolvers::#{compiler.to_s.capitalize}")
-      @compiler.compile(self)
-    end
-    
-    # print_to_chef
-    # When the dependency resolver comes through and resolves
-    # this resource, it will come through and check if it resolves
-    # to chef by checking it it responds to the 
-    #  print_to_chef
-    # method. The contents of the method are considered an ERB
-    # template and will be rendered as an ERB template.
-    def print_to_chef
-      <<-EOE
-# <%= has_method_name %>
-      EOE
-    end
-    
-    # META FUNCTIONS
-    # ALL RESOURCES HAVE THESE METHODS AVAILABLE
-    def notifies(other_resources_hash, action_to_take=:reload)
-      @meta_notifies ||= {}
-      other_resources_hash.each do |k,v|
-        notifies_array = (@meta_notifies[k] ||= [])
-        notifies_array << [v, action_to_take] unless notifies_array.include?([v, action_to_take])
-        # Implicitly add a require
-        # requires(k => v)
-      end
-    end
-    
-    def subscribes(other_resources_hash, action_to_take=:reload, at_time=:delayed)
-      @meta_subscribes ||= {}
-      other_resources_hash.each do |k,v|
-        subscribes_array = (@meta_subscribes[k] ||= [])
-        subscribes_array << [v, action_to_take, at_time] unless subscribes_array.include?([v, action_to_take, at_time])
-      end
-    end
-    
-    # Requires
-    def requires(other_resources_obj)
-      case other_resources_obj
-      when Hash
-        other_resources_obj.each do |k,v|
-          dependencies[k] ||= []
-          dependencies[k] << v unless dependencies[k].include?(v)
-        end
-      when Array
-        other_resources_obj.each do |obj|
-          requires(obj)
-        end
-      else
-        # When is an object
-        # k = other_resources_obj.has_method_name
-        # dependencies[k] ||= []
-        # dependencies[k] << other_resources_obj.name
-      end
-    end
-    
-    # Not if
-    # If a block is given with the not_if, we assume it is
-    # a proc object so we grab the proc source code
-    # on both not_if and only_if code
-    def not_if(code_str=nil, &block)
-      @meta_not_if = block ? [block.code, :block] : [code_str, :string]
-    end
-    
-    # Run only if
-    def only_if(code_str=nil, &block)
-      @meta_only_if = block ? [block.code, :block] : [code_str, :string]
-    end
-        
-    # Should this resource exist on the remote systems
-    # which is a lookup of the instance variable 
-    # on the instance of the resource
-    # The default is that the resource DOES exist
-    def exists(n=nil)
-      @exists
-    end
-    alias :exists? :exists
-    
-    # The resource exists in the output and should be created
-    # on the remote systems.
-    def exists!
-      @exists = true
-    end
-    
-    # The resource should be removed or deleted from the remote
-    # system
-    def does_not_exist!
-      @exists = false
-      false
-    end
-    
-    # CALLBACKS
-    def before_compile
-    end
-    
-    def after_compile
-    end
-    
-    def after_loaded_requires_parent
-      requires parent if parent && !parent.is_a?(PoolParty::Cloud) && !parent.is_a?(PoolParty::Pool)
-    end
-    
-    # Singleton methods
-    # has_name
-    # The has_ and does_not_have methods names
-    # are considered, unless otherwise denoted to be 
-    # the top level class name
-    # for instance
-    #   class Tengo < Resource
-    #   end
-    # the has_ method will be
-    #   has_tengo
-    def self.has_method_name
-      to_s.top_level_class
-    end
-    
-    # has_method_name alias for the singleton method has_method_name
-    # so that there is access to the has_method_name on the instance
-    def has_method_name
-      self.class.has_method_name
-    end
-    
-    # DSL METHODS
-    # Get access to the cloud that contains this resource
-    def cloud
-      get_parent_of_class(PoolParty::Cloud)
-    end
-    # Get access to the pool that contains this resource
-    def pool
-      get_parent_of_class(PoolParty::Pool)
-    end
-    
-    def case_of(var, &block)
-    end
-    
-    # Define the resource methods for all the resources sublcassed by Resource
-    # this creates the methods:
-    #   has_<resource_name>
-    #   does_not_have_<resource_name>
-    #   <resource_name>
-    # on the Base class
-    # The has_ method calls exists! on the resource, then places the resource
-    # in the ordered_resources array
-    def self.define_resource_methods
-      defined_resources.each do |res|
-        next if res.method_defined?
-        ddputs "Defining resource: #{res} as #{res.has_method_name} on #{self}"
-        define_resource(res, is_base_resource_class? ? Base : self)
-        res.method_defined!
-        unless res.defined_resources.empty?
-          res.define_resource_methods
-        end
-      end
-    end
-    
-    def self.is_base_resource_class?
-      self.to_s == PoolParty::Resource.to_s
-    end
-    
-    # Define the resource on the base class so it's available across all
-    # PoolParty classes that use Base
-    def self.define_resource(res, base_klass=Base)
-      base_klass.class_eval <<-EOE
-        def has_#{res.has_method_name}(a={},b={},e=true, &block)
-          obj = #{res}.new(a,b,e,&block)
-          resources << obj
-          obj
-        end
-        def does_not_have_#{res.has_method_name}(a={},b={},e=false,&block)
-          obj = has_#{res.has_method_name}(a,b,e,&block)
-          obj
-        end
-        def #{res.has_method_name}s
-          all_resources.select {|q| q if q.class.to_s =~ /#{res.to_s.classify}/ }
-        end
-        alias :#{res.has_method_name} :has_#{res.has_method_name}
-        
-        def get_#{res.has_method_name}(nm)
-          {:#{res.has_method_name} => nm}
-        end
-      EOE
-    end
-    
-    # When a new resource is created, the class gets stored as a defined resource
-    # in the defined_resources resources class variable
-    def self.inherited(subclass)
-      defined_resources << subclass
-    end
-    
-    # Note that this resource has been defined already
-    def self.method_defined!
-      @defined = true
-    end
-    
-    # Query if this resource has been defined yet
-    def self.method_defined?
-      defined
-    end
-    
-    def self.defined
-      @defined ||= false
-    end
-    
-    # Storage of defined resources that are stored when
-    # the subclass'd resource is subclassed
-    def self.defined_resources
-      @defined_resources ||= []
-    end
-    
-    # HELPERS FOR RESOURCES
-    # Print objects
-    # This helper takes an object and prints them out with as expected
-    # Case of:
-    #   Number:
-    #     Integer of the format \d\d\d      => 0644
-    #     Else                              => 79
-    #   String
-    #     String of the format \d\d\d\d     => 0655
-    #     String of the format \d\d\d       => 0644
-    #     Else                              => "String"
-    #   Proc object
-    #     Calls the proc object
-    #   Array
-    #     All                               => [ "a", "b" ]
-    #   Symbol
-    #     All                               => :a
-    #   Hash
-    #     All                               => :a => "a", :b => ["b"]
-    #   Object
-    #     All                               => object
-    def print_variable(obj)
-      case obj
-      when Fixnum
-        case obj
-        when /^\d{3}$/
-          "0#{obj.to_i}"
-        else
-          "#{obj.to_i}"
-        end        
-      when String
-        "\"#{obj}\""
-      when Proc
-        obj.call # eh
-      when Array
-        "[ #{obj.map {|e| print_variable(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
-      when nil
-        nil
-      when Symbol
-        ":#{obj}"
-      when Hash
-        "#{obj.map {|k,v| ":#{k} => #{print_variable(v)}" unless v == obj }.compact.join(",\n")}"
-      else
-        "#{obj}"
-      end
-    end
-    
-    
-    private
-    # Get parent of class
-    def get_parent_of_class(klass)
-      if parent.is_a? klass
-        parent
-      elsif parent && !parent.is_a?(PoolParty::Pool)
-        parent.cloud
-      else
-        nil
-      end      
-    end
-  end
-end
-
-Dir["#{File.dirname(__FILE__)}/resources/*.rb"].each {|lib| require lib }

data/lib/poolparty/resources/conditional.rb

@@ -1,65 +0,0 @@
-=begin rdoc
-  Gives access to conditional statements
-  
-  == Usage
-    has_case "os" do
-      when_is :ubuntu, "git-core"
-      else_is "git"
-    end
-  
-  translates to:
-  
-    case "os"
-    when :ubuntu
-      "git-core"
-    else
-      "git"
-    end
-=end
-module PoolParty
-  module Resources
-    
-    class Conditional < Resource
-      
-      default_options(
-        :name => nil
-      )
-      
-      def self.has_method_name
-        "case"
-      end
-      
-      # When is
-      def when_is(val, output)
-        conditions << [val, output]
-      end
-      
-      def else_is(output)
-        conditions.push([:else, output])
-      end
-      
-      def conditions
-        @conditions ||= []
-      end
-      
-      def print_to_chef
-        arr = []
-        arr << "case #{print_variable(name)}"
-        conditions.each do |cond|
-          if cond[0] == :else
-            arr << "else"
-            arr << "  #{print_variable(cond[1])}"
-            break
-          else
-            arr << "when #{print_variable(cond[0])}"
-            arr << "  #{print_variable(cond[1])}"
-          end
-        end
-        arr << "end"
-        arr.join("\n")
-      end
-      
-    end
-    
-  end
-end

data/lib/poolparty/resources/cron.rb

@@ -1,64 +0,0 @@
-=begin rdoc
-== Cron
- 
-The cron resource will set cron jobs at the intervals you set
- 
-== Usage
- 
-  has_cron(:name => '...') do
-    # More options.
-    # This block is optional
-  end
- 
-== Options
- 
-* <tt>name</tt> The name of the cronjob
-* <tt>user</tt> The users who owns the cronjob  
-* <tt>command</tt> The cronjob command to run
-* <tt>minute</tt> Set the minute of the cronjob
-* <tt>hour</tt> Set the hour of the cronjob
-* <tt>month</tt> Set the month of the cronjob
-* <tt>monthday</tt> Set the day of the month of the cronjob
-* <tt>weekday</tt> Set the weekday of the cronjob, in 0-6 format, where 0 is Sunday
- 
-== Example
- 
-  has_cron(:name => "report mailer", :minute => "5", :hour => "0", :weekday => 1) do
-    command "/bin/sh /home/user/email_reports.sh"
-  end
- 
-=end
-module PoolParty
-  module Resources
-    
-    class Cron < Resource
-      
-      default_options(
-        :minute   => "*",
-        :hour     => "*",
-        :day      => "*",
-        :month    => "*",
-        :weekday  => "*",
-        :user     => "root",
-        :command  => nil
-      )
-      
-      def print_to_chef
-        <<-EOE
-cron "<%= name || command %>" do
-  command "<%= command || name %>"
-  action :<%= exists? ? :create : :delete %>
-  minute <%= print_variable(minute) %>
-  hour <%= print_variable(hour) %>
-  day <%= print_variable(day) %>
-  month <%= print_variable(month) %>
-  weekday <%= print_variable(weekday) %>
-  user <%= print_variable(user) %>
-end
-        EOE
-      end
-      
-    end
-    
-  end
-end

data/lib/poolparty/resources/directory.rb

@@ -1,54 +0,0 @@
-=begin rdoc rdoc
-== Directory
- 
-The directory resource is used to describe a directory that should be present
-on all of the instances.
- 
-== Usage
- 
-  has_directory 'name', :from => '/local/path', :to => '/path/on/server/'
-  
-The above example will place the contents of '/local/path' at '/path/on/server/name'
- 
-  has_directory(:name => '/etc/apache2')
- 
-== Options
- 
-* <tt>name</tt> Describe the location of the file with the name
-* <tt>mode</tt> Describe the mode of the file (default: 644)
-* <tt>owner</tt> The owner of the file (default: poolparty user)
- 
-=end
-module PoolParty
-  module Resources
-    
-    class Directory < Resource
-      
-      default_options(
-        :recursive  => true,
-        :mode       => "0644",
-        :owner      => "root",
-        :group      => "root",
-        :recursive  => true
-      )
-
-      def after_loaded
-        requires get_user(owner) if owner && owner != "root"
-      end
-      
-      def print_to_chef
-        <<-EOE
-directory "<%= name %>" do
-  action :<%= exists ? :create : :delete %>
-  recursive <%= print_variable(recursive) %>
-  mode <%= print_variable(mode) %>
-  owner <%= print_variable(owner) %>
-  group <%= print_variable(group) %>
-end
-        EOE
-      end
-      
-    end
-    
-  end
-end

data/lib/poolparty/resources/exec.rb

@@ -1,61 +0,0 @@
-=begin rdoc rdoc
-== Exec
- 
-Ensure a command is run on the instances
- 
-== Usage
- 
-  has_exec(:name => '...') do
-    # More options. 
-    # This block is optional
-  end
- 
-== Options
- 
-* <tt>name</tt> The name of your exec. This is optional, but nice for debugging purposes
-* <tt>cwd</tt> Current working directory to execute the command (optional)
-* <tt>command</tt> This describes the command to run
-* <tt>path</tt> The path to run the command with (optional)
- 
-== Examples
-  has_exec 'ps aux | grep erl | mail -s "running commands" root@root.com' do
-    onlyif => 'ps aux | grep beam'
-  end
-=end
-module PoolParty
-  module Resources
-    
-    class Exec < Resource
-      
-      default_options(
-        :path         => ["/usr/bin:/bin:/usr/local/bin:$PATH"],
-        :command      => nil,
-        :creates      => nil,
-        :cwd          => nil,
-        :environment  => nil,
-        :group        => nil,
-        :returns      => nil,
-        :user         => nil,
-        :action       => :run
-      )
-      
-      def print_to_chef
-str = 'execute "<%= name %>" do
-  command <%= print_variable(command || name) %>
-  path <%= print_variable(path) %>
-  action <%= print_variable(action ? action : (exists ? :run : :nothing)) %>
-'
-      str << "  creates <%= print_variable(creates) %>\n" if creates
-      str << "  cwd <%= print_variable(cwd) %>\n" if cwd
-      str << "  environment <%= print_variable(environment) %>\n" if environment
-      str << "  group <%= print_variable(group) %>\n" if group
-      str << "  returns <%= print_variable(returns) %>\n" if returns
-      str << "  user <%= print_variable(user) %>\n" if user
-      
-      str << "end"
-      end
-      
-    end
-    
-  end
-end

data/lib/poolparty/resources/file.rb

@@ -1,87 +0,0 @@
-=begin rdoc rdoc
-== File
-
-The file resource is used to describe a file that should be present on all of the instances.
-
-== Usage
-
-  has_file(:name => '...') do
-    # More options. 
-    # This block is optional
-  end
-
-== Options
-
-* <tt>name</tt> Describe the location of the file with the name
-* <tt>mode</tt> Describe the mode of the file (default: 644)
-* <tt>owner</tt> The owner of the file (default: poolparty user)
-* <tt>content</tt> The contents of the file
-* <tt>source</tt> Used to describe a file that is hosted on the master instance.
-* <tt>template</tt> The file contents are described with the template. The location given must be readable
-  
-To write a file to the template directory, use:
-
-  copy_template_to_storage_directory(filepath)
-
-== Example
-  has_file(:name => '/etc/motd', :content => 'Hey and welcome to your node today!')
-=end
-module PoolParty
-  module Resources
-    
-    class FileResource < Resource
-      has_searchable_paths
-      
-      default_options(
-        :content  => "# File generated by PoolParty",
-        :mode     => "0644",
-        :backup   => 5,
-        :owner    => "root"
-      )
-
-      def after_loaded
-        requires get_user(owner) if owner && owner != "root"
-      end
-            
-      def self.has_method_name
-        "file"
-      end
-      
-      def print_to_chef
-        <<-EOE
-template "<%= name %>" do
-  source "<%= name %>.erb"
-  action :<%= exists? ? :create : :delete %>
-  backup <%= backup %>
-  mode <%= print_variable(mode) %>
-  owner <%= print_variable(owner) %>
-end
-        EOE
-      end
-      
-      def template(*arg)
-        if arg.empty?
-          @template
-        else
-          file = arg.first
-          @template = if File.file?(b = File.expand_path(file))
-            b
-          elsif File.file?(d = File.expand_path(File.join(clouds_dot_rb_dir, file)))
-            d
-          elsif f = search_in_known_locations(file)
-            f
-          else
-            raise PoolParty::PoolPartyError.create("TemplateNotFound", "The template #{file} could not be found when creating the file #{name}. Please check that it exists")
-          end
-        end
-      end
-      
-      # A convenience helper to point to the path of the file
-      def path
-        name
-      end
-      
-    end
-    
-  end
-end

data/lib/poolparty/resources/gem_package.rb

@@ -1,55 +0,0 @@
-=begin rdoc
-== Gempackage
-
-# Allows you to specify a gem to be installed
-# You can optionally pass a :download_url if you want a specific gem or version installed
-
-== Usage
-
-  has_gempackage(:name => '...') do
-    # More options. 
-    # This block is optional
-  end
-
-== Options
-
-* <tt>name</tt> The gem name
-* <tt>download_url</tt> The location of the gem to download and server across the instances
-* <tt>version</tt> The gem version requirement (optional and useless if download_url is given)
-* <tt>source</tt> The gem source (optional and useless matter if download_url is given)
-* <tt>bin</tt> Specify exact gem binary
-* <tt>jruby</tt> Will set 'bin' to 'jruby -S gem'
-
-== Example
-  has_gempackage(:name => 'rake', 
-    :download_url => 'http://rubyforge.org/frs/download.php/43954/rake-0.8.3.gem')
-=end
-module PoolParty
-  module Resources
-    
-    class GemPackage < Resource
-      
-      default_options(
-        :action         => :install,
-        :version        => nil,
-        :response_file  => nil,
-        :source         => nil,
-        :options        => nil
-      )
-      
-      def print_to_chef
-        str = <<-EOE
-gem_package "<%= name %>" do
-  action <%= print_variable(action ? action : (exists ? :install : :remove)) %>
-EOE
-        str << "  options <%= print_variable(options) %>\n" if options
-        str << "  version <%= print_variable(version) %>\n" if version
-        str << "  source <%= print_variable(source) %>\n" if source
-        str << "  response_file <%= print_variable(response_file) %>\n" if response_file
-        str << "end"
-      end
-      
-    end
-    
-  end
-end