wamp_client 0.0.9 → 0.1.0

data/lib/wamp/client/transport/base.rb

@@ -0,0 +1,152 @@
+=begin
+
+Copyright (c) 2018 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require 'wamp/client/serializer'
+
+module Wamp
+  module Client
+    module Transport
+      class Base
+
+        # Callback when the socket is opened
+        @on_open
+        def on_open(&on_open)
+          @on_open = on_open
+        end
+
+        # Callback when the socket is closed.  Parameters are
+        # @param reason [String] String telling the reason it was closed
+        @on_close
+        def on_close(&on_close)
+          @on_close = on_close
+        end
+
+        # Callback when a message is received.  Parameters are
+        # @param msg [Array] The parsed message that was received
+        @on_message
+        def on_message(&on_message)
+          @on_message = on_message
+        end
+
+        # Callback when there is an error.  Parameters are
+        # @param msg [String] The message from the error
+        @on_error
+        def on_error(&on_error)
+          @on_error = on_error
+        end
+
+        # Simple setter for callbacks
+        def on(event, &callback)
+          case event
+          when :open
+            self.on_open(&callback)
+          when :close
+            self.on_close(&callback)
+          when :message
+            self.on_message(&callback)
+          when :error
+            self.on_error(&callback)
+          else
+            raise RuntimeError, "Unknown on(event) '#{event}'"
+          end
+        end
+
+        attr_accessor :uri, :proxy, :headers, :protocol, :serializer, :connected
+
+        # Constructor for the transport
+        # @param options [Hash] The connection options.  the different options are as follows
+        # @option options [String] :uri The url to connect to
+        # @option options [String] :proxy The proxy to use
+        # @option options [String] :protocol The protocol
+        # @option options [Hash] :headers Custom headers to include during the connection
+        # @option options [WampClient::Serializer::Base] :serializer The serializer to use
+        def initialize(options)
+
+          # Initialize the parameters
+          self.connected = false
+          self.uri = options[:uri]
+          self.proxy = options[:proxy]
+          self.headers = options[:headers] || {}
+          self.protocol = options[:protocol] || 'wamp.2.json'
+          self.serializer = options[:serializer] || Wamp::Client::Serializer::JSONSerializer.new
+
+          # Add the wamp.2.json protocol header
+          self.headers['Sec-WebSocket-Protocol'] = self.protocol
+
+          # Initialize callbacks
+          @on_open = nil
+          @on_close = nil
+          @on_message = nil
+          @on_error = nil
+
+        end
+
+        # Connects to the WAMP Server using the transport
+        def connect
+          # Implement in subclass
+        end
+
+        # Disconnects from the WAMP Server
+        def disconnect
+          # Implement in subclass
+        end
+
+        # Returns true if the transport it connected
+        def connected?
+          self.connected
+        end
+
+        # Sends a Message
+        # @param [Array] msg - The message payload to send
+        def send_message(msg)
+          # Implement in subclass
+        end
+
+        # Process the callback when the timer expires
+        # @param [Integer] milliseconds - The number
+        # @param [block] callback - The callback that is fired when the timer expires
+        def self.add_timer(milliseconds, &callback)
+          # Implement in subclass
+        end
+        def add_timer(milliseconds, &callback)
+          self.class.add_timer(milliseconds, &callback)
+        end
+
+        # Method to start the event machine for the socket
+        def self.start_event_machine(&block)
+          # Implement in subclass
+        end
+
+        # Method to stop the vent machine
+        def self.stop_event_machine
+          # Implement in subclass
+        end
+
+      end
+    end
+  end
+end

data/lib/{wamp_client → wamp/client}/transport/event_machine_base.rb

@@ -1,6 +1,6 @@
 =begin
 
-Copyright (c) 2016 Eric Chapman
+Copyright (c) 2018 Eric Chapman
 
 MIT License
 
@@ -28,27 +28,29 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 require 'eventmachine'
 require_relative 'base'
 
-module WampClient
-  module Transport
-    class EventMachineBase < Base
+module Wamp
+  module Client
+    module Transport
+      class EventMachineBase < Base
 
-      def self.start_event_machine(&block)
-        EM.run do
-          block.call
+        def self.start_event_machine(&block)
+          EM.run do
+            block.call
+          end
         end
