fairchild-poolparty 1.1.3

data/lib/poolparty/aska/aska.rb

@@ -0,0 +1,152 @@
+=begin rdoc
+  Aska
+  TODO: Extract this into a proper gem
+=end
+module Aska
+  module ClassMethods
+    def rules(name=:rules, arr=[], create_vars=true)
+      rs = look_up_rules(name)
+      # returning look_up_rules(name) do |rs|
+      arr.each do |line|
+        next unless line
+        rule = Rule.new(line)
+        next unless rule.valid?
+        k = rule.key
+        v = rule.var
+        m = rule.comparison
+
+        create_instance_variable(k, create_vars)
+        rs << {k => [m, v]}
+        rs << {k => [">", "0"]} unless rs.reject {|a| a.to_s == "#{k}>0" }
+      end
+      self.send(:define_method, name) do
+        look_up_rules(name)
+      end
+      rs
+      # end
+    end
+    def create_instance_variable(k, create_vars=true)
+      aska_attr_accessors << k.to_sym unless aska_attr_accessors.include?(k.to_sym)
+      if create_vars
+        attr_reader k.to_sym unless respond_to?("#{k}".to_sym)
+        attr_writer k.to_sym unless respond_to?("#{k}=".to_sym)
+      end
+    end
+    def look_up_rules(name)
+      defined_rules[name.to_sym] ||= Rules.new
+    end
+    def are_rules?(name)
+      !look_up_rules(name).empty?
+    end
+    def aska_attr_accessors
+      @aska_attr_accessors ||= Rules.new
+    end
+    def defined_rules
+      @defined_rules ||= {}
+    end
+    def aska_named(name)
+      "#{name}_aska"
+    end
+  end
+  
+  module InstanceMethods
+    def rules
+      @rules ||= self.class.defined_rules
+    end
+    def valid_rules?(name=:rules)
+      self.class.look_up_rules(name).reject {|rule| valid_rule?(rule) }.empty?
+    end
+    def __aska_send_value(m)
+      if respond_to?(m.to_sym)
+        self.send(m.to_sym)
+      else
+        m
+      end
+    end
+    def valid_rule?(rule)
+      rule.each do |key,value|
+        begin
+          return __aska_send_value(key).send(value[0].to_sym, __aska_get_var(value[1]))
+        rescue Exception => e
+          return false
+        end
+      end
+    end
+    def rules_values
+      returning Array.new do |arr|
+        self.class.defined_rules.each do |name,rule_array|
+          arr << "#{name} : #{valid_rules?(name.to_sym)}"
+          rule_array.each do |rule|
+            rule.map do |k,v|
+              arr << "  #{k} -> #{__aska_send_value(k)} (#{v[0]} #{v[1]})"
+            end
+          end
+        end
+      end.join("\n")
+    end
+    # Get the variable from the class
+    # If it's defined as an attr_accessor, we know it has been defined as a rule
+    # Otherwise, if we are passing it as a 
+    def __aska_get_var(name)
+      # attr_accessor?(name) ? aska(name) : 
+      (supported_method?(name) ? name.to_sym : name.to_f)
+    end
+    def __aska_aska(name)
+      self.class.aska_named(name)
+    end
+    def attr_accessor?(name)
+      self.class.aska_attr_accessors.include?(name.to_sym)
+    end
+    def supported_method?(meth)
+      %w(< > == => =<).include?("#{meth}")
+    end
+    
+    def look_up_rules(r);self.class.look_up_rules(r);end
+    def are_rules?(r);self.class.are_rules?(r);end
+    
+    # def method_missing(m, *args, &block)
+    #   if self.class.defined_rules.has_key?(m.to_sym)
+    #     self.class.send(:define_method, m) do
+    #       self.class.look_up_rules(m)
+    #     end
+    #     self.send m
+    #   else
+    #     super
+    #   end
+    # end
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+  
+  class Rule < String
+    attr_accessor :value
+    
+    def initialize(v)
+      @value = v
+    end
+    def valid?
+      value =~ /(.+)[=\\\<\>](.*)/
+    end
+    def key
+      value[/(.+)[=\\\<\>](.*)/, 1].gsub(/\s+/, '')
+    end
+    def comparison
+      value[/[=\\<>]/, 0].gsub(/\s+/, '')
+    end
+    def var
+      value[/(.+)[=\\<>](.*)/, 2].gsub(/\s+/, '')
+    end
+    def value
+      @value ||= ""
+    end
+  end
+  
+  class Rules < Array
+    def to_s
+      self.map {|r| v=r.keys.first;"'#{v} #{r[v][0]} #{r[v][1]}'"}.join(", ")
+    end
+  end
+end

