meepo 1.5.2

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, ip = nil)
+      @dns_mutex.synchronize { dns_data[name] = { 'port' => port, 'ip' => ip } }
+    end
+  end
+end

data/lib/invoker/errors.rb

@@ -0,0 +1,17 @@
+module Invoker
+  module Errors
+    class ToomanyOpenConnections < StandardError; end
+    class ProcessTerminated < StandardError
+      attr_accessor :message, :ready_fd
+      def initialize(ready_fd, message)
+        @ready_fd = ready_fd
+        @message = message
+      end
+    end
+
+    class NoValidPortFound < StandardError; end
+    class InvalidConfig < StandardError; end
+    class InvalidFile < StandardError; end
+    class ClientDisconnected < StandardError; end
+  end
+end

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.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, 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.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"