poolparty 0.0.4 → 0.2.6

data/lib/poolparty/helpers/provisioners/master.rb

@@ -0,0 +1,136 @@
+module PoolParty
+  module Provisioner
+    class Master < ProvisionerBase
+      
+      def initialize(cloud=self, os=:ubuntu)
+        super(cloud.master, cloud, os)
+        @master_ip = cloud.master.ip
+      end
+
+      def valid?
+        !(@cloud.nil? || @cloud.master.nil?)
+      end
+
+      def error
+        raise RemoteException.new(:could_not_install, "Your cloud does not have a master")
+      end
+
+      def install_tasks
+        [
+          install_haproxy,
+          install_heartbeat,
+          create_local_hosts_entry,
+          setup_basic_structure,
+          setup_configs,        
+          setup_fileserver,
+          setup_autosigning,          
+        ] << configure_tasks
+      end
+
+      def configure_tasks
+        [
+          start_puppetmaster,
+          create_local_node,
+          move_templates,
+          create_poolparty_manifest,
+          restart_puppetd
+        ]
+      end
+      
+      # def install_haproxy
+      #   "#{installer_for( "haproxy" )}"
+      # end
+      # 
+      # def install_heartbeat        
+      #   "#{installer_for( "heartbeat-2" )}"
+      # end
+
+      def create_local_hosts_entry
+        <<-EOS
+if [ -z \"$(grep -v '#' /etc/hosts | grep 'master')" ]; then echo '#{@master_ip}           puppet master' >> /etc/hosts; fi
+        EOS
+      end
+
+      def setup_basic_structure
+        <<-EOS
+puppetmasterd --mkusers
+mkdir -p #{Base.remote_storage_path}
+echo "import 'nodes/*.pp'" > /etc/puppet/manifests/site.pp
+echo "import 'classes/*.pp'" >> /etc/puppet/manifests/site.pp
+mkdir -p /etc/puppet/manifests/nodes 
+mkdir -p /etc/puppet/manifests/classes
+mv #{Base.remote_storage_path}/#{Base.tmp_path}/namespaceauth.conf /etc/puppet/namespaceauth.conf
+        EOS
+      end
+
+      def setup_configs
+        <<-EOS
+echo "#{open(File.join(template_directory, "puppet.conf")).read}" > /etc/puppet/puppet.conf
+        EOS
+      end
+
+      def setup_fileserver
+        <<-EOS
+echo "
+[files]
+  path #{Base.remote_storage_path}/#{Base.tmp_path}
+  allow *" > /etc/puppet/fileserver.conf
+mkdir -p /var/poolparty/facts
+mkdir -p /var/poolparty/files
+mkdir -p /etc/poolparty
+        EOS
+      end
+      # Change this eventually for better security supportsetup_fileserver
+      def setup_autosigning
+        <<-EOS
+echo "*" > /etc/puppet/autosign.conf
+        EOS
+      end
+
+      def create_local_node
+        str = <<-EOS
+node default {
+  include poolparty
+}
+        EOS
+         @cloud.list_of_running_instances.each do |ri|
+           str << <<-EOS           
+node "#{ri.name}" inherits default {}
+           EOS
+         end
+"echo '#{str}' > /etc/puppet/manifests/nodes/nodes.pp"
+      end
+
+      def move_templates
+        <<-EOS
+mkdir -p #{Base.template_path}
+mv #{Base.remote_storage_path}/#{Base.template_directory}/* #{Base.template_path}
+        EOS
+      end
+
+      def create_poolparty_manifest
+        <<-EOS
+mv #{Base.remote_storage_path}/#{Base.tmp_path}/poolparty.pp /etc/puppet/manifests/classes/poolparty.pp
+mv #{Base.remote_storage_path}/#{Base.tmp_path}/#{Base.key_file_locations.first} "#{Base.base_config_directory}/.ppkeys"
+mv #{Base.remote_storage_path}/#{Base.tmp_path}/#{Base.default_specfile_name} #{Base.base_config_directory}/#{Base.default_specfile_name}
+mv #{Base.remote_storage_path}/#{Base.tmp_path}/#{@cloud.full_keypair_name} #{@cloud.remote_keypair_path}
+        EOS
+      end
+
+      def start_puppetmaster
+        <<-EOS
+ps aux | grep puppetmasterd | awk '{print $2}' | xargs kill
+rm -rf /etc/puppet/ssl
+puppetmasterd
+        EOS
+      end
+
+      def restart_puppetd
+        <<-EOS
+          puppetd --listen --fqdn=#{@instance.name} --server=master
+          puppetrun --host #{@instance.name}
+        EOS
+      end
+    end
+  end
+end