-      end
 
-      def self.stop_event_machine
-        EM.stop
-      end
+        def self.stop_event_machine
+          EM.stop
+        end
 
-      def self.add_timer(milliseconds, &callback)
-        delay = (milliseconds.to_f/1000.0).ceil
-        EM.add_timer(delay) {
-          callback.call
-        }
-      end
+        def self.add_timer(milliseconds, &callback)
+          delay = (milliseconds.to_f/1000.0).ceil
+          EM.add_timer(delay) {
+            callback.call
+          }
+        end
 
+      end
     end
   end
 end

data/lib/wamp/client/transport/faye_web_socket.rb

@@ -0,0 +1,85 @@
+=begin
+
+Copyright (c) 2018 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require_relative 'event_machine_base'
+
+# This implementation uses the 'faye-websocket' Gem.
+module Wamp
+  module Client
+    module Transport
+      class FayeWebSocket < EventMachineBase
+        attr_accessor :socket
+
+        def initialize(options)
+          super(options)
+          self.socket = nil
+
+          # Only make them include the gem if they are going to use it
+          require 'faye/websocket'
+        end
+
+        def connect
+          options = { :headers => self.headers }
+          options[:proxy] = self.proxy if self.proxy != nil
+          self.socket = Faye::WebSocket::Client.new(self.uri, [self.protocol], options)
+
+          self.socket.on(:open) do |event|
+            self.connected = true
+            @on_open.call if @on_open
+          end
+
+          self.socket.on(:message) do |event|
+            @on_message.call(self.serializer.deserialize(event.data)) if @on_message
+          end
+
+          self.socket.on(:close) do |event|
+            self.connected = false
+            @on_close.call(event.reason) if @on_close
+          end
+
+          self.socket.on(:error) do |event|
+            @on_error.call(event.message) if @on_error
+          end
+        end
+
+        def disconnect
+          self.socket.close
+          self.connected = false
+        end
+
+        def send_message(msg)
+          if self.connected
+            self.socket.send(self.serializer.serialize(msg))
+          else
+            raise RuntimeError, "Socket must be open to call 'send_message'"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/wamp/client/transport/web_socket_event_machine.rb

@@ -0,0 +1,88 @@
+=begin
+
+Copyright (c) 2018 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require_relative 'event_machine_base'
+
+# This implementation uses the 'websocket-eventmachine-client' Gem.
+# This is the default if no transport is included
+module Wamp
+  module Client
+    module Transport
+      class WebSocketEventMachine < EventMachineBase
+        attr_accessor :socket
+
+        def initialize(options)
+          super(options)
+          self.socket = nil
+
+          # Only make them include the gem if they are going to use it
+          require 'websocket-eventmachine-client'
+
+          # Raise an exception if proxy was included (not supported)
+          if self.proxy != nil
+            raise RuntimeError, "The WebSocketEventMachine transport does not support 'proxy'.  Try using 'faye-websocket' transport instead"
+          end
+        end
+
+        def connect
+          self.socket = WebSocket::EventMachine::Client.connect(
+              :uri => self.uri,
+              :headers => self.headers
+          )
+
+          self.socket.onopen do
+            self.connected = true
+            @on_open.call if @on_open
+          end
+
+          self.socket.onmessage do |msg, type|
+            @on_message.call(self.serializer.deserialize(msg)) if @on_message
+          end
+
+          self.socket.onclose do |code, reason|
+            self.connected = false
+            @on_close.call(reason) if @on_close
+          end
+        end
+
+        def disconnect
+          self.connected = !self.socket.close  # close returns 'true' if the connection was closed immediately
+        end
+
+        def send_message(msg)
+          if self.connected
+            self.socket.send(self.serializer.serialize(msg), {type: 'text'})
+          else
+            raise RuntimeError, "Socket must be open to call 'send_message'"
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/{wamp_client → wamp/client}/version.rb

@@ -1,6 +1,6 @@
 =begin
 
-Copyright (c) 2016 Eric Chapman
+Copyright (c) 2018 Eric Chapman
 
 MIT License
 
@@ -25,6 +25,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 =end
 
