def start(args):
receiver = Receiver('', args.address, args.port)
sender = Sender(args.address, args.port)
receiver.start()
sender.start()
receiver.join()
sender.join()
def emulate(args):
'''
Starts the Sender/Receiver process threads, sleeps for
args.RUNTIME, and terminates both threads. Returns a tuple of
lists: (s_log, r_log), where s_log is sender's log and r_log is
receiver's log.
'''
args.SENDER_TIMEOUT = float(args.SENDER_TIMEOUT)
args.RUNTIME = float(args.RUNTIME)
assert args.SENDER_TIMEOUT > 0
assert args.RUNTIME > 0
s = Sender(args.SENDER_TIMEOUT)
r = Receiver()
s.set_remote_endpoint(r)
r.set_remote_endpoint(s)
r.daemon = True
s.daemon = True
# Start the sender process.
s.start()
r.start()
try:
time.sleep(args.RUNTIME)
except KeyboardInterrupt:
print "Interrupted, terminating."
# We have to be careful with terminating the two threads, as they
# can only exit in specific states, and we can cause a deadlock.
# First, we terminate the sender, and wait for it to finish. Once
# this happens, we know that the receiver is in an ok terminal
# state, so we terminate it right after.
s.terminate()
s.join()
r.terminate()
r.join()
#s.log.append((([0,0], "S-TERM")))
#r.log.append((([0,0], "R-TERM")))
# At this point, the sender is not generating any more
# messages. But, we might have some oustanding messages in
# receiver's queue. So, process these, if any:
while not r.rx_queue.empty():
# Receive msg and generate any outstanding acks.
r.transition()
r.transition()
r.transition()
# Consume any outstanding acks on the sender's side.
s.consume_acks()
return (s.log, r.log)
def emulate(args):
'''
Starts the Sender/Receiver process threads, sleeps for
args.RUNTIME, and terminates both threads. Returns a tuple of
lists: (s_log, r_log), where s_log is sender's log and r_log is
receiver's log.
'''
args.SENDER_TIMEOUT = float(args.SENDER_TIMEOUT)
args.RUNTIME = float(args.RUNTIME)
assert args.SENDER_TIMEOUT > 0
assert args.RUNTIME > 0
s = Sender(args.SENDER_TIMEOUT)
r = Receiver()
s.set_remote_endpoint(r)
r.set_remote_endpoint(s)
r.daemon = True
s.daemon = True
# Start the sender process.
s.start()
r.start()
try:
time.sleep(args.RUNTIME)
except KeyboardInterrupt:
print "Interrupted, terminating."
# We have to be careful with terminating the two threads, as they
# can only exit in specific states, and we can cause a deadlock.
# First, we terminate the sender, and wait for it to finish. Once
# this happens, we know that the receiver is in an ok terminal
# state, so we terminate it right after.
s.terminate()
s.join()
r.terminate()
r.join()
#s.log.append((([0,0], "S-TERM")))
#r.log.append((([0,0], "R-TERM")))
# At this point, the sender is not generating any more
# messages. But, we might have some oustanding messages in
# receiver's queue. So, process these, if any:
while not r.rx_queue.empty():
# Receive msg and generate any outstanding acks.
r.transition()
r.transition()
r.transition()
# Consume any outstanding acks on the sender's side.
s.consume_acks()
return (s.log, r.log)
def ncd_loop(doInit, dlThreadNum):
ndutil.setTimezone()
#read config
cnfManager = CnfManager()
cnfManager.load('./ndc.cnf')
cnfData = cnfManager.getCnfData()
#check dirs
ndutil.enableDir(cnfData['dirWorking'])
ndutil.enableDir(cnfData['dirStore'])
#ndlcom
logger = Logger('nDroid-Crawler', cnfData['ndlComHost'], cnfData['ndlComPort'])
logger.logger('Initiating')
dbManager = DbManager(cnfData['dbHost'], cnfData['dbUser'], cnfData['dbPass'], cnfData['dbName'])
if doInit:
dbManager.create_table()
os.system('rm -f %s/*' % cnfData['dirWorking'])
os.system('rm -f %s/*' % cnfData['dirStore'])
#logger.logger('Customizing Spiders')
#spiderGenerator = SpiderGenerator('template', 'spider/spiders')
#for spider in cnfData['spiders']:
# spiderGenerator.gen_spider(spider, cnfData[spider]['startPage'], cnfData[spider]['stopPage'])
rpQueue = Queue()
pdQueue = Queue()
dpQueue = Queue()
pdLock = threading.Lock()
rpcMonitor = RpcMonitor(logger, cnfData['rpcPort'], cnfData['rpcAuth'], 'RpcMonitor')
rpcMonitor.setGlobalInfo(ndutil.getCurrentTimeStr(), 'Standalone', dlThreadNum)
rpcMonitor.setDownloadTotal(pdQueue.qsize())
rpcMonitor.setPdQueueSize(pdQueue.qsize())
botScheduler = BotScheduler(logger, rpcMonitor, cnfData['spiders'], cnfData['spiderCnfs'], 'BotScheduler')
receiver = Receiver(logger, rpcMonitor, rpQueue, cnfData['receiverPort'], 'Receiver')
preProcessor = PreProcessor(logger, rpcMonitor, rpQueue, pdQueue, pdLock, dbManager, 'PreProcessor')
downloader = Downloader([logger, rpcMonitor, pdQueue, dpQueue, pdLock, dlThreadNum, cnfData['dirWorking']], 'Downloader')
processor = Processor(logger, rpcMonitor, dpQueue, pdLock, pdQueue, dbManager, cnfData['dirWorking'], cnfData['dirStore'], 'Processor')
logger.logger('Starting Threads')
rpcMonitor.start()
botScheduler.start()
receiver.start()
preProcessor.start()
downloader.start()
processor.start()
processor.join()
downloader.join()
preProcessor.join()
receiver.join()
botScheduler.join()
rpcMonitor.join()
class Main(responder.API):
def __init__(self,
*,
port: str,
baudrate: int,
path: str = 'db',
bs: int = 32,
to: int = 5,
http: int = 8080):
super().__init__()
pid = os.getpid()
logger.info('*** NMEA Recorder startup (%d)' % pid)
self.process: Dict[str, int] = {}
self.process['main'] = pid
self.ppp: Dict[str, Patrol] = {}
self.ppp['main'] = Patrol(pid=pid)
self.ready: bool = True
self.g = GPS()
self.ws = WebsocketServer(debug=True)
self.qp = Queue()
self.dbsession = DBSession(path=pathlib.Path(path),
buffersize=bs,
timeout=to)
self.dbsession.start()
self.process[self.dbsession.name] = self.dbsession.pid
self.ppp[self.dbsession.name] = Patrol(pid=self.dbsession.pid)
self.receiver = Receiver(port=port, baudrate=baudrate, qp=self.qp)
self.receiver.start()
self.process[self.receiver.name] = self.receiver.pid
self.ppp[self.receiver.name] = Patrol(pid=self.receiver.pid)
self.mc = fromUDP(quePoint=self.qp, mcip='239.192.0.1', mcport=60001)
self.mc.start()
self.process[self.mc.name] = self.mc.pid
self.ppp[self.mc.name] = Patrol(pid=self.mc.pid)
self.main = Thread(target=self.collector, name='MainLoop', daemon=True)
self.main.start()
self.p = Thread(target=self.patrol, name='Patrol', daemon=True)
self.p.start()
for k, v in self.ppp.items():
v.start()
self.add_route('/ws', self.ws.wsserver, websocket=True)
self.add_route('/', self.top)
self.add_route('/main.js', self.mainJS)
self.add_route('/classes.js', self.classes)
self.add_event_handler('shutdown', self.cleanup) # notice!
self.run(address='0.0.0.0', port=http)
async def cleanup(self):
self.dbsession.join()
self.receiver.join()
self.mc.join()
logger.debug('... OK! shutdown')
def top(self, req: responder.Request, resp: responder.Response):
resp.content = self.template('index.html')
def classes(self, req: responder.Request, resp: responder.Response):
resp.content = self.template('classes.js')
def mainJS(self, req: responder.Request, resp: responder.Response):
resp.content = self.template('main.js')
def collector(self):
loop: bool = True
try:
while loop:
try:
raw: bytes = self.receiver.qp.get()
except (KeyboardInterrupt, ) as e:
break
else:
self.dbsession.qp.put(raw)
part = raw.split(b'*')
if len(part) > 1:
main = part[0][1:]
csum = int(part[1][:2], 16)
calc = reduce(xor, main, 0)
if calc != csum:
logger.error('!!! bad checksum')
else:
item = main.split(b',')
symbol = item[0]
prefix = symbol[0:2]
suffix = symbol[2:5]
if prefix == b'GP':
if suffix == b'RMC':
location = self.g.get(item=item)
ooo = {
'type': 'location',
'info': asdict(location)
}
self.ws.broadcast(message=json.dumps(ooo))
if location.valid:
print(location)
except KeyboardInterrupt as e:
loop = False
def patrol(self):
loop: bool = True
try:
while loop:
time.sleep(5)
stats = {'type': 'stats', 'info': {}}
# logger.info('--------------------------------------------------------------------')
for k, v in self.ppp.items():
stats['info'][k] = asdict(v.stats)
# logger.info(stats)
self.ws.broadcast(message='%s' % json.dumps(stats, indent=2))
except KeyboardInterrupt as e:
loop = False
class Main:
def __init__(self, UPLOAD=True, USE_GUI=True, USE_FILESTREAM=False):
self._socket_address = 'src/client/data_stream.sock'
self._receiver = Receiver(self._socket_address)
self._geo_listen = Geometry()
self._frequency = 15
if USE_FILESTREAM:
self._stream = FileStream(
"gen_data/downtown-east2_only_turn_sigs_speed_lims.json",
self._socket_address)
self._send_frequency = 1
self._speed_limit = None
self._speed_time = None
self._gui = None
self._forgot_signals_event = threading.Event()
self._speeding_event = threading.Event()
self._aggressive_event = threading.Event()
self._green_event = threading.Event()
self._green_event.direction = None
self._speeding_event.speed_limit = None
self._last_turn_forget = None
self._turn_analyzer = TurnSignalAnalyzer(self._forgot_signals_event)
self._speeding_analyzer = SpeedingAnalyzer(self._speeding_event)
self._green = Green(1, self._green_event)
self._aggressive_analyze = AggressiveAnalyzer(self._aggressive_event)
self._evaluatebox_last_time = None
if USE_GUI:
self._gui = GUI(self._receiver.is_alive)
t = threading.Thread(target=self._mainloop, daemon=True)
t.daemon = True
t.start()
if UPLOAD:
self._distributor = Distributor(
'/src/client/upload_stream.sock', self._send_frequency)
s = threading.Thread(target=self._sender, daemon=True)
s.start()
if USE_GUI:
self._gui.mainloop()
else:
self._receiver.join() # keep main from exiting
def _mainloop(self):
while True:
sleep(1 / self._frequency)
if self._evaluatebox_last_time is None or self._evaluatebox_last_time - time.time() > 5:
self._evaluatebox_last_time = time.time()
self._gui._evaluate_box.set_value(EvaluateBox.GOOD)
if self._gui is None:
continue
if Geometry._pos is not None:
if Geometry._inter_pos:
self._gui.set_coords(*Geometry._inter_pos)
else:
self._gui.set_coords(*Geometry._pos)
if Geometry._marker is not None:
self._gui.set_marker(Geometry._marker)
if self._forgot_signals_event.is_set():
self._last_turn_forget = time.time()
self._gui._turn_signal_sym.set_vibrate(10)
self._forgot_signals_event.clear()
if self._last_turn_forget is not None and time.time() - self._last_turn_forget > 3:
self._gui._turn_signal_sym.set_vibrate(0)
if self._evaluatebox_last_time is None or time.time() - \
self._evaluatebox_last_time > 3:
if self._aggressive_event.is_set():
self._gui._evaluate_box.set_value(EvaluateBox.BAD)
self._evaluatebox_last_time = time.time()
self._aggressive_event.clear()
elif self._green_event.is_set():
if self._green_event.direction == 'up':
self._gui._evaluate_box.set_value(EvaluateBox.GEAR_UP)
elif self._green_event.direction == 'down':
self._gui._evaluate_box.set_value(
EvaluateBox.GEAR_DOWN)
self._evaluatebox_last_time = time.time()
self._green_event.clear()
else:
self._gui._evaluate_box.set_value(EvaluateBox.GOOD)
if self._speed_limit != self._speeding_event.speed_limit:
self._speed_limit = self._speeding_event.speed_limit
self._gui.set_speed_limit(self._speed_limit)
if self._speeding_event.is_set():
offset = 3
self._gui._speed_limit_sym.set_vibrate(
offset + (10 - offset) * self._speeding_event.speeding_percentage)
self._speeding_event.clear()
self._speed_time = time.time()
elif self._speed_time is not None and time.time() - self._speed_time > 2:
self._gui._speed_limit_sym.set_vibrate(0)
def _sender(self):
while True:
self._distributor.send()
sleep(1 / self._send_frequency)