data/lib/poolparty/helpers/provisioners/slave.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  module Provisioner
+    class Slave < ProvisionerBase
+
+      def install_tasks
+        [ 
+          setup_puppet
+        ] << configure_tasks
+      end
+
+      def configure_tasks
+        [
+          setup_configs,
+          start_puppet
+        ]
+      end
+
+      def setup_puppet
+        <<-EOE
+          puppetd --mkusers
+          if [ -z "$(grep -v '#' /etc/hosts | grep 'master')" ]; then echo "#{master_ip} puppet master" >> /etc/hosts; else echo "host already set"; fi
+          mv #{Base.remote_storage_path}/#{Base.tmp_path}/namespaceauth.conf /etc/puppet/namespaceauth.conf
+        EOE
+      end
+
+      def setup_configs
+        <<-EOS
+          echo "#{open(File.join(template_directory, "puppet.conf")).read}" > /etc/puppet/puppet.conf        
+        EOS
+      end
+
+      def start_puppet
+        <<-EOS
+puppetd --listen --fqdn=#{@instance.name}
+        EOS
+      end
+      
+      def master_ip
+        @cloud.master.ip
+      end
+
+    end
+  end
+end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -0,0 +1,89 @@
+require "ftools"
+
+module PoolParty
+  module CloudResourcer
+    
+    # Store block
+    def store_block(&block)
+      @store_block ||= block
+    end
+    # Set instances with a range
+    def instances(arg)
+      if arg.is_a?(Range)
+        minimum_instances arg.first
+        maximum_instances arg.last
+      end
+    end
+    
+    def full_keypair_path
+      unless keypair_path
+        raise RuntimeException.new("Keypair cannot be found")        
+      else
+        ::File.expand_path(keypair_path)
+      end
+    end
+    
+    def keypair_path
+      keypair_paths.each do |path|
+        possible_keypair_basenames.each do |base|
+          full_path = ::File.join( File.expand_path(path), "#{base}#{keypair}")
+          return full_path if ::File.exists?(full_path)
+        end
+      end
+      return nil
+    end
+    
+    def full_keypair_name
+      keypair_paths.each do |path|
+        possible_keypair_basenames.each do |base|
+          full_path = ::File.join( File.expand_path(path), "#{base}#{keypair}")
+          return "#{base}#{keypair}" if ::File.exists?(full_path)
+        end
+      end
+      return nil
+    end
+    
+    def remote_keypair_path
+      ::File.join( keypair_paths.last, "#{possible_keypair_basenames.first}#{keypair}" )
+    end
+    def new_keypair_path
+      ::File.join( keypair_paths.first, "#{possible_keypair_basenames.first}#{keypair}" )
+    end
+    
+    def possible_keypair_basenames
+      [
+        "id_rsa-",
+        ""
+      ]
+    end
+    
+    def keypair_paths
+      [
+        Base.base_keypair_path,
+        Base.base_config_directory,
+        Base.remote_storage_path
+      ]
+    end
+    
+    # Set the parent on the resource
+    def set_parent(pare, sink_options=true)
+      @parent = pare      
+      # Add self as a service on the parent
+      pare.add_service(self) if pare.respond_to?(:add_service)
+      # Take the options of the parents
+      configure(pare.options) if pare.respond_to?(:options) && sink_options
+    end
+    
+    def number_of_resources
+      arr = resources.map do |n, r|
+        r.size
+      end
+      resources.map {|n,r| r.size}.inject(0){|sum,i| sum+=i}
+    end
+    
+    def parent
+      @parent ||= nil
+    end
+    
+  end
+end

data/lib/poolparty/modules/configurable.rb

@@ -0,0 +1,34 @@
+module PoolParty
+  module Configurable
+    module ClassMethods      
+      def default_options(h={})
+        @default_options ||= h
+      end
+    end
+    
+    module InstanceMethods
+      def options(h={})
+        @options ||= self.class.default_options.merge(h)
+      end
+      
+      def configure(h={})
+        options(h).merge!(h)
+      end
+      
+      def reconfigure(h={})
+        @options = nil
+        options(h)
+      end
+      
+      def set_vars_from_options(opts={})
+        opts.each {|k,v| self.send k.to_sym, v } unless opts.empty?
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+      receiver.send :include, MethodMissingSugar
+    end
+  end
+end

