Add an agent for WebTransport Support. (#113)

* Add RTCIceTransport and RTCIceCandidate.

Change-Id: If39775bf3494bdceeef44846abfb775dbd4e8a65

* Add RTCQuicTransport.

* Receive data from client.

OnData event is not complied with spec. Fin is not respected.

* Write data to QuicStream.

* Add a task runner to call QUIC APIs.

* Fix a memory leak issue.

* Move QUIC to a separate directory.

* Separate WebRTC and QUIC code.

This experimental change makes WebRTC agent running QUIC code. We'll
move QUIC to a standalone agent in future changes.

* Add signaling support for publishing a QUIC stream.

* Forwarding data through QUIC data channel.

This change adds data filed to publication and subscription.

* Adding interfaces for data pipeline in C++ level.

* QuicStream implements FrameSource and FrameDestination.

* Forward data in C++ level.

* Add documentation for how to run server with QUIC enabled.

* Update doc for CHROMIUM_HOME.

* Fix argument issue for quicConnection.js.

* Fix dependency issue during building.

Certificate is not used right now, so we don't need to initialize
SSL at this time. It removes its dependent to rtc_base.

* Copy data during forwarding.

QuicStringPiece may read freed buffer when write to transport.

* Fix a memery leak issue.

* Move QUIC transport to a standalone agent.

* Add more files to QUIC agent.

* QUIC agent can be started and stopped.

* Enable unit tests for RTCIceTransport.

* Add an implementation of P2PQuicPacketTransportInterface.

* Refactor QUIC addon.

Moving QUIC implementation to QUIC SDK.

* Implement RTCQuicTransport::listen.

* Enable write observer and read delegate.

* Implement delegate for P2PQuicTransport.

This commit also removes some unused files.

* QuicStream is able to receive data.

* Implement write for QuicStream.

* Remove an EscapableHandleScope and add dtor for QuicStream.

* Remove branch specific section for README.md.

* Modify documentation for QUIC addon.

* Remove patches for Chromium.

QUIC addon depends on QUIC SDK now. Changes for Chromium will be
performed in QUIC SDK repo.

* Restore build configuration.

We used to add QUIC as a feature for webrtc agent, but we decided
to add a new QUIC agent for QUIC connections now. This change
restores modifications for webrtc agent.

* Exclude quic-agent from full package.

Don't pack quic-agent by default because CI for QUIC SDK is not ready.
So it cannot get the binary of QUIC SDK.

* Restore changes made outside QUIC addon.

* Adding QUIC agent.

* Add QUIC subscription support.

* Recover connections.js.

* QUIC P2P multiplexing support.

* Add QUIC transport server.

* Rename QuicStream to RTCQuicStream.

* Add QUIC transport streams.

* QUIC transport server is able to receive data.

* Quic transport server is able to send data.

* Remove code for QUIC API for Peer-to-peer Connections.

We will implement QuicTransport of WebTransport in server.

* Make QUIC agent to build with node.js v12.

* Add contentsessionid event for QuicTransportStream.

This event is fired when a QuicTransportStream could be associated with
a publication or subscription. Since server side defines session ID as a
published stream ID or a subscription ID, we use `contentsessionid` here
to distingulish it from Quic session.

* Fix data is undefined.

* Fix some issues to run QuicTransportServer in QUIC agent.

* Use UUID for publication and subscription ID.

UUID is better to be encoded for QuicTransport.

This commit adds a new dependency: uuid.
https://www.npmjs.com/package/uuid.

* Parse the first 16 bytes of QuicStream as UUID.

* Participants recieve notification when a data stream is added.

* Stream info has data property.

It indicates whether this is a data stream.

* Add subscription support for QUIC agent.

* Add support to subscribe data streams.

* Linkup publications and subscriptions for data streams.

* Enhance readme.

* Enable data stream forwarding.

* Enable authentication for QUIC transport.

QUIC transport is authenticated by transport ID which is issued by
the signaling module of portal. In the future, when QUIC transport
is allowed for signaling, other authentication method should be used. A
possible one is token, which is similar to the socket.io channel we are
using today.

* Remove P2P QUIC and code cleanup.

* Don't pack QUIC agent by default.

QUIC agent depends on QUIC SDK, which is not supported by testing
system.

* Add data source for linkup.

* Add unit test for QuicTransportServer.

* Fix build issues after rebasing.

* Don't start quic-agent by default.

* Clean up.

* Close connection if no transport ID is received after 10s.

* Update QuicFactory for QUIC SDK API change.

* Address some format and naming issues.

* Port number is configurable.

* Change QUIC agent port configuration from a range to a value.

QUIC agent always uses the minimal port number configured. So the range
actually is not respected.

* QUIC agent reads certificate path from configuration file.

* Fix an issue introduced by rebasing.

A new parameter was add for roomController.publish.

* Remove unused flags from build script.

* Fix race conditions by minimizing lock usages.

* Tokens have URL for WebTransport connections.

A new property webTransportUrl is added to tokens if a QUIC agent is
running.

* Add token for WebTransport in the response of join.

No update for tests for portal because it looks like no check in or
night testing is running the test code, and some cases are failed in my
development environment.

* Authenticate WebTransport connections with tokens.

Tokens are issued by portal after joining. QUIC agent asks portal for
authentication.

* Fix issues for publications after rebasing.

* Fix publish method after rebasing.

Server can detect new streams from QUIC agent, but this change breaks
rtcController and stream events sent from server don't have "data"
property. These issues along with other subscribe issues will be fixed
in following commits.

* Fix subscribe method after rebasing.

* Separate rtcController and quicController.

Conference sessions over QUIC used to be handled by accessController.
But a recent change added rtcController, moved some logicals out of
accessController. So we need to either have a quicController or extend
rtcController or accessController. This change adds a quicController.
However, it would be better to redesign the interface of *Controller,
and create a single controller for each conference.

* Fix WebRTC agent.

Changes for adding WebTransport support broken WebRTC agent. This change
fixes these issues.

* Add back origin info.

Don't know why origin is a property of media. Add it to publish info and
subscribe info.

* Terminate a session returns a promise.

A session might be managed by rtcController or quicController, since
accessController doesn't know a session's type, try to terminate it in
either rtcControoler or quicController.

* Add a configuration item to disable WebTransport support.

* Restore v11Client.js.

Protocol version was upgraded to v1.2. We don't need to touch v1.1
protocol handler.

* Add a guide for WebTransport.

* Clean up.

* Address comments.

Author: jianjunz

doc/servermd/WebTransportGuide.md

@@ -0,0 +1,23 @@
+# Open WebRTC Toolkit WebTransport Support
+
+## Overview
+
+Open WebRTC Toolkit (OWT) added [WebTransport](https://w3c.github.io/webtransport/) over [QUIC](https://tools.ietf.org/html/draft-ietf-quic-transport-32) support since 5.0. At this moment, it only supports simple data forwarding.
+
+WebTransport over other protocols are not support.
+
+## Streams
+
+Similar to media streams, a stream for arbitrary data also supports `publish` and `subscribe`. A new property `data` is added to indicate if a stream is for arbitrary data. Media features like mixing and transcoding are not supported. If you develop client applications without OWT Client SDKs, please refer to [PR 125](https://github.com/open-webrtc-toolkit/owt-server/pull/125) for protocol changes and payload format. OWT JavaScript SDK and C++ SDK support streams for arbitrary data, please see API references of these two SDKs for newly added APIs. Basically, client side creates data streams, then `publish` and `subscribe` just as media streams. `streamadded` event also fires for data streams.
+
+## QUIC agent
+
+QUIC agent handles WebTransport connections from clients. It depends on [OWT QUIC SDK](https://github.com/open-webrtc-toolkit/owt-deps-quic). By default, it listens on 7700 port. Only one instance is running on a single machine or a docker environment.
+
+## Roadmap
+
+We are planning to support follow features, but we don't have an ETA so far.
+
+- Signaling over QUIC. Instead of creating a WebSocket connection between a client and portal, we could use a WebTransport connection for both signaling and other data.
+- Media over QUIC. Sending and receiving audio and video data over QUIC instead of WebRTC.
+- Datagram support. Datagram support with FEC and NACK may help us to reduce the latency when sending media over QUIC.

scripts/build.js

@@ -170,4 +170,4 @@ Promise.all(works)
       let checkOutput = execSync(`node ${moduleTestScript} ${runtimeAddonDir}`).toString();
       console.log(checkOutput);
     }
-  });
+  });

