auser-poolparty 1.2.12 → 1.3.0

data/examples/maize.rb

@@ -1,37 +0,0 @@
-# Basic poolparty template
-
-pool :clouds do
-  cloud :app do
-    instances 1..3
-    # keypair "#{ENV['HOME']}/ec2/ec2-keypair.pem" # or the full path to the keypair on the development machine
-    ami 'ami-7cfd1a15'
-    using :vmrun do
-      vmx_hash({
-        "/Users/alerner/Documents/vm/Ubuntu32bitVM.vmwarevm/Ubuntu32bitVM.vmx" => "192.168.248.133"
-      })
-    end
-    
-    # directories
-    has_directory "/var/www"
-
-    # packages
-    has_package(:name => "logwatch")
-    has_package(:name => "imagemagick")
-    has_package(:name => "libmagick9-dev")
-    has_package(:name => "librmagick-ruby")
-    has_package(:name => "ffmpeg")
-    has_package(:name => "monit")
-
-    # gems
-    has_gem_package(:name => "rmagick")
-    has_gem_package(:name => "rubyist-aasm")
-    has_gem_package(:name => "rvideo")
-    has_gem_package(:name => "right_aws")
-    has_gem_package(:name => "ap4r")
-    has_gem_package(:name => "rmagick")
-    
-    # services
-    has_service(:name => "monit")
-  end
-
-end

data/examples/metavirt_cloud.rb

@@ -1,33 +0,0 @@
-require 'rubygems'
-$:.unshift File.dirname(__FILE__)+'/../lib/'
-require "poolparty"
-
-pool :multiverse do
-  
-  cloud :front do
-    instances 2..4
-    keypair 'multiverse_front'
-    has_file "/etc/motd", :content => "Welcome to your poolparty instance!"
-    using :metavirt do
-      server_config({:host=>"192.168.1.97", :port=>3000})
-      authorized_keys 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCTppECfx7Tb0zoviRfqFaePyAek6+ZktKkHiTHu/jkhG1s4q1oHEe89no21xLxuReyJrDlNe8rLxxZzoYCaAWRdhcqMR3BNqb2w2jpF4pH+bFj0557KrwWP6HSNpRRkyYhxLqZbuH/2t3TzkPevZbcfSYa09jIzqnmTruh9l1s+n5E3cNr/RDdDn7tv3Ok7mKN7GEjkK7F83Pt9xviHevg22xqzm99nS+hg6Kl/fQUTO6pOmC5x+9V47RJz1+9WdhGJ7M83zijX9rMnAwrR5LFoL6aZyyU0G71SpoIL5e8XD/jt1WNKFJOfG8YMLb3i03UABm/Q5Q30+R7UoRxSWRX'
-
-      # using :vmrun do
-      #   # vmx_files Dir[::File.expand_path("~/Documents/Virtual Machines.localized/metavirts/*/*.vmx")]
-      #   vmx_files [
-      #     "/Users/alerner/Documents/vm/Ubuntu32bitVM.vmwarevm/Ubuntu32bitVM.vmx"
-      #     ]
-      # end
-      
-      using :libvirt do
-        image_id 'mvi_ef77fdf0'
-        # memory 256000
-        # cpus 1
-        # network 'vnet0'
-      end
-      
-    end
-  end
-  
-end
-

data/examples/paparazzi.conf.erb

@@ -1,21 +0,0 @@
-<VirtualHost *:80>
-  ServerName <%= @params[:server_name] %>
-  ServerAlias <% @params[:server_aliases].each do |a| %><%= "#{a}" %> <% end %>
-  DocumentRoot <%= @params[:docroot] %>
-
-  RailsBaseURI /
-  RailsEnv <%= @params[:rails_env] %>
-  RailsAllowModRewrite on
-  PassengerMaxPoolSize <%= @node[:rails][:max_pool_size] %>
-
-  <Directory <%= @params[:docroot] %>>
-    Options FollowSymLinks
-    AllowOverride None
-    Order allow,deny
-    Allow from all
-  </Directory>
-
-  LogLevel info
-  ErrorLog <%= @node[:apache][:log_dir] %>/<%= @params[:name] %>-error.log
-  CustomLog <%= @node[:apache][:log_dir] %>/<%= @params[:name] %>-access.log combined
-</VirtualHost>

