pry-remote-em 0.7.5 → 1.0.0

data/lib/pry-remote-em/client/broker.rb

@@ -1,4 +1,4 @@
-require "pry-remote-em/client/generic"
+require 'pry-remote-em/client/generic'
 
 module PryRemoteEm
   module Client
@@ -22,11 +22,14 @@ module PryRemoteEm
       end
 
       def unbind
-        log.info("[pry-remote-em broker-client] broker connection unbound starting a new one")
+        return if EventMachine.stopping?
+
         # Give the existing broker a little time to release the port. Even if the
         # restart here fails the next time a server tries to register, a new client
         # will be created; when that fails Broker#restart will be called again.
-        EM::Timer.new(rand(0.9)) do
+        timeout = ENV['PRYEMBROKERTIMEOUT'].nil? || ENV['PRYEMBROKERTIMEOUT'].empty? ? RECONNECT_TO_BROKER_TIMEOUT : ENV['PRYEMBROKERTIMEOUT']
+        log.info("[pry-remote-em broker-client] broker connection unbound; starting a new one in a #{timeout} seconds")
+        EM::Timer.new(timeout) do
           PryRemoteEm::Broker.restart
         end
       end

data/lib/pry-remote-em/client/generic.rb

@@ -1,4 +1,4 @@
-require "pry-remote-em/proto"
+require 'pry-remote-em/proto'
 
 module PryRemoteEm
   module Client
@@ -6,7 +6,7 @@ module PryRemoteEm
       include EM::Deferrable
       include Proto
 
-      def initialize(opt = {})
+      def initialize(opts = {})
         @opts   = opts
       end
 
@@ -27,7 +27,7 @@ module PryRemoteEm
       def start_tls
         return if @tls_started
         @tls_started = true
-        log.info("[pry-remote-em] negotiating TLS")
+        log.info('[pry-remote-em] negotiating TLS')
         super(opts[:tls].is_a?(Hash) ? opts[:tls] : {})
       end
 
@@ -37,10 +37,11 @@ module PryRemoteEm
           log.info("[pry-remote-em] client connected to pryem://#{ip}:#{port}/")
         else
           # TODO use the args used to create this connection
-          log.info("[pry-remote-em] client connected")
+          log.info('[pry-remote-em] client connected')
         end
-        @nego_timer = EM::Timer.new(PryRemoteEm::NEGOTIMER) do
-          fail("[pry-remote-em] server didn't finish negotiation within #{PryRemoteEm::NEGOTIMER} seconds; terminating")
+        timeout = ENV['PRYEMNEGOTIMEOUT'].nil? || ENV['PRYEMNEGOTIMEOUT'].empty? ? NEGOTIATION_TIMEOUT : ENV['PRYEMNEGOTIMEOUT']
+        @nego_timer = EM::Timer.new(timeout) do
+          fail("[pry-remote-em] server didn't finish negotiation within #{timeout} seconds; terminating")
         end
       end
 

data/lib/pry-remote-em/client/interactive_menu.rb

