pry-remote-em 1.1.0-java

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

@@ -0,0 +1,39 @@
+require 'pry-remote-em/client/generic'
+
+module PryRemoteEm
+  module Client
+    module Broker
+      include Client::Generic
+      include EM::Deferrable
+
+      def log
+        return opts[:logger] if opts[:logger]
+        @log ||= Logger.new(STDERR)
+      end
+
+      def receive_banner(name, version, scheme)
+        if super(name, version, scheme)
+          @opts[:tls] ? start_tls : succeed(self)
+        end
+      end
+
+      def ssl_handshake_completed
+        succeed(self)
+      end
+
+      def unbind
+        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.
+        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
+
+    end # module::Broker
+  end # module::Client
+end # module::PryRemoteEm

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

@@ -0,0 +1,74 @@
+require 'pry-remote-em/proto'
+
+module PryRemoteEm
+  module Client
+    module Generic
+      include EM::Deferrable
+      include Proto
+
+      def initialize(opts = {})
+        @opts   = opts
+      end
+
+      def opts
+        @opts ||= {}
+      end
+
+      def log
+        @log ||= Class.new do
+          def print(str); $stderr.puts(str) end
+          alias :info :print
+          alias :warn :print
+          alias :error :print
+          alias :debug :print
+        end.new
+      end
+
+      def start_tls
+        return if @tls_started
+        @tls_started = true
+        log.info('[pry-remote-em] negotiating TLS')
+        super(opts[:tls].is_a?(Hash) ? opts[:tls] : {})
+      end
+
+      def connection_completed
+        if get_peername
+          port, ip = Socket.unpack_sockaddr_in(get_peername)
+          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')
+        end
+        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
+
+      def receive_banner(name, version, scheme)
+        log.info("[pry-remote-em] remote is #{name} #{version} #{scheme}")
+        client_ver = Gem::Version.new(PryRemoteEm::VERSION)
+        server_req = Gem::Requirement.new("~>#{version}")
+        server_ver = Gem::Version.new(version)
+        client_req = Gem::Requirement.new("~>#{PryRemoteEm::VERSION}")
+        unless server_req.satisfied_by?(client_ver) || client_req.satisfied_by?(server_ver)
+          fail("[pry-remote-em] incompatible version #{PryRemoteEm::VERSION}")
+          return false
+        end
+        if scheme.nil? || scheme != (reqscheme = opts[:tls] ? 'pryems' : 'pryem')
+          if scheme == 'pryems' && defined?(::OpenSSL)
+            opts[:tls] = true
+          else
+            fail("[pry-remote-em] server doesn't support required scheme #{reqscheme.dump}")
+            return false
+          end
+        end
+        @negotiated = true
+        @nego_timer.cancel
+        true
+      end
+
+
+    end # module::Generic
+  end # module::Client
+end # module::PryRemoteEm

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

@@ -0,0 +1,193 @@
+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
+        show_th_col = opts[:show_metrics] || list.any? { |id, server| server.has_key?('metrics') && server['metrics']['errors'] }
+        if show_th_col
+          th_col      = list.map { |id, server| third_column_for_server(server) }
+          th_col_name = opts[:show_metrics] == '@' ? 'metrics' : opts[:show_metrics] || 'errors'
+          th_col_len  = [th_col.flatten.map(&:size).max || 1, th_col_name.size].max
+        end
+        formatter   = "| %-3s |  %-#{nm_col_len}s  |  %-#{sc_col_len}s  |#{"  %-#{th_col_len}s  |" if show_th_col}"
+        header      = sprintf(formatter, '', 'name', sc_col_name, *th_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|
+          index_column = [(index + 1).to_s]
+          first_column = [server['name']]
+          second_column = second_column_for_server(server)
+          third_column = third_column_for_server(server) if show_th_col
+
+          lines = show_th_col ? [second_column.size, third_column.size].max : second_column.size
+
+          lines.times do |index|
+            table << sprintf(formatter, index_column[index] || '', first_column[index] || '', second_column[index] || '', *(show_th_col ? third_column[index] || '' : nil))
+          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)
+        data = case opts[:show_details]
+        when nil then filtered_urls_list_for_server(server)
+        when '@' then server['details']
+        else server['details'][opts[:show_details]]
+        end
+
+        prepare_data_for_table(data)
+      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
+
+      def third_column_for_server(server)
+        data = case opts[:show_metrics]
+        when nil then server['metrics']['errors']
+        when '@' then server['metrics']
+        else server['metrics'][opts[:show_metrics]]
+        end
+
+        prepare_data_for_table(data)
+      end
+
+      def prepare_data_for_table(data)
+        case data
+        when Array then data.map(&:to_s)
+        when Hash then data.map { |key, value| "#{key}: #{value}" }
+        else [data.to_s]
+        end
+      end
+    end # module::InteractiveMenu
+  end # module::Client
+end # module PryRemoteEm

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

