p2p_streams_channel 0.0.2

data/app/assets/javascripts/p2p/p2p_peer.js

@@ -0,0 +1,208 @@
+import { ConnectionState, MessageType } from "p2p/message"
+import P2pConnection from "p2p/p2p_connection"
+
+export default class P2pPeer {
+    constructor(sessionId, peerId, container, signaling, iceConfig, heartbeatConfig) {
+        this.sessionId = sessionId
+        this.container = container
+        this.signaling = signaling
+        this.iceConfig = iceConfig
+        this.heartbeatConfig = heartbeatConfig
+        this.peerId = peerId
+        this.hostPeerId = null
+        this.iamHost = false
+        this.state = null
+    }
+
+    setup() {
+        this.connections = new Map()
+        this.signal(ConnectionState.SessionJoin, {})
+        this.dispatchP2pConnectionState({state: ConnectionState.Negotiating})
+    }
+
+    signal(state, data) {
+        let msg = {
+            "type": MessageType.Connection,
+            "session_id": this.sessionId,
+            "peer_id": this.peerId,
+            "state": state,
+            ...data
+        }
+        this.signaling.send(msg)
+    }
+
+    negotiate(msg) {
+        switch (msg.state) {
+            case ConnectionState.SessionJoin:
+                break
+            case ConnectionState.SessionReady:
+                if (msg.host_peer_id == this.peerId) { // iam host
+                    this.iamHost = true
+                    this.hostPeerId = this.peerId
+                    if (msg.peer_id == this.peerId) {
+                        this.updateP2pConnectionState()
+                        return
+                    }
+
+                    const connection = new P2pConnection(this, msg.peer_id, this.peerId, this.iamHost, this.iceConfig, this.heartbeatConfig)
+                    this.connections.set(msg.peer_id, connection)
+
+                    const rtcPeerConnection = connection.setupRTCPeerConnection()
+                    if (!rtcPeerConnection) {
+                        // TODO: failed case
+                        return
+                    }
+                    rtcPeerConnection.createOffer()
+                        .then(offer => {
+                            return rtcPeerConnection.setLocalDescription(offer)
+                        })
+                        .then(() => {
+                            let offer = {"host_peer_id": msg.host_peer_id}
+                            offer[ConnectionState.SdpOffer] = JSON.stringify(rtcPeerConnection.localDescription)
+                            this.signal(ConnectionState.SdpOffer, offer)
+                        })
+                        .catch(err => console.log(err))
+                }
+
+                this.state = ConnectionState.SessionReady
+
+                break
+            case ConnectionState.SdpOffer:
+                if (msg.host_peer_id != this.peerId && this.state != ConnectionState.SdpOffer) { // iam not host
+                    this.hostPeerId = msg.host_peer_id
+                    const connection = new P2pConnection(this, this.peerId, msg.host_peer_id, this.iamHost, this.iceConfig, this.heartbeatConfig)
+                    this.connections.set(this.peerId, connection)
+                    
+                    const rtcPeerConnection = connection.setupRTCPeerConnection()
+
+                    let offer = JSON.parse(msg[ConnectionState.SdpOffer])
+                    // console.log(`${this.peerId} get Offer`)
+                    // console.log(offer)
+                    rtcPeerConnection.setRemoteDescription(new RTCSessionDescription(offer))
+                        .then(() => {
+                            rtcPeerConnection.createAnswer()
+                                .then(answer => {
+                                    return rtcPeerConnection.setLocalDescription(answer)
+                                })
+                                .then(() => {
+                                    let answer = {"host_peer_id": msg.host_peer_id}
+                                    answer[ConnectionState.SdpAnswer] = JSON.stringify(rtcPeerConnection.localDescription)
+                                    this.signal(ConnectionState.SdpAnswer, answer)
+                                })
+                                .catch(err => console.log(err))
+                        })
+                }
+                break
+            case ConnectionState.SdpAnswer:
+                if (msg.host_peer_id == this.peerId) { // iam host
+                    // console.log(` ${this.peerId} get Answer`)
+                    const clientConnection = this.connections.get(msg.peer_id)
+                    if (!clientConnection) return;
+
+                    const rtcPeerConnection = clientConnection.rtcPeerConnection
+                    let answer = JSON.parse(msg[ConnectionState.SdpAnswer])
+                    
+                    rtcPeerConnection.setRemoteDescription(new RTCSessionDescription(answer))
+                        .catch(err => console.log(err))
+                }
+                break
+            case ConnectionState.IceCandidate:
+                if (msg[ConnectionState.IceCandidate]) {
+                    this.connections.forEach((connection, peerId) => {
+                        connection.rtcPeerConnection.addIceCandidate(new RTCIceCandidate(msg[ConnectionState.IceCandidate]))
+                            .catch(err => console.log(err))
+                    })
+                }
+                break
+            case ConnectionState.Error:
+                // console.log("Connection Error")
+                break
+            default:
+                break
+        }
+    }
+
+    dispatchP2pMessage(message, type, senderId) {
+        this.connections.forEach((connection, peerId) => {
+            connection.sendP2pMessage(message, type, senderId)
+        })
+    }
+    
+    sendP2pMessage(message) {
+        if (this.iamHost) {
+            this.container.dispatchP2pMessage({
+                type: MessageType.Data,
+                senderId: this.peerId,
+                data: message
+            })
+        }
+
+        this.connections.forEach((connection, peerId) => {
+            connection.sendP2pMessage(message, MessageType.Data, this.peerId)
+        })
+    }
+
+    receivedP2pMessage(message) {
+        switch (message.type) {
+            case MessageType.Data:
+            case MessageType.DataConnectionState:
+                if (this.iamHost) {
+                    //broadcast to all connections
+                    this.dispatchP2pMessage(message.data, message.type, message.senderId)
+                }
+                
+                // dispatch msg to all sub views
+                this.container.dispatchP2pMessage(message)
+                break
+            default:
+                break
+        }
+    }
+
+    updateP2pConnectionState(connection = null) {
+        if (this.iamHost) {
+            this.connectionStatus ||= {}
+            this.connections.forEach((connection, peerId) => {
+                this.connectionStatus[peerId] = connection.state
+            })
+            this.connectionStatus[this.hostPeerId] = ConnectionState.Connected
+
+            this.container.dispatchP2pMessage({
+                type: MessageType.DataConnectionState,
+                senderId: this.peerId,
+                data: this.connectionStatus
+            })
+
+            this.dispatchP2pMessage(this.connectionStatus, MessageType.DataConnectionState, this.hostPeerId)
+        }
+
+        if (connection) {
+            this.dispatchP2pConnectionState(connection)
+        }
+    }
+
+    dispatchP2pConnectionState(connection) {
+        switch (connection.state) {
+            case ConnectionState.Negotiating:
+                this.container.p2pNegotiating()
+                break
+            case ConnectionState.Connecting:
+                this.container.p2pConnecting()
+                break
+            case ConnectionState.Connected:
+                this.container.p2pConnected()
+                break
+            case ConnectionState.DisConnected:
+                this.container.p2pDisconnected()
+                break
+            case ConnectionState.Closed:
+                this.container.p2pClosed()
+                break
+            case ConnectionState.Failed:
+                this.container.p2pError()
+                break
+            default:
+                break
+          }
+    }
+}

