caterer 0.11.2 → 1.0.0

data/lib/caterer/action/server.rb

@@ -1,9 +1,10 @@
 module Caterer
   module Action
     module Server
+      autoload :Cleanup,  'caterer/action/server/cleanup'
       autoload :Lock,     'caterer/action/server/lock'
       autoload :Platform, 'caterer/action/server/platform'
-      autoload :Reboot,   'caterer/action/server/reboot'
+      autoload :Prepare,  'caterer/action/server/prepare'
       autoload :Validate, 'caterer/action/server/validate'
       autoload :Unlock,   'caterer/action/server/unlock'
     end

data/lib/caterer/action/{provisioner/install.rb → server/cleanup.rb}

@@ -1,13 +1,13 @@
 module Caterer
   module Action
-    module Provisioner
-      class Install < Base
-
+    module Server
+      class Cleanup < Base
+        
         def call(env)
-          env[:provisioner].install(env[:server])
+          env[:server].cleanup! if env[:ghost_mode]
           @app.call(env)
         end
-        
+
       end
     end
   end

data/lib/caterer/action/server/{reboot.rb → prepare.rb}

@@ -1,11 +1,13 @@
 module Caterer
   module Action
     module Server
-      class Reboot < Base
+      class Prepare < Base
+        
         def call(env)
-          env[:server].reboot!
+          env[:server].prepare!
           @app.call(env)
         end
+
       end
     end
   end

data/lib/caterer/actions.rb

@@ -3,7 +3,6 @@ Caterer.actions.register(:validate) do
   Vli::Action::Builder.new do
     use Caterer::Action::Config::Validate::Image
     use Caterer::Action::Config::Validate::Provisioner
-    use Caterer::Action::Provisioner::Validate::Engine
     use Caterer::Action::Server::Validate::SSH
     use Caterer::Action::Server::Validate::Unlocked
   end
@@ -25,67 +24,30 @@ Caterer.actions.register(:unlock) do
   end
 end
 
-Caterer.actions.register(:bootstrap) do
-  Vli::Action::Builder.new do
-    use Caterer::Action::Environment::Setup
-    use Caterer.actions.get(:validate)
-    use Caterer::Action::Server::Platform
-    use Caterer::Action::Provisioner::Load
-    use Caterer::Action::Provisioner::Prepare
-    use Caterer::Action::Server::Lock
-    use Caterer::Action::Provisioner::Bootstrap
-    use Caterer::Action::Provisioner::Install
-    use Caterer::Action::Provisioner::Cleanup
-    use Caterer::Action::Server::Unlock
-  end
-end
-
 Caterer.actions.register(:provision) do
   Vli::Action::Builder.new do
     use Caterer::Action::Environment::Setup
     use Caterer.actions.get(:validate)
     use Caterer::Action::Server::Platform
-    use Caterer::Action::Provisioner::Load
-    use Caterer::Action::Provisioner::Prepare
-    use Caterer::Action::Provisioner::Validate::Bootstrapped
     use Caterer::Action::Server::Lock
-    use Caterer::Action::Provisioner::Provision
-    use Caterer::Action::Provisioner::Cleanup
-    use Caterer::Action::Server::Unlock
-  end
-end
-
-Caterer.actions.register(:up) do
-  Vli::Action::Builder.new do
-    use Caterer::Action::Environment::Setup
-    use Caterer.actions.get(:validate)
-    use Caterer::Action::Server::Platform
-    use Caterer::Action::Provisioner::Load
+    use Caterer::Action::Server::Prepare
+    use Caterer::Action::Image::Prepare
     use Caterer::Action::Provisioner::Prepare
-    use Caterer::Action::Server::Lock
-    use Caterer::Action::Provisioner::Bootstrap
-    use Caterer::Action::Provisioner::Install
-    use Caterer::Action::Provisioner::Provision
+    use Caterer::Action::Image::Run
     use Caterer::Action::Provisioner::Cleanup
+    use Caterer::Action::Image::Cleanup
+    use Caterer::Action::Server::Cleanup
     use Caterer::Action::Server::Unlock
   end
 end
 
