auser-poolparty 1.2.12 → 1.3.0

data/lib/dependency_resolvers/chef/resources/route.rb

@@ -0,0 +1,52 @@
+=begin rdoc
+== Route
+  
+  Manage the system routing table.
+  
+== Usage
+
+  has_route "10.0.0.1" do
+    gateway "10.0.0.20"
+    metric 5
+    route_type :net
+    netmask "255.255.0.0"
+  end
+  
+== Options
+* <tt>gateway</tt> The gateway for the route
+* <tt>metric</tt> The route metric as an integer
+* <tt>route_type</tt> The type of route as a symbol, either :host or :net
+* <tt>netmask</tt> The decimal representation of the network mask eg 255.255.255.0
+* <tt>device</tt> Network interface to apply this route to
+  
+=end
+module PoolParty
+  module Resources
+    
+    class Route < Directory
+      
+      default_options(
+        :gateway    => nil,
+        :metric     => nil,
+        :route_type => :host,
+        :netmask    => nil,
+        :device     => nil
+      )
+      
+      def print_to_chef
+        str = <<-EOE
+route "<%= name %>" do
+  gateway <%= print_variable(gateway) %>
+  metric <%= print_variable(metric) %>
+  route_type <%= print_variable(route_type) %>
+  netmask <%= print_variable(netmask) %>
+  action :<%= exists? ? :add : :delete %>
+EOE
+        str << "  device <%= print_variable(device) %>\n" if device
+        str << "end"
+      end
+      
+    end
+    
+  end
+end

data/lib/dependency_resolvers/chef/resources/script.rb

@@ -0,0 +1,62 @@
+=begin rdoc
+== Script
+  Execute a script using the specified interpreter. Includes actions/attributes available to Execute resources. Predefined available script interpreters are bash, csh, perl, python and ruby.
+
+== Usage
+  has_script "install_something" do
+    interpreter "bash"
+    user "root"
+    cwd "/tmp"
+    code <<-EOH 
+wget http://www.example.com/tarball.tar.gz
+tar -zxf tarball.tar.gz
+cd tarball
+./configure
+make
+make install
+EOH
+  end
+  
+== Options
+* <tt>code</tt> Quoted script of code to execute.
+* <tt>interpreter</tt> The interpreter to use to run the script
+  
+=end
+module PoolParty
+  module Resources
+    
+    class Script < Exec
+            
+      default_options(
+        :code => nil,
+        :interpreter => nil,
+        # Exec
+        :path => ["/usr/bin:/bin:/usr/local/bin:$PATH"],
+        :command => nil,
+        :creates => nil,
+        :cwd => nil,
+        :environment => nil,
+        :group => nil,
+        :returns => nil,
+        :user => nil
+      )
+            
+      def print_to_chef
+str = 'script "<%= name %>" do
+  code "<%= code %>"
+'
+      str << "  interpreter <%= print_variable(interpreter) %>\n" if interpreter
+      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/dependency_resolvers/chef.rb