@@ -0,0 +1,42 @@
+require 'termios' unless RUBY_PLATFORM =~ /java/
+
+module PryRemoteEm
+  module Client
+    module Keyboard
+
+      def initialize(c)
+        @con            = c
+        # TODO check actual current values to determine if it's enabled or not
+        @buff_enabled   = true
+
+        bufferio(false)
+
+        @old_trap = Signal.trap(:INT) do
+          @con.send_shell_sig(:int)
+        end
+      end
+
+      def receive_data(d)
+        print d.chr
+        @con.send_shell_data(d)
+      end
+
+      def unbind
+        bufferio(true)
+
+        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.
+      def bufferio(enable)
+        return if !defined?(Termios) || 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)
+        @buff_enabled = enable
+      end
+    end # module::Keyboard
+  end # module::Client
+end # module PryRemoteEm

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

@@ -0,0 +1,33 @@
+require 'pry-remote-em/client/generic'
+
+module PryRemoteEm
+  module Client
+    module Proxy
+
+      def initialize(client, opts = {})
+        @opts   = opts
+        @client = client
+      end
+
+      def connection_completed
+        if get_peername
+          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')
+        end
+        @client.proxy_incoming_to(self)
+        proxy_incoming_to(@client)
+      end
+
+      def log
+        return @opts[:logger] if @opts[:logger]
+        @log ||= Logger.new(STDERR)
+      end
+
+      def unbind
+        @client && @client.close_connection(true)
+      end
+    end # module::Proxy
+  end # module::Client
+end # module::PryRemoteEm

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

@@ -0,0 +1,39 @@
+module PryRemoteEm
+  # Simple metrics system
+  # See Sandbox section in Readme for guide
+  module Metrics
+    def list
+      @list ||= Hash.new { |hash, key| hash[key] = 0 }
+    end
+
+    def add(name, value = 1)
+      list[name] += value
+    end
+
+    def reduce(name, value = 1)
+      add(name, -value)
+    end
+
+    def maximum(name, value)
+      list[name] = value if list[name] < value
+    end
+
+    def minimum(name, value)
+      list[name] = value if list[name] > value
+    end
+
+    def set(name, value)
+      list[name] = value
+    end
+
+    def get(name)
+      list[name]
+    end
+
+    def any?
+      list.any?
+    end
+
+    extend self
+  end
+end

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

@@ -0,0 +1,148 @@
+# 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
+    def receive_data(data)
+      @unpacker ||= MessagePack::Unpacker.new
+      @unpacker.feed_each(data) { |object| receive_object(object) }
+    end
+
+    def send_object(object)
+      send_data(object.to_msgpack)
+    end
+
+    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'])
+      elsif j['m']
+        receive_msg(j['m'])
+      elsif j['mb']
+        receive_msg_bcast(j['mb'])
+      elsif j['s']
+        receive_shell_cmd(j['s'])
+      elsif j.include?('sc')
+        receive_shell_result(j['sc'])
+      elsif j['g']
+        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(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['sl']
+        receive_server_list(j['sl'])
+      elsif j['srl']
+        receive_server_reload_list
+      elsif j['tls']
+        receive_start_tls
+      elsif j['pc']
+        receive_proxy_connection(j['pc'])
+      else
+        receive_unknown(j)
+      end
+    end
+
+
+    def receive_prompt(p); end
+    def receive_banner(name, version, scheme); end
+    def receive_auth(a, b = nil); end
+    def receive_msg(m); end
+    def receive_msg_bcast(mb); end
+    def receive_shell_cmd(c); end
+    def receive_shell_result(c); 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(id, urls, name, details, metrics); 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_object({g: g})
+    end
+    def send_auth(a)
+      send_object({a: a})
+    end
+    def send_prompt(p)
+      send_object({p: p})
+    end
+    def send_msg_bcast(m)
+      send_object({mb: m})
+    end
+    def send_msg(m)
+      send_object({m: m})
+    end
+    def send_shell_cmd(c)
+      send_object({s: c})
+    end
+    def send_shell_result(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_object({c: word})
+    end
+    def send_clear_buffer
+      send_object({cb: true})
+    end
+    def send_raw(d)
+      send_object(d.is_a?(String) ? {d: d} : d)
+    end
+
+    def send_start_tls
+      send_object({tls: true})
+    end
+
+    def send_register_server(id, urls, name, details, metrics)
+      send_object({rs: [id, urls, name, details, metrics]})
+    end
+    def send_unregister_server(id)
+      send_object({urs: id})
+    end
+    def send_heatbeat(url)
+      send_object({hb: url})
+    end
+    def send_server_list(list = nil)
+      send_object({sl: list})
+    end
+    def send_server_reload_list
+      send_object({srl: true})
+    end
+
+    def send_proxy_connection(url)
+      send_object({pc: url})
+    end
+  end # module::Proto
+end # module::PryRemoteEm