tightrope 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 15a7366d3564b2186c12e87fd4b1f23c3fb92f288ea868e3d39cb21d97a41874
+  data.tar.gz: 219c19c58e24e601c4754cfdb782133156bbe947808612bc4a7eb9f5c0a13be9
+SHA512:
+  metadata.gz: e70a010a40b5c1d1bdb0a0c66487acd72b650724a144e1dc32f71405a9c698f6bc8bdabebe6eab3b4101dfd12bc5dc7a08e47cc0a96ba3eb126d48981d263158
+  data.tar.gz: 420fbb1d5d74e583a9169b6d33e5ddcdd36f5b255feef928b76b2368c4dbe7ca7d5c8b874449eea93b1ea9ab7c033a860e4fbbe3cbe3cc234ae792a2b1907917

data/lib/tightrope.rb

@@ -0,0 +1,7 @@
+require "websocket-eventmachine-client"
+
+require_relative 'tightrope/version'
+require_relative 'tightrope/errors'
+require_relative 'tightrope/websocket/filter_client'
+require_relative 'tightrope/websocket/action_cable_client'
+require_relative 'tightrope/websocket/action_cable_auth_client'

data/lib/tightrope/errors.rb

@@ -0,0 +1,12 @@
+module Tightrope
+  ERROR_OK                         = 0
+  ERROR_PARAM_CHANNEL_MISSING      = 1
+  ERROR_PARAM_MESSAGE_MISSING      = 2
+  ERROR_PARAM_ACTION_MISSING       = 3
+  ERROR_CHANNEL_ALREADY_SUBSCRIBED = 4
+  ERROR_CLIENT_HAS_NOTSUBSCRIBED   = 5
+  ERROR_PARAM_CHANNEL_NOT_UNIQUE   = 6
+
+  class LoginError < Exception
+  end
+end

data/lib/tightrope/version.rb

@@ -0,0 +1,3 @@
+module Tightrope
+  VERSION = "0.1.1"
+end

data/lib/tightrope/websocket/action_cable_auth_client.rb

