pry-remote-em 1.1.0-java

data/bin/pry-remote-em

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'uri'
+require 'readline'
+require 'highline'
+require 'pry-remote-em/client'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.on('-c', '--connect NAME', 'connect to the first pry remote em server matching NAME') do |name|
+    options[:connect] = name
+  end
+  opts.on('-p', '--proxy NAME', 'proxy through the broker to the first pry remote em server matching NAME') do |name|
+    options[:proxy] = name
+  end
+  opts.on('-P', '--proxy-by-default', 'show servers table with proxy mode enabled by default (ignored on -c or -p)') do |name|
+    options[:proxy_by_default] = true
+  end
+
+  opts.on('--fh HOST', '--filter-host HOST', 'only show servers listening at the given address (regexp)') do |host|
+    if host =~ /^pryems?:\/\//
+      ARGV.push(host)
+    else
+      options[:filter_host] = Regexp.new(host)
+    end
+  end
+  opts.on('--fn NAME', '--filter-name NAME', 'only show servers with a matching name (regexp)') do |name|
+    if name =~ /^pryems?:\/\//
+      ARGV.push(name)
+    else
+      options[:filter_name] = Regexp.new(name)
+    end
+  end
+  opts.on('--[no-]fs', '--[no-]filter-ssl', 'show only servers that support ssl') do |ssl|
+    options[:filter_ssl] = ssl
+  end
+
+  opts.on('--sh', '--sort-host', 'sort by host') { options[:sort] = :host }
+  opts.on('--sn', '--sort-name', 'sort by server name') { |name| options[:sort] = :name }
+  opts.on('--sp', '--sort-port', 'sort by port') { options[:sort] = :port }
+  opts.on('--ss', '--sort-ssl', 'sort by ssl support') { options[:sort] = :ssl }
+
+  opts.on('-d', '--details KEY', "show value from server's details option by given key instead of url in table, use @ to show all details") do |key|
+    options[:show_details] = key
+  end
+
+  opts.on('-m', '--metrics KEY', "show value from server's metrics by given key in a third column, use @ to show all metrics, default - errors (if any)") do |key|
+    options[:show_metrics] = key
+  end
+
+  opts.on('-i', '--ignore-localhost', 'filter out localhost urls from list') do
+    options[:ignore_localhost] = true
+  end
+
+  opts.parse!(ARGV)
+end
+
+uri = if ARGV[0].nil? || ARGV[0].empty?
+  host = ENV['PRYEMBROKER'].nil? || ENV['PRYEMBROKER'].empty? ? PryRemoteEm::DEFAULT_BROKER_HOST : ENV['PRYEMBROKER']
+  port = ENV['PRYEMBROKERPORT'].nil? || ENV['PRYEMBROKERPORT'].empty? ? PryRemoteEm::DEFAULT_BROKER_PORT : ENV['PRYEMBROKERPORT']
+  "pryem://#{host}:#{port}"
+else
+  ARGV[0]
+end
+uri = URI.parse(uri)
+unless %w(pryem pryems).include?(uri.scheme)
+  abort "only pryem URIs are currently supported\n usage: pryem[s]://#{PryRemoteEm::DEFAULT_BROKER_HOST}:#{PryRemoteEm::DEFAULT_BROKER_PORT}"
+end
+uri.port = PryRemoteEm::DEFAULT_BROKER_PORT unless uri.port
+
+tried = 0
+auth_proc = proc do
+  tried += 1
+  user   = uri.user || ($stdin.tty? ? Readline.readline('user: ') : raise('username is require for authentication'))
+  pass   = if !uri.password.nil? && tried <= 1
+             uri.password
+           elsif $stdin.tty?
+             HighLine.new.ask("#{user}'s password: ") { |q| q.echo = '*' }
+           else
+             raise 'password is required to authenticate'
+           end
+  [user, pass]
+end
+
+EM.run do
+  client_options = options.merge(auth: auth_proc, tls: uri.scheme == 'pryems')
+  PryRemoteEm::Client.start(uri.host, uri.port, client_options) { EM.stop }
+end

