caterer 0.11.2 → 1.0.0

data/lib/caterer/command/server.rb

@@ -0,0 +1,106 @@
+module Caterer
+  module Command
+    class Server < Base
+      
+      def add_server_opts(parser, options)
+        parser.separator ""
+        parser.on("-c CONFIG", 'assumes Caterfile in current directory')
+        parser.separator ""
+        parser.on("-u USER", "--user USER", 'assumes current username') do |u|
+          options[:user] = u
+        end
+        parser.on('-p PASSWORD', '--password PASSWORD', 'assumes key') do |p|
+          options[:pass] = p
+        end
+        parser.on('-k KEY', '--key KEY', 'path to private key') do |k|
+          options[:key] = k
+        end
+        parser.on('-P PORT', '--port PORT', 'assumes 22') do |p|
+          options[:port] = p
+        end
+        parser.on('-i IMAGE', '--image IMAGE', 'corresponds to a image in Caterfile') do |i|
+          options[:image] = i
+        end
+        parser.on('-g GROUP', '--group GROUP', 'corresponds to a group in Caterfile') do |g|
+          options[:group] = g
+        end
+        parser.separator ""
+      end
+
+      def with_target_servers(argv, options={})
+        target_servers(argv, options).each do |server|
+          yield server if block_given?
+        end
+      end
+
+      def target_servers(argv, options={})
+        @servers ||= begin
+          servers = []
+
+          argv.first.split(",").each do |host|
+            
+            if group = @env.config.groups[host.to_sym]
+              group.members.each do |key, member|
+                servers << init_server(group, member, options)
+              end
+            else
+
+              if not host.match /::/
+                host = "default::#{host}"
+              end
+
+              g, m   = host.split "::"
+              group  = nil
+              member = nil
+
+              if group = @env.config.groups[g.to_sym]
+                member = group.members[m.to_sym]
+              end
+
+              servers << init_server(group, member, options.merge(:host => m))
+            end
+          end    
+
+          servers
+        end
+      end
+
+      def init_server(group=nil, member=nil, options={})
+
+        group   ||= Config::Group.new
+        member  ||= Config::Member.new
+
+        opts = {}
+        opts[:alias]  = member.name
+        opts[:user]   = options[:user] || member.user || group.user
+        opts[:pass]   = options[:pass] || member.password || group.password
+        opts[:host]   = member.host || options[:host]
+        opts[:port]   = options[:port] || member.port
+        opts[:images] = image_list(options) || member.images || group.images
+        opts[:key]    = options[:key] || member.key || group.key
+
+        opts[:data] = begin
+
+          data = group.data.merge(member.data)
+
+          if options[:data]
+            # todo: rather than puking if the json is valid, this should create a pretty language
+            json = MultiJson.load options[:data], :symbolize_keys => true
+            data = data.merge(json) if json and json.is_a? Hash
+          end
+
+          data
+        end
+
+        Caterer::Server.new(@env, opts)
+      end
+
+      def image_list(options={})
+        if images = options[:image]
+          images.split(',').map(&:to_sym)
+        end
+      end
+
+    end
+  end
+end

data/lib/caterer/command/unlock.rb

@@ -1,15 +1,17 @@
 module Caterer
   module Command
-    class Unlock < Base
+    class Unlock < Server
       
       def execute
         options = {}
-        opts = OptionParser.new do |opts|
+        parser = OptionParser.new do |opts|
           opts.banner = "Usage: cater unlock HOST [options]"
         end
 
+        add_server_opts(parser, options)
+
         # Parse the options
-        argv = parse_options(opts, options, true)
+        argv = parse_options(parser, true)
         return if not argv
 
         with_target_servers(argv, options) do |server|

data/lib/caterer/commands.rb

@@ -1,8 +1,5 @@
 # commands
-Caterer.commands.register(:bootstrap) { Caterer::Command::Bootstrap }
 Caterer.commands.register(:clean)     { Caterer::Command::Clean }
 Caterer.commands.register(:lock)      { Caterer::Command::Lock }
 Caterer.commands.register(:provision) { Caterer::Command::Provision }
-Caterer.commands.register(:reboot)    { Caterer::Command::Reboot }
 Caterer.commands.register(:unlock)    { Caterer::Command::Unlock }
-Caterer.commands.register(:up)        { Caterer::Command::Up }

data/lib/caterer/config.rb

@@ -2,11 +2,6 @@ module Caterer
   module Config
     autoload :Base,         'caterer/config/base'
     autoload :Berkshelf,    'caterer/config/berkshelf'
-    autoload :Cluster,      'caterer/config/cluster'
-    autoload :Group,        'caterer/config/group'
-    autoload :Member,       'caterer/config/member'
-    autoload :Node,         'caterer/config/node'
-    autoload :Image,        'caterer/config/image'
     autoload :Provisioner,  'caterer/config/provisioner'
   end
 end

