meepo 1.5.2

data/lib/invoker/cli.rb

@@ -0,0 +1,159 @@
+require "socket"
+require "thor"
+
+module Invoker
+  class CLI < Thor
+    def self.start(*args)
+      cli_args = args.flatten
+      # If it is not a valid task, it is probably file argument
+      if default_start_command?(cli_args)
+        args = [cli_args.unshift("start")]
+      end
+      super(*args)
+    end
+
+    desc "setup", "Run Invoker setup"
+    option :tld,
+      type: :string,
+      banner: 'Configure invoker to use a different top level domain'
+    def setup
+      Invoker::Power::Setup.install(get_tld(options))
+    end
+
+    desc "version", "Print Invoker version"
+    def version
+      Invoker::Logger.puts Invoker::VERSION
+    end
+    map %w(-v --version) => :version
+
+    desc "uninstall", "Uninstall Invoker and all installed files"
+    def uninstall
+      Invoker::Power::Setup.uninstall
+    end
+
+    desc "start [CONFIG_FILE]", "Start Invoker Server"
+    option :port, type: :numeric, banner: "Port series to be used for starting rack servers"
+    option :daemon,
+      type: :boolean,
+      banner: "Daemonize the server into the background",
+      aliases: [:d]
+    def start(file = nil)
+      Invoker.setup_config_location
+      port = options[:port] || 9000
+      Invoker.daemonize = options[:daemon]
+      Invoker.load_invoker_config(file, port)
+      warn_about_notification
+      warn_about_old_configuration
+      pinger = Invoker::CLI::Pinger.new(unix_socket)
+      abort("Invoker is already running".color(:red)) if pinger.invoker_running?
+      Invoker.commander.start_manager
+    end
+
+    desc "add process", "Add a program to Invoker server"
+    def add(name)
+      unix_socket.send_command('add', process_name: name)
+    end
+
+    desc "add_http process_name port [IP]", "Add an external http process to Invoker DNS server"
+    def add_http(name, port, ip = nil)
+      unix_socket.send_command('add_http', process_name: name, port: port, ip: ip)
+    end
+
+    desc "tail process1 process2", "Tail a particular process"
+    def tail(*names)
+      tailer = Invoker::CLI::Tail.new(names)
+      tailer.run
+    end
+
+    desc "reload process", "Reload a process managed by Invoker"
+    option :signal,
+      banner: "Signal to send for killing the process, default is SIGINT",
+      aliases: [:s]
+    def reload(name)
+      signal = options[:signal] || 'INT'
+      unix_socket.send_command('reload', process_name: name, signal: signal)
+    end
+
+    desc "list", "List all running processes"
+    def list
+      unix_socket.send_command('list') do |response_object|
+        Invoker::ProcessPrinter.new(response_object).tap { |printer| printer.print_table }
+      end
+    end
+
+    desc "remove process", "Stop a process managed by Invoker"
+    option :signal,
+      banner: "Signal to send for killing the process, default is SIGINT",
+      aliases: [:s]
+    def remove(name)
+      signal = options[:signal] || 'INT'
+      unix_socket.send_command('remove', process_name: name, signal: signal)
+    end
+
+    desc "stop", "Stop Invoker daemon"
+    def stop
+      Invoker.daemon.stop
+    end
+
+    private
+
+    def self.default_start_command?(args)
+      command_name = args.first
+      command_name &&
+        !command_name.match(/^-/) &&
+        !valid_tasks.include?(command_name)
+    end
+
+    def self.valid_tasks
+      tasks.keys + ["help"]
+    end
+
+    def get_tld(options)
+      if options[:tld] && !options[:tld].empty?
+        options[:tld]
+      else
+        'dev'
+      end
+    end
+
+    def unix_socket
+      Invoker::IPC::UnixClient.new
+    end
+
+    def warn_about_notification
+      if Invoker.darwin?
+        warn_about_terminal_notifier
+      else
+        warn_about_libnotify
+      end
+    end
+
+    def warn_about_libnotify
+      require "libnotify"
+    rescue LoadError
+      Invoker::Logger.puts "You can install libnotify gem for Invoker notifications "\
+        "via system tray".color(:red)
+    end
+
+    def warn_about_terminal_notifier
+      if Invoker.darwin?
+        command_path = `which terminal-notifier`
+        if !command_path || command_path.empty?
+          Invoker::Logger.puts "You can enable OSX notification for processes "\
+            "by installing terminal-notifier gem".color(:red)
+        end
+      end
+    end
+
+    def warn_about_old_configuration
+      Invoker::Power::PfMigrate.new.tap do |pf_migrator|
+        pf_migrator.migrate
+      end
+    end
+  end
+end
+
+require "invoker/cli/question"
+require "invoker/cli/tail_watcher"
+require "invoker/cli/tail"
+require "invoker/cli/pinger"

data/lib/invoker/cli/pinger.rb

