itrg-invoker 1.6.0

data/lib/invoker/event/manager.rb

@@ -0,0 +1,79 @@
+module Invoker
+  module Event
+    class Manager
+      attr_accessor :scheduled_events, :triggered_events
+
+      def initialize
+        @scheduled_events = Hash.new {|h,k| h[k] = [] }
+        @triggered_events = []
+        @trigger_mutex = Mutex.new()
+      end
+
+      # Trigger an event. The event is not triggered immediately, but is just scheduled to be
+      # triggered.
+      #
+      # @param command_label [String] Command for which event should be triggered
+      # @param event_name [Symbol, nil] The optional event name
+      def trigger(command_label, event_name = nil)
+        @trigger_mutex.synchronize do
+          triggered_events << OpenStruct.new(
+            :command_label => command_label, 
+            :event_name => event_name)
+        end
+      end
+
+      # Schedule an Event. The event will only trigger when a scheduled event matches
+      # a triggered event.
+      #
+      # @param command_label [String] Command for which the event should be triggered
+      # @param event_name [String, nil] Optional event name
+      # @param block The block to execute when event actually triggers
+      def schedule_event(command_label, event_name = nil, &block)
+        @trigger_mutex.synchronize do
+          scheduled_events[command_label] << OpenStruct.new(:event_name => event_name, :block => block)
+        end
+      end
+
+      # On next iteration of event loop, this method is called and we try to match
+      # scheduled events with events that were triggered. 
+      def run_scheduled_events
+        filtered_events_by_name_and_command = []
+
+        triggered_events.each_with_index do |triggered_event, index|
+          matched_events = scheduled_events[triggered_event.command_label]
+          if matched_events && !matched_events.empty?
+            filtered_events_by_name_and_command, unmatched_events = 
+              filter_matched_events(matched_events, triggered_event)
+            triggered_events[index] = nil
+            remove_scheduled_event(unmatched_events, triggered_event.command_label)
+          end
+        end
+        triggered_events.compact!
+
+        filtered_events_by_name_and_command.each {|event| yield event }
+      end
+
+      private
+      def filter_matched_events(matched_events, event)
+        matched_filtered_events = []
+        
+        matched_events.each_with_index do |matched_event, index|
+          if !event.event_name || event.event_name == matched_event.event_name
+            matched_filtered_events << matched_event
+            matched_events[index] = nil
+          end
+        end
+        [matched_filtered_events, matched_events.compact]
+      end
+
+      def remove_scheduled_event(matched_events, command_label)
+        if !matched_events || matched_events.empty?
+          scheduled_events.delete(command_label)
+        else
+          scheduled_events[command_label] = matched_events
+        end
+      end
+
+    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, message_object.ip)
+        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,17 @@
+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,
+          ip: process_detail && process_detail['ip'] ? process_detail['ip'] : '0.0.0.0'
+        )
+        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/list_response.rb

@@ -0,0 +1,35 @@
+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,
+              port: process.port
+            }
+            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/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, :ip
+      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, :port
+      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, :ip
+      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/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/ipc/server.rb

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

data/lib/invoker/ipc/tail_command.rb

@@ -0,0 +1,11 @@
+module Invoker
+  module IPC
+    class TailCommand < BaseCommand
+      def run_command(message_object)
+        Invoker::Logger.puts("Adding #{message_object.process_names.inspect}")
+        Invoker.tail_watchers.add(message_object.process_names, client_socket)
+        false
+      end
+    end
+  end
+end

data/lib/invoker/ipc/unix_client.rb

@@ -0,0 +1,60 @@
+module Invoker
+  module IPC
+    class UnixClient
+      def send_command(command, message = {})
+        message_object = get_message_object(command, message)
+        open_client_socket do |socket|
+          send_json_message(socket, message_object)
+          socket.flush
+          if block_given?
+            response_object = Invoker::IPC.message_from_io(socket)
+            yield response_object
+          end
+        end
+      end
+
+      def send_and_receive(command, message = {})
+        response = nil
+        message_object = get_message_object(command, message)
+        open_client_socket(false) do |socket|
+          send_json_message(socket, message_object)
+          socket.flush
+          response = Invoker::IPC.message_from_io(socket)
+        end
+        response
+      end
+
+      def send_and_wait(command, message = {})
+        begin
+          socket = Socket.unix(Invoker::IPC::Server::SOCKET_PATH)
+        rescue
+          abort("Invoker does not seem to be running".colorize(:red))
+        end
+        message_object = get_message_object(command, message)
+        send_json_message(socket, message_object)
+        socket.flush
+        socket
+      end
+
+      def self.send_command(command, message_arguments = {}, &block)
+        new.send_command(command, message_arguments, &block)
+      end
+
+      private
+
+      def get_message_object(command, message_arguments)
+        Invoker::IPC::Message.const_get(Invoker::IPC.camelize(command)).new(message_arguments)
+      end
+
+      def open_client_socket(abort_if_not_running = true)
+        Socket.unix(Invoker::IPC::Server::SOCKET_PATH) { |socket| yield socket }
+      rescue
+        abort_if_not_running && abort("Invoker does not seem to be running".colorize(:red))
+      end
+
+      def send_json_message(socket, message_object)
+        socket.write(message_object.encoded_message)
+      end
+    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/logger.rb

@@ -0,0 +1,13 @@
+module Invoker
+  class Logger
+    def self.puts(message)
+      return if ENV["INVOKER_TESTS"]
+      $stdout.puts(message)
+    end
+
+    def self.print(message)
+      return if ENV["INVOKER_TESTS"]
+      $stdout.print(message)
+    end
+  end
+end