poolparty 0.0.4 → 0.2.6

data/lib/poolparty/base_packages/haproxy.rb

@@ -0,0 +1,42 @@
+module PoolParty
+  class Base
+    plugin :haproxy do
+      
+      def enable
+        execute_if("$hostname", "master") do
+          package({:name => "haproxy"})
+
+          # Startup haproxy and enable it
+          has_line_in_file("ENABLED=1", "/etc/default/haproxy")
+          has_line_in_file("SYSLOGD=\"-r\"", "/etc/default/syslogd")
+          has_line_in_file("local0.* /var/log/haproxy.log", "/etc/syslog.conf", {:notify => 'Service["sysklogd"]'})
+
+          # Restart sysklogd after we update the haproxy.log
+          has_service(:name => "sysklogd") do
+            ensures "running"
+          end
+
+          # Service is required
+          has_service(:name => "haproxy")
+
+          # Tempalte variables
+          variable(:name => "name_haproxy", :value => "#{@parent.name}")
+          variable(:name => "nodenames_haproxy", :value => list_of_node_names)
+          variable(:name => "node_ips_haproxy",  :value => list_of_node_ips)
+          variable(:name => "ports_haproxy", :value => ([(self.respond_to?(:port) ? port : Base.port)].flatten))        
+          variable(:name => "forwarding_port", :value => (respond_to?(:forwarding_port) ? forwarding_port : Base.forwarding_port))
+          variable(:name => "proxy_mode", :value => (respond_to?(:proxy_mode) ? proxy_mode : Base.proxy_mode))
+
+          # These can also be passed in via hash
+          has_remotefile(:name => "/etc/haproxy.cfg") do
+            mode 644
+            # onlyif '$hostname == "master"'
+            requires 'Package["haproxy"]'
+            notify 'Service["haproxy"]'
+            template File.join(File.dirname(__FILE__), "..", "templates/haproxy.conf")
+          end
+        end
+      end
+    end  
+  end
+end

data/lib/poolparty/base_packages/heartbeat.rb

@@ -0,0 +1,45 @@
+module PoolParty
+  class Base
+    plugin :heartbeat do
+      
+      def enable
+        execute_if("$hostname", "master") do
+          has_package(:name => "heartbeat-2", :ensure => "installed")
+          has_service(:name => "heartbeat", :hasstatus => true) do
+            ensures "running"
+          end
+        
+          has_exec(:name => "heartbeat-update-cib", :command => "/usr/sbin/cibadmin -R -x /etc/ha.d/cib.xml", :refreshonly => true)
+        
+          # variables for the templates
+          has_variable({:name => "ha_nodenames", :value => list_of_node_names})
+          has_variable({:name => "ha_node_ips",  :value => list_of_node_ips})
+          has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Base.port)})
+        
+          # These can also be passed in via hash
+          has_remotefile(:name => "/etc/ha.d/ha.cf") do
+            mode 444
+            requires 'Package["heartbeat-2"]'
+            notify 'Service["heartbeat"]'
+            template File.join(File.dirname(__FILE__), "..", "templates/ha.cf")
+          end
+        
+          has_remotefile(:name => "/etc/ha.d/authkeys") do
+            mode 400
+            requires 'Package["heartbeat-2"]'
+            notify 'Service["heartbeat"]'
+            template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
+          end
+        
+          has_remotefile(:name => "/etc/ha.d/cib.xml") do
+            mode 444
+            requires 'Package["heartbeat-2"]'
+            notify 'Exec["heartbeat-update-cib"]'
+            template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
+          end
+        end
+        
+      end
+    end  
+  end
+end

data/lib/poolparty/base_packages/poolparty.rb

