caterer 0.0.1 → 0.1.0

data/lib/caterer/command/bootstrap.rb

@@ -0,0 +1,28 @@
+module Caterer
+  module Command
+    class Bootstrap < Base
+      
+      def execute
+        options = {}
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: cater bootstrap HOST [options]"
+          opts.separator ""
+          opts.on("-s SCRIPT", "--script SCRIPT", 'optional bootstrap script') do |s|
+            options[:script] = s
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts, options, true)
+        return if not argv
+
+        with_target_servers(argv, options) do |server|
+          server.bootstrap({:script => options[:script]})
+        end
+
+        0
+      end
+
+    end
+  end
+end

data/lib/caterer/command/provision.rb

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

data/lib/caterer/command/reboot.rb

@@ -0,0 +1,22 @@
+module Caterer
+  module Command
+    class Reboot < Base
+      
+      def execute
+        options = {}
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: cater provision HOST [options]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts, options, true)
+        return if not argv
+
+        @env.ui.info options
+        @env.ui.info argv
+        0
+      end
+
+    end
+  end
+end

data/lib/caterer/command/test.rb

@@ -1,9 +1,16 @@
 module Caterer
   module Command
-    class Test < Vli::Command::Base
+    class Test < Base
       
       def execute
-        puts "testy testy!"
+        options = {}
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: cater test"
+        end
+
+        # Parse the options
+        argv = parse_options(opts, options, false)
+
         0
       end
 

data/lib/caterer/command/up.rb

@@ -0,0 +1,28 @@
+module Caterer
+  module Command
+    class Up < Base
+      
+      def execute
+        options = {}
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: cater provision HOST [options]"
+          opts.separator ""
+          opts.on("-s SCRIPT", "--script SCRIPT", 'optional bootstrap script') do |s|
+            options[:script] = s
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts, options, true)
+        return if not argv
+
+        with_target_servers(argv, options) do |server|
+          server.up({:script => options[:script]})
+        end
+
+        0
+      end
+
+    end
+  end
+end

data/lib/caterer/command.rb

@@ -1,5 +1,10 @@
 module Caterer
   module Command
-    autoload :Test, 'caterer/command/test'
+    autoload :Base,       'caterer/command/base'
+    autoload :Bootstrap,  'caterer/command/bootstrap'
+    autoload :Provision,  'caterer/command/provision'
+    autoload :Reboot,     'caterer/command/reboot'
+    autoload :Test,       'caterer/command/test'
+    autoload :Up,         'caterer/command/up'
   end
 end

data/lib/caterer/commands.rb

@@ -1 +1,6 @@
-Caterer.commands.register(:test) { Caterer::Command::Test }
+# commands
+Caterer.commands.register(:test)      { Caterer::Command::Test }
+Caterer.commands.register(:bootstrap) { Caterer::Command::Bootstrap }
+Caterer.commands.register(:provision) { Caterer::Command::Provision }
+Caterer.commands.register(:up)        { Caterer::Command::Up }
+Caterer.commands.register(:reboot)    { Caterer::Command::Reboot }

data/lib/caterer/communication/rsync.rb

@@ -0,0 +1,14 @@
+module Caterer
+  module Communication
+    class Rsync
+      
+      def initialize(server)
+        @server     = server
+        @logger     = Log4r::Logger.new("caterer::communication::ssh")
+      end
+
+      
+
+    end
+  end
+end

data/lib/caterer/communication/ssh.rb