-Caterer.actions.register(:reboot) do
-  Vli::Action::Builder.new do
-    use Caterer::Action::Environment::Setup
-    use Caterer::Action::Server::Validate::SSH
-    use Caterer::Action::Server::Platform
-    use Caterer::Action::Server::Reboot
-  end
-end
-
 Caterer.actions.register(:clean) do
   Vli::Action::Builder.new do
     use Caterer::Action::Environment::Setup
     use Caterer.actions.get(:validate)
     use Caterer::Action::Server::Platform
-    use Caterer::Action::Provisioner::Load
-    use Caterer::Action::Provisioner::Uninstall
+    use Caterer::Action::Provisioner::Cleanup
+    use Caterer::Action::Image::Cleanup
+    use Caterer::Action::Server::Cleanup
   end
 end

data/lib/caterer/cli.rb

@@ -1,14 +1,14 @@
 # Credit:
 # special thanks to Vagrant project: https://github.com/mitchellh/vagrant
-# where the source of this module was originally extracted.
+# where parts of this module were extracted
 
 require 'optparse'
 
 module Caterer
-  class Cli < Vli::Command::Base
+  class Cli
     def initialize(argv, env)
-      super
-
+      @argv   = argv
+      @env    = env
       @logger = Log4r::Logger.new("caterer::cli")
       @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
 
@@ -67,5 +67,51 @@ module Caterer
       @env.ui.info opts.help, :prefix => false
     end
 
+    # This method will split the argv given into three parts: the
+    # flags to this command, the subcommand, and the flags to the
+    # subcommand. For example:
+    #
+    #     -v status -h -v
+    #
+    # The above would yield 3 parts:
+    #
+    #     ["-v"]
+    #     "status"
+    #     ["-h", "-v"]
+    #
+    # These parts are useful because the first is a list of arguments
+    # given to the current command, the second is a subcommand, and the
+    # third are the commands given to the subcommand.
+    #
+    # @return [Array] The three parts.
+    def split_main_and_subcommand(argv)
+      # Initialize return variables
+      main_args   = nil
+      sub_command = nil
+      sub_args    = []
+
+      # We split the arguments into two: One set containing any
+      # flags before a word, and then the rest. The rest are what
+      # get actually sent on to the subcommand.
+      argv.each_index do |i|
+        if !argv[i].start_with?("-")
+          # We found the beginning of the sub command. Split the
+          # args up.
+          main_args   = argv[0, i]
+          sub_command = argv[i]
+          sub_args    = argv[i + 1, argv.length - i + 1]
+
+          # Break so we don't find the next non flag and shift our
+          # main args.
+          break
+        end
+      end
+
+      # Handle the case that argv was empty or didn't contain any subcommand
+      main_args = argv.dup if main_args.nil?
+
+      return [main_args, sub_command, sub_args]
+    end
+
   end
 end

data/lib/caterer/command.rb

@@ -3,12 +3,9 @@ module Caterer
     autoload :Base,       'caterer/command/base'
     autoload :Clean,      'caterer/command/clean'
     autoload :Berks,      'caterer/command/berks'
-    autoload :Bootstrap,  'caterer/command/bootstrap'
     autoload :Lock,       'caterer/command/lock'
     autoload :Provision,  'caterer/command/provision'
-    autoload :Reboot,     'caterer/command/reboot'
-    autoload :Test,       'caterer/command/test'
+    autoload :Server,     'caterer/command/server'
     autoload :Unlock,     'caterer/command/unlock'
-    autoload :Up,         'caterer/command/up'
   end
 end

data/lib/caterer/command/base.rb

@@ -3,126 +3,35 @@ require 'multi_json'
 
 module Caterer
   module Command
-    class Base < Vli::Command::Base
+    class Base
       
-      def parse_options(opts=nil, options={}, force_argv=true)
+      include Vli::Util::SafePuts
+      
+      def initialize(argv, env)
+        @argv   = argv
+        @env    = env
+      end
+
+      def execute; end
+
+      def parse_options(opts=nil, force_argv=false)
+        argv = @argv.dup
         opts ||= OptionParser.new