@@ -0,0 +1,36 @@
+module PoolParty
+  class Base
+    plugin :poolparty do
+      
+      def enable        
+        has_package(:name => "erlang")
+        # These should be installed automagically by poolparty, but just in case
+        with_options(:requires => 'Package["update-rubygems"]') do
+          has_gempackage(:name => "open4")
+          has_gempackage(:name => "parsetree")
+          has_gempackage(:name => "rubyinline")
+          has_gempackage(:name => "activesupport")
+          has_gempackage(:name => "logging")
+          has_gempackage(:name => "hoe")
+          has_gempackage(:name => "xml-simple")
+          has_gempackage(:name => "ruby2ruby")
+
+          has_gempackage(:name => "grempe-amazon-ec2", :source => "http://gems.github.com", :requires => 'Package["xml-simple"]')
+          has_gempackage(:name => "auser-poolparty", :source => "http://gems.github.com", :requires => 'Package["activesupport", "logging", "hoe", "open4"]')          
+        end                
+        # Build hostsfile
+        # TODO: COME BACK AND CLEAN THIS UP
+        (self.respond_to?(:list_of_running_instances) ? self : parent).list_of_running_instances.each do |ri|
+          has_host({:name => "#{ri.name}", :ip => ri.ip })
+        end
+        
+        cron({:command => "cloud-maintain"}) do
+          minute "*/5"
+          user "puppet"
+        end
+        # has_host(:name => "puppet", :ip => (self.respond_to?(:master) ? self : parent).master.ip)
+      end
+      
+    end  
+  end
+end

data/lib/poolparty/base_packages/ruby.rb

@@ -0,0 +1,43 @@
+module PoolParty
+  class Base
+    plugin :ruby do
+      
+      def enable                
+        install_base_packages
+      end
+      
+      def install_base_packages
+        has_package(:name => "libreadline-ruby1.8")
+        has_package(:name => "libruby1.8")                
+        has_package(:name => "ruby1.8-dev")
+        has_package(:name => "ruby1.8")
+        has_package(:name => "rubygems")
+        
+        has_line_in_file("export PATH=$PATH:/var/lib/gems/1.8/bin/", "/etc/profile")
+        
+        # exec(:name => "update-rubygems") do
+        #   command "gem update --system"
+        #   onlyif "gem -v | grep 1."
+        #   notify 'Exec["fix-updated-rubygems"]'
+        # end
+        # exec(:name => "fix-updated-rubygems") do
+        #   command "awk \'{print} NR == 9 {print \"require \"rubygems/gem_runner\"\"}\' /usr/bin/gem"
+        #   ifnot "awk \"/gem_runner/\" /usr/bin/gem"
+        # end
+      end
+      
+      def enable_ri
+        has_package(:name => "ri1.8")
+      end
+      
+      def enable_irb
+        has_package(:name => "irb1.8")
+      end
+      
+      def enable_rdoc
+        has_package(:name => "rdoc1.8")
+      end
+      
+    end  
+  end
+end

data/lib/poolparty/core/array.rb

@@ -0,0 +1,24 @@
+=begin rdoc
+  Array extensions
+=end
+require "enumerator"
+class Array
+  def to_os
+    map {|a| a.to_os }
+  end
+  def collect_with_index &block
+    self.enum_for(:each_with_index).collect &block
+  end
+  def runnable(quiet=true)
+    self.join(" \n ").runnable(quiet)
+  end
+  def nice_runnable(quiet=true)
+    self.flatten.reject{|e| (e.nil? || e.empty?) }.join(" \n ").chomp.nice_runnable(quiet)
+  end
+  def to_string(prev="")
+    map {|a| a.to_string(prev)}.join("\n")
+  end
+  def get_named(str="")
+    map {|a| a.name == str ? a : nil }.reject {|a| a.nil? }
+  end
+end

data/lib/poolparty/core/float.rb

@@ -0,0 +1,13 @@
+class Float
+  def round_to(x)
+    (self * 10**x).round.to_f / 10**x
+  end
+
+  def ceil_to(x)
+    (self * 10**x).ceil.to_f / 10**x
+  end
+
+  def floor_to(x)
+    (self * 10**x).floor.to_f / 10**x
+  end
+end