data/bin/pry-remote-em-broker

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'pry-remote-em/broker'
+require 'optparse'
+
+options = { tls: false }
+OptionParser.new do |opts|
+  opts.on('-h', '--host HOST', 'host to bind broker server (same as PRYEMBROKER variable, default: "127.0.0.1")') do |host|
+    options[:host] = host
+  end
+
+  opts.on('-p', '--port PORT', 'port to bind broker server (same as PRYEMBROKERPORT variable, default: 6462)') do |port|
+    options[:port] = port
+  end
+
+  opts.on('-s', '--tls', 'use TLS for broker (default: false)') do
+    options[:tls] = true
+  end
+
+  opts.parse!(ARGV)
+end
+
+
+EM.run do
+  trap(:INT) { EM.stop }
+
+  PryRemoteEm::Broker.run options[:host], options[:port], tls: options[:tls], raise_if_port_in_use: true
+end

data/lib/pry-remote-em.rb

@@ -0,0 +1,74 @@
+begin
+  require 'openssl'
+rescue LoadError
+  warn 'OpenSSL support is not available'
+end
+require 'socket'
+require 'fiber'
+require 'uri'
+require 'eventmachine'
+require 'pry-remote-em/version'
+require 'pry-remote-em/proto'
+require 'pry-remote-em/server'
+
+module PryRemoteEm
+  DEFAULT_SERVER_HOST = '127.0.0.1'
+  DEFAULT_SERVER_PORT = 6463
+  DEFAULT_BROKER_HOST = '127.0.0.1'
+  DEFAULT_BROKER_PORT = 6462
+
+  NEGOTIATION_TIMEOUT         = 15
+  HEARTBEAT_SEND_INTERVAL     = 15
+  HEARTBEAT_CHECK_INTERVAL    = 20
+  RECONNECT_TO_BROKER_TIMEOUT = 3
+
+  MAXIMUM_ERRORS_IN_SANDBOX = 100
+end
+
+
+class Object
+  def remote_pry_em(host = nil, port = nil, options = {}, &block)
+    host, options = nil, host if host.kind_of?(Hash) # Support for options hash as first argument instead of third
+
+    options = { target: self, host: host, port: port }.merge(options)
+    PryRemoteEm::Server.run(options, &block)
+  end
+
+  alias pry_remote_em remote_pry_em # source of common confusing
+end
+
+
+unless defined?(EventMachine.popen3)
+  module EventMachine
+    # @see http://eventmachine.rubyforge.org/EventMachine.html#M000491
+    # @see https://gist.github.com/535644/4d5b645b96764e07ccb53539529bea9270741e1a
+    def self.popen3(cmd, handler=nil, *args)
+      klass = klass_from_handler(Connection, handler, *args)
+      w     = Shellwords::shellwords(cmd)
+      w.unshift(w.first) if w.first
+
+      new_stderr = $stderr.dup
+      rd, wr     = IO::pipe
+
+      $stderr.reopen wr
+      s = invoke_popen(w)
+      $stderr.reopen new_stderr
+
+      klass.new(s, *args).tap do |c|
+        EM.attach(rd, Popen3StderrHandler, c)
+        @conns[s] = c
+        yield(c) if block_given?
+      end
+    end
+
+    class Popen3StderrHandler < EventMachine::Connection
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def receive_data(data)
+        @connection.receive_stderr(data)
+      end
+    end  # class::Popen3StderrHandler
+  end # module::EventMachine
+end # defined?(EventMachine.popen3)

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

