#!/usr/bin/env python3 # # Copyright (c) 2018, Matthew Waters # # 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())