auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/installers/vmrun.rb

@@ -1,144 +0,0 @@
-module PoolParty
-  module Installers
-    class Vmrun < BaseInstaller
-      
-      def commands
-        [
-          :get_vmrun_file, :get_vm_ip, :get_key,
-          :add_vmware_fusion_to_path, :start_vmrun_instance,
-          :wait_for_connection, :scp_key, :test_login, :fix_eth0,
-          :shutdown_vmrun_instance
-        ]
-      end
-      
-      private
-      
-      def get_vmrun_file
-        if !default_vmrun_files.empty?
-          show_menu_for_vmrun_files
-        else
-          ask_for_vmrun_path
-        end
-      end
-      
-      def show_menu_for_vmrun_files
-        say "We found the following vmware files in the default vmware directory.\nChoose one of these to use as your vmrun file or select other"
-        choose do |menu|
-          menu.prompt = "Vmware file > "
-          [default_vmrun_files, :other].flatten.each do |base|
-            menu.choice base do 
-              
-              @vmrun_file = base == :other ? ask_for_vmrun_path : base
-            end
-          end
-        end
-      end
-      
-      def ask_for_vmrun_path
-        vmrun_file_help =<<-EOV
-Vmware uses a vmwarevm file to keep information about the vmware instance. To find the vmwarevm file, 
-navigate to vmware and find the vm you'd like to use. Find this in finder and paste that here.
-        EOV
-
-        vmrun_file = <<-EOE
-Awesome. What's the path to your vmwarevm file?
-        EOE
-        ask_with_help :message => vmrun_file, :help => vmrun_file_help do |t|
-          @vmrun_file = default_vmrun_file if t.nil? || t.empty?
-        end
-      end
-      
-      def get_vm_ip
-        ip_help =<<-EOV
-Right now, vmrun, the remoter base needs an explicitly set ip. Log into your vm and type ifconfig. Copy and paste that here.
-        EOV
-        ask_with_help :message => "Now, what's the ip of your vm?",
-                      :validate => /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|h|H/,
-                      :help => ip_help do |i|
-          @ip = i
-        end
-      end
-      
-      def get_key
-        key_help =<<-EOV
-Finally, we'll set somethings up here shortly, but first we'll need to know where your public key is. We'll assume it's 
-at ~/.ssh/id_rsa.pub. If this is true, then just press enter. Otherwise, enter the path of your public key.        
-        EOV
-        
-        ask_with_help :message => "What keypair would you like to use? (default: ~/.ssh/id_rsa.pub)",
-                      :help => key_help do |k|
-          @key = k.empty? ? ::File.expand_path("~/.ssh/id_rsa.pub") : k
-        end
-      end
-      
-      def wait_for_connection
-        ping_port_and(@ip, 22) do
-          puts "Instance available for connection"
-        end
-      end
-      
-      def scp_key
-        colored_say "Sending key to vmware instance..."
-        o = %x{scp #{@key} root@#{@ip}:~/.ssh/authorized_keys}
-        sleep 2
-      end
-      
-      def test_login
-        raise "Could not connect to #{@ip}. Check to make sure you set the ip properly" unless ping_port(@ip, 22, 3)
-      end
-      
-      # TODO: Fix this
-      def fix_eth0    
-      end
-      
-      def add_vmware_fusion_to_path
-        colored_say "Exporting path with the VMware Fusion. You will want to add this to your path by adding \n\texport PATH=/Library/Application Support/VMware Fusion:$PATH\n to your .profile or .bashrc file"
-        o = %x{export PATH=/Library/Application\\\ Support/VMware\\\ Fusion:$PATH}
-        sleep 2
-      end
-      
-      def start_vmrun_instance
-        vmrun_path = `which vmrun`.chomp!
-        command = "#{vmrun_path.path_quote} start #{@vmrun_file.path_quote}"
-        %x{#{command}}
-      end
-      
-      def shutdown_vmrun_instance
-        vmrun_path = `which vmrun`.chomp!
-        command = "#{vmrun_path.path_quote} stop #{@vmrun_file.path_quote}"
-        %x{#{command}}
-      end
-      
-      def closing_message
-        vmx_file = Dir["#{@vmrun_file}/*.vmx"].first
-          clds =<<-EOC
-pool :my_pool do
-  cloud :my_app do
-    using :vmrun do
-      vmx_hash({
-        "#{vmx_file}" => "#{@ip}"
-      })
-    end
-
-    has_file "/etc/motd" do
-      content "Welcome to your first PoolParty instance!"
-    end
-  end
-end             
-                EOC
-
-        ::File.open("clouds.rb", "w") {|f| f << clds}
-        super
-      end
-      
-      def default_vmrun_files
-        @default_vmrun_files ||= find_default_vmrun_files rescue nil
-      end
-      
-      def find_default_vmrun_files
-        Dir["#{::File.expand_path("~")}/Documents/Virtual\ Machines.localized/*.vmwarevm"]
-      end
-      
-    end
-  end
-end

data/lib/poolparty/lite.rb

@@ -1,33 +0,0 @@
-require "rubygems"
-require "json"
-begin
-  require "#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify"
-rescue Exception => e
-  require "dslify"
-end
-require "#{::File.dirname(__FILE__)}/core/string"
-require "#{::File.dirname(__FILE__)}/core/hash"
-require "#{::File.dirname(__FILE__)}/core/object"
-require "#{::File.dirname(__FILE__)}/poolparty/default"
-require "#{::File.dirname(__FILE__)}/modules/user_helpers"
-require "#{::File.dirname(__FILE__)}/modules/cloud_resourcer"
-require "#{::File.dirname(__FILE__)}/modules/pinger"
-require "#{::File.dirname(__FILE__)}/schema"
-require "#{::File.dirname(__FILE__)}/net/init"
-require "#{::File.dirname(__FILE__)}/poolparty/neighborhoods"
-require "#{::File.dirname(__FILE__)}/exceptions/RemoteException.rb"
-
-module PoolParty
-  extend ::PoolParty::Remote
-  
-  def self.load_cloud_from_json(json_file_path=nil)
-    json_file = json_file_path || PoolParty::Default.properties_hash_file
-    PoolParty::Schema.new( ::File.read(json_file) ) rescue exit 1
-  end  
-end
-
-class String
-  def camelcase
-    gsub(/(^|_|-)(.)/) { $2.upcase }
-  end
-end

data/lib/poolparty/modules/callbacks.rb

@@ -1,57 +0,0 @@
-module PoolParty
-  module Callbacks
-    module ClassMethods
-      def additional_callbacks(arr=[])
-        @additional_callbacks ||= arr
-      end
-    end
-    
-    module InstanceMethods
-      def defined_callbacks
-        [
-          :before_bootstrap,
-          :after_bootstrap,
-          :before_provision,
-          :after_provision,
-          :before_configure,
-          :after_configure,
-          :after_create,
-          # TODO: Add after_launch_instance and after_terminate_instance
-          :after_launch_instance,
-          # :after_terminate_instance,
-          self.class.additional_callbacks
-        ].flatten
-      end
-      
-      # Callbacks on bootstrap and configuration
-      # Defines the callback accessors:
-      #   call_before/after_bootstrap/configure_callbacks
-      # 
-      # When called, this method will first check to see if there 
-      # are plugins and call those plugin's callbacks when called
-      # The method (before/after_bootstrap/configure) is called
-      # on self if the callback method is defined on self
-      def setup_callbacks
-        defined_callbacks.each do |meth|
-          unless respond_to?("call_#{meth}_callbacks".to_sym)
-            self.class.module_eval <<-EOE
-              def call_#{meth}_callbacks(*args)
-                if respond_to?(:plugin_store) && plugin_store
-                  plugin_store.each do |a| 
-                    a.call_#{meth}_callbacks(*args) if a.respond_to?(:call_#{meth}_callbacks)
-                  end
-                end
-                self.send :#{meth}, *args if respond_to?(:#{meth})
-              end
-            EOE
-          end
-        end
-      end
-    end
-    
-    def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods      
-    end
-  end
-end

data/lib/poolparty/modules/cloud_dsl.rb

@@ -1,38 +0,0 @@
-module PoolParty
-  module CloudDsl
-    
-    # TODO: Add to ec2 remoter_base
-    # def mount_ebs_volume_at(id="", loc="/data")
-    #   ebs_volume_id id
-    #   ebs_volume_mount_point loc
-    #   ebs_volume_device "/dev/#{id.sanitize}"
-    #         
-    #   has_mount(:name => loc, :device => ebs_volume_device)
-    #   has_directory(:name => loc)
-    # end
-    
-    # Enable a service package
-    def enable(*services)
-      services.each do |service|
-        dsl_options[service] = :enabled
-      end
-    end
-    # Disable a service package
-    def disable(*services)
-      services.each do |service|
-        dsl_options[service] = :disabled
-      end
-    end
-    
-    # Check to see if the package has been enabled
-    def enabled?(srv);dsl_options.has_key?(srv) && dsl_options[srv] == :enabled;end
-    
-    # All services that are :enabled and have a plugin that corresponds, call on the cloud
-    def add_optional_enabled_services
-      dsl_options.each do |k,v|
-        self.send k if enabled?(k) && respond_to?(k)
-      end
-    end
-    
-  end
-end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -1,110 +0,0 @@
-=begin rdoc
-  CloudResourcer provides the cloud with convenience methods
-  that you can call on your cloud. This is where the 
-  
-    instances 2..10
-    
-  method is stored, for instance. It's also where the key convenience methods are written
-=end
-require "fileutils"
-
-module PoolParty
-  module CloudResourcer
-    
-    def plugin_directory(arr=[])
-      arr = [arr] if arr.is_a?(String)
-      arr << [
-        "#{::File.expand_path(Dir.pwd)}/plugins",
-        "#{::File.expand_path(Default.poolparty_home_path)}/plugins"
-      ]
-      arr.flatten.each {|arg|    
-        Dir["#{arg}/*/*.rb"].each {|f| require f } if ::File.directory?(arg)
-      }
-    end
-    
-    # Store block
-    def store_block(&block)
-      @stored_block ||= block ? block : nil
-    end
-    
-    def stored_block
-      @stored_block
-    end
-    
-    # This will run the blocks after they are stored if there is a block
-    # associated
-    def run_stored_block
-      self.run_in_context @stored_block if @stored_block
-    end
-    
-    # Set instances with a range or a number
-    # if passed with a hash, call nodes(hash) to return filtered list of 
-    # instances
-    def instances(arg)
-      case arg
-      when Range
-        minimum_instances arg.first
-        maximum_instances arg.last
-      when Fixnum
-        minimum_instances arg
-        maximum_instances arg
-      when Hash
-        nodes(arg)
-      else
-        raise SpecException.new("Don't know how to handle instances cloud input #{arg}")
-      end
-    end
-    
-    # Declare the remoter base
-    # Check to make sure the available_bases is available, otherwise raise
-    # Give access to the cloud the remote_base and instantiate a new
-    # instance of the remote base
-    def using(t, o={}, &block)
-      return self.send(t) if self.respond_to?(t)
-      klass_string = "::PoolParty::Remote::#{t.to_s.camelcase}"
-      remote_base_klass = klass_string.constantize
-      if ::PoolParty::Remote.available.include?(remote_base_klass)
-        set_default_options(remote_base_klass.default_options)
-        @remote_base = remote_base_klass.send(:new, o.merge(:cloud=>self), &block)
-        self.remoter_base t.to_sym
-        instance_eval "def #{t};@remote_base;end"
-        
-        # instance_eval "def launch_new_instance!(o={}); remote_base.launch_new_instance!;end"
-        # instance_eval "def terminate_instance!(o={}); remote_base.terminate_instance!(o);end"
-        # instance_eval "def describe_instances(o={}); remote_base.describe_instances;end"
-        # instance_eval "def describe_instance(o={}); remote_base.describe_instance(o);end"
-      else
-        raise "Unknown remote base: #{t}"
-      end
-    end
-    
-    def dependency_resolver(name=nil)
-      if !name.nil?
-        ext = name=~/Resolver$/  ? nil : 'Resolver'
-        klass = ::PoolParty.module_eval("#{name.camelcase}#{ext}")
-        raise DependencyResolverException.new("Unknown resolver") unless klass
-        dsl_options[:dependency_resolver] = "#{name.camelcase}#{ext}"
-        @dependency_resolver = klass
-      else
-        @dependency_resolver
-      end
-    end
-        
-    # def update_from_schema(schema)
-    #   self.dsl_options.merge! schema.options.to_hash
-    #   self.dependency_resolver = schema.options.dependency_resolver.split("::")[-1].gsub(/Resolver/, '').preserved_class_constant("Resolver") rescue PoolParty::Chef
-    #   keypair schema.options.keypair_name
-    #   remote_base_class = PoolParty::Remote.module_eval( schema.options.remoter_base.camelcase )
-    #   self.remote_base = remote_base_class.new  schema.options.remote_base.to_hash
-    #   
-    #   # self.keypair = PoolParty::Key.new schema.options.keypair.basename
-    #   # keypair = schema.options.delete(:keypairs).map {|a| PoolParty::Key.new(a.basename) }
-    #   # options.merge! schema.options.to_hash
-    #   # dsl_options[:keypairs] = keypairs
-    #   # 
-    #   # dsl_options[:dependency_resolver] = schema.options.dependency_resolver.split("::")[-1].gsub(/Resolver/, '').preserved_class_constant("Resolver") rescue PoolParty::Chef
-    #   
-    # end
-    
-  end
-end

data/lib/poolparty/modules/daemonizable.rb

@@ -1,140 +0,0 @@
-# # TODO: Diet
-# module PoolParty      
-#   module Daemonizeable
-#     
-#     attr_accessor :pid_file
-#     
-#     def self.included(base)
-#       base.extend ClassMethods
-#     end
-#     
-#     def pid
-#       @pid ||= File.file?(pid_file) ? open(pid_file).read.to_i : nil
-#     end
-#     
-#     def pid_file
-#       @pid_file ||= "/tmp/poolparty_monitor.pid"
-#     end
-#     
-#     # Returns +true+ the process identied by +pid+ is running.
-#     def running?
-#       return false unless pid
-#       Process.getpgid(pid) != -1
-#     rescue Errno::ESRCH
-#       false
-#     end
-#     
-#     # Turns the current script into a daemon process that detaches from the console.
-#     def daemonize(&block)
-#       raise unless pid_file
-# 
-#       remove_stale_pid_file
-#       
-#       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
-#       
-#       vputs "Daemonizing..."
-#       trap("CHLD") {Process.wait(-1, Process::WNOHANG)}        
-#       @pid = fork do
-#         Signal.trap('HUP', 'IGNORE') # Don't die upon logout
-#         File.open("/dev/null", "r+") do |devnull|
-#           $stdout.reopen(devnull)
-#           $stderr.reopen(devnull)
-#           $stdin.reopen(devnull) unless @use_stdin
-#         end
-#         block.call if block
-#       end
-#       
-#       Dir.chdir(pwd)
-#       
-#       write_pid_file
-#       
-#       trap('HUP') { restart }
-#       at_exit do
-#         remove_pid_file
-#       end
-#       Process.detach(pid)
-#     end
-#     
-#     # Register a proc to be called to restart the server.
-#     def on_restart(&block)
-#       @on_restart = block
-#     end
-#     
-#     # Restart the server.
-#     def restart
-#       raise ArgumentError, "Can't restart, no 'on_restart' proc specified" unless @on_restart
-#       stop
-#       remove_pid_file
-#       @on_restart.call
-#       exit!
-#     end
-#     
-#     module ClassMethods
-#       # Send a QUIT signal the process which PID is stored in +pid_file+.
-#       # If the process is still running after +timeout+, KILL signal is
-#       # sent.
-#       def kill(pid_file, timeout=60)
-#         if pid = send_signal('QUIT', pid_file)
-#           Timeout.timeout(timeout) do
-#             sleep 0.1 while Process.running?(pid)
-#           end
-#         end
-#       rescue Timeout::Error
-#         print "Timeout! "
-#         send_signal('KILL', pid_file)
-#       rescue Interrupt
-#         send_signal('KILL', pid_file)
-#       ensure
-#         puts pid_file
-#         File.delete(pid_file) if File.exists?(pid_file)
-#       end
-#       
-#       # Restart the server by sending HUP signal.
-#       def restart(pid_file)
-#         send_signal('HUP', pid_file)
-#       end
-#       
-#       # Send a +signal+ to the process which PID is stored in +pid_file+.
-#       def send_signal(signal, pid_file)
-#         if File.exist?(pid_file) && pid = open(pid_file).read
-#           pid = pid.to_i
-#           print "Sending #{signal} signal to process #{pid} ... "
-#           Process.kill(signal, pid)
-#           puts
-#           pid
-#         else
-#           puts "Can't stop process, no PID found in #{pid_file}"
-#           nil
-#         end
-#       rescue Errno::ESRCH # No such process
-#         puts "process not found!"
-#         nil
-#       end
-#     end
-#     
-#     protected
-#       def remove_pid_file
-#         File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
-#       end
-#     
-#       def write_pid_file
-#         FileUtils.mkdir_p File.dirname(@pid_file)
-#         open(@pid_file,"w") { |f| f.write(@pid) }
-#         File.chmod(0644, @pid_file)
-#       end
-#       
-#       # If PID file is stale, remove it.
-#       def remove_stale_pid_file
-#         if File.exist?(@pid_file)
-#           if pid && running?
-#             puts "Pid file exists" and raise
-#           else
-#             remove_pid_file
-#           end
-#         end
-#       end
-#   end
-#   class Daemon
-#     include Daemonizeable
-#   end
-# end

data/lib/poolparty/modules/definable_resource.rb

@@ -1,53 +0,0 @@
-module PoolParty
-  module DefinableResource
-    # Define a new resource that can be called like any other resource
-    # Similar to any other resource (like file or exec)
-    # but you define it how you want it to work
-    # Example:
-    # 
-    # define_resource(:line_in_file) do
-    # end
-    # 
-    # Within the block, you can define any methods you want to run as
-    # part of the resource
-    # 
-    # One thing to note is that this is NOT like other resources in the sense
-    # that it does not give you any extra methods like the resources do
-    # 
-    # For example usage, see lib/poolparty/plugins/line.rb
-    def define_resource(name, &block)
-      $stderr.puts "define_resource (#{name}) is depricated (#{caller[0]})"
-      name.to_s.new_resource_class &block
-    end
-    
-    # DEPRICATED
-    # use plugin instead
-    #
-    # Allow us to create virtual resources
-    # Generally, in plugins
-    # This sets a virtual resource against the Resource class
-    # Example:
-    # 
-    # virtual_resource(:virtualhost) do    
-    # end
-    # 
-    # This defines a virtualhost as a virtual resource
-    #  and consequently gives the methods has_virtualhost and does_not_have_virtualhost
-    # 
-    # Note that you can define any resources within the virtual resource
-    # within the definition or the call.
-    # Call example:
-    # has_virtualhost do
-    #  name "xnot.org"
-    # end
-    # 
-    # Which sets the virtual host's name as xnot.org
-    # 
-    # An example is included in the poolparty-apache-plugin
-    def virtual_resource(name=:virtual_resource, opts={}, &block)
-      $stderr.puts "virtual_resource (#{name}) is depricated"
-      plugin(name, &block)
-    end
-    
-  end
-end

data/lib/poolparty/modules/file_writer.rb

@@ -1,95 +0,0 @@
-module PoolParty
-  module FileWriter
-    def copy_file_to_storage_directory(file, preceded="")
-      make_base_directory
-      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
-      ::FileUtils.cp file, path unless file == path || ::File.file?(path)
-    end
-    def cleanup_storage_directory
-      ::FileUtils.rm_rf "#{Default.storage_directory}"
-    end
-    def copy_template_to_storage_directory(file, force=false)
-      make_template_directory
-      path = ::File.join( tmp_path, Default.template_directory, ::File.basename(file) )
-      if force
-        FileUtils.cp file, path
-      else
-        FileUtils.cp file, path unless file == path || ::File.exists?(path)
-      end       
-    end
-    def copy_directory_into_template_storage_directory(dir)
-      path = make_template_directory(dir)
-      Dir["#{dir}/*"].each do |file|
-        FileUtils.cp file, path unless ::File.exists?(::File.join(path, ::File.basename(file)))
-      end
-      ::File.basename(path)
-    end
-    def copy_directory_into_storage_directory(from, pat)
-      to = ::File.join(Default.storage_directory, pat)
-      
-      # make_directory_in_storage_directory(to) unless ::File.directory?(to)
-      FileUtils.cp_r(from, to)
-    end
-    def make_directory_in_storage_directory(dirname="newdir")      
-      path = ::File.join( Default.storage_directory, dirname )
-      make_base_path path
-    end
-    def write_to_file_in_storage_directory(file, str="", preceded="", &block)
-      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
-      write_to_file(path, str, &block)
-    end
-    def write_to_file(file, str="", preceded="", &block)
-      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
-      make_base_path( Default.storage_directory )
-      ::File.open(path, "w+") do |f|
-        f.print str
-        f.flush
-        f.print block.call(f) if block
-      end
-    end
-    # Write a temp file with the content str and return the Tempfile
-    # It creates a random file name
-    def write_to_temp_file(str="", &block)
-      returning Tempfile.new("#{Default.storage_directory}/PoolParty-#{str[0..10].chomp}-#{rand(1000)}") do |fp|
-        fp.print str
-        fp.flush
-        block.call(fp)
-      end
-    end
-    def make_base_path(path)
-      unless FileTest.directory?(path)
-        begin
-          ::FileUtils.rm path if ::File.file?(path)
-          ::FileUtils.mkdir_p path
-        rescue Errno::ENOTDIR
-        rescue Errno::EEXIST
-          puts "There was an error"
-        end
-      end
-    end
-    def make_base_directory
-      begin
-        FileUtils.mkdir_p Default.storage_directory unless ::File.directory?(Default.storage_directory)
-      rescue Errno::EEXIST
-        FileUtils.rm Default.storage_directory
-        make_base_directory
-      end            
-    end
-    def make_template_directory(dir=nil)
-      path = dir ? ::File.join(tmp_path, Default.template_directory, ::File.basename(dir)) : ::File.join(tmp_path, Default.template_directory)
-      begin
-        make_base_directory
-        FileUtils.mkdir path unless ::File.directory?(path)
-      rescue Errno::EEXIST
-        FileUtils.rm path if ::File.exists?(path)
-        make_template_directory(dir)
-      end      
-      path
-    end
-    def clear_base_directory
-      Dir["#{Default.storage_directory}/**/*"].each do |f|
-        ::FileUtils.rm f if ::File.file?(f)
-      end
-    end
-  end
-end

data/lib/poolparty/modules/output.rb

@@ -1,13 +0,0 @@
-module PoolParty
-  module Output
-
-    def output(*args)
-      returning (@output ||= []) do |output|
-        args.each do |line|
-          (output ||= []) << line
-        end
-      end
-    end
-
-  end
-end