ShaYmez/hbnet
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
82213561b8
hbnet/bridge.py

1398 lines
88 KiB
Python
Raw Normal View History

push changes
2018-12-27 15:31:08 -05:00
#!/usr/bin/env python
#
###############################################################################
update copyright
2019-02-22 17:30:16 -05:00
# Copyright (C) 2016-2019 Cortney T. Buffington, N0MJS <n0mjs@me.com>
push changes
2018-12-27 15:31:08 -05:00
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
###############################################################################
'''
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
This application, in conjuction with it's rule file (rules.py) will
push changes
2018-12-27 15:31:08 -05:00
work like a "conference bridge". This is similar to what most hams think of as a
reflector. You define conference bridges and any system joined to that conference
bridge will both receive traffic from, and send traffic to any other system
joined to the same conference bridge. It does not provide end-to-end connectivity
as each end system must individually be joined to a conference bridge (a name
you create in the configuraiton file) to pass traffic.
This program currently only works with group voice calls.
'''
# Python modules we need
import sys
from bitarray import bitarray
from time import time
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
import importlib.util
push changes
2018-12-27 15:31:08 -05:00
# Twisted is pretty important, so I keep it separate
from twisted.internet.protocol import Factory, Protocol
from twisted.protocols.basic import NetstringReceiver
from twisted.internet import reactor, task
# Things we import from the main hblink module
download burnlist on start
2021-06-03 16:38:47 -04:00
from hblink import HBSYSTEM, OPENBRIDGE, systems, hblink_handler, reportFactory, REPORT_OPCODES, mk_aliases, download_burnlist
Mostly kinda works now
2019-01-04 16:32:13 -05:00
from dmr_utils3.utils import bytes_3, int_id, get_alias
push changes
2018-12-27 15:31:08 -05:00
from dmr_utils3 import decode, bptc, const
import config
import log
change how constants are imported
2018-12-27 15:36:32 -05:00
from const import *
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
from hashlib import sha256
push changes
2018-12-27 15:31:08 -05:00
# Stuff for socket reporting
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
import pickle
# REMOVE LATER from datetime import datetime
push changes
2018-12-27 15:31:08 -05:00
# The module needs logging, but handlers, etc. are controlled by the parent
import logging
logger = logging.getLogger(__name__)
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
import os, ast
import json, requests
clean code, PROXY now works
2021-06-13 12:54:33 -04:00
# User for different functions that need to be running: APRS, Proxy, etc
import threading
# Hotspot Proxy stuff
from hotspot_proxy_v2 import Proxy
push changes
2018-12-27 15:31:08 -05:00
# Does anybody read this stuff? There's a PEP somewhere that says I should do this.
__author__ = 'Cortney T. Buffington, N0MJS'
update copyrights
2019-03-05 20:01:07 -05:00
__copyright__ = 'Copyright (c) 2016-2019 Cortney T. Buffington, N0MJS and the K0USY Group'
push changes
2018-12-27 15:31:08 -05:00
__credits__ = 'Colin Durbridge, G4EML, Steve Zingman, N4IRS; Mike Zingman, N4IRR; Jonathan Naylor, G4KLX; Hans Barthen, DL5DI; Torsten Shultze, DG1HT'
__license__ = 'GNU GPLv3'
__maintainer__ = 'Cort Buffington, N0MJS'
__email__ = 'n0mjs@me.com'
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
##import os, ast
def download_config(L_CONFIG_FILE, cli_file):
user_man_url = L_CONFIG_FILE['USER_MANAGER']['URL']
shared_secret = str(sha256(L_CONFIG_FILE['USER_MANAGER']['SHARED_SECRET'].encode()).hexdigest())
config_check = {
'get_config':L_CONFIG_FILE['USER_MANAGER']['THIS_SERVER_NAME'],
'secret':shared_secret
}
json_object = json.dumps(config_check, indent = 4)
try:
req = requests.post(user_man_url, data=json_object, headers={'Content-Type': 'application/json'})
resp = json.loads(req.text)
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
## print(resp)
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
## print(type(resp))
## conf = config.build_config(resp['config'])
## print(conf)
## with open('/tmp/conf_telp.cfg', 'w') as f:
## f.write(str(resp['config']))
## print(resp)
iterate_config = resp['peers'].copy()
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
## iterate_masters = resp['masters'].copy()
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
corrected_config = resp['config'].copy()
corrected_config['SYSTEMS'] = {}
corrected_config['LOGGER'] = {}
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
iterate_config.update(resp['masters'].copy())
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
corrected_config['SYSTEMS'].update(iterate_config)
corrected_config['LOGGER'].update(L_CONFIG_FILE['LOGGER'])
corrected_config['USER_MANAGER'].update(L_CONFIG_FILE['USER_MANAGER'])
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
## iterate_config.update(resp['masters'].copy())
finish MASTERS managment
2021-06-13 10:39:14 -04:00
## print(iterate_config)
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
## print(iterate_config)
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
## corrected_config = CONFIG_FILE.copy()
## print(corrected_config)
## print()
## print(iterate_config['config']['SYSTEMS'])
## print(resp['config'])
## print((iterate_config['test']))
## print(corrected_config)
corrected_config['GLOBAL']['TG1_ACL'] = config.acl_build(corrected_config['GLOBAL']['TG1_ACL'], 16776415)
corrected_config['GLOBAL']['TG2_ACL'] = config.acl_build(corrected_config['GLOBAL']['TG2_ACL'], 16776415)
corrected_config['GLOBAL']['REG_ACL'] = config.acl_build(corrected_config['GLOBAL']['REG_ACL'], 16776415)
corrected_config['GLOBAL']['SUB_ACL'] = config.acl_build(corrected_config['GLOBAL']['SUB_ACL'], 16776415)
## corrected_config['SYSTEMS'] = {}
for i in iterate_config:
finish MASTERS managment
2021-06-13 10:39:14 -04:00
## print(i)
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
## corrected_config['SYSTEMS'][i] = {}
if iterate_config[i]['MODE'] == 'MASTER' or iterate_config[i]['MODE'] == 'PROXY':
corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415)
finish MASTERS managment
2021-06-13 10:39:14 -04:00
if iterate_config[i]['MODE'] == 'OPENBRIDGE':
corrected_config['SYSTEMS'][i]['NETWORK_ID'] = int(iterate_config[i]['NETWORK_ID']).to_bytes(4, 'big')
if iterate_config[i]['MODE'] == 'PEER' or iterate_config[i]['MODE'] == 'XLXPEER':
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
corrected_config['SYSTEMS'][i]['RADIO_ID'] = int(iterate_config[i]['RADIO_ID']).to_bytes(4, 'big')
corrected_config['SYSTEMS'][i]['TG1_ACL'] = config.acl_build(iterate_config[i]['TG1_ACL'], 16776415)
corrected_config['SYSTEMS'][i]['TG2_ACL'] = config.acl_build(iterate_config[i]['TG2_ACL'], 16776415)
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
corrected_config['SYSTEMS'][i]['MASTER_SOCKADDR'] = tuple(iterate_config[i]['MASTER_SOCKADDR'])
corrected_config['SYSTEMS'][i]['SOCK_ADDR'] = tuple(iterate_config[i]['SOCK_ADDR'])
finish MASTERS managment
2021-06-13 10:39:14 -04:00
if iterate_config[i]['MODE'] == 'PEER':
corrected_config['SYSTEMS'][i].update({'STATS':{
'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES
'CONNECTED': None,
'PINGS_SENT': 0,
'PINGS_ACKD': 0,
'NUM_OUTSTANDING': 0,
'PING_OUTSTANDING': False,
'LAST_PING_TX_TIME': 0,
'LAST_PING_ACK_TIME': 0,
}})
if iterate_config[i]['MODE'] == 'XLXPEER':
corrected_config['SYSTEMS'][i].update({'XLXSTATS': {
'CONNECTION': 'NO', # NO, RTPL_SENT, AUTHENTICATED, CONFIG-SENT, YES
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
'CONNECTED': None,
'PINGS_SENT': 0,
'PINGS_ACKD': 0,
'NUM_OUTSTANDING': 0,
'PING_OUTSTANDING': False,
'LAST_PING_TX_TIME': 0,
'LAST_PING_ACK_TIME': 0,
}})
finish MASTERS managment
2021-06-13 10:39:14 -04:00
corrected_config['SYSTEMS'][i]['USE_ACL'] = iterate_config[i]['USE_ACL']
corrected_config['SYSTEMS'][i]['SUB_ACL'] = config.acl_build(iterate_config[i]['SUB_ACL'], 16776415)
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
## print(iterate_masters)
## for i in iterate_masters:
## iterate_masters['SYSTEMS']
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
## config.process_acls(corrected_config)
sucessful MASTER get from brifge.py
2021-06-12 13:07:10 -04:00
print(corrected_config['SYSTEMS'])
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
print('-------')
return corrected_config
# For exception, write blank dict
except requests.ConnectionError:
logger.error('Config server unreachable, defaulting to local config')
return config.build_config(cli_file)
clean code, PROXY now works
2021-06-13 12:54:33 -04:00
# From hotspot_proxy2, FreeDMR
def hotspot_proxy(listen_port, port_start, port_stop):
Master = "127.0.0.1"
ListenPort = listen_port
DestportStart = port_start
DestPortEnd = port_stop
Timeout = 30
Stats = True
Debug = False
BlackList = [1234567]
CONNTRACK = {}
for port in range(DestportStart,DestPortEnd+1,1):
CONNTRACK[port] = False
reactor.listenUDP(ListenPort,Proxy(Master,ListenPort,CONNTRACK,BlackList,Timeout,Debug,DestportStart,DestPortEnd))
def loopingErrHandle(failure):
logger.error('(GLOBAL) STOPPING REACTOR TO AVOID MEMORY LEAK: Unhandled error innowtimed loop.\n {}'.format(failure))
reactor.stop()
def stats():
count = 0
nowtime = time()
for port in CONNTRACK:
if CONNTRACK[port]:
count = count+1
totalPorts = DestPortEnd - DestportStart
freePorts = totalPorts - count
print("{} ports out of {} in use ({} free)".format(count,totalPorts,freePorts))
if Stats == True:
stats_task = task.LoopingCall(stats)
statsa = stats_task.start(30)
statsa.addErrback(loopingErrHandle)
push changes
2018-12-27 15:31:08 -05:00
# Module gobal varaibles
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
# Dictionary for dynamically mapping unit (subscriber) to a system.
# This is for pruning unit-to-uint calls to not broadcast once the
# target system for a unit is identified
# format 'unit_id': ('SYSTEM', time)
UNIT_MAP = {}
push changes
2018-12-27 15:31:08 -05:00
# Timed loop used for reporting HBP status
#
# REPORT BASED ON THE TYPE SELECTED IN THE MAIN CONFIG FILE
def config_reports(_config, _factory):
if True: #_config['REPORTS']['REPORT']:
def reporting_loop(logger, _server):
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(REPORT) Periodic reporting loop started')
push changes
2018-12-27 15:31:08 -05:00
_server.send_config()
_server.send_bridge()
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.info('(REPORT) HBlink TCP reporting server configured')
push changes
2018-12-27 15:31:08 -05:00
report_server = _factory(_config)
report_server.clients = []
reactor.listenTCP(_config['REPORTS']['REPORT_PORT'], report_server)
reporting = task.LoopingCall(reporting_loop, logger, report_server)
reporting.start(_config['REPORTS']['REPORT_INTERVAL'])
return report_server
# Import Bridging rules
# Note: A stanza *must* exist for any MASTER or CLIENT configured in the main
# configuration file and listed as "active". It can be empty,
# but it has to exist.
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
def make_bridges(_rules):
push changes
2018-12-27 15:31:08 -05:00
# Convert integer GROUP ID numbers from the config into hex strings
# we need to send in the actual data packets.
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
for _bridge in _rules:
for _system in _rules[_bridge]:
push changes
2018-12-27 15:31:08 -05:00
if _system['SYSTEM'] not in CONFIG['SYSTEMS']:
provide meaninful output when a bridge is configured for a system not in the main configuration
2019-02-02 17:46:40 -05:00
sys.exit('ERROR: Conference bridge "{}" references a system named "{}" that is not enabled in the main configuration'.format(_bridge, _system['SYSTEM']))
push changes
2018-12-27 15:31:08 -05:00
Mostly kinda works now
2019-01-04 16:32:13 -05:00
_system['TGID'] = bytes_3(_system['TGID'])
push changes
2018-12-27 15:31:08 -05:00
for i, e in enumerate(_system['ON']):
Mostly kinda works now
2019-01-04 16:32:13 -05:00
_system['ON'][i] = bytes_3(_system['ON'][i])
push changes
2018-12-27 15:31:08 -05:00
for i, e in enumerate(_system['OFF']):
Mostly kinda works now
2019-01-04 16:32:13 -05:00
_system['OFF'][i] = bytes_3(_system['OFF'][i])
push changes
2018-12-27 15:31:08 -05:00
_system['TIMEOUT'] = _system['TIMEOUT']*60
if _system['ACTIVE'] == True:
_system['TIMER'] = time() + _system['TIMEOUT']
else:
_system['TIMER'] = time()
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
return _rules
push changes
2018-12-27 15:31:08 -05:00
# Run this every minute for rule timer updates
def rule_timer_loop():
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
global UNIT_MAP
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(ROUTER) routerHBP Rule timer loop started')
push changes
2018-12-27 15:31:08 -05:00
_now = time()
for _bridge in BRIDGES:
for _system in BRIDGES[_bridge]:
if _system['TO_TYPE'] == 'ON':
if _system['ACTIVE'] == True:
if _system['TIMER'] < _now:
_system['ACTIVE'] = False
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.info('(ROUTER) Conference Bridge TIMEOUT: DEACTIVATE System: %s, Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
push changes
2018-12-27 15:31:08 -05:00
else:
timeout_in = _system['TIMER'] - _now
seconds formatting to 2 decimal places
2019-01-09 11:10:29 -05:00
logger.info('(ROUTER) Conference Bridge ACTIVE (ON timer running): System: %s Bridge: %s, TS: %s, TGID: %s, Timeout in: %.2fs,', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']), timeout_in)
push changes
2018-12-27 15:31:08 -05:00
elif _system['ACTIVE'] == False:
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(ROUTER) Conference Bridge INACTIVE (no change): System: %s Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
push changes
2018-12-27 15:31:08 -05:00
elif _system['TO_TYPE'] == 'OFF':
if _system['ACTIVE'] == False:
if _system['TIMER'] < _now:
_system['ACTIVE'] = True
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.info('(ROUTER) Conference Bridge TIMEOUT: ACTIVATE System: %s, Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
push changes
2018-12-27 15:31:08 -05:00
else:
timeout_in = _system['TIMER'] - _now
seconds formatting to 2 decimal places
2019-01-09 11:10:29 -05:00
logger.info('(ROUTER) Conference Bridge INACTIVE (OFF timer running): System: %s Bridge: %s, TS: %s, TGID: %s, Timeout in: %.2fs,', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']), timeout_in)
push changes
2018-12-27 15:31:08 -05:00
elif _system['ACTIVE'] == True:
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(ROUTER) Conference Bridge ACTIVE (no change): System: %s Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
push changes
2018-12-27 15:31:08 -05:00
else:
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(ROUTER) Conference Bridge NO ACTION: System: %s, Bridge: %s, TS: %s, TGID: %s', _system['SYSTEM'], _bridge, _system['TS'], int_id(_system['TGID']))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
_then = _now - 60
remove_list = []
for unit in UNIT_MAP:
if UNIT_MAP[unit][1] < (_then):
remove_list.append(unit)
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
for unit in remove_list:
del UNIT_MAP[unit]
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
logger.debug('Removed unit(s) %s from UNIT_MAP', remove_list)
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
push changes
2018-12-27 15:31:08 -05:00
if CONFIG['REPORTS']['REPORT']:
Mostly kinda works now
2019-01-04 16:32:13 -05:00
report_server.send_clients(b'bridge updated')
push changes
2018-12-27 15:31:08 -05:00
# run this every 10 seconds to trim orphaned stream ids
def stream_trimmer_loop():
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(ROUTER) Trimming inactive stream IDs from system lists')
push changes
2018-12-27 15:31:08 -05:00
_now = time()
for system in systems:
# HBP systems, master and peer
if CONFIG['SYSTEMS'][system]['MODE'] != 'OPENBRIDGE':
for slot in range(1,3):
_slot = systems[system].STATUS[slot]
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
# RX slot check
change how constants are imported
2018-12-27 15:36:32 -05:00
if _slot['RX_TYPE'] != HBPF_SLT_VTERM and _slot['RX_TIME'] < _now - 5:
_slot['RX_TYPE'] = HBPF_SLT_VTERM
seconds formatting to 2 decimal places
2019-01-09 11:10:29 -05:00
logger.info('(%s) *TIME OUT* RX STREAM ID: %s SUB: %s TGID %s, TS %s, Duration: %.2f', \
push changes
2018-12-27 15:31:08 -05:00
system, int_id(_slot['RX_STREAM_ID']), int_id(_slot['RX_RFS']), int_id(_slot['RX_TGID']), slot, _slot['RX_TIME'] - _slot['RX_START'])
if CONFIG['REPORTS']['REPORT']:
Mostly kinda works now
2019-01-04 16:32:13 -05:00
systems[system]._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(_slot['RX_STREAM_ID']), int_id(_slot['RX_PEER']), int_id(_slot['RX_RFS']), slot, int_id(_slot['RX_TGID']), _slot['RX_TIME'] - _slot['RX_START']).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
# TX slot check
change how constants are imported
2018-12-27 15:36:32 -05:00
if _slot['TX_TYPE'] != HBPF_SLT_VTERM and _slot['TX_TIME'] < _now - 5:
_slot['TX_TYPE'] = HBPF_SLT_VTERM
seconds formatting to 2 decimal places
2019-01-09 11:10:29 -05:00
logger.info('(%s) *TIME OUT* TX STREAM ID: %s SUB: %s TGID %s, TS %s, Duration: %.2f', \
push changes
2018-12-27 15:31:08 -05:00
system, int_id(_slot['TX_STREAM_ID']), int_id(_slot['TX_RFS']), int_id(_slot['TX_TGID']), slot, _slot['TX_TIME'] - _slot['TX_START'])
if CONFIG['REPORTS']['REPORT']:
Mostly kinda works now
2019-01-04 16:32:13 -05:00
systems[system]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(_slot['TX_STREAM_ID']), int_id(_slot['TX_PEER']), int_id(_slot['TX_RFS']), slot, int_id(_slot['TX_TGID']), _slot['TX_TIME'] - _slot['TX_START']).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
# OBP systems
# We can't delete items from a dicationry that's being iterated, so we have to make a temporarly list of entrys to remove later
if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
remove_list = []
for stream_id in systems[system].STATUS:
if systems[system].STATUS[stream_id]['LAST'] < _now - 5:
remove_list.append(stream_id)
for stream_id in remove_list:
if stream_id in systems[system].STATUS:
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
_stream = systems[system].STATUS[stream_id]
_sysconfig = CONFIG['SYSTEMS'][system]
save of incremental work
2020-03-03 17:51:50 -05:00
if systems[system].STATUS[stream_id]['ACTIVE']:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
logger.info('(%s) *TIME OUT* STREAM ID: %s SUB: %s PEER: %s TYPE: %s DST ID: %s TS 1 Duration: %.2f', \
update
2020-02-18 13:11:19 -05:00
system, int_id(stream_id), get_alias(int_id(_stream['RFS']), subscriber_ids), get_alias(int_id(_sysconfig['NETWORK_ID']), peer_ids), _stream['TYPE'], get_alias(int_id(_stream['DST']), talkgroup_ids), _stream['LAST'] - _stream['START'])
push changes
2018-12-27 15:31:08 -05:00
if CONFIG['REPORTS']['REPORT']:
update
2020-02-18 13:11:19 -05:00
if _stream['TYPE'] == 'GROUP':
systems[system]._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(stream_id), int_id(_sysconfig['NETWORK_ID']), int_id(_stream['RFS']), 1, int_id(_stream['DST']), _stream['LAST'] - _stream['START']).encode(encoding='utf-8', errors='ignore'))
elif _stream['TYPE'] == 'UNIT':
systems[system]._report.send_bridgeEvent('UNIT VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(system, int_id(stream_id), int_id(_sysconfig['NETWORK_ID']), int_id(_stream['RFS']), 1, int_id(_stream['DST']), _stream['LAST'] - _stream['START']).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
removed = systems[system].STATUS.pop(stream_id)
else:
logger.error('(%s) Attemped to remove OpenBridge Stream ID %s not in the Stream ID list: %s', system, int_id(stream_id), [id for id in systems[system].STATUS])
class routerOBP(OPENBRIDGE):
def __init__(self, _name, _config, _report):
OPENBRIDGE.__init__(self, _name, _config, _report)
Inbound OBP Unit calls
2019-12-04 18:23:04 -05:00
self.name = _name
push changes
2018-12-27 15:31:08 -05:00
self.STATUS = {}
Inbound OBP Unit calls
2019-12-04 18:23:04 -05:00
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
# list of self._targets for unit (subscriber, private) calls
self._targets = []
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Working Code - REPORT ERRORS!
2019-12-03 14:11:01 -05:00
def group_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data):
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
pkt_time = time()
dmrpkt = _data[20:53]
_bits = _data[15]
# Is this a new call stream?
if (_stream_id not in self.STATUS):
# This is a new call stream
self.STATUS[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
update
2020-02-18 13:11:19 -05:00
'TYPE': 'GROUP',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
}
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# If we can, use the LC from the voice header as to keep all options intact
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
decoded = decode.voice_head_term(dmrpkt)
self.STATUS[_stream_id]['LC'] = decoded['LC']
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# If we don't have a voice header then don't wait to decode the Embedded LC
# just make a new one from the HBP header. This is good enough, and it saves lots of time
else:
self.STATUS[_stream_id]['LC'] = LC_OPT + _dst_id + _rf_src
update
2020-02-17 20:18:11 -05:00
logger.info('(%s) *GROUP CALL START* OBP STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('GROUP VOICE,START,RX,{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
self.STATUS[_stream_id]['LAST'] = pkt_time
for _bridge in BRIDGES:
for _system in BRIDGES[_bridge]:
if (_system['SYSTEM'] == self._system and _system['TGID'] == _dst_id and _system['TS'] == _slot and _system['ACTIVE'] == True):
for _target in BRIDGES[_bridge]:
if (_target['SYSTEM'] != self._system) and (_target['ACTIVE']):
_target_status = systems[_target['SYSTEM']].STATUS
_target_system = self._CONFIG['SYSTEMS'][_target['SYSTEM']]
if _target_system['MODE'] == 'OPENBRIDGE':
# Is this a new call stream on the target?
if (_stream_id not in _target_status):
# This is a new call stream on the target
_target_status[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
fixing typos on obp call tracking
2020-02-19 14:27:37 -05:00
'TYPE': 'GROUP',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
}
# Generate LCs (full and EMB) for the TX stream
dst_lc = b''.join([self.STATUS[_stream_id]['LC'][0:3], _target['TGID'], _rf_src])
_target_status[_stream_id]['H_LC'] = bptc.encode_header_lc(dst_lc)
_target_status[_stream_id]['T_LC'] = bptc.encode_terminator_lc(dst_lc)
_target_status[_stream_id]['EMB_LC'] = bptc.encode_emblc(dst_lc)
logger.info('(%s) Conference Bridge: %s, Call Bridged to OBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
if CONFIG['REPORTS']['REPORT']:
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])).encode(encoding='utf-8', errors='ignore'))
# Record the time of this packet so we can later identify a stale stream
_target_status[_stream_id]['LAST'] = pkt_time
# Clear the TS bit -- all OpenBridge streams are effectively on TS1
_tmp_bits = _bits & ~(1 << 7)
# Assemble transmit HBP packet header
_tmp_data = b''.join([_data[:8], _target['TGID'], _data[11:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
# MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
# MUST RE-WRITE DESTINATION TGID IF DIFFERENT
# if _dst_id != rule['DST_GROUP']:
dmrbits = bitarray(endian='big')
dmrbits.frombytes(dmrpkt)
# Create a voice header packet (FULL LC)
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
dmrbits = _target_status[_stream_id]['H_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['H_LC'][98:197]
# Create a voice terminator packet (FULL LC)
elif _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VTERM:
dmrbits = _target_status[_stream_id]['T_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['T_LC'][98:197]
if CONFIG['REPORTS']['REPORT']:
call_duration = pkt_time - _target_status[_stream_id]['START']
Fixed typo in call state tracking.
2020-03-16 09:38:16 -04:00
_target_status[_stream_id]['ACTIVE'] = False
save of incremental work
2020-03-03 17:51:50 -05:00
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration).encode(encoding='utf-8', errors='ignore'))
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# Create a Burst B-E packet (Embedded LC)
elif _dtype_vseq in [1,2,3,4]:
dmrbits = dmrbits[0:116] + _target_status[_stream_id]['EMB_LC'][_dtype_vseq] + dmrbits[148:264]
dmrpkt = dmrbits.tobytes()
_tmp_data = b''.join([_tmp_data, dmrpkt])
else:
# BEGIN CONTENTION HANDLING
#
# The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
# From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
# From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
# From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
# From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
# The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
#
if ((_target['TGID'] != _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
continue
if ((_target['TGID'] != _target_status[_target['TS']]['TX_TGID']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']))
continue
if (_target['TGID'] == _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < STREAM_TO):
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
continue
if (_target['TGID'] == _target_status[_target['TS']]['TX_TGID']) and (_rf_src != _target_status[_target['TS']]['TX_RFS']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < STREAM_TO):
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']), int_id(_target_status[_target['TS']]['TX_RFS']))
continue
# Is this a new call stream?
if (_target_status[_target['TS']]['TX_STREAM_ID'] != _stream_id):
# Record the DST TGID and Stream ID
_target_status[_target['TS']]['TX_START'] = pkt_time
_target_status[_target['TS']]['TX_TGID'] = _target['TGID']
_target_status[_target['TS']]['TX_STREAM_ID'] = _stream_id
_target_status[_target['TS']]['TX_RFS'] = _rf_src
_target_status[_target['TS']]['TX_PEER'] = _peer_id
# Generate LCs (full and EMB) for the TX stream
dst_lc = b''.join([self.STATUS[_stream_id]['LC'][0:3], _target['TGID'], _rf_src])
_target_status[_target['TS']]['TX_H_LC'] = bptc.encode_header_lc(dst_lc)
_target_status[_target['TS']]['TX_T_LC'] = bptc.encode_terminator_lc(dst_lc)
_target_status[_target['TS']]['TX_EMB_LC'] = bptc.encode_emblc(dst_lc)
logger.debug('(%s) Generating TX FULL and EMB LCs for HomeBrew destination: System: %s, TS: %s, TGID: %s', self._system, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
logger.info('(%s) Conference Bridge: %s, Call Bridged to HBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
if CONFIG['REPORTS']['REPORT']:
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])).encode(encoding='utf-8', errors='ignore'))
# Set other values for the contention handler to test next time there is a frame to forward
_target_status[_target['TS']]['TX_TIME'] = pkt_time
_target_status[_target['TS']]['TX_TYPE'] = _dtype_vseq
# Handle any necessary re-writes for the destination
if _system['TS'] != _target['TS']:
_tmp_bits = _bits ^ 1 << 7
else:
_tmp_bits = _bits
# Assemble transmit HBP packet header
_tmp_data = b''.join([_data[:8], _target['TGID'], _data[11:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
# MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
# MUST RE-WRITE DESTINATION TGID IF DIFFERENT
# if _dst_id != rule['DST_GROUP']:
dmrbits = bitarray(endian='big')
dmrbits.frombytes(dmrpkt)
# Create a voice header packet (FULL LC)
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
dmrbits = _target_status[_target['TS']]['TX_H_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_H_LC'][98:197]
# Create a voice terminator packet (FULL LC)
elif _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VTERM:
dmrbits = _target_status[_target['TS']]['TX_T_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_T_LC'][98:197]
if CONFIG['REPORTS']['REPORT']:
call_duration = pkt_time - _target_status[_target['TS']]['TX_START']
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration).encode(encoding='utf-8', errors='ignore'))
# Create a Burst B-E packet (Embedded LC)
elif _dtype_vseq in [1,2,3,4]:
dmrbits = dmrbits[0:116] + _target_status[_target['TS']]['TX_EMB_LC'][_dtype_vseq] + dmrbits[148:264]
dmrpkt = dmrbits.tobytes()
_tmp_data = b''.join([_tmp_data, dmrpkt, b'\x00\x00']) # Add two bytes of nothing since OBP doesn't include BER & RSSI bytes #_data[53:55]
# Transmit the packet to the destination system
systems[_target['SYSTEM']].send_system(_tmp_data)
#logger.debug('(%s) Packet routed by bridge: %s to system: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
# Final actions - Is this a voice terminator?
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM):
call_duration = pkt_time - self.STATUS[_stream_id]['START']
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
logger.info('(%s) *GROUP CALL END* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %.2f', \
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration).encode(encoding='utf-8', errors='ignore'))
Fixed assignment typos [_stream_id]['ACTIVE']: False to [_stream_id]['ACTIVE'] = False Thanks, Steve!
2020-03-18 10:32:32 -04:00
self.STATUS[_stream_id]['ACTIVE'] = False
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
logger.debug('(%s) OpenBridge sourced call stream end, remove terminated Stream ID: %s', self._system, int_id(_stream_id))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
def unit_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data):
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
global UNIT_MAP
push changes
2018-12-27 15:31:08 -05:00
pkt_time = time()
dmrpkt = _data[20:53]
Updates
2018-12-27 17:46:35 -05:00
_bits = _data[15]
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
# Make/update this unit in the UNIT_MAP cache
UNIT_MAP[_rf_src] = (self.name, pkt_time)
# Is this a new call stream?
inbound OBP Unit calls
2019-12-04 18:25:50 -05:00
if (_stream_id not in self.STATUS):
# This is a new call stream
self.STATUS[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
update
2020-02-18 13:11:19 -05:00
'TYPE': 'UNIT',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True
inbound OBP Unit calls
2019-12-04 18:25:50 -05:00
}
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
# Create a destination list for the call:
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
if _dst_id in UNIT_MAP:
if UNIT_MAP[_dst_id][0] != self._system:
self._targets = [UNIT_MAP[_dst_id][0]]
else:
self._targets = []
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
logger.error('UNIT call to a subscriber on the same system, send nothing')
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
else:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
self._targets = list(UNIT)
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
self._targets.remove(self._system)
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
# This is a new call stream, so log & report
logger.info('(%s) *UNIT CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) UNIT: %s (%s), TS: %s, FORWARD: %s', \
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, self._targets)
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
if CONFIG['REPORTS']['REPORT']:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
self._report.send_bridgeEvent('UNIT VOICE,START,RX,{},{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), self._targets).encode(encoding='utf-8', errors='ignore'))
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
# Record the time of this packet so we can later identify a stale stream
self.STATUS[_stream_id]['LAST'] = pkt_time
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
for _target in self._targets:
_target_status = systems[_target].STATUS
_target_system = self._CONFIG['SYSTEMS'][_target]
if self._CONFIG['SYSTEMS'][_target]['MODE'] == 'OPENBRIDGE':
if (_stream_id not in _target_status):
# This is a new call stream on the target
_target_status[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
fixing typos on obp call tracking
2020-02-19 14:27:37 -05:00
'TYPE': 'UNIT',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
}
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
logger.info('(%s) Unit call bridged to OBP System: %s TS: %s, TGID: %s', self._system, _target, _slot if _target_system['BOTH_SLOTS'] else 1, int_id(_dst_id))
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
if CONFIG['REPORTS']['REPORT']:
systems[_target]._report.send_bridgeEvent('UNIT VOICE,START,TX,{},{},{},{},{},{}'.format(_target, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
# Record the time of this packet so we can later identify a stale stream
_target_status[_stream_id]['LAST'] = pkt_time
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
# Clear the TS bit and follow propper OBP definition, unless "BOTH_SLOTS" is set. This only works for unit calls.
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
if _target_system['BOTH_SLOTS']:
_tmp_bits = _bits
else:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
_tmp_bits = _bits & ~(1 << 7)
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
# Assemble transmit HBP packet
_tmp_data = b''.join([_data[:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
_data = b''.join([_tmp_data, dmrpkt])
save of incremental work
2020-03-03 17:51:50 -05:00
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM):
Fixed assignment typos [_stream_id]['ACTIVE']: False to [_stream_id]['ACTIVE'] = False Thanks, Steve!
2020-03-18 10:32:32 -04:00
_target_status[_stream_id]['ACTIVE'] = False
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
else:
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
# BEGIN STANDARD CONTENTION HANDLING
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
#
# The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
# From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
# From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
# From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
# From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
# The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
#
update
2020-02-18 13:11:19 -05:00
'''
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if ((_dst_id != _target_status[_slot]['RX_TGID']) and ((pkt_time - _target_status[_slot]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
Update bridge.py
2019-12-04 20:05:48 -05:00
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['RX_TGID']))
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
continue
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if ((_dst_id != _target_status[_slot]['TX_TGID']) and ((pkt_time - _target_status[_slot]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
Update bridge.py
2019-12-04 20:05:48 -05:00
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['TX_TGID']))
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
continue
update
2020-02-18 13:11:19 -05:00
'''
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if (_dst_id == _target_status[_slot]['RX_TGID']) and ((pkt_time - _target_status[_slot]['RX_TIME']) < STREAM_TO):
Update bridge.py
2019-12-04 20:05:48 -05:00
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['RX_TGID']))
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
continue
if (_dst_id == _target_status[_slot]['TX_TGID']) and (_rf_src != _target_status[_slot]['TX_RFS']) and ((pkt_time - _target_status[_slot]['TX_TIME']) < STREAM_TO):
Update bridge.py
2019-12-04 20:05:48 -05:00
if self.STATUS[_stream_id]['CONTENTION'] == False:
self.STATUS[_stream_id]['CONTENTION'] = True
logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target, _slot, int_id(_target_status[_slot]['TX_TGID']), int_id(_target_status[_slot]['TX_RFS']))
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
continue
# Record target information if this is a new call stream?
Update bridge.py
2019-12-04 20:02:24 -05:00
if (_stream_id not in self.STATUS):
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
# Record the DST TGID and Stream ID
_target_status[_slot]['TX_START'] = pkt_time
_target_status[_slot]['TX_TGID'] = _dst_id
_target_status[_slot]['TX_STREAM_ID'] = _stream_id
_target_status[_slot]['TX_RFS'] = _rf_src
_target_status[_slot]['TX_PEER'] = _peer_id
logger.info('(%s) Unit call bridged to HBP System: %s TS: %s, UNIT: %s', self._system, _target, _slot, int_id(_dst_id))
if CONFIG['REPORTS']['REPORT']:
systems[_target]._report.send_bridgeEvent('UNIT VOICE,START,TX,{},{},{},{},{},{}'.format(_target, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
# Set other values for the contention handler to test next time there is a frame to forward
_target_status[_slot]['TX_TIME'] = pkt_time
_target_status[_slot]['TX_TYPE'] = _dtype_vseq
#send the call:
systems[_target].send_system(_data)
save of incremental work
2020-03-03 17:51:50 -05:00
if _target_system['MODE'] == 'OPENBRIDGE':
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM):
if (_stream_id in _target_status):
_target_status.pop(_stream_id)
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
# Final actions - Is this a voice terminator?
Update bridge.py
2019-12-04 20:06:57 -05:00
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM):
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
self._targets = []
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
call_duration = pkt_time - self.STATUS[_stream_id]['START']
Adding inbound OBP Processing
2019-12-04 18:12:26 -05:00
logger.info('(%s) *UNIT CALL END* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) UNIT %s (%s), TS %s, Duration: %.2f', \
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('UNIT VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
push changes
2018-12-27 15:31:08 -05:00
if _call_type == 'group':
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self.group_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data)
elif _call_type == 'unit':
self.unit_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data)
elif _call_type == 'vscsbk':
logger.debug('CSBK recieved, but HBlink does not process them currently')
else:
logger.error('Unknown call type recieved -- not processed')
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
class routerHBP(HBSYSTEM):
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
def __init__(self, _name, _config, _report):
HBSYSTEM.__init__(self, _name, _config, _report)
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
self.name = _name
push changes
2018-12-27 15:31:08 -05:00
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
# list of self._targets for unit (subscriber, private) calls
self._targets = []
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# Status information for the system, TS1 & TS2
# 1 & 2 are "timeslot"
# In TX_EMB_LC, 2-5 are burst B-E
self.STATUS = {
1: {
'RX_START': time(),
'TX_START': time(),
Update bridge.py
2020-02-09 18:08:32 -05:00
'RX_SEQ': 0,
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
'RX_RFS': b'\x00',
'TX_RFS': b'\x00',
'RX_PEER': b'\x00',
'TX_PEER': b'\x00',
'RX_STREAM_ID': b'\x00',
'TX_STREAM_ID': b'\x00',
'RX_TGID': b'\x00\x00\x00',
'TX_TGID': b'\x00\x00\x00',
'RX_TIME': time(),
'TX_TIME': time(),
'RX_TYPE': HBPF_SLT_VTERM,
'TX_TYPE': HBPF_SLT_VTERM,
'RX_LC': b'\x00',
'TX_H_LC': b'\x00',
'TX_T_LC': b'\x00',
'TX_EMB_LC': {
1: b'\x00',
2: b'\x00',
3: b'\x00',
4: b'\x00',
}
},
2: {
'RX_START': time(),
'TX_START': time(),
Update bridge.py
2020-02-09 18:08:32 -05:00
'RX_SEQ': 0,
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
'RX_RFS': b'\x00',
'TX_RFS': b'\x00',
'RX_PEER': b'\x00',
'TX_PEER': b'\x00',
'RX_STREAM_ID': b'\x00',
'TX_STREAM_ID': b'\x00',
'RX_TGID': b'\x00\x00\x00',
'TX_TGID': b'\x00\x00\x00',
'RX_TIME': time(),
'TX_TIME': time(),
'RX_TYPE': HBPF_SLT_VTERM,
'TX_TYPE': HBPF_SLT_VTERM,
'RX_LC': b'\x00',
'TX_H_LC': b'\x00',
'TX_T_LC': b'\x00',
'TX_EMB_LC': {
1: b'\x00',
2: b'\x00',
3: b'\x00',
4: b'\x00',
}
}
}
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
def group_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data):
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
global UNIT_MAP
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
pkt_time = time()
dmrpkt = _data[20:53]
_bits = _data[15]
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# Make/update an entry in the UNIT_MAP for this subscriber
UNIT_MAP[_rf_src] = (self.name, pkt_time)
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# Is this a new call stream?
if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
if (self.STATUS[_slot]['RX_TYPE'] != HBPF_SLT_VTERM) and (pkt_time < (self.STATUS[_slot]['RX_TIME'] + STREAM_TO)) and (_rf_src != self.STATUS[_slot]['RX_RFS']):
logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s PEER: %s <TO> TGID %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_peer_id), int_id(_dst_id), _slot)
return
# This is a new call stream
self.STATUS[_slot]['RX_START'] = pkt_time
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
logger.info('(%s) *GROUP CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s', \
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('GROUP VOICE,START,RX,{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
# If we can, use the LC from the voice header as to keep all options intact
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
decoded = decode.voice_head_term(dmrpkt)
self.STATUS[_slot]['RX_LC'] = decoded['LC']
# If we don't have a voice header then don't wait to decode it from the Embedded LC
# just make a new one from the HBP header. This is good enough, and it saves lots of time
else:
self.STATUS[_slot]['RX_LC'] = LC_OPT + _dst_id + _rf_src
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
for _bridge in BRIDGES:
for _system in BRIDGES[_bridge]:
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if (_system['SYSTEM'] == self._system and _system['TGID'] == _dst_id and _system['TS'] == _slot and _system['ACTIVE'] == True):
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
for _target in BRIDGES[_bridge]:
if _target['SYSTEM'] != self._system:
if _target['ACTIVE']:
push changes
2018-12-27 15:31:08 -05:00
_target_status = systems[_target['SYSTEM']].STATUS
_target_system = self._CONFIG['SYSTEMS'][_target['SYSTEM']]
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
push changes
2018-12-27 15:31:08 -05:00
if _target_system['MODE'] == 'OPENBRIDGE':
# Is this a new call stream on the target?
if (_stream_id not in _target_status):
# This is a new call stream on the target
_target_status[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
update
2020-02-18 13:11:19 -05:00
'TYPE': 'GROUP',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True,
push changes
2018-12-27 15:31:08 -05:00
}
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
# Generate LCs (full and EMB) for the TX stream
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
dst_lc = b''.join([self.STATUS[_slot]['RX_LC'][0:3], _target['TGID'], _rf_src])
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
_target_status[_stream_id]['H_LC'] = bptc.encode_header_lc(dst_lc)
_target_status[_stream_id]['T_LC'] = bptc.encode_terminator_lc(dst_lc)
_target_status[_stream_id]['EMB_LC'] = bptc.encode_emblc(dst_lc)
push changes
2018-12-27 15:31:08 -05:00
logger.info('(%s) Conference Bridge: %s, Call Bridged to OBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
Add TX Call reporting
2019-01-07 16:08:29 -05:00
if CONFIG['REPORTS']['REPORT']:
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])).encode(encoding='utf-8', errors='ignore'))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
push changes
2018-12-27 15:31:08 -05:00
# Record the time of this packet so we can later identify a stale stream
_target_status[_stream_id]['LAST'] = pkt_time
# Clear the TS bit -- all OpenBridge streams are effectively on TS1
_tmp_bits = _bits & ~(1 << 7)
# Assemble transmit HBP packet header
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
_tmp_data = b''.join([_data[:8], _target['TGID'], _data[11:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
push changes
2018-12-27 15:31:08 -05:00
# MUST TEST FOR NEW STREAM AND IF SO, RE-WRITE THE LC FOR THE TARGET
# MUST RE-WRITE DESTINATION TGID IF DIFFERENT
# if _dst_id != rule['DST_GROUP']:
dmrbits = bitarray(endian='big')
dmrbits.frombytes(dmrpkt)
# Create a voice header packet (FULL LC)
change how constants are imported
2018-12-27 15:36:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
push changes
2018-12-27 15:31:08 -05:00
dmrbits = _target_status[_stream_id]['H_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['H_LC'][98:197]
# Create a voice terminator packet (FULL LC)
change how constants are imported
2018-12-27 15:36:32 -05:00
elif _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VTERM:
push changes
2018-12-27 15:31:08 -05:00
dmrbits = _target_status[_stream_id]['T_LC'][0:98] + dmrbits[98:166] + _target_status[_stream_id]['T_LC'][98:197]
Add TX Call reporting
2019-01-07 16:08:29 -05:00
if CONFIG['REPORTS']['REPORT']:
call_duration = pkt_time - _target_status[_stream_id]['START']
Fixed assignment typos [_stream_id]['ACTIVE']: False to [_stream_id]['ACTIVE'] = False Thanks, Steve!
2020-03-18 10:32:32 -04:00
_target_status[_stream_id]['ACTIVE'] = False
Add TX Call reporting
2019-01-07 16:08:29 -05:00
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
# Create a Burst B-E packet (Embedded LC)
elif _dtype_vseq in [1,2,3,4]:
dmrbits = dmrbits[0:116] + _target_status[_stream_id]['EMB_LC'][_dtype_vseq] + dmrbits[148:264]
dmrpkt = dmrbits.tobytes()
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
_tmp_data = b''.join([_tmp_data, dmrpkt])
push changes
2018-12-27 15:31:08 -05:00
else:
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# BEGIN STANDARD CONTENTION HANDLING
push changes
2018-12-27 15:31:08 -05:00
#
# The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
# From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
# From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
# From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
# From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
# The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
#
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if ((_target['TGID'] != _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
logger.info('(%s) Call not routed to TGID %s, target active or in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
push changes
2018-12-27 15:31:08 -05:00
continue
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if ((_target['TGID'] != _target_status[_target['TS']]['TX_TGID']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
logger.info('(%s) Call not routed to TGID%s, target in group hangtime: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']))
push changes
2018-12-27 15:31:08 -05:00
continue
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if (_target['TGID'] == _target_status[_target['TS']]['RX_TGID']) and ((pkt_time - _target_status[_target['TS']]['RX_TIME']) < STREAM_TO):
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
logger.info('(%s) Call not routed to TGID%s, matching call already active on target: HBSystem: %s, TS: %s, TGID: %s', self._system, int_id(_target['TGID']), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['RX_TGID']))
push changes
2018-12-27 15:31:08 -05:00
continue
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
if (_target['TGID'] == _target_status[_target['TS']]['TX_TGID']) and (_rf_src != _target_status[_target['TS']]['TX_RFS']) and ((pkt_time - _target_status[_target['TS']]['TX_TIME']) < STREAM_TO):
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
Revert "Update bridge.py" This reverts commit 0a2edc09a53d748143dd8e55e38ac58208a3f6ef.
2019-12-04 19:59:55 -05:00
logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, TGID: %s, SUB: %s', self._system, int_id(_rf_src), _target['SYSTEM'], _target['TS'], int_id(_target_status[_target['TS']]['TX_TGID']), int_id(_target_status[_target['TS']]['TX_RFS']))
push changes
2018-12-27 15:31:08 -05:00
continue
# Is this a new call stream?
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
push changes
2018-12-27 15:31:08 -05:00
# Record the DST TGID and Stream ID
_target_status[_target['TS']]['TX_START'] = pkt_time
_target_status[_target['TS']]['TX_TGID'] = _target['TGID']
_target_status[_target['TS']]['TX_STREAM_ID'] = _stream_id
_target_status[_target['TS']]['TX_RFS'] = _rf_src
_target_status[_target['TS']]['TX_PEER'] = _peer_id
# Generate LCs (full and EMB) for the TX stream
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
dst_lc = self.STATUS[_slot]['RX_LC'][0:3] + _target['TGID'] + _rf_src
push changes
2018-12-27 15:31:08 -05:00
_target_status[_target['TS']]['TX_H_LC'] = bptc.encode_header_lc(dst_lc)
_target_status[_target['TS']]['TX_T_LC'] = bptc.encode_terminator_lc(dst_lc)
_target_status[_target['TS']]['TX_EMB_LC'] = bptc.encode_emblc(dst_lc)
logger.debug('(%s) Generating TX FULL and EMB LCs for HomeBrew destination: System: %s, TS: %s, TGID: %s', self._system, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
logger.info('(%s) Conference Bridge: %s, Call Bridged to HBP System: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
if CONFIG['REPORTS']['REPORT']:
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,START,TX,{},{},{},{},{},{}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID'])).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
# Set other values for the contention handler to test next time there is a frame to forward
_target_status[_target['TS']]['TX_TIME'] = pkt_time
_target_status[_target['TS']]['TX_TYPE'] = _dtype_vseq
# Handle any necessary re-writes for the destination
if _system['TS'] != _target['TS']:
_tmp_bits = _bits ^ 1 << 7
else:
_tmp_bits = _bits
# Assemble transmit HBP packet header
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
_tmp_data = b''.join([_data[:8], _target['TGID'], _data[11:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
push changes
2018-12-27 15:31:08 -05:00
dmrbits = bitarray(endian='big')
dmrbits.frombytes(dmrpkt)
# Create a voice header packet (FULL LC)
change how constants are imported
2018-12-27 15:36:32 -05:00
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD:
push changes
2018-12-27 15:31:08 -05:00
dmrbits = _target_status[_target['TS']]['TX_H_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_H_LC'][98:197]
# Create a voice terminator packet (FULL LC)
change how constants are imported
2018-12-27 15:36:32 -05:00
elif _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VTERM:
push changes
2018-12-27 15:31:08 -05:00
dmrbits = _target_status[_target['TS']]['TX_T_LC'][0:98] + dmrbits[98:166] + _target_status[_target['TS']]['TX_T_LC'][98:197]
if CONFIG['REPORTS']['REPORT']:
Add TX Call reporting
2019-01-07 16:08:29 -05:00
call_duration = pkt_time - _target_status[_target['TS']]['TX_START']
systems[_target['SYSTEM']]._report.send_bridgeEvent('GROUP VOICE,END,TX,{},{},{},{},{},{},{:.2f}'.format(_target['SYSTEM'], int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _target['TS'], int_id(_target['TGID']), call_duration).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
# Create a Burst B-E packet (Embedded LC)
elif _dtype_vseq in [1,2,3,4]:
dmrbits = dmrbits[0:116] + _target_status[_target['TS']]['TX_EMB_LC'][_dtype_vseq] + dmrbits[148:264]
dmrpkt = dmrbits.tobytes()
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
_tmp_data = b''.join([_tmp_data, dmrpkt, _data[53:55]])
push changes
2018-12-27 15:31:08 -05:00
# Transmit the packet to the destination system
systems[_target['SYSTEM']].send_system(_tmp_data)
#logger.debug('(%s) Packet routed by bridge: %s to system: %s TS: %s, TGID: %s', self._system, _bridge, _target['SYSTEM'], _target['TS'], int_id(_target['TGID']))
save of incremental work
2020-03-03 17:51:50 -05:00
if _target_system['MODE'] == 'OPENBRIDGE':
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != HBPF_SLT_VTERM):
if (_stream_id in _target_status):
_target_status.pop(_stream_id)
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# Final actions - Is this a voice terminator?
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != HBPF_SLT_VTERM):
call_duration = pkt_time - self.STATUS[_slot]['RX_START']
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
logger.info('(%s) *GROUP CALL END* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) TGID %s (%s), TS %s, Duration: %.2f', \
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('GROUP VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration).encode(encoding='utf-8', errors='ignore'))
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
#
# Begin in-band signalling for call end. This has nothign to do with routing traffic directly.
#
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
# Iterate the rules dictionary
push changes
2018-12-27 15:31:08 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
for _bridge in BRIDGES:
for _system in BRIDGES[_bridge]:
if _system['SYSTEM'] == self._system:
# TGID matches a rule source, reset its timer
if _slot == _system['TS'] and _dst_id == _system['TGID'] and ((_system['TO_TYPE'] == 'ON' and (_system['ACTIVE'] == True)) or (_system['TO_TYPE'] == 'OFF' and _system['ACTIVE'] == False)):
_system['TIMER'] = pkt_time + _system['TIMEOUT']
logger.info('(%s) Transmission match for Bridge: %s. Reset timeout to %s', self._system, _bridge, _system['TIMER'])
# TGID matches an ACTIVATION trigger
if (_dst_id in _system['ON'] or _dst_id in _system['RESET']) and _slot == _system['TS']:
# Set the matching rule as ACTIVE
if _dst_id in _system['ON']:
if _system['ACTIVE'] == False:
_system['ACTIVE'] = True
_system['TIMER'] = pkt_time + _system['TIMEOUT']
logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
# Cancel the timer if we've enabled an "OFF" type timeout
if _system['TO_TYPE'] == 'OFF':
_system['TIMER'] = pkt_time
logger.info('(%s) Bridge: %s set to "OFF" with an on timer rule: timeout timer cancelled', self._system, _bridge)
# Reset the timer for the rule
if _system['ACTIVE'] == True and _system['TO_TYPE'] == 'ON':
_system['TIMER'] = pkt_time + _system['TIMEOUT']
logger.info('(%s) Bridge: %s, timeout timer reset to: %s', self._system, _bridge, _system['TIMER'] - pkt_time)
# TGID matches an DE-ACTIVATION trigger
if (_dst_id in _system['OFF'] or _dst_id in _system['RESET']) and _slot == _system['TS']:
# Set the matching rule as ACTIVE
if _dst_id in _system['OFF']:
if _system['ACTIVE'] == True:
_system['ACTIVE'] = False
logger.info('(%s) Bridge: %s, connection changed to state: %s', self._system, _bridge, _system['ACTIVE'])
# Cancel the timer if we've enabled an "ON" type timeout
if _system['TO_TYPE'] == 'ON':
_system['TIMER'] = pkt_time
logger.info('(%s) Bridge: %s set to ON with and "OFF" timer rule: timeout timer cancelled', self._system, _bridge)
# Reset the timer for the rule
if _system['ACTIVE'] == False and _system['TO_TYPE'] == 'OFF':
_system['TIMER'] = pkt_time + _system['TIMEOUT']
logger.info('(%s) Bridge: %s, timeout timer reset to: %s', self._system, _bridge, _system['TIMER'] - pkt_time)
# Cancel the timer if we've enabled an "ON" type timeout
if _system['ACTIVE'] == True and _system['TO_TYPE'] == 'ON' and _dst_group in _system['OFF']:
_system['TIMER'] = pkt_time
logger.info('(%s) Bridge: %s set to ON with and "OFF" timer rule: timeout timer cancelled', self._system, _bridge)
#
# END IN-BAND SIGNALLING
#
# Mark status variables for use later
self.STATUS[_slot]['RX_PEER'] = _peer_id
self.STATUS[_slot]['RX_SEQ'] = _seq
self.STATUS[_slot]['RX_RFS'] = _rf_src
self.STATUS[_slot]['RX_TYPE'] = _dtype_vseq
self.STATUS[_slot]['RX_TGID'] = _dst_id
self.STATUS[_slot]['RX_TIME'] = pkt_time
self.STATUS[_slot]['RX_STREAM_ID'] = _stream_id
def unit_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data):
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
global UNIT_MAP
push changes
2018-12-27 15:31:08 -05:00
pkt_time = time()
dmrpkt = _data[20:53]
Updates
2018-12-27 17:46:35 -05:00
_bits = _data[15]
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# Make/update this unit in the UNIT_MAP cache
UNIT_MAP[_rf_src] = (self.name, pkt_time)
Track subscribers this is not yet really useable, just getting the mechanics started
2019-11-29 11:35:27 -05:00
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
# Is this a new call stream?
if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# Collision in progress, bail out!
if (self.STATUS[_slot]['RX_TYPE'] != HBPF_SLT_VTERM) and (pkt_time < (self.STATUS[_slot]['RX_TIME'] + STREAM_TO)) and (_rf_src != self.STATUS[_slot]['RX_RFS']):
logger.warning('(%s) Packet received with STREAM ID: %s <FROM> SUB: %s PEER: %s <TO> UNIT %s, SLOT %s collided with existing call', self._system, int_id(_stream_id), int_id(_rf_src), int_id(_peer_id), int_id(_dst_id), _slot)
return
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
# Create a destination list for the call:
if _dst_id in UNIT_MAP:
if UNIT_MAP[_dst_id][0] != self._system:
self._targets = [UNIT_MAP[_dst_id][0]]
else:
self._targets = []
update
2020-02-18 13:11:19 -05:00
logger.error('UNIT call to a subscriber on the same system, send nothing')
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
else:
update
2020-02-18 13:11:19 -05:00
self._targets = list(UNIT)
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
self._targets.remove(self._system)
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# This is a new call stream, so log & report
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
self.STATUS[_slot]['RX_START'] = pkt_time
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
logger.info('(%s) *UNIT CALL START* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) UNIT: %s (%s), TS: %s, FORWARD: %s', \
update sample config
2020-02-17 20:20:10 -05:00
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, self._targets)
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
if CONFIG['REPORTS']['REPORT']:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
self._report.send_bridgeEvent('UNIT VOICE,START,RX,{},{},{},{},{},{},{}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), self._targets).encode(encoding='utf-8', errors='ignore'))
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
for _target in self._targets:
update sample config
2020-02-17 20:20:10 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
_target_status = systems[_target].STATUS
_target_system = self._CONFIG['SYSTEMS'][_target]
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
if self._CONFIG['SYSTEMS'][_target]['MODE'] == 'OPENBRIDGE':
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
if (_stream_id not in _target_status):
# This is a new call stream on the target
_target_status[_stream_id] = {
'START': pkt_time,
'CONTENTION':False,
'RFS': _rf_src,
update
2020-02-18 13:11:19 -05:00
'TYPE': 'UNIT',
save of incremental work
2020-03-03 17:51:50 -05:00
'DST': _dst_id,
'ACTIVE': True
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
}
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
logger.info('(%s) Unit call bridged to OBP System: %s TS: %s, UNIT: %s', self._system, _target, _slot if _target_system['BOTH_SLOTS'] else 1, int_id(_dst_id))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
if CONFIG['REPORTS']['REPORT']:
Working Code - REPORT ERRORS!
2019-12-03 14:11:01 -05:00
systems[_target]._report.send_bridgeEvent('UNIT VOICE,START,TX,{},{},{},{},{},{}'.format(_target, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
# Record the time of this packet so we can later identify a stale stream
_target_status[_stream_id]['LAST'] = pkt_time
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
# Clear the TS bit and follow propper OBP definition, unless "BOTH_SLOTS" is set. This only works for unit calls.
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
if _target_system['BOTH_SLOTS']:
_tmp_bits = _bits
else:
READY FOR TESTING unit calls should be working on HBP and OBP systems. Also adds the ability to send TS data in OBP for unit calls to preserve timeslot routing for unit calls.
2020-03-15 22:23:03 -04:00
_tmp_bits = _bits & ~(1 << 7)
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Fixed Private Call Bridging when BOTH_SLOTS selected This is the problem where bridge.py is told to send private calls marked with EITHER timeslot over openbridge. Packets weren't assembled correctly when the BOTH_SLOTS option was set True in the hblink configuraiton file. d: # modified: bridge.py # modified: hblink.py # # Changes not staged for commit: # modified: .gitattributes # modified: Dockerfile # modified: voice_lib.py #
2020-04-27 12:01:54 -04:00
# Assemble transmit HBP packet
_tmp_data = b''.join([_data[:15], _tmp_bits.to_bytes(1, 'big'), _data[16:20]])
_data = b''.join([_tmp_data, dmrpkt])
save of incremental work
2020-03-03 17:51:50 -05:00
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM):
Fixed assignment typos [_stream_id]['ACTIVE']: False to [_stream_id]['ACTIVE'] = False Thanks, Steve!
2020-03-18 10:32:32 -04:00
_target_status[_stream_id]['ACTIVE'] = False
Working Code - REPORT ERRORS!
2019-12-03 14:11:01 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
else:
# BEGIN STANDARD CONTENTION HANDLING
#
# The rules for each of the 4 "ifs" below are listed here for readability. The Frame To Send is:
# From a different group than last RX from this HBSystem, but it has been less than Group Hangtime
# From a different group than last TX to this HBSystem, but it has been less than Group Hangtime
# From the same group as the last RX from this HBSystem, but from a different subscriber, and it has been less than stream timeout
# From the same group as the last TX to this HBSystem, but from a different subscriber, and it has been less than stream timeout
# The "continue" at the end of each means the next iteration of the for loop that tests for matching rules
#
update
2020-02-17 20:18:11 -05:00
'''
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
if ((_dst_id != _target_status[_slot]['RX_TGID']) and ((pkt_time - _target_status[_slot]['RX_TIME']) < _target_system['GROUP_HANGTIME'])):
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
logger.info('(%s) Call not routed to destination %s, target active or in group hangtime: HBSystem: %s, TS: %s, DEST: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['RX_TGID']))
continue
if ((_dst_id != _target_status[_slot]['TX_TGID']) and ((pkt_time - _target_status[_slot]['TX_TIME']) < _target_system['GROUP_HANGTIME'])):
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
logger.info('(%s) Call not routed to destination %s, target in group hangtime: HBSystem: %s, TS: %s, DEST: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['TX_TGID']))
continue
update
2020-02-17 20:18:11 -05:00
'''
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
if (_dst_id == _target_status[_slot]['RX_TGID']) and ((pkt_time - _target_status[_slot]['RX_TIME']) < STREAM_TO):
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
logger.info('(%s) Call not routed to destination %s, matching call already active on target: HBSystem: %s, TS: %s, DEST: %s', self._system, int_id(_dst_id), _target, _slot, int_id(_target_status[_slot]['RX_TGID']))
continue
if (_dst_id == _target_status[_slot]['TX_TGID']) and (_rf_src != _target_status[_slot]['TX_RFS']) and ((pkt_time - _target_status[_slot]['TX_TIME']) < STREAM_TO):
if _frame_type == HBPF_DATA_SYNC and _dtype_vseq == HBPF_SLT_VHEAD and self.STATUS[_slot]['RX_STREAM_ID'] != _stream_id:
logger.info('(%s) Call not routed for subscriber %s, call route in progress on target: HBSystem: %s, TS: %s, DEST: %s, SUB: %s', self._system, int_id(_rf_src), _target, _slot, int_id(_target_status[_slot]['TX_TGID']), int_id(_target_status[_slot]['TX_RFS']))
continue
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# Record target information if this is a new call stream?
if (_stream_id != self.STATUS[_slot]['RX_STREAM_ID']):
# Record the DST TGID and Stream ID
_target_status[_slot]['TX_START'] = pkt_time
_target_status[_slot]['TX_TGID'] = _dst_id
_target_status[_slot]['TX_STREAM_ID'] = _stream_id
_target_status[_slot]['TX_RFS'] = _rf_src
_target_status[_slot]['TX_PEER'] = _peer_id
untested OBP support added Push is just to sync with a test system.
2019-12-02 09:30:25 -05:00
logger.info('(%s) Unit call bridged to HBP System: %s TS: %s, UNIT: %s', self._system, _target, _slot, int_id(_dst_id))
if CONFIG['REPORTS']['REPORT']:
Working Code - REPORT ERRORS!
2019-12-03 14:11:01 -05:00
systems[_target]._report.send_bridgeEvent('UNIT VOICE,START,TX,{},{},{},{},{},{}'.format(_target, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id)).encode(encoding='utf-8', errors='ignore'))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
unit to unit calls, with contention working - HBSystems only This appears to work, but no openbridge support yet.
2019-12-01 14:27:07 -05:00
# Set other values for the contention handler to test next time there is a frame to forward
_target_status[_slot]['TX_TIME'] = pkt_time
_target_status[_slot]['TX_TYPE'] = _dtype_vseq
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
#send the call:
systems[_target].send_system(_data)
update
2020-02-18 13:11:19 -05:00
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
# Final actions - Is this a voice terminator?
if (_frame_type == HBPF_DATA_SYNC) and (_dtype_vseq == HBPF_SLT_VTERM) and (self.STATUS[_slot]['RX_TYPE'] != HBPF_SLT_VTERM):
Works, but no contention handler Private call forwarding works, with destionation routing cache, but no contention handler yet.
2019-12-01 12:20:14 -05:00
self._targets = []
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
call_duration = pkt_time - self.STATUS[_slot]['RX_START']
logger.info('(%s) *UNIT CALL END* STREAM ID: %s SUB: %s (%s) PEER: %s (%s) UNIT %s (%s), TS %s, Duration: %.2f', \
self._system, int_id(_stream_id), get_alias(_rf_src, subscriber_ids), int_id(_rf_src), get_alias(_peer_id, peer_ids), int_id(_peer_id), get_alias(_dst_id, talkgroup_ids), int_id(_dst_id), _slot, call_duration)
if CONFIG['REPORTS']['REPORT']:
self._report.send_bridgeEvent('UNIT VOICE,END,RX,{},{},{},{},{},{},{:.2f}'.format(self._system, int_id(_stream_id), int_id(_peer_id), int_id(_rf_src), _slot, int_id(_dst_id), call_duration).encode(encoding='utf-8', errors='ignore'))
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
incremental update - Not Working the program runs at ths point, logging is updated for group calls, no errors in unit sectinon, but no contention handler and send routines not yet built.
2019-12-01 11:06:08 -05:00
# Mark status variables for use later
self.STATUS[_slot]['RX_PEER'] = _peer_id
self.STATUS[_slot]['RX_SEQ'] = _seq
self.STATUS[_slot]['RX_RFS'] = _rf_src
self.STATUS[_slot]['RX_TYPE'] = _dtype_vseq
self.STATUS[_slot]['RX_TGID'] = _dst_id
self.STATUS[_slot]['RX_TIME'] = pkt_time
self.STATUS[_slot]['RX_STREAM_ID'] = _stream_id
OBP Support Added -- CURRENTLY UNTESTED OpenBridge support added, but not yet tested. This push is so that I can pick up my updates on another computer to test.
2019-12-02 09:29:52 -05:00
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
def dmrd_received(self, _peer_id, _rf_src, _dst_id, _seq, _slot, _call_type, _frame_type, _dtype_vseq, _stream_id, _data):
push changes
2018-12-27 15:31:08 -05:00
if _call_type == 'group':
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
self.group_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data)
elif _call_type == 'unit':
update sample config
2020-02-17 20:20:10 -05:00
if self._system not in UNIT:
update
2020-02-18 13:11:19 -05:00
logger.error('(%s) *UNIT CALL NOT FORWARDED* UNIT calling is disabled for this system (INGRESS)', self._system)
update sample config
2020-02-17 20:20:10 -05:00
else:
add configuration to enable unit routing
2019-12-02 20:49:37 -05:00
self.unit_received(_peer_id, _rf_src, _dst_id, _seq, _slot, _frame_type, _dtype_vseq, _stream_id, _data)
fix typo
2020-11-22 01:42:05 -05:00
elif _call_type == 'vcsbk':
Separate UNIT from GROUP Calls Initial framework for processing UNIT calls
2019-11-28 11:49:32 -05:00
logger.debug('CSBK recieved, but HBlink does not process them currently')
else:
logger.error('Unknown call type recieved -- not processed')
push changes
2018-12-27 15:31:08 -05:00
#
# Socket-based reporting section
#
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
class bridgeReportFactory(reportFactory):
push changes
2018-12-27 15:31:08 -05:00
def send_bridge(self):
Mostly kinda works now
2019-01-04 16:32:13 -05:00
serialized = pickle.dumps(BRIDGES, protocol=2) #.decode("utf-8", errors='ignore')
push changes
2018-12-27 15:31:08 -05:00
self.send_clients(REPORT_OPCODES['BRIDGE_SND']+serialized)
def send_bridgeEvent(self, _data):
Mostly kinda works now
2019-01-04 16:32:13 -05:00
if isinstance(_data, str):
string testing for reporting push
2019-01-09 11:12:41 -05:00
_data = _data.decode('utf-8', error='ignore')
push changes
2018-12-27 15:31:08 -05:00
self.send_clients(REPORT_OPCODES['BRDG_EVENT']+_data)
#************************************************
# MAIN PROGRAM LOOP STARTS HERE
#************************************************
if __name__ == '__main__':
import argparse
import sys
import os
import signal
# Change the current directory to the location of the application
os.chdir(os.path.dirname(os.path.realpath(sys.argv[0])))
# CLI argument parser - handles picking up the config file from the command line, and sending a "help" message
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config', action='store', dest='CONFIG_FILE', help='/full/path/to/config.file (usually hblink.cfg)')
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
parser.add_argument('-r', '--rules', action='store', dest='RULES_FILE', help='/full/path/to/rules.file (usually rules.py)')
push changes
2018-12-27 15:31:08 -05:00
parser.add_argument('-l', '--logging', action='store', dest='LOG_LEVEL', help='Override config file logging level.')
cli_args = parser.parse_args()
# Ensure we have a path for the config file, if one wasn't specified, then use the default (top of file)
if not cli_args.CONFIG_FILE:
cli_args.CONFIG_FILE = os.path.dirname(os.path.abspath(__file__))+'/hblink.cfg'
# Call the external routine to build the configuration dictionary
config and peer managment, masters WIP
2021-06-09 16:03:00 -04:00
LOCAL_CONFIG = config.build_config(cli_args.CONFIG_FILE)
#print(LOCAL_CONFIG)
#print(download_config(LOCAL_CONFIG))
#if LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']:
#print(download_config(LOCAL_CONFIG)['config'])
## CONFIG = config.build_config(download_config(LOCAL_CONFIG))
#CONFIG = download_config(LOCAL_CONFIG)
#if not LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']:
## print(download_config(LOCAL_CONFIG)['config'])
## CONFIG = config.build_config(cli_args.CONFIG_FILE)
#print((CONFIG))
## config.process_acls(LOCAL_CONFIG)
if LOCAL_CONFIG['USER_MANAGER']['REMOTE_CONFIG_ENABLED']:
CONFIG = download_config(LOCAL_CONFIG, cli_args.CONFIG_FILE)
else:
CONFIG = config.build_config(cli_args.CONFIG_FILE)
## print(CONFIG)
push changes
2018-12-27 15:31:08 -05:00
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
# Ensure we have a path for the rules file, if one wasn't specified, then use the default (top of file)
if not cli_args.RULES_FILE:
cli_args.RULES_FILE = os.path.dirname(os.path.abspath(__file__))+'/rules.py'
push changes
2018-12-27 15:31:08 -05:00
# Start the system logger
if cli_args.LOG_LEVEL:
CONFIG['LOGGER']['LOG_LEVEL'] = cli_args.LOG_LEVEL
logger = log.config_logging(CONFIG['LOGGER'])
update coypright years
2020-03-16 10:35:28 -04:00
logger.info('\n\nCopyright (c) 2013, 2014, 2015, 2016, 2018, 2019, 2020\n\tThe Regents of the K0USY Group. All rights reserved.\n')
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(GLOBAL) Logging system started, anything from here on gets logged')
push changes
2018-12-27 15:31:08 -05:00
# Set up the signal handler
def sig_handler(_signal, _frame):
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.info('(GLOBAL) SHUTDOWN: CONFBRIDGE IS TERMINATING WITH SIGNAL %s', str(_signal))
push changes
2018-12-27 15:31:08 -05:00
hblink_handler(_signal, _frame)
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.info('(GLOBAL) SHUTDOWN: ALL SYSTEM HANDLERS EXECUTED - STOPPING REACTOR')
push changes
2018-12-27 15:31:08 -05:00
reactor.stop()
# Set signal handers so that we can gracefully exit if need be
for sig in [signal.SIGINT, signal.SIGTERM]:
signal.signal(sig, sig_handler)
Mostly kinda works now
2019-01-04 16:32:13 -05:00
push changes
2018-12-27 15:31:08 -05:00
# Create the name-number mapping dictionaries
peer_ids, subscriber_ids, talkgroup_ids = mk_aliases(CONFIG)
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
# Import the ruiles file as a module, and create BRIDGES from it
spec = importlib.util.spec_from_file_location("module.name", cli_args.RULES_FILE)
rules_module = importlib.util.module_from_spec(spec)
try:
spec.loader.exec_module(rules_module)
logger.info('(ROUTER) Routing bridges file found and bridges imported: %s', cli_args.RULES_FILE)
except (ImportError, FileNotFoundError):
sys.exit('(ROUTER) TERMINATING: Routing bridges file not found or invalid: {}'.format(cli_args.RULES_FILE))
push changes
2018-12-27 15:31:08 -05:00
# Build the routing rules file
Add ability to specify a rules file on the CLI
2019-10-07 10:52:33 -04:00
BRIDGES = make_bridges(rules_module.BRIDGES)
add configuration to enable unit routing
2019-12-02 20:49:37 -05:00
# Get rule parameter for private calls
Working Code - REPORT ERRORS!
2019-12-03 14:11:01 -05:00
UNIT = rules_module.UNIT
push changes
2018-12-27 15:31:08 -05:00
# INITIALIZE THE REPORTING LOOP
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
if CONFIG['REPORTS']['REPORT']:
fix typo
2019-01-07 11:50:33 -05:00
report_server = config_reports(CONFIG, bridgeReportFactory)
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
else:
report_server = None
logger.info('(REPORT) TCP Socket reporting not configured')
push changes
2018-12-27 15:31:08 -05:00
# HBlink instance creation
clean code, PROXY now works
2021-06-13 12:54:33 -04:00
logger.info('(GLOBAL) HBNet \'bridge.py\' -- SYSTEM STARTING...')
# Generate list of Enabled MODE: PROXY masters
proxy_master_list = []
for i in CONFIG['SYSTEMS']:
if CONFIG['SYSTEMS'][i]['ENABLED'] == True:
if CONFIG['SYSTEMS'][i]['MODE'] == 'PROXY':
proxy_master_list.append(i)
# Start proxy as a thread (if enabled in config) for each set of MASTERs
for m in proxy_master_list:
if CONFIG['SYSTEMS'][m]['EXTERNAL_PROXY_SCRIPT'] == False:
proxy_thread = threading.Thread(target=hotspot_proxy, args=(CONFIG['SYSTEMS'][m]['EXTERNAL_PORT'],CONFIG['SYSTEMS'][m]['INTERNAL_PORT_START'],CONFIG['SYSTEMS'][m]['INTERNAL_PORT_STOP'],))
proxy_thread.daemon = True
proxy_thread.start()
logger.info('Started thread for PROXY for MASTER set: ' + m)
#Build Master configs from list
for i in proxy_master_list:
n_systems = CONFIG['SYSTEMS'][i]['INTERNAL_PORT_STOP'] - CONFIG['SYSTEMS'][i]['INTERNAL_PORT_START']
n_count = 0
while n_count < n_systems:
CONFIG['SYSTEMS'].update({i + '-' + str(n_count): {
'MODE': 'MASTER',
'ENABLED': True,
'STATIC_APRS_POSITION_ENABLED': CONFIG['SYSTEMS'][i]['STATIC_APRS_POSITION_ENABLED'],
'REPEAT': CONFIG['SYSTEMS'][i]['REPEAT'],
'MAX_PEERS': 1,
'IP': '127.0.0.1',
'PORT': CONFIG['SYSTEMS'][i]['INTERNAL_PORT_START'] + n_count,
'PASSPHRASE': CONFIG['SYSTEMS'][i]['PASSPHRASE'],
'GROUP_HANGTIME': CONFIG['SYSTEMS'][i]['GROUP_HANGTIME'],
'USE_ACL': CONFIG['SYSTEMS'][i]['USE_ACL'],
'REG_ACL': CONFIG['SYSTEMS'][i]['REG_ACL'],
'SUB_ACL': CONFIG['SYSTEMS'][i]['SUB_ACL'],
'TGID_TS1_ACL': CONFIG['SYSTEMS'][i]['TG1_ACL'],
'TGID_TS2_ACL': CONFIG['SYSTEMS'][i]['TG2_ACL']
}})
CONFIG['SYSTEMS'][i + '-' + str(n_count)].update({'PEERS': {}})
systems[i + '-' + str(n_count)] = routerHBP(i + '-' + str(n_count), CONFIG, report_server)
n_count = n_count + 1
# Remove original MASTER stanza to prevent errors
CONFIG['SYSTEMS'].pop(i)
logger.info('Generated MASTER instances for proxy set: ' + i)
push changes
2018-12-27 15:31:08 -05:00
for system in CONFIG['SYSTEMS']:
if CONFIG['SYSTEMS'][system]['ENABLED']:
if CONFIG['SYSTEMS'][system]['MODE'] == 'OPENBRIDGE':
systems[system] = routerOBP(system, CONFIG, report_server)
else:
systems[system] = routerHBP(system, CONFIG, report_server)
reactor.listenUDP(CONFIG['SYSTEMS'][system]['PORT'], systems[system], interface=CONFIG['SYSTEMS'][system]['IP'])
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.debug('(GLOBAL) %s instance created: %s, %s', CONFIG['SYSTEMS'][system]['MODE'], system, systems[system])
push changes
2018-12-27 15:31:08 -05:00
def loopingErrHandle(failure):
Large updates, mostly contact to join
2019-01-07 10:44:36 -05:00
logger.error('(GLOBAL) STOPPING REACTOR TO AVOID MEMORY LEAK: Unhandled error in timed loop.\n %s', failure)
push changes
2018-12-27 15:31:08 -05:00
reactor.stop()
# Initialize the rule timer -- this if for user activated stuff
rule_timer_task = task.LoopingCall(rule_timer_loop)
rule_timer = rule_timer_task.start(60)
rule_timer.addErrback(loopingErrHandle)
# Initialize the stream trimmer
stream_trimmer_task = task.LoopingCall(stream_trimmer_loop)
stream_trimmer = stream_trimmer_task.start(5)
stream_trimmer.addErrback(loopingErrHandle)
clean code, PROXY now works
2021-06-13 12:54:33 -04:00
logger.info('Unit calls will be bridged to: ' + str(UNIT))
print(CONFIG['SYSTEMS'])
download burnlist on start
2021-06-03 16:38:47 -04:00
# Download burn list
with open(CONFIG['USER_MANAGER']['BURN_FILE'], 'w') as f:
f.write(str(download_burnlist(CONFIG)))
push changes
2018-12-27 15:31:08 -05:00
reactor.run()
Reference in New Issue Copy Permalink