poolparty 1.2.2 → 1.3.1

data/lib/poolparty/poolparty/cloud.rb

@@ -1,236 +0,0 @@
-require File.dirname(__FILE__) + "/plugin_model"
-require File.dirname(__FILE__) + "/resource"
-
-module PoolParty    
-  module Cloud
-    # Instantiate a new cloud
-    def cloud(name, &block)
-      clouds[name] ||= Cloud.new(name, &block)
-    end
-
-    # Global hash of clouds
-    def clouds
-      $clouds ||= {}
-    end
-    
-    # TODO: Deprecate
-    def with_cloud(cl, opts={}, &block)
-      raise CloudNotFoundException.new("Cloud not found") unless cl
-      cl.options.merge!(opts) if opts
-      cl.run_in_context &block if block
-    end
-    
-    class Cloud < PoolParty::PoolPartyBaseClass
-      attr_reader :templates, :cloud_name, :remote_base
-
-      include CloudResourcer
-      include PoolParty::PluginModel
-      include PoolParty::Resources
-      include PoolParty::Callbacks
-      include PoolParty::DependencyResolverCloudExtensions
-      include PrettyPrinter
-
-      # Net methods
-      include ::PoolParty::Remote
-      include PoolParty::CloudDsl
-      include PoolParty::Verification
-      # include PoolParty::Monitors
-
-      def verbose
-        true
-      end
-      
-      def self.immutable_methods
-        [:name]
-      end
-      
-      # Redefining methods are not allowed
-      def self.method_added sym        
-        raise "Exception: #{sym.to_s.capitalize} method has been redefined" if immutable_methods.include?(sym) && !respond_to?(sym)
-      end
-      
-      alias :name :cloud_name
-      
-      # Call the remoter commands on the cloud if they don't exist on the cloud itself
-      # This gives the cloud access to the remote_base's methods
-      def method_missing(m, *args, &block)
-        remote_base.respond_to?(m) ? remote_base.send(m, *args, &block) : super
-      end
-      
-      # Default set of options. Most take the Default options from the default class
-      default_options(
-        :expand_when => Default.expand_when,
-        :contract_when => Default.contract_when,
-        :minimum_instances => 2,
-        :maximum_instances => 5,
-        :access_key => Default.access_key,
-        :secret_access_key => Default.secret_access_key,
-        :ec2_dir => ENV["EC2_HOME"],
-        :minimum_runtime => Default.minimum_runtime,
-        :user => Default.user
-      )
-      
-      additional_callbacks [
-        "after_launch_instance"
-      ]
-      
-      # Freeze the cloud_name so we can't modify it at all, set the plugin_directory
-      # call and run instance_eval on the block and then call the after_create callback
-      def initialize(name, &block)
-        @cloud_name = name
-        @cloud_name.freeze
-        
-        plugin_directory "#{pool_specfile ? ::File.dirname(pool_specfile) : Dir.pwd}/plugins"        
-        before_create
-        super
-        after_create
-      end
-      
-      # Fetch the name of the cloud
-      def name(*args)
-        @cloud_name ||= @cloud_name ? @cloud_name : (args.empty? ? :default_cloud : args.first)
-      end
-      
-      def before_create     
-        context_stack.push self
-        (parent ? parent : self).add_poolparty_base_requirements
-        context_stack.pop
-      end
-      
-      # Callback
-      # called after the cloud has been created, everything has run and is set at this point
-      # here the base requirements are added as well as an empty chef recipe is called
-      # Also, the after_create hook on the plugins used by the cloud are called here
-      def after_create
-        ::FileUtils.mkdir_p("#{Default.tmp_path}/dr_configure")
-        
-        run_in_context do
-          add_optional_enabled_services
-          chef do
-          end
-        end
-        
-        plugin_store.each {|a| a.call_after_create_callbacks }
-        setup_defaults
-        
-        setup_callbacks
-      end
-      
-      # setup defaults for the cloud
-      def setup_defaults
-        # this can be overridden in the spec, but ec2 is the default
-        using :ec2
-        options[:keypair] ||= keypair rescue nil
-        options[:rules] = {:expand => dsl_options[:expand_when], :contract => dsl_options[:contract_when]}
-        dependency_resolver 'chef'        
-        # enable :haproxy unless dsl_options[:haproxy] == :disabled
-      end
-      
-      def after_launch_instance(inst=nil)
-        remote_base.send :after_launch_instance, inst
-      end
-      
-      # provide list of public ips to get into the cloud
-      def ips
-        nodes(:status => "running").map {|ri| ri.ip }
-      end
-      
-      # TODO: make this be a random ip, since we should not rely on it being the same each time
-      def ip
-        ips.first
-      end
-            
-      # Build the new poolparty manifest
-      # Wrapping all of these requirements into the one 
-      # poolparty class.
-      # 
-      # TODO: Consider the benefits of moving all the manifest
-      # classes to separate files and keeping the containing
-      # references in the include
-      def build_and_store_new_config_file(filepath=nil, force=false)
-        filepath ||= ::File.join(Default.storage_directory, "poolparty.pp")
-        # write_properties_hash if debugging
-        vputs "Building new manifest configuration file (forced: #{force})"
-        manifest = force ? rebuild_manifest : build_manifest
-        ::File.open(filepath, "w") do |file|
-          file << manifest
-        end
-      end
-      
-      # If there is a directory named monitors in the same directory
-      # as the pool specification file is in,
-      # then create a monitors directory in the storage directory
-      # and mirror the two. When PoolParty "boots" up, it scans
-      # the monitors directory for any custom monitors
-      # that are in known locations, these are included
-      def copy_custom_monitors
-        unless Default.custom_monitor_directories.empty?
-          Default.custom_monitor_directories.each do |dir|
-            Dir["#{dir}/*.rb"].each {|f| ::Suitcase::Zipper.add(f, "monitors")}
-          end
-        end
-      end
-
-      #FIXME MOVE TO DEPENDECY RESOL
-      # Configuration files
-      def build_manifest
-        vputs "Building manifest"
-        @build_manifest ||= build_from_existing_file
-        unless @build_manifest          
-          props = to_properties_hash
-          
-          @build_manifest =  options[:dependency_resolver].send(:compile, props, self)
-        end
-        dputs "Finished creating manifest"
-        @build_manifest
-      end
-      
-      # Force rebuilding of the manifest
-      def rebuild_manifest
-        @build_manifest = nil
-        build_manifest
-      end
-      
-      # If the pp already exists, then let's not recreate it
-      # TODO: Abstract
-      def build_from_existing_file
-        ::FileTest.file?("#{Default.base_config_directory}/poolparty.pp") ? open("#{Default.base_config_directory}/poolparty.pp").read : nil
-      end
-      
-      def write_properties_hash(filename=::File.join(Default.tmp_path, Default.properties_hash_filename) )
-        file_path = ::File.dirname(filename)
-        file_name = "#{::File.basename(filename, ::File.extname(filename))}_#{name}#{::File.extname(filename)}"
-        output = to_properties_hash.to_json
-        ::File.open("#{file_path}/#{file_name}", "w") {|f| f.write output }
-        true
-      end
-      
-      # Add all the poolparty requirements here
-      # NOTE: These are written as plugins in the lib/poolparty/base_packages directory
-      # for examples. 
-      # Also note that there is no block associated. This is because we have written
-      # all that is necessary in a method called enable
-      # which is called when there is no block
-      def add_poolparty_base_requirements
-        # poolparty_base_heartbeat
-        poolparty_base_ruby
-        poolparty_base_packages        
-      end
-      
-      # TODO: Deprecate
-      def other_clouds
-        arr = []
-        clouds.each do |name, cl|
-          arr << cl if name != self.name
-        end
-        arr
-      end
-      
-      # Reset the entire cloud
-      def reset!
-        reset_remoter_base!
-        @build_manifest = @describe_instances = @remote_instances_list = nil
-      end            
-    end
-  end 
-end

