janus_gateway 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ef894fe4018704ac9bb29bda7b1d12add02ba10
+  data.tar.gz: ccbd4074640d1e190d16eaf56afcf13a0ad20813
+SHA512:
+  metadata.gz: 1606c18623b561ebd0f4b8b2e9363b0ddc350cd80fd845a8adf7424925874bfce6065cd1804779ecb09266d6bb0acecd81462faee865b686f0145e55e6db2582
+  data.tar.gz: e00f2f6f51b735d3aff9625d24e64603db06a4d64dbf95744c03760a22a079c345ad0b735a0a31a0316ad10ea7da084fa4c22b714885c23bae5f2e2412268dd9

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Cargo Media
+
+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.

data/README.md

@@ -0,0 +1,118 @@
+janus-gateway-ruby [![Build Status](https://travis-ci.org/cargomedia/janus-gateway-ruby.svg)](https://travis-ci.org/cargomedia/janus-gateway-ruby)
+==================
+Minimalistic [janus-gateway](https://github.com/meetecho/janus-gateway) client for ruby
+
+Installation
+------------
+```
+gem install janus_gateway
+```
+
+API coverage
+------------
+Current implementation support only a few of API features. For more details please follow official documentation of [REST API](https://janus.conf.meetecho.com/docs/rest.html)
+
+Library usage
+-------------
+
+Source code itself is well-documented so when writing code it should auto-complete and hint in all supported usages.
+
+### Client
+In order to make any request you need to instantiate client with correct transport layer (see transport section).
+
+```ruby
+ws = JanusGateway::Transport::WebSocket.new('ws://localhost:8188/janus')
+client = JanusGateway::Client.new(ws)
+```
+
+This client is used by all other classes connecting to api no matter if it's Resource or helper class like Agent.
+
+### Transports
+Client allows to use multiple, supported by Janus transportation layers. Currently the `WebSocket` transport is implemented and is the default.
+
+```ruby
+ws = JanusGateway::Transport::WebSocket.new('ws://localhost:8188/janus')
+```
+
+### Resources
+Each resource has built-in event emitter to handle basic behaviours like `create` and `destroy`. Additionally the creation of resources can be chained.
+There are two types of resources: Janus-API resource and Plugin-API (please see Plugin section).
+
+You can bind on events:
+```ruby
+session = JanusGateway::Resource::Session.new(client)
+
+session.on :create do
+  # do something
+end
+
+session.on :destroy do
+  # do something
+end
+
+session.create
+```
+
+Resource creation and destroying are asynchronous operations which return a `Concurrent::Promise`:
+```ruby
+session = JanusGateway::Resource::Session.new(client)
+
+session.create.then do |session|
+  # do something with success
+end.rescue do |error|
+  # do something with error
+end
+```
+
+#### Session
+Create new session:
+```ruby
+session = JanusGateway::Resource::Session.new(client)
+session.create
+```
+
+Destroy a session:
+```ruby
+session.destroy
+```
+
+#### Plugin
+Create new plugin:
+```ruby
+plugin = JanusGateway::Resource::Plugin.new(client, session, 'plugin-name')
+plugin.create
+```
+
+Destroy a plugin:
+```ruby
+plugin.destroy
+```
+
+### Plugins
+Janus support for native and custom [plugins](https://janus.conf.meetecho.com/docs/group__plugins.html).
+
+#### Rtpbrodcast plugin
+This is custom plugin for `RTP` streaming. Please find more details in official [repository](https://github.com/cargomedia/janus-gateway-rtpbroadcast).
+Plugin must be installed and active in `Janus` server.
+
+Plugin resource supports `events` and `chaining` in the same way like `Janus` resource.
+
+##### Mountpoint create
+Plugins allows to create `RTP` mountpoint.
+
+```ruby
+ws = JanusGateway::Transport::WebSocket.new('ws://localhost:8188/janus')
+client = JanusGateway::Client.new(ws)
+
+client.on :open do
+  JanusGateway::Resource::Session.new(client).create.then do |session|
+    JanusGateway::Plugin::Rtpbroadcast.new(client, session).create.then do |plugin|
+      JanusGateway::Plugin::Rtpbroadcast::Mountpoint.new(client, plugin, 'test-mountpoint').create.then do |mountpoint|
+        # do something with mountpoint
+      end
+    end
+  end
+end
+
+client.connect
+```

data/lib/janus_gateway.rb

@@ -0,0 +1,21 @@
+module JanusGateway
+
+  require 'json'
+  require 'events'
+  require 'concurrent'
+
+  require 'janus_gateway/client'
+  require 'janus_gateway/transport'
+  require 'janus_gateway/resource'
+  require 'janus_gateway/error'
+
+  require 'janus_gateway/resource/session'
+  require 'janus_gateway/resource/plugin'
+
+  require 'janus_gateway/transport/websocket'
+
+  require 'janus_gateway/plugin/rtpbroadcast'
+  require 'janus_gateway/plugin/rtpbroadcast/mountpoint'
+
+  require 'janus_gateway/version'
+end

data/lib/janus_gateway/client.rb

@@ -0,0 +1,38 @@
+module JanusGateway
+
+  class Client
+
+    attr_accessor :transport
+
+    # @param [JanusGateway::Transport]
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def connect
+      @transport.run
+    end
+
+    def disconnect
+      @transport.disconnect
+    end
+
+    # @param [Hash] data
+    # @return [Concurrent::Promise]
+    def send_transaction(data)
+      @transport.send_transaction(data)
+    end
+
+    # @return [TrueClass, FalseClass]
+    def is_connected?
+      @transport.is_connected?
+    end
+
+    # @param [Symbol, String] event
+    # @param [Proc] block
+    def on(event, &block)
+      @transport.on(event, &block)
+    end
+
+  end
+end

data/lib/janus_gateway/error.rb

@@ -0,0 +1,27 @@
+module JanusGateway
+
+  class Error < StandardError
+
+    # @param [Integer] error_code
+    # @param [String] error_info
+    def initialize(error_code, error_info)
+      @code, @info = error_code, error_info
+    end
+
+    # @return [String]
+    def message
+      "<Code: #{code}> <Info: #{info}>"
+    end
+
+    # @return [Integer]
+    def code
+      @code
+    end
+
+    # @return [String]
+    def info
+      @info
+    end
+
+  end
+end

data/lib/janus_gateway/plugin/rtpbroadcast.rb

@@ -0,0 +1,12 @@
+module JanusGateway::Plugin
+
+  class Rtpbroadcast < JanusGateway::Resource::Plugin
+
+    # @param [JanusGateway::Client] client
+    # @param [JanusGateway::Resource::Session] session
+    def initialize(client, session)
+      super(client, session, 'janus.plugin.cm.rtpbroadcast')
+    end
+
+  end
+end

data/lib/janus_gateway/plugin/rtpbroadcast/mountpoint.rb

@@ -0,0 +1,116 @@
+module JanusGateway::Plugin
+
+  class Rtpbroadcast::Mountpoint < JanusGateway::Resource
+
+    # @param [JanusGateway::Client] client
+    # @param [JanusGateway::Plugin::Rtpbroadcast] plugin
+    # @param [String] id
+    # @param [Array] streams
+    def initialize(client, plugin, id, streams = nil)
+      @plugin = plugin
+      @id = id
+      @data = nil
+
+      @streams = streams || [
+        {
+          :audio => 'yes',
+          :video => 'yes',
+          :audiopt => 111,
+          :audiortpmap => 'opus/48000/2',
+          :videopt => 100,
+          :videortpmap => 'VP8/90000'
+        }
+      ]
+
+      super(client)
+    end
+
+    # @return [Concurrent::Promise]
+    def create
+      promise = Concurrent::Promise.new
+
+      client.send_transaction(
+        {
+          :janus => 'message',
+          :session_id => plugin.session.id,
+          :handle_id => plugin.id,
+          :body => {
+            :request => 'create',
+            :id => id,
+            :name => id,
+            :description => id,
+            :recorded => true,
+            :streams => @streams
+          }
+        }
+      ).then do |data|
+        plugindata = data['plugindata']['data']
+        if plugindata['error_code'].nil?
+          _on_created(data)
+
+          promise.set(self).execute
+        else
+          error = JanusGateway::Error.new(plugindata['error_code'], plugindata['error'])
+
+          _on_error(error)
+
+          promise.fail(error).execute
+        end
+      end.rescue do |error|
+        promise.fail(error).execute
+      end
+
+      promise
+    end
+
+    # @return [Array<Hash>]
+    def streams
+      !data.nil? ? data['data']['stream']['streams'] : []
+    end
+
+    # @return [Concurrent::Promise]
+    def destroy
+      promise = Concurrent::Promise.new
+
+      _on_destroyed
+      promise.set(self).execute
+
+      promise
+    end
+
+    # @return [JanusGateway::Resource::Session]
+    def session
+      plugin.session
+    end
+
+    # @return [JanusGateway::Resource::Plugin]
+    def plugin
+      @plugin
+    end
+
+    # @return [Hash, NilClass]
+    def data
+      @data
+    end
+
+    private
+
+    def _on_error(error)
+      self.emit :error, error
+    end
+
+    def _on_created(data)
+      @data = data['plugindata']
+
+      plugin.on :destroy do
+        destroy
+      end
+
+      self.emit :create, @id
+    end
+
+    def _on_destroyed
+      self.emit :destroy, @id
+    end
+  end
+end

data/lib/janus_gateway/resource.rb

@@ -0,0 +1,37 @@
+module JanusGateway
+
+  class Resource
+
+    include Events::Emitter
+
+    attr_accessor :id
+
+    # @param [JanusGateway::Client] client
+    # @param [String] id
+    def initialize(client, id = nil)
+      @client = client
+      @id = id
+    end
+
+    # @return [String, NilClass]
+    def id
+      @id
+    end
+
+    # @return [JanusGateway::Client]
+    def client
+      @client
+    end
+
+    # @return [Concurrent::Promise]
+    def create
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    # @return [Concurrent::Promise]
+    def destroy
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+  end
+end

data/lib/janus_gateway/resource/plugin.rb

@@ -0,0 +1,72 @@
+module JanusGateway
+
+  class Resource::Plugin < Resource
+
+    # @param [JanusGateway::Client] client
+    # @param [JanusGateway::Resource::Session] session
+    # @param [String] plugin_name
+    def initialize(client, session, plugin_name)
+      @session = session
+      @name = plugin_name
+
+      super(client)
+    end
+
+    # @return [String]
+    def name
+      @name
+    end
+
+    # @return [Concurrent::Promise]
+    def create
+      promise = Concurrent::Promise.new
+
+      client.send_transaction(
+        {
+          :janus => 'attach',
+          :plugin => name,
+          :session_id => @session.id
+        }
+      ).then do |*args|
+        _on_created(*args)
+
+        promise.set(self).execute
+      end.rescue do |error|
+        promise.fail(error).execute
+      end
+
+      promise
+    end
+
+    def destroy
+      promise = Concurrent::Promise.new
+
+      _on_destroyed
+      promise.set(self).execute
+
+      promise
+    end
+
+    # @return [JanusGateway::Resource::Session]
+    def session
+      @session
+    end
+
+    private
+
+    def _on_created(data)
+      @id = data['data']['id']
+
+      session.on :destroy do |data|
+        destroy
+      end
+
+      self.emit :create, @id
+    end
+
+    def _on_destroyed
+      self.emit :destroy, @id
+    end
+
+  end
+end

data/lib/janus_gateway/resource/session.rb

@@ -0,0 +1,103 @@
+module JanusGateway
+
+  class Resource::Session < Resource
+
+    # @param [JanusGateway::Client] client
+    def initialize(client)
+      @heartbeat_thread = nil
+
+      super
+    end
+
+    # @return [Concurrent::Promise]
+    def create
+      promise = Concurrent::Promise.new
+
+      client.send_transaction(
+        {
+          :janus => 'create'
+        }
+      ).then do |*args|
+        _on_created(*args)
+        heartbeat
+
+        promise.set(self).execute
+      end.rescue do |error|
+        promise.fail(error).execute
+      end
+
+      promise
+    end
+
+    # @return [Concurrent::Promise]
+    def destroy
+      promise = Concurrent::Promise.new
+
+      client.send_transaction(
+        {
+          :janus => 'destroy',
+          :session_id => @id
+        }
+      ).then do |*args|
+        _on_destroyed
+
+        promise.set(self).execute
+      end.rescue do |error|
+        promise.fail(error).execute
+      end
+
+      promise
+    end
+
+    # @return [Thread]
+    def heartbeat
+      @heartbeat_thread.exit unless @heartbeat_thread.nil?
+
+      @heartbeat_thread = Thread.new do
+        sleep_time = 5
+        while true do
+          sleep(sleep_time)
+          client.send_transaction(
+            {
+              :janus => 'keepalive',
+              :session_id => @id
+            }
+          ).then do |*args|
+            sleep_time = 30
+          end.rescue do |error|
+            sleep_time = 1
+          end
+        end
+      end
+    end
+
+    private
+
+    # @param [Hash] data
+    def _on_created(data)
+      @id = data['data']['id']
+
+      client.on :message do |data|
+        if data['janus'] == 'timeout' and data['session_id'] == @id
+          send(:_on_destroyed)
+        end
+      end
+
+      client.on :close do
+        self.emit :destroy
+      end
+
+      client.on :error do
+        self.emit :destroy
+      end
+
+      self.emit :create
+    end
+
+    def _on_destroyed
+      @heartbeat_thread.exit unless @heartbeat_thread.nil?
+      self.emit :destroy
+    end
+
+  end
+end

data/lib/janus_gateway/transport.rb

@@ -0,0 +1,45 @@
+module JanusGateway
+
+  class Transport
+
+    include Events::Emitter
+
+    def run
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    def connect
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    def disconnect
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    # @param [Hash] data
+    def send(data)
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    # @param [Hash] data
+    # @return [Concurrent::Promise]
+    def send_transaction(data)
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    # @return [TrueClass, FalseClass]
+    def is_connected?
+      raise("`#{__method__}` is not implemented for `#{self.class.name}`")
+    end
+
+    # @return [String]
+    def transaction_id_new
+      transaction_id = ''
+      24.times do
+        transaction_id << (65 + rand(25)).chr
+      end
+      transaction_id
+    end
+
+  end
+end

data/lib/janus_gateway/transport/websocket.rb

@@ -0,0 +1,122 @@
+require 'eventmachine'
+require 'faye/websocket'
+
+module JanusGateway
+
+  class Transport::WebSocket < Transport
+
+    attr_reader :transaction_queue
+
+    # @param [String] url
+    # @param [String] protocol
+    def initialize(url, protocol = 'janus-protocol')
+      @url = url
+      @protocol = protocol
+      @client = nil
+      @transaction_queue = Hash.new
+    end
+
+    def run
+      EventMachine.run do
+        EM.error_handler { |e| raise(e) }
+        connect
+      end
+    end
+
+    def connect
+      raise('WebSocket client already exists!') unless @client.nil?
+
+      @client = _create_client(@url, @protocol)
+
+      client.on :open do
+        self.emit :open
+      end
+
+      client.on :message do |event|
+        data = JSON.parse(event.data)
+
+        transaction_list = @transaction_queue.clone
+
+        transaction_id = data['transaction']
+        unless transaction_id.nil?
+          promise = transaction_list[transaction_id]
+          unless promise.nil?
+            if ['success', 'ack'].include?(data['janus'])
+              promise.set(data).execute
+            else
+              error_data = data['error']
+              error = JanusGateway::Error.new(error_data['code'], error_data['reason'])
+              promise.fail(error).execute
+            end
+          end
+        end
+
+        self.emit :message, data
+      end
+
+      client.on :close do
+        self.emit :close
+      end
+    end
+
+    # @param [Hash] data
+    def send(data)
+      client.send(JSON.generate(data))
+    end
+
+    # @param [Hash] data
+    # @return [Concurrent::Promise]
+    def send_transaction(data)
+      promise = Concurrent::Promise.new
+      transaction = transaction_id_new
+
+      data[:transaction] = transaction
+      send(data)
+
+      @transaction_queue[transaction] = promise
+
+      thread = Thread.new do
+        sleep(_transaction_timeout)
+        error = JanusGateway::Error.new(0, "Transaction id `#{transaction}` has failed due to timeout!")
+        promise.fail(error).execute
+        @transaction_queue.remove(transaction)
+      end
+
+      promise.then { thread.exit }
+      promise.rescue { thread.exit }
+
+      promise
+    end
+
+    def disconnect
+      client.close unless client.nil?
+      EventMachine.stop if EventMachine.reactor_running?
+    end
+
+    # @return [TrueClass, FalseClass]
+    def is_connected?
+      !client.nil? and (client.ready_state == Faye::WebSocket::API::OPEN)
+    end
+
+    # @return [Faye::WebSocket::Client, NilClass]
+    def client
+      @client
+    end
+
+    private
+
+    # @param [String] url
+    # @param [String] protocol
+    # @return [Faye::WebSocket::Client]
+    def _create_client(url, protocol)
+      Faye::WebSocket::Client.new(url, protocol)
+    end
+
+    # @return [Float, Integer]
+    def _transaction_timeout
+      30
+    end
+
+  end
+
+end

data/lib/janus_gateway/version.rb

@@ -0,0 +1,3 @@
+module JanusGateway
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: janus_gateway
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cargo Media
+- kris-lab
+- tomaszdurka
+- njam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.8
+- !ruby/object:Gem::Dependency
+  name: events
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: janus-gateway API client
+email: tech@cargomedia.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/janus_gateway.rb
+- lib/janus_gateway/client.rb
+- lib/janus_gateway/error.rb
+- lib/janus_gateway/plugin/rtpbroadcast.rb
+- lib/janus_gateway/plugin/rtpbroadcast/mountpoint.rb
+- lib/janus_gateway/resource.rb
+- lib/janus_gateway/resource/plugin.rb
+- lib/janus_gateway/resource/session.rb
+- lib/janus_gateway/transport.rb
+- lib/janus_gateway/transport/websocket.rb
+- lib/janus_gateway/version.rb
+homepage: https://github.com/cargomedia/janus-gateway-ruby
+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.5.0
+signing_key: 
+specification_version: 4
+summary: janus-gateway client
+test_files: []