@@ -0,0 +1,171 @@
+require 'highline'
+
+module PryRemoteEm
+  module Client
+    module InteractiveMenu
+      def choose_server(list)
+        highline    = HighLine.new
+        choice      = nil
+        url         = nil
+        nm_col_len  = list.map { |id, server| server['name'].size }.max
+        sc_col      = list.map { |id, server| second_column_for_server(server) }
+        sc_col_name = opts[:show_details] == '@' ? 'details' : opts[:show_details] || 'url'
+        sc_col_len  = [sc_col.flatten.map(&:size).max || 1, sc_col_name.size].max
+        header      = sprintf("| %-3s |  %-#{nm_col_len}s  |  %-#{sc_col_len}s  |", '', 'name', sc_col_name)
+        border      = ('-' * header.length)
+        table       = [border, header, border]
+        list        = list.to_a
+        list        = filter_server_list(list)
+        list        = sort_server_list(list)
+        list.each.with_index do |(id, server), index|
+          column = second_column_for_server(server)
+
+          table << sprintf("|  %-2d |  %-#{nm_col_len}s  |  %-#{sc_col_len}s  |", index + 1, server['name'], column.first)
+
+          if column.size > 1
+            column[1..-1].each do |element|
+              table << sprintf("|  %-2s |  %-#{nm_col_len}s  |  %-#{sc_col_len}s  |", '', '', element)
+            end
+          end
+        end
+        table << border
+        table = table.join("\n")
+        Kernel.puts table
+
+        proxy = if (choice = opts.delete(:proxy))
+          true
+        elsif (choice = opts.delete(:connect))
+          false
+        elsif opts.delete(:proxy_by_default)
+          true
+        else
+          false
+        end
+
+        while url.nil?
+          if proxy
+            question = "(q) to quit; (r) to refresh; (c) to connect without proxy\nproxy to: "
+          else
+            question = "(q) to quit; (r) to refresh; (p) to proxy\nconnect to: "
+          end
+
+          choice = highline.ask(question)
+
+          return close_connection if ['q', 'quit', 'exit'].include?(choice.downcase)
+          if ['r', 'reload', 'refresh'].include?(choice.downcase)
+            send_server_reload_list
+            return nil
+          end
+          if ['c', 'connect'].include?(choice.downcase)
+            proxy = false
+            choice = nil
+            next
+          end
+          if ['p', 'proxy'].include?(choice.downcase)
+            proxy = true
+            choice = nil
+            next
+          end
+
+          choice = choice[/^\d+$/] ?
+            list[choice.to_i - 1] :
+            list.detect { |(id, server)| choice == id || choice == server['name'] || server['urls'].include?(choice) }
+
+          if choice
+            id, server = *choice
+            urls = filtered_urls_list_for_server(server)
+            url = if urls.size > 1
+              choose_url(urls)
+            elsif urls.size == 1
+              urls.first
+            else
+              log.error("\033[31mno #{'non-localhost ' if opts[:ignore_localhost]}urls for this server\033[0m")
+              nil
+            end
+          else
+            log.error("\033[31mserver not found\033[0m")
+          end
+        end
+
+        return url, proxy
+      end
+
+      def choose_url(urls)
+        highline = HighLine.new
+        url      = nil
+        length   = urls.map(&:size).max
+        border   = '-' * (length + 8)
+        Kernel.puts border
+        urls.each.with_index do |url, index|
+          Kernel.puts sprintf("| %d | %-#{length}s |", index + 1, url)
+        end
+        Kernel.puts border
+
+        choice = highline.ask('select url: ')
+
+        url = if choice && choice[/^\d+$/]
+          urls[choice.to_i - 1]
+        elsif urls.include?(choice)
+          choice
+        end
+
+        log.error("\033[31mno url selected\033[0m") unless url
+
+        return url
+      end
+
+      def sort_server_list(list)
+        case opts[:sort]
+        when :name
+          list.sort { |(_, a), (_, b)| a['name'] <=> b['name'] }
+        when :ssl
+          list.sort &sort_by_uri(:scheme)
+        when :port
+          list.sort &sort_by_uri(:port)
+        else # :host or default
+          list.sort &sort_by_uri(:host)
+        end
+      end
+
+      def sort_by_uri(part)
+        -> a, b { URI.parse(a[1]['urls'].first).send(part) <=> URI.parse(b[1]['urls'].first).send(part) }
+      end
+
+      def filter_server_list(list)
+        if opts[:filter_host]
+          list = list.select { |(id, server)| server['urls'].any? { |url| URI.parse(url).host =~ opts[:filter_host] } }
+        end
+        if opts[:filter_name]
+          list = list.select { |(id, server)| server['name'] =~ opts[:filter_name] }
+        end
+        if opts.has_key?(:filter_ssl)
+          target_scheme = opts[:filter_ssl] ? 'pryems' : 'pryem'
+          list = list.select { |(id, server)| server['urls'].any? { |url| URI.parse(url).scheme == target_scheme } }
+        end
+        if list.empty?
+          log.info("\033[33m[pry-remote-em] no registered servers match the given filter\033[0m")
+          Process.exit
+        end
+        list
+      end
+
+      def second_column_for_server(server)
+        column = case opts[:show_details]
+        when nil then filtered_urls_list_for_server(server)
+        when '@' then server['details']
+        else server['details'][opts[:show_details]]
+        end
+
+        case column
+        when Array then column.map(&:to_s)
+        when Hash then column.map { |key, value| "#{key}: #{value}" }
+        else [column.to_s]
+        end
+      end
+
+      def filtered_urls_list_for_server(server)
+        opts[:ignore_localhost] ? server['urls'].reject { |url| %w[localhost 127.0.0.1 ::1].include?(URI.parse(url).host) } : server['urls']
+      end
+    end # module::InteractiveMenu
+  end # module::Client
+end # module PryRemoteEm

data/lib/pry-remote-em/client/keyboard.rb

@@ -1,4 +1,5 @@
-require "termios"
+require 'termios'
+
 module PryRemoteEm
   module Client
     module Keyboard
@@ -7,34 +8,30 @@ module PryRemoteEm
         @con            = c
         # TODO check actual current values to determine if it's enabled or not
         @buff_enabled   = true
-        # On EM < 1.0.0.beta.4 the keyboard handler and Termios don't work well together
-        # readline will complain that STDIN isn't a tty after Termios manipulation, so
-        # just don't let it happen
-        @manip_buff     = Gem.loaded_specs["eventmachine"].version >= Gem::Version.new("1.0.0.beta.4")
+
         bufferio(false)
