auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/pool.rb

@@ -0,0 +1,154 @@
+module PoolParty
+    
+  class Pool < DslBase
+    
+    # Freeze the pool_name so we can't modify it at all
+    # call and run instance_eval on the block and then call the after_create callback
+    def initialize(n, &block)
+      PoolParty::Pool.init
+      
+      context_stack.clear
+      
+      @pool_name = n.to_s
+      @pool_name.freeze
+      
+      super do
+        instance_eval &block
+        form_clouds
+        clouds.each do |name, cld|
+          cld.after_all_loaded
+        end
+        
+      end
+    end
+    
+    # cloud
+    # Define a cloud by a name and a block
+    def cloud(name, o={}, &block)
+      if block
+        clouds[name.to_s] ||= PoolParty::Cloud.new(name, o, &block)
+      else
+        raise PoolPartyError.new("CloudError", "You must pass a block when defining a cloud")
+      end
+    end
+    
+    # Run twice to catch the errors on the first run
+    # TODO: CHANGE ME!
+    def form_clouds
+      failed_clouds = []
+      clouds.each do |name, cld|
+        begin
+          clouds[name].form_clouds
+        rescue Exception => e
+          failed_clouds << [name, cld]
+          next
+        end
+      end
+      failed_clouds.each do |name, cld|
+        clouds[name].form_clouds
+      end
+    end
+    
+    # Singleton methods
+    
+    # Load a clouds.rb
+    # Call the prerequisites (before_file_load)
+    # and then instance_eval the contents
+    # finally, call after_file_load callback after the
+    # clouds.rb is loaded
+    # Arguments:
+    #   + file on the filesystem
+    #   + open-uri url (http)
+    def self.load_from_file(filename=nil)
+      raise PoolPartyError.create("CloudsDotRbLoadError", "Cannot load the specified clouds.rb: #{filename}. Check to make sure it exists") unless filename && File.file?(filename)
+      ddputs "Loading #{filename} from file in Pool"
+      @clouds_dot_rb_file = filename
+      before_file_load(clouds_dot_rb_file)
+      o = instance_eval open(clouds_dot_rb_file).read, clouds_dot_rb_file
+      after_file_load(clouds_dot_rb_file)
+      o
+    end
+    
+    # Store the clouds_dot_rb_file location
+    def self.clouds_dot_rb_file(n=nil)
+      if n
+        @clouds_dot_rb_file = n
+      else
+        @clouds_dot_rb_file
+      end
+    end
+    
+    def self.clouds_dot_rb_dir
+      File.dirname(self.clouds_dot_rb_file) if self.clouds_dot_rb_file
+    end
+    
+    # Load the default clouds.rb file
+    # If a full filepath is given, then load the given path
+    # if it is given, but not found or is not given entirely, then search the
+    # following locations, in preferential order for the clouds_dot_rb_file and
+    # load the first one found
+    #   + CWD/clouds.rb
+    #   + ENV["CLOUDS_DOT_RB"]
+    #   + ENV["HOME"]/clouds.rb
+    #   + /etc/poolparty/clouds.rb
+    #   + /var/poolparty/clouds.rb
+    def self.find_and_load_default_clouds_dot_rb(filename="clouds.rb")
+      f = if File.file?(filename) 
+          filename
+        else
+          find_default_clouds_dot_rb(filename)
+        end
+      load_from_file(f)
+    end
+    
+    # Look for the default clouds_dot_rb_file
+    def self.find_default_clouds_dot_rb(filename)      
+      path = default_clouds_dot_rb_locations.detect do |dir|
+        File.file?(File.expand_path(dir / filename))
+      end
+      raise PoolPartyError.create("CloudsConfigFile", "Cannot find your config file") unless path && filename
+      File.expand_path(File.join(path, filename))
+    end
+    
+    # Default clouds_dot_rb_file locations
+    #   + CWD/clouds.rb
+    #   + ENV["CLOUDS_DOT_RB"]
+    #   + ENV["HOME"]/clouds.rb
+    #   + /etc/poolparty/clouds.rb
+    #   + /var/poolparty/clouds.rb
+    def self.default_clouds_dot_rb_locations
+      @default_clouds_dot_rb_locations ||= [
+        Dir.pwd,
+        ENV["CLOUDS_DOT_RB"],
+        PoolParty::Default.poolparty_home_path,
+        PoolParty::Default.base_config_directory,
+        PoolParty::Default.remote_storage_path
+      ].flatten.reject {|a| a.nil?}
+    end
+    
+    # Before the specfile is loaded this method is called
+    # It...
+    #   + loads the plugin paths local to the clouds_dot_rb_file into the load_path
+    #   + calls the resource define_resource_methods to define the resource methods
+    #   + sets up the log
+    def self.before_file_load(filepath)
+      $:.unshift(::File.dirname(filepath))
+      Dir["#{::File.dirname(filepath)}/plugins/*"].each { |plugin_path| $:.unshift(plugin_path) }
+    end
+    
+    # Call init to the resource methods and init the log
+    # It pulls the requires for chef
+    # TODO: Pull require_chef_only_resources out
+    def self.init
+      DependencyResolvers::Chef.require_chef_only_resources
+      PoolParty::Resource.define_resource_methods
+      PoolParty::PoolPartyLog.init
+    end
+    
+    # CALLBACKS
+    # After the entire cloud is loaded
+    def self.after_file_load(filepath)
+    end
+    
+  end
+end