data/app/assets/javascripts/p2p/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "p2p",
+  "version": "0.0.1",
+  "files": ["./*.*"],
+  "main": "./index.js",
+  "dependencies": {
+    "@hotwired/stimulus": "^3.2.2",
+    "@hotwired/turbo-rails": "^8.0.4",
+    "esbuild": "^0.20.2"
+  },
+  "scripts": {
+    "build": "esbuild app/assets/javascripts/*.* --bundle --minify --format=esm --outdir=app/assets/builds --public-path=/assets"
+  }
+}

data/app/channels/signaling_channel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class SignalingChannel < Turbo::StreamsChannel
+    def subscribed
+        super
+        
+        # TODO: user_id, session_id, is_host
+        @session_id = params["session_id"]
+        @peer_id = params["peer_id"]
+    end
+
+    def receive(data)
+        puts "Signaling Server peer #{@peer_id} receive #{data} #{params}"
+        send_back_msg = P2pStreamsChannel.resolve(data)
+        if send_back_msg.present?
+            SignalingChannel.sync send_back_msg, to: P2pStreamsChannel.fetch_session(data["session_id"])
+        end
+    end
+
+    def unsubscribed
+        super
+
+        P2pStreamsChannel.disconnect_if_host_peer(@session_id, @peer_id)
+    end
+
+    def self.sync(data, to:)
+        ActionCable.server.broadcast stream_name_from(to), data
+    end
+end

