rocket_chat-realtime 0.1.0

data/README.md

@@ -0,0 +1,40 @@
+# RocketChat::Realtime
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rocket_chat/realtime`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rocket_chat-realtime'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rocket_chat-realtime
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rocket_chat-realtime. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rocket_chat-realtime/blob/master/CODE_OF_CONDUCT.md).
+
+
+## Code of Conduct
+
+Everyone interacting in the RocketChat::Realtime project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rocket_chat-realtime/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'rocket_chat/realtime'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rocket_chat/realtime.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'rocket_chat/realtime/version'
+require 'rocket_chat/realtime/message'
+require 'rocket_chat/realtime/reactor'
+require 'rocket_chat/realtime/connector'
+require 'rocket_chat/realtime/adapter'
+require 'rocket_chat/realtime/dispatcher'
+require 'rocket_chat/realtime/async_task'
+require 'rocket_chat/realtime/event_emitter'
+require 'rocket_chat/realtime/client'
+
+module RocketChat
+  # RocketChat Realtiem API
+  #
+  # The Realtime API is depend on Metero.js DDP
+  # https://github.com/meteor/meteor/blob/devel/packages/ddp/DDP.md
+  #
+  # @since 0.1.0
+  module Realtime
+    module_function
+
+    # Logger
+    #
+    # @return [Logger]
+    #
+    # @since 0.1.0
+    def logger
+      @logger ||=
+        Logger.new(STDERR, progname: name, level: Logger::ERROR)
+    end
+
+    # Set logger
+    #
+    # @param logger [Logger]
+    #
+    # @since 0.1.0
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # Connect to RocketChat
+    #
+    # @param options [Hash] connection options
+    #
+    # @return [RocketChat::Realtime::Client]
+    #
+    # @since 0.1.0
+    def connect(options = {})
+      client = Client.new(options)
+      client.connect
+      Reactor.run
+      client
+    end
+  end
+end

data/lib/rocket_chat/realtime/adapter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RocketChat
+  module Realtime
+    # Socket Adapter for WebSocket::Driver
+    #
+    # @since 0.1.0
+    class Adapter
+      # @since 0.1.0
+      attr_reader :url
+
+      # @param url [String] the server to connect
+      #
+      # @since 0.1.0
+      def initialize(url)
+        @url = url
+        @mutex = Mutex.new
+        @buffer = ''
+      end
+
+      # Enqueue data to send to server
+      #
+      # @param data [String]
+      #
+      # @since 0.1.0
+      def write(data)
+        @mutex.synchronize { @buffer = @buffer.dup.concat(data) }
+      end
+
+      # Pump Buffer
+      #
+      # @param io [IO] the data write to
+      #
+      # @return [Number] total bytes written
+      #
+      # @since 0.1.0
+      def pump_buffer(io)
+        @mutex.synchronize do
+          written = 0
+          begin
+            written = io.write_nonblock @buffer unless @buffer.empty?
+            @buffer = @buffer.byteslice(written..-1) if written.positive?
+          rescue IO::WaitWritable, IO::WaitReadable
+            return written
+          end
+          written
+        end
+      end
+    end
+  end
+end

data/lib/rocket_chat/realtime/async_task.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'forwardable'
+
+require 'concurrent'
+
+module RocketChat
+  module Realtime
+    # AsyncTask resolver
+    #
+    # @since 0.1.0
+    class AsyncTask
+      class << self
+        extend Forwardable
+
+        delegate %w[start resolve] => :instance
+      end
+
+      include Singleton
+      include Concurrent::Promises::FactoryMethods
+
+      # @since 0.1.0
+      TASK_TIMEOUT = 60
+
+      # @since 0.1.0
+      def initialize
+        @tasks = Concurrent::Map.new
+      end
+
+      # Register a new task
+      #
+      # @param id [String] task id
+      # @param block [Proc] async taks to execute
+      #
+      # @return [Concurrent::Promises::ResolvableFuture]
+      #
+      # @since 0.1.0
+      def start(id)
+        # TODO: check for atomic
+        yield if block_given?
+        Concurrent::ScheduledTask.execute(TASK_TIMEOUT) { @tasks.delete(id)&.reject(:timeout) }
+        @tasks.fetch_or_store(id, resolvable_future)
+      end
+
+      # Resolve task
+      #
+      # @param result [RocketChat::Realtime::ReslutMessage]
+      #
+      # @return [Concurrent::Promises::ResolvableFuture]
+      #
+      # @since 0.1.0
+      def resolve(id, result = nil)
+        task = @tasks.delete(id)
+        task&.resolve true, result
+        task
+      end
+    end
+  end
+end

data/lib/rocket_chat/realtime/client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'json'
+
+require 'websocket/driver'
+
+require 'rocket_chat/realtime/methods/auth'
+require 'rocket_chat/realtime/methods/message'
+require 'rocket_chat/realtime/subscriptions/room'
+
+module RocketChat
+  module Realtime
+    # Rocket.Chat Reamtime API
+    #
+    # @since 0.1.0
+    class Client
+      extend Forwardable
+
+      include EventEmitter
+      include Methods::Auth
+      include Methods::Message
+      include Subscriptions::Room
+
+      # @since 0.1.0
+      INITIALIZE_COMMAND = {
+        msg: :connect,
+        version: '1',
+        support: ['1']
+      }.freeze
+
+      # @since 0.1.0
+      delegate %w[ping pong] => :driver
+
+      # @since 0.1.0
+      attr_reader :server, :connector, :adapter, :driver
+
+      # @param options [Hash]
+      #
+      # @since 0.1.0
+      def initialize(options = {})
+        @server = options[:server]
+        @connector = Connector.new(endpoint)
+        @adapter = Adapter.new(endpoint)
+        @driver = WebSocket::Driver.client(adapter)
+        @dispatcher = Dispatcher.new(self)
+      end
+
+      # @return [String] the realtime api endpoint
+      #
+      # @since 0.1.0
+      def endpoint
+        "#{server}/websocket"
+      end
+
+      # Connect to server
+      #
+      # @since 0.1.0
+      def connect
+        driver.start
+        driver.text(INITIALIZE_COMMAND.to_json)
+        Reactor.register(self)
+      end
+
+      # Close connection to server
+      #
+      # @since 0.1.0
+      def disconnect
+        @dispatcher.dispose
+        driver.close
+        Reactor.deregister(self)
+      end
+
+      # WebSocket is opened
+      #
+      # @return [Boolean] open or not
+      #
+      # @since 0.1.0
+      def opened?
+        driver.state == :open
+      end
+
+      # Process I/O
+      #
+      # @param monitor [NIO::Monitor]
+      #
+      # @since 0.1.0
+      def process(monitor)
+        driver.parse(monitor.io.read_nonblock(2**14)) if monitor.readable?
+        adapter.pump_buffer(monitor.io) if monitor.writeable?
+      rescue IO::WaitReadable, IO::WaitWritable
+        # nope
+      rescue Errno::ECONNRESET, EOFError, Errno::ECONNABORTED
+        RocketChat::Realtime.logger.warn('Remote server is closed.')
+        monitor.close
+        disconnect
+      end
+    end
+  end
+end

data/lib/rocket_chat/realtime/connector.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'openssl'
+require 'forwardable'
+
+module RocketChat
+  module Realtime
+    # Socket manager
+    #
+    # @since 0.1.0
+    class Connector
+      extend Forwardable
+
+      delegate %w[hostname] => :uri
+
+      # @since 0.1.0
+      attr_reader :uri
+
+      # @param url [String] the websocket server to connect
+      #
+      # @since 0.1.0
+      def initialize(url)
+        @uri = URI(url)
+      end
+
+      # Connect to server
+      #
+      # @return [Socket] the socket
+      def connect
+        return @socket if @socket
+        return raw_socket unless ssl?
+
+        ssl_socket
+      end
+
+      alias socket connect
+
+      # Check the SSL enabled
+      #
+      # @return [Boolean] is enabled
+      #
+      # @since 0.1.0
+      def ssl?
+        @uri.scheme == 'wss'
+      end
+
+      # The port to connect
+      #
+      # @return [Number] the port
+      #
+      # @since 0.1.0
+      def port
+        @uri.port || (ssl? ? 443 : 80)
+      end
+
+      protected
+
+      # @return [Socket] the raw tcp socket
+      def raw_socket
+        @socket = TCPSocket.new hostname, port
+      end
+
+      # @return [OpenSSL::SSL::SSLSocket] the ssl socket
+      def ssl_socket
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths
+
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        ctx.cert_store = store
+
+        @socket = OpenSSL::SSL::SSLSocket.new(raw_socket, ctx)
+        @socket.hostname = @uri.hostname
+        @socket.connect
+      end
+    end
+  end
+end

data/lib/rocket_chat/realtime/dispatcher.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'forwardable'
+
+# RPC
+require 'rocket_chat/realtime/handlers/result'
+
+# Subscription
+require 'rocket_chat/realtime/handlers/ready'
+require 'rocket_chat/realtime/handlers/changed'
+
+module RocketChat
+  module Realtime
+    # Message Dispatcher
+    #
+    # @since 0.1.0
+    class Dispatcher
+      extend Forwardable
+
+      # @since 0.1.0
+      HANDLERS = {
+        # Heartbeat
+        'ping' => ->(dispatcher, _) { dispatcher.driver.text({ 'msg': 'pong' }.to_json) },
+        # RPC
+        'result' => Handlers::Result,
+        # Subscription
+        'ready' => Handlers::Ready,
+        'changed' => Handlers::Changed
+      }.freeze
+
+      # @since 0.1.0
+      delegate %w[logger] => RocketChat::Realtime
+
+      # @since 0.1.0
+      delegate %w[driver] => :client
+
+      # @since 0.1.0
+      attr_reader :client
+
+      # @param driver [WebSocket::Driver::Client]
+      #
+      # @since 0.1.0
+      def initialize(client)
+        @client = client
+
+        driver.on(:message, &method(:dispatch))
+      end
+
+      # Dispatch messages
+      #
+      # @param event [WebSocket::Driver::MessageEvent]
+      #
+      # @return [Boolean] is dispatched
+      #
+      # @since 0.1.0
+      def dispatch(event)
+        message = JSON.parse(event.data)
+        handler = HANDLERS[message.fetch('msg', nil)]
+        if handler
+          handler.call(self, message)
+        else
+          logger.debug("No handler found for: #{message}")
+          false
+        end
+      rescue JSON::ParserError
+        # nope
+      end
+
+      # Dispose
+      #
+      # Clear references
+      #
+      # @since 0.1.0
+      def dispose
+        @client = nil
+      end
+    end
+  end
+end