auser-poolparty 0.1.2 → 0.2.2

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

@@ -0,0 +1,120 @@
+module PoolParty
+  module Provisioner
+    class Master < ProvisionerBase
+      
+      def initialize(cloud=self, os=:ubuntu)
+        super(cloud.master, cloud)
+      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_puppet_master,
+          create_local_hosts_entry,
+          setup_basic_structure,
+          setup_configs,        
+          setup_fileserver,
+          setup_autosigning,
+          start_puppetmaster
+        ] << configure_tasks
+      end
+
+      def configure_tasks
+        [
+          create_local_node,
+          move_templates,
+          create_poolparty_manifest,
+          restart_puppetd
+        ]
+      end
+
+      def install_puppet_master
+        "#{installer_for(@os)} #{get_puppet_packages_for(@os)}"
+      end
+
+      def create_local_hosts_entry
+        <<-EOS
+if [ -z "grep -v '#' /etc/hosts | grep 'puppet'" ]; 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
+        EOS
+      end
+
+      def start_puppetmaster
+"puppetmasterd && puppetd --listen"
+      end    
+
+      def restart_puppetd # && puppetrun --host 127.0.0.1
+        # "puppetd --listen"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module PoolParty
+  module Provisioner
+    class Slave < ProvisionerBase
+
+      def install_tasks
+        [
+          install_puppet,        
+          setup_puppet
+        ] << configure_tasks
+      end
+
+      def configure_tasks
+        [
+          setup_configs,
+          start_puppet
+        ]
+      end
+
+      def install_puppet
+        <<-EOE        
+          #{installer_for(@os)} #{get_puppet_packages_for(@os)}
+          echo 'DAEMON_OPTS="-w 120 –server puppet"' > /etc/default/puppet
+        EOE
+      end
+
+      def setup_puppet
+        <<-EOE
+          puppetd --mkusers
+          if [ -z "$(grep -v '#' /etc/hosts | grep 'puppet')" ]; then echo "#{master_ip} puppet" >> /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
+        EOS
+      end
+      
+      def master_ip
+        @cloud.master.ip
+      end
+
+    end
+  end
+end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -0,0 +1,72 @@
+require "ftools"
+
+module PoolParty
+  module CloudResourcer
+    
+    # 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 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)
+      @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)
+    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
+    # 
+    # This 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,17 @@
+module PoolParty
+  module MethodMissingSugar
+
+    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)
+      end
+    end
+    
+    def get_from_options(m, *args)
+      args.empty? ? options[m] : options[m] = (args.is_a?(Array) && args.size > 1) ? args : args[0]
+    end
+    
+  end
+end

data/lib/poolparty/modules/output.rb

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

data/lib/poolparty/modules/pretty_printer.rb

@@ -0,0 +1,38 @@
+module PoolParty
+  module PrettyPrinter
+    
+    def pretty_print(prev="\t")
+      returning Array.new do |out|
+        out << pretty_name(prev, self)
+        out << pretty_options(prev, self)
+        
+        if self.respond_to?(:clouds)
+          clouds.each do |name, cl|
+            out << pretty_name(prev*2, cl)
+            out << pretty_options(prev*2, cl) #cl.pretty_print("#{prev}\t")
+          end
+        end
+        if self.respond_to?(:plugins)
+          out << "#{prev}\t\tPlugins"
+          out << "#{prev}\t\t" + plugins.map {|a| a}.join("\n")
+        end
+      end.join("\n")
+    end
+    
+    # Gather options on the object
+    # Do not print if the option is nil or empty.
+    # Also, don't show the option if the option is empty or the default option on the cloud    
+    def pretty_options(prev, o)
+      print_options = (o.respond_to?(:parent) && o.parent) ? 
+        (o.options.delete_if {|k,v| o.parent.options.has_key?(k) && o.parent.options[k] == o.options[k] && !o.options[k].nil? } ) : 
+        o.options
+      print_options = print_options.map {|k,v| [k, o.send(k.to_sym).to_s] }.inject({}) { |r,e| r[e[0]] = e[1] unless o.class.default_options[e[0]] == e[1] || e[1].nil? || e[1].empty?; r }
+      print_options.flush_out("#{prev}\t")
+    end
+    
+    def pretty_name(prev, o)
+      "#{prev}#{o.class.to_s.top_level_class.capitalize}: #{o.name if o.respond_to?(:name)}"
+    end
+    
+  end
+end