@@ -0,0 +1,23 @@
+require "timeout"
+
+module Invoker
+  class CLI::Pinger
+    attr_accessor :unix_client
+    def initialize(unix_client)
+      @unix_client = unix_client
+    end
+
+    def invoker_running?
+      response = send_ping_and_read_response
+      response && response.status == 'pong'
+    end
+
+    private
+
+    def send_ping_and_read_response
+      Timeout.timeout(2) { unix_client.send_and_receive('ping') }
+    rescue Timeout::Error
+      nil
+    end
+  end
+end

data/lib/invoker/cli/question.rb

@@ -0,0 +1,15 @@
+module Invoker
+  class CLI::Question
+    def self.agree(question_text)
+      $stdout.print(question_text)
+      answer = $stdin.gets
+      answer.strip!
+      if answer =~ /\Ay(?:es)?|no?\Z/i
+        answer =~ /\Ay(?:es)?\Z/i
+      else
+        $stdout.puts "Please enter 'yes' or 'no'."
+        agree(question_text)
+      end
+    end
+  end
+end

data/lib/invoker/cli/tail.rb

@@ -0,0 +1,34 @@
+module Invoker
+  class CLI::Tail
+    attr_accessor :process_names
+    def initialize(process_names)
+      verify_process_name(process_names)
+      @process_names = process_names
+      @unix_socket = Invoker::IPC::UnixClient.new
+    end
+
+    def run
+      socket = @unix_socket.send_and_wait('tail', process_names: process_names)
+      trap('INT') { socket.close }
+      loop do
+        message = read_next_line(socket)
+        break unless message
+        puts message.tail_line
+      end
+    end
+
+    private
+
+    def verify_process_name(process_names)
+      if process_names.empty?
+        abort("Tail command requires one or more process name")
+      end
+    end
+
+    def read_next_line(socket)
+      Invoker::IPC.message_from_io(socket)
+    rescue
+      nil
+    end
+  end
+end

data/lib/invoker/cli/tail_watcher.rb

@@ -0,0 +1,34 @@
+module Invoker
+  # This class defines sockets which are open for watching log files
+  class CLI::TailWatcher
+    attr_accessor :tail_watchers
+
+    def initialize
+      @tail_mutex = Mutex.new
+      @tail_watchers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def [](process_name)
+      @tail_mutex.synchronize { tail_watchers[process_name] }
+    end
+
+    def add(names, socket)
+      @tail_mutex.synchronize do
+        names.each { |name| tail_watchers[name] << socket }
+      end
+    end
+
+    def remove(name, socket)
+      @tail_mutex.synchronize do
+        client_list = tail_watchers[name]
+        client_list.delete(socket)
+        purge(name, socket) if client_list.empty?
+      end
+    end
+
+    def purge(name, socket)
+      tail_watchers.delete(name)
+      Invoker.close_socket(socket)
+    end
+  end
+end

data/lib/invoker/command_worker.rb

@@ -0,0 +1,60 @@
+module Invoker
+  class CommandWorker
+    attr_accessor :command_label, :pipe_end, :pid, :color
+
+    def initialize(command_label, pipe_end, pid, color)
+      @command_label = command_label
+      @pipe_end = pipe_end
+      @pid = pid
+      @color = color
+    end
+
+    # Copied verbatim from Eventmachine code
+    def receive_data data
+      (@buf ||= '') << data
+
+      while @buf.slice!(/(.*?)\r?\n/)
+        receive_line($1)
+      end
+    end
+
+    def unbind
+      Invoker::Logger.print(".")
+    end
+
+    # Print the lines received over the network
+    def receive_line(line)
+      tail_watchers = Invoker.tail_watchers[@command_label]
+      color_line = "#{@command_label.color(color)} : #{line}"
+      if tail_watchers && !tail_watchers.empty?
+        json_encoded_tail_response = tail_response(color_line)
+        if json_encoded_tail_response
+          tail_watchers.each { |tail_socket| send_data(tail_socket, json_encoded_tail_response) }
+        end
+      else
+        Invoker::Logger.puts color_line
+      end
+    end
+
+    def to_h
+      { command_label:  command_label, pid:  pid.to_s }
+    end
+
+    def send_data(socket, data)
+      socket.write(data)
+    rescue
+      Invoker::Logger.puts "Removing #{@command_label} watcher #{socket} from list"
+      Invoker.tail_watchers.remove(@command_label, socket)
+    end
+
+    private
+
+    # Encode current line as json and send the response.
+    def tail_response(line)
+      tail_response = Invoker::IPC::Message::TailResponse.new(tail_line: line)
+      tail_response.encoded_message
+    rescue
+      nil
+    end
+  end
+end

data/lib/invoker/commander.rb

