def _process_queue(self, task):
"""Process the scan thread queue, updating parameter values
from the UI. Checks to make sure the event is a valid one,
else it's logged and dropped.
:param: task: current task object
:type: ScanningTask object
:returns: True if an update was processed,
False if no update was found.
"""
processed_something = False
while task.scanq.update_queued():
name, value = task.scanq.get_event_update()
if not name or not value:
logger.warning("Event update attempt returned None.")
break
try:
key = str(name.split("_", 1)[1])
if key in task.params:
if key in ('range_min', 'range_max'):
task.params[key] = khertz_to_hertz(value)
else:
task.params[key] = value
else:
logger.warning("Invalid key in event update: {}".format(key))
break
except Exception as e:
logger.warning("Processing event update failed with {}".format(e))
logger.warning("Event list: {} {}".format(name, value))
break
processed_something = True
logger.info("Queue passed %s %i", name, value)
logger.info("Params[%s] = %s", key, task.params[key])
return processed_something
def _frequency(self, task, log):
"""Performs a frequency scan, using the task obj for finding
all the info. This function is wrapped by Scanning.scan()
:param task: object that represent a scanning task
:type task: object from ScanningTask
:raises: none
:returns: updates the scanning task object with the new activity found
"""
mode = task.params["cbb_scan_mode"].get()
task.rig.set_mode(mode)
level = []
pass_count = task.params["passes"]
interval = khertz_to_hertz(task.params["interval"])
while self.scan_active:
freq = task.params["range_min"]
# If the range is negative, silently bail...
if freq > task.params["range_max"]:
self.scan_active = False
while freq < task.params["range_max"]:
if self._process_queue(task):
freq, pass_count, interval = self._get_task_items(task)
try:
self._frequency_tune(task, freq)
except (socket.error, socket.timeout):
break
if self._signal_check(task.params["sgn_level"], task.rig,
level):
if task.params["record"]:
self._start_recording(task)
if task.params["auto_bookmark"]:
self._autobookmark(level, task, freq)
if task.params["log"]:
nbm = self._create_new_bookmark(task, freq)
log.write('F', nbm, level[0])
if self.scan_active:
self._queue_sleep(task)
if task.params["record"]:
self._stop_recording()
elif self.hold_bookmark:
nbm = self._create_new_bookmark(task, self.prev_freq)
task.new_bookmark_list.append(nbm)
self._prev_bookmark(False, None, None)
freq = freq + interval
if not self.scan_active:
return task
pass_count, task = self._pass_count_update(pass_count, task)
task.scanq.notify_end_of_scan()
return task
def _check_interval(self):
"""Checks for a sane interval. We don't want to search for signals
with bandwidth lower than MIN_INTERVAL, if there is such a low interval
we overwrite and log an error.
"""
if khertz_to_hertz(self.params["interval"]) < MIN_INTERVAL:
logger.error("Low interval provided:{}".format(self.params["interval"]))
logger.error("Overriding with {}".format(MIN_INTERVAL))
self.params["interval"] = MIN_INTERVAL
def _check_interval(self):
"""Checks for a sane interval. We don't want to search for signals
with bandwidth lower than MIN_INTERVAL, if there is such a low interval
we overwrite and log an error.
"""
if khertz_to_hertz(self.params["interval"]) < MIN_INTERVAL:
logger.error("Low interval provided:{}".format(
self.params["interval"]))
logger.error("Overriding with {}".format(MIN_INTERVAL))
self.params["interval"] = MIN_INTERVAL
def _frequency(self, task, log):
"""Performs a frequency scan, using the task obj for finding
all the info. This function is wrapped by Scanning.scan()
:param task: object that represent a scanning task
:type task: object from ScanningTask
:raises: none
:returns: updates the scanning task object with the new activity found
"""
level = []
pass_count = task.params["passes"]
interval = khertz_to_hertz(task.params["interval"])
while self.scan_active:
freq = task.params["range_min"]
# If the range is negative, silently bail...
if freq > task.params["range_max"]:
self.scan_active = False
while freq < task.params["range_max"]:
if self._process_queue(task):
freq, pass_count, interval = self._get_task_items(task)
try:
self._frequency_tune(task, freq)
except (socket.error, socket.timeout):
break
if self._signal_check(task.params["sgn_level"],
task.rig,
level):
if task.params["record"]:
self._start_recording()
if task.params["auto_bookmark"]:
nbm = self._create_new_bookmark(task, freq)
task.new_bookmark_list.append(nbm)
if task.params["log"]:
nbm = self._create_new_bookmark(task, freq)
log.write('F', nbm, level[0])
if self.scan_active:
self._queue_sleep(task)
if task.params["record"]:
self._stop_recording()
freq = freq + interval
if not self.scan_active:
return task
pass_count, task = self._pass_count_update(pass_count, task)
task.scanq.notify_end_of_scan()
return task
def _process_queue(self, task):
"""Process the scan thread queue, updating parameter values
from the UI. Checks to make sure the event is a valid one,
else it's logged and dropped.
:param: task: current task object
:type: ScanningTask object
:returns: True if an update was processed,
False if no update was found.
"""
processed_something = False
while task.scanq.update_queued():
name, value = task.scanq.get_event_update()
if not name or not value:
logger.warning("Event update attempt returned None.")
break
try:
key = str(name.split("_", 1)[1])
if key in task.params:
if key in ('range_min', 'range_max'):
task.params[key] = khertz_to_hertz(value)
else:
task.params[key] = value
else:
logger.warning(
"Invalid key in event update: {}".format(key))
break
except Exception as e:
logger.warning(
"Processing event update failed with {}".format(e))
logger.warning("Event list: {} {}".format(name, value))
break
processed_something = True
logger.info("Queue passed %s %i", name, value)
logger.info("Params[%s] = %s", key, task.params[key])
return processed_something
def __init__(self,
scanq,
mode,
bookmarks,
nbl,
pass_params,
rig_controller,
log_filename):
"""We do some checks to see if we are good to go with the scan.
:param scanq: queue used send/receive events from the UI.
:type scanq: Queue object
:param pass_params: configuration parameters
:type pass_params: standard python dictionary
:param mode: scanning mode, either bookmark or frequency
:type mode: string
:param bookmark: the actual list of bookmarks, may be empty
:type bookmark: list of tuples, every tuple is a bookmark
:raises: UnsupportedScanningConfigError if action or mode are not
allowed
:raises: ValueError if the pass_params dictionary contains invalid data
:returns: none
"""
self.error = None
self.new_bookmark_list = nbl
self.bookmarks = bookmarks
self.scanq = scanq
self.log_filename = log_filename
if mode.lower() not in SUPPORTED_SCANNING_MODES:
logger.error("Unsupported scanning mode "\
"provided, exiting.")
logger.error("Provided mode:{}".format(mode))
logger.error("Supported modes:{}".format(SUPPORTED_SCANNING_MODES))
raise UnsupportedScanningConfigError
self.mode = mode
self.params = pass_params
self.rig = rig_controller
try:
self.params["range_min"] = \
khertz_to_hertz(int(filter(str.isdigit,
self.params["txt_range_min"].get())))
self.params["range_max"] = \
khertz_to_hertz(int(filter(str.isdigit,
self.params["txt_range_max"].get())))
self.params["interval"] = int(filter(str.isdigit,
self.params["txt_interval"].get()))
self.params["delay"] = int(filter(str.isdigit,
self.params["txt_delay"].get()))
self.params["passes"] = int(filter(str.isdigit,
self.params["txt_passes"].get()))
self.params["sgn_level"] = int(re.sub("[^-0-9]",
"",
self.params["txt_sgn_level"].get()))
self.params["log"] = self.params["ckb_log"].is_checked()
self.params["wait"] = self.params["ckb_wait"].is_checked()
self.params["record"] = self.params["ckb_record"].is_checked()
self.params["auto_bookmark"] = self.params["ckb_auto_bookmark"].is_checked()
except ValueError:
"""We log some info and re raise."""
logger.exception("One input values is not of the proper type.")
logger.exception("range_max:{}".format(self.params["txt_range_max"]))
logger.exception("range_min:{}".format(self.params["txt_range_min"]))
logger.exception("interval:{}".format(self.params["txt_interval"]))
logger.exception("delay:{}".format(self.params["txt_delay"]))
logger.exception("passes:{}".format(self.params["txt_passes"]))
logger.exception("sgn_level:{}".format(self.params["txt_sgn_level"]))
raise
if mode == "frequency":
self._check_interval()
def _get_task_items(self, task):
freq = task.params["range_min"]
pass_count = task.params["passes"]
interval = khertz_to_hertz(task.params["interval"])
return freq, pass_count, interval
def __init__(self, scanq, mode, bookmarks, nbl, pass_params,
rig_controller, log_filename):
"""We do some checks to see if we are good to go with the scan.
:param scanq: queue used send/receive events from the UI.
:type scanq: Queue object
:param pass_params: configuration parameters
:type pass_params: standard python dictionary
:param mode: scanning mode, either bookmark or frequency
:type mode: string
:param bookmark: the actual list of bookmarks, may be empty
:type bookmark: list of tuples, every tuple is a bookmark
:raises: UnsupportedScanningConfigError if action or mode are not
allowed
:raises: ValueError if the pass_params dictionary contains invalid data
:returns: none
"""
self.error = None
self.new_bookmark_list = nbl
self.bookmarks = bookmarks
self.scanq = scanq
self.log_filename = log_filename
if mode.lower() not in SUPPORTED_SCANNING_MODES:
logger.error("Unsupported scanning mode " "provided, exiting.")
logger.error("Provided mode:{}".format(mode))
logger.error("Supported modes:{}".format(SUPPORTED_SCANNING_MODES))
raise UnsupportedScanningConfigError
self.mode = mode
self.params = pass_params
self.rig = rig_controller
try:
self.params["range_min"] = khertz_to_hertz(
int(filter(str.isdigit, self.params["txt_range_min"].get())))
self.params["range_max"] = khertz_to_hertz(
int(filter(str.isdigit, self.params["txt_range_max"].get())))
self.params["interval"] = int(
filter(str.isdigit, self.params["txt_interval"].get()))
self.params["delay"] = int(
filter(str.isdigit, self.params["txt_delay"].get()))
self.params["passes"] = int(
filter(str.isdigit, self.params["txt_passes"].get()))
self.params["sgn_level"] = int(
re.sub("[^-0-9]", "", self.params["txt_sgn_level"].get()))
self.params["log"] = self.params["ckb_log"].is_checked()
self.params["wait"] = self.params["ckb_wait"].is_checked()
self.params["record"] = self.params["ckb_record"].is_checked()
self.params["auto_bookmark"] = self.params[
"ckb_auto_bookmark"].is_checked()
except ValueError:
"""We log some info and re raise."""
logger.exception("One input values is not of the proper type.")
logger.exception("range_max:{}".format(
self.params["txt_range_max"]))
logger.exception("range_min:{}".format(
self.params["txt_range_min"]))
logger.exception("interval:{}".format(self.params["txt_interval"]))
logger.exception("delay:{}".format(self.params["txt_delay"]))
logger.exception("passes:{}".format(self.params["txt_passes"]))
logger.exception("sgn_level:{}".format(
self.params["txt_sgn_level"]))
raise
if mode == "frequency":
self._check_interval()
def _get_task_items(self, task):
freq = task.params["range_min"]
pass_count = task.params["passes"]
interval = khertz_to_hertz(task.params["interval"])
return freq, pass_count, interval