-        # TODO retain the old SIGINT handler and reset it later
-        trap :SIGINT do
-          @con.send_data({:ssc => true})
+
+        @old_trap = Signal.trap(:INT) do
+          @con.send_shell_sig(:int)
         end
       end
 
       def receive_data(d)
-        @con.send_data({:sd => d})
+        print d.chr
+        @con.send_shell_data(d)
       end
 
       def unbind
         bufferio(true)
-        trap :SIGINT do
-          Process.exit
-        end
+
+        Signal.trap(:INT, @old_trap)
       end
 
       # Makes stdin buffered or unbuffered.
       # In unbuffered mode read and select will not wait for "\n"; also will not echo characters.
       # This probably does not work on Windows.
-      # On EventMachine < 1.0.0.beta.4 this method doesn't do anything
       def bufferio(enable)
-        return if !@manip_buff || (enable && @buff_enabled) || (!enable && !@buff_enabled)
+        return if (enable && @buff_enabled) || (!enable && !@buff_enabled)
         attr = Termios.getattr($stdin)
         enable ? (attr.c_lflag |= Termios::ICANON | Termios::ECHO) : (attr.c_lflag &= ~(Termios::ICANON|Termios::ECHO))
         Termios.setattr($stdin, Termios::TCSANOW, attr)
@@ -43,4 +40,3 @@ module PryRemoteEm
     end # module::Keyboard
   end # module::Client
 end # module PryRemoteEm
-

data/lib/pry-remote-em/client/proxy.rb

@@ -1,4 +1,5 @@
-require "pry-remote-em/client/generic"
+require 'pry-remote-em/client/generic'
+
 module PryRemoteEm
   module Client
     module Proxy
@@ -13,7 +14,7 @@ module PryRemoteEm
           port, ip = Socket.unpack_sockaddr_in(get_peername)
           log.info("[pry-remote-em] proxy connected to pryem://#{ip}:#{port}/")
         else
-          log.info("[pry-remote-em] proxy connected")
+          log.info('[pry-remote-em] proxy connected')
         end
         @client.proxy_incoming_to(self)
         proxy_incoming_to(@client)

data/lib/pry-remote-em/proto.rb

@@ -1,59 +1,23 @@
-require 'json'
-require "zlib"
+# Prefer MessagePack "out of the box" protocol over old JSON+Zlib+CRC
+# variant because of strange `expected "PRYEM" not "}PRYE"` errors
+# on long output over network (not localhost).
+require 'msgpack'
 
 module PryRemoteEm
   module Proto
-    PREAMBLE      = 'PRYEM'
-    SEPERATOR     = ' '
-    PREAMBLE_LEN  = PREAMBLE.bytesize
-    SEPERATOR_LEN = SEPERATOR.bytesize
-
-    def send_json(d)
-      send_data(JSON.dump(d.is_a?(String) ? {:d => d} : d))
-    end
-
-    def send_data(data)
-      crc  = Zlib::crc32(data).to_s
-      msg  = PREAMBLE + (data.bytesize + crc.bytesize + SEPERATOR_LEN).to_s + SEPERATOR + crc + SEPERATOR +  data
-      super(msg)
+    def receive_data(data)
+      @unpacker ||= MessagePack::Unpacker.new
+      @unpacker.feed_each(data) { |object| receive_object(object) }
     end
 
-    # Each frame is a string consisting of 4 parts
-    #   1. preamble (PRYEM)
-    #   2. length in characters of crc, a seperator, and body
-    #   3. CRC
-    #   4. JSON encoded body
-    # It is possible and likely that receive_data will be given more than one frame at a time, or
-    # an incomplete frame.
-    # @example "PRYEM42 3900082256 {\"g\":\"PryRemoteEm 0.7.0 pryem\"}PRYEM22 1794245389 {\"a\":false}"
-    def receive_data(d)
-      return unless d && d.bytesize > 0
-      @buffer ||= "" # inlieu of a post_init
-      @buffer << d
-      while @buffer && !@buffer.empty?
-        return unless @buffer.bytesize >= PREAMBLE_LEN &&
-          (len_ends = @buffer.index(SEPERATOR)) &&
-          (crc_ends = @buffer.index(SEPERATOR, len_ends))
-        if (preamble = @buffer[0...PREAMBLE_LEN]) != PREAMBLE
-          raise "message is not in proper format; expected #{PREAMBLE.inspect} not #{preamble.inspect}"
-        end
-        length    = @buffer[PREAMBLE_LEN ... len_ends].to_i
-        return if len_ends + length > @buffer.bytesize
-        crc_start = len_ends + SEPERATOR_LEN
-        crc, data = @buffer[crc_start ... crc_start + length].split(SEPERATOR, 2)
-        crc       = crc.to_i
-        @buffer   = @buffer[crc_start + length .. -1]
-        if (dcrc = Zlib::crc32(data)) == crc
-          receive_json(JSON.load(data))
-        else
-          warn("data crc #{dcrc} doesn't match crc #{crc.inspect}; discarding #{data.inspect}")
-        end
-      end
-      @buffer
+    def send_object(object)
+      send_data(object.to_msgpack)
     end
 