data/lib/caterer/config/base.rb

@@ -3,12 +3,13 @@ module Caterer
     class Base
 
       attr_reader :images, :groups
-      attr_accessor :default_provisioner
+      attr_accessor :dest_dir
 
       def initialize
-        @images = {}
-        @groups = {}
-        @keys   = {}
+        @images   = {}
+        @groups   = {}
+        @keys     = {}
+        @dest_dir = '/opt/cater'
       end
 
       def image(name)

data/lib/caterer/config/provisioner/chef_solo.rb

@@ -2,10 +2,9 @@ module Caterer
   module Config
     module Provisioner
       class ChefSolo
-        attr_accessor :dest_dir, :run_list, :json, :cookbooks_path, :roles_path, :data_bags_path, :bootstrap_scripts
+        attr_accessor :run_list, :json, :cookbooks_path, :roles_path, :data_bags_path, :bootstrap_scripts
 
         def initialize
-          @dest_dir          = '/opt/cater/chef_solo'
           @run_list          = []
           @json              = {}
           @cookbooks_path    = ['cookbooks']

data/lib/caterer/group.rb

@@ -0,0 +1,24 @@
+module Caterer
+  class Group
+
+    attr_reader    :name
+    attr_accessor  :images, :members, :user, :password, :key, :data
+
+    def initialize(name=nil)
+      @name    = name
+      @images  = []
+      @members = {}
+      @data    = {}
+    end
+
+    def add_image(image)
+      @images << image
+    end
+
+    def member(name)
+      @members[name] ||= Member.new(name)
+      yield @members[name] if block_given?
+      @members[name]
+    end
+  end
+end

data/lib/caterer/image.rb

@@ -0,0 +1,88 @@
+require 'tilt'
+
+module Caterer
+  class Image
+  
+    attr_reader :name, :provisioners
+
+    def initialize(name)
+      @name         = name
+      @provisioners = []
+    end
+
+    def provision(type, opts={})
+      provisioner_klass = Caterer.provisioners.get(type)
+      raise ":#{type} is not a valid provisioner" if not provisioner_klass
+      provisioner = provisioner_klass.new(self, opts)
+      yield provisioner if block_given?
+      @provisioners << provisioner
+      provisioner
+    end
+
+    # actions
+
+    def prepare(server)
+      # create bin dir
+      server.ssh.sudo "mkdir -p #{bin_dir}", :stream => true
+      server.ssh.sudo "chown -R #{server.username} #{bin_dir}", :stream => true
+
+      # create lib dir
+      server.ssh.sudo "mkdir -p #{lib_dir}", :stream => true
+      server.ssh.sudo "chown -R #{server.username} #{lib_dir}", :stream => true
+
+      # create var dir
+      server.ssh.sudo "mkdir -p #{var_dir}", :stream => true
+      server.ssh.sudo "chown -R #{server.username} #{var_dir}", :stream => true
+
+      # create bin wrapper
+      server.ui.info "Generating bin wrapper..."
+      server.ssh.upload(StringIO.new(bin_wrapper_content), bin_wrapper_path)
+      server.ssh.sudo "chmod +x #{bin_wrapper_path}", :stream => true
+    end
+
+    def run(server)
+      # run
+      server.ui.info "Running #{name}..."
+      res = server.ssh.sudo bin_wrapper_path, :stream => true
+      unless res == 0
+        server.ui.error "#{name} failed with exit code: #{res}"
+      end
+    end
+
+    def cleanup(server)
+      server.ui.info "Cleaning #{name}..."
+      server.ssh.sudo "rm -rf #{var_dir}"
+      server.ssh.sudo "rm -rf #{lib_dir}"
+      server.ssh.sudo "rm -f #{bin_wrapper_path}"
+    end
+
+    # helpers
+
+    def bin_dir
+      "#{config.dest_dir}/bin"
+    end
+
+    def lib_dir
+      "#{config.dest_dir}/lib/#{name}"
+    end
+
+    def var_dir
+      "#{config.dest_dir}/var/#{name}"
+    end
+
+    def bin_wrapper_path
+      "#{bin_dir}/cater-#{name}"
+    end
+
+    protected
+
+    def config
+      @config ||= Caterer.config
+    end
+
+    def bin_wrapper_content
+      Tilt.new(File.expand_path('../../templates/image/bin_wrapper.erb', __FILE__)).render(self)
+    end
+
+  end
+end

data/lib/caterer/member.rb

@@ -0,0 +1,13 @@
+module Caterer
+  class Member
+
+    attr_reader :name
+    attr_accessor :host, :port, :user, :password, :key, :images, :data
+    
+    def initialize(name=nil)
+      @name = name
+      @data = {}
+    end
+
+  end
+end

