def __call__(self, *args):
global allowed_origins, application_args, auths
origin = request.headers.get('Origin')
abort = False
if not origin:
log.warning("Missing Origin header in request")
self.response = Response(status=500, headers={})
abort = True
elif allowed_origins is not None and (origin is None or origin not in allowed_origins):
self.response = Response(status=403, headers={})
abort = True
elif auths is not None: # TODO check auth properly...
auth = request.headers.get('Authorization', None)
if auth is None or not check_auth(auth, application_args, auths):
log.warning("Unauthorized attempt to POST from %s" % str(request.remote_addr))
self.response = Response(status=403, headers={})
abort = True
if not abort:
try:
# TODO: use response data
if len(request.data) > 0:
request_data = json.loads(request.data)
else:
request_data = {}
response_payload = self.action(origin, request_data)
if response_payload is None:
response_payload = ""
self.response = Response(status=200, headers={})
self.response.data = response_payload
except Exception as e: # TODO: catch exact exception
log.warning("Could not get JSON data from request: %s" % str(e))
self.response = Response(status=500, headers={})
return self.response
def __call__(self, *args):
logger.debug3("HTTP Request from {}".format(str(request.remote_addr)))
origin = request.headers.get('Origin')
abort = False
if request.url_rule is not None and str(
request.url_rule) == '/status/':
auth = request.headers.get('Authorization', False)
if self.application_args.mitm_status_password != "" and \
(not auth or auth != self.application_args.mitm_status_password):
self.response = Response(status=500, headers={})
abort = True
else:
abort = False
else:
if not origin:
logger.warning("Missing Origin header in request")
self.response = Response(status=500, headers={})
abort = True
elif (
self.mapping_manager.get_all_devicemappings().keys()
is not None and
(origin is None or origin
not in self.mapping_manager.get_all_devicemappings().keys())):
logger.warning(
"MITMReceiver request without Origin or disallowed Origin: {}"
.format(origin))
self.response = Response(status=403, headers={})
abort = True
elif self.mapping_manager.get_auths() is not None:
auth = request.headers.get('Authorization', None)
if auth is None or not check_auth(
auth, self.application_args,
self.mapping_manager.get_auths()):
logger.warning("Unauthorized attempt to POST from {}",
str(request.remote_addr))
self.response = Response(status=403, headers={})
abort = True
if not abort:
try:
# TODO: use response data
if len(request.data) > 0:
request_data = json.loads(request.data)
else:
request_data = {}
response_payload = self.action(origin, request_data)
if response_payload is None:
response_payload = ""
self.response = Response(
status=200, headers={"Content-Type": "application/json"})
self.response.data = response_payload
except Exception as e: # TODO: catch exact exception
logger.warning("Could not get JSON data from request: {}",
str(e))
self.response = Response(status=500, headers={})
return self.response
async def __register(self, websocket_client_connection):
logger.info("Client {} registering", str(
websocket_client_connection.request_headers.get_all("Origin")[0]))
if self.__stop_server.is_set():
logger.info(
"MAD is set to shut down, not accepting new connection")
return False
try:
origin = str(
websocket_client_connection.request_headers.get_all("Origin")[0])
except IndexError:
logger.warning("Client from {} tried to connect without Origin header", str(
websocket_client_connection.request_headers.get_all("Origin")[0]))
return False
if origin not in self.__mapping_manager.get_all_devicemappings().keys():
logger.warning("Register attempt of unknown Origin: {}".format(origin))
return False
if origin in self.__users_connecting:
logger.info("Client {} is already connecting".format(origin))
return False
auths = self.__mapping_manager.get_auths()
if auths:
try:
authBase64 = str(
websocket_client_connection.request_headers.get_all("Authorization")[0])
except IndexError:
logger.warning("Client from {} tried to connect without auth header", str(
websocket_client_connection.request_headers.get_all("Origin")[0]))
return False
async with self.__users_mutex:
logger.debug("Checking if {} is already present", str(origin))
if origin in self.__current_users:
logger.warning(
"Worker with origin {} is already running, killing the running one and have client reconnect",
str(origin))
self.__current_users.get(origin)[1].stop_worker()
return
self.__users_connecting.append(origin)
# reset pref. error counter if exist
await self.__reset_fail_counter(origin)
try:
if auths and authBase64 and not check_auth(authBase64, self.args, auths):
logger.warning("Invalid auth details received from {}", str(
websocket_client_connection.request_headers.get_all("Origin")[0]))
return False
logger.info("Starting worker {}".format(origin))
if self._configmode:
worker = WorkerConfigmode(self.args, origin, self, walker = None,
mapping_manager = self.__mapping_manager, mitm_mapper = self.__mitm_mapper,
db_wrapper = self.__db_wrapper, routemanager_name=None)
logger.debug("Starting worker for {}", str(origin))
new_worker_thread = Thread(
name='worker_%s' % origin, target=worker.start_worker)
async with self.__users_mutex:
self.__current_users[origin] = [
new_worker_thread, worker, websocket_client_connection, 0]
return True
last_known_state = {}
client_mapping = self.__mapping_manager.get_devicemappings_of(origin)
devicesettings = self.__mapping_manager.get_devicesettings_of(origin)
logger.info("Setting up routemanagers for {}", str(origin))
if client_mapping.get("walker", None) is not None:
if devicesettings is not None and "walker_area_index" not in devicesettings:
logger.debug("Initializing devicesettings")
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', 0)
self.__mapping_manager.set_devicesetting_value_of(origin, 'finished', False)
self.__mapping_manager.set_devicesetting_value_of(origin, 'last_action_time', None)
self.__mapping_manager.set_devicesetting_value_of(origin, 'last_cleanup_time', None)
self.__mapping_manager.set_devicesetting_value_of(origin, 'job', False)
await asyncio.sleep(1) # give the settings a moment... (dirty "workaround" against race condition)
walker_index = devicesettings.get('walker_area_index', 0)
if walker_index > 0:
# check status of last area
if not devicesettings.get('finished', False):
logger.info(
'Something wrong with last round - get back to old area')
walker_index -= 1
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', walker_index)
# devicesettings['walker_area_index'] = walker_index
walker_area_array = client_mapping["walker"]
walker_settings = walker_area_array[walker_index]
# preckeck walker setting
while not pre_check_value(walker_settings) and walker_index-1 <= len(walker_area_array):
walker_area_name = walker_area_array[walker_index]['walkerarea']
logger.info(
'{} not using area {} - Walkervalue out of range', str(origin), str(walker_area_name))
if walker_index >= len(walker_area_array) - 1:
logger.error(
'Could not find any working area at this time - check your mappings for device: {}',
str(origin))
walker_index = 0
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', walker_index)
walker_settings = walker_area_array[walker_index]
await websocket_client_connection.close()
return
walker_index += 1
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', walker_index)
walker_settings = walker_area_array[walker_index]
devicesettings = self.__mapping_manager.get_devicesettings_of(origin)
logger.debug("Checking walker_area_index length")
if (devicesettings.get("walker_area_index", None) is None
or devicesettings['walker_area_index'] >= len(walker_area_array)):
# check if array is smaller than expected - f.e. on the fly changes in mappings.json
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', 0)
self.__mapping_manager.set_devicesetting_value_of(origin, 'finished', False)
walker_index = 0
walker_area_name = walker_area_array[walker_index]['walkerarea']
if walker_area_name not in self.__mapping_manager.get_all_routemanager_names():
await websocket_client_connection.close()
raise WrongAreaInWalker()
logger.debug('Devicesettings {}: {}', str(origin), devicesettings)
logger.info('{} using walker area {} [{}/{}]', str(origin), str(
walker_area_name), str(walker_index+1), str(len(walker_area_array)))
walker_routemanager_mode = self.__mapping_manager.routemanager_get_mode(walker_area_name)
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', walker_index+1)
self.__mapping_manager.set_devicesetting_value_of(origin, 'finished', False)
if walker_index >= len(walker_area_array) - 1:
self.__mapping_manager.set_devicesetting_value_of(origin, 'walker_area_index', 0)
# set global mon_iv
routemanager_settings = self.__mapping_manager.routemanager_get_settings(walker_area_name)
if routemanager_settings is not None:
client_mapping['mon_ids_iv'] =\
self.__mapping_manager.get_monlist(routemanager_settings.get("mon_ids_iv", None),
walker_area_name)
else:
walker_routemanager_mode = None
if "last_location" not in devicesettings:
devicesettings['last_location'] = Location(0.0, 0.0)
logger.debug("Setting up worker for {}", str(origin))
worker = None
if walker_routemanager_mode is None:
pass
elif walker_routemanager_mode in ["raids_mitm", "mon_mitm", "iv_mitm"]:
worker = WorkerMITM(self.args, origin, last_known_state, self, routemanager_name=walker_area_name,
mitm_mapper=self.__mitm_mapper, mapping_manager=self.__mapping_manager,
db_wrapper=self.__db_wrapper,
pogo_window_manager=self.__pogoWindowManager, walker=walker_settings)
elif walker_routemanager_mode in ["pokestops"]:
worker = WorkerQuests(self.args, origin, last_known_state, self, routemanager_name=walker_area_name,
mitm_mapper=self.__mitm_mapper, mapping_manager=self.__mapping_manager,
db_wrapper=self.__db_wrapper, pogo_window_manager=self.__pogoWindowManager,
walker=walker_settings)
elif walker_routemanager_mode in ["idle"]:
worker = WorkerConfigmode(self.args, origin, self, walker=walker_settings,
mapping_manager=self.__mapping_manager, mitm_mapper=self.__mitm_mapper,
db_wrapper=self.__db_wrapper, routemanager_name=walker_area_name)
else:
logger.error("Mode not implemented")
sys.exit(1)
if worker is None:
logger.error("Invalid walker mode for {}. Closing connection".format(str(origin)))
await websocket_client_connection.close()
else:
logger.debug("Starting worker for {}", str(origin))
new_worker_thread = Thread(
name='worker_%s' % origin, target=worker.start_worker)
new_worker_thread.daemon = True
async with self.__users_mutex:
self.__current_users[origin] = [new_worker_thread,
worker, websocket_client_connection, 0]
new_worker_thread.start()
except WrongAreaInWalker:
logger.error('Unknown Area in Walker settings - check config')
await websocket_client_connection.close()
except Exception as e:
exc_type, exc_value, exc_trace = sys.exc_info()
logger.error("Other unhandled exception during register: {}\n{}, {}".format(e.with_traceback(None),
exc_value, str(e)))
await websocket_client_connection.close()
finally:
async with self.__users_mutex:
self.__users_connecting.remove(origin)
return True
async def __register(self, websocket_client_connection):
logger.info(
"Client {} registering",
str(
websocket_client_connection.request_headers.get_all("Origin")
[0]))
if self.__stop_server.is_set():
logger.info(
"MAD is set to shut down, not accepting new connection")
return False
try:
id = str(
websocket_client_connection.request_headers.get_all("Origin")
[0])
except IndexError:
logger.warning(
"Client from {} tried to connect without Origin header",
str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
return False
if self.__auths:
try:
authBase64 = str(
websocket_client_connection.request_headers.get_all(
"Authorization")[0])
except IndexError:
logger.warning(
"Client from {} tried to connect without auth header",
str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
return False
self.__current_users_mutex.acquire()
try:
logger.debug("Checking if {} is already present", str(id))
user_present = self.__current_users.get(id)
if user_present is not None:
logger.warning(
"Worker with origin {} is already running, killing the running one and have client reconnect",
str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
user_present[1].stop_worker()
return False
elif self.__auths and authBase64 and not check_auth(
authBase64, self.args, self.__auths):
logger.warning(
"Invalid auth details received from {}",
str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
return False
if self._configmode:
worker = WorkerConfigmode(self.args, id, self)
logger.debug("Starting worker for {}", str(id))
new_worker_thread = Thread(name='worker_%s' % id,
target=worker.start_worker)
self.__current_users[id] = [
new_worker_thread, worker, websocket_client_connection, 0
]
return True
last_known_state = {}
client_mapping = self.__device_mappings[id]
devicesettings = client_mapping["settings"]
logger.info("Setting up routemanagers for {}", str(id))
if client_mapping.get("walker", None) is not None:
if "walker_area_index" not in devicesettings:
devicesettings['walker_area_index'] = 0
devicesettings['finished'] = False
devicesettings['last_action_time'] = None
devicesettings['last_cleanup_time'] = None
walker_index = devicesettings.get('walker_area_index', 0)
if walker_index > 0:
# check status of last area
if not devicesettings.get('finished', False):
logger.info(
'Something wrong with last round - get back to old area'
)
walker_index -= 1
devicesettings['walker_area_index'] = walker_index
walker_area_array = client_mapping["walker"]
walker_settings = walker_area_array[walker_index]
# preckeck walker setting
while not pre_check_value(
walker_settings) and walker_index - 1 <= len(
walker_area_array):
walker_area_name = walker_area_array[walker_index][
'walkerarea']
logger.info(
'{} dont using area {} - Walkervalue out of range',
str(id), str(walker_area_name))
if walker_index >= len(walker_area_array) - 1:
logger.error(
'Dont find any working area - check your config')
walker_index = 0
devicesettings['walker_area_index'] = walker_index
walker_settings = walker_area_array[walker_index]
break
walker_index += 1
devicesettings['walker_area_index'] = walker_index
walker_settings = walker_area_array[walker_index]
if devicesettings['walker_area_index'] >= len(
walker_area_array):
# check if array is smaller then expected - f.e. on the fly changes in mappings.json
devicesettings['walker_area_index'] = 0
devicesettings['finished'] = False
walker_index = devicesettings.get('walker_area_index', 0)
walker_area_name = walker_area_array[walker_index][
'walkerarea']
if walker_area_name not in self.__routemanagers:
raise WrongAreaInWalker()
logger.debug('Devicesettings {}: {}', str(id), devicesettings)
logger.info('{} using walker area {} [{}/{}]', str(id),
str(walker_area_name), str(walker_index + 1),
str(len(walker_area_array)))
walker_routemanager = \
self.__routemanagers[walker_area_name].get(
"routemanager", None)
devicesettings['walker_area_index'] += 1
devicesettings['finished'] = False
if walker_index >= len(walker_area_array) - 1:
devicesettings['walker_area_index'] = 0
# set global mon_iv
client_mapping['mon_ids_iv'] = \
self.__routemanagers[walker_area_name].get(
"routemanager").settings.get("mon_ids_iv", [])
else:
walker_routemanager = None
if "last_location" not in devicesettings:
devicesettings['last_location'] = Location(0.0, 0.0)
logger.debug("Setting up worker for {}", str(id))
if walker_routemanager is None:
pass
elif walker_routemanager.mode in [
"raids_mitm", "mon_mitm", "iv_mitm"
]:
worker = WorkerMITM(self.args,
id,
last_known_state,
self,
walker_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
pogoWindowManager=self.__pogoWindowManager,
walker=walker_settings)
elif walker_routemanager.mode in ["raids_ocr"]:
from worker.WorkerOCR import WorkerOCR
worker = WorkerOCR(self.args,
id,
last_known_state,
self,
walker_routemanager,
devicesettings,
db_wrapper=self.__db_wrapper,
pogoWindowManager=self.__pogoWindowManager,
walker=walker_settings)
elif walker_routemanager.mode in ["pokestops"]:
worker = WorkerQuests(
self.args,
id,
last_known_state,
self,
walker_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
pogoWindowManager=self.__pogoWindowManager,
walker=walker_settings)
elif walker_routemanager.mode in ["idle"]:
worker = WorkerConfigmode(self.args, id, self)
else:
logger.error("Mode not implemented")
sys.exit(1)
logger.debug("Starting worker for {}", str(id))
new_worker_thread = Thread(name='worker_%s' % id,
target=worker.start_worker)
new_worker_thread.daemon = False
self.__current_users[id] = [
new_worker_thread, worker, websocket_client_connection, 0
]
new_worker_thread.start()
except WrongAreaInWalker:
logger.error('Unknown Area in Walker settings - check config')
finally:
self.__current_users_mutex.release()
return True
async def __register(self, websocket_client_connection):
log.info("Client %s registering" % str(
websocket_client_connection.request_headers.get_all("Origin")[0]))
try:
id = str(
websocket_client_connection.request_headers.get_all("Origin")
[0])
except IndexError:
log.warning(
"Client from %s tried to connect without Origin header" % str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
return False
if self.__auths:
try:
authBase64 = str(
websocket_client_connection.request_headers.get_all(
"Authorization")[0])
except IndexError:
log.warning(
"Client from %s tried to connect without auth header" %
str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
return False
self.__current_users_mutex.acquire()
user_present = self.__current_users.get(id)
if user_present is not None:
log.warning(
"Worker with origin %s is already running, killing the running one and have client reconnect"
% str(
websocket_client_connection.request_headers.get_all(
"Origin")[0]))
user_present[1].stop_worker()
self.__current_users_mutex.release()
return False
elif self.__auths and authBase64 and not check_auth(
authBase64, self.args, self.__auths):
log.warning("Invalid auth details received from %s" % str(
websocket_client_connection.request_headers.get_all("Origin")
[0]))
self.__current_users_mutex.release()
return False
self.__current_users_mutex.release()
last_known_state = {}
client_mapping = self.__device_mappings[id]
timer = Timer(client_mapping["switch"], id,
client_mapping["switch_interval"])
await asyncio.sleep(0.8)
daytime_routemanager = self.__routemanagers[
client_mapping["daytime_area"]].get("routemanager")
if client_mapping.get("nighttime_area", None) is not None:
nightime_routemanager = self.__routemanagers[
client_mapping["nighttime_area"]].get("routemanager", None)
else:
nightime_routemanager = None
devicesettings = client_mapping["settings"]
started = False
if timer.get_switch() is True and client_mapping.get(
"nighttime_area", None) is not None:
# set global mon_iv
client_mapping['mon_ids_iv'] = self.__routemanagers[
client_mapping["nighttime_area"]].get(
"routemanager").settings.get("mon_ids_iv", [])
# start the appropriate nighttime manager if set
if nightime_routemanager is None:
pass
elif nightime_routemanager.mode in [
"raids_mitm", "mon_mitm", "iv_mitm"
]:
worker = WorkerMITM(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
started = True
elif nightime_routemanager.mode in ["raids_ocr"]:
from worker.WorkerOCR import WorkerOCR
worker = WorkerOCR(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
started = True
elif nightime_routemanager.mode in ["pokestops"]:
worker = WorkerQuests(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
started = True
else:
log.fatal("Mode not implemented")
sys.exit(1)
if not timer.get_switch() or not started:
# set mon_iv
client_mapping['mon_ids_iv'] = self.__routemanagers[
client_mapping["daytime_area"]].get(
"routemanager").settings.get("mon_ids_iv", [])
# we either gotta run daytime mode OR nighttime routemanager not set
if daytime_routemanager.mode in [
"raids_mitm", "mon_mitm", "iv_mitm"
]:
worker = WorkerMITM(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
elif daytime_routemanager.mode in ["raids_ocr"]:
from worker.WorkerOCR import WorkerOCR
worker = WorkerOCR(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
elif daytime_routemanager.mode in ["pokestops"]:
worker = WorkerQuests(self.args,
id,
last_known_state,
self,
daytime_routemanager,
nightime_routemanager,
self.__mitm_mapper,
devicesettings,
db_wrapper=self.__db_wrapper,
timer=timer)
else:
log.fatal("Mode not implemented")
sys.exit(1)
new_worker_thread = Thread(name='worker_%s' % id,
target=worker.start_worker)
new_worker_thread.daemon = True
self.__current_users_mutex.acquire()
self.__current_users[id] = [
new_worker_thread, worker, websocket_client_connection, 0
]
self.__current_users_mutex.release()
new_worker_thread.start()
return True
async def __register(self, websocket):
# await websocket.recv()
log.info("Client registering....")
try:
id = str(websocket.request_headers.get_all("Origin")[0])
except IndexError:
log.warning(
"Client from %s tried to connect without Origin header" %
str(websocket)) # TODO: list IP or whatever...
return False
if self.auths:
try:
authBase64 = str(
websocket.request_headers.get_all("Authorization")[0])
except IndexError:
log.warning(
"Client from %s tried to connect without auth header" %
str(websocket))
return False
if self.__current_users.get(id, None) is not None:
log.warning("Worker for %s is already running" % str(id))
return False
elif self.auths and authBase64 and not check_auth(
authBase64, self.args, self.auths):
return False
lastKnownState = {}
client_mapping = self.device_mappings[id]
daytime_routemanager = self.routemanagers[
client_mapping["daytime_area"]].get("routemanager")
if client_mapping.get("nighttime_area", None) is not None:
nightime_routemanager = self.routemanagers[
client_mapping["nighttime_area"]].get("routemanager", None)
else:
nightime_routemanager = None
devicesettings = client_mapping["settings"]
if daytime_routemanager.mode == "raids_mitm" or daytime_routemanager.mode == "mon_mitm":
Worker = WorkerMITM(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
self._received_mapping,
devicesettings,
db_wrapper=self.db_wrapper)
else:
from worker.WorkerOcr import WorkerOcr
Worker = WorkerOcr(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
devicesettings,
db_wrapper=self.db_wrapper)
# start off new thread, pass our instance in
newWorkerThread = Thread(name='worker_%s' % id,
target=Worker.start_worker)
newWorkerThread.daemon = False
newWorkerThread.start()
self.__current_users[id] = [newWorkerThread, Worker, websocket]
return True
async def __register(self, websocket):
# await websocket.recv()
log.info("Client registering....")
try:
id = str(websocket.request_headers.get_all("Origin")[0])
except IndexError:
# TODO: list IP or whatever...
log.warning(
"Client from %s tried to connect without Origin header" %
str(websocket))
return False
if self.auths:
try:
authBase64 = str(
websocket.request_headers.get_all("Authorization")[0])
except IndexError:
log.warning(
"Client from %s tried to connect without auth header" %
str(websocket))
return False
if self.__current_users.get(id, None) is not None:
log.warning("Worker for %s is already running" % str(id))
return False
elif self.auths and authBase64 and not check_auth(
authBase64, self.args, self.auths):
return False
lastKnownState = {}
client_mapping = self.device_mappings[id]
daytime_routemanager = self.routemanagers[
client_mapping["daytime_area"]].get("routemanager")
if client_mapping.get("nighttime_area", None) is not None:
nightime_routemanager = self.routemanagers[
client_mapping["nighttime_area"]].get("routemanager", None)
else:
nightime_routemanager = None
devicesettings = client_mapping["settings"]
started = False
if MadGlobals.sleep is True:
# start the appropriate nighttime manager if set
if nightime_routemanager is None:
pass
elif nightime_routemanager.mode in [
"raids_mitm", "mon_mitm", "iv_mitm"
]:
Worker = WorkerMITM(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
self._mitm_mapper,
devicesettings,
db_wrapper=self.db_wrapper)
started = True
elif nightime_routemanager.mode in ["raids_ocr"]:
from worker.WorkerOcr import WorkerOcr
Worker = WorkerOcr(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
devicesettings,
db_wrapper=self.db_wrapper)
started = True
elif nightime_routemanager.mode in ["pokestops"]:
Worker = WorkerQuests(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
self._mitm_mapper,
devicesettings,
db_wrapper=self.db_wrapper)
started = True
else:
log.fatal("Mode not implemented")
sys.exit(1)
if not MadGlobals.sleep or not started:
# we either gotta run daytime mode OR nighttime routemanager not set
if daytime_routemanager.mode in [
"raids_mitm", "mon_mitm", "iv_mitm"
]:
Worker = WorkerMITM(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
self._mitm_mapper,
devicesettings,
db_wrapper=self.db_wrapper)
elif daytime_routemanager.mode in ["raids_ocr"]:
from worker.WorkerOcr import WorkerOcr
Worker = WorkerOcr(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
devicesettings,
db_wrapper=self.db_wrapper)
elif daytime_routemanager.mode in ["pokestops"]:
Worker = WorkerQuests(self.args,
id,
lastKnownState,
self,
daytime_routemanager,
nightime_routemanager,
self._mitm_mapper,
devicesettings,
db_wrapper=self.db_wrapper)
else:
log.fatal("Mode not implemented")
sys.exit(1)
newWorkerThread = Thread(name='worker_%s' % id,
target=Worker.start_worker)
self.__current_users[id] = [newWorkerThread, Worker, websocket]
newWorkerThread.daemon = False
newWorkerThread.start()
return True