data/examples/plugin_without_plugin_directory.rb

@@ -1,12 +0,0 @@
-pool :app do
-  require File.dirname(__FILE__) + "/pool/test_plugins/webserver"
-  
-  instances 2..10
-  
-  cloud :app do
-    apache do
-      enable_php
-    end    
-  end
-  
-end

data/examples/vmrun_cloud.rb

@@ -1,17 +0,0 @@
-require 'rubygems'
-$:.unshift File.dirname(__FILE__)+'/../lib/'
-require "poolparty"
-
-pool :multiverse do
-  
-  cloud :vv do
-    keypair "front"
-    instances 1
-    has_file "/etc/motd", :content => "Welcome to your poolparty instance!"
-    using :vmrun do
-      vmx_hash "/Users/stimble/Documents/Virtual Machines.localized/Jaunty.vmwarevm/Jaunty.vmx" => '172.16.68.143'
-    end
-  end
-  
-end
-

data/generators/poolspec/USAGE

@@ -1,5 +0,0 @@
-Description:
-  Create a basic pool template
-  
-Usage:
-  pool generate [name]

data/generators/poolspec/poolspec_generator.rb

@@ -1,58 +0,0 @@
-class PoolspecGenerator < RubiGen::Base
-
-  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
-                              Config::CONFIG['ruby_install_name'])
-
-  default_options :author => nil
-
-  attr_reader :name
-
-  def initialize(runtime_args, runtime_options = {})
-    super
-    usage if args.empty?
-    @destination_root = File.expand_path(args.shift)
-    @name = base_name
-    extract_options
-  end
-
-  def manifest
-    record do |m|
-      # Ensure appropriate folder(s) exists
-      m.directory ''
-      BASEDIRS.each { |path| m.directory path }
-      
-      m.template "pool_spec_template.erb", "clouds.rb"
-      # Create stubs
-      # m.template "template.rb",  "some_file_after_erb.rb"
-      # m.template_copy_each ["template.rb", "template2.rb"]
-      # m.file     "file",         "some_file_copied"
-      # m.file_copy_each ["path/to/file", "path/to/file2"]
-    end
-  end
-
-  protected
-    def add_options!(opts)
-      opts.separator ''
-      opts.separator 'Options:'
-      # For each option below, place the default
-      # at the top of the file next to "default_options"
-      # opts.on("-a", "--author=\"Your Name\"", String,
-      #         "Some comment about this option",
-      #         "Default: none") { |options[:author]| }
-      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
-    end
-
-    def extract_options
-      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
-      # Templates can access these value via the attr_reader-generated methods, but not the
-      # raw instance variable value.
-      # @author = options[:author]
-      @pool_name = ARGV.pop
-    end
-
-    # Installation skeleton.  Intermediate directories are automatically
-    # created so don't sweat their absence here.
-    BASEDIRS = %w(
-      plugins
-    )
-end

data/generators/poolspec/templates/pool_spec_template.erb

@@ -1,9 +0,0 @@
-# Basic poolparty template
-
-pool :<%= name -%> do
-  
-  cloud :app do
-    instances 2..5
-  end
-
-end

data/lib/poolparty/aska.rb

@@ -1,144 +0,0 @@
-=begin rdoc
-  Aska
-  
-  A rule parser.
-  
-  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    
-  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/core/array.rb