data/lib/caterer/provisioner.rb

@@ -2,5 +2,6 @@ module Caterer
   module Provisioner
     autoload :Base,     'caterer/provisioner/base'
     autoload :ChefSolo, 'caterer/provisioner/chef_solo'
+    autoload :Shell,    'caterer/provisioner/shell'
   end
 end

data/lib/caterer/provisioner/base.rb

@@ -2,17 +2,18 @@ module Caterer
   module Provisioner
     class Base
 
+      attr_reader :image
+
       # config dsl
       def errors; end
 
       # provision dsl
-      def bootstrap(server); end
-      def bootstrapped?(server); true; end
       def cleanup(server); end
       def install(server); end
+      def installed?(server); true; end
       def prepare(server); end
-      def provision(server); end
       def uninstall(server); end
+      def provision_cmd; end
         
     end
   end

data/lib/caterer/provisioner/chef_solo.rb

@@ -10,18 +10,17 @@ module Caterer
       
       include Util::Shell
 
-      attr_reader :run_list
-      attr_accessor :dest_dir, :json, :cookbooks_path, :roles_path
-      attr_accessor :data_bags_path, :bootstrap_scripts
-
-      def initialize
-        @dest_dir          = config.dest_dir.dup
-        @run_list          = config.run_list.dup
-        @json              = config.json.dup
-        @cookbooks_path    = config.cookbooks_path.dup
-        @roles_path        = config.roles_path.dup
-        @data_bags_path    = config.data_bags_path.dup
-        @bootstrap_scripts = config.bootstrap_scripts.dup
+      attr_reader   :run_list
+      attr_accessor :json, :cookbooks_path, :roles_path
+      attr_accessor :data_bags_path
+
+      def initialize(image, opts={})
+        @image          = image
+        @run_list       = provisioner_config.run_list.dup
+        @json           = provisioner_config.json.dup
+        @cookbooks_path = provisioner_config.cookbooks_path.dup
+        @roles_path     = provisioner_config.roles_path.dup
+        @data_bags_path = provisioner_config.data_bags_path.dup
       end
 
       # config DSL
@@ -34,27 +33,6 @@ module Caterer
         @run_list << "role[#{role}]"
       end
 
-      # I don't like this at all, but it seems to make the best Caterfile workflow
-      def add_image(image)
-        image = Caterer.config.images[image]
-        raise "Unknown image :#{image}" if not image
-
-        provisioner = image.provisioner
-        raise "No provisioner for :#{image}" if not provisioner
-
-        if not provisioner.class == self.class
-          raise "add_image incompatibility: #{provisioner.class} != #{self.class}"
-        end
-
-        @run_list += provisioner.run_list
-        @bootstrap_scripts += provisioner.bootstrap_scripts
-        @json = @json.merge(provisioner.json)
-      end
-
-      def add_bootstrap(script)
-        @bootstrap_scripts << script
-      end
-
       def errors
         errors = {}
 
@@ -81,54 +59,6 @@ module Caterer
 
       # provision engine
 
-      def bootstrap(server)
-
-        # validate
-        with_bootstrap_scripts do |script, count|
-
-          if not File.exists? script
-            server.ui.error "#{script} does not exist!"
-            return
-          end
-
-        end
-
-        # upload
-        with_bootstrap_scripts do |script, count|
-
-          server.ui.info "Uploading #{script}..."
-          server.ssh.upload script, "#{target_bootstrap_path}-#{count}"
-
-          server.ssh.sudo "chown #{server.username} #{target_bootstrap_path}-#{count}", :stream => true
-          server.ssh.sudo "chmod +x #{target_bootstrap_path}-#{count}", :stream => true
-
-        end
-
-        # run
-        with_bootstrap_scripts do |script, count|
-
-          server.ui.info "Running #{script}..."
-          res = server.ssh.sudo "#{target_bootstrap_path}-#{count}", :stream => true
-
-          unless res == 0
-            server.ui.error "#{script} failed with exit code: #{res}"
-          end
-
-        end
-
-      end
-
-      def bootstrapped?(server)
-        res = server.ssh.sudo "command -v chef-solo &>/dev/null"
-        res == 0 ? true : false
-      end
-
-      def prepare(server)
-        # create base dir
-        server.ssh.sudo "mkdir -p #{dest_dir}", :stream => true
-        server.ssh.sudo "chown -R #{server.username} #{dest_dir}", :stream => true
-      end
-
       def install(server)
         server.ui.info "Preparing installation..."
 
@@ -141,12 +71,30 @@ module Caterer
 
         res = server.ssh.sudo bash(File.read(installer)), :stream => true
 
+        # somewhere mark (on the server) that we installed chef-solo for later uninstall
+
         unless res == 0
           server.ui.error "install failed with exit code: #{res}"
         end
       end
 