-    def receive_json(j)
-      if j['p']
+    def receive_object(j)
+      if !j.is_a?(Hash)
+        receive_unknown(j)
+      elsif j['p']
         receive_prompt(j['p'])
       elsif j['d']
         receive_raw(j['d'])
@@ -66,23 +30,27 @@ module PryRemoteEm
       elsif j.include?('sc')
         receive_shell_result(j['sc'])
       elsif j['g']
-        receive_banner(*j['g'].split(" ", 3))
+        receive_banner(*j['g'].split(' ', 3))
       elsif j['c']
         receive_completion(j['c'])
+      elsif j['cb']
+        receive_clear_buffer
       elsif j.include?('a')
         receive_auth(*Array(j['a']))
       elsif j['sd']
         receive_shell_data(j['sd'])
       elsif j['ssc']
-        receive_shell_sig(:term)
+        receive_shell_sig(j['ssc'].to_sym)
       elsif j['hb']
         receive_heartbeat(j['hb'])
       elsif j['rs']
         receive_register_server(*Array(j['rs']))
       elsif j['urs']
         receive_unregister_server(j['urs'])
-      elsif j.include?('sl')
-        j['sl'] ?  receive_server_list(j['sl']) : receive_server_list
+      elsif j['sl']
+        receive_server_list(j['sl'])
+      elsif j['srl']
+        receive_server_reload_list
       elsif j['tls']
         receive_start_tls
       elsif j['pc']
@@ -90,7 +58,6 @@ module PryRemoteEm
       else
         receive_unknown(j)
       end
-      j
     end
 
 
@@ -101,67 +68,81 @@ module PryRemoteEm
     def receive_msg_bcast(mb); end
     def receive_shell_cmd(c); end
     def receive_shell_result(c); end
-    def receive_completion(c); end
-    def receive_raw(r); end
     def receive_shell_sig(sym); end
     def receive_shell_data(d); end
+    def receive_completion(c); end
+    def receive_clear_buffer; end
+    def receive_raw(r); end
     def receive_unknown(j); end
 
     def receive_start_tls; end
 
-    def receive_register_server(url, name); end
-    def receive_unregister_server(url); end
-    def receive_server_list(list = nil); end
+    def receive_register_server(id, urls, name, details); end
+    def receive_unregister_server(id); end
+    def receive_server_list(list); end
+    def receive_server_reload_list; end
 
     def receive_proxy_connection(url); end
 
     def send_banner(g)
-      send_json({:g => g})
+      send_object({g: g})
     end
     def send_auth(a)
-      send_json({:a => a})
+      send_object({a: a})
     end
     def send_prompt(p)
-      send_json({:p => p})
+      send_object({p: p})
     end
     def send_msg_bcast(m)
-      send_json({:mb => m})
+      send_object({mb: m})
     end
     def send_msg(m)
-      send_json({:m => m})
+      send_object({m: m})
     end
     def send_shell_cmd(c)
-      send_json({:s => c})
+      send_object({s: c})
     end
     def send_shell_result(r)
-      send_json({:sc => r})
+      send_object({sc: r})
+    end
+    def send_shell_sig(sym)
+      send_object({ssc: sym})
+    end
+    def send_shell_data(d)
+      send_object({sd: d})
     end
     def send_completion(word)
-      send_json({:c => word})
+      send_object({c: word})
+    end
+    def send_clear_buffer
+      send_object({cb: true})
     end
-    def send_raw(l)
-      send_json(l)
+    def send_raw(d)
+      send_object(d.is_a?(String) ? {d: d} : d)
     end
 
     def send_start_tls
-      send_json({:tls => true})
+      send_object({tls: true})
     end
 
-    def send_register_server(url, name)
-      send_json({:rs => [url, name]})
+    def send_register_server(id, urls, name, details)
+      send_object({rs: [id, urls, name, details]})
     end
-    def send_unregister_server(url)
-      send_json({:urs => url})
+    def send_unregister_server(id)
+      send_object({urs: id})
     end
     def send_heatbeat(url)
-      send_json({:hb => url})
+      send_object({hb: url})
     end
     def send_server_list(list = nil)
-      send_json({:sl => list})
+      send_object({sl: list})
+    end
+    def send_server_reload_list
+      send_object({srl: true})
     end
 
     def send_proxy_connection(url)
-      send_json({:pc => url})
+      send_object({pc: url})
     end
   end # module::Proto
 end # module::PryRemoteEm