pry-remote-em 0.6.3 → 0.7.0

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

@@ -0,0 +1,36 @@
+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
+        log.info("[pry-remote-em broker-client] broker connection unbound starting a new one")
+        # 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
+          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,73 @@
+require "pry-remote-em/proto"
+
+module PryRemoteEm
+  module Client
+    module Generic
+      include EM::Deferrable
+      include Proto
+
+      def initialize(opt = {})
+        @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
+        @nego_timer = EM::Timer.new(PryRemoteEm::NEGOTIMER) do
+          fail("[pry-remote-em] server didn't finish negotiation within #{PryRemoteEm::NEGOTIMER} 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/proxy.rb

@@ -0,0 +1,32 @@
+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/proto.rb

@@ -0,0 +1,167 @@
+require 'json'
+require "zlib"
+
+module PryRemoteEm
+  module Proto
+    PREAMBLE      = 'PRYEM'
+    SEPERATOR     = ' '
+    PREAMBLE_LEN  = PREAMBLE.length
+    SEPERATOR_LEN = SEPERATOR.length
+
+    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.length + crc.length + SEPERATOR_LEN).to_s + SEPERATOR + crc + SEPERATOR +  data
+      super(msg)
+    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.length > 0
+      @buffer ||= "" # inlieu of a post_init
+      @buffer << d
+      while @buffer && !@buffer.empty?
+        return unless @buffer.length >= 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.length
+        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
+    end
+
+    def receive_json(j)
+      if 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.include?('a')
+        receive_auth(*Array(j['a']))
+      elsif j['sd']
+        receive_shell_data(j['sd'])
+      elsif j['ssc']
+        receive_shell_sig(:term)
+      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['tls']
+        receive_start_tls
+      elsif j['pc']
+        receive_proxy_connection(j['pc'])
+      else
+        receive_unknown(j)
+      end
+      j
+    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_completion(c); end
+    def receive_raw(r); end
+    def receive_shell_sig(sym); end
+    def receive_shell_data(d); 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_proxy_connection(url); end
+
+    def send_banner(g)
+      send_json({:g => g})
+    end
+    def send_auth(a)
+      send_json({:a => a})
+    end
+    def send_prompt(p)
+      send_json({:p => p})
+    end
+    def send_msg_bcast(m)
+      send_json({:mb => m})
+    end
+    def send_msg(m)
+      send_json({:m => m})
+    end
+    def send_shell_cmd(c)
+      send_json({:s => c})
+    end
+    def send_shell_result(r)
+      send_json({:sc => r})
+    end
+    def send_completion(word)
+      send_json({:c => word})
+    end
+    def send_raw(l)
+      send_json(l)
+    end
+
+    def send_start_tls
+      send_json({:tls => true})
+    end
+
+    def send_register_server(url, name)
+      send_json({:rs => [url, name]})
+    end
+    def send_unregister_server(url)
+      send_json({:urs => url})
+    end
+    def send_heatbeat(url)
+      send_json({:hb => url})
+    end
+    def send_server_list(list = nil)
+      send_json({:sl => list})
+    end
+
+    def send_proxy_connection(url)
+      send_json({:pc => url})
+    end
+  end # module::Proto
+end # module::PryRemoteEm

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

@@ -1,7 +1,9 @@
 require 'pry'
 require 'logger'
 require 'pry-remote-em'
+require 'pry-remote-em/broker'
 require 'pry-remote-em/server/shell_cmd'
+
 # How it works with Pry
 #
 # When PryRemoteEm.run is called it registers with EventMachine for a given ip
@@ -26,14 +28,41 @@ require 'pry-remote-em/server/shell_cmd'
 # Pry just interacts with PryRemoteEm as if it were any other blocking Readline
 # object. The important bit is making sure that it is started in a new Fiber that
 # can be paused and resumed as needed. PryRemoteEm#readline pauses it and
-# PryRemoteEm#receive_json resumes it.
+# PryRemoteEm#receive_raw resumes it.
 #
 # Reference:
 # http://www.igvita.com/2010/03/22/untangling-evented-code-with-ruby-fibers/
-
 module PryRemoteEm
+  class << self
+    # Local PryRemoteEm EM signatures and server name indexed by url. Each
+    # signature can be used with high level EM methods like EM.stop_server or
+    # EM.get_sockname. If a server has been stopped EM.get_sockname will return
+    # nil for that server's signature.
+    def servers
+      @servers ||= {}
+    end
+
+    # Safely stop one or more PryRemoteEm servers and remove them from the list
+    # of servers.
+    # @param [String] id url or name
+    def stop_server(id)
+      if servers[id]
+        EM.stop_server(servers[id][0]) if EM.get_sockname(servers[id][0])
+        Broker.unregister(id)
+        servers.delete(id)
+        return Array(id)
+      end
+      servers.select{ |i, (sig, name)| name == id }.map do |i, (sig, name)|
+        EM.stop_server(sig) if EM.get_sockname(sig)
+        Broker.unregister(i)
+        servers.delete(i)
+        i
+      end
+    end # stop_server(id)
+  end
+
   module Server
-    include JsonProto
+    include Proto
 
     class << self
       # Start a pry-remote-em server
@@ -46,11 +75,12 @@ module PryRemoteEm
       # @option opts [Proc, Object] :auth require user authentication - see README
       # @option opts [Boolean] :allow_shell_cmds
       def run(obj, host = DEFHOST, port = DEFPORT, opts = {:tls => false})
-        tries = :auto == port ? 100.tap{ port = DEFPORT } : 1
+        tries = [port, opts[:port_fail]].include?(:auto) ? 100 : 1
+        port  = DEFPORT if :auto == port
         # TODO raise a useful exception not RuntimeError
         raise "root permission required for port below 1024 (#{port})" if port < 1024 && Process.euid != 0
         begin
-          EM.start_server(host, port, PryRemoteEm::Server, obj, opts) do |pre|
+          server = EM.start_server(host, port, PryRemoteEm::Server, obj, opts) do |pre|
             Fiber.new {
               begin
                 yield pre if block_given?
@@ -62,16 +92,29 @@ module PryRemoteEm
           end
         rescue => e
           # EM 1.0.0.beta4's message tells us the port is in use; 0.12.10 just says, 'no acceptor'
-          if (e.message.include?('port is in use') || e.message.include?('no acceptor')) && tries >= 1
+          if (e.message.include?('port is in use') || e.message.include?('no acceptor')) && tries > 1
             tries -= 1
             port += 1
             retry
           end
-          raise e
+          raise "can't bind to #{host}:#{port} - #{e}"
+        end
+        url    = "#{opts[:tls] ? 'pryems' : 'pryem'}://#{host}:#{port}/"
+        begin
+          name = obj.send(:eval, 'self')
+        rescue
+          name = "#{obj}"
+        end
+        name   = Pry.view_clip(name)
+        PryRemoteEm.servers[url] = [server, name]
+        (opts[:logger] || ::Logger.new(STDERR)).info("[pry-remote-em] listening for connections on #{url}")
+        Broker.run(opts[:broker_host] || ENV['PRYEMBROKER'] || DEF_BROKERHOST, opts[:broker_port] || ENV['PRYEMBROKERPORT'] || DEF_BROKERPORT, opts)
+        EM::Timer.new(rand(0.9)) { Broker.register(url, name) }
+        rereg = EM::PeriodicTimer.new(15) do
+          EM.get_sockname(server) ? Broker.register(url, name) : nil #rereg.cancel
         end
-        scheme = opts[:tls] ? 'pryems' : 'pryem'
-        (opts[:logger] || ::Logger.new(STDERR)).info("[pry-remote-em] listening for connections on #{scheme}://#{host}:#{port}/")
-      end # run(obj, host = DEFHOST, port = DEFPORT)
+        url
+      end
 
       # The list of pry-remote-em connections for a given object, or the list of all pry-remote-em
       # connections for this process.
@@ -127,14 +170,21 @@ module PryRemoteEm
       end
     end
 
+    def url
+      port, host = Socket.unpack_sockaddr_in(get_sockname)
+      "#{@opts[:tls] ? 'pryems' : 'pryem'}://#{host}:#{port}/"
+    end
+
     def post_init
       @lines = []
       Pry.config.pager, @old_pager = false, Pry.config.pager
       @auth_required  = @auth
       port, ip        = Socket.unpack_sockaddr_in(get_peername)
       @log.info("[pry-remote-em] received client connection from #{ip}:#{port}")
-      send_data({:g => "PryRemoteEm #{VERSION} #{@opts[:tls] ? 'pryems' : 'pryem'}"})
-      @opts[:tls] ? start_tls : (@auth_required && send_data({:a => false}))
+      # TODO include first level prompt in banner
+      send_banner("PryRemoteEm #{VERSION} #{@opts[:tls] ? 'pryems' : 'pryem'}")
+      @log.info("#{url} PryRemoteEm #{VERSION} #{@opts[:tls] ? 'pryems' : 'pryem'}")
+      @opts[:tls] ? start_tls : (@auth_required && send_auth(false))
       PryRemoteEm::Server.register(@obj, self)
     end
 
@@ -145,7 +195,7 @@ module PryRemoteEm
 
     def ssl_handshake_completed
       @log.info("[pry-remote-em] TLS connection established (#{peer_ip}:#{peer_port})")
-      send_data({:a => false}) if @auth_required
+      send_auth(false) if @auth_required
     end
 
     def peer_ip
@@ -162,74 +212,94 @@ module PryRemoteEm
       @peer_port
     end
 
-    def receive_json(j)
-      return send_data({:a => false}) if @auth_required && !j['a']
+    def receive_raw(d)
+      return if require_auth
+      return send_last_prompt if d.nil? || d.empty?
+      @lines.push(*d.split("\n"))
+      if @waiting
+        f, @waiting = @waiting, nil
+        f.resume(@lines.shift)
+      end
+    end
+
+    # tab completion request
+    def receive_completion(c)
+      return if require_auth
+      send_completion(@compl_proc.call(c))
+    end
 
-      if j['d'] # just normal data
-        return send_last_prompt if j['d'].empty?
-        @lines.push(*j['d'].split("\n"))
-        if @waiting
-          f, @waiting = @waiting, nil
-          f.resume(@lines.shift)
-        end
-      elsif j['c'] # tab completion request
-        send_data({:c => @compl_proc.call(j['c'])})
-
-      elsif j['a'] # authentication response
-        return send_data({:a => true}) if !@auth || !@auth_required
-        return send_data({:a => 'auth data must be a two element array'}) unless j['a'].is_a?(Array) && j['a'].length == 2
-        auth_attempt(j['a'][0], peer_ip)
-        unless (@auth_required = !@auth.call(*j['a']))
-          @user = j['a'][0]
-          auth_ok(j['a'][0], peer_ip)
-          authenticated!
-        else
-         auth_fail(j['a'][0], peer_ip)
-          if @auth_tries <= 0
-            msg = "max authentication attempts reached"
-            send_data({:a => msg})
-            @log.debug("[pry-remote-em] #{msg} (#{peer_ip}:#{peer_port})")
-            return close_connection_after_writing
-          end
-          @auth_tries -= 1
+    def receive_auth(user, pass)
+      return send_auth(true) if !@auth || !@auth_required
+      return send_auth('auth data must include a user and pass') if user.nil? || pass.nil?
+      auth_attempt(user, peer_ip)
+      unless (@auth_required = !@auth.call(user, pass))
+        @user = user
+        auth_ok(user, peer_ip)
+        authenticated!
+      else
+       auth_fail(user, peer_ip)
+        if @auth_tries <= 0
+          msg = "max authentication attempts reached"
+          send_auth(msg)
+          @log.debug("[pry-remote-em] #{msg} (#{peer_ip}:#{peer_port})")
+          return close_connection_after_writing
         end
-        return send_data({:a => !@auth_required})
+        @auth_tries -= 1
+      end
+      return send_auth(!@auth_required)
+    end
 
-      elsif j['m'] # message all peer connections
-        peers.each { |peer| peer.send_message(j['m'], @user) }
-        send_last_prompt
+    def receive_msg(m)
+      return if require_auth
+      peers.each { |peer| peer.send_message(m, @user) }
+      send_last_prompt
+    end
 
-      elsif j['b'] # broadcast message
-        peers(:all).each { |peer| peer.send_bmessage(j['b'], @user) }
-        send_last_prompt
+    def receive_msg_bcast(mb)
+      return if require_auth
+      peers(:all).each { |peer| peer.send_bmessage(mb, @user) }
+      send_last_prompt
+    end
 
-      elsif j['s'] # shell command
-        # TODO confirm shell command's are allowed
-        unless @allow_shell_cmds
-          puts "\033[1mshell commands are not allowed by this server\033[0m"
-          @log.error("refused to execute shell command '#{j['s']}' for #{@user} (#{peer_ip}:#{peer_port})")
-          send_data({:sc => -1})
-          send_last_prompt
-        else
-          @log.warn("executing shell command '#{j['s']}' for #{@user} (#{peer_ip}:#{peer_port})")
-          @shell_cmd = EM.popen3(j['s'], ShellCmd, self)
-        end
+    def receive_shell_cmd(cmd)
+      return if require_auth
+      unless @allow_shell_cmds
+        puts "\033[1mshell commands are not allowed by this server\033[0m"
+        @log.error("refused to execute shell command '#{cmd}' for #{@user} (#{peer_ip}:#{peer_port})")
+        send_shell_result(-1)
+        send_last_prompt
+      else
+        @log.warn("executing shell command '#{cmd}' for #{@user} (#{peer_ip}:#{peer_port})")
+        @shell_cmd = EM.popen3(cmd, ShellCmd, self)
+      end
+    end
 
-      elsif j['sd'] # shell data
-        @shell_cmd.send_data(j['sd'])
+    def receive_shell_data(d)
+      return if require_auth
+      @shell_cmd.send_data(d)
+    end
 
-      elsif j['ssc'] # shell ctrl-c
-        @shell_cmd.close_connection
+    def receive_shell_sig(type)
+      return if require_auth
+      type == :term && @shell_cmd.close_connection
+    end
 
-      else
-        warn "received unexpected data: #{j.inspect}"
-      end # j['d']
-    end # receive_json(j)
+    def receive_unknown(j)
+      return if require_auth
+      warn "received unexpected data: #{j.inspect}"
+      send_error("received unexpected data: #{j.inspect}")
+      send_last_prompt
+    end
 
+    def require_auth
+      return false if !@auth_required
+      send_auth(false)
+      true
+    end
 
     def authenticated!
       while (aa = @after_auth.shift)
-        send_data(aa)
+        aa.call
       end
     end
 
@@ -246,19 +316,24 @@ module PryRemoteEm
     end
 
     def send_last_prompt
-      @auth_required ? @after_auth.push({:p => @last_prompt}) :  send_data({:p => @last_prompt})
+      @auth_required ? (after_auth { send_prompt(@last_prompt) }) :  send_prompt(@last_prompt)
+    end
+
+    def after_auth(&blk)
+      # TODO perhaps replace with #auth_ok
+      @after_auth.push(blk)
     end
 
     # Sends a chat message to the client.
     def send_message(msg, from = nil)
       msg = "#{msg} (@#{from})" unless from.nil?
-      @auth_required ?  @after_auth.push({:m => msg}) : send_data({:m => msg})
+      @auth_required ?  (after_auth {send_msg(msg)}) : send_msg(msg)
     end
     #
     # Sends a chat message to the client.
     def send_bmessage(msg, from = nil)
       msg = "#{msg} (@#{from})" unless from.nil?
-      @auth_required ?  @after_auth.push({:mb => msg}) : send_data({:mb => msg})
+      @auth_required ?  (after_auth {send_msg_bcast(msg)}) : send_msg_bcast(msg)
     end
 
     # Callbacks for events on the server
@@ -299,19 +374,22 @@ module PryRemoteEm
       end
     end # auth_fail(*args, &blk)
 
+    def send_error(msg)
+      puts "\033[31m#{msg}\033[0m"
+    end
 
     # Methods that make Server compatible with Pry
 
     def readline(prompt)
       @last_prompt = prompt
-      @auth_required ? @after_auth.push({:p => prompt}) : send_data({:p => prompt})
+      @auth_required ? (after_auth { send_prompt(prompt) }) : send_prompt(prompt)
       return @lines.shift unless @lines.empty?
       @waiting = Fiber.current
       return Fiber.yield
     end
 
     def print(val)
-      @auth_required ? @after_auth.push({:d => val}) : send_data({:d => val})
+      @auth_required ? (after_auth { send_raw(val) }) : send_raw(val)
     end
     alias :write :print