@@ -0,0 +1,185 @@
+require 'timeout'
+require 'net/ssh'
+require 'net/scp'
+require 'log4r'
+
+module Caterer
+  module Communication
+    class SSH
+      include Util::ANSIEscapeCodeRemover
+      include Util::Retryable
+      
+      def initialize(server)
+        @server     = server
+        @connection = nil
+        @logger     = Log4r::Logger.new("caterer::communication::ssh")
+      end
+
+      def ready?
+        @logger.debug("Checking whether SSH is ready...")
+
+        Timeout.timeout(30) do
+          connect
+        end
+
+        # If we reached this point then we successfully connected
+        @logger.info("SSH is ready!")
+        true
+      rescue => e
+        # The above errors represent various reasons that SSH may not be
+        # ready yet. Return false.
+        @logger.info("SSH not up: #{e.inspect}")
+        return false
+      end
+
+      def execute(command, opts={}, &block)
+        connect do |connection|
+          shell_execute(connection, command, opts, &block)
+        end
+      end
+
+      def sudo(command, opts={}, &block)
+        sudo = (@server.username == 'root') ? false : true
+        execute(command, opts.merge({:sudo => sudo}), &block)
+      end
+
+      def upload(from, to)
+        @logger.debug("Uploading: #{from} to #{to}")
+
+        # Do an SCP-based upload...
+        connect do |connection|
+          opts = {}
+          opts[:recursive] = true if from.is_a?(String) and File.directory?(from)
+          scp = Net::SCP.new(connection)
+          scp.upload!(from, to, opts)
+        end
+      rescue Net::SCP::Error => e
+        # If we get the exit code of 127, then this means SCP is unavailable.
+        raise "scp unavailable" if e.message =~ /\(127\)/
+
+          # Otherwise, just raise the error up
+          raise
+      end
+
+      protected
+
+      # Opens an SSH connection and yields it to a block.
+      def connect
+        if @connection && !@connection.closed?
+          # There is a chance that the socket is closed despite us checking
+          # 'closed?' above. To test this we need to send data through the
+          # socket.
+          begin
+            @connection.exec!("")
+          rescue IOError
+            @logger.info("Connection has been closed. Not re-using.")
+            @connection = nil
+          end
+
+          # If the @connection is still around, then it is valid,
+          # and we use it.
+          if @connection
+            @logger.debug("Re-using SSH connection.")
+            return yield @connection if block_given?
+            return
+          end
+        end
+
+        # Connect to SSH, giving it a few tries
+        connection = nil
+        # These are the exceptions that we retry because they represent
+        # errors that are generally fixed from a retry and don't
+        # necessarily represent immediate failure cases.
+        exceptions = [
+          Errno::ECONNREFUSED,
+          Errno::EHOSTUNREACH,
+          Net::SSH::Disconnect,
+          Timeout::Error
+        ]
+
+        @logger.info("Connecting to SSH: (#{@server.host}:#{@server.port}")
+        @server.ui.info "Connecting..."
+        connection = retryable(:tries => 10, :on => exceptions) do
+          Net::SSH.start(@server.host, @server.username, @server.ssh_opts)
+        end
+
+        @connection = connection
+
+        # This is hacky but actually helps with some issues where
+        # Net::SSH is simply not robust enough to handle... see
+        # issue #391, #455, etc.
+        # sleep 4
+
+        # Yield the connection that is ready to be used and
+        # return the value of the block
+        return yield connection if block_given?
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, opts={})
+
+        opts[:sudo] ||= false
+        opts[:stream] ||= false
+
+        @logger.info("Execute: #{command} (opts=#{opts.inspect})")
+        exit_status = nil
+
+        # Determine the shell to execute. If we are using `sudo` then we
+        # need to wrap the shell in a `sudo` call.
+        shell = "bash -l"
+        shell = "sudo -H #{shell}" if opts[:sudo]
+
+        # Open the channel so we can execute or command
+        channel = connection.open_channel do |ch|
+          ch.exec(shell) do |ch2, _|
+            # Setup the channel callbacks so we can get data and exit status
+            ch2.on_data do |ch3, data|
+              @logger.debug("stdout: #{data}")
+              if block_given?
+                # Filter out the clear screen command
+                data = remove_ansi_escape_codes(data)
+                yield :stdout, data
+              end
+              if opts[:stream]
+                @server.ui.info data, {:prefix => false, :new_line => false}
+              end
+            end
+
+            ch2.on_extended_data do |ch3, type, data|
+              @logger.debug("stderr: #{data}")
+              if block_given?
+                # Filter out the clear screen command
+                data = remove_ansi_escape_codes(data)
+                yield :stderr, data
+              end
+              if opts[:stream]
+                @server.ui.info data, {:prefix => false, :new_line => false}
+              end
+            end
+
+            ch2.on_request("exit-status") do |ch3, data|
+              exit_status = data.read_long
+              @logger.debug("Exit status: #{exit_status}")
+            end
+
+            # Set the terminal
+            ch2.send_data "export TERM=vt100\n"
+
+            # Output the command
+            ch2.send_data "#{command}\n"
+
+            # Remember to exit or this channel will hang open
+            ch2.send_data "exit\n"
+          end
+        end
+
+        # Wait for the channel to complete
+        channel.wait
+
+        # Return the final exit status
+        return exit_status
+      end
+
+    end
+  end
+end

data/lib/caterer/communication.rb

@@ -0,0 +1,6 @@
+module Caterer
+  module Communication
+    autoload :Rsync,  'caterer/communication/rsync'
+    autoload :SSH,    'caterer/communication/ssh'
+  end
+end

data/lib/caterer/config/base.rb

@@ -1,17 +1,30 @@
-module Caterer::Config
+module Caterer
+  module Config
+    class Base
 
-  class Base
-    attr_accessor :roles
+      attr_reader :images, :groups
 
-    def initialize
-      @roles = []  
-    end
+      def initialize
+        @images  = {}
+        @groups  = {}
+      end
+
+      def image(name)
+        @images[name] ||= Image.new(name)
+        yield @images[name] if block_given?
+      end
+
+      def group(name)
+        @groups[name] ||= Group.new(name)
+        yield @groups[name] if block_given?
+      end
+      
+      def member(name, &block)
+        group(:default) do |d|
+          d.member(name, &block)
+        end
+      end
 
-    def role(name)
-      role = Caterer::Config::Role.new(name)
-      yield role if block_given?
-      @roles << role
     end
   end
-
 end

data/lib/caterer/config/group.rb

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

data/lib/caterer/config/image.rb

@@ -0,0 +1,20 @@
+require 'active_support/inflector'
+
+module Caterer
+  module Config
+    class Image
+      
+      attr_reader :name, :provisioner
+
+      def initialize(name)
+        @name = name
+      end
+
+      def provision(type)
+        @provisioner = "Caterer::Config::Provision::#{type.to_s.classify}".constantize.new(type)
+        yield @provisioner if block_given?
+      end
+
+    end
+  end
+end