data/lib/poolparty/pool_party_error.rb

@@ -0,0 +1,19 @@
+=begin rdoc
+  PoolPartyError
+  
+  Create an StandardError on the fly
+=end
+module PoolParty
+  class PoolPartyError
+    
+    # Create an error with the class_name and error message
+    # If the StandardError is not yet defined, define it, subclassing
+    # StandardError and return the new class
+    # Note: the class is set on Object
+    def self.create(class_name="StandardError", msg="Error")
+      Object.const_set(class_name, Class.new(StandardError)) unless Object.const_defined?(class_name)
+      class_name.constantize.send(:new, msg)
+    end
+    
+  end
+end

data/lib/poolparty/pool_party_log.rb

@@ -0,0 +1,47 @@
+=begin rdoc
+  Logger
+=end
+module PoolParty  
+  class PoolPartyLog
+
+    @logger = nil
+    
+    class << self
+      attr_accessor :logger, :level, :file #:nodoc
+      
+      def init(path = false)
+        @file = path ? File.join(path, "poolparty.log") : StringIO.new
+        @logger = Logger.new(file)
+        level = @log_level = :info
+      end
+      
+      # Sets the level for the Logger by symbol or by command line argument.
+      # Throws an ArgumentError if you feed it a bogus log level (that is not
+      # one of :debug, :info, :warn, :error, :fatal or the corresponding strings)
+      def level=(loglevel)
+        case loglevel.to_sym
+        when :debug
+          @logger.level = Logger::DEBUG
+        when :info
+          @logger.level = Logger::INFO
+        when :warn
+          @logger.level = Logger::WARN
+        when :error
+          @logger.level = Logger::ERROR
+        when :fatal
+          @logger.level = Logger::FATAL
+        else
+          raise ArgumentError, "Log level must be one of :debug, :info, :warn, :error, or :fatal"
+        end
+      end
+      
+      def method_missing(method_symbol, *args)
+        init unless @logger
+        @logger.send(method_symbol, *args)
+      end
+      
+    end # class << self
+
+
+  end
+end

data/lib/poolparty/resource.rb

@@ -0,0 +1,279 @@
+module PoolParty
+  class Resource < Base
+    
+    attr_reader :exists
+    attr_reader :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={}, &block)
+      @exists = true
+      super
+      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])
+      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_hsh)
+      other_resources_hsh.each do |k,v|
+        current_deps = (dependencies[k] ||= [])
+        current_deps << v unless current_deps.include?(v)
+      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    
+    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
+    
+    # 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}"
+        define_resource(res)
+        res.method_defined!
+        unless res.defined_resources.empty?
+          res.define_resource_methods
+        end
+      end
+    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.class_eval <<-EOE
+        def has_#{res.has_method_name}(a={},b={},&block)
+          obj = #{res}.new(a,b,&block)
+          obj.exists!
+          resources << obj
+          obj
+        end
+        def does_not_have_#{res.has_method_name}(a={},b={},&block)
+          obj = has_#{res.has_method_name}(a,b,&block)
+          obj.does_not_exist!
+          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
+        case obj
+        when /^\d{4}$/
+          "#{obj}"
+        when /^\d{3}$/
+          "0#{obj}"
+        else
+          "\"#{obj}\""
+        end
+      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

@@ -0,0 +1,65 @@
+=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,19 +1,17 @@
-module PoolParty    
-  module Resources
 =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
@@ -22,33 +20,44 @@ The cron resource will set cron jobs at the intervals you set
 * <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(
-        :command => nil,
-        :user => "root",
-        :minute => "*",
-        :hour => "*",
-        :month => "*",
-        :weekday => "*"
+        :minute   => "*",
+        :hour     => "*",
+        :day      => "*",
+        :month    => "*",
+        :weekday  => "*",
+        :user     => "root",
+        :command  => nil
       )
       
-      def present
-        :create
+      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
       
-      def absent
-        :delete
-      end
-
     end
     
   end