invoker 1.0.4 → 1.1.0

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/parsers/config.rb

@@ -28,6 +28,7 @@ module Invoker
       end
 
       private
+
       def load_config
         if is_ini?
           process_ini

data/lib/invoker/power/balancer.rb

@@ -1,3 +1,6 @@
+require 'em-proxy'
+require 'http-parser'
+
 module Invoker
   module Power
     class BalancerConnection < EventMachine::ProxyServer::Connection
@@ -45,7 +48,7 @@ module Invoker
       DEV_MATCH_REGEX = /([\w-]+)\.dev(\:\d+)?$/
 
       def self.run(options = {})
-        EventMachine.start_server('0.0.0.0', Invoker::CONFIG.http_port,
+        EventMachine.start_server('0.0.0.0', Invoker.config.http_port,
                                   BalancerConnection, options) do |connection|
           balancer = Balancer.new(connection)
           balancer.install_callbacks
@@ -68,9 +71,9 @@ module Invoker
 
       def headers_received(header)
         @session = UUID.generate()
-        config = select_backend_config(header['Host'])
-        if config
-          connection.server(session, host: '0.0.0.0', port: config.port)
+        dns_check_response = select_backend_config(header['Host'])
+        if dns_check_response && dns_check_response.port
+          connection.server(session, host: '0.0.0.0', port: dns_check_response.port)
           connection.relay_to_servers(@buffer.join)
           @buffer = []
         else
@@ -102,13 +105,13 @@ module Invoker
       end
 
       def frontend_disconnect(backend, name)
-        http_parser.reset()
+        http_parser.reset
         unless @backend_data
           Invoker::Logger.puts("\nApplication not running. Returning error page.".color(:red))
           return_error_page(503)
         end
         @backend_data = false
-        connection.close_connection_after_writing() if backend == session
+        connection.close_connection_after_writing if backend == session
       end
 
       def extract_host_from_domain(host)
@@ -116,16 +119,23 @@ module Invoker
       end
 
       private
+
       def select_backend_config(host)
         matching_string = extract_host_from_domain(host)
         return nil unless matching_string
         if selected_app = matching_string[1]
-          Invoker::CONFIG.process(selected_app)
+          dns_check(process_name: selected_app)
         else
           nil
         end
       end
 
+      def dns_check(dns_args)
+        Invoker::IPC::UnixClient.send_command("dns_check", dns_args) do |dns_response|
+          dns_response
+        end
+      end
+
       def return_error_page(status)
         http_response = Invoker::Power::HttpResponse.new()
         http_response.status = status

data/lib/invoker/power/config.rb

@@ -1,12 +1,15 @@
 require "yaml"
+
 module Invoker
   module Power
     # Save and Load Invoker::Power config
     class ConfigExists < StandardError; end
+
     class Config
-      CONFIG_LOCATION = File.join(ENV['HOME'], ".invoker")
+      CONFIG_LOCATION = File.join(Dir.home, ".invoker", "config")
+
       def self.has_config?
-        File.exists?(CONFIG_LOCATION)
+        File.exist?(CONFIG_LOCATION)
       end
 
       def self.create(options = {})
@@ -18,7 +21,7 @@ module Invoker
       end
 
       def self.delete
-        if File.exists?(CONFIG_LOCATION)
+        if File.exist?(CONFIG_LOCATION)
           File.delete(CONFIG_LOCATION)
         end
       end

data/lib/invoker/power/dns.rb

@@ -1,37 +1,38 @@
 require "logger"
+require 'rubydns'
 
 module Invoker
-
   module Power
-
-    class DNS
-      IN = Resolv::DNS::Resource::IN
+    class DNS < RubyDNS::Server
       def self.server_ports
         [
-          [:udp, '127.0.0.1', Invoker::CONFIG.dns_port],
-          [:tcp, '127.0.0.1', Invoker::CONFIG.dns_port]
+          [:udp, '127.0.0.1', Invoker.config.dns_port],
+          [:tcp, '127.0.0.1', Invoker.config.dns_port]
         ]
       end
 
-      def self.run_dns
-        RubyDNS::run_server(:listen => server_ports) do
-          on(:start) do
-            @logger.level = ::Logger::WARN
-          end
-
-          # For this exact address record, return an IP address
-          match(/.*\.dev/, IN::A) do |transaction|
-            transaction.respond!("127.0.0.1")
-          end
+      def initialize
+        @logger = ::Logger.new($stderr)
+        @logger.level = ::Logger::FATAL
+      end
 
-          # Default DNS handler
-          otherwise do |transaction|
-            transaction.failure!(:NXDomain)
-          end
+      def process(name, resource_class, transaction)
+        if name_matches?(name) && resource_class_matches?(resource_class)
+          transaction.respond!("127.0.0.1")
+        else
+          transaction.fail!(:NXDomain)
         end
       end
 
-    end
+      private
 
+      def resource_class_matches?(resource_class)
+        resource_class == Resolv::DNS::Resource::IN::A
+      end
+
+      def name_matches?(name)
+        name =~ /.*\.dev/
+      end
+    end
   end
 end

data/lib/invoker/power/http_response.rb

@@ -56,7 +56,7 @@ module Invoker
           file_content = File.read(file_name)
           self.body = file_content
         else
-          raise Invoker::Errors:InvalidFile, "Invalid file as body"
+          raise Invoker::Errors::InvalidFile, "Invalid file as body"
         end
       end
 

data/lib/invoker/power/power.rb

@@ -0,0 +1,3 @@
+require "invoker/power/http_response"
+require "invoker/power/dns"
+require "invoker/power/balancer"

data/lib/invoker/power/powerup.rb

@@ -8,12 +8,13 @@ module Invoker
       end
 
       def run
+        require "invoker/power/power"
         EM.epoll
         EM.run {
           trap("TERM") { stop }
           trap("INT") { stop }
-          DNS.run_dns()
-          Balancer.run()
+          DNS.new.run(listen: DNS.server_ports)
+          Balancer.run
         }
       end
 

data/lib/invoker/power/setup.rb

@@ -1,4 +1,4 @@
-require "highline/import"
+require "eventmachine"
 
 module Invoker
   module Power
@@ -42,7 +42,7 @@ module Invoker
       end
 
       def uninstall_invoker
-        uninstall_invoker_flag = agree("Are you sure you want to uninstall firewall rules created by setup (y/n) : ")
+        uninstall_invoker_flag = Invoker::CLI::Question.agree("Are you sure you want to uninstall firewall rules created by setup (y/n) : ")
 
         if uninstall_invoker_flag
           remove_resolver_file
@@ -62,6 +62,7 @@ module Invoker
       end
 
       def create_config_file
+        Invoker.setup_config_location
         Invoker::Power::Config.create(
           dns_port: port_finder.dns_port,
           http_port: port_finder.http_port
@@ -162,7 +163,7 @@ port #{dns_port}
         Invoker::Logger.puts "If you have already uninstalled Pow, proceed with installation"\
           " by pressing y/n."
 
-        replace_resolver_flag = agree("Replace Pow configuration (y/n) : ")
+        replace_resolver_flag = Invoker::CLI::Question.agree("Replace Pow configuration (y/n) : ")
 
         if replace_resolver_flag
           Invoker::Logger.puts "Invoker has overwritten one or more files created by Pow. "\
@@ -173,12 +174,13 @@ port #{dns_port}
       end
 
       private
+
       def open_resolver_for_write
         FileUtils.mkdir(RESOLVER_DIR) unless Dir.exists?(RESOLVER_DIR)
         fl = File.open(RESOLVER_FILE, "w")
         yield fl
       ensure
-        fl && fl.close()
+        fl && fl.close
       end
 
     end

data/lib/invoker/process_manager.rb

@@ -0,0 +1,187 @@
+module Invoker
+  # Class is responsible for managing all the processes Invoker is supposed
+  # to manage. Takes care of starting, stopping and restarting processes.
+  class ProcessManager
+    LABEL_COLORS = [:green, :yellow, :blue, :magenta, :cyan]
+    attr_accessor :open_pipes, :workers
+
+    def initialize
+      @open_pipes = {}
+      @workers = {}
+      @worker_mutex = Mutex.new
+      @thread_group = ThreadGroup.new
+    end
+
+    def start_process(process_info)
+      m, s = PTY.open
+      s.raw! # disable newline conversion.
+
+      pid = run_command(process_info, s)
+
+      s.close
+
+      worker = CommandWorker.new(process_info.label, m, pid, select_color)
+
+      add_worker(worker)
+      wait_on_pid(process_info.label, pid)
+    end
+
+    # Start a process given their name
+    # @param process_name [String] Command label of process specified in config file.
+    def start_process_by_name(process_name)
+      if process_running?(process_name)
+        Invoker::Logger.puts "\nProcess '#{process_name}' is already running".color(:red)
+        return false
+      end
+
+      process_info = Invoker.config.process(process_name)
+      start_process(process_info) if process_info
+    end
+
+    # Remove a process from list of processes managed by invoker supervisor.It also
+    # kills the process before removing it from the list.
+    #
+    # @param remove_message [Invoker::IPC::Message::Remove]
+    # @return [Boolean] if process existed and was removed else false
+    def stop_process(remove_message)
+      worker = workers[remove_message.process_name]
+      command_label = remove_message.process_name
+      return false unless worker
+      signal_to_use = remove_message.signal || 'INT'
+
+      Invoker::Logger.puts("Removing #{command_label} with signal #{signal_to_use}".color(:red))
+      kill_or_remove_process(worker.pid, signal_to_use, command_label)
+    end
+
+    # Receive a message from user to restart a Process
+    # @param [Invoker::IPC::Message::Reload]
+    def restart_process(reload_message)
+      command_label = reload_message.process_name
+      if stop_process(reload_message.remove_message)
+        Invoker.commander.schedule_event(command_label, :worker_removed) do
+          start_process_by_name(command_label)
+        end
+      else
+        start_process_by_name(command_label)
+      end
+    end
+
+    def run_power_server
+      return unless Invoker.can_run_balancer?(false)
+
+      powerup_id = Invoker::Power::Powerup.fork_and_start
+      wait_on_pid("powerup_manager", powerup_id)
+      at_exit do
+        begin
+          Process.kill("INT", powerup_id)
+        rescue Errno::ESRCH; end
+      end
+    end
+
+    # Given a file descriptor returns the worker object
+    #
+    # @param fd [IO] an IO object with valid file descriptor
+    # @return [Invoker::CommandWorker] The worker object which is associated with this fd
+    def get_worker_from_fd(fd)
+      open_pipes[fd.fileno]
+    end
+
+    def load_env(directory = nil)
+      directory ||= ENV['PWD']
+      default_env = File.join(directory, '.env')
+      return {} unless File.exist?(default_env)
+      Dotenv::Environment.new(default_env)
+    end
+
+    def kill_workers
+      @workers.each do |key, worker|
+        begin
+          Process.kill("INT", -Process.getpgid(worker.pid))
+        rescue Errno::ESRCH
+          Invoker::Logger.puts "Error killing #{key}"
+        end
+      end
+      @workers = {}
+    end
+
+    # List currently running commands
+    def process_list
+      Invoker::IPC::Message::ListResponse.from_workers(workers)
+    end
+
+    private
+
+    def wait_on_pid(command_label, pid)
+      raise Invoker::Errors::ToomanyOpenConnections if @thread_group.enclosed?
+
+      thread = Thread.new do
+        Process.wait(pid)
+        message = "Process with command #{command_label} exited with status #{$?.exitstatus}"
+        Invoker::Logger.puts("\n#{message}".color(:red))
+        Invoker.notify_user(message)
+        Invoker.commander.trigger(command_label, :exit)
+      end
+      @thread_group.add(thread)
+    end
+
+    def select_color
+      selected_color = LABEL_COLORS.shift
+      LABEL_COLORS.push(selected_color)
+      selected_color
+    end
+
+    def process_running?(command_label)
+      !!workers[command_label]
+    end
+
+    def kill_or_remove_process(pid, signal_to_use, command_label)
+      process_kill(pid, signal_to_use)
+      true
+    rescue Errno::ESRCH
+      Invoker::Logger.puts("Killing process with #{pid} and name #{command_label} failed".color(:red))
+      remove_worker(command_label, false)
+      false
+    end
+
+    def process_kill(pid, signal_to_use)
+      if signal_to_use.to_i == 0
+        Process.kill(signal_to_use, -Process.getpgid(pid))
+      else
+        Process.kill(signal_to_use.to_i, -Process.getpgid(pid))
+      end
+    end
+
+    # Remove worker from all collections
+    def remove_worker(command_label, trigger_event = true)
+      worker = @workers[command_label]
+      if worker
+        @open_pipes.delete(worker.pipe_end.fileno)
+        @workers.delete(command_label)
+      end
+      if trigger_event
+        Invoker.commander.trigger(command_label, :worker_removed)
+      end
+    end
+
+    # add worker to global collections
+    def add_worker(worker)
+      @open_pipes[worker.pipe_end.fileno] = worker
+      @workers[worker.command_label] = worker
+      Invoker.commander.watch_for_read(worker.pipe_end)
+    end
+
+    def run_command(process_info, write_pipe)
+      command_label = process_info.label
+
+      Invoker.commander.schedule_event(command_label, :exit) { remove_worker(command_label) }
+
+      env_options = load_env(process_info.dir)
+
+      spawn_options = {
+        :chdir => process_info.dir || ENV['PWD'], :out => write_pipe, :err => write_pipe,
+        :pgroup => true, :close_others => true, :in => :close
+      }
+      Invoker.run_without_bundler { spawn(env_options, process_info.cmd, spawn_options) }
+    end
+  end
+end