data/lib/poolparty/poolparty/default.rb

@@ -1,159 +0,0 @@
-=begin rdoc
-  Base
-  This handles user interaction, loading the parameters, etc.
-=end
-require "open-uri"
-require "ftools"
-module PoolParty
-  class Default
-    include Dslify
-    
-    # def self.options
-    default_options(
-      :testing => false,
-      :debugging => false,
-      :minimum_instances => 2,
-      :maximum_instances => 5,
-      :user => "root", # This should change here
-      :base_keypair_path => "#{ENV["HOME"]}/.ec2",
-      :base_ssh_path => "#{ENV["HOME"]}/.ssh",
-      :tmp_path => "/tmp/poolparty",
-      :poolparty_home_path => "#{ENV["HOME"]}/.poolparty",
-      :remote_storage_path => "/var/poolparty",
-      :remote_gem_path => "/var/poolparty/gems",
-      :fileserver_base => "puppet://master/files",
-      :base_config_directory => "/etc/poolparty",
-      :template_directory => "templates",
-      :template_path => "/var/lib/puppet/templates",
-      :module_path => "/etc/puppet/modules/poolparty",
-      :default_specfile_name => "clouds.rb",
-      :properties_hash_filename => "clouds.json",
-      :vendor_path => "#{::File.dirname(__FILE__)}/../../../vendor",
-      :poolparty_src_path => "#{::File.dirname(__FILE__)}/../../..",
-      :port => "80",
-      :forwarding_port => "8080",
-      :monitor_port => 8081,
-      :proxy_mode => "http",
-      :butterfly_port => 8642,
-      :minimum_runtime  => 3000, #50.minutes in seconds
-      :contract_when => "load < 0.25",
-      :expand_when => "load > 0.9"
-    )
-    
-    def options
-      default_options
-    end
-    
-    # Class methods
-    class << self
-      def method_missing(m,*a,&block)
-        default_options.include?(m) ? default_options[m] : super
-      end
-      def options
-        default_options
-      end
-      # Get the access_key
-      def access_key
-        @access_key ||= load_access_keys_from_environment_var || load_keys_from_file[:access_key]
-      end
-      def load_access_keys_from_environment_var
-        [ ENV["AWS_ACCESS_KEY"], ENV["AWS_ACCESS_KEY_ID"]].reject {|a| a.nil? }.first
-      end
-      def secret_access_key
-        @secret_access_key ||= load_secret_access_keys_from_environment_var || load_keys_from_file[:secret_access_key]
-      end
-      def load_secret_access_keys_from_environment_var
-        [ ENV["AWS_SECRET_ACCESS_KEY"] ].reject {|a| a.nil? }.first
-      end
-      def read_keyfile
-        open(get_working_key_file_locations).read
-      end
-      def load_keys_from_file
-        @keys ||= get_working_key_file_locations ? YAML::load( read_keyfile ) : {}
-      end
-      # Store the keys in a yaml format to give the master access
-      # So that the master has access to the files
-      def store_keys_in_file
-        unless access_key.nil? || secret_access_key.nil?
-          write_to_file( key_file_locations.first, YAML::dump({:access_key => access_key, :secret_access_key => secret_access_key}))        
-        end
-      end
-      def store_keys_in_file_for(obj=nil)
-        if obj
-          @access_key = obj.access_key
-          @secret_access_key = obj.secret_access_key
-        end
-        store_keys_in_file
-      end
-      def reset!
-        @keys = nil
-      end
-      
-      # Get the instance first instance file that exists on the system from the expected places
-      # denoted in the local_instances_list_file_locations
-      def get_working_key_file_locations
-        key_file_locations.reject {|f| f unless ::File.file?(f) }.first
-      end
-      # Expected places for the instances.list to be located at on the machine
-      def key_file_locations
-        [
-          ".ppkeys",
-          "#{Default.base_config_directory}/.ppkeys",
-          "#{Default.storage_directory}/ppkeys",          
-          "~/.ppkeys",
-          "ppkeys"
-        ]
-      end
-      def properties_hash_file
-        [
-          Default.base_config_directory,
-          Dir.pwd
-        ].collect do |dir|
-          full_dir = ::File.join(dir, Default.properties_hash_filename)
-          full_dir if ::File.file?(full_dir)
-        end.compact.first || "#{Default.base_config_directory}/#{Default.properties_hash_filename}"
-      end
-      def storage_directory
-        [
-            "/var/poolparty"
-        ].select do |dir|
-          dir if viable_directory?(dir)
-        end.first || ::File.join( "/tmp/poolparty")
-      end
-      def logger_location
-        [
-            "/var/log/poolparty"
-        ].select do |dir|
-          dir if viable_directory?(dir)
-        end.first
-      end
-      # Assume the logs will be at the pool.log location within the 
-      # logger_location set above
-      def pool_logger_location
-        ::File.join(logger_location, "poolparty.log")
-      end
-      def custom_monitor_directories
-        [
-          "/var/poolparty/monitors",
-          "/etc/poolparty/monitors",
-          "#{Dir.pwd}/monitors"
-        ].select {|d| d if viable_directory?(d) }
-      end
-      
-      def custom_modules_directories
-        [
-          "/var/poolparty/modules",
-          "/etc/poolparty/modules",
-          "#{Dir.pwd}/modules"
-        ].select {|d| d if viable_directory?(d) }
-      end
-      # Only return true if the directory we are reading is both readable
-      # and exists
-      def viable_directory?(dir)
-        ::File.directory?(dir) && ::File.readable?(dir)
-      end
-    end
-    #end of class methods
-    
-  end    
-end