-        opts.separator ""
-        opts.on("-c CONFIG", 'assumes Caterfile in current directory')
-        opts.separator ""
-        opts.on("-u USER", "--user USER", 'assumes current username') do |u|
-          options[:user] = u
-        end
-        opts.on('-p PASSWORD', '--password PASSWORD', 'assumes key') do |p|
-          options[:pass] = p
-        end
-        opts.on('-k KEY', '--key KEY', 'path to private key') do |k|
-          options[:key] = k
-        end
-        opts.on('-P PORT', '--port PORT', 'assumes 22') do |p|
-          options[:port] = p
-        end
-        opts.on('-e ENGINE', '--engine ENGINE', 'provision engine' ) do |e|
-          options[:engine] = e
-        end
-        opts.on('-d JSON', '--data JSON', 'json data that the provisioner may use' ) do |d|
-          options[:data] = d
-        end
-        opts.on('-i IMAGE', '--image IMAGE', 'corresponds to a image in Caterfile') do |i|
-          options[:image] = i
-        end
-        opts.on('-g GROUP', '--group GROUP', 'corresponds to a group in Caterfile') do |g|
-          options[:group] = g
+
+        opts.on_tail("-h", "--help", "Print this help") do
+          safe_puts(opts.help)
+          return nil
         end
-        opts.separator ""
 
         begin
-          argv = super(opts)
+          opts.parse!(argv)
           raise if force_argv and (not argv or argv.length == 0)
           argv
         rescue
           safe_puts(opts.help)
           nil
         end
-        
-      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
-
-        if engine = options[:engine]
-          opts[:engine] = engine.to_sym
-        end
-
-        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
-
-        Server.new(@env, opts)
-      end
-
-      def image_list(options={})
-        if images = options[:image]
-          images.split(',').map(&:to_sym)
-        end
       end
 
     end

data/lib/caterer/command/berks.rb

@@ -1,19 +1,16 @@
 module Caterer
   module Command
-    class Berks < Vli::Command::Base
+    class Berks < Base
       
       def execute
         options = {}
-        opts = OptionParser.new do |opts|
+        parser = OptionParser.new do |opts|
           opts.banner = "Usage: cater berks install|update|clean"
         end
 
         # Parse the options
-        argv = parse_options(opts)
-        if not argv.any?
-          safe_puts(opts.help)
-          return
-        end
+        argv = parse_options(parser, true)
+        return if not argv
 
         case argv.first
         when 'install'
@@ -23,7 +20,7 @@ module Caterer
         when 'clean'
           run_action :berks_clean, {force_berks_clean: true}
         else
-          safe_puts(opts.help)
+          safe_puts(parser.help)
         end
 
         0

data/lib/caterer/command/clean.rb

@@ -1,15 +1,17 @@
 module Caterer
   module Command
-    class Clean < Base
+    class Clean < Server
       
       def execute
         options = {}
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: cater provision HOST [options]"
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: cater clean 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/command/lock.rb

@@ -1,15 +1,17 @@
 module Caterer
   module Command
-    class Lock < Base
+    class Lock < Server
       
       def execute
         options = {}
-        opts = OptionParser.new do |opts|
+        parser = OptionParser.new do |opts|
           opts.banner = "Usage: cater lock 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/command/provision.rb

@@ -1,19 +1,34 @@
 module Caterer
   module Command
-    class Provision < Base
+    class Provision < Server
       
       def execute
         options = {}
-        opts = OptionParser.new do |opts|
+        parser = OptionParser.new do |opts|
           opts.banner = "Usage: cater provision HOST [options]"
         end
 
+        add_server_opts(parser, options)
+
+        # add provision specific options
+        parser.on('-d JSON', '--data JSON', 'json data that the provisioner may use' ) do |d|
+          options[:data] = d
+        end
+        parser.on('--ghost', 'provision in ghost-mode (leave no trace)') do
+          options[:ghost] = true
+        end
+        parser.on('--dry', "sync provision configuration, but don't run the provisioner") do
+          options[:dry] = true
+        end
+
+        parser.separator ""
+
         # 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|
-          server.provision
+          server.provision(dry_run: options[:dry], ghost_mode: options[:ghost])
         end
 
         0