@@ -0,0 +1,228 @@
+=begin rdoc
+Base dependency_resolver
+=end
+module DependencyResolvers
+  
+  class Chef < Base
+    
+    class << self
+      attr_reader :cookbook_directory
+      
+      def before_compile
+        @cookbook_directory = compile_directory/"cookbooks"/"poolparty"
+        raise PoolParty::PoolPartyError.create("ChefCompileError", "No compile_directory is specified. Please specify one.") unless compile_directory
+        FileUtils.mkdir_p cookbook_directory unless ::File.directory?(cookbook_directory)
+      end
+      
+      def after_compile(o)
+        compile_default_recipe(o)
+        compile_variables
+        compile_files
+        compile_recipes
+        
+        write_dna_json
+        write_solo_dot_rb
+      end
+      
+      def compile_command
+        "/usr/bin/chef-solo -c /etc/chef/solo.rb -j /etc/chef/dna.json"
+      end
+         
+      # compile the resources
+      # Compiles the resource appropriately against the type
+      # If the resource is a variable, then we don't have any output
+      # as the output will be handled in after_compile with compile_variables
+      # If the resource is a file, then add it to the files array and run the
+      # compile_resource command (on super) for the output. The file will later
+      # be turned into a .erb template file in the compile_directory
+      # Otherwise just run the output to get the default.rb recipe
+      def compile_resource(res)
+        # Apply meta_functions here        
+        o = case res
+        when PoolParty::Resources::Variable
+          # do variable stuff
+          variables << res
+          ""
+        when PoolParty::Resources::FileResource
+          files << res
+          super
+        when PoolParty::Resources::ChefAttributesFile
+          attribute_files << res
+          ""
+        else
+          super
+        end
+        
+        apply_meta_functions(res, o) if res.is_a?(PoolParty::Resource)
+      end
+      
+      default_attr_reader :variables, []
+      default_attr_reader :files, []
+      default_attr_reader :attribute_files, []
+      
+      def require_chef_only_resources
+        # Require the chef-only resources
+        $:.unshift("#{File.dirname(__FILE__)}/chef")
+        
+        to_define_resoures = []
+        %w( http_request remote_directory remote_file route script chef_attributes_file).each do |res|
+          require "resources/#{res}"
+          PoolParty::Resource.define_resource("PoolParty::Resources::#{res.classify}".constantize)
+        end
+      end
+      
+      private
+      
+      # Take the print_to_chef string and apply metafunctions to the string on the resource
+      # If there are no meta functions on the resource, do not touch the resulting
+      # string
+      def apply_meta_functions(resource, str)
+        regex = /[(.*)do(\w*)?(.*)]?(\w)*end$/
+        
+        add = []
+        apply_meta_notifies(resource, add) if resource.meta_notifies
+        apply_meta_subscribes(resource, add) if resource.meta_subscribes
+
+        if resource.meta_not_if
+          tmp = "  not_if "
+          tmp += resource.meta_not_if[1] == :block ? "do #{resource.meta_not_if[0]} end" : "\"#{resource.meta_not_if[0]}\""
+          add << tmp
+        end
+        
+        if resource.meta_only_if
+          tmp = "   only_if "
+          tmp += resource.meta_only_if[1] == :block ? "do #{resource.meta_only_if[0]} end" : "\"#{resource.meta_only_if[0]}\""
+          add << tmp
+        end
+        
+        add << "  ignore_failure #{resource.print_variable(resource.ignore_failure)}" if resource.ignore_failure
+        add << "  provider #{resource.print_variable(resource.provider)}" if resource.provider
+        
+        return str if add.empty?
+        newstr = str.chomp.gsub(regex, "")
+        "#{newstr}#{add.join("\n")}\nend"
+      end
+      
+      def apply_meta_notifies(resource, add)
+        # The meta_notifies is a hash that looks like: {:file => [["pool_name", :reload]]}
+        resource.meta_notifies.each do |ty, arr|
+          arr.each do |nm, action|
+            add << "  notifies :#{action}, resources(:#{chef_safe_resource(ty)} => \"#{nm}\")"
+          end
+        end
+      end
+      
+      def apply_meta_subscribes(resource, add)
+        # The meta_subscribes is a hash that looks like: {:file=>[["pool_name", :reload, :immediately]]
+        resource.meta_subscribes.each do |ty, arr|
+          arr.each do |nm, action, at_time|
+            # subscribes :reload, resources\(:service => "apache"\), :delayed
+            add << "  subscribes :#{action}, resources(:#{chef_safe_resource(ty)} => \"#{nm}\"), :#{at_time}"
+          end
+        end
+      end
+      
+      # Cleanup for chef resource output
+      # Not particularly clean, but a necessary evil because
+      # certain resources don't reflect the chef output
+      # such as has_exec corresponds to execute
+      def chef_safe_resource(name)
+        case name
+        when :exec
+          "execute"
+        else
+          name
+        end
+      end
+      
+      # Take the variables and compile them into the file attributes/poolparty.rb
+      def compile_variables
+        # Make sure the attributes/ directory is there
+        FileUtils.mkdir_p cookbook_directory/"attributes" unless ::File.directory?(cookbook_directory/"attributes")        
+        
+        f = cookbook_directory/"attributes"/"poolparty.rb"
+        # Collect the file pointers that will be using to print out the attributes
+        file_pointers = {:poolparty => File.open(f, "w")}
+        variables.each do |var|
+          if var.parent && !var.parent.is_a?(PoolParty::Cloud)
+            f = cookbook_directory/"attributes"/"#{var.parent.has_method_name}.rb"
+            File.unlink f if File.file?(f)
+            file_pointers[var.parent.has_method_name] = File.open(f, "w+")
+          end
+        end
+        # Make sure the attribute exists in each file
+        file_pointers.each do |n,f|
+          f << "\n#{n} Mash.new unless attribute?(\"#{n}\")\n"
+        end
+        variables.each do |var|
+          
+          var_val = handle_print_variable(ProxyObject.new(var, @caller).compile(:value))
+          if var.parent && !var.parent.is_a?(PoolParty::Cloud)
+            file_pointers[var.parent.has_method_name] << "#{var.parent.has_method_name}[:#{var.name}] = #{var_val}\n"
+          else
+            file_pointers[:poolparty] << "poolparty[:#{var.name}] = #{var_val}\n"
+          end
+        end
+        # Close the files
+        file_pointers.each {|k,v| v.close }
+      end
+      
+      # Compile the files
+      def compile_files
+        FileUtils.mkdir_p cookbook_directory/"files" unless ::File.directory?(cookbook_directory/"files")
+        files.each do |fi|
+          fpath = cookbook_directory/"templates"/"default"/"#{fi.path}.erb"
+          FileUtils.mkdir_p File.dirname(fpath) unless File.directory?(File.dirname(fpath))
+          content = fi.template ? open(fi.template).read : fi.content
+          File.open(fpath, "w") do |f|
+            f << content
+          end
+        end
+        
+        # Compile the attribute files
+        attribute_files.each do |res|
+          fpath = cookbook_directory/"attributes"/"#{File.basename(res.path)}"
+          FileUtils.mkdir_p File.dirname(fpath) unless File.directory?(File.dirname(fpath))
+          File.open(fpath, "a") do |f|
+            f << res.content
+          end
+        end
+      end
+      
+      # compile the recipes
+      # TODO
+      def compile_recipes
+      end
+      
+      def write_dna_json
+        File.open(compile_directory/"dna.json", "w") do |f|
+          f << JSON.generate({:recipes => ["poolparty"]})
+        end
+      end
+      
+      def compile_default_recipe(content)
+        FileUtils.mkdir_p cookbook_directory/"recipes" unless ::File.directory?(cookbook_directory/"recipes")
+        File.open(cookbook_directory/"recipes"/"default.rb", "w") do |f|
+          f << content
+        end
+      end
+      
+      def write_solo_dot_rb
+        content = <<-EOE
+cookbook_path     "/etc/chef/cookbooks"
+node_path         "/etc/chef/nodes"
+log_level         :info
+file_store_path  "/etc/chef"
+file_cache_path  "/etc/chef"
+        EOE
+        
+        File.open(compile_directory/"solo.rb", "w") do |f|
+          f << content
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/dependency_resolvers/proxy_object.rb