@@ -0,0 +1,50 @@
+require 'http'
+
+module Tightrope
+  module WebSocket
+    class ActionCableAuthClient < ::Tightrope::WebSocket::ActionCableClient
+      def self.connect(args)
+        local_args = prepare_args(args)
+        uri = URI.parse(local_args[:uri])
+
+        host = uri.host
+        port = uri.port
+
+        if args[:auth_uri]
+          auth_uri = URI.parse(local_args[:auth_uri])
+          host = auth_uri.host
+          port = auth_uri.port
+          local_args[:ssl] = true if auth_uri.scheme == 'https'
+        else
+          auth_path = local_args[:auth_path].sub(/^\//, '') if local_args[:auth_path]
+          local_args[:auth_uri] = (args[:ssl] ? 'https' : 'http') + "://#{host}"
+          local_args[:auth_uri] << ":#{port}" if port
+          local_args[:auth_uri] << "/#{auth_path}" if auth_path
+        end
+
+        local_args.delete(:auth_path)
+
+        check_arg(local_args, :user)
+        check_arg(local_args, :password)
+        local_args[:headers] = login(local_args)
+
+        super(local_args)
+      end
+
+      def self.login(args)
+        res = HTTP.post(args[:auth_uri], json: {email: args[:user], password: args[:password]})
+        raise Tightrope::LoginError.new("Login failed for user #{args[:user]}") if res.code != 200
+
+        {'access-token' => res.headers['access-token'],
+         'expiry'       => res.headers['expiry'],
+         'uid'          => res.headers['uid'],
+         'client'       => res.headers['client'],
+         'token-type'   => 'Bearer'}
+      end
+
+      def self.check_arg(args, key)
+        raise ArgumentError.new("Argument ':#{key.to_s}' is missing") unless args[key]
+      end
+    end
+  end
+end

data/lib/tightrope/websocket/action_cable_client.rb

@@ -0,0 +1,148 @@
+require 'cgi'
+require 'json'
+
+module Tightrope
+  module WebSocket
+    class ActionCableClient < Tightrope::WebSocket::FilterClient
+      attr_reader :channel
+
+      def initialize(args)
+        @channel = args[:channel] if args[:channel]
+        @channel_subscribed = false
+        super(args)
+      end
+
+      def channel_subscribed?
+        @channel_subscribed
+      end
+
+      # Connect to an ActionCable websocket server
+      # @param args [Hash] The request arguments
+      # @option args [String] :host The host IP/DNS name
+      # @option args [Integer] :port The port to connect too(default = 80)
+      # @option args [String] :uri Full URI for server(optional - use instead of host/port combination)
+      # @option args [Integer] :version Version of protocol to use(default = 13)
+      # @option args [Hash] :headers HTTP headers to use in the handshake
+      # @option args [Boolean] :ssl Force SSL/TLS connection
+      def self.connect(args = {})
+        super(prepare_args(args))
+      end
+
+      def self.prepare_args(args = {})
+        host = nil
+        port = nil
+        cable_path = nil
+        query = nil
+
+        if args[:uri]
+          uri = URI.parse(args[:uri])
+          host = uri.host
+          port = uri.port
+          args[:ssl] = true if uri.scheme == 'wss'
+        else
+          host = args[:host] if args[:host]
+          port = args[:port] if args[:port]
+          cable_path = args[:cable_path].sub(/^\//, '') if args[:cable_path]
+
+          args[:uri] = (args[:ssl] ? 'wss' : 'ws') + '://' + host
+          args[:uri] << ":#{port}" if port
+          args[:uri] << "/#{cable_path}" if cable_path
+          if args[:query]
+            args[:uri] << '?'
+            args[:query].each {|k,v| args[:uri] << ::CGI::escape(k.to_s) + '=' + ::CGI::escape(v.to_s) + '&'}
+            args[:uri].sub!(/&$/, '')
+          end
+
+          [:host, :port, :cable_path, :query].each {|k| args.delete(k) }
+        end
+
+        args
+      end
+
+      def subscribe_to_channel(channel = nil, options = {})
+        if channel_subscribed?
+          error(__method__, Tightrope::ERROR_CHANNEL_ALREADY_SUBSCRIBED)
+          return false
+        end
+
+        if @channel.nil? && channel.nil?
+          error(__method__, Tightrope::ERROR_PARAM_CHANNEL_MISSING)
+          return false
+        end
+
+        if @channel && channel && @channel != channel
+          error(__method__, Tightrope::ERROR_PARAM_CHANNEL_NOT_UNIQUE)
+          return false
+        end
+
+        @channel = channel if @channel.nil? && channel
+
+        send_message(command: 'subscribe', channel: @channel, opts: options)
+      end
+
+      def send_message(options = {})
+        channel = options[:channel]
+        unless channel
+          error(__method__, Tightrope::ERROR_PARAM_CHANNEL_MISSING)
+          return false
+        end
+
+        identifier = {channel: channel}
+        identifier.merge!(options[:opts]) if options[:opts]
+        msg = {command: options[:command] || 'message', identifier: identifier.to_json}
+
+        if options[:message] || options[:action]
+          unless options[:message]
+            error(__method__, Tightrope::ERROR_PARAM_MESSAGE_MISSING)
+            return false
+          end
+          unless options[:action]
+            error(__method__, Tightrope::ERROR_PARAM_ACTION_MISSING)
+            return false
+          end
+          msg[:data] = {message: options[:message], action: options[:action]}.to_json
+        end
+
+        send(msg.to_json, type: options['type'] || 'text')
+      end
+
+      def send_to_channel(options = {})
+        unless channel_subscribed?
+          error(__method__, Tightrope::ERROR_CLIENT_HAS_NOTSUBSCRIBED)
+          return false
+        end
+
+        send_message(options.merge(channel: @channel))
+      end
+
+      def trigger_onsubscription(channel)
+        @onsubscription.call(channel) if @onsubscription
+      end
+
+      #
+      # is called when the subscription confirmation is sent
+      #
+      def onsubscription(&blk)
+        @onsubscription = blk
+      end
+
+      #
+      # triggers event 'onsubscribtion' when subscription confirmation is sent
+      #
+      def filter_text(frame)
+        unless channel_subscribed?
+          confirmation = JSON.parse(frame.to_s)
+          if confirmation['type'] == 'confirm_subscription'
+            identifier = JSON.parse(confirmation['identifier'])
+            @channel_subscribed = @channel && identifier['channel'] == @channel
+            trigger_onsubscription(identifier['channel']) if @channel_subscribed
+            return @channel_subscribed
+          end
+        end
+        false
+      end
+
+    end
+  end # ActionCableClient
+
+end

data/lib/tightrope/websocket/filter_client.rb

@@ -0,0 +1,87 @@
+require 'json'
+
+module Tightrope
+  module WebSocket
+    # https://tools.ietf.org/html/rfc6455
+
+    class FilterClient < ::WebSocket::EventMachine::Client
+      #
+      # Websocket client for filtering frames send by websocket events.
+      # You can customize the methods
+      #    filter_text, filter_binary, filter_ping, filter_pong and filter_close
+      #
+      def initialize(args)
+        create_methods
+        super(args)
+      end
+
+      [:text, :binary, :ping, :pong, :close].each do |type|
+        define_method("filter_#{type.to_s}") { |arg| false }
+      end
+
+      def args
+        instance_variable_get("@args")
+      end
+
+      def error(method, code, message = '')
+        e = {method: method, code: code}
+        e[:message] = message if message && message != ''
+        trigger_onerror(e.to_json)
+      end
+
+      private
+
+      def create_method(name, &block)
+        self.class.send(:define_method, name, &block)
+      end
+
+      def create_methods
+        [:onopen, :onping, :onpong, :onerror, :onmessage, :onclose].each do |event|
+          create_method("trigger_#{event}".to_sym) do |data,type=nil|
+            ivar = instance_variable_get("@#{event}")
+            ivar.call(data,type) if ivar
+          end
+        end
+
+        create_method(:handle_open) do |data|
+          frame_super = instance_variable_get("@frame")
+          frame_super << data
+          instance_variable_set("@frame", frame_super)
+          while frame = frame_super.next
+            state = instance_variable_get("@state")
+            if state == :open
+              case frame.type
+              when :close
+                state = :closing
+                instance_variable_set("@state", :closing)
+                close
+                trigger_onclose(frame.code, frame.data) unless filter_close(frame)
+              when :ping
+                pong(frame.to_s)
+                trigger_onping(frame.to_s) unless filter_ping(frame)
+              when :pong
+                trigger_onpong(frame.to_s) unless filter_pong(frame)
+              when :text
+                trigger_onmessage(frame.to_s, :text) unless filter_text(frame)
+              when :binary
+                trigger_onmessage(frame.to_s, :binary) unless filter_binary(frame)
+              end
+            else
+              break
+            end
+          end
+
+          if frame_super.error?
+            error_code = case error
+              when :invalid_payload_encoding then 1007
+              else 1002
+            end
+            trigger_onerror(error.to_s)
+            close(error_code)
+            unbind
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: tightrope
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Andreas Leipelt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  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'
+description: tigthrope
+email:
+- andreas@leipelt-hamburg.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tightrope.rb
+- lib/tightrope/errors.rb
+- lib/tightrope/version.rb
+- lib/tightrope/websocket/action_cable_auth_client.rb
+- lib/tightrope/websocket/action_cable_client.rb
+- lib/tightrope/websocket/filter_client.rb
+homepage: https://github.com/briareos62/tightrope
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Rails ActionCable client library for use in non browser clients. Based on
+  Eventmachine.
+test_files: []