data/lib/poolparty/poolparty/key.rb

@@ -1,78 +0,0 @@
-=begin rdoc
-  ssh key used to login to remote instances
-=end
-module PoolParty
-  class Key
-    
-    attr_accessor :filepath
-    
-    # Create a new key that defaults to id_rsa as the name. 
-    def initialize(fpath=nil)
-      @filepath = (fpath.nil? || fpath.empty?) ? "id_rsa" : fpath
-    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 ||= ::File.file?(::File.expand_path(filepath)) ? ::File.expand_path(filepath) : search_in_known_locations
-    end
-    alias :to_s :full_filepath
-    
-    # Basename of the keypair
-    def basename
-      @basename ||= ::File.basename(full_filepath, ::File.extname(full_filepath)) rescue filepath
-    end
-    
-    # Just the filename of the keypair
-    def filename
-      @filename ||= ::File.basename(full_filepath) rescue filepath
-    end
-    
-    # Search for the key in default locations with the entire filepath
-    # if the file exists. If it doesn't exist in the default locations, 
-    # then it returns nil and assumes we it doesn't exist
-    def search_in_known_locations
-      self.class.keypair_paths.each do |path|
-        full_path = ::File.join( ::File.expand_path(path), ::File.basename(filepath))
-        return full_path if ::File.exists?(full_path)
-      end
-      # raise Exception.new("We cannot continue without a keypair. Please define a keypair in your clouds.rb")
-      # TODO: Add raise for keypair
-      nil
-    end
-    
-    # Default locations to search for the key
-    def self.keypair_paths
-      [ 
-        "#{ENV["HOME"]}/.ssh",
-        "#{Default.poolparty_home_path}/keys",
-        PoolParty::Default.base_keypair_path,
-        PoolParty::Default.base_config_directory,
-        PoolParty::Default.base_ssh_path,
-        PoolParty::Default.remote_storage_path,
-        Dir.pwd
-      ]
-    end
-    
-    # Support to add the enumerable each to keys
-    def each
-      yield full_filepath
-    end
-    
-    # Turn the keypair into the a useful json string
-    def to_json
-      "{\"basename\":\"#{basename}\",\"full_filepath\": \"/etc/poolparty/#{filename}\"}"
-    end
-    
-  end
-end

