gstreamer/webrtc/check/validate/webrtc_validate.py
Matthew Waters 615813ef93 check/validate: a few more tests and improvements
Tests a matrix of options:
- local/remote negotiation initiator
- 'most' bundle-policy combinations (some combinations will never work)
- firefox or chrome browser

Across 4 test scenarios:
- simple negotiation with default browser streams (or none if gstreamer
  initiates)
- sending a vp8 stream
- opening a data channel
- sending a message over the data channel

for a total of 112 tests!
2020-05-06 06:01:57 +00:00

286 lines
12 KiB
Python

#!/usr/bin/env python3
#
# Copyright (c) 2018, Matthew Waters <matthew@centricular.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
# Boston, MA 02110-1301, USA.
import os
import sys
import argparse
import json
import logging
from signalling import WebRTCSignallingClient, RemoteWebRTCObserver
from actions import ActionObserver
from client import WebRTCClient
from browser import Browser, create_driver
from enums import SignallingState, NegotiationState, DataChannelState, Actions
import gi
gi.require_version("GLib", "2.0")
from gi.repository import GLib
gi.require_version("Gst", "1.0")
from gi.repository import Gst
gi.require_version("GstWebRTC", "1.0")
from gi.repository import GstWebRTC
gi.require_version("GstSdp", "1.0")
from gi.repository import GstSdp
gi.require_version("GstValidate", "1.0")
from gi.repository import GstValidate
FORMAT = '%(asctime)-23s %(levelname)-7s %(thread)d %(name)-24s\t%(funcName)-24s %(message)s'
LEVEL = os.environ.get("LOGLEVEL", "DEBUG")
logging.basicConfig(level=LEVEL, format=FORMAT)
l = logging.getLogger(__name__)
class WebRTCApplication(object):
def __init__(self, server, id_, peerid, scenario_name, browser_name, html_source, test_name=None):
self.server = server
self.peerid = peerid
self.html_source = html_source
self.id = id_
self.scenario_name = scenario_name
self.browser_name = browser_name
self.test_name = test_name
def _init_validate(self, scenario_file):
self.runner = GstValidate.Runner.new()
self.monitor = GstValidate.Monitor.factory_create(
self.client.pipeline, self.runner, None)
self._scenario = GstValidate.Scenario.factory_create(
self.runner, self.client.pipeline, self.scenario_name)
self._scenario.connect("done", self._on_scenario_done)
self._scenario.props.execute_on_idle = True
if not self._scenario.props.handles_states:
self.client.pipeline.set_state(Gst.State.PLAYING)
def _on_scenario_done(self, scenario):
l.error ('scenario done')
GLib.idle_add(self.quit)
def _connect_actions(self, actions):
def on_action(atype, action):
"""
From a validate action, perform the action as required
"""
if atype == Actions.CREATE_OFFER:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
c.create_offer()
return GstValidate.ActionReturn.OK
elif atype == Actions.CREATE_ANSWER:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
c.create_answer()
return GstValidate.ActionReturn.OK
elif atype == Actions.WAIT_FOR_NEGOTIATION_STATE:
states = [NegotiationState(action.structure["state"]), NegotiationState.ERROR]
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
state = c.wait_for_negotiation_states(states)
return GstValidate.ActionReturn.OK if state != NegotiationState.ERROR else GstValidate.ActionReturn.ERROR
elif atype == Actions.ADD_STREAM:
self.client.add_stream(action.structure["pipeline"])
return GstValidate.ActionReturn.OK
elif atype == Actions.ADD_DATA_CHANNEL:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
c.add_data_channel(action.structure["id"])
return GstValidate.ActionReturn.OK
elif atype == Actions.SEND_DATA_CHANNEL_STRING:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
channel = c.find_channel (action.structure["id"])
channel.send_string (action.structure["msg"])
return GstValidate.ActionReturn.OK
elif atype == Actions.WAIT_FOR_DATA_CHANNEL_STATE:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
states = [DataChannelState(action.structure["state"]), DataChannelState.ERROR]
channel = c.find_channel (action.structure["id"])
state = channel.wait_for_states(states)
return GstValidate.ActionReturn.OK if state != DataChannelState.ERROR else GstValidate.ActionReturn.ERROR
elif atype == Actions.CLOSE_DATA_CHANNEL:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
channel = c.find_channel (action.structure["id"])
channel.close()
return GstValidate.ActionReturn.OK
elif atype == Actions.WAIT_FOR_DATA_CHANNEL:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
state = c.wait_for_data_channel(action.structure["id"])
return GstValidate.ActionReturn.OK
elif atype == Actions.WAIT_FOR_DATA_CHANNEL_STRING:
assert action.structure["which"] in ("local", "remote")
c = self.client if action.structure["which"] == "local" else self.remote_client
channel = c.find_channel (action.structure["id"])
channel.wait_for_message(action.structure["msg"])
return GstValidate.ActionReturn.OK
elif atype == Actions.WAIT_FOR_NEGOTIATION_NEEDED:
self.client.wait_for_negotiation_needed(action.structure["generation"])
return GstValidate.ActionReturn.OK
elif atype == Actions.SET_WEBRTC_OPTIONS:
self.client.set_options (action.structure)
self.remote_client.set_options (action.structure)
return GstValidate.ActionReturn.OK
else:
assert "Not reached" == ""
actions.action.connect (on_action)
def _connect_client_observer(self):
def on_offer_created(offer):
text = offer.sdp.as_text()
msg = json.dumps({'sdp': {'type': 'offer', 'sdp': text}})
self.signalling.send(msg)
self.client.on_offer_created.connect(on_offer_created)
def on_answer_created(answer):
text = answer.sdp.as_text()
msg = json.dumps({'sdp': {'type': 'answer', 'sdp': text}})
self.signalling.send(msg)
self.client.on_answer_created.connect(on_answer_created)
def on_ice_candidate(mline, candidate):
msg = json.dumps({'ice': {'sdpMLineIndex': str(mline), 'candidate' : candidate}})
self.signalling.send(msg)
self.client.on_ice_candidate.connect(on_ice_candidate)
def on_pad_added(pad):
if pad.get_direction() != Gst.PadDirection.SRC:
return
self.client.add_stream_with_pad('fakesink', pad)
self.client.on_pad_added.connect(on_pad_added)
def _connect_signalling_observer(self):
def have_json(msg):
if 'sdp' in msg:
sdp = msg['sdp']
res, sdpmsg = GstSdp.SDPMessage.new()
GstSdp.sdp_message_parse_buffer(bytes(sdp['sdp'].encode()), sdpmsg)
sdptype = GstWebRTC.WebRTCSDPType.ANSWER if sdp['type'] == 'answer' else GstWebRTC.WebRTCSDPType.OFFER
desc = GstWebRTC.WebRTCSessionDescription.new(sdptype, sdpmsg)
self.client.set_remote_description(desc)
elif 'ice' in msg:
ice = msg['ice']
candidate = ice['candidate']
sdpmlineindex = ice['sdpMLineIndex']
self.client.add_ice_candidate(sdpmlineindex, candidate)
self.signalling.have_json.connect(have_json)
def error(msg):
# errors are unexpected
l.error ('Unexpected error: ' + msg)
GLib.idle_add(self.quit)
GLib.idle_add(sys.exit, -20)
self.signalling.error.connect(error)
def _init(self):
self.main_loop = GLib.MainLoop()
self.client = WebRTCClient()
self._connect_client_observer()
self.signalling = WebRTCSignallingClient(self.server, self.id)
self.remote_client = RemoteWebRTCObserver (self.signalling)
self._connect_signalling_observer()
actions = ActionObserver()
actions.register_action_types()
self._connect_actions(actions)
# wait for the signalling server to start up before creating the browser
self.signalling.wait_for_states([SignallingState.OPEN])
self.signalling.hello()
self.browser = Browser(create_driver(self.browser_name))
self.browser.open(self.html_source)
browser_id = self.browser.get_peer_id ()
assert browser_id == self.peerid
self.signalling.create_session(self.peerid)
test_name = self.test_name if self.test_name else self.scenario_name
self.remote_client.set_title (test_name)
self._init_validate(self.scenario_name)
def quit(self):
# Stop signalling first so asyncio doesn't keep us alive on weird failures
l.info('quiting')
self.signalling.stop()
l.info('signalling stopped')
self.main_loop.quit()
l.info('main loop stopped')
self.client.stop()
l.info('client stopped')
self.browser.driver.quit()
l.info('browser exitted')
def run(self):
try:
self._init()
l.info("app initialized")
self.main_loop.run()
l.info("loop exited")
except:
l.exception("Fatal error")
self.quit()
raise
def parse_options():
parser = argparse.ArgumentParser()
parser.add_argument('id', help='ID of this client', type=int)
parser.add_argument('--peer-id', help='ID of the peer to connect to', type=int)
parser.add_argument('--server', help='Signalling server to connect to, eg "wss://127.0.0.1:8443"')
parser.add_argument('--html-source', help='HTML page to open in the browser', default=None)
parser.add_argument('--scenario', help='Scenario file to execute', default=None)
parser.add_argument('--browser', help='Browser name to use', default=None)
parser.add_argument('--name', help='Name of the test', default=None)
return parser.parse_args()
def init():
Gst.init(None)
GstValidate.init()
args = parse_options()
if not args.scenario:
args.scenario = os.environ.get('GST_VALIDATE_SCENARIO', None)
# if we have both manual scenario creation and env, then the scenario
# is executed twice...
if 'GST_VALIDATE_SCENARIO' in os.environ:
del os.environ['GST_VALIDATE_SCENARIO']
if not args.scenario:
raise ValueError("No scenario file provided")
if not args.server:
raise ValueError("No server location provided")
if not args.peer_id:
raise ValueError("No peer id provided")
if not args.html_source:
raise ValueError("No HTML page provided")
if not args.browser:
raise ValueError("No Browser provided")
return args
def run():
args = init()
w = WebRTCApplication (args.server, args.id, args.peer_id, args.scenario, args.browser, args.html_source, test_name=args.name)
return w.run()
if __name__ == "__main__":
sys.exit(run())