@@ -0,0 +1,95 @@
+require "io/console"
+require 'pty'
+require "json"
+require "dotenv"
+require "forwardable"
+
+module Invoker
+  class Commander
+    attr_accessor :reactor, :process_manager
+    attr_accessor :event_manager, :runnables, :thread_group
+    extend Forwardable
+
+    def_delegators :@process_manager, :start_process_by_name, :stop_process
+    def_delegators :@process_manager, :restart_process, :get_worker_from_fd, :process_list
+
+    def_delegators :@event_manager, :schedule_event, :trigger
+    def_delegator :@reactor, :watch_for_read
+
+    def initialize
+      @thread_group = ThreadGroup.new
+      @runnable_mutex = Mutex.new
+
+      @event_manager = Invoker::Event::Manager.new
+      @runnables = []
+
+      @reactor = Invoker::Reactor.new
+      @process_manager = Invoker::ProcessManager.new
+      Thread.abort_on_exception = true
+    end
+
+    # Start the invoker process supervisor. This method starts a unix server
+    # in separate thread that listens for incoming commands.
+    def start_manager
+      verify_process_configuration
+      daemonize_app if Invoker.daemonize?
+      install_interrupt_handler
+      unix_server_thread = Thread.new { Invoker::IPC::Server.new }
+      @thread_group.add(unix_server_thread)
+      process_manager.run_power_server
+      Invoker.config.autorunnable_processes.each do |process_info|
+        process_manager.start_process(process_info)
+        Logger.puts("Starting process - #{process_info.label} waiting for #{process_info.sleep_duration} seconds...")
+        sleep(process_info.sleep_duration)
+      end
+      at_exit { process_manager.kill_workers }
+      start_event_loop
+    end
+
+    def on_next_tick(*args, &block)
+      @runnable_mutex.synchronize do
+        @runnables << OpenStruct.new(:args => args, :block => block)
+      end
+    end
+
+    def run_runnables
+      @runnables.each do |runnable|
+        instance_exec(*runnable.args, &runnable.block)
+      end
+      @runnables = []
+    end
+
+    private
+
+    def verify_process_configuration
+      if !Invoker.config.processes || Invoker.config.processes.empty?
+        raise Invoker::Errors::InvalidConfig.new("No processes configured in config file")
+      end
+    end
+
+    def start_event_loop
+      loop do
+        reactor.monitor_for_fd_events
+        run_runnables
+        run_scheduled_events
+      end
+    end
+
+    def run_scheduled_events
+      event_manager.run_scheduled_events do |event|
+        event.block.call
+      end
+    end
+
+    def install_interrupt_handler
+      Signal.trap("INT") do
+        process_manager.kill_workers
+        exit(0)
+      end
+    end
+
+    def daemonize_app
+      Invoker.daemon.start
+    end
+  end
+end

data/lib/invoker/daemon.rb

@@ -0,0 +1,126 @@
+module Invoker
+  # rip off from borg
+  # https://github.com/code-mancers/borg/blob/master/lib/borg/borg_daemon.rb
+  class Daemon
+    attr_reader :process_name
+
+    def initialize
+      @process_name = 'invoker'
+    end
+
+    def start
+      if running?
+        Invoker::Logger.puts "Invoker daemon is already running"
+        exit(0)
+      elsif dead?
+        File.delete(pid_file) if File.exists?(pid_file)
+      end
+      Invoker::Logger.puts "Running Invoker daemon"
+      daemonize
+    end
+
+    def stop
+      kill_process
+    end
+
+    def pid_file
+      File.join(Invoker.home, ".invoker", "#{process_name}.pid")
+    end
+
+    def pid
+      File.read(pid_file).strip.to_i
+    end
+
+    def log_file
+      File.join(Invoker.home, ".invoker", "#{process_name}.log")
+    end
+
+    def daemonize
+      if fork
+        sleep(2)
+        exit(0)
+      else
+        Process.setsid
+        File.open(pid_file, "w") do |file|
+          file.write(Process.pid.to_s)
+        end
+        Invoker::Logger.puts "Invoker daemon log is available at #{log_file}"
+        redirect_io(log_file)
+        $0 = process_name
+      end
+    end
+
+    def kill_process
+      pgid =  Process.getpgid(pid)
+      Process.kill('-TERM', pgid)
+      File.delete(pid_file) if File.exist?(pid_file)
+      Invoker::Logger.puts "Stopped Invoker daemon"
+    end
+
+    def process_running?
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def status
+      @status ||= check_process_status
+    end
+
+    def pidfile_exists?
+      File.exist?(pid_file)
+    end
+
+    def running?
+      status == 0
+    end
+
+    # pidfile exists but process isn't running
+    def dead?
+      status == 1
+    end
+
+    private
+
+    def check_process_status
+      if pidfile_exists? && process_running?
+        0
+      elsif pidfile_exists? # but not process_running
+        1
+      else
+        3
+      end
+    end
+
+    def redirect_io(logfile_name = nil)
+      redirect_file_to_target($stdin)
+      redirect_stdout(logfile_name)
+      redirect_stderr
+    end
+
+    def redirect_stderr
+      redirect_file_to_target($stderr, $stdout)
+      $stderr.sync = true
+    end
+
+    def redirect_stdout(logfile_name)
+      if logfile_name
+        begin
+          $stdout.reopen logfile_name, "a"
+          $stdout.sync = true
+        rescue StandardError
+          redirect_file_to_target($stdout)
+        end
+      else
+        redirect_file_to_target($stdout)
+      end
+    end
+
+    def redirect_file_to_target(file, target = "/dev/null")
+      begin
+        file.reopen(target)
+      rescue; end
+    end
+  end
+end