data/lib/poolparty/base_packages/bind.rb

@@ -0,0 +1,11 @@
+module PoolParty
+  class Base
+    plugin :poolparty_base_bind do
+      
+      def enable
+        
+      end
+      
+    end
+  end
+end

data/lib/poolparty/base_packages/haproxy.rb

@@ -0,0 +1,46 @@
+module PoolParty
+  class Base
+    plugin :poolparty_base_haproxy do
+      
+      def enable
+        # We need the haproxy package
+        has_package "apache2"
+        has_service "apache2"
+        has_package({:name => "haproxy"})
+    
+        # Restart sysklogd after we update the haproxy.log
+        has_service(:name => "sysklogd")
+    
+        # Template variables
+        has_variable("haproxy_name", :value => "#{cloud.name}")
+        has_variable("listen_ports", :value => [ "8080" ], :namespace => "apache")
+        
+        has_variable("ports_haproxy", :value => ([(self.respond_to?(:port) ? port : Default.port)].flatten))        
+        has_variable("forwarding_port", :value => (respond_to?(:forwarding_port) ? forwarding_port : Default.forwarding_port))
+        has_variable("proxy_mode", :value => (respond_to?(:proxy_mode) ? proxy_mode : Default.proxy_mode))
+    
+        # Startup haproxy and enable it
+        has_line_in_file(:line => "ENABLED=1", :file => "/etc/default/haproxy")
+        has_line_in_file({:line => "SYSLOGD=\"-r\"", :file => "/etc/default/syslogd"})
+        has_line_in_file({:line => "local0.* /var/log/haproxy.log", :file => "/etc/syslog.conf"}, {:notify => get_service("sysklogd")})
+
+        has_exec "reloadhaproxy", 
+          :command => "/etc/init.d/haproxy reload", 
+          :requires => get_package("haproxy")
+        
+        # Service is required
+        has_service("haproxy", :ensures => "running") do
+          stops get_service("apache2"), :immediately
+          starts get_service("apache2")
+        end
+        
+        has_directory "/var/run/haproxy"
+        
+        has_file "/etc/haproxy/haproxy.cfg" do
+          template "#{::File.dirname(__FILE__)}/../templates/haproxy.conf"
+          calls get_exec("reloadhaproxy")
+        end
+      end
+    end
+  end
+end

data/lib/poolparty/base_packages/heartbeat.rb

@@ -0,0 +1,58 @@
+module PoolParty
+  class Base
+    plugin :poolparty_base_heartbeat do
+      
+      def enable        
+        # execute_on_master do
+        has_package({:name => "heartbeat-2"})
+        has_package({:name => "heartbeat-2-dev"})
+        
+        has_service("heartbeat")
+      
+        # has_service(:name => "heartbeat", :hasstatus => true, :hasrestart => true)
+        # has_directory(:name => "/etc/ha.d")
+        # 
+        # has_remotefile(:name => "/etc/ha.d/ha.cf") do
+        #   mode 444
+        #   notify service(:name => "heartbeat")
+        #   template "ha.cf"
+        # end
+        # 
+        # has_remotefile(:name => "/etc/ha.d/logd.cf") do
+        #   mode 600
+        #   notify service(:name => "heartbeat")
+        #   template File.join(File.dirname(__FILE__), "..", "templates/logd.cf")
+        # end
+        # 
+        # has_exec(:name => "heartbeat-update-cib", :command => "/usr/sbin/cibadmin -R -x /etc/ha.d/cib.xml", :refreshonly => true)
+        #     
+        # has_remotefile(:name => "/etc/ha.d/authkeys") do
+        #   mode 600
+        #   notify service(:name => "heartbeat")
+        #   template File.join(File.dirname(__FILE__), "..", "templates/authkeys")
+        # end
+        #     
+        # has_remotefile(:name => "/etc/ha.d/cib.xml") do
+        #   mode 444
+        #   notify exec(:name => "heartbeat-update-cib")
+        #   template File.join(File.dirname(__FILE__), "..", "templates/cib.xml")
+        # end
+        # 
+        # has_remotefile(:name => "/etc/ha.d/haresources") do
+        #   mode 644
+        #   template File.join(File.dirname(__FILE__), "..", "templates/haresources")
+        # end
+        # # end
+        # 
+        # # variables for the templates
+        # has_variable(:name => "ha_nodenames", :value => "generate('/usr/bin/env', '/usr/bin/server-list-active', '-c', 'name', '-n', '#{cloud.name}')")
+        # has_variable(:name => "ha_node_ips",  :value => "generate('/usr/bin/env', '/usr/bin/server-list-active', '-c', 'ip', '-n', '#{cloud.name}')")
+        # 
+        # has_variable({:name => "ha_timeout",  :value => (self.respond_to?(:timeout) ? timeout : "5s")})
+        # has_variable({:name => "ha_port", :value => (self.respond_to?(:port) ? port : Default.port)})
+          
+      end
+
+    end  
+  end
+end