data/lib/poolparty/modules/definable_resource.rb

@@ -0,0 +1,59 @@
+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)
+      symc = "#{name}".classify
+      klass = symc.class_constant(PoolParty::Resources::CustomResource, {:preserve => true}, &block)
+      PoolParty::Resources.module_eval &block
+      klass
+    end
+    
+    # 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)
+      symc = "#{name}".classify
+      eval <<-EOE
+        class PoolParty::Resources::#{symc} < PoolParty::Resources::Resource
+        end
+      EOE
+      klass = "PoolParty::Resources::#{symc}".constantize
+      klass.module_eval &block if block
+      klass.send :define_method, :virtual_resource?, Proc.new{true}
+      klass
+    end
+    
+  end  
+end

data/lib/poolparty/modules/file_writer.rb

@@ -0,0 +1,55 @@
+module PoolParty
+  module FileWriter
+    def copy_file_to_storage_directory(file)
+      make_base_directory
+      path = ::File.join( Base.storage_directory, ::File.basename(file) )
+      FileUtils.cp file, path
+    end
+    def copy_template_to_storage_directory(file)
+      make_template_directory
+      path = ::File.join( Base.template_directory, ::File.basename(file) )
+      FileUtils.cp file, path
+    end
+    def write_to_file_in_storage_directory(file, str, &block)
+      path = ::File.join( Base.storage_directory, ::File.basename(file) )
+      write_to_file(path, str, &block)
+    end
+    def write_to_file(file, str, &block)
+      path = ::File.join( Base.storage_directory, ::File.basename(file) )
+      make_base_path( Base.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("#{Base.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.mkdir_p path
+        rescue Errno::ENOTDIR
+        rescue Errno::EEXIST
+          puts "There was an error"
+        end
+      end
+    end
+    def make_base_directory
+      FileUtils.mkdir_p Base.storage_directory unless ::File.directory?(Base.storage_directory)
+    end
+    def make_template_directory
+      FileUtils.mkdir_p Base.template_directory unless ::File.directory?(Base.template_directory)      
+    end
+    def clear_base_directory
+      FileUtils::rm_rf "#{Base.storage_directory}"
+    end
+  end
+end

data/lib/poolparty/modules/method_missing_sugar.rb

@@ -0,0 +1,53 @@
+=begin rdoc
+  Using method missing gives us the ability to set any attribute on the object into the options
+  such that it can be retrieved later
+=end
+module PoolParty
+  module MethodMissingSugar
+    # Method_Missing
+    # When a method cannot be found on the current object
+    # it is sent to method_missing
+    # First, we check if there is a block given and if the block
+    # is given with a class of the same type, then it is a block to be evaluated on 
+    # itself, so we instantiate it here, otherwise, don't handle it here and let
+    # the super class worry about it.
+    # If the block is not given, then we are going to look for it on the 
+    # options of itself or its parent.
+    # See get_from_options for more information
+    def method_missing(m, *args, &block)
+      if block_given?
+        (args[0].class == self.class) ? args[0].instance_eval(&block) : super
+      else        
+        get_from_options(m, *args, &block)
+      end
+    end
+    
+    # Get the method from the options
+    # First, we check to see if any options are being sent to the method
+    # of the form:
+    # name "Fred"
+    # If there are args sent to it, check to see if it is an array
+    # If it is, we want to send it an array only if the array is contains more than one element.
+    # This becomes important when we are building the manifest
+    # If it is not an array of more than one element, then we just send it the first of the args
+    # If there are no args sent to it, then we check to see if the method is already in the options
+    # which means we are retrieving the property
+    # of the form
+    # @cloud.name => @cloud.options[:name]
+    # Finally, if the method name is not in the options, then we check to make sure it's not set on the 
+    # parent, we don't want the parent's set option and that the parent isnot itself and send it
+    # to the parent to handle. Otherwise, we'll say it's nil instead
+    def get_from_options(m, *args, &block)
+      if args.empty?
+        if options.has_key?(m)
+          options[m]
+        else
+          (parent.nil? || parent.class == self.class || !parent.respond_to?(:options)) ? nil : parent.send(m, *args, &block)
+        end        
+      else
+        options[m] = (args.is_a?(Array) && args.size > 1) ? args : args[0]
+      end
+    end
+    
+  end
+end