data/lib/poolparty/poolparty/loggable.rb

@@ -1,28 +0,0 @@
-#todo: Deprecate
-# =begin rdoc
-#   A logging class to allow us to log to locations
-# =end
-# class Loggable
-#   def initialize    
-#     self.class.loggers << file_logger
-#     file_logger.level = :info
-#   end
-#   def file_logger
-#     @file_logger ||= Logging.logger( Default.pool_logger_location, logging_opts )
-#   end
-#   def stdout_logger
-#     @stdout_logger ||= Logging.logger(STDOUT, logging_opts.merge({:pattern => "%m\n"}))
-#   end
-#   def logging_opts
-#     {:pattern => "[%d] %-l : %m\n",
-#     :date_pattern => "%Y-%m-%d %H:%M:%S.%s"}
-#   end
-#   %w(info warn debug notice).each do |meth|
-#     define_method(meth.to_sym) do |*args|
-#       self.class.loggers.each {|l| l.send meth.to_sym, args}
-#     end
-#   end
-#   def self.loggers
-#     @loggers ||= []
-#   end
-# end

data/lib/poolparty/poolparty/neighborhoods.rb

@@ -1,102 +0,0 @@
-=begin rdoc
-  Neighborhood
-  
-  Neighborhoods describes the neighborhood that an instance is in.
-  Neighborhoods are instances that are "near" other instances, either by 
-  association of instantiation or through monitor_rack.   
-=end
-require "#{::File.dirname(__FILE__)}/../modules/pinger"
-require "#{::File.dirname(__FILE__)}/../schema"
-
-module PoolParty
-  class Neighborhoods
-    include ::PoolParty::Pinger    
-    attr_reader :schema
-    
-    # Create a neighborhood from a string, array or hash given.
-    def initialize(data)
-      raise Exception.new("You must pass a string or a hash to Neighborhoods") unless data
-      parsed_data = case data
-      when Array
-        {:instances => data.map {|entry| disect(entry) }}
-      when String
-        {:instances => JSON.parse(data)}#.map "#{inst["instance_id"]}\t#{inst["ip"]}"}}
-      when Hash
-        data
-      end
-      @schema = PoolParty::Schema.new(parsed_data)
-      raise Exception.new("No instances found in the Neighborhoods schema") unless @schema.instances
-    end
-    
-    # Get the known instances from the neighborhood.json file on the server
-    def instances
-      @instances ||= @schema.to_hash[:instances] rescue @schema.instances.collect {|line| disect(line) }
-    end
-    
-    # Returns empty if the neighborhood has no instances
-    def empty?
-      instances.empty?
-    end
-    
-    # Get the next node in the hash
-    def next_node(node_hash)
-      return nil if empty?
-      sort.wrapping_next(node_hash)
-    end
-    
-    # Sort the instances by ip string, a very basic sort
-    def sort
-      instances.sort {|a, b| a.ip <=> b.ip}
-    end
-    
-    # Get the instances at the specific index of the neighborhood
-    def [](at)
-      instances[at] if at >= 0 && at < instances.size
-    end
-    
-    def disect(line)
-      case line
-      when String
-        arr = line.split("\t")
-        {:instance_id => arr[0], :ip => arr[1]}
-      else
-        line
-      end
-    end
-    
-    # Run through an enumeration of the instances
-    def each(&block)
-      instances.each &block
-    end
-    
-    # TODO: Make this into something useful
-    def clump(filepath=nil)
-      out = instances.to_json
-      ::File.open(filepath, "w") {|f| f << out } if filepath
-      out
-    end
-    
-    def self.clump(json, filepath=nil)
-      new(json).clump(filepath)
-    end
-    
-    # Load the default neighborhood.json file
-    # If the neighborhood.json file exists in 
-    #   /etc/poolparty/neighborhood.json
-    # then load the neighborhood from the file, otherwise
-    # if there is a butterfly server running locally,
-    # query it for the current neighborhood.
-    # Finally, return an empty set of instances
-    def self.load_default
-      if ::File.file?("/etc/poolparty/neighborhood.json")
-        new( open("/etc/poolparty/neighborhood.json").read )
-      elsif ping_port("127.0.0.1", Default.butterfly_port, 1)# butterfly responding?
-        require "open-uri"
-        new( open("http://127.0.0.1:8642/neighborhood").read )
-      else
-        new("[]")
-      end
-    end
-    
-  end
-end

