invoker 1.0.4 → 1.1.0

data/lib/invoker/dns_cache.rb

@@ -0,0 +1,23 @@
+module Invoker
+  class DNSCache
+    attr_accessor :dns_data
+
+    def initialize(config)
+      self.dns_data = {}
+      @dns_mutex = Mutex.new
+      Invoker.config.processes.each do |process|
+        if process.port
+          dns_data[process.label] = { 'port' => process.port }
+        end
+      end
+    end
+
+    def [](process_name)
+      @dns_mutex.synchronize { dns_data[process_name] }
+    end
+
+    def add(name, port)
+      @dns_mutex.synchronize { dns_data[name] = { 'port' => port } }
+    end
+  end
+end

data/lib/invoker/errors.rb

@@ -12,5 +12,6 @@ module Invoker
     class NoValidPortFound < StandardError; end
     class InvalidConfig < StandardError; end
     class InvalidFile < StandardError; end
+    class ClientDisconnected < StandardError; end
   end
 end

data/lib/invoker/ipc.rb

@@ -0,0 +1,45 @@
+require "invoker/ipc/base_command"
+require 'invoker/ipc/message'
+require 'invoker/ipc/add_command'
+require 'invoker/ipc/add_http_command'
+require 'invoker/ipc/client_handler'
+require 'invoker/ipc/dns_check_command'
+require 'invoker/ipc/list_command'
+require 'invoker/ipc/remove_command'
+require 'invoker/ipc/server'
+require "invoker/ipc/reload_command"
+require 'invoker/ipc/tail_command'
+require 'invoker/ipc/unix_client'
+require "invoker/ipc/ping_command"
+
+module Invoker
+  module IPC
+    INITIAL_PACKET_SIZE = 9
+    def self.message_from_io(io)
+      json_size = io.read(INITIAL_PACKET_SIZE)
+      json_string = io.read(json_size.to_i)
+      ruby_object_hash = JSON.parse(json_string)
+      command_name = camelize(ruby_object_hash['type'])
+      command_klass = Invoker::IPC::Message.const_get(command_name)
+      command_klass.new(ruby_object_hash)
+    end
+
+    # Taken from Rails without inflection support
+    def self.camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+
+    def self.underscore(term)
+      word = term.to_s.gsub('::', '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/invoker/ipc/add_command.rb

@@ -0,0 +1,12 @@
+module Invoker
+  module IPC
+    class AddCommand < BaseCommand
+      def run_command(message_object)
+        Invoker.commander.on_next_tick(message_object.process_name) do |process_name|
+          start_process_by_name(process_name)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/invoker/ipc/add_http_command.rb

@@ -0,0 +1,10 @@
+module Invoker
+  module IPC
+    class AddHttpCommand < BaseCommand
+      def run_command(message_object)
+        Invoker.dns_cache.add(message_object.process_name, message_object.port)
+        true
+      end
+    end
+  end
+end

data/lib/invoker/ipc/base_command.rb

@@ -0,0 +1,24 @@
+module Invoker
+  module IPC
+    class BaseCommand
+      attr_accessor :client_socket
+      def initialize(client_socket)
+        @client_socket = client_socket
+      end
+
+      def send_data(message_object)
+        client_socket.write(message_object.encoded_message)
+      end
+
+      # Invoke the command that actual processes incoming message
+      # returning true from this message means, command has been processed
+      # and client socket can be closed. returning false means, it is a
+      # long running command and socket should not be closed immediately
+      # @param [Invoker::IPC::Message] incoming message
+      # @return [Boolean] true or false
+      def run_command(message_object)
+        raise "Not implemented"
+      end
+    end
+  end
+end

data/lib/invoker/ipc/client_handler.rb

@@ -0,0 +1,26 @@
+module Invoker
+  module IPC
+    class ClientHandler
+      attr_accessor :client_socket
+      def initialize(client_socket)
+        @client_socket = client_socket
+      end
+
+      def read_and_execute
+        client_handler, message_object = read_incoming_command
+        client_socket.close if client_handler.run_command(message_object)
+      rescue StandardError => error
+        Invoker::Logger.puts error.message
+        Invoker::Logger.puts error.backtrace
+        client_socket.close
+      end
+
+      private
+
+      def read_incoming_command
+        message_object = Invoker::IPC.message_from_io(client_socket)
+        [message_object.command_handler_klass.new(client_socket), message_object]
+      end
+    end
+  end
+end

data/lib/invoker/ipc/dns_check_command.rb

@@ -0,0 +1,16 @@
+module Invoker
+  module IPC
+    class DnsCheckCommand < BaseCommand
+      def run_command(message_object)
+        process_detail = Invoker.dns_cache[message_object.process_name]
+
+        dns_check_response = Invoker::IPC::Message::DnsCheckResponse.new(
+          process_name: message_object.process_name,
+          port: process_detail ? process_detail['port'] : nil
+        )
+        send_data(dns_check_response)
+        true
+      end
+    end
+  end
+end

data/lib/invoker/ipc/list_command.rb

@@ -0,0 +1,11 @@
+module Invoker
+  module IPC
+    class ListCommand < BaseCommand
+      def run_command(message_object)
+        list_response = Invoker.commander.process_list
+        send_data(list_response)
+        true
+      end
+    end
+  end
+end

data/lib/invoker/ipc/message.rb

@@ -0,0 +1,170 @@
+module Invoker
+  module IPC
+    module Message
+      module Serialization
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        def as_json
+          attributes.merge(type: message_type)
+        end
+
+        def to_json
+          JSON.generate(as_json)
+        end
+
+        def message_attributes
+          self.class.message_attributes
+        end
+
+        def encoded_message
+          json_data = to_json
+          json_size = json_data.length.to_s
+          length_str = json_size.rjust(Invoker::IPC::INITIAL_PACKET_SIZE, '0')
+          length_str + json_data
+        end
+
+        def eql?(other)
+          other.class == self.class &&
+            compare_attributes(other)
+        end
+
+        def attributes
+          message_attribute_keys = message_attributes || []
+          message_attribute_keys.reduce({}) do |mem, obj|
+            value = send(obj)
+            if value.is_a?(Array)
+              mem[obj] = serialize_array(value)
+            elsif value.is_a?(Hash)
+              mem[obj] = serialize_hash(value)
+            else
+              mem[obj] = value.respond_to?(:as_json) ? value.as_json : encode_as_utf(value)
+            end
+            mem
+          end
+        end
+
+        private
+
+        def compare_attributes(other)
+          message_attributes.all? do |attribute_name|
+            send(attribute_name).eql?(other.send(attribute_name))
+          end
+        end
+
+        def encode_as_utf(value)
+          return value unless value.is_a?(String)
+          value.encode("utf-8", invalid: :replace, undef: :replace, replace: '_')
+        end
+
+        def serialize_array(attribute_array)
+          attribute_array.map do |x|
+            x.respond_to?(:as_json) ? x.as_json : encode_as_utf(x)
+          end
+        end
+
+        def serialize_hash(attribute_hash)
+          attribute_hash.inject({}) do |temp_mem, (temp_key, temp_value)|
+            if temp_value.respond_to?(:as_json)
+              temp_mem[temp_key] = temp_value.as_json
+            else
+              temp_mem[temp_key] = encode_as_utf(temp_value)
+            end
+          end
+        end
+
+        module ClassMethods
+          def message_attributes(*incoming_attributes)
+            if incoming_attributes.empty? && defined?(@message_attributes)
+              @message_attributes
+            else
+              @message_attributes ||= []
+              new_attributes = incoming_attributes.flatten
+              @message_attributes += new_attributes
+              attr_accessor *new_attributes
+            end
+          end
+        end
+      end
+
+      class Base
+        def initialize(options)
+          options.each do |key, value|
+            if self.respond_to?("#{key}=")
+              send("#{key}=", value)
+            end
+          end
+        end
+
+        def message_type
+          Invoker::IPC.underscore(self.class.name).split("/").last
+        end
+
+        def command_handler_klass
+          Invoker::IPC.const_get("#{IPC.camelize(message_type)}Command")
+        end
+      end
+
+      class Add < Base
+        include Serialization
+        message_attributes :process_name
+      end
+
+      class Tail < Base
+        include Serialization
+        message_attributes :process_names
+      end
+
+      class AddHttp < Base
+        include Serialization
+        message_attributes :process_name, :port
+      end
+
+      class Reload < Base
+        include Serialization
+        message_attributes :process_name, :signal
+
+        def remove_message
+          Remove.new(process_name: process_name, signal: signal)
+        end
+      end
+
+      class List < Base
+        include Serialization
+      end
+
+      class Process < Base
+        include Serialization
+        message_attributes :process_name, :shell_command, :dir, :pid
+      end
+
+      class Remove < Base
+        include Serialization
+        message_attributes :process_name, :signal
+      end
+
+      class DnsCheck < Base
+        include Serialization
+        message_attributes :process_name
+      end
+
+      class DnsCheckResponse < Base
+        include Serialization
+        message_attributes :process_name, :port
+      end
+
+      class Ping < Base
+        include Serialization
+      end
+
+      class Pong < Base
+        include Serialization
+        message_attributes :status
+      end
+    end
+  end
+end
+
+require "invoker/ipc/message/list_response"
+require "invoker/ipc/message/tail_response"

data/lib/invoker/ipc/message/list_response.rb

@@ -0,0 +1,33 @@
+module Invoker
+  module IPC
+    module Message
+      class ListResponse < Base
+        include Serialization
+        message_attributes :processes
+        def initialize(options)
+          self.processes = []
+          process_array = options[:processes] || options['processes']
+          process_array.each do |process_hash|
+            processes << Process.new(process_hash)
+          end
+        end
+
+        def self.from_workers(workers)
+          process_array = []
+          Invoker.config.processes.each do |process|
+            worker_attrs = {
+              :shell_command => process.cmd, :process_name => process.label,
+              :dir => process.dir
+            }
+            if worker = workers[process.label]
+              worker_attrs.update(pid: worker.pid)
+            end
+            process_array << worker_attrs
+          end
+
+          new(processes: process_array)
+        end
+      end
+    end
+  end
+end

data/lib/invoker/ipc/message/tail_response.rb

@@ -0,0 +1,10 @@
+module Invoker
+  module IPC
+    module Message
+      class TailResponse < Base
+        include Serialization
+        message_attributes :tail_line
+      end
+    end
+  end
+end

data/lib/invoker/ipc/ping_command.rb

@@ -0,0 +1,10 @@
+module Invoker
+  module IPC
+    class PingCommand < BaseCommand
+      def run_command(message_object)
+        pong = Invoker::IPC::Message::Pong.new(status: 'pong')
+        send_data(pong)
+      end
+    end
+  end
+end

data/lib/invoker/ipc/reload_command.rb

@@ -0,0 +1,12 @@
+module Invoker
+  module IPC
+    class ReloadCommand < BaseCommand
+      def run_command(message_object)
+        Invoker.commander.on_next_tick(message_object) do |reload_message|
+          restart_process(reload_message)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/invoker/ipc/remove_command.rb

@@ -0,0 +1,12 @@
+module Invoker
+  module IPC
+    class RemoveCommand < BaseCommand
+      def run_command(message_object)
+        Invoker.commander.on_next_tick(message_object) do |remove_message|
+          stop_process(remove_message)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/invoker/{command_listener → ipc}/server.rb

@@ -1,31 +1,26 @@
 require "fileutils"
 
 module Invoker
-  module CommandListener
+  module IPC
     class Server
       SOCKET_PATH = "/tmp/invoker"
       def initialize
         @open_clients = []
-        Socket.unix_server_loop(SOCKET_PATH) {|sock, client_addrinfo|
-          begin
-            process_client(sock)
-          ensure
-            sock.close
-          end
-        }
+        Socket.unix_server_loop(SOCKET_PATH) do |sock, client_addrinfo|
+          Thread.new { process_client(sock) }
+        end
       end
 
       def clean_old_socket
-        if File.exists?(SOCKET_PATH)
+        if File.exist?(SOCKET_PATH)
           FileUtils.rm(SOCKET_PATH, :force => true)
         end
       end
 
       def process_client(client_socket)
-        client = Invoker::CommandListener::Client.new(client_socket)
+        client = Invoker::IPC::ClientHandler.new(client_socket)
         client.read_and_execute
       end
     end
   end
-
 end