scripts/build.json

@@ -49,6 +49,12 @@
             "webrtc-frame"
         ]
     },
+    "mcu-quic": {
+        "include":[
+            "mcu",
+            "quic"
+        ]
+    },
     "video-mixer-sw" : {
         "path" : "source/agent/video/videoMixer/videoMixer_sw",
         "gyp" : "binding.sw.gyp"
@@ -111,5 +117,9 @@
     },
     "resource-util" : {
         "path" : "source/agent/addons/resourceUtil"
+    },
+    "quic" : {
+        "path" : "source/agent/addons/quic",
+        "description": "QUIC agent supports WebTransport - QuicTransport connections. Experimental feature."
     }
 }

scripts/pack.js

@@ -40,6 +40,8 @@ const originCwd = cwd();
 const osScript = path.join(rootDir, 'scripts/detectOS.sh');
 const osType = execSync(`bash ${osScript}`).toString().toLowerCase();
 
+const experimentalTargets = ['quic-agent'];
+
 var allTargets = [];
 
 if (options.full) {
@@ -131,7 +133,8 @@ function getPackList(targets) {
   }
 
   var packList = targets.filter((element) => {
-    if (options.target.includes('all')) return true;
+    // Don't include QUIC agent by default until CI is added for QUIC SDK.
+    if (options.target.includes('all') && !experimentalTargets.includes(element.rules.name)) return true;
     return options.target.includes(element.rules.name);
   });
   if (packList.length === 0) {
@@ -598,6 +601,9 @@ function packScripts() {
   }
   scriptItems.push('app');
   scriptItems.forEach((m) => {
+    if (experimentalTargets.includes(m)) {
+      return;
+    }
     startCommands += '${bin}/daemon.sh start ' + m + ' $1\n';
     stopCommands += '${bin}/daemon.sh stop ' + m + '\n';
   });

scripts/release/daemon-bin.sh

@@ -169,6 +169,13 @@ case $startStop in
           > "${stdout}" 2>&1 </dev/null &
         echo $! > ${pid}
         ;;
+      quic-agent )
+        cd ${OWT_HOME}/quic_agent
+        export LD_LIBRARY_PATH=./lib:${LD_LIBRARY_PATH}
+        nohup nice -n ${OWT_NICENESS} ./OWT-MCU-Agent . -U quic\
+          > "${stdout}" 2>&1 </dev/null &
+        echo $! > ${pid}
+        ;;
       management-console )
         cd ${OWT_HOME}/management_console
         nohup nice -n ${OWT_NICENESS} node . \