@@ -0,0 +1,90 @@
+=begin rdoc
+  Proxy printer object
+  
+  This stands in as the middle between the resource and the 
+  dependency resolver and provides helper methds to the
+  output
+=end
+module DependencyResolvers
+  
+  class ProxyObject
+    attr_accessor :proxy
+    attr_reader :current_printing_method, :caller
+    
+    def initialize(proxy, caller=nil)
+      @proxy = proxy
+      @caller = caller
+    end
+    
+    # <tt>Compile</tt>
+    # Arguments:
+    #   * String
+    #     If a string is passed, it is assumed to be an erb template and
+    #     is rendered in the binding of this object (the proxy is contained)
+    #   * Symbol
+    #     If a symbol is passed, it is assumed to be a method, primarily
+    #     used for <tt>print_to_<resolver_name></tt> methods
+    # The output of compile is an erb template that is rendered in the context
+    # of this proxy object
+    def compile(meth_name)
+      str = case meth_name
+      when String
+        meth_name
+      when Symbol
+        @current_printing_method = meth_name
+        self.send(meth_name).to_s
+      else
+        raise PoolParty::PoolPartyError.create("ProxyObjectError", "Compilation of #{proxy.inspect} error. Strings and symbols are supported")
+      end
+      begin
+        ERB.new(str).result(self.send(:binding))
+      rescue Exception => e
+        p [:error, e, str]
+      end      
+    end
+    
+    # Print the dsl options in the Erb string format
+    # given by the method print_dsl_options(str)
+    # To use print_dsl_options, the format is:
+    # print_dsl_options("print :key = ':value'")
+    # The string substitution uses the ^ substitution found in string.rb
+    # This will substitute the key and the value in the format given by the 
+    # string passed. For instance
+    #   dsl_options = {:to => "world", :message => "hello"}
+    #   print_dsl_options(":key => :value") =
+    #     message => hello
+    #     to => world
+    # This should be used if all the dsl_options
+    # are to printed in the same format
+    def print_dsl_options(str)
+      dsl_options.map do |k,v|
+        v.nil? ? nil : str ^ {:key => k, :value => v}
+      end.compact.join("\n")
+    end
+    
+    # Take all the ordered_resources of the proxy object
+    # and print them with the current_printing_method, aka :chef for print_to_chef
+    # This creates a new proxy object with each resource and sends it
+    # :compile with the current printing method, collects the output
+    # and joins them with a newline
+    def print_resources
+      resources.map do |res|
+        ProxyObject.new(res).compile(current_printing_method)
+      end.join("\n")
+    end
+    
+    def instance
+      @caller
+    end
+    
+    # method_missing
+    # Because this ProxyObject is responsible for proxying
+    # methods to the proxy object, the method_missing method
+    # is used to curry methods across
+    def method_missing(m,*a,&block)
+      proxy.send(m,*a,&block)
+    end
+    
+  end
+  
+end