-module WampClient
-  VERSION = '0.0.9'
+module Wamp
+  module Client
+    VERSION = '0.1.0'
+  end
 end

data/scripts/gen_message.rb

@@ -69,49 +69,50 @@ count = 0
 message_type_lookup.each do |name, value|
 
   # Generate the defines
-  message_type_define += "      #{name} = #{value}\n"
+  message_type_define += "        #{name} = #{value}\n"
 
   # Generate the lookup
   if count == 0
-    message_lookup_define += '        if'
+    message_lookup_define += '          if'
   else
-    message_lookup_define += '        elsif'
+    message_lookup_define += '          elsif'
   end
   message_lookup_define += " params[0] == Types::#{name}\n"
-  message_lookup_define += "          object = WampClient::Message::#{name.downcase.capitalize}.parse(params)\n"
+  message_lookup_define += "            object = Wamp::Client::Message::#{name.downcase.capitalize}.parse(params)\n"
 
   count += 1
 end
 
-source_file_header = "require 'wamp_client/check'
+source_file_header = "require 'wamp/client/check'
 
 # !!!!THIS FILE IS AUTOGENERATED.  DO NOT HAND EDIT!!!!
 
-module WampClient
-  module Message
+module Wamp
+  module Client
+    module Message
 
-    module Types
-#{message_type_define}    end
+      module Types
+#{message_type_define}      end
 
-    class Base
-      include WampClient::Check
+      class Base
+        include Wamp::Client::Check
 
-      def payload
-        []
-      end
+        def payload
+          []
+        end
 
-      # @param params [Array]
-      def self.parse(params)
-        object = nil
-#{message_lookup_define}        end
+        # @param params [Array]
+        def self.parse(params)
+          object = nil
+#{message_lookup_define}          end
 
-        object
+          object
+        end
       end
-
-    end
 "
 
 source_file_footer = "
+    end
   end
 end
 "
@@ -120,7 +121,7 @@ test_file_header = "require 'spec_helper'
 
 # !!!!THIS FILE IS AUTOGENERATED.  DO NOT HAND EDIT!!!!
 
-describe WampClient::Message do
+describe Wamp::Client::Message do
 "
 
 test_file_footer = "
@@ -330,7 +331,7 @@ messages.each do |message|
   required_count = 0
   param_formats = ''
   message[:formats].each do |format|
-    param_formats += '    #   ' + format + "\n"
+    param_formats += '      #   ' + format + "\n"
 
     # Generate the params
     temp_format = format.delete(' ')
@@ -367,14 +368,14 @@ messages.each do |message|
   # Source File
   ###############################################
   source_file += "\n"
-  source_file += '    # ' + message[:name].capitalize + "\n"
-  source_file += '    # ' + message[:description] + "\n"
-  source_file += "    # Formats:\n"
+  source_file += '      # ' + message[:name].capitalize + "\n"
+  source_file += '      # ' + message[:description] + "\n"
+  source_file += "      # Formats:\n"
   source_file += param_formats
-  source_file += '    class ' + message[:name].capitalize + " < Base\n"
+  source_file += '      class ' + message[:name].capitalize + " < Base\n"
 
   # Generate the local variables
-  source_file += '      attr_accessor'
+  source_file += '        attr_accessor'
   count = 0
   params.each do |param|
     source_file += ',' unless count == 0
@@ -384,20 +385,20 @@ messages.each do |message|
   source_file += "\n"
 
   # Generate the constructor
-  source_file += "\n      def initialize("
+  source_file += "\n        def initialize("
   count = 0
   checks = ''
   setters = ''
   params.each do |param|
-    setters += "        self.#{param[:name]} = #{param[:name]}\n"
+    setters += "          self.#{param[:name]} = #{param[:name]}\n"
 
     source_file += ', ' if count > 0
     if param[:required]
       source_file += "#{param[:name]}"
-      checks += "        self.class.check_#{param[:type]}('#{param[:name]}', #{param[:name]})\n"
+      checks += "          self.class.check_#{param[:type]}('#{param[:name]}', #{param[:name]})\n"
     else
       source_file += "#{param[:name]}=nil"