@@ -0,0 +1,229 @@
+require 'logger'
+require 'socket'
+require 'pry-remote-em'
+require 'pry-remote-em/client/broker'
+require 'pry-remote-em/client/proxy'
+
+module PryRemoteEm
+  module Broker
+    class << self
+      attr_reader :listening, :host, :port
+      alias :listening? :listening
+
+      def run(host = nil, port = nil, opts = {})
+        host ||= ENV['PRYEMBROKER'].nil? || ENV['PRYEMBROKER'].empty? ? DEFAULT_BROKER_HOST : ENV['PRYEMBROKER']
+        port ||= ENV['PRYEMBROKERPORT'].nil? || ENV['PRYEMBROKERPORT'].empty? ? DEFAULT_BROKER_PORT : ENV['PRYEMBROKERPORT']
+        port = port.to_i if port.kind_of?(String)
+        raise "root permission required for port below 1024 (#{port})" if port < 1024 && Process.euid != 0
+        @host = host
+        @port = port
+        opts = opts.dup
+        # Brokers cannot use SSL directly. If they do then when a proxy request to an SSL server is received
+        # the client and server will not be able to negotiate a SSL session. The proxied traffic can be SSL
+        # encrypted, but the SSL session will be between the client and the server.
+        opts[:tls] = false
+        @opts = opts
+        start_server(host, port, opts) unless @listening || ENV['PRYEMREMOTEBROKER'] || @opts[:remote_broker]
+        client { |c| yield self } if block_given?
+      end
+
+      def restart
+        log.info("[pry-remote-em broker] restarting on pryem://#{host}:#{port}")
+        @waiting   = nil
+        @client    = nil
+        run(@host, @port, @opts) do
+          PryRemoteEm.servers.each do |id, description|
+            next unless EM.get_sockname(description[:server])
+            register(
+              id: description[:id],
+              urls: description[:urls],
+              name: description[:name],
+              details: description[:details],
+              metrics: PryRemoteEm::Metrics.list
+            )
+          end
+        end
+      end
+
+      def opts
+        @opts ||= {}
+      end
+
+      def log
+        return opts[:logger] if opts[:logger]
+        @log ||= Logger.new(STDERR)
+      end
+
+      def servers
+        @servers ||= {}
+      end
+
+      def register(description)
+        client { |c| c.send_register_server(description[:id], description[:urls], description[:name], description[:details], description[:metrics]) }
+      end
+
+      def unregister(id)
+        client { |c| c.send_unregister_server(id) }
+      end
+
+      def register_server(id, description)
+        servers[id] = description
+        watch_heartbeats(id)
+        log.info("[pry-remote-em broker] registered #{id} #{description.inspect}")
+      end
+
+      def update_server(server, description)
+        server.update(urls: description[:urls], name: description[:name])
+        server[:details].update(description[:details])
+        server[:metrics].update(description[:metrics])
+      end
+
+      def unregister_server(id)
+        server = servers.delete(id) or return
+        log.warn("[pry-remote-em broker] unregister #{id} #{server.inspect}")
+        timer = timers.delete(id)
+        timer.cancel if timer
+        hbeats.delete(id)
+      end
+
+      def watch_heartbeats(id)
+        interval = ENV['PRYEMHBCHECK'].nil? || ENV['PRYEMHBCHECK'].empty? ? HEARTBEAT_CHECK_INTERVAL : ENV['PRYEMHBCHECK']
+        timers[id] ||= EM::PeriodicTimer.new(interval) do
+          if !hbeats[id] || (Time.new - hbeats[id]) > 20
+            unregister_server(id)
+          end
+        end
+      end
+
+      def timers
+        @timers ||= {}
+      end
+
+      def hbeats
+        @hbeats ||= {}
+      end
+
+      def connected?
+        @connected
+      end
+
+      private
+
+      def start_server(host, port, opts)
+        EM.start_server(host, port, PryRemoteEm::Broker, opts)
+        log.info("[pry-remote-em broker] listening on #{opts[:tls] ? 'pryems' : 'pryem'}://#{host}:#{port}")
+        @listening = true
+      rescue => error
+        if error.message.include?('port is in use')
+          if opts[:raise_if_port_in_use]
+            raise
+          else
+            # A broker is already listening on this port, we can do nothing
+          end
+        else
+          raise
+        end
+      end
+
+      def client(&blk)
+        raise ArgumentError.new('A block is required') unless block_given?
+        if @client
+          yield @client
+          return
+        end
+
+        if @waiting
+          @waiting << blk
+        else
+          @waiting = [blk]
+          EM.connect(host, port, Client::Broker, @opts) do |client|
+            client.errback { |e| raise(e || 'broker client error') }
+            client.callback do
+              @client = client
+              while (w = @waiting.shift)
+                w.call(client)
+              end
+            end
+          end
+        end
+      end
+    end # class << self
+
+    include Proto
+
+    def receive_server_reload_list
+      send_server_list(Broker.servers)
+    end
+
+    def receive_register_server(id, urls, name, details, metrics)
+      @ids.push(id)
+      description = { urls: urls, name: name, details: details, metrics: metrics }
+      Broker.hbeats[id] = Time.new
+      server = Broker.servers[id]
+      if server
+        Broker.update_server(server, description)
+      else
+        Broker.register_server(id, description)
+      end
+    end
+
+    def receive_unregister_server(id)
+      server = Broker.servers[id]
+      Broker.unregister_server(id) if server
+    end
+
+    def receive_proxy_connection(url)
+      log.info("[pry-remote-em broker] proxying to #{url}")
+      url = URI.parse(url)
+      EM.connect(url.host, url.port, Client::Proxy, self)
+    end
+
+    def initialize(opts = {}, &blk)
+      @opts = opts
+      @ids = []
+    end
+
+    def log
+      Broker.log
+    end
+
+    def post_init
+      port, ip = Socket.unpack_sockaddr_in(get_peername)
+      log.info("[pry-remote-em broker] received client connection from #{ip}:#{port}")
+      send_banner("PryRemoteEm #{VERSION} #{@opts[:tls] ? 'pryems' : 'pryem'}")
+      @opts[:tls] ? start_tls : send_server_list(Broker.servers)
+    end
+
+    def start_tls
+      log.debug("[pry-remote-em broker] starting TLS (#{peer_ip}:#{peer_port})")
+      send_start_tls
+      super(@opts[:tls].is_a?(Hash) ? @opts[:tls] : {})
+    end
+
+    def peer_ip
+      return @peer_ip if @peer_ip
+      return '' if get_peername.nil?
+      @peer_port, @peer_ip = Socket.unpack_sockaddr_in(get_peername)
+      @peer_ip = '127.0.0.1' if @peer_ip == '::1' # Little hack to avoid segmentation fault in EventMachine 1.2.0.1 while connecting to PryRemoteEm Server from localhost with IPv6 address
+      @peer_ip
+    end
+
+    def peer_port
+      return @peer_port if @peer_port
+      return '' if get_peername.nil?
+      peer_ip # Fills peer_port too
+      @peer_port
+    end
+
+    def ssl_handshake_completed
+      log.info("[pry-remote-em broker] TLS connection established (#{peer_ip}:#{peer_port})")
+      send_server_list(Broker.servers)
+    end
+
+    def unbind
+      @ids.each do |id|
+        Broker.unregister_server(id)
+      end
+    end
+  end # module::Broker
+end # module::PryRemoteEm

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