data/lib/poolparty/core/hash.rb

@@ -0,0 +1,29 @@
+=begin rdoc
+  Hash extentions
+=end
+class Hash
+  alias :old_select :select
+
+  def select(&block)
+    Hash[*self.old_select(&block).inject([]){|res,(k,v)| res << k << v}]    
+  end
+  def extract!(&block)
+    o = select(&block)
+    o.keys.each {|k| self.delete(k) }
+    o
+  end
+  def safe_merge(other_hash)
+    merge(other_hash.delete_if {|k,v| has_key?(k) })
+  end
+  def safe_merge!(other_hash)
+    merge!(other_hash.delete_if {|k,v| has_key?(k) && !v.nil? })
+  end
+  def flush_out(prev="", post="")
+    map {|k,v| "#{prev}#{k} => #{v.to_option_string}#{post}"}
+  end
+  def to_os
+    m={}
+    each {|k,v| m[k] = v.to_os }
+    MyOpenStruct.new(m)
+  end
+end

data/lib/poolparty/core/kernel.rb

@@ -0,0 +1,37 @@
+=begin rdoc
+  Kernel overloads
+=end
+module Kernel
+  # Nice wait instead of sleep
+  def wait(time=5)
+    sleep time.is_a?(String) ? eval(time) : time
+  end
+  def as(klass_or_obj, &block)
+    block.in_context(klass_or_obj).call
+  end
+  def load_p(dir)
+    Dir["#{dir}/*.rb"].each do |file|
+      require "#{file}" if ::FileTest.file?(file)
+    end
+    Dir["#{dir}/*"].each do |dir|
+      load_p(dir) if ::FileTest.directory?(dir)
+    end
+  end
+  def with_warnings_suppressed
+    saved_verbosity = $-v
+    $-v = nil
+    yield
+  ensure
+    $-v = saved_verbosity
+  end
+  def hide_output
+    begin
+      old_stdout = STDOUT.dup
+      STDOUT.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+      yield if block_given?
+    ensure
+      STDOUT.flush
+      STDOUT.reopen(old_stdout)
+    end
+  end  
+end

data/lib/{core → poolparty/core}/module.rb

@@ -19,4 +19,22 @@ class Module
         private target
     end
   end
+  def attr_accessor_with_default( *syms, &block )
+    raise 'Default value in block required' unless block
+    syms.each do | sym |
+      module_eval do
+        attr_writer( sym )
+        define_method( sym ) do | |
+          class << self; self; end.class_eval do
+            attr_reader( sym )
+          end
+          instance_variables.include?("@#{sym}") ? instance_variable_get( "@#{sym}" ) : instance_variable_set( "@#{sym}", block.call )
+        end
+      end
+    end
+    nil
+  end
+  def set(*args)
+  end
+  alias_method :custom, :set
 end

data/lib/poolparty/core/my_open_struct.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+  Create an extended open struct
+=end
+require "ostruct"
+class MyOpenStruct < OpenStruct
+  attr_accessor :keys
+  def initialize(h)
+    @keys = h.keys
+    super
+  end
+  def to_hash
+    m = {}
+    @keys.map do |key|
+      m.update( {key => self.send(key)} )
+    end
+    m
+  end
+end

data/lib/poolparty/core/object.rb