data/lib/caterer/config/member.rb

@@ -0,0 +1,14 @@
+module Caterer
+  module Config
+    class Member
+
+      attr_reader :name
+      attr_accessor :host, :port, :user, :password, :images
+      
+      def initialize(name=nil)
+        @name = name
+      end
+
+    end
+  end
+end

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

@@ -1,18 +1,42 @@
-module Caterer::Config::Provision
+module Caterer
+  module Config
+    module Provision
 
-  class ChefSolo
-    
-    attr_accessor :recipes, :json
+      class ChefSolo
+        
+        attr_reader :name, :run_list
+        attr_accessor :json, :cookbooks_path, :roles_path, :data_bags_path, :bootstrap_script
 
-    def initialize
-      @recipes = []
-      @json = {}
-    end
+        def initialize(name)
+          @name           = name
+          @run_list       = []
+          @json           = {}
+          @cookbooks_path = ['cookbooks']
+          @roles_path     = ['roles']
+          @data_bags_path = ['data_bags']
+        end
 
-    def add_recipe(recipe)
-      @recipes << recipe
-    end
+        def add_recipe(recipe)
+          @run_list << "recipe[#{recipe}]"
+        end
 
-  end
+        def add_role(role)
+          @run_list << "role[#{role}]"
+        end
+
+        def errors
+          errors = {}
 
+          if not @run_list.length > 0
+            errors[:run_list] = "is empty"
+          end
+
+          if errors.length > 0
+            errors
+          end
+        end
+
+      end
+    end
+  end
 end

data/lib/caterer/config/provision.rb

@@ -1,5 +1,7 @@
-module Caterer::Config
-  module Provision
-    autoload :ChefSolo, 'caterer/config/provision/chef_solo'
+module Caterer
+  module Config
+    module Provision
+      autoload :ChefSolo, 'caterer/config/provision/chef_solo'
+    end
   end
 end

data/lib/caterer/config.rb

@@ -1,7 +1,11 @@
 module Caterer
   module Config
     autoload :Base,       'caterer/config/base'
-    autoload :Role,       'caterer/config/role'
+    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 :Provision,  'caterer/config/provision'
   end
 end

data/lib/caterer/environment.rb

@@ -9,42 +9,68 @@ module Caterer
       opts = {
         :cwd => nil,
         :caterfile_name => nil,
-        :ui_class => nil
+        :ui_class => nil,
+        :custom_config => nil
       }.merge(opts)
 
       opts[:cwd] ||= ENV["CATERER_CWD"] if ENV.has_key?("CATERER_CWD")
       opts[:cwd] ||= Dir.pwd
-      opts[:cwd]  = Pathname.new(opts[:cwd])
 
       opts[:caterfile_name] ||= []
-      opts[:caterfile_name] = [opts[:caterfile_name]] if !opts[:vagrantfile_name].is_a?(Array)
+      opts[:caterfile_name] = [opts[:caterfile_name]] if !opts[:caterfile_name].is_a?(Array)
       opts[:caterfile_name] += ["Caterfile"]
 
-      @cwd            = opts[:cwd]
+      @cwd            = Pathname.new(opts[:cwd])
       @caterfile_name = opts[:caterfile_name]
+      @custom_config  = opts[:custom_config]
 
       ui_class = opts[:ui_class] || Vli::UI::Silent
       @ui      = ui_class.new("cater")
 
     end
 
-    def load!
-      load_default_config
-      load_custom_config
+    def action_runner
+      @action_runner ||= Vli::Action::Runner.new(action_registry) do
+        {
+          :action_runner  => action_runner,
+          :ui             => @ui
+        }
+      end
+    end
+
+    def action_registry
+      Caterer.actions
+    end
+
+    def config
+      @config ||= begin
+        load_default_config
+        load_custom_config
+        Caterer.config
+      end
     end
+    alias :load! :config
 
     def load_default_config
-      # doesn't work yet
-      # require 'config/default'
+      require_relative '../../config/default'
     end
 
     def load_custom_config
-      @caterfile_name.each do |config_file|
-        file = "#{@cwd}/#{config_file}"
-        load file if File.exists? file
+      if @custom_config
+        # if it's been explicitly defined, load it
+        load_config_file @custom_config
+      else
+        # lets try a few variations
+        @caterfile_name.each do |config_file|
+          load_config_file "#{@cwd}/#{config_file}"
+        end
       end
     end
 
+    def load_config_file(file)
+      load file if File.exists? file
+    end
+
     def cli(*args)
       Cli.new(args.flatten, self).execute
     end

data/lib/caterer/provisioner/base.rb

@@ -0,0 +1,19 @@
+module Caterer
+  module Provisioner
+    class Base
+
+      attr_reader :server
+
+      def initialize(server, config=nil)
+        @server = server
+        @config = config
+      end
+
+      def bootstrap(script=nil);  end
+      def prepare;    end
+      def provision;  end
+      def cleanup;    end
+
+    end
+  end
+end