-      def provision(server)
+      def installed?(server)
+        res = server.ssh.sudo "command -v chef-solo &>/dev/null"
+        res == 0 ? true : false
+      end
+
+      def prepare(server)
+        # create lib dir
+        server.ssh.sudo "mkdir -p #{dest_lib_dir}", :stream => true
+        server.ssh.sudo "chown -R #{server.username} #{dest_lib_dir}", :stream => true
+
+        # create var dir
+        server.ssh.sudo "mkdir -p #{dest_var_dir}", :stream => true
+        server.ssh.sudo "chown -R #{server.username} #{dest_var_dir}", :stream => true
+
+        # create cache dir
+        server.ssh.sudo "mkdir -p #{dest_cache_dir}", :stream => true
+        server.ssh.sudo "chown -R #{server.username} #{dest_cache_dir}", :stream => true
 
         # create cookbooks directory
         server.ssh.sudo "mkdir -p #{target_cookbooks_path}", :stream => true
@@ -187,82 +135,73 @@ module Caterer
         server.ssh.upload(StringIO.new(json_config(config_data.merge(server.data))), target_json_config_path)
 
         # set permissions on everything
-        server.ssh.sudo "chown -R #{server.username} #{dest_dir}", :stream => true
+        server.ssh.sudo "chown -R #{server.username} #{dest_lib_dir}", :stream => true
+        server.ssh.sudo "chown -R #{server.username} #{dest_var_dir}", :stream => true
 
-        # run
-        server.ui.info "Running chef-solo..."
-        res = server.ssh.sudo command_string, :stream => true
-        unless res == 0
-          server.ui.error "chef-solo failed with exit code: #{res}"
-        end
       end
 
-      def cleanup(server)
-        server.ui.info "Cleaning up..."
-
-        # installer
-        server.ssh.sudo "rm -f #{target_install_path}", :stream => true
-
-        # bootstrap scripts
-        server.ssh.sudo "rm -f #{target_bootstrap_path}*", :stream => true
-
-        # solo.rb
-        server.ssh.sudo "rm -f #{target_solo_path}", :stream => true
-
-        # json
-        server.ssh.sudo "rm -f #{target_json_config_path}", :stream => true
-
-        # for now, leave cookbooks, roles, and data bags for faster provisioning
+      def provision_cmd
+        "chef-solo -c #{target_solo_path} -j #{target_json_config_path}"
       end
 
       def uninstall(server)
         server.ui.info "Uninstalling..."
 
-        server.ssh.sudo "rm -rf #{dest_dir}", :stream => true
+        # figure out how to uninstall chef_solo IF we installed it
       end
 
       protected
 
       def config
-        @config ||= Caterer.config.provisioner.chef_solo
+        @config ||= Caterer.config
       end
 
-      def with_bootstrap_scripts
-        bootstrap_scripts.each_with_index do |script, index|
-          yield script, index if block_given?
-        end
+      def provisioner_config
+        @provisioner_config ||= config.provisioner.chef_solo
+      end
+
+      def dest_lib_dir
+        "#{image.lib_dir}/chef-solo"
+      end
+
+      def dest_var_dir
+        "#{image.var_dir}/chef-solo"
+      end
+
+      def dest_cache_dir
+        "#{dest_var_dir}/cache"
       end
 
       def target_install_path
-        "#{dest_dir}/install"
+        "#{dest_lib_dir}/install"
       end
 
       def target_bootstrap_path
-        "#{dest_dir}/bootstrap"
+        "#{dest_lib_dir}/bootstrap"
       end
 
       def target_cookbooks_path
-        "#{dest_dir}/cookbooks"
+        "#{dest_lib_dir}/cookbooks"
       end
 
       def target_roles_path
-        "#{dest_dir}/roles"
+        "#{dest_lib_dir}/roles"
       end
 
       def target_data_bags_path
-        "#{dest_dir}/data_bags"
+        "#{dest_lib_dir}/data_bags"
       end
 
       def target_solo_path
-        "#{dest_dir}/solo.rb"
+        "#{dest_lib_dir}/solo.rb"
       end
 
       def target_json_config_path
-        "#{dest_dir}/config.json"
+        "#{dest_lib_dir}/config.json"
       end
 
       def install_script(platform)
-        File.expand_path("../../../templates/provisioner/chef_solo/bootstrap/#{platform}.sh", __FILE__)
+        File.expand_path("../../../templates/provisioner/chef_solo/install/#{platform}.sh", __FILE__)
       end
 
       def solo_content(server)
@@ -287,10 +226,6 @@ module Caterer
         end
       end
 
-      def command_string
-        "chef-solo -c #{target_solo_path} -j #{target_json_config_path}"
-      end
-
     end
   end
 end