data/lib/poolparty/base_packages/poolparty.rb

@@ -0,0 +1,14 @@
+module PoolParty
+  class Base
+    plugin :poolparty_base_packages do
+      
+      def enable
+        has_cron "/usr/bin/server-manage-election" do
+          minute "0,5,10,15,20,25,30,35,40,45,50,55"
+          command "/usr/bin/server-manage-election"
+        end
+      end
+      
+    end
+  end
+end

data/lib/poolparty/base_packages/ruby.rb

@@ -0,0 +1,42 @@
+module PoolParty
+  class Base
+    plugin :poolparty_base_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_line_in_file(:line => "export PATH=$PATH:/var/lib/gems/1.8/bin", :file => "/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/base_packages/runit.rb

@@ -0,0 +1,21 @@
+=begin rdoc
+  Runit beginning
+  NOT IMPLEMENTED YET
+=end
+module PoolParty
+  class Base
+    plugin :poolparty_base_runit do
+      
+      def enable
+        unless enabled
+          has_file(:name => "inittab", :path => "/etc/inittab", :mode => 0644, :owner => "root", :group => "root")
+          has_package(:name => "runit", :ensures => "latest", :requires => get_file("inittab"))
+          has_exec(:name => "/sbin/start runsvdir", :cwd => "/var/service")
+          # has_remotefile(:name => "/etc/event.d/runsvdir", :notify => get_exec("/sbin/start runsvdir"))
+          enabled true
+        end          
+      end
+      
+    end
+  end
+end

data/lib/poolparty/capistrano/cloud_tasks.rb

@@ -0,0 +1,10 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace(:cloud_tasks) do    
+    desc "List running clouds"
+    task :list do
+      cmd = "cloud-list -n #{cloud.name}"
+      puts cmd
+      # %x[cmd]
+    end
+  end
+end

data/lib/poolparty/capistrano.rb

@@ -0,0 +1,54 @@
+$:.unshift(File.join(File.dirname(__FILE__)))
+require "poolparty"
+require "poolpartycl"
+
+module PoolParty
+  module Capistrano
+    
+    $cap_clouds = {}
+    
+    def set_poolparty_file(file)
+      load_pool file
+    end
+    
+    def set_cloud(name)
+      cld = PoolParty::Cloud.cloud(name)
+      if cld && !cloud_retrieved_already?
+        $cap_clouds[name] = cld
+        @cloud = cld
+        instance_eval <<-EOE
+  ssh_options[:keys] = [ '#{cld.full_keypair_path}' ]
+  set :user, '#{cld.user}'
+  set :username, "#{cld.user}"
+  ssh_options[:forward_agent] = true
+  EOE
+      end
+      cld
+    end
+    
+    def cloud_retrieved_already?
+      $cap_clouds.key?(name)
+    end
+    def get_cloud(name)
+      set_cloud(name)
+    end
+    
+    # Get the master ip for the cloud to set in the deploy.rb file
+    def cloud_master(name)
+      get_cloud(name).ip
+    end
+    
+    def set_role_for_all_instances(role, name)
+      ips = get_cloud(name).list_of_running_instances.map {|ri| ri.ip }
+      ips.each {|ip| send :role, role.to_sym, "#{ip}"}
+    end
+  end
+end
+
+module Capistrano
+  class Configuration
+    include ::PoolParty::Capistrano
+        
+    # Dir["#{::File.dirname(__FILE__)}/capistrano/*.rb"].each {|f| pload f }
+  end
+end

data/lib/poolparty/config/postlaunchmessage.txt

@@ -0,0 +1,5 @@
+Your cloud is launching
+-----------------------
+Your master's ip address is: :master_ip
+
+Depending on how your cloud is setup, this process may take a while.

data/lib/poolparty/core/array.rb

@@ -0,0 +1,36 @@
+=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(pre="")
+    map {|a| a.to_string(pre)}.join("\n")
+  end
+  def get_named(str="")
+    map {|a| a.name == str ? a : nil }.reject {|a| a.nil? }
+  end
+  def respec_string(ns=[])
+    "'#{map {|e| e.to_option_string }.join("', '")}'"
+  end
+  # Example  nodes.select_with_hash(:status=>'running')
+  def select_with_hash(conditions={})
+    select do |node|
+      conditions.any? do |k,v| 
+        ( node.has_key?(k) && node[k]==v ) or ( node.respond_to?(k) && node.send(k)==v )
+      end
+    end
+  end
+    
+end

data/lib/poolparty/core/class.rb

@@ -0,0 +1,26 @@
+# Taken from rspec with high respect. 
+# Mainly unused, for now
+class Class
+  # Creates a new subclass of self, with a name "under" our own name.
+  # Example:
+  #
+  #   x = Foo::Bar.subclass('Zap'){}
+  #   x.name # => Foo::Bar::Zap_1
+  #   x.superclass.name # => Foo::Bar
+  def subclass(base_name, &body)
+    klass = Class.new(self)
+    class_name = "#{base_name}_#{class_count!}"
+    instance_eval do
+      const_set(class_name, klass)
+    end
+    klass.instance_eval(&body)
+    klass
+  end
+
+  private
+  def class_count!
+    @class_count ||= 0
+    @class_count += 1
+    @class_count
+  end
+end

data/lib/poolparty/core/exception.rb

@@ -0,0 +1,10 @@
+=begin rdoc
+  Exception overloads
+=end
+class Exception
+  alias nice_message to_str
+  # Gives us a nice_message for exceptions
+  def nice_message(padding="")
+    "#{padding}#{message}\n#{padding}"# + backtrace.join("\n#{padding}")
+  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,71 @@
+=begin rdoc
+  Hash extentions
+=end
+class Hash
+  def choose(&block)
+    Hash[*self.select(&block).inject([]){|res,(k,v)| res << k << v}]    
+  end
+
+  def to_instance_variables(inst=nil)
+    each do |k,v|
+      inst.instance_variable_set "@#{k}", v
+      inst.class.send :attr_reader, k if inst
+    end
+  end
+  
+  # extracted from activesupport
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  def values_at(*indices)
+    indices.collect {|key| self[key]}
+  end
+  
+  #TODO: deprecate
+  # def extract!(&block)
+  #   o = Hash[*select(&block).flatten]
+  #   o.keys.each {|k| self.delete(k) }
+  #   o
+  # end
+  def append(other_hash)
+    returning Hash.new do |h|
+      h.merge!(self)
+      other_hash.each do |k,v|
+        h[k] = has_key?(k) ? [self[k], v].flatten.uniq : v
+      end
+    end
+  end
+  def append!(other_hash)
+    other_hash.each do |k,v|
+      self[k] = has_key?(k) ? [self[k], v].flatten.uniq : v
+    end
+    self
+  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 to_os
+    m={}
+    each {|k,v| m[k] = v.to_os }
+    MyOpenStruct.new(m)
+  end
+  def method_missing(sym, *args, &block)
+    if has_key?(sym)
+      fetch(sym)
+    elsif has_key?(sym.to_s)
+      fetch(sym.to_s)
+    else
+      super
+    end
+  end
+  def next_sorted_key(from)
+    idx = (size - keys.sort.index(from))
+    keys.sort[idx - 1]
+  end
+end

data/lib/poolparty/core/kernel.rb

@@ -0,0 +1,66 @@
+=begin rdoc
+  Kernel overloads
+=end
+
+module Kernel
+  def get_latest_caller
+    returning Array.new do |arr|
+      callstack.size.times {|i| arr << callstack[i][0] unless callstack[i][0] =~ /lib\/poolparty/ }
+    end.first
+  end
+  def callstack( level = 1 )
+    call_str_array = caller(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
+  # 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 with_warnings_suppressed
+    saved_verbosity = $-v
+    $-v = nil
+    yield
+  ensure
+    $-v = saved_verbosity
+  end
+  
+  def capture_stdout(&block)
+     old_stdout = $stdout
+     out = StringIO.new
+     $stdout = out
+     begin
+        block.call if block
+     ensure
+        $stdout = old_stdout
+     end
+     out.string
+  end
+
+  #redirect stdout and stderr to /dev/null and reopen after block
+  def hide_output
+    begin
+      old_stdout = STDOUT.dup
+      old_stderr = STDERR.dup
+      STDOUT.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+      STDERR.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+      yield if block_given?
+    ensure
+      STDOUT.flush
+      STDOUT.reopen(old_stdout)
+      STDERR.flush
+      STDERR.reopen(old_stderr)
+    end
+  end
+
+end

data/lib/poolparty/core/metaid.rb

@@ -0,0 +1,15 @@
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end