data/lib/keypair.rb

@@ -0,0 +1,93 @@
+=begin rdoc
+  ssh key used to login to remote instances\
+=end
+class Keypair
+  
+  include SearchablePaths
+  has_searchable_paths(:prepend_paths => [Dir.pwd, '/etc/poolparty/keys', "#{ENV["HOME"]}/.ssh/", "#{ENV["HOME"]}/.ec2/", ENV['EC2_CONFIG_DIR']])
+  
+  attr_accessor :filepath
+  
+  # Create a new key that defaults to id_rsa as the name. 
+  def initialize(fpath)
+    @filepath = fpath
+    valid?
+  end
+  
+  # If the full_filepath is nil, then the key doesn't exist
+  def exists?
+    full_filepath != nil
+  end
+  
+  # Read the content of the key
+  def content
+    @content ||= exists? ? open(full_filepath).read : nil
+  end
+      
+  # Returns the full_filepath of the key. If a full filepath is passed, we just return the expanded filepath
+  # for the keypair, otherwise query where it is against known locations
+  def full_filepath
+    @full_filepath ||= if File.file?(::File.expand_path(filepath))
+      ::File.expand_path(filepath)
+      else
+        search_in_known_locations(filepath)
+      end
+  end
+  alias :to_s :full_filepath
+  
+  #TODO: gracefully handle the case when a passpharase is needed
+  # Generate a public key from the private key
+  # net/ssh already has this built-in from our extension.
+  def public_key
+    if !@public_key_string || @public_key_string.empty?
+      pkey = Net::SSH::KeyFactory.load_private_key(full_filepath)
+      @public_key_string = pkey.public_key
+    else
+      @public_key_string
+    end
+  end
+  
+  def public_key=(str)
+     @public_key_string = str
+  end
+  
+  # Basename of the keypair
+  def basename
+    @basename ||= ::File.basename(filepath, ::File.extname(filepath))
+  end
+  
+  # Just the filename of the keypair
+  def filename
+    @filename ||= ::File.basename(full_filepath) rescue filepath
+  end
+  
+  # Support to add the enumerable each to keys
+  def each
+    yield full_filepath
+  end
+      
+  # Validation checks
+  # if all of the validations pass, the object is considered valid
+  # the validations are responsible for raising a PoolPartyError (StandardError)
+  def valid?
+    validations.each {|validation| self.send(validation.to_sym) }
+  end
+
+  private
+
+  # Validations
+  def validations
+    [:keypair_found?, :has_proper_permissions?]
+  end
+  
+  # Check the proper permissions
+  def has_proper_permissions?
+    perm_truth = [:readable?, :writable?, :executable?].map {|meth| File.send(meth, full_filepath)} == [true, true, false]
+    raise StandardError.new("Your keypair #{full_filepath} has improper file permissions. Keypairs must be 0600 permission. Please chmod your keypair file and try again") unless perm_truth
+  end
+  
+  def keypair_found?
+    raise StandardError.new("#{filepath} key file cannot be found") unless exists?
+  end
+  
+end