@@ -1,60 +0,0 @@
-=begin rdoc
-  Array extensions
-=end
-require "enumerator"
-class Array
-  def to_os
-    map {|a| a.to_os }
-  end
-  
-  def histogram
-    out = {}
-    map do |ele|
-      if out.has_key?(ele)
-        out[ele] += 1
-      else
-        out.merge!(ele => 1)
-      end
-    end
-    out
-  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={})
-    return self if conditions.empty?
-    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
-  
-  def wrapping_next(id)
-    raise "Element #{id} not in array" unless index(id)
-    index(id) >= size-1 ? at(0) : at(index(id)+1)
-  end
-    
-end

data/lib/poolparty/core/class.rb

@@ -1,26 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-=begin rdoc
-  Exception overloads
-=end
-class Exception
-  alias :nice_message :to_s
-  # 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

@@ -1,13 +0,0 @@
-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

@@ -1,139 +0,0 @@
-=begin rdoc
-  Hash extentions
-=end
-class Hash
-  
-  # alias_method :_old_reader, :[]
-  # # Treat string and symbols the same
-  # def [](key)
-  #   if o = _old_reader(key) || has_key?(key)
-  #     return o 
-  #   elsif key.is_a? Symbol
-  #     _old_reader(key.to_s)
-  #   elsif key.is_a? String
-  #     _old_reader(key.to_sym) rescue _old_reader(key)
-  #   else
-  #     _old_reader(key)
-  #   end
-  # end
-  
-  # Return a hash of all the elements where the block evaluates to true
-  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 next_sorted_key(from)
-    idx = (size - keys.sort.index(from))
-    keys.sort[idx - 1]
-  end
-  
-  def stringify_keys
-    dup.stringify_keys!
-  end
-  
-  # Converts all of the keys to strings
-  def stringify_keys!
-    keys.each{|k| 
-      v = delete(k)
-      self[k.to_s] = v
-      v.stringify_keys! if v.is_a?(Hash)
-      v.each{|p| p.stringify_keys! if p.is_a?(Hash)} if v.is_a?(Array)
-    }
-    self
-  end
-  
-  def symbolize_keys(key_modifier=nil)
-    dup.symbolize_keys!(key_modifier)
-  end
-  
-  # Converts all of the keys to strings
-  # can pass in a :key_modifier that will be sent to each key, before being symbolized.
-  # This can be usefull if you want to downcase, or snake_case each key.
-  # >> {'Placement' => {'AvailabilityZone'=>"us-east-1a"} }.symbolize_keys(:snake_case)
-  # => {:placement=>{:availability_zone=>"us-east-1a"}}  
-  def symbolize_keys!(key_modifier=nil) 
-    keys.each{|k| 
-      v = delete(k)
-      if key_modifier && k.respond_to?(key_modifier)
-        k = k.send(key_modifier)
-      end
-      self[k.to_sym] = v
-      v.symbolize_keys!(key_modifier) if v.is_a?(Hash)
-      v.each{|p| p.symbolize_keys!(key_modifier) if p.is_a?(Hash)} if v.is_a?(Array)
-    }
-    self
-  end
-  
-  def to_cloud
-    $:.unshift("#{::File.dirname(__FILE__)}/../../poolparty")
-    require "poolparty"
-    cld = Cloud.new((fetch(:name) rescue "hashed_cloud"))
-    cld.set_vars_from_options(self)
-    cld
-  end
-  
-  def method_missing(sym, *args, &block)
-    if has_key?(sym.to_sym)
-      fetch(sym)
-    elsif has_key?(sym.to_s)
-      fetch(sym.to_s)
-    else
-      super
-    end
-  end  
-end

data/lib/poolparty/core/integer.rb

@@ -1,11 +0,0 @@
-class Integer
-  def months
-    PoolParty::Duration.new(self * 30.days, [[:months, self]])
-  end
-  alias :month :months
-
-  def years
-    PoolParty::Duration.new(self * 365.25.days, [[:years, self]])
-  end
-  alias :year :years
-end

data/lib/poolparty/core/kernel.rb

@@ -1,66 +0,0 @@
-=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/my_open_struct.rb

@@ -1,18 +0,0 @@
-=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