data/app/helpers/p2p_streams_channel/tag_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module P2pStreamsChannel::TagHelper
+    def p2p_frame_tag(session_id:, peer_id:, **params, &block)
+        session = P2pStreamsChannel.fetch_session(session_id, **params)
+        signed_stream_name = Turbo::StreamsChannel.signed_stream_name(session)
+        content = capture(&block)
+
+        %(
+            <p2p-frame channel="SignalingChannel" signed-stream-name=#{signed_stream_name} 
+                session-id=#{session.id} peer-id=#{peer_id.to_json} params=#{params.to_json}>
+                #{content}
+            </p2p-frame>
+        ).html_safe
+    end
+end

data/lib/p2p_streams_channel/cache.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "./session_state"
+
+module P2pStreamsChannel
+    module_function
+
+    # TODO:
+    # params[start_time]
+    # params[end_time]
+    # params[max_number_of_peers]
+    #
+    def fetch_session(session_id, **params)
+        P2pStreamsChannel.store.fetch(session_id, expires_in: params[:expires_in]) do
+            P2pStreamsChannel::Session.new(session_id, secret_key: params[:secret_key])
+        end
+    end
+
+    def save_session(session)
+        P2pStreamsChannel.store.write(session.id, session)
+    end
+end

data/lib/p2p_streams_channel/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module P2pStreamsChannel
+    class Engine < ::Rails::Engine
+        config.autoload_once_paths = %W( #{root}/app/channels )
+        
+        initializer "p2p_streams_channel.assets" do
+            if Rails.application.config.respond_to?(:assets)
+              Rails.application.config.assets.precompile += Dir["#{root}/app/assets/javascripts/*/*"]
+            end
+        end
+
+        config.autoload_once_paths = %W( #{root}/app/helpers )
+        initializer "p2p_streams_channel.helpers" do
+            ActiveSupport.on_load(:action_controller_base) do
+              helper P2pStreamsChannel::Engine.helpers
+            end
+        end
+    end
+end

data/lib/p2p_streams_channel/negotiation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module P2pStreamsChannel
+    class Negotiation
+        def join(peer_id, session_state)
+            session_state.add_peer(peer_id)
+            session_state.host_ready? ? ready_response(peer_id, session_state) : nil
+        rescue => e
+            error_response(e, session_state)
+        end
+
+        def ready_response(peer_id, session_state)
+            {
+                "type": P2pStreamsChannel::CONNECTION_MESSAGE_TYPE,
+                "state": P2pStreamsChannel::STATE_SESSION_READY,
+                "host_peer_id": session_state.host_peer_id,
+                "peer_id": peer_id
+            }
+        end
+
+        def error_response(err, session_state)
+            # TODO:
+        end
+    end
+end

data/lib/p2p_streams_channel/session.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "./negotiation"
+
+module P2pStreamsChannel
+    # TODO: support optional :db -> save session to db
+    class Session
+        attr_reader :id, :secret_key, :negotiation, :session_state
+        
+        def initialize(id, secret_key: "")
+            @id = id
+            @secret_key = secret_key
+            @negotiation = Negotiation.new
+            @session_state = SessionState.new
+        end
+
+        def signature
+            {id: @id}
+        end
+
+        def to_param
+            signature.to_param
+        end
+
+        def to_json
+            signature.to_json
+        end
+
+        def join_peer(peer_id)
+            @negotiation.join(peer_id, session_state).tap do |response|
+                save!
+            end
+        end
+
+        def disconnect_peer(peer_id)
+            if session_state.host_peer_id == peer_id
+                reset_state
+            else
+                session_state.remove_peer(peer_id)
+                save!
+            end
+        end
+
+        def is_host_peer?(peer_id)
+            session_state.host_peer_id == peer_id
+        end
+
+        def reset_state
+            @session_state = SessionState.new
+            save!
+        end
+
+        def save!
+            P2pStreamsChannel.save_session(self)
+        end
+    end
+end

data/lib/p2p_streams_channel/session_handler.rb

@@ -0,0 +1,32 @@
+module P2pStreamsChannel
+    module_function
+
+    CONNECTION_MESSAGE_TYPE = "Connection".freeze
+
+    def resolve(message)
+        case message["type"]
+        when CONNECTION_MESSAGE_TYPE
+            handle_session(message)
+        else
+        end
+    end
+
+    def handle_session(data)
+        case data["state"]
+        when P2pStreamsChannel::STATE_SESSION_JOIN
+            if session = P2pStreamsChannel.fetch_session(data["session_id"])
+                session.join_peer(data["peer_id"])
+            end
+        else
+            data
+        end
+    end
+
+    def disconnect_if_host_peer(session_id, peer_id)
+        if session = P2pStreamsChannel.fetch_session(session_id)
+            if session.is_host_peer?(peer_id)
+                session.disconnect_peer(peer_id)
+            end
+        end
+    end
+end

data/lib/p2p_streams_channel/session_state.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module P2pStreamsChannel
+    STATE_SESSION_JOIN = "SessionJoin".freeze
+    STATE_SESSION_READY = "SessionReady".freeze
+    STATE_CONNECTED = "connected".freeze
+
+    class SessionState
+        attr_reader :peers, :host_peer_id
+
+        def initialize(host_peer_id = nil)
+            @peers = {}
+            @host_peer_id = host_peer_id
+        end
+
+        def add_peer(peer_id)
+            @peers[peer_id] = true
+            @host_peer_id = peer_id if @host_peer_id.nil?
+        end
+
+        def remove_peer(peer_id)
+            @peers[peer_id] = false
+        end
+
+        def num_of_connected_peers
+            @peers.count { |peer, connected| connected == true }
+        end
+
+        def host_ready?
+            @peers[@host_peer_id] == true 
+        end
+    end
+end

data/lib/p2p_streams_channel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module P2pStreamsChannel
+  VERSION = "0.0.2"
+end

data/lib/p2p_streams_channel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "p2p_streams_channel/version"
+require_relative "p2p_streams_channel/engine"
+require_relative "p2p_streams_channel/cache"
+require_relative "p2p_streams_channel/session"
+require_relative "p2p_streams_channel/session_handler"
+
+require_relative  "rails/generators/p2p_streams_channel/install_generator"
+
+module P2pStreamsChannel
+  class Error < StandardError; end
+
+  class Configuration
+    attr_accessor :store
+  end
+
+  mattr_reader :configs, default: Configuration.new
+
+  def config
+    yield(configs)
+  end
+  module_function :config
+
+  def store
+      configs.store || Rails.cache
+  end
+  module_function :store
+end

data/lib/rails/generators/p2p_streams_channel/controller_generator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "rails/generators"
+
+module P2pStreamsChannel
+    class ControllerGenerator < ::Rails::Generators::NamedBase
+        source_root File.expand_path("../templates", __FILE__)
+
+        def p2p_controller_js
+            copy_file "controller.js", "app/javascript/controllers/#{name}_controller.js"
+        end
+    end
+end

data/lib/rails/generators/p2p_streams_channel/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require "rails/generators"
+
+module P2pStreamsChannel
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    
+    def importmap
+      return unless (importmap_path = Rails.root.join("config/importmap.rb")).exist?
+      
+      append_to_file importmap_path, %(\npin_all_from "#{File.expand_path("../../../../app/assets/javascripts/p2p/", __dir__)}", under: "p2p"\n)
+    end
+
+    def node
+      return unless Rails.root.join("package.json").exist?
+
+      run "yarn add p2p@file:#{File.expand_path("../../../../app/assets/javascripts/p2p/", __dir__)}"
+    end
+
+    def create_initializer
+      copy_file "initializer.rb", "config/initializers/p2p_streams_channel.rb"
+    end
+  end
+end

data/lib/rails/generators/p2p_streams_channel/templates/controller.js

@@ -0,0 +1,51 @@
+import { P2pController } from "p2p"
+
+export default class extends P2pController {
+    //
+    // p2p callbacks
+    //
+    p2pNegotiating() {
+        // your peer start to negotiate with the host through ActionCable
+    }
+
+    p2pConnecting() {
+        // your peer is connecting directly with the host peer
+    }
+
+    p2pConnected() {
+        // your peer's connected to the host peer
+        // from now you could start send message to the other through the host peer
+    }
+
+    p2pDisconnected() {
+        // your peer's disconnected from the host peer
+    }
+
+    p2pClosed() {}
+
+    p2pError() {}
+
+    // receiving message from the other through the host peer
+    p2pReceivedMessage(message) {
+        switch(message["type"]) {
+            case "Data":
+                // message["data"]: the raw text(or whatever)
+                break
+            case "Data.Connection.State":
+                // message["data"]: the current connection state of other peers
+                // for (let [peer, state] of Object.entries(message["data"])) {}
+                break
+            default:
+                break
+        }
+    }
+
+    //
+    // send message to the others through the host peer:
+    // this.p2pSendMessage('hi')
+    //
+    // this.iamHost: your peer is the host or not
+    // this.peerId: your peer id
+    // this.hostPeerId: the host peer id
+    //
+}

data/lib/rails/generators/p2p_streams_channel/templates/initializer.rb

@@ -0,0 +1,4 @@
+P2pStreamsChannel.config do |config|
+    # config.store = Rails.cache
+end
+

data/p2p_streams_channel.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative "lib/p2p_streams_channel/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "p2p_streams_channel"
+  spec.version = P2pStreamsChannel::VERSION
+  spec.authors = ["theforestvn88"]
+  spec.email = ["theforestvn88@gmail.com"]
+
+  spec.summary = "rails p2p turbo streams channel"
+  spec.description = "rails p2p turbo streams channel"
+  spec.homepage = "https://github.com/theforestvn88/p2p_streams_channel"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/theforestvn88/p2p_streams_channel"
+  spec.metadata["changelog_uri"] = "https://github.com/theforestvn88/p2p_streams_channel"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails"
+  spec.add_dependency 'turbo-rails'
+  spec.add_dependency 'stimulus-rails'
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec-rails'
+  spec.test_files = Dir["spec/**/*"]
+end

data/sig/p2p_streams_channel.rbs

@@ -0,0 +1,4 @@
+module P2pStreamsChannel
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,4 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
+//= link_tree ../../javascript .js
+//= link_tree ../../../vendor/javascript .js

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/* Application styles */
+
+
+.not-available {
+    display: none;
+}
+
+.available {
+    display: flex;
+}
+
+.room {
+    display: flex;
+    justify-content: space-between;
+}

data/spec/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end