scripts/release/daemon-mcu.sh

@@ -169,6 +169,13 @@ case $startStop in
           > "${stdout}" 2>&1 </dev/null &
         echo $! > ${pid}
         ;;
+      quic-agent )
+        cd ${OWT_HOME}/quic_agent
+        export LD_LIBRARY_PATH=./lib:${LD_LIBRARY_PATH}
+        nohup nice -n ${OWT_NICENESS} node . -U quic\
+          > "${stdout}" 2>&1 </dev/null &
+        echo $! > ${pid}
+        ;;
       analytics-agent )
         cd ${OWT_HOME}/analytics_agent
         export LD_LIBRARY_PATH=./lib:${LD_LIBRARY_PATH}

source/agent/addons/quic/QuicFactory.cc

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "QuicFactory.h"
+#include "owt/quic/quic_transport_factory.h"
+#include <mutex>
+
+DEFINE_LOGGER(QuicFactory, "QuicFactory");
+
+std::once_flag getQuicFactoryOnce;
+
+std::shared_ptr<QuicFactory> QuicFactory::s_quicFactory = nullptr;
+
+QuicFactory::QuicFactory()
+    : m_quicTransportFactory(std::shared_ptr<owt::quic::QuicTransportFactory>(owt::quic::QuicTransportFactory::Create()))
+{
+}
+
+std::shared_ptr<owt::quic::QuicTransportFactory> QuicFactory::getQuicTransportFactory()
+{
+    std::call_once(getQuicFactoryOnce, []() {
+        QuicFactory* factory = new QuicFactory();
+        s_quicFactory = std::shared_ptr<QuicFactory>(factory);
+    });
+    return s_quicFactory->m_quicTransportFactory;
+}