data/lib/mixins/askable.rb

@@ -0,0 +1,154 @@
+require "colors"
+module Askable
+  module ClassMethods
+    def ask(msg="", opts={}, &block)
+      begin
+        answer = Question.new(msg, STDIN).answer
+        
+        unless opts[:no_value]
+          if answer.nil? || answer == ""
+            colored_say("You must enter a value\nTry again\n")
+            ask(msg, &block)
+          end
+        end
+      rescue Exception => e
+        colored_say e.inspect
+        exit 0
+      end
+    end
+
+    def ask_with_help(opts={}, &block)
+      help_str = opts[:help]
+      message = opts[:message]
+
+      colored_say("#{message} (h for help)")
+      o = ask("? ")
+      
+      if %w(h H).include?(o)
+        colored_say help_str
+        ask_with_help(opts, &block)
+      else
+        block.call(o) if block
+      end
+      o
+    end
+    
+    def colored_ask(str, o={})
+      ask(substitute_color_tags(str), o)
+    end
+  
+    def rescued_ask(m, r)
+      begin
+        t = colored_ask m
+      rescue Exception => e
+        say r
+      end
+    end
+    
+    def colored_say(str, o={})
+      out = substitute_color_tags(str)
+      o[:no_newline] ? print(out) : puts(out)
+    end
+    
+    def colored_print(str)
+      print substitute_color_tags(str)
+    end
+    
+    def choose(str, choices={}, opts={}, &block)
+      colored_say(str)
+      choices.each do |k,v|
+        colored_say("#{k}) #{v}")
+      end
+      colored_print((opts[:prompt] || "> "))
+      pick = gets.chomp.to_i
+      yield choices[pick] if block
+      choices[pick]
+    end
+    
+    def wait
+      begin        
+        STDIN.readline unless auto_install # -y passed
+      rescue Interrupt
+        exit 2
+      end
+  	end
+  	
+  	def substitute_color_tags(data)
+      Colors.process(data)
+    end
+    
+  end
+  
+  module InstanceMethods
+    def ask(msg, &block)
+      self.class.ask(msg, &block)
+    end
+
+    def ask_with_help(opts={}, &block); self.class.ask_with_help(opts, &block);end
+
+    def colored_ask(str, o)
+      self.class.colored_ask(str, o)
+    end
+
+    def colored_say(str, o={})
+      self.class.colored_say(str, o)
+    end
+
+    def colored_print(str)
+      self.class.colored_print(str)
+    end
+    
+    def choose(str, choices={}, opts={}, &block); self.class.choose(str, choices, opts, &block); end
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+  
+  class Question
+    attr_reader :answer
+    include Askable
+    
+    def initialize(question, input=STDIN, opts={})
+      @question = question
+      @input = input
+      
+      defaults = {
+        :wrap => 60
+      }
+      
+      @opts = defaults.merge(opts)
+      
+      ask
+    end
+    
+    private
+    
+    # get the answer, chomp it, etc.
+    def ask
+      case @question
+      when String
+        ask_string
+      when Array
+        ask_array
+      end
+    end
+    
+    def ask_string
+      colored_say @question, :no_newline => true
+      @answer = @input.gets
+      answer.chomp!
+    end
+    
+    def ask_array
+      @question.each_with_index do |q, i|
+        colored_say "#{i+1}> #{q}"
+      end
+      colored_say "(number 1-#{@question.size})"
+      colored_say "? ", :no_newline => true
+      num = (@input.gets).to_i rescue colored_say("<red>Invalid input, must be a number between 1 and #{@question.size + 1}")
+      @answer = @question[num-1]
+    end
+  end
+end