pazuzu 0.1.2

data/lib/pazuzu/command_line/controller.rb

@@ -0,0 +1,152 @@
+module Pazuzu
+  module CommandLine
+
+    class Controller
+
+      def initialize
+      end
+
+      def run!(arguments)
+        config_path, socket_path, format = nil, nil, 'text'
+
+        OptionParser.new do |opts|
+          opts.banner = "#{File.basename($0)} [OPTIONS] COMMAND [...]"
+          opts.separator ""
+          opts.on('--socket PATH', 'Connect to socket PATH') do |value|
+            socket_path = File.expand_path(value)
+          end
+          opts.on("-c FILE", "--config FILE", 'Read configuration from FILE') do |value|
+            config_path = File.expand_path(value)
+          end
+          opts.on('-f FORMAT', '--format FORMAT') do |value|
+            format = value
+          end
+          opts.on("-h", "--help", "Show this help.") do
+            puts opts
+            exit
+          end
+          opts.parse!(arguments)
+        end
+
+        if arguments.empty?
+          abort "No command specified. Run with 'help' for list of commands."
+        end
+
+        unless %w(text json).include?(format)
+          abort "Invalid format '#{format}'."
+        end
+
+        if config_path
+          configuration = YAML.load(File.open(config_path))
+          socket_path = configuration['socket_path']
+        end
+        socket_path ||= Supervisor::DEFAULT_SOCKET_PATH
+
+        command, command_arguments = arguments[0], arguments[1..-1]
+
+        begin
+          client = Control::SocketClient.new(socket_path)
+        rescue Errno::ECONNREFUSED
+          abort "Connection refused on #{socket_path}. Server might not be running."
+        else
+          response = client.execute(command, *command_arguments)
+          if response
+            case format
+              when 'json'
+                puts JSON.dump(response, :pretty => true)
+              when 'text'
+                if response['success']
+                  puts(response['success'])
+                elsif response['error']
+                  abort(response['error'])
+                elsif response['results']
+                  case command
+                    when 'log'
+                      print_log(response['results'])
+                    when 'help'
+                      print_help(response['results'])
+                    when 'list'
+                      print_applications(response['results'])
+                    else
+                      abort("Don't know how to print results from '#{command}'.")
+                  end
+                else
+                  abort("Unrecognized response from server: #{JSON.dump response}")
+                end
+            end
+          else
+            exit(1)
+          end
+        end
+      end
+
+      def print_log(entries)
+        entries.each do |entry|
+          puts [
+            entry['time'],
+            entry['source'],
+            entry['message']
+          ].join("\t")
+        end
+      end
+
+      def print_help(items)
+        puts "Command                    Description"
+        puts "-------------------------  ------------------------------"
+        items.each do |item|
+          puts [
+            "%-25s" % item['syntax'],
+            "%-30s" % item['description']
+          ].join("  ")          
+        end
+      end
+
+      def print_applications(applications)
+        puts "Process                 State                           Command"
+        puts "----------------------  ------------------------------  ----------------------------"
+        applications.each do |application|
+          (application['workers'] || []).each do |worker|
+            (worker['instances'] || []).each do |instance|
+              state = instance['state']
+              if state == 'running'
+                state = format_uptime(instance['uptime'])
+              end
+              recovery_count = instance['recovery_count']
+              if recovery_count and recovery_count > 0
+                state << " (#{recovery_count} recoveries)"
+              end
+              puts [
+                "%-22s" % instance['name'],
+                "%-30s" % state,
+                instance['command']
+              ].join("  ")
+            end
+          end
+        end
+      end
+
+      def format_uptime(uptime)
+        s = 'running'
+        if uptime
+          s << ' for '
+          days, hours, minutes, seconds =
+            (uptime / 1.day).floor,
+            (uptime / 1.hour).floor,
+            (uptime / 1.minute).floor,
+            (uptime / 1.second).floor
+          if days > 0
+            s << "#{days}d, #{hours}h"
+          elsif hours > 0 or minutes > 0
+            s << "#{hours}h, " if hours > 0
+            s << "#{minutes}m"
+          else
+            s << "#{seconds}s"
+          end
+        end
+        s
+      end
+
+    end
+
+  end
+end

data/lib/pazuzu/control/protocol.rb