-      checks += "        self.class.check_#{param[:type]}('#{param[:name]}', #{param[:name]}, true)\n"
+      checks += "          self.class.check_#{param[:type]}('#{param[:name]}', #{param[:name]}, true)\n"
     end
 
     count += 1
@@ -405,38 +406,38 @@ messages.each do |message|
   source_file += ")\n\n"
   source_file += checks + "\n"
   source_file += setters + "\n"
-  source_file += "      end\n"
+  source_file += "        end\n"
 
   # Generate the 'type' method
-  source_file += "\n      def self.type\n        Types::#{message[:name].upcase}\n      end\n"
+  source_file += "\n        def self.type\n          Types::#{message[:name].upcase}\n        end\n"
 
   # Generate the parser
-  source_file += "\n      def self.parse(params)\n"
-  source_file += "\n        self.check_gte('params list', #{required_count+1}, params.count)\n"
-  source_file += "        self.check_equal('message type', self.type, params[0])\n"
-  source_file += "\n        params.shift\n        self.new(*params)\n"
-  source_file += "\n      end\n"
+  source_file += "\n        def self.parse(params)\n"
+  source_file += "\n          self.check_gte('params list', #{required_count+1}, params.count)\n"
+  source_file += "          self.check_equal('message type', self.type, params[0])\n"
+  source_file += "\n          params.shift\n          self.new(*params)\n"
+  source_file += "\n        end\n"
 
   # Generate the payload
-  source_file += "\n      def payload\n"
+  source_file += "\n        def payload\n"
 
   optional_params = []
   params.each do |param|
     unless param[:required]
       optional_params.push(param)
-      source_file += "        self.#{param[:name]} ||= #{empty_value_from_type(param[:type])}\n"
+      source_file += "          self.#{param[:name]} ||= #{empty_value_from_type(param[:type])}\n"
     end
   end
   source_file += "\n"
 
-  source_file += "        payload = [self.class.type]\n"
+  source_file += "          payload = [self.class.type]\n"
   optional_count = 0
   params.each do |param|
     if param[:required]
-      source_file += "        payload.push(self.#{param[:name]})\n"
+      source_file += "          payload.push(self.#{param[:name]})\n"
     else
       optional_count += 1
-      source_file += "\n        return payload if (self.#{param[:name]}.empty?"
+      source_file += "\n          return payload if (self.#{param[:name]}.empty?"
 
       # Insert remaining parameters
       for i in optional_count..(optional_params.size-1) do
@@ -444,19 +445,19 @@ messages.each do |message|
       end
 
       source_file += ")\n"
-      source_file += "        payload.push(self.#{param[:name]})\n"
+      source_file += "          payload.push(self.#{param[:name]})\n"
     end
   end
-  source_file += "\n        payload\n"
-  source_file += "      end\n"
+  source_file += "\n          payload\n"
+  source_file += "        end\n"
 
   # Generate the string
-  source_file += "\n      def to_s\n"
-  source_file += "        '#{message[:name].upcase} > ' + self.payload.to_s\n"
-  source_file += "      end\n"
+  source_file += "\n        def to_s\n"
+  source_file += "          '#{message[:name].upcase} > ' + self.payload.to_s\n"
+  source_file += "        end\n"
 
 
-  source_file += "\n    end\n"
+  source_file += "\n      end\n"
 
   ###############################################
   # Test File
@@ -469,7 +470,7 @@ messages.each do |message|
     end
   end
 
-  class_name = "WampClient::Message::#{message[:name].capitalize}"
+  class_name = "Wamp::Client::Message::#{message[:name].capitalize}"
 
   test_file += "\n  describe #{class_name} do\n"
 
@@ -500,7 +501,7 @@ messages.each do |message|
   # Generate Global Parser Test
   test_file += "\n    it 'globally parses the message and creates an object' do\n"
   test_file += "      params = [#{message_type_lookup[message[:name].upcase]},#{value_array.join(',')}]\n"
-  test_file += "      object = WampClient::Message::Base.parse(params)\n\n"
+  test_file += "      object = Wamp::Client::Message::Base.parse(params)\n\n"
   params.each do |param|
     if param[:required]
       test_file += "      expect(object.#{param[:name]}).to eq(#{value_from_type(param[:type])})\n"