source/agent/addons/quic/QuicFactory.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef QUIC_QUICFACTORY_H_
+#define QUIC_QUICFACTORY_H_
+
+#include <memory>
+#include <logger.h>
+
+namespace owt {
+namespace quic {
+    class QuicTransportFactory;
+}
+}
+
+class QuicFactory {
+public:
+    DECLARE_LOGGER();
+    virtual ~QuicFactory() = default;
+    static std::shared_ptr<owt::quic::QuicTransportFactory> getQuicTransportFactory();
+
+private:
+    explicit QuicFactory();
+
+    static std::shared_ptr<QuicFactory> s_quicFactory;
+    std::shared_ptr<owt::quic::QuicTransportFactory> m_quicTransportFactory;
+};
+
+#endif

source/agent/addons/quic/QuicTransportConnection.cc

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "QuicTransportConnection.h"
+#include "QuicTransportStream.h"
+
+using v8::Function;
+using v8::FunctionTemplate;
+using v8::Local;
+using v8::Object;
+using v8::ObjectTemplate;
+using v8::Value;
+
+Nan::Persistent<v8::Function> QuicTransportConnection::s_constructor;
+
+DEFINE_LOGGER(QuicTransportConnection, "QuicTransportConnection");
+
+QuicTransportConnection::QuicTransportConnection()
+    : m_session(nullptr)
+    , m_visitor(nullptr)
+{
+}
+
+QuicTransportConnection::~QuicTransportConnection()
+{
+    if (!uv_is_closing(reinterpret_cast<uv_handle_t*>(&m_asyncOnStream))) {
+        uv_close(reinterpret_cast<uv_handle_t*>(&m_asyncOnStream), NULL);
+    }
+    m_session->SetVisitor(nullptr);
+}
+
+NAN_MODULE_INIT(QuicTransportConnection::init)
+{
+    Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(newInstance);
+    tpl->SetClassName(Nan::New("QuicTransportConnection").ToLocalChecked());
+    Local<ObjectTemplate> instanceTpl = tpl->InstanceTemplate();
+    instanceTpl->SetInternalFieldCount(1);
+
+    Nan::SetPrototypeMethod(tpl, "createBidirectionalStream", createBidirectionalStream);
+
+    s_constructor.Reset(Nan::GetFunction(tpl).ToLocalChecked());
+    Nan::Set(target, Nan::New("QuicTransportConnection").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
+}
+
+void QuicTransportConnection::setVisitor(Visitor* visitor)
+{
+    m_visitor = visitor;
+}
+
+void QuicTransportConnection::OnIncomingStream(owt::quic::QuicTransportStreamInterface* stream)
+{
+    ELOG_DEBUG("OnIncomingStream.");
+    {
+        std::lock_guard<std::mutex> lock(m_streamQueueMutex);
+        m_streamsToBeNotified.push(stream);
+    }
+    m_asyncOnStream.data = this;
+    uv_async_send(&m_asyncOnStream);
+}
+
+void QuicTransportConnection::onEnded()
+{
+}
+
+NAN_METHOD(QuicTransportConnection::newInstance)
+{
+    if (!info.IsConstructCall()) {
+        ELOG_DEBUG("Not construct call.");
+        return;
+    }
+    QuicTransportConnection* obj = new QuicTransportConnection();
+    obj->Wrap(info.This());
+    uv_async_init(uv_default_loop(), &obj->m_asyncOnStream, &QuicTransportConnection::onStreamCallback);
+    info.GetReturnValue().Set(info.This());
+}
+
+v8::Local<v8::Object> QuicTransportConnection::newInstance(owt::quic::QuicTransportSessionInterface* session)
+{
+    Local<Object> connectionObject = Nan::NewInstance(Nan::New(QuicTransportConnection::s_constructor)).ToLocalChecked();
+    QuicTransportConnection* obj = Nan::ObjectWrap::Unwrap<QuicTransportConnection>(connectionObject);
+    obj->m_session = session;
+    return connectionObject;
+}
+
+NAUV_WORK_CB(QuicTransportConnection::onStreamCallback)
+{
+    ELOG_DEBUG("OnStreamCallback.");
+    Nan::HandleScope scope;
+    QuicTransportConnection* obj = reinterpret_cast<QuicTransportConnection*>(async->data);
+    if (obj == nullptr || obj->m_streamsToBeNotified.empty()) {
+        return;
+    }
+    while (!obj->m_streamsToBeNotified.empty()) {
+        obj->m_streamQueueMutex.lock();
+        auto quicStream=obj->m_streamsToBeNotified.front();
+        obj->m_streamsToBeNotified.pop();
+        obj->m_streamQueueMutex.unlock();
+        v8::Local<v8::Object> streamObject = QuicTransportStream::newInstance(quicStream);
+        QuicTransportStream* stream = Nan::ObjectWrap::Unwrap<QuicTransportStream>(streamObject);
+        quicStream->SetVisitor(stream);
+        Nan::MaybeLocal<v8::Value> onEvent = Nan::Get(obj->handle(), Nan::New<v8::String>("onincomingstream").ToLocalChecked());
+        if (!onEvent.IsEmpty()) {
+            v8::Local<v8::Value> onEventLocal = onEvent.ToLocalChecked();
+            if (onEventLocal->IsFunction()) {
+                v8::Local<v8::Function> eventCallback = onEventLocal.As<Function>();
+                Nan::AsyncResource* resource = new Nan::AsyncResource(Nan::New<v8::String>("onincomingstream").ToLocalChecked());
+                Local<Value> args[] = { streamObject };
+                resource->runInAsyncScope(Nan::GetCurrentContext()->Global(), eventCallback, 1, args);
+            }
+        } else {
+            ELOG_DEBUG("onEvent is empty");
+        }
+    }
+}
+
+NAN_METHOD(QuicTransportConnection::createBidirectionalStream){
+    QuicTransportConnection* obj = Nan::ObjectWrap::Unwrap<QuicTransportConnection>(info.Holder());
+    auto stream=obj->m_session->CreateBidirectionalStream();
+    v8::Local<v8::Object> streamObject = QuicTransportStream::newInstance(stream);
+    info.GetReturnValue().Set(streamObject);
+}

source/agent/addons/quic/QuicTransportConnection.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef QUIC_QUICTRANSPORTCONNECTION_H_
+#define QUIC_QUICTRANSPORTCONNECTION_H_
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+#include <logger.h>
+#include <nan.h>
+
+#include "QuicTransportStream.h"
+#include "owt/quic/quic_transport_session_interface.h"
+
+class QuicTransportConnection : public Nan::ObjectWrap, public owt::quic::QuicTransportSessionInterface::Visitor, QuicTransportStream::Visitor {
+    DECLARE_LOGGER();
+
+public:
+    class Visitor {
+        // Authentication passed with user ID `id`.
+        virtual void onAuthentication(const std::string& id) = 0;
+        // Connection is closed.
+        virtual void onClose() = 0;
+    };
+    explicit QuicTransportConnection();
+    ~QuicTransportConnection();
+    void setVisitor(Visitor* visitor);
+    static v8::Local<v8::Object> newInstance(owt::quic::QuicTransportSessionInterface* session);
+
+    static NAN_MODULE_INIT(init);
+    static NAN_METHOD(newInstance);
+    static NAN_METHOD(createBidirectionalStream);
+    static NAUV_WORK_CB(onStreamCallback);
+
+    static Nan::Persistent<v8::Function> s_constructor;
+
+protected:
+    // Overrides owt::quic::QuicTransportSessionInterface::Visitor.
+    void OnIncomingStream(owt::quic::QuicTransportStreamInterface*) override;
+    void OnCanCreateNewOutgoingStream(bool unidirectional) override { }
+
+    // Overrides QuicTransportStream::Visitor.
+    void onEnded() override;
+
+private:
+    owt::quic::QuicTransportSessionInterface* m_session;
+    Visitor* m_visitor;
+    // Key is content session ID, i.e.: publication ID, subscription ID.
+    std::unordered_map<std::string, std::unique_ptr<QuicTransportStream>> m_streams;
+    // Move to `m_streams` after associate with a publication or subscription.
+    std::vector<std::unique_ptr<QuicTransportStream>> m_unassociatedStreams;
+
+    uv_async_t m_asyncOnStream;
+    std::mutex m_streamQueueMutex;
+    std::queue<owt::quic::QuicTransportStreamInterface*> m_streamsToBeNotified;
+};
+
+#endif