def send_answer(self, start_port, payload):
options = {"ICE": "remove", "label": "callee", "generate RTCP": "on"}
sdp_answer = self.commands.answer(
generate_sdp('127.0.0.1', start_port, payload=payload),
# generate_sdp(self.sdp_address, start_port),
str(start_port - 2) + "-" + str(start_port),
"from-tag" + str(start_port - 2),
"to-tag" + str(start_port - 2),
**options)
if not self.ws:
send(self.address, self.port, sdp_answer, self.sdp_address,
start_port)
else:
ws_send(self.address,
self.port,
sdp_answer,
bind_address=self.sdp_address,
bind_port=start_port)
def delete_calls(self):
''' Delete calls from rtpengine
Iterate through the generated calls and delete them from
rtpengine based on their call_id and from-tag.
'''
if not self.ws:
for call in self.calls:
send(self.address, self.port,
self.commands.delete(call['call_id'], call['from-tag']),
self.sdp_address, 3000)
else:
for call in self.calls:
ws_send(self.address,
self.port,
self.commands.delete(call['call_id'],
call['from-tag']),
bind_address=self.sdp_address,
bind_port=3000)
def check_delete():
# print(len(kubernetes_apis))
for a in kubernetes_apis:
if RTPE_PROTOCOL == 'ws':
query = ws_send(RTPE_PROTOCOL,
RTPE_PORT,
commands.query(a.call_id),
sock=ws_sock)
if RTPE_PROTOCOL == 'udp':
query = send(RTPE_ADDRESS, RTPE_PORT, commands.query(a.call_id),
LOCAL_ADDRESS, 2002)
if query['result'] == 'error':
a.delete_resources()
kubernetes_apis.remove(a)
def create_resource(call_id, from_tag, to_tag):
global kubernetes_apis
for a in kubernetes_apis:
if a.call_id == call_id:
return
if RTPE_PROTOCOL == 'udp':
query = send(RTPE_ADDRESS, RTPE_PORT, commands.query(call_id),
LOCAL_ADDRESS, 2998)
if RTPE_PROTOCOL == 'ws':
query = ws_send(RTPE_ADDRESS,
RTPE_PORT,
commands.query(call_id),
sock=ws_sock)
from_port = query['tags'][from_tag]['medias'][0]['streams'][0][
'local port']
from_c_address = query['tags'][from_tag]['medias'][0]['streams'][0][
'endpoint']['address']
from_c_port = query['tags'][from_tag]['medias'][0]['streams'][0][
'endpoint']['port']
to_port = query['tags'][to_tag]['medias'][0]['streams'][0]['local port']
to_c_address = query['tags'][to_tag]['medias'][0]['streams'][0][
'endpoint']['address']
to_c_port = query['tags'][to_tag]['medias'][0]['streams'][0]['endpoint'][
'port']
kubernetes_apis.append(
KubernetesAPIClient(in_cluster=True,
call_id=call_id,
tag=from_tag,
local_ip=from_c_address,
local_rtp_port=from_c_port,
local_rtcp_port=from_c_port + 1,
remote_rtp_port=from_port,
remote_rtcp_port=from_port + 1,
without_jsonsocket=WITHOUT_JSONSOCKET,
ws=True))
kubernetes_apis.append(
KubernetesAPIClient(in_cluster=True,
call_id=call_id,
tag=to_tag,
local_ip=to_c_address,
local_rtp_port=to_c_port,
local_rtcp_port=to_c_port + 1,
remote_rtp_port=to_port,
remote_rtcp_port=to_port + 1,
without_jsonsocket=WITHOUT_JSONSOCKET,
ws=True))
def generate_calls(self, cnt):
''' Generate a given number of calls.
The first call will have these ports: offer - 3002 and answer -
3004 and it will increase always by two. This is important to debug
if somethin went wrong.
It will use the ffmpeg command to create subprocesses which runs
almost side-by-side.
Watch out for the cnt because it can produce a huge load cause the
ffmpeg memory usage.
Args:
cnt: Number of concurrent calls.
'''
start_port = 3000
offers = []
answers = []
caller_source_ports = []
callee_source_ports = []
caller_destinations = []
callee_destinations = []
for _ in range(cnt):
# Offer
start_port += 2
self.send_offer(start_port, self.codecs[0])
# Answer
start_port += 2
self.send_answer(start_port, self.codecs[1])
if not self.ws:
query = send(
self.address, self.port,
self.commands.query(
str(start_port - 2) + "-" + str(start_port)),
self.sdp_address, 2998)
else:
query = ws_send(self.address,
self.port,
self.commands.query(
str(start_port - 2) + "-" +
str(start_port)),
bind_address=self.sdp_address,
bind_port=2998,
delay=5)
offer_rtp_port = query['tags'][
"from-tag" +
str(start_port - 2)]['medias'][0]['streams'][0]['local port']
answer_rtp_port = query['tags'][
"to-tag" +
str(start_port - 2)]['medias'][0]['streams'][0]['local port']
offer_rtcp_port = query['tags'][
"from-tag" +
str(start_port - 2)]['medias'][0]['streams'][1]['local port']
answer_rtcp_port = query['tags'][
"to-tag" +
str(start_port - 2)]['medias'][0]['streams'][1]['local port']
print(
f'Offer RTP port: {offer_rtp_port}, RTCP port {offer_rtcp_port}!'
)
print(
f'Answer RTP port: {answer_rtp_port}, RTCP port {answer_rtcp_port}!'
)
if not self.rtpsend:
offers.append(
f'rtp://{self.address}:{str(offer_rtp_port)}?localrtpport={str(start_port - 2)}'
)
answers.append(
f'rtp://{self.address}:{str(answer_rtp_port)}?localrtpport={str(start_port)}'
)
else:
caller_source_ports.append(str(start_port - 2))
callee_source_ports.append(str(start_port))
caller_destinations.append(self.address + '/' +
str(offer_rtp_port))
callee_destinations.append(self.address + '/' +
str(answer_rtp_port))
if not self.sidecar:
# Offer
self.apis.append(
KubernetesAPIClient(
self.in_cluster,
call_id=str(start_port - 2) + "-" + str(start_port),
tag="from-tag" + str(start_port - 2),
# local_ip='127.0.0.1',
local_ip=self.sdp_address,
local_rtp_port=start_port - 2,
local_rtcp_port=start_port - 1,
remote_rtp_port=offer_rtp_port,
remote_rtcp_port=offer_rtcp_port,
without_jsonsocket=self.without_jsonsocket))
# Answer
self.apis.append(
KubernetesAPIClient(
self.in_cluster,
call_id=str(start_port - 2) + "-" + str(start_port),
tag="to-tag" + str(start_port - 2),
# local_ip='127.0.0.1',
local_ip=self.sdp_address,
local_rtp_port=start_port,
local_rtcp_port=start_port + 1,
remote_rtp_port=answer_rtp_port,
remote_rtcp_port=answer_rtcp_port,
without_jsonsocket=self.without_jsonsocket))
# time.sleep(1)
if self.audio_file:
ffmpeg(self.audio_file, cnt, offers, answers, self.codecs)
elif self.rtpsend:
rtpsend(self.rtpsend, cnt, caller_source_ports,
caller_destinations, callee_source_ports,
callee_destinations)
else:
time.sleep(600)
async def ws_processing(websocket, path):
global ws_sock
if RTPE_CONTROLLER == 'l7mp':
# websocket init
ws_base_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ws_base_sock.connect((RTPE_ADDRESS, RTPE_PORT))
# enableTrace(True)
data = None
try:
data = parse_data(await websocket.recv())
if "call-id" in data:
ws_sock = create_connection(
f'ws://{RTPE_ADDRESS}:{RTPE_PORT}',
subprotocols=["ng.rtpengine.com"],
origin='127.0.0.1',
socket=ws_base_sock,
header=[f'callid: {data["call-id"]}'])
else:
ws_sock = create_connection(f'ws://{RTPE_ADDRESS}:{RTPE_PORT}',
subprotocols=["ng.rtpengine.com"],
origin='127.0.0.1',
socket=ws_base_sock)
response = ws_send(RTPE_ADDRESS, RTPE_PORT, data, sock=ws_sock)
# pprint(response)
if 'sdp' in response:
response['sdp'] = response['sdp'].replace(
'127.0.0.1', '192.168.99.103')
time.sleep(1)
await websocket.send(data['cookie'] + " " +
bc.encode(response).decode())
except websockets.exceptions.ConnectionClosedError:
pass
if data['command'] == 'delete':
delete_kube_resources(data['call-id'])
if data['command'] == 'answer':
create_resource(data['call-id'], data['from-tag'], data['to-tag'])
ws_sock.close()
ws_base_sock.close()
if RTPE_CONTROLLER == 'envoy':
ENVOY_MGM_ADDRESS = socket.gethostbyname_ex(
os.getenv('ENVOY_MGM_ADDRESS'))[2][0]
ENVOY_MGM_PORT = int(os.getenv('ENVOY_MGM_PORT'))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('127.0.0.1', 2000))
# websocket init
ws_base_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ws_base_sock.connect((RTPE_ADDRESS, RTPE_PORT))
# enableTrace(True)
data = None
try:
data = parse_data(await websocket.recv())
if "call-id" in data:
ws_sock = create_connection(
f'ws://{RTPE_ADDRESS}:{RTPE_PORT}',
subprotocols=["ng.rtpengine.com"],
origin='127.0.0.1',
socket=ws_base_sock,
header=[f'callid: {data["call-id"]}'])
else:
ws_sock = create_connection(f'ws://{RTPE_ADDRESS}:{RTPE_PORT}',
subprotocols=["ng.rtpengine.com"],
origin='127.0.0.1',
socket=ws_base_sock)
response = ws_send(RTPE_ADDRESS, RTPE_PORT, data, sock=ws_sock)
pprint(response)
if 'sdp' in response:
response['sdp'] = response['sdp'].replace(
'127.0.0.1', '192.168.99.103')
time.sleep(1)
await websocket.send(data['cookie'] + " " +
bc.encode(response).decode())
except websockets.exceptions.ConnectionClosedError:
pass
# if data['command'] == 'delete':
# delete_kube_resources(data['call-id'])
if data['command'] in ['answer', 'delete']:
query = ws_send(RTPE_ADDRESS,
RTPE_PORT,
commands.query(data['call-id']),
sock=ws_sock)
caller_port = query['tags'][
data['from-tag']]['medias'][0]['streams'][0]['local port']
callee_port = query['tags'][
data['to-tag']]['medias'][0]['streams'][0]['local port']
json_data = json.dumps({
"caller_rtp": caller_port,
"caller_rtcp": caller_port + 1,
"callee_rtp": callee_port,
"callee_rtcp": callee_port + 1
}).encode('utf-8')
sock.sendto(json_data, (ENVOY_MGM_ADDRESS, ENVOY_MGM_PORT))
sock.close()
ws_sock.close()
ws_base_sock.close()