@@ -0,0 +1,54 @@
+=begin rdoc
+  Basic, add an alias_method to the object class
+  Add returning to the object
+=end
+class Object
+  def my_methods
+    self.methods.sort - (self.class.methods + self.class.superclass.methods)
+  end
+  def to_os
+    self
+  end  
+  def alias_method(new_id, original_id)
+    original = self.method(original_id).to_proc
+    define_method(new_id){|*args| original.call(*args)}
+  end
+  def with_options(opts={}, parent=self, &block)
+    @p = parent.clone
+    @p.options.merge!(opts)
+    @p.instance_eval &block if block
+  end  
+  def returning(receiver)
+    yield receiver
+    receiver
+  end
+  def extended(&block)
+    block.in_context(self).call
+    self
+  end
+  def to_option_string
+    case self.class
+    when String
+      self.to_option_string
+    when Array
+      self.each {|a| a.to_option_string }.join(" ")
+    else
+      "#{self}"
+    end
+  end
+  def block_instance_eval(*args, &block)
+    return instance_eval(*args,&block) unless block_given? && !block.arity.zero?
+    old_method = (self.class.instance_method(:__) rescue nil)
+    self.class.send(:define_method, :__, &block)
+    block_method = self.class.instance_method(:__)
+    if old_method
+      self.class.send(:define_method, :__, old_method)
+    else
+      self.class.send(:remove_method, :__)
+    end
+    block_method.bind(self).call(*args)
+  end
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+end

data/lib/poolparty/core/proc.rb

@@ -0,0 +1,7 @@
+require 'ruby2ruby' 
+
+class Proc
+  def to_ruby(opts={})
+    Ruby2Ruby.new.process(self.to_sexp).gsub(/proc \{/, "do \n#{opts.map {|k,v| "#{k} \"#{v}\""}.join("\n")}\n").sub(/\}/, "\nend")
+  end
+end

data/lib/poolparty/core/string.rb

@@ -0,0 +1,72 @@
+class String
+  def hasherize(format=[])
+    hash = {}
+    i = 0
+    self.split(%r{[\n|\t|\s| ]+}).map {|a| a.strip}.each do |f|
+      next unless format[i]
+      unless f == "" || f.nil?
+        hash[format[i].to_sym] = f
+        i+=1
+      end      
+    end
+    hash
+  end
+  def ^(h={})
+    self.gsub(/:([\w]+)/) {h[$1.to_sym] if h.include?($1.to_sym)}
+  end
+  def arrayable
+    self.strip.split(/\n/)
+  end
+  def runnable(quite=true)
+    # map {|l| l << "#{" >/dev/null 2>/dev/null" if quite}" }.
+    self.strip.split(/\n/).join(" && ")
+  end
+  def top_level_class
+    self.split("::")[-1].downcase rescue self
+  end
+  def sanitize
+    self.gsub(/[\.]*/, '')
+  end
+  def nice_runnable(quite=true)
+    self.split(/ && /).join("\n")
+  end
+  def to_option_string(ns=[])
+    a_template = (self =~ /template/) == 0
+    a_service = self =~ /^[A-Z][a-zA-Z]*\[[a-zA-Z0-9\-\.\"\'_\$\{\}\/]*\]/
+    (a_service || a_template) ? "#{self}" : "'#{self}'"
+  end
+  # Refactor this guy to get the class if the class is defined, and not always create a new one
+  # although, it doesn't really matter as ruby will just reopen the class
+  def class_constant(superclass=nil, opts={}, &block)
+    symc = ((opts && opts[:preserve]) ? ("#{self.classify}Classs") : "PoolParty#{self.classify}Classs").classify
+    
+    kla=<<-EOE
+      class #{symc} #{"< #{superclass}" if superclass}
+      end
+    EOE
+    
+    Kernel.module_eval kla
+    klass = symc.constantize
+    klass.module_eval &block if block
+    
+    klass
+  end
+  
+  def module_constant(&block)
+    symc = "#{self}_Module".classify
+    mod = Object.const_defined?(symc) ? Object.const_get(symc.to_sym) : Module.new(&block)
+    Object.const_set(symc, mod) unless Object.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def preserved_module_constant(ext="", from="PoolParty::", &block)
+    symc = "#{self}#{ext}".classify
+    mod = Kernel.const_defined?(symc) ? Kernel.const_get(symc.to_sym) : Module.new(&block)
+    Kernel.const_set(symc, mod) unless Kernel.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def collect_each_line_with_index(&block)
+    returning [] do |arr|
+      arr << self.split(/\n/).collect_with_index(&block)
+    end.flatten
+  end
+end