data/lib/poolparty/poolparty/plugin.rb

@@ -1,71 +0,0 @@
-require "#{::File.dirname(__FILE__)}/service.rb"
-require "#{::File.dirname(__FILE__)}/../provision/boot_strapper.rb"
-
-module PoolParty
-  module Plugin
-        
-    class Plugin < PoolParty::Service
-      include CloudResourcer
-      include PoolParty::DependencyResolverCloudExtensions
-      include PoolParty::Callbacks
-      
-      def initialize(opts={}, prnt=nil, &block)
-        setup_callbacks
-
-        run_in_context do
-          before_load(opts, &block)
-        end
-        
-        block = Proc.new {enable} unless block
-        
-        @opts = (opts.is_a?(Hash) ? opts : {:name => opts})
-        super(opts, &block)
-        
-        run_in_context do
-          loaded @opts, &block
-        end
-                
-        after_create
-      end
-      
-      # Overwrite this method
-      def before_load(o={}, &block)        
-      end
-      def loaded(o={}, &block)
-      end
-      # Callbacks available to plugins
-      def after_create
-      end
-      
-      def enable
-      end
-      def is_plugin?
-        true
-      end
-      def cloud
-        @parent
-      end
-      
-      def bootstrap_gems *gems
-        gems.each do |g|
-          Provision::BootStrapper.gem_list << g unless Provision::BootStrapper.gem_list.include?(g)
-        end
-      end
-      
-      def bootstrap_commands cmds
-        Provision::BootStrapper.class_commands << cmds
-      end
-      
-      def configure_commands cmds
-        Provision::DrConfigure.class_commands << cmds
-      end
-      
-      def self.inherited(subclass)
-        method_name = subclass.to_s.top_level_class.gsub(/pool_party_/, '').gsub(/_class/, '').downcase.to_sym
-        add_has_and_does_not_have_methods_for(method_name)
-      end
-      
-    end
-    
-  end
-end