@@ -0,0 +1,304 @@
+module Pazuzu
+  module Control
+
+    class Protocol
+
+      COMMAND_MAPPINGS = [
+        {
+          :pattern => /^help$/,
+          :command => :help,
+          :usage => 'help',
+          :description => 'Show commands.'
+        },
+        {
+          :pattern => /^q(?:uit)?$/,
+          :command => :quit,
+          :usage => 'q, quit',
+          :description => 'Quits session.'
+        },
+        {
+          :pattern => /^list(?:\s+(?<spec>[^\s]+))?$/,
+          :command => :list,
+          :usage => 'list [SPEC]',
+          :description => 'Lists applications whose name, worker or instance matches SPEC (eg., "myapp", "myapp.web*").'
+        },
+        {
+          :pattern => /^log(?:\s+(?<spec>[^\s]+)(?:\s+(?<limit>.*))?)?$/,
+          :command => :log,
+          :usage => 'log [SPEC] [LIMIT]',
+          :description => 'Lists log entries for application, workers or instances matching SPEC, at most LIMIT lines.'
+        },
+        {
+          :pattern => /^start(?:\s+(?<spec>[^\s]+))?$/,
+          :command => :start,
+          :usage => 'start SPEC',
+          :description => 'Starts an application, worker or instance by SPEC.'
+        },
+        {
+          :pattern => /^restart(?:\s+(?<spec>[^\s]+))?$/,
+          :command => :restart,
+          :usage => 'restart SPEC',
+          :description => 'Restarts an application, worker or instance by SPEC. Stopped matches will be started.'
+        },
+        {
+          :pattern => /^stop(?:\s+(?<spec>[^\s]+))?$/,
+          :command => :stop,
+          :usage => 'stop SPEC',
+          :description => 'Stops an application, worker or instance by SPEC.'
+        },
+        {
+          :pattern => /^scale\s+(?<spec>[^\s]+)(?:\s+(?<value>(?:\+|-)?[^\s]+))?$/,
+          :command => :scale,
+          :usage => 'scale WORKER-SPEC VALUE',
+          :description => 'Set the number of instances for a worker (or workers). Value may be an absolute number, or a relative (+1, -1), or the string "default".'
+        }
+      ].freeze
+
+      def initialize(io, supervisor)
+        @io = io
+        @supervisor = supervisor
+        @active = true
+        @logger = Utility::AnnotatedLogger.new(
+          @supervisor.logger, 'Control socket')
+      end
+
+      def run!
+        while @active
+          line = @io.gets
+          break unless line
+          line.strip!
+          unless line.blank?
+            handle_command(line)
+          end
+        end
+      end
+
+      def handle_command(line)
+        @logger.info "Received: #{line}"
+        matched = false
+        COMMAND_MAPPINGS.each do |command|
+          match = command[:pattern].match(line)
+          if match
+            self.send("handle_#{command[:command]}_command", match)
+            matched = true
+            break
+          end
+        end
+        unless matched
+          error! "Don't understand '#{line}'"
+        end
+      end
+
+      def handle_help_command(options)
+        results! COMMAND_MAPPINGS.map { |command|
+          {
+            :syntax => command[:usage],
+            :description => command[:description]
+          }
+        }
+      end
+
+      def handle_list_command(options)
+        spec = options[:spec]
+        results = Set.new
+        match_objects(spec) do |object|
+          case object
+            when Application
+              results.add(object)
+            when Worker
+              results.add(object.application)
+            when Instance
+              results.add(object.worker.application)
+          end
+        end
+        results! results.map { |object| serialize_object(object) }
+      end
+
+      def handle_log_command(options)
+        spec = options[:spec]
+        limit = options[:limit].try(:to_i)
+        matches = collapse_hierarchy(match_objects(spec))
+        entries = matches.map { |object| object.log_entries }
+        entries.flatten!(1)
+        entries.sort_by! { |(source, time, message)| time }
+        entries.slice!(0, entries.length - limit) if limit
+        results! entries.map { |(source, time, message)|
+          {:source => source, :time => time, :message => message}
+        }
+      end
+
+      def handle_start_command(options)
+        spec = options[:spec]
+        matches = collapse_hierarchy(match_objects(spec))
+        matches |= match_objects(spec).select { |object| object.run_state != :running }
+        matches.each do |object|
+          object.start!
+        end
+        if matches.any?
+          success! "Started #{matches.map(&:qname).join(', ')}."
+        else
+          error! "No matches."
+        end
+      end
+
+      def handle_restart_command(options)
+        spec = options[:spec]
+        matches = collapse_hierarchy(match_objects(spec))
+        matches |= match_objects(spec).select { |object| object.run_state != :running }
+        matches.each do |object|
+          object.stop!
+        end
+        if matches.any?
+          begin
+            timeout(30) do
+              loop do
+                break if matches.all? { |object| object.run_state == :stopped }
+                sleep(1)
+              end
+            end
+            matches.each do |object|
+              object.start!
+            end
+            timeout(30) do
+              loop do
+                break if matches.all? { |object| object.run_state == :running }
+                sleep(1)
+              end
+            end
+          rescue Timeout::Error
+            error! "Timed out."
+          else
+            success! "Restarted #{matches.map(&:qname).join(', ')}."
+          end
+        else
+          error! "No matches."
+        end
+      end
+
+      def handle_stop_command(options)
+        spec = options[:spec]
+        matches = collapse_hierarchy(match_objects(spec))
+        matches.each do |object|
+          object.stop!
+        end
+        if matches.any?
+          success! "Stopped #{matches.map(&:qname).join(', ')}."
+        else
+          error! "No matches."
+        end
+      end
+
+      def handle_scale_command(options)
+        spec, value = options[:spec], options[:value]
+        if value
+          matches = []
+          match_objects(spec) do |object|
+            if object.is_a?(Worker)
+              case value
+                when /^(\+|-)/
+                  object.add_instance_count!(value.to_i)
+                when /^default$/i
+                  object.revert_dynamic_instance_count!
+                else
+                  object.set_instance_count!(value.to_i)
+              end
+              matches << object
+            end
+          end
+          if matches.any?
+            success! "Adjusted #{matches.map(&:qname).join(', ')}."
+          else
+            error! "No matches."
+          end
+        else
+          error! "No value specified."
+        end
+      end
+
+      def handle_quit_command(options)
+        success! 'It was a pleasure.'
+        @active = false
+      end
+
+      def respond!(data)
+        output = JSON.dump(data, :pretty => true)
+        @logger.debug "Sending: #{output}"
+        @io.puts('%010x' % output.length)
+        @io.puts(output)
+      end
+
+      def results!(results)
+        respond!(:results => results)
+      end
+
+      def error!(message)
+        respond!(:error => message)
+      end
+
+      def success!(message)
+        respond!(:success => message)
+      end
+
+      def serialize_object(object)
+        data = {}
+        data[:name] = object.qname
+        data[:command] = object.command_line if object.respond_to?(:command_line)
+        data[:state] = object.run_state
+        data[:started_at] = object.started_at.iso8601 if object.started_at
+        data[:stopped_at] = object.stopped_at.iso8601 if object.stopped_at
+        data[:uptime] = Time.now - object.started_at if object.started_at
+        case object
+          when Application
+            data[:workers] = object.workers.map { |worker| serialize_object(worker) }
+          when Worker
+            data[:instances] = object.instances.map { |instance| serialize_object(instance) }
+          when Instance
+            data[:recovery_count] = object.recovery_count
+        end
+        data
+      end
+
+      def collapse_hierarchy(objects)
+        return objects.dup.delete_if { |object|
+          case object
+            when Worker
+              objects.include?(object.application)
+            when Instance
+              objects.include?(object.worker) || objects.include?(object.worker.application)
+            else
+              false
+          end
+        }
+      end
+
+      def match_objects(spec, &block)
+        results = Set.new
+        @supervisor.applications.each do |application|
+          application.workers.each do |worker|
+            worker.instances.each do |instance|
+              if match_name?(instance.qname, spec)
+                results << instance
+                yield instance if block
+              end
+            end
+            if match_name?(worker.qname, spec)
+              results << worker
+              yield worker if block
+            end
+          end
+          if match_name?(application.qname, spec)
+            results << application
+            yield application if block
+          end
+        end
+        results.to_a
+      end
+
+      def match_name?(name, spec)
+        spec.blank? || name == spec || File.fnmatch(spec, name)
+      end
+
+    end
+
+  end
+end