meepo 1.5.2

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/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".color(: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".color(:red))
+      end
+
+      def send_json_message(socket, message_object)
+        socket.write(message_object.encoded_message)
+      end
+    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

data/lib/invoker/parsers/config.rb

@@ -0,0 +1,184 @@
+require 'iniparse'
+
+module Invoker
+  module Parsers
+    class Config
+      PORT_REGEX = /\$PORT/
+
+      attr_accessor :processes, :power_config
+      attr_reader :filename
+
+      # initialize takes a port form cli and decrements it by 1 and sets the
+      # instance variable @port. This port value is used as the environment
+      # variable $PORT mentioned inside invoker.ini. When method pick_port gets
+      # fired it increments the value of port by 1, subsequently when pick_port
+      # again gets fired, for another command, it will again increment port
+      # value by 1, that way generating different ports for different commands.
+      def initialize(filename, port)
+        @filename = filename || autodetect_config_file
+        print_message_and_abort if invalid_config_file?
+
+        @port = port - 1
+        @processes = load_config
+        if Invoker.can_run_balancer?
+          @power_config = Invoker::Power::Config.load_config()
+        end
+      end
+
+      def http_port
+        power_config && power_config.http_port
+      end
+
+      def dns_port
+        power_config && power_config.dns_port
+      end
+
+      def https_port
+        power_config && power_config.https_port
+      end
+
+      def tld
+        power_config && power_config.tld
+      end
+
+      def autorunnable_processes
+        process_to_run = processes.reject(&:disable_autorun)
+        process_to_run.sort_by { |process| process.index }
+      end
+
+      def process(label)
+        processes.detect { |pconfig| pconfig.label == label }
+      end
+
+      private
+
+      def autodetect_config_file
+        Dir.glob("{invoker.ini,Procfile}").first
+      end
+
+      def invalid_config_file?
+        @filename.nil?
+      end
+
+      def load_config
+        @filename = to_global_file if is_global?
+
+        if is_ini?
+          process_ini
+        elsif is_procfile?
+          process_procfile
+        else
+          print_message_and_abort
+        end
+      end
+
+      def process_ini
+        ini_content = File.read(@filename)
+        document = IniParse.parse(ini_content)
+        document.map do |section|
+          check_directory(section["directory"])
+          process_command_from_section(section)
+        end
+      end
+
+      def process_procfile
+        procfile = Invoker::Parsers::Procfile.new(@filename)
+        procfile.entries.map do |name, command|
+          section = { "label" => name, "command" => command }
+          process_command_from_section(section)
+        end
+      end
+
+      def print_message_and_abort
+        Invoker::Logger.puts("\n Invalid config file. Invoker requires an ini or a Procfile.".color(:red))
+        abort
+      end
+
+      def process_command_from_section(section)
+        if supports_subdomain?(section)
+          port = pick_port(section)
+          if port
+            command = replace_port_in_command(section['command'], port)
+            section['port'], section['command'] = port, command
+          end
+        end
+
+        make_pconfig(section)
+      end
+
+      def pick_port(section)
+        if section['command'] =~ PORT_REGEX
+          @port += 1
+        elsif section['port']
+          section['port']
+        else
+          nil
+        end
+      end
+
+      def make_pconfig(section)
+        pconfig = {
+          label: section["label"] || section.key,
+          dir: expand_directory(section["directory"]),
+          cmd: section["command"]
+        }
+        pconfig['port'] = section['port'] if section['port']
+        pconfig['disable_autorun'] = section['disable_autorun'] if section['disable_autorun']
+        pconfig['index'] = section['index'].to_i if section['index']
+        section_index = pconfig['index'].to_i
+        if section_index
+          pconfig['index'] = section_index
+        else
+          pconfig['index'] = 0
+        end
+
+        sleep_duration = section['sleep'].to_i
+        if sleep_duration > 0
+          pconfig['sleep_duration'] = sleep_duration
+        else
+          pconfig['sleep_duration'] = 1
+        end
+
+        OpenStruct.new(pconfig)
+      end
+
+      def supports_subdomain?(section)
+        (section['command'] =~ PORT_REGEX) || section['port']
+      end
+
+      def check_directory(app_dir)
+        if app_dir && !app_dir.empty? && !File.directory?(expand_directory(app_dir))
+          raise Invoker::Errors::InvalidConfig.new("Invalid directory #{app_dir}")
+        end
+      end
+
+      def expand_directory(app_dir)
+        File.expand_path(app_dir) if app_dir
+      end
+
+      def replace_port_in_command(command, port)
+        if command =~ PORT_REGEX
+          command.gsub(PORT_REGEX, port.to_s)
+        else
+          command
+        end
+      end
+
+      def is_ini?
+        File.extname(@filename) == '.ini'
+      end
+
+      def is_procfile?
+        @filename =~ /Procfile/
+      end
+
+      def to_global_file
+        File.join(Invoker::Power::Config.config_dir, "#{@filename}.ini")
+      end
+
+      def is_global?
+        @filename =~ /^\w+$/ && File.exist?(to_global_file)
+      end
+    end
+  end
+end

data/lib/invoker/parsers/procfile.rb

@@ -0,0 +1,86 @@
+module Invoker
+  module Parsers
+    # rip off from foreman
+    class Procfile
+      # Initialize a Procfile
+      #
+      # @param [String] filename (nil)  An optional filename to read from
+      #
+      def initialize(filename=nil)
+        @entries = []
+        load(filename) if filename
+      end
+
+      # Yield each +Procfile+ entry in order
+      #
+      def entries
+        return @entries unless block_given?
+        @entries.each do |(name, command)|
+          yield name, command
+        end
+      end
+
+      # Retrieve a +Procfile+ command by name
+      #
+      # @param [String] name  The name of the Procfile entry to retrieve
+      #
+      def [](name)
+        @entries.detect { |n,c| name == n }.last
+      end
+
+      # Create a +Procfile+ entry
+      #
+      # @param [String] name     The name of the +Procfile+ entry to create
+      # @param [String] command  The command of the +Procfile+ entry to create
+      #
+      def []=(name, command)
+        delete name
+        @entries << [name, command]
+      end
+
+      # Remove a +Procfile+ entry
+      #
+      # @param [String] name  The name of the +Procfile+ entry to remove
+      #
+      def delete(name)
+        @entries.reject! { |n,c| name == n }
+      end
+
+      # Load a Procfile from a file
+      #
+      # @param [String] filename  The filename of the +Procfile+ to load
+      #
+      def load(filename)
+        @entries.replace parse(filename)
+      end
+
+      # Save a Procfile to a file
+      #
+      # @param [String] filename  Save the +Procfile+ to this file
+      #
+      def save(filename)
+        File.open(filename, 'w') do |file|
+          file.puts self.to_s
+        end
+      end
+
+      # Get the +Procfile+ as a +String+
+      #
+      def to_s
+        @entries.map do |name, command|
+          [ name, command ].join(": ")
+        end.join("\n")
+      end
+
+      private
+
+      def parse(filename)
+        File.read(filename).gsub("\r\n","\n").split("\n").map do |line|
+          if line =~ /^([A-Za-z0-9_-]+):\s*(.+)$/
+            [$1, $2]
+          end
+        end.compact
+      end
+    end
+  end
+end