@@ -0,0 +1,233 @@
+require 'uri'
+require 'pry-remote-em'
+require 'pry-remote-em/client/keyboard'
+require 'pry-remote-em/client/generic'
+require 'pry-remote-em/client/interactive_menu'
+require 'pry'
+#require 'pry-coolline' rescue require 'readline'
+
+module PryRemoteEm
+  module Client
+    include EM::Deferrable
+    include Generic
+    include InteractiveMenu
+    include Pry::Helpers::BaseHelpers
+
+    class << self
+      def start(host = nil, port = nil, opts = {})
+        EM.connect(host || PryRemoteEm::DEFAULT_SERVER_HOST, port || PryRemoteEm::DEFAULT_SERVER_PORT, PryRemoteEm::Client, opts) do |c|
+          c.callback { yield if block_given? }
+          c.errback do |e|
+            Kernel.puts "[pry-remote-em] connection failed\n#{e}"
+            yield(e) if block_given?
+          end
+        end
+      end
+    end # class << self
+
+    attr_reader :opts
+
+    def initialize(opts = {})
+      @opts = opts
+      if (a = opts[:auth])
+        if a.respond_to?(:call)
+          @auth = a
+        else
+          @auth = lambda { a }
+        end
+      end
+    end
+
+    def post_init
+      @input = if defined?(PryCoolline)
+        PryCoolline.make_coolline
+      else
+        Pry.history.load if Pry.config.history.should_load
+        Readline
+      end
+      @input.completion_proc = method(:auto_complete)
+    end
+
+    def ssl_handshake_completed
+      log.info('[pry-remote-em] TLS connection established')
+      @opts[:tls] = true
+    end
+
+    def unbind
+      if (uri = @reconnect_to)
+        @reconnect_to = nil
+        tls       = uri.scheme == 'pryems'
+        log.info("\033[35m[pry-remote-em] connection will not be encrypted\033[0m")  if @opts[:tls] && !tls
+        @opts[:tls]   = tls
+        @tls_started  = false
+        reconnect(uri.host, uri.port)
+      else
+        @unbound = true
+        log.info('[pry-remote-em] session terminated')
+        error? ? fail : succeed
+      end
+    end
+
+    def receive_banner(name, version, scheme)
+      # Client::Generic#receive_banner
+      if super(name, version, scheme)
+        start_tls if @opts[:tls]
+      end
+    end
+
+    def receive_server_list(list)
+      if list.empty?
+        log.info("\033[33m[pry-remote-em] no servers are registered with the broker\033[0m")
+        Process.exit
+      end
+      url, proxy = choose_server(list)
+      return unless url
+      uri = URI.parse(url)
+      if proxy
+        @opts[:tls]  = uri.scheme == 'pryems'
+        @negotiated  = false
+        @tls_started = false
+        return send_proxy_connection(url)
+      end
+      @reconnect_to = uri
+      close_connection
+    end
+
+    def receive_auth(a)
+      return fail a if a.is_a?(String)
+      return authenticate if a == false
+      @authenticated = true if a == true
+    end
+
+    def receive_msg(m)
+      Kernel.puts "\033[1m! msg: " + m + "\033[0m"
+    end
+
+    def receive_msg_bcast(mb)
+      Kernel.puts "\033[1m!! msg: " + mb + "\033[0m"
+    end
+
+    def receive_shell_cmd(c)
+      Kernel.puts c
+    end
+
+    def receive_shell_result(c)
+      if @keyboard
+        @keyboard.bufferio(true)
+        @keyboard.close_connection
+      end
+      if c == 255 || c == 127
+        Kernel.puts 'command not found'
+      end
+    end
+
+    # TODO detect if the old pager behavior of Pry is supported and use it
+    # through Pry.pager. If it's not then use the SimplePager.
+    def pager
+      pager_class = ENV['PRYEMNOPAGER'] ? Pry::Pager::NullPager : @opts[:pager] || Pry::Pager::SimplePager
+      @pager ||= pager_class.new(Pry::Output.new(Pry))
+    end
+
+    def receive_raw(r)
+      pager.write(r)
+    rescue Pry::Pager::StopPaging
+      warn '[pry-remote-em] stop paging is not implemented, use PRYEMNOPAGER environment variable to avoid paging at all'
+    end
+
+    def receive_unknown(j)
+      warn "[pry-remote-em] received unexpected data: #{j.inspect}"
+    end
+
+    def authenticate
+      return fail('[pry-remote-em] authentication required') unless @auth
+      return fail("[pry-remote-em] can't authenticate before negotiation complete") unless @negotiated
+      user, pass = @auth.call
+      return fail("[pry-remote-em] expected #{@auth} to return a user and password") unless user && pass
+      send_auth([user, pass])
+    end # authenticate
+
+    def auto_complete(word)
+      word = word.completed_word if defined?(Coolline) && word.kind_of?(Coolline)
+
+      @waiting = Thread.current
+      EM.next_tick { send_completion(word) }
+      sleep
+      c = Thread.current[:completion]
+      Thread.current[:completion] = nil
+      c
+    end
+
+    def receive_completion(c)
+      return unless @waiting
+      @waiting[:completion] = c
+      @waiting, t = nil, @waiting
+      t.run
+    end
+
+    def receive_prompt(p)
+      readline(p)
+    end
+
+    def readline(prompt = @last_prompt)
+      @last_prompt = prompt
+      if @negotiated && !@unbound
+        operation = proc do
+          thread = Thread.current
+          old_trap = Signal.trap(:INT) { thread.raise Interrupt }
+          begin
+            @input.readline(prompt)
+          rescue Interrupt
+            send_clear_buffer
+            puts
+            :ignore_me
+          ensure
+            Signal.trap(:INT, old_trap)
+          end
+        end
+
+        callback  = proc do |l|
+          next if l == :ignore_me
+
+          add_to_history(l) unless l.nil? || l.empty?
+
+          if l.nil?
+            readline
+          elsif '^^' == l[0..1]
+            send_msg_bcast(l[2..-1])
+          elsif '^' == l[0]
+            send_msg(l[1..-1])
+          elsif '.' == l[0]
+            send_shell_cmd(l[1..-1])
+            @keyboard = EM.open_keyboard(Keyboard, self)
+          elsif 'reset' == l.strip
+            # TODO work with 'bundle exec pry-remote-em ...'
+            # TODO work with 'ruby -I lib bin/pry-remote-em ...'
+            Kernel.puts "\033[1m#{$0} #{ARGV.join(' ')}\033[0m"
+            exec("#{$0} #{ARGV.join(' ')}")
+          else
+            send_raw(l)
+          end
+        end
+
+        EM.defer(operation, callback)
+      end
+    end # readline(prompt = @last_prompt)
+
+    def add_to_history(line)
+      if defined?(Readline) && @input == Readline
+        Readline::HISTORY.push(line)
+      end
+      # Nothing to do with Coolline, it just works
+    end
+  end # module::Client
+end # module::PryRemoteEm
+
+# TODO detect if the old pager behavior of Pry is supported and use it. If it's not
+# then don't bother adding a pager accessor
+# Pry::Helpers::BaseHelpers#stagger_output expects Pry.pager to be defined
+class Pry
+  class << self
+    attr_accessor :pager unless respond_to?(:pager)
+  end
+end
+Pry.pager = true