farcall 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0590f2273cea0df6aa322c05cc5b5b4b75be5da0
-  data.tar.gz: be36bff0dfe37581e19af74308361b9958cdc4a2
+  metadata.gz: 7ccf7c600e32b64b16b3ee5e278064bef7214274
+  data.tar.gz: 2e7fc842321b53483a09b02caf9cc9c8fc8af85f
 SHA512:
-  metadata.gz: 4d400f0595d4b54caeff4f8c09eacc5282b5fdf23b5eb57b4c5f5a5620ad82d2e95d7520212b655a0f29a9fc4fd0e79161c2f236fe51f3b28536327c3277e634
-  data.tar.gz: 680ead9d24db0a9fc2b6b09c2c40c661030ad1917f91ddff132d6c85de92625ea269e02ec44616be135decdac714067e8e77050374a08720917bf53a52bb4a52
+  metadata.gz: 611fea3359ae86917d1625f8b1daf79e78c4cf20421a8ee64d3e679a00fbe0007a8bd79a551fb9e24bf6d38e3eea47dc9e77ac92927cb05c7c66f51d0ae8749e
+  data.tar.gz: 4010ab7cf9dbe52c2e4ca519c3df823a5ea104ff7783118340e576ebd2551c0866b20967c55b82e0a8a23e00a7314a73362efb433db6da9f092a8386c1388afe

data/README.md

@@ -1,11 +1,23 @@
 # Farcall
 
+## News
+
+Since 0.3.0 farcall gem provides websocket client and server out of the box. 
+
 ## Description
 
 The simple and elegant cross-platform RPC protocol that uses any formatter/transport capable of
 transmitting dictionary-like objects, for example, JSON, 
 [BOSS](https://github.com/sergeych/boss_protocol), XML, BSON and many others. This gem
-supports out of the box JSON and [BOSS](https://github.com/sergeych/boss_protocol) protocols. 
+supports out of the box JSON and [BOSS](https://github.com/sergeych/boss_protocol) protocols and
+streams and sockets as the media.
+
+There is also optional support for eventmachine based wbesocket server and regular client websocket
+connection. All you need is to include gem 'em-websocket' and/or gem 'websocket-client-simple'. 
+All websocket implementations use JSON encoding to vbe interoperable with most web allications.
+
+We do not include them in the dependencies because eventmachine is big and does not work with jruby,
+and websocket client is not always needed and we are fond of minimizing dependencies.
 
 RPC is made asynchronously, each call can have any return values. While one call is waiting,
 other calls can be executed. The protocol is bidirectional Call parameters could be
@@ -15,7 +27,7 @@ dictionary, wahtever.
 Exception/errors transmitting is also supported. The interface is very simple and rubyish. The 
 protocol is very easy to implement if there is no implementation, see 
 [Farcall protocol specification](https://github.com/sergeych/farcall/wiki). Java library for
-Android and desktop is coming soon.
+Android and desktop is ready upon request (leave me a task or a message in th github).
 
 ## Installation
 
@@ -23,8 +35,15 @@ Add this line to your application's Gemfile:
 
 ```ruby
     gem 'farcall'
-    # If you want to use binary-effective boss encoding:
-    # gem 'noss-protocol', '>= 1.4.1' 
+    # If you want to use binary-effective boss encoding, uncomment:
+    # gem 'boss-protocol', '>= 1.4.1'
+    #
+    # if you want to use eventmachine and server websocket, uncomment:
+    # gem 'em-websocket' 
+    # 
+    # To use websocket client, uncomment
+    # gem 'websocket-client-simple'
+     
 ```
 
 And then execute:
@@ -59,8 +78,16 @@ Or install it yourself as:
     TestProvider.new socket: connected_socket, format: :boss
 ```
 
-Suppose whe have some socket connected to one above, then TestProvider methods are available via
-this connection:
+`Farcall::Provider` provides easy constructors to use it with the transport or the endpoint.
+If you need to implement farcall over somw other media, just extend `TestTransport` and provide
+`send_data` and call `on_received_data` when need. It's very simple and straightforward.
+
+Consult [online documentation for Transport](http://www.rubydoc.info/gems/farcall/Farcall/Transport)
+and [Provider](http://www.rubydoc.info/gems/farcall/Farcall/Provider) for more.
+
+In the most common case you just have to connect two sockets, in which case everythng works right
+out of the box. Suppose whe have some socket connected to one above, then TestProvider methods are 
+available via this connection:
 
 ```ruby
 
@@ -120,11 +147,15 @@ So, I would recommend:
  
 - if you need BOSS but can't find it on your platform, use both and contact me :)
 
+## Usage with eventmacine
+
+You can use `EmFarcall::Endpoint` widely as it uses a pair of EM::Channel as a trasnport, e.g.
+it could be easily connected to any evented data source.
+
 ## Documentation
 
 * [Farcall protocol](https://github.com/sergeych/farcall/wiki)
 
-
 * Gem [online docs](http://www.rubydoc.info/gems/farcall)
 
 ## Contributing

data/farcall.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
     pass structures (dictionaries, hashes, whatever you name it). Out of the box provides
     JSON and BOSS formats over streams and sockets.
     End
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/sergeych/farcall"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -22,8 +22,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "boss-protocol", ">= 1.4.1"
+  spec.add_dependency 'hashie'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'em-websocket'
+  spec.add_development_dependency 'websocket-client-simple'
+  spec.add_development_dependency 'boss-protocol', '>= 1.4.3'
 end

data/lib/farcall/boss_transport.rb

@@ -9,6 +9,8 @@ module Farcall
     # Create json transport, see Farcall::Transpor#create for parameters
     def initialize **params
       setup_streams **params
+      @formatter = Boss::Formatter.new(@output)
+      @formatter.set_stream_mode
     end
 
     def on_data_received= block
@@ -21,7 +23,7 @@ module Farcall
     end
 
     def send_data hash
-      @output << Boss.dump(hash)
+      @formatter << hash
     end
 
     def close

data/lib/farcall/em_farcall.rb

@@ -0,0 +1,248 @@
+begin
+  require 'hashie'
+  require 'eventmachine'
+
+  # As the eventmachine callback paradigm is completely different from the threaded paradigm
+  # of the Farcall, that runs pretty well under JRuby and in multithreaded MRI, we provide
+  # compatible but different implementations: {EmFarcall::Endpoint}, {EmFarcall::Interface}
+  # and {EmFarcall::Provider}. Changes to adapt these are minimal except of the callback
+  # paradigm. The rest is the same.
+  #
+  module EmFarcall
+
+    # Endpoint that run in the reactor thread of the EM. Eventmachine should rin by the time of
+    # creation of the endpoint. All the methods can be called from any thread, not only
+    # EM's reactor thread.
+    #
+    # As the eventmachine callback paradigm is completely different from the threaded paradigm
+    # of the Farcall, that runs pretty well under
+    # JRuby and in multithreaded MRI, we provide
+    # compatible but different endpoint to run under EM.
+    #
+    # Its main difference is that there is no sync_call, instead, calling remote commands
+    # from the endpoint and/ot interface can provide blocks that are called when the remote
+    # is executed.
+    #
+    # The EM version of the endpoint works with any 2 EM:C:Channels.
+    #
+    class Endpoint
+
+      # Create new endpoint to work with input and output channels
+      #
+      # @param [EM::Channel] input_channel
+      # @param [EM::Channel] output_channel
+      def initialize(input_channel, output_channel, errback=nil, provider: nil)
+        EM.schedule {
+          @input, @output, @errback = input_channel, output_channel, errback
+          @trace                    = false
+          @in_serial                = @out_serial = 0
+          @callbacks                = {}
+          @handlers                 = {}
+          @unnamed_handler          = -> (name, *args, **kwargs) {
+            raise NoMethodError, "method does not exist: #{name}"
+          }
+          @input.subscribe { |data|
+            process_input(data)
+          }
+          if provider
+            @provider         = provider
+            provider.endpoint = self
+          end
+        }
+      end
+
+      # Set or get provider instance. When provider is set, its public methods are called by the remote
+      # and any possible exception are passed back to caller party. You can use any ruby class instance
+      # everything will work, operators, indexes[] and like.
+      attr_accessor :provider
+
+      # Call remote with specified name and arguments calling block when done.
+      # if block is provided, it will be called when the remote will be called and possibly return
+      # some data.
+      #
+      # Block receives single object paramter with two fields: `result.error` and `result.result`.
+      #
+      # `result.error` is not nil when the remote raised error, then `error[:class]` and
+      # `error.text` are set accordingly.
+      #
+      # if error is nil then result.result receives any return data from the remote method.
+      #
+      # for example:
+      #
+      #   endpoint.call( 'some_func', 10, 20) { |done|
+      #      if done.error
+      #        puts "Remote error class: #{done.error[:class]}: #{done.error.text}"
+      #      else
+      #        puts "Remote returned #{done.result}"
+      #   }
+      #
+      # @param [String] name command name
+      # @return [Endpoint] self
+      def call(name, *args, **kwargs, &block)
+        EM.schedule {
+          if block
+            @callbacks[@in_serial] = block
+          end
+          send_block cmd: name, args: args, kwargs: kwargs
+        }
+        self
+      end
+
+      # Close the endpoint
+      def close
+        super
+      end
+
+      # Report error via errback and the endpoint
+      def error text
+        STDERR.puts "farcall ws server error #{text}"
+        EM.schedule {
+          @errback.call(text) if @errback
+          close
+        }
+      end
+
+      # Set handler to perform the named command. Block will be called when the remote party calls
+      # with parameters passed from the remote. The block returned value will be passed back to
+      # the caller.
+      #
+      # If the block raises the exception it will be reported to the caller as an error (depending
+      # on it's platofrm, will raise exception on its end or report error)
+      def on(name, &block)
+        @handlers[name.to_s] = block
+      end
+
+      # Process remote command. First parameter passed to the block is the method name, the rest
+      # are optional arguments of the call:
+      #
+      #    endpoint.on_command { |name, *args, **kwargs|
+      #      if name == 'echo'
+      #        { args: args, keyword_args: kwargs }
+      #      else
+      #        raise "unknown command"
+      #      end
+      #    }
+      #
+      # raising exceptions from the block cause farcall error to be returned back th the caller.
+      def on_command &block
+        raise "unnamed handler should be present" unless block
+        @unnamed_handler = block
+      end
+
+      # Same as #on_command (compatibilty method)
+      def on_remote_call &block
+        on_command block
+      end
+
+      # Get the Farcall::RemoteInterface connnected to this endpoint. Any subsequent calls with
+      # return the same instance.
+      def remote
+        @remote ||= EmFarcall::Interface.new endpoint: self
+      end
+
+      private
+
+      # :nodoc: sends block with correct framing
+      def send_block **data
+        data[:serial] = @out_serial
+        @out_serial   += 1
+        @output << data
+      end
+
+      # :nodoc:
+      def execute_command cmd, ref, args, kwargs
+        kwargs = (kwargs || {}).inject({}) {
+            |all, kv|
+          all[kv[0].to_sym] = kv[1]
+          all
+        }
+        args << kwargs if kwargs && !kwargs.empty?
+        result = if proc = @handlers[cmd.to_s]
+                   proc.call(*args)
+                 elsif @provider
+                   provider.send :remote_call, cmd.to_sym, args
+                 else
+                   @unnamed_handler.call(cmd, args)
+                 end
+        send_block ref: ref, result: result
+
+      rescue
+        if @trace
+          puts $!
+          puts $!.backtrace.join("\n")
+        end
+        send_block ref: ref, error: { class: $!.class.name, text: $!.to_s }
+      end
+
+      # :nodoc: important that this method is called from reactor thread only
+      def process_input data
+        # To be free from :keys and 'keys'
+        data = Hashie::Mash.new(data) unless data.is_a?(Hashie::Mash)
+        if data.serial != @in_serial
+          error "framing error (wrong serial:)"
+        else
+          @in_serial += 1
+          if (cmd = data.cmd) != nil
+            execute_command(cmd, data.serial, data.args || [], data.kwargs || {})
+          else
+            ref = data.ref
+            if ref
+              if (block = @callbacks.delete(ref)) != nil
+                block.call(Hashie::Mash.new(result: data.result, error: data.error))
+              end
+            else
+              error "framing error: no ref in block #{data.inspect}"
+            end
+          end
+        end
+      end
+    end
+
+    # Interface to the remote provider via Farcall protocols. Works the same as if the object
+    # is local and yields block in return, unlike Farcall::Interface that blocks
+    #
+    # RemoteInterface transparently creates methods as you call them to speedup subsequent
+    # calls.
+    #
+    class Interface
+
+      # Create interface connected to some endpoint ar transpost.
+      #
+      # Please remember that Farcall::Transport instance could be used with only
+      # one connected object, unlike Farcall::Endpoint, which could be connected to several
+      # consumers.
+      #
+      # @param [Farcall::Endpoint|Farcall::Transport] arg either endpoint or a transport
+      #        to connect interface to
+      def initialize(endpoint)
+        @endpoint = endpoint
+      end
+
+      def method_missing(method_name, *arguments, **kw_arguments, &block)
+        instance_eval <<-End
+        def #{method_name} *arguments, **kw_arguments, &block
+          @endpoint.call '#{method_name}', *arguments, **kw_arguments, &block
+        end
+        End
+        @endpoint.call method_name, *arguments, **kw_arguments, &block
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+
+    class Provider < Farcall::Provider
+
+      attr_accessor :endpoint
+
+      def far_interface
+        endpoint.remote
+      end
+
+    end
+  end
+rescue LoadError
+  $!.to_s =~ /eventmachine/ or raise
+end
+

data/lib/farcall/em_wsserver_endpoint.rb

@@ -0,0 +1,73 @@
+begin
+  require 'em-websocket'
+  require 'eventmachine'
+  require_relative './em_farcall'
+
+  module EmFarcall
+
+    # Farcall websocket client. To use it you must add to your Gemfile:
+    #
+    #   gem 'websocket-client-simple'
+    #
+    # then you can use it with EM:
+    #
+    #    endpoint = nil
+    #
+    #    EM::WebSocket.run(params) do |ws|
+    #      ws.onopen { |handshake|
+    #        # Check handshake.path, handshake query
+    #        # for example to select the provider, then connect Farcall to websocket:
+    #        endpoint = EmFarcall::WsServerEndpoint.new ws, provider: WsProvider.new
+    #      }
+    #    end
+    #
+    # now we can use it as usual: remote can call provder method, and we can call remote:
+    #
+    #    endpoint.remote.do_something( times: 4) { |result|
+    #    }
+    #
+    #
+    # We do not include it into gem dependencies as it uses EventMachine
+    # which is not needed under JRuby and weight alot (the resto of Farcall plays well with jruby
+    # and MRI threads)
+    #
+    # Due to event-driven nature of eventmachine, WsServerEndpoint uses special version of
+    # {EmFarcall::Endpoint} and {EmFarcall::WsProvider} which are code compatible with regular
+    # farcall classes except for the callback-style calls where appropriate.
+    class WsServerEndpoint < EmFarcall::Endpoint
+
+      # Create endpoint with the already opened websocket instance. Note that all the handshake
+      # should be done prior to construct endpoint (e.g. you may want to have different endpoints
+      # for different paths and arguments)
+      #
+      # See {EmFarcall::Endpoint} for methods to call remote interface and process remote requests.
+      #
+      # @param [EM::WebSocket] websocket socket in open state (handshake should be passed)
+      def initialize websocket, **kwargs
+        @input  = EM::Channel.new
+        @output = EM::Channel.new
+        super(@input, @output, **kwargs)
+
+        websocket.onmessage { |data|
+          @input << unpack(data)
+        }
+        @output.subscribe { |data|
+          websocket.send(pack data)
+        }
+      end
+
+      def unpack data
+        JSON.parse data
+      end
+
+      def pack data
+        JSON[data]
+      end
+
+    end
+
+  end
+rescue LoadError
+  $!.to_s =~ /em-websocket/ or raise
+end
+

data/lib/farcall/endpoint.rb

@@ -1,13 +1,19 @@
+require 'hashie'
+
 module Farcall
 
   # The protocol endpoint. Takes some transport and implements Farcall protocol over
   # it. You can use it direcly or with Farcall::RemoteInterface and Farcall::LocalProvider helper
   # classes.
   #
+  # Note that the returned data is converted to Hashie::Mash primarily for the sake of :key vs.
+  # 'key' ambigity that otherwise might appear depending on the transport encoding protocol. Anyway
+  # it is better than ruby hash ;)
+  #
   # Endpoint class is thread-safe.
   class Endpoint
 
-    # Set or get provider instance. When provider is set, its methods are called by the remote
+    # Set or get provider instance. When provider is set, its public methods are called by the remote
     # and any possible exception are passed back to caller party. You can use any ruby class instance
     # everything will work, operators, indexes[] and like.
     attr_accessor :provider
@@ -59,8 +65,9 @@ module Farcall
     end
 
     # Call remote party. Retruns immediately. When remote party answers, calls the specified block
-    # if present. The block should take |error, result| parameters. Error could be nil or
-    # {'class' =>, 'text' => } hash. result is always nil if error is presented.
+    # if present. The block should take |error, result| parameters. If result's content hashes
+    # or result itself are instances of th Hashie::Mash. Error could be nil or
+    # {'class' =>, 'text' => } Hashie::Mash hash. result is always nil if error is presented.
     #
     # It is desirable to use Farcall::Endpoint#interface or
     # Farcall::RemoteInterface rather than this low-level method.
@@ -84,7 +91,8 @@ module Farcall
     # Farcall::RemoteInterface rather than this low-level method.
     #
     # @param [String] name of the remote command
-    # @return [Object] any data that remote party retruns
+    # @return [Object] any data that remote party retruns. If it is a hash, it is a Hashie::Mash
+    #     instance.
     # @raise [Farcall::RemoteError]
     #
     def sync_call(name, *args, **kwargs)
@@ -143,12 +151,14 @@ module Farcall
 
     def _received(data)
       # p [:r, data]
+      data = Hashie::Mash.new data
+
       cmd, serial, args, kwargs, ref, result, error =
           %w{cmd serial args kwargs ref result error}.map { |k| data[k] || data[k.to_sym] }
       !serial || serial < 0 and abort 'missing or bad serial'
 
       @receive_lock.synchronize {
-        serial == @in_serial or abort "bad sync"
+        serial == @in_serial or abort "framing error (wrong serial)"
         @in_serial += 1
       }
 
@@ -161,15 +171,18 @@ module Farcall
                        if kwargs && !kwargs.empty?
                          # ruby thing: keyqord args must be symbols, not strings:
                          fixed = {}
-                         kwargs.each { |k,v| fixed[k.to_sym] = v}
+                         kwargs.each { |k, v| fixed[k.to_sym] = v }
                          args << fixed
                        end
-                       @provider.send cmd.to_sym, *args
+                       @provider.send :remote_call, cmd.to_sym, args
                      elsif @on_remote_call
                        @on_remote_call.call cmd, args, kwargs
                      end
             _send ref: serial, result: result
           rescue Exception => e
+            # puts e
+            # puts e.backtrace.join("\n")
+
             _send ref: serial, error: { 'class' => e.class.name, 'text' => e.to_s }
           end
 
@@ -195,23 +208,54 @@ module Farcall
     # suites you better.
     #
     # Please remember that Farcall::Transport instance could be used with only
-    # one conneced object, unlike Farcall::Endpoint, which could be connected to several
+    # one connected object, unlike Farcall::Endpoint, which could be connected to several
     # consumers.
+    #
+    # @param [Farcall::Endpoint] endpoint to connect to (no transport should be provided).
+    #           note that if endpoint is specified, transport would be ignored eeven if used
+    # @param [Farcall::Transport] transport to use (don't use endpoint then)
     def initialize endpoint: nil, transport: nil, **params
-      @endpoint          = if endpoint
-                             endpoint
-                           else
-                             transport ||= Farcall::Transport.create **params
-                             Farcall::Endpoint.new transport
-                           end
-      @endpoint.provider = self
+      if endpoint || transport || params.size > 0
+        @endpoint          = if endpoint
+                               endpoint
+                             else
+                               transport ||= Farcall::Transport.create **params
+                               Farcall::Endpoint.new transport
+                             end
+        @endpoint.provider = self
+      end
     end
 
     # Get remote interface
-    # @return [Farcall::Interface] to call methods on the other end
+    # @return [Farcall::Interface] to call methods on the other end, e.g. if this provider would
+    # like to call other party's methiod, it can do it cimply by:
+    #
+    #   far_interface.some_method('hello')
+    #
     def far_interface
       @endpoint.remote
     end
+
+    # close connection if need
+    def close_connection
+      @endpoint.close
+    end
+
+    protected
+
+    # Override it to repond to remote calls. Base implementation let invoke only public method
+    # only owned by this class. Be careful to not to expose more than intended!
+    def remote_call name, args
+      m = public_method(name)
+      if m && m.owner == self.class
+        m.call(*args)
+      else
+        raise NoMethodError, "method #{name} is not found"
+      end
+    rescue NameError
+      raise NoMethodError, "method #{name} is not found"
+    end
+
   end
 
   # Intervace to the remote provider via Farcall protocols. Works the same as if the object
@@ -228,7 +272,7 @@ module Farcall
     # Create interface connected to some endpoint ar transpost.
     #
     # Please remember that Farcall::Transport instance could be used with only
-    # one conneced object, unlike Farcall::Endpoint, which could be connected to several
+    # one connected object, unlike Farcall::Endpoint, which could be connected to several
     # consumers.
     #
     # @param [Farcall::Endpoint|Farcall::Transport] arg either endpoint or a transport

data/lib/farcall/monitor_lock.rb

@@ -0,0 +1,74 @@
+require 'thread'
+
+# :nodoc:
+class MontorLock
+
+  def initialize
+    @condition = ConditionVariable.new
+    @mutex = Mutex.new
+  end
+
+  def notify
+    @mutex.synchronize {
+      @condition.signal
+    }
+  end
+
+  def wait
+    @mutex.synchronize {
+      @condition.wait(@mutex)
+      yield if block_given?
+    }
+  end
+
+end
+
+# :nodoc:
+class Semaphore
+
+  def initialize state_set=false
+    @monitor = MontorLock.new
+    @state_set = state_set
+  end
+
+  def set?
+    @state_set
+  end
+
+  def clear?
+    !set?
+  end
+
+  def wait state
+    while @state_set != state do
+      @monitor.wait
+    end
+    @state_set
+  end
+
+  def wait_set
+    wait true
+  end
+
+  def wait_clear
+    wait false
+  end
+
+  def wait_change &block
+    @monitor.wait {
+      block.call(@state_set) if block
+    }
+    @state_set
+  end
+
+  def set new_state=true
+    if @state_set != new_state
+      @state_set = new_state
+      @monitor.notify
+    end
+  end
+
+  def clear
+    set false
+  end
+end

data/lib/farcall/transport.rb

@@ -46,7 +46,9 @@ module Farcall
     end
 
     # Tansport must call this process on each incoming hash
-    # passing it as the only parameter, e.g. self.on_data_received(hash)
+    # passing it as the only parameter, e.g. self.on_data_received.call(hash)
+    # Common trick is to start inner event loop on on_data_recieved=, don't forget
+    # to call super first.
     attr_accessor :on_data_received, :on_abort, :on_close
 
     # Utility function. Calls the provided block on data reception. Resets the

data/lib/farcall/version.rb

@@ -1,3 +1,3 @@
 module Farcall
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

data/lib/farcall/wsclient_transport.rb

@@ -0,0 +1,55 @@
+require 'farcall'
+require 'websocket-client-simple'
+require_relative './monitor_lock'
+require 'json'
+
+module Farcall
+  # Websocket client transport using JSON encodeing. Works with ruby threads, pure ruby, runs
+  # everywhere. Use if like any thoer Farcall::Transport, for example:
+  #
+  # in your Gemfile
+  #
+  #     gem 'websocket-client-simple'
+  #
+  # in the code
+  #
+  #     wst = Farcall::WebsocketJsonClientTransport.new 'ws://icodici.com:8080/test'
+  #     i = Farcall::Interface.new transport: wst
+  #     result = i.authenticate(login, password) # remote call via interface...
+  #
+  class WebsocketJsonClientTransport < Farcall::Transport
+
+    # Create transport connected to the specified websocket url. Constructor blocks
+    # until connected, or raise error if connection can't be established. Transport uses
+    # JSON encodgin over standard websocket protocol.
+    def initialize ws_url
+      # The stranges bug around in the WebSocket::Client (actually in his eventemitter)
+      me = self
+
+      is_open = Semaphore.new
+      @ws     = WebSocket::Client::Simple.connect(ws_url)
+
+      @ws.on(:open) {
+        # if me != self
+        #   puts "\n\n\nSelf is set to wrong in the callback in #{RUBY_VERSION}\n\n\n"
+        # end
+        # puts "client is open"
+        is_open.set
+      }
+
+      @ws.on(:message) { |m|
+        # puts "ws client received #{JSON.parse m.data}"
+        me.on_data_received and me.on_data_received.call(JSON.parse m.data)
+        # puts "and sent"
+      }
+      @ws.on(:close) { close }
+      is_open.wait_set
+    end
+
+    # :nodoc:
+    def send_data data
+      @ws.send JSON[data]
+    end
+
+  end
+end

data/lib/farcall.rb

@@ -8,6 +8,9 @@ begin
   require 'farcall/boss_transport'
 rescue LoadError
 end
+require 'farcall/wsclient_transport'
+require 'farcall/em_wsserver_endpoint'
+
 
 module Farcall
   # Your code goes here...

data/spec/endpoint_spec.rb

@@ -11,8 +11,35 @@ class TestProvider < Farcall::Provider
     @a, @b     = a, b
     return "Foo: #{a+b}, #{optional}"
   end
+
+  def self.doncallpublic
+
+  end
+
+  def get_hash
+    { 'foo' => 'bar', 'bardd' => 'buzz', 'last' => 'item', 'bar' => 'test'}
+  end
+
+  private
+
+  def dontcall
+
+  end
 end
 
+class StringProvider < Farcall::Provider
+  def initialize(str)
+    @str = str
+  end
+
+  def provide_hash
+    { 'bar' => 'test', 'foo' => 'bar'}
+  end
+
+  def value
+    @str
+  end
+end
 
 describe 'endpoint' do
   include Farcall
@@ -38,14 +65,20 @@ describe 'endpoint' do
     i.a.should == 5
     i.b.should == 6
 
-    ib.split.should == ['Hello', 'world']
+    # ib.split.should == ['Hello', 'world']
+
+    expect(-> { i.dontcall() }).to raise_error Farcall::RemoteError, /NoMethodError/
+    expect(-> { i.sleep() }).to raise_error Farcall::RemoteError, /NoMethodError/
+    expect(-> { i.abort() }).to raise_error Farcall::RemoteError, /NoMethodError/
+    expect(-> { i.doncallpublic() }).to raise_error Farcall::RemoteError, /NoMethodError/
+    expect(-> { i.initialize(1) }).to raise_error Farcall::RemoteError, /NoMethodError/
   end
 
   def check_protocol format
     s1, s2 = Socket.pair(:UNIX, :STREAM, 0)
 
     tp = TestProvider.new socket: s1, format: format
-    i  = Farcall::Interface.new socket: s2, format: format, provider: "Hello world"
+    i  = Farcall::Interface.new socket: s2, format: format, provider: StringProvider.new("bar")
 
     expect(-> { i.foo() }).to raise_error Farcall::RemoteError
 
@@ -55,14 +88,18 @@ describe 'endpoint' do
     i.a.should == 5
     i.b.should == 6
 
-    tp.far_interface.split.should == ['Hello', 'world']
+    i.get_hash.foo.should == 'bar'
+    i.get_hash.bar.should == 'test'
+    tp.far_interface.value.should == 'bar'
+    tp.far_interface.provide_hash.bar.should == 'test'
+    tp.far_interface.provide_hash.foo.should == 'bar'
   end
 
   it 'should connect json via shortcut' do
     check_protocol :json
   end
 
-  it 'should connect boss via shortcut' do
+  it 'boss connect boss via shortcut' do
     check_protocol :boss
   end
 

data/spec/websock_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+require 'eventmachine'
+
+def standard_check_wsclient(cnt1, r1, r2, r3)
+  r1 = Hashie::Mash.new(r1)
+  r2 = Hashie::Mash.new(r2)
+
+  r1.kwargs.hello.should == 'world'
+  r1.superpong.should == [1, 2, 3]
+  r2.kwargs.hello.should == 'world'
+  r2.superpong.should == [1, 2, 10]
+
+  cnt1.should == 2
+end
+
+def standard_check(cnt1, r1, r2, r3)
+  r1.error.should == nil
+  r1.result.kwargs.hello.should == 'world'
+  r1.result.superpong.should == [1, 2, 3]
+  r2.error.should == nil
+  r2.result.kwargs.hello.should == 'world'
+  r2.result.superpong.should == [1, 2, 10]
+  r3.error[:class].should == 'RuntimeError'
+  r3.error.text.should == 'test error'
+  cnt1.should == 3
+end
+
+
+def setup_endpoints
+  c1, c2, c3, c4 = 4.times.map { EM::Channel.new }
+
+  @e1 = EmFarcall::Endpoint.new c1, c2
+  @e2 = EmFarcall::Endpoint.new c3, c4
+
+  c2.subscribe { |x| c3 << x }
+  c4.subscribe { |x| c1 << x }
+
+  @e2.on :superping do |*args, **kwargs|
+    if kwargs[:need_error]
+      raise 'test error'
+    end
+    { superpong: args, kwargs: kwargs }
+  end
+  [@e1, @e2]
+end
+
+describe 'em_farcall' do
+
+  it 'exchange messages' do
+    r1   = nil
+    r2   = nil
+    r3   = nil
+    cnt1 = 0
+
+    EM.run {
+      e1, e2 = setup_endpoints
+      e1.call 'superping', 1, 2, 3, hello: 'world' do |r|
+        r1   = r
+        cnt1 += 1
+      end
+
+      e1.call 'superping', 1, 2, 10, hello: 'world' do |r|
+        r2   = r
+        cnt1 += 1
+      end
+
+      e1.call 'superping', 1, 2, 10, need_error: true, hello: 'world' do |r|
+        r3   = r
+        cnt1 += 1
+        EM.stop
+      end
+
+      EM.add_timer(4) {
+        EM.stop
+      }
+    }
+    standard_check(cnt1, r1, r2, r3)
+  end
+
+  it 'uses remote interface' do
+    r1   = nil
+    r2   = nil
+    r3   = nil
+    cnt1 = 0
+
+    EM.run {
+      e1, e2 = setup_endpoints
+      i      = EmFarcall::Interface.new e1
+
+      i.superping(1, 2, 3, hello: 'world') { |r|
+        r1   = r
+        cnt1 += 1
+      }
+
+      i.superping 1, 2, 10, hello: 'world' do |r|
+        r2   = r
+        cnt1 += 1
+      end
+
+      i.superping 1, 2, 10, need_error: true, hello: 'world' do |r|
+        r3   = r
+        cnt1 += 1
+        EM.stop
+      end
+
+      i.test_not_existing
+
+      EM.add_timer(4) {
+        EM.stop
+      }
+    }
+    standard_check(cnt1, r1, r2, r3)
+  end
+
+  it 'runs via websockets' do
+    r1   = nil
+    r2   = nil
+    r3   = nil
+    cnt1 = 0
+
+    EM.run {
+      params = {
+          :host => 'localhost',
+          :port => 8088
+      }
+      e1     = nil
+      e2     = nil
+
+      EM::WebSocket.run(params) do |ws|
+        ws.onopen { |handshake|
+          e2 = EmFarcall::WsServerEndpoint.new ws
+
+          e2.on :superping do |*args, **kwargs|
+            if kwargs[:need_error]
+              raise 'test error'
+            end
+            { superpong: args, kwargs: kwargs }
+          end
+        }
+      end
+
+
+      EM.defer {
+        t1 = Farcall::WebsocketJsonClientTransport.new 'ws://localhost:8088/test'
+        i  = Farcall::Interface.new transport: t1
+
+        r1   = i.superping(1, 2, 3, hello: 'world')
+        cnt1 += 1
+
+        r2   = i.superping 1, 2, 10, hello: 'world'
+        cnt1 += 1
+
+        expect {
+          r3 = i.superping 1, 2, 10, need_error: true, hello: 'world'
+        }.to raise_error(Farcall::RemoteError, "RuntimeError: test error")
+
+        expect {
+          r3 = i.superping_bad 13, 2, 10, hello: 'world'
+        }.to raise_error(Farcall::RemoteError, /NoMethodError/)
+
+
+        EM.stop
+      }
+      EM.add_timer(4) {
+        EM.stop
+      }
+    }
+
+    standard_check_wsclient(cnt1, r1, r2, r3)
+  end
+
+
+  class WsProvider < EmFarcall::Provider
+    def superping *args, **kwargs
+      if kwargs[:need_error]
+        raise 'test error'
+      end
+      { superpong: args, kwargs: kwargs }
+    end
+  end
+
+  it 'runs via websockets with provider' do
+    r1   = nil
+    r2   = nil
+    r3   = nil
+    cnt1 = 0
+
+    EM.run {
+      params = {
+          :host => 'localhost',
+          :port => 8088
+      }
+      e1     = nil
+      e2     = nil
+
+      EM::WebSocket.run(params) do |ws|
+        ws.onopen { |handshake|
+          e2 = EmFarcall::WsServerEndpoint.new ws, provider: WsProvider.new
+        }
+      end
+
+
+      EM.defer {
+        t1 = Farcall::WebsocketJsonClientTransport.new 'ws://localhost:8088/test'
+        i  = Farcall::Interface.new transport: t1
+
+        r1   = i.superping(1, 2, 3, hello: 'world')
+        cnt1 += 1
+
+        r2   = i.superping 1, 2, 10, hello: 'world'
+        cnt1 += 1
+
+        expect {
+          r3 = i.superping 1, 2, 11, need_error: true, hello: 'world'
+        }.to raise_error(Farcall::RemoteError, "RuntimeError: test error")
+
+        expect {
+          r3 = i.superping_bad 13, 2, 10, need_error: true, hello: 'world'
+        }.to raise_error(Farcall::RemoteError, /NoMethodError/)
+
+
+        EM.stop
+      }
+      EM.add_timer(4) {
+        EM.stop
+      }
+    }
+
+    standard_check_wsclient(cnt1, r1, r2, r3)
+  end
+
+
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: farcall
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - sergeych
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-28 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +66,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: boss-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 1.4.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 1.4.3
 description: |2
       Simple and effective cross-platform RPC protocol. Can work with any transport capable to
       pass structures (dictionaries, hashes, whatever you name it). Out of the box provides
@@ -85,15 +127,19 @@ files:
 - farcall.gemspec
 - lib/farcall.rb
 - lib/farcall/boss_transport.rb
+- lib/farcall/em_farcall.rb
+- lib/farcall/em_wsserver_endpoint.rb
 - lib/farcall/endpoint.rb
 - lib/farcall/json_transport.rb
+- lib/farcall/monitor_lock.rb
 - lib/farcall/transport.rb
 - lib/farcall/version.rb
+- lib/farcall/wsclient_transport.rb
 - spec/endpoint_spec.rb
-- spec/rmi_spec.rb
 - spec/spec_helper.rb
 - spec/transports_spec.rb
-homepage: ''
+- spec/websock_spec.rb
+homepage: https://github.com/sergeych/farcall
 licenses:
 - MIT
 metadata: {}
@@ -113,12 +159,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Simple, elegant and cross-platofrm RPC protocol
 test_files:
 - spec/endpoint_spec.rb
-- spec/rmi_spec.rb
 - spec/spec_helper.rb
 - spec/transports_spec.rb
+- spec/websock_spec.rb

data/spec/rmi_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe 'rmi' do
-
-  it 'should connect existing objects and'
-
-end