def __create_start_threads(self):
self.item_widgets_thread = GetFromQueueToSignalThread(
self.stop_event, 0.05, self.gui_queue)
self.item_widgets_thread.item_ready.connect(self.__process_frame_data)
self.item_widgets_thread.start()
self.item_widgets_update_thread = GetFromQueueToSignalThread(
self.stop_event, 0.05, self.cloud_rx_queue)
self.item_widgets_update_thread.item_ready.connect(self.__update_list)
self.item_widgets_update_thread.start()
self.auth_status_thread = CheckAuthThread(self.stop_event,
self.config.config)
self.auth_status_thread.state_signal.connect(self.set_auth_status)
self.auth_status_thread.start()
self.update_service_thread = Updater(self.stop_event,
self.config.config,
self.application_path)
self.update_service_thread.to_update.connect(
self.update_service_thread.show_update_window)
self.update_service_thread.start()
self.ui.credentialsLoadButton.clicked.connect(
self.__credentials_file_load_check_propagate)
def run_all(server, dt):
global gridUpdates
if gameData["waitingToStart"]:
if "players" in gameData:
numberOfPlayersReady = 0
for player in gameData["players"]:
if gameData["players"][player]["isReady"]:
numberOfPlayersReady += 1
if numberOfPlayersReady == len(
gameData["players"]) and numberOfPlayersReady >= 1:
gameData["waitingToStart"] = False
gameData["isGameFinished"] = False
gameData["scores"]["pacteam"] = 0
gameData["scores"]["ghostteam"] = 0
for player in gameData["players"]:
gameData["players"][player]["score"] = 0
else:
safeData = copy.deepcopy(gameData)
gridChanges = []
for player in safeData['players']:
updater = Updater(player, dt, dt)
gameData["players"][player], gridChange = updater.run(
safeData["players"][player], server.getGame())
if gridChange is not None:
gridChanges.append(gridChange)
safeData = copy.deepcopy(gameData)
gameData["players"] = playerDefeat(safeData["players"])
gameData["gumCount"] = server.getGumCount()
if gameData["gumCount"] == 0:
gameData["waitingToStart"] = True
gameData["isGameFinished"] = True
gridUpdates.clear()
gridChanges.clear()
server.reloadGrid()
for player in gameData["players"]:
if gameData["players"][player]["isPacman"]:
gameData["scores"]["pacteam"] += gameData["players"][
player]["score"]
else:
gameData["scores"]["ghostteam"] += gameData["players"][
player]["score"]
gameData["players"][player]["isReady"] = False
gameData["players"][player]["speed"] = [0, 0]
gameData["players"][player]["inputs"] = [0, 0]
gameData["players"][player]["idleMove"] = True
gameData["players"][player]["respawn"] = True
return gridChanges
return []
def main():
u = Updater(0.5)
with open(sys.argv[1],'r') as f:
last = update_pool(get_a_line(f.readline()))
lines = f.readlines()
u.start()
for l in lines:
r = get_a_line(l)
if equal(r,last):
last['data']=last['data']+r['data']
else:
result.append(last)
last = r
last = update_pool(last)
u.output = '%s.%s%s%s'%(len(result),last['city'],last['area'],last['road'])
pool_dup = sorted(pool,reverse=True,key=lambda x:len(x))
for r in result:
r['feat']=find_feature(pool_dup,r['city']+r['area']+r['road'])
u.output = 'changing:%s%s%s,%s'%(r['city'],r['area'],r['road'],r['feat'])
u.stop()
print 'writing files'
po = codecs.open('word_pool.js','w','utf-8')
po.write(u'var pool=')
po.write(json.dumps(pool_dup,encoding='utf8',ensure_ascii=False))
po.write(u';')
po.close()
ro = codecs.open('data.js','w','utf-8')
ro.write(u'var database=')
ro.write(json.dumps(result,encoding='utf8',ensure_ascii=False))
ro.write(u';')
ro.close()
def run_all(self, dt):
input_delta_time = time.time() - self.last_input_change_time
if "executionTimes" in self.gameData:
if self.gameData["executionTimes"][-1] != 0:
loops = dt / self.gameData["executionTimes"][-1]
else:
loops = 1
print("Client delta time : ", dt, " server last delta time :",
self.gameData["executionTimes"][-1], " loops to do : ",
loops)
else:
loops = 1
for i in range(round(loops)):
if "players" in self.gameData:
safeData = copy.deepcopy(self.gameData)
for player in safeData['players']:
updater = Updater(player,
self.gameData["executionTimes"][-1],
self.gameData["executionTimes"][-1])
self.gameData["players"][player], gridChange = updater.run(
safeData["players"][player], self.game)
def main():
u = Updater(0.5)
extracted = {}
with codecs.open(sys.argv[1],'r','utf8') as f:
lines = f.readlines()
u.start()
for l in lines:
for n in l:
if n!=u'\n' and n!=u'\u3000' and n!=u'\r':
extracted[n]=1
u.output=n
u.stop()
op = codecs.open('extracted.txt','w','utf-8')
k = extracted.keys()
k.sort()
for c in k:
op.write(c)
op.close()
parser.add_argument(
"-o",
"--outfile",
default=None,
type=str,
help="Output file to write newly fetched info JSON (optional).")
parser.add_argument(
"-u",
"--updatefile",
default=None,
type=str,
help=
"File to write the update diff to (in human-readable format). If not provided, writes to stdout."
)
parser.add_argument("-v",
"--verbose",
action="store_true",
help="If set, print out (to stdout) scraping updates.")
args = parser.parse_args()
upd = Updater(args.infile, args.outfile)
if args.updatefile:
# Write the update to a file
with open(args.updatefile, "w") as fs:
upd.update_studies(fs=fs, verbose=args.verbose)
else:
# Write the update to stdout
upd.update_studies(verbose=args.verbose)
def main():
"""Run the main code of the program."""
try:
# arg parsing
parser = argparse.ArgumentParser(
prog=appcmdname,
description='Prints the current system and station (if docked) to stdout and optionally writes player '
'status, ship locations, ship loadout and/or station data to file. '
'Requires prior setup through the accompanying GUI app.'
)
parser.add_argument('-v', '--version', help='print program version and exit', action='store_const', const=True)
group_loglevel = parser.add_mutually_exclusive_group()
group_loglevel.add_argument('--loglevel',
metavar='loglevel',
help='Set the logging loglevel to one of: '
'CRITICAL, ERROR, WARNING, INFO, DEBUG, TRACE',
)
group_loglevel.add_argument('--trace',
help='Set the Debug logging loglevel to TRACE',
action='store_true',
)
parser.add_argument('-a', metavar='FILE', help='write ship loadout to FILE in Companion API json format')
parser.add_argument('-e', metavar='FILE', help='write ship loadout to FILE in E:D Shipyard plain text format')
parser.add_argument('-l', metavar='FILE', help='write ship locations to FILE in CSV format')
parser.add_argument('-m', metavar='FILE', help='write station commodity market data to FILE in CSV format')
parser.add_argument('-o', metavar='FILE', help='write station outfitting data to FILE in CSV format')
parser.add_argument('-s', metavar='FILE', help='write station shipyard data to FILE in CSV format')
parser.add_argument('-t', metavar='FILE', help='write player status to FILE in CSV format')
parser.add_argument('-d', metavar='FILE', help='write raw JSON data to FILE')
parser.add_argument('-n', action='store_true', help='send data to EDDN')
parser.add_argument('-p', metavar='CMDR', help='Returns data from the specified player account')
parser.add_argument('-j', help=argparse.SUPPRESS) # Import JSON dump
args = parser.parse_args()
if args.version:
updater = Updater(provider='internal')
newversion: Optional[EDMCVersion] = updater.check_appcast()
if newversion:
print(f'{appversion} ({newversion.title!r} is available)')
else:
print(appversion)
return
if args.trace:
edmclogger.set_channels_loglevel(logging.TRACE)
elif args.loglevel:
if args.loglevel not in ('CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'TRACE'):
print('loglevel must be one of: CRITICAL, ERROR, WARNING, INFO, DEBUG, TRACE', file=sys.stderr)
sys.exit(EXIT_ARGS)
edmclogger.set_channels_loglevel(args.loglevel)
logger.debug(f'Startup v{appversion} : Running on Python v{sys.version}')
logger.debug(f'''Platform: {sys.platform}
argv[0]: {sys.argv[0]}
exec_prefix: {sys.exec_prefix}
executable: {sys.executable}
sys.path: {sys.path}'''
)
log_locale('Initial Locale')
if args.j:
logger.debug('Import and collate from JSON dump')
# Import and collate from JSON dump
data = json.load(open(args.j))
config.set('querytime', int(getmtime(args.j)))
else:
# Get state from latest Journal file
logger.debug('Getting state from latest journal file')
try:
logdir = config.get('journaldir') or config.default_journal_dir
logger.debug(f'logdir = "{logdir}"')
logfiles = sorted((x for x in os.listdir(logdir) if JOURNAL_RE.search(x)),
key=lambda x: x.split('.')[1:])
logfile = join(logdir, logfiles[-1])
logger.debug(f'Using logfile "{logfile}"')
with open(logfile, 'r') as loghandle:
for line in loghandle:
try:
monitor.parse_entry(line)
except Exception:
logger.debug(f'Invalid journal entry {line!r}')
except Exception:
logger.exception("Can't read Journal file")
sys.exit(EXIT_SYS_ERR)
if not monitor.cmdr:
logger.error('Not available while E:D is at the main menu')
sys.exit(EXIT_SYS_ERR)
# Get data from Companion API
if args.p:
logger.debug(f'Attempting to use commander "{args.p}"')
cmdrs = config.get('cmdrs') or []
if args.p in cmdrs:
idx = cmdrs.index(args.p)
else:
for idx, cmdr in enumerate(cmdrs):
if cmdr.lower() == args.p.lower():
break
else:
raise companion.CredentialsError()
companion.session.login(cmdrs[idx], monitor.is_beta)
else:
logger.debug(f'Attempting to use commander "{monitor.cmdr}" from Journal File')
cmdrs = config.get('cmdrs') or []
if monitor.cmdr not in cmdrs:
raise companion.CredentialsError()
companion.session.login(monitor.cmdr, monitor.is_beta)
querytime = int(time())
data = companion.session.station()
config.set('querytime', querytime)
# Validation
if not deep_get(data, 'commander', 'name', default='').strip():
logger.error("No data['command']['name'] from CAPI")
sys.exit(EXIT_SERVER)
elif not deep_get(data, 'lastSystem', 'name') or \
data['commander'].get('docked') and not \
deep_get(data, 'lastStarport', 'name'): # Only care if docked
logger.error("No data['lastSystem']['name'] from CAPI")
sys.exit(EXIT_SERVER)
elif not deep_get(data, 'ship', 'modules') or not deep_get(data, 'ship', 'name', default=''):
logger.error("No data['ship']['modules'] from CAPI")
sys.exit(EXIT_SERVER)
elif args.j:
pass # Skip further validation
elif data['commander']['name'] != monitor.cmdr:
logger.error(f'Commander "{data["commander"]["name"]}" from CAPI doesn\'t match "{monitor.cmdr}" from Journal') # noqa: E501
sys.exit(EXIT_CREDENTIALS)
elif data['lastSystem']['name'] != monitor.system or \
((data['commander']['docked'] and data['lastStarport']['name'] or None) != monitor.station) or \
data['ship']['id'] != monitor.state['ShipID'] or \
data['ship']['name'].lower() != monitor.state['ShipType']:
logger.error('Mismatch(es) between CAPI and Journal for at least one of: StarSystem, Last Star Port, Ship ID or Ship Name/Type') # noqa: E501
sys.exit(EXIT_LAGGING)
# stuff we can do when not docked
if args.d:
logger.debug(f'Writing raw JSON data to "{args.d}"')
out = json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, separators=(',', ': '))
with open(args.d, 'wb') as f:
f.write(out.encode("utf-8"))
if args.a:
logger.debug(f'Writing Ship Loadout in Companion API JSON format to "{args.a}"')
loadout.export(data, args.a)
if args.e:
logger.debug(f'Writing Ship Loadout in ED Shipyard plain text format to "{args.e}"')
edshipyard.export(data, args.e)
if args.l:
logger.debug(f'Writing Ship Locations in CSV format to "{args.l}"')
stats.export_ships(data, args.l)
if args.t:
logger.debug(f'Writing Player Status in CSV format to "{args.t}"')
stats.export_status(data, args.t)
if data['commander'].get('docked'):
print(f'{deep_get(data, "lastSystem", "name", default="Unknown")},'
f'{deep_get(data, "lastStarport", "name", default="Unknown")}'
)
else:
print(deep_get(data, 'lastSystem', 'name', default='Unknown'))
if (args.m or args.o or args.s or args.n or args.j):
if not data['commander'].get('docked'):
logger.error("Can't use -m, -o, -s, -n or -j because you're not currently docked!")
return
elif not deep_get(data, 'lastStarport', 'name'):
logger.error("No data['lastStarport']['name'] from CAPI")
sys.exit(EXIT_LAGGING)
# Ignore possibly missing shipyard info
elif not (data['lastStarport'].get('commodities') or data['lastStarport'].get('modules')):
logger.error("No commodities or outfitting (modules) in CAPI data")
return
else:
return
# Finally - the data looks sane and we're docked at a station
if args.j:
logger.debug('Importing data from the CAPI return...')
# Collate from JSON dump
collate.addcommodities(data)
collate.addmodules(data)
collate.addships(data)
if args.m:
logger.debug(f'Writing Station Commodity Market Data in CSV format to "{args.m}"')
if data['lastStarport'].get('commodities'):
# Fixup anomalies in the commodity data
fixed = companion.fixup(data)
commodity.export(fixed, COMMODITY_DEFAULT, args.m)
else:
logger.error("Station doesn't have a market")
if args.o:
if data['lastStarport'].get('modules'):
logger.debug(f'Writing Station Outfitting in CSV format to "{args.o}"')
outfitting.export(data, args.o)
else:
logger.error("Station doesn't supply outfitting")
if (args.s or args.n) and not args.j and not \
data['lastStarport'].get('ships') and data['lastStarport']['services'].get('shipyard'):
# Retry for shipyard
sleep(SERVER_RETRY)
new_data = companion.session.station()
# might have undocked while we were waiting for retry in which case station data is unreliable
if new_data['commander'].get('docked') and \
deep_get(new_data, 'lastSystem', 'name') == monitor.system and \
deep_get(new_data, 'lastStarport', 'name') == monitor.station:
data = new_data
if args.s:
if deep_get(data, 'lastStarport', 'ships', 'shipyard_list'):
logger.debug(f'Writing Station Shipyard in CSV format to "{args.s}"')
shipyard.export(data, args.s)
elif not args.j and monitor.stationservices and 'Shipyard' in monitor.stationservices:
logger.error('Failed to get shipyard data')
else:
logger.error("Station doesn't have a shipyard")
if args.n:
try:
eddn_sender = eddn.EDDN(None)
logger.debug('Sending Market, Outfitting and Shipyard data to EDDN...')
eddn_sender.export_commodities(data, monitor.is_beta)
eddn_sender.export_outfitting(data, monitor.is_beta)
eddn_sender.export_shipyard(data, monitor.is_beta)
except Exception:
logger.exception('Failed to send data to EDDN')
except companion.ServerError:
logger.error('Frontier CAPI Server returned an error')
sys.exit(EXIT_SERVER)
except companion.SKUError:
logger.error('Frontier CAPI Server SKU problem')
sys.exit(EXIT_SERVER)
except companion.CredentialsError:
logger.error('Frontier CAPI Server: Invalid Credentials')
sys.exit(EXIT_CREDENTIALS)
def updateSystem():
#Update Clarissa System
print("UPDATING IN 30 SECONDS! CLOSE ALL CLARISSA FILES!")
time_check.sleep(30)
update = Updater(dir_path)
update.update()
class StartQT4(QtGui.QMainWindow):
def __init__(self, stop_event, config, gui_queue, cloud_tx_queue,
cloud_rx_queue, error_queue, path_queue, send_active,
upload_cloud_thread, application_path):
QtGui.QWidget.__init__(self, None)
self.ui = Ui_mainWindow()
self.ui.setupUi(self)
QtGui.QWidget.setWindowTitle(
self, "PW-Sat2 Ground Station (ver. {0}) - Main Window".format(
config.config['APP_VERSION']))
self.__add_available_signal_sources()
self.exit_message_handler = ExitMessageHandler(gui_queue,
cloud_tx_queue,
cloud_rx_queue,
error_queue, path_queue)
self.config = config
self.stop_event = stop_event
self.application_path = application_path
self.gui_queue = gui_queue
self.error_queue = error_queue
self.cloud_tx_queue = cloud_tx_queue
self.cloud_rx_queue = cloud_rx_queue
self.send_active = send_active
self.upload_cloud_thread = upload_cloud_thread
self.first_frame = True
self.__init_ribbon()
self.__handle_frames_file_picker()
self.__create_start_threads()
self.__set_send_active()
self.__connect_demodulator_button()
self.__connect_run_source_button()
self.ui.credentialsButton.clicked.connect(
self.auth_status_thread.check)
self.validate_credentials = ValidateCredentials(
os.path.join(os.path.dirname(__file__), '..',
self.config.config['CREDENTIALS_FILE']))
self.logger = logging.getLogger(__name__ + "." +
self.__class__.__name__)
if self.validate_credentials.file_blank():
self.__add_credentials_widget()
else:
self.__add_welcome_widget()
def __add_credentials_widget(self):
self.ui.framesListWidget.setSelectionMode(
QtGui.QAbstractItemView.NoSelection)
item_widget = CredentialsChooseWidget()
text = "<html><head/><body><p><span style=\" " \
"font-size:14pt; font-weight:600;\">Sign in and download credentials</span><br/>" \
"Go to our page {0} and download file with your credentials to enable " \
"upload to cloud.</p></body></html>".format(self.config.config['CLOUD_URL'])
item_widget.label_6.setText(text)
item_widget.choose_credentials_file_button.clicked.connect(
self.__handle_credentials_file_widget_button)
item = QtGui.QListWidgetItem(self.ui.framesListWidget)
item.setSizeHint(QtCore.QSize(0, 500))
self.ui.framesListWidget.addItem(item)
self.ui.framesListWidget.setItemWidget(item, item_widget)
def __handle_credentials_file_widget_button(self):
if self.__credentials_file_load_check_propagate(
) == CorrectCredentials:
self.__remove_last_widget()
self.__add_welcome_widget()
else:
pass
def __add_welcome_widget(self):
self.ui.framesListWidget.setSelectionMode(
QtGui.QAbstractItemView.NoSelection)
item_widget = UiFrameListEmptyWidget()
item_widget.help_step_1.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_WELCOME_STEP_1']))
item_widget.help_step_2.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_WELCOME_STEP_2']))
item_widget.help_step_3.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_WELCOME_STEP_3']))
item = QtGui.QListWidgetItem(self.ui.framesListWidget)
item.setSizeHint(QtCore.QSize(0, 400))
self.ui.framesListWidget.addItem(item)
self.ui.framesListWidget.setItemWidget(item, item_widget)
def __remove_last_widget(self):
self.ui.framesListWidget.setSelectionMode(
QtGui.QAbstractItemView.SingleSelection)
self.ui.framesListWidget.takeItem(0)
def __handle_frames_file_picker(self):
self.from_file_thread = FromFileToGuiQueueThreadFactory(
self.stop_event, self.config.config, self.gui_queue)
self.ui.loadFramesFromFileButton.clicked.connect(
self.from_file_thread.load_from_file)
def __connect_frame_uploads_buttons(self):
self.ui.autoUploadToolButton.clicked.connect(self.__autosend_handle)
self.ui.sendUnsuccessfulButton.clicked.connect(
self.__resend_errors_handle)
def __connect_demodulator_button(self):
self.ui.runDemodulatorButton.clicked.connect(self.__run_demodulator)
def __connect_run_source_button(self):
self.ui.runSourceButton.clicked.connect(self.__run_source)
def __run_source(self):
item = self.ui.signalSourceDropdownButton.currentText()
if item == "Recorded IQ File":
self.source_thread = Thread(target=self.__source_iq_file_command)
self.source_thread.start()
elif item == "FUNcube Dongle Pro+":
self.source_thread = Thread(target=self.__source_fcd_plus_command)
self.source_thread.start()
elif item == "RTL-SDR":
self.source_thread = Thread(target=self.__source_rtl_sdr_command)
self.source_thread.start()
elif item == "PlutoSDR":
self.source_thread = Thread(target=self.__source_pluto_sdr_command)
self.source_thread.start()
elif item == "Audio in (SSB - USB)":
self.source_thread = Thread(target=self.__source_ssb_command)
self.source_thread.start()
else:
print "Not implemented yet!"
def __source_iq_file_command(self):
print os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "iq_file"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "iq_file"
])
def __source_ssb_command(self):
print os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "iq_file"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "ssb"
])
def __source_fcd_plus_command(self):
print os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "fcd+"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "fcd+"
])
def __source_rtl_sdr_command(self):
print os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "rtl-sdr"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "rtl-sdr"
])
def __source_pluto_sdr_command(self):
print os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "pluto"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "pluto"
])
def __demodulator_command(self):
print os.path.join(
os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY'] + ' -s "demodulator"')
subprocess.call([
os.path.join(os.path.dirname(__file__), '..',
self.config.config['GRC_BINARY']), '-s', "demodulator"
])
def __run_demodulator(self):
self.demodulator_thread = Thread(target=self.__demodulator_command)
self.demodulator_thread.start()
def __connect_help_buttons(self):
self.ui.helpAccountButton.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_ACCOUNT']))
self.ui.helpSignalSourceButton.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_SOURCE']))
self.ui.helpDemodulatorButton.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_DEMODULATOR']))
self.ui.helpCloudUploadButton.clicked.connect(
lambda: webbrowser.open(self.config.config['HELP_UPLOAD']))
def __create_start_threads(self):
self.item_widgets_thread = GetFromQueueToSignalThread(
self.stop_event, 0.05, self.gui_queue)
self.item_widgets_thread.item_ready.connect(self.__process_frame_data)
self.item_widgets_thread.start()
self.item_widgets_update_thread = GetFromQueueToSignalThread(
self.stop_event, 0.05, self.cloud_rx_queue)
self.item_widgets_update_thread.item_ready.connect(self.__update_list)
self.item_widgets_update_thread.start()
self.auth_status_thread = CheckAuthThread(self.stop_event,
self.config.config)
self.auth_status_thread.state_signal.connect(self.set_auth_status)
self.auth_status_thread.start()
self.update_service_thread = Updater(self.stop_event,
self.config.config,
self.application_path)
self.update_service_thread.to_update.connect(
self.update_service_thread.show_update_window)
self.update_service_thread.start()
self.ui.credentialsLoadButton.clicked.connect(
self.__credentials_file_load_check_propagate)
def __credentials_file_load_check_propagate(self):
result = LoadCredentialsFile.load_with_dialog(self.config.config)
if result is CorrectCredentials:
self.auth_status_thread.cloud.load_credentials()
self.upload_cloud_thread.cloud.load_credentials()
self.auth_status_thread.check()
self.logger.log(logging.DEBUG, "Updated credential file")
elif result is WrongOrEmptyCredentials:
self.logger.log(
logging.DEBUG,
"Not updated credential file - wrong or empty file")
self.__show_dialog_credentials_not_loaded_wrong_file()
elif result is UnknownError:
self.logger.log(
logging.DEBUG,
"Not updated credential file - wrong or empty path")
self.__show_dialog_credentials_not_loaded_unknown_error()
return result
def __show_dialog_credentials_not_loaded_wrong_file(self):
msg = "<h2>Credentials file not loaded!</h2>" \
"Credentials file is empty or corrupted.<br>" \
"Go to radio.pw-sat.pl and generate a new credentials file."
QtGui.QMessageBox.warning(None, 'Credentials file not loaded!', msg,
QtGui.QMessageBox.Ok)
def __show_dialog_credentials_not_loaded_unknown_error(self):
msg = "<h2>Credentials file not loaded!</h2>" \
"Unknown error occured!"
QtGui.QMessageBox.warning(None, 'Credentials file not loaded!', msg,
QtGui.QMessageBox.Ok)
def __set_send_active(self):
self.send_active.set()
def __init_ribbon(self):
self.__connect_help_buttons()
self.__connect_frame_uploads_buttons()
self.__init_credential_buttons()
def __init_credential_buttons(self):
set_btn_icon(self.ui.credentialsButton,
":/user/img/user-alt-slash-solid.svg")
self.ui.credentialsButton.setText("Signing in...")
self.ui.credentialsButton.setToolTip("Signing in in progress...")
def __first_frame(self):
if self.first_frame:
self.first_frame = False
return True
return False
def __process_frame_data(self, packet):
# remove welcome widget when the first frame is received
if self.__first_frame():
self.__remove_last_widget()
data = self.__produce_list_item(packet)
self.__add_to_list(data)
self.ui.framesListWidget.scrollToBottom()
self.cloud_tx_queue.append(data)
def __produce_list_item(self, packet):
item_widget = UiFrameListWidgetFactory.get(packet)
item = QtGui.QListWidgetItem(self.ui.framesListWidget)
item.setSizeHint(QtCore.QSize(0, 65))
return PacketListData(item, item_widget, packet)
def __add_to_list(self, data):
self.ui.framesListWidget.addItem(data.item)
self.ui.framesListWidget.setItemWidget(data.item, data.widget_item)
def __update_list(self, data):
base_url = self.config.config['CLOUD_URL']
if data.upload_status:
UiFrameListWidgetFactory.set_sent(data.widget_item, data.uuid,
base_url)
else:
UiFrameListWidgetFactory.set_send_error(data.widget_item)
def __autosend_handle(self):
if self.ui.autoUploadToolButton.isChecked():
self.ui.autoUploadToolButton.setText("Auto-Upload Enabled")
self.send_active.set()
else:
self.send_active.clear()
self.ui.autoUploadToolButton.setText("Auto-Upload Disabled")
def __resend_errors_handle(self):
upload = UploadCloudError(self.stop_event, self.config.config,
self.cloud_rx_queue, self.error_queue)
upload.start()
def set_auth_status(self, auth_status):
self.validate_credentials.load()
if auth_status:
set_btn_icon(self.ui.credentialsButton,
":/user/img/user-check-solid.svg")
self.ui.credentialsButton.setText(
self.validate_credentials.credentials_data["identifier"])
self.ui.credentialsButton.setToolTip("Signed up successfully")
elif self.validate_credentials.file_blank():
set_btn_icon(self.ui.credentialsButton,
":/user/img/user-alt-slash-solid.svg")
self.ui.credentialsButton.setText("No credentials loaded")
self.ui.credentialsButton.setToolTip(
"Download credentials from radio.pw-sat.pl and load file"
" clicking button load credentials from file.")
elif not auth_status and not self.validate_credentials.file_blank():
set_btn_icon(self.ui.credentialsButton,
":/user/img/user-alt-slash-solid.svg")
self.ui.credentialsButton.setText(
"Cannot sign in, trying again...")
self.ui.credentialsButton.setToolTip(
"Cannot sign in - restart application, check internet connection or"
" download and load new credentials from radio.pw-sat.pl.")
def __add_available_signal_sources(self):
self.ui.signalSourceDropdownButton.addItem("Recorded IQ File")
self.ui.signalSourceDropdownButton.addItem("RTL-SDR")
self.ui.signalSourceDropdownButton.addItem("Audio in (SSB - USB)")
if platform.startswith('linux'):
self.ui.signalSourceDropdownButton.addItem("FUNcube Dongle Pro+")
self.ui.signalSourceDropdownButton.addItem("PlutoSDR")
def closeEvent(self, event):
self.exit_message_handler.exit_action(event)
def run(self, opts=None):
if opts:
options = self.create_options(opts)
self.set_options(options)
options = self.options
# check proxy options
proxy = options.proxy
if options.proxy:
try:
pattern = 'http[s]?://(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]):[0-9][0-9][0-9][0-9]'
m = re.search(pattern, proxy)
if m is None:
self.banner()
print("\n[Error] - Proxy malformed!\n")
sys.exit(2)
except Exception:
self.banner()
print("\n[Error] - Proxy malformed!\n")
sys.exit(2)
# check tor connection
if options.checktor:
self.banner()
try:
print("\nSending request to: https://check.torproject.org\n")
tor_reply = urllib2.urlopen(
"https://check.torproject.org").read()
your_ip = tor_reply.split('<strong>')[1].split(
'</strong>')[0].strip()
if not tor_reply or 'Congratulations' not in tor_reply:
print("It seems that Tor is not properly set.\n")
print("Your IP address appears to be: " + your_ip + "\n")
else:
print("Congratulations!. Tor is properly being used :-)\n")
print("Your IP address appears to be: " + your_ip + "\n")
except:
print(
"Cannot reach TOR checker system!. Are you correctly connected?\n"
)
# search for 'zombies' on google results
if options.search:
try:
self.banner()
print(
"\nSearching for 'zombies' on google results. Good Luck ;-)\n"
)
zombies = self.search_zombies()
check_url_link_reply = raw_input(
"Wanna check if they are valid zombies? (Y/n)\n")
print '-' * 25
if check_url_link_reply == "n" or check_url_link_reply == "N":
print "\nBye!\n"
else:
test = self.testing(zombies)
except Exception:
print("[Error] - Something wrong searching!\n")
# test web 'zombie' servers -> show statistics
if options.test:
try:
self.banner()
zombies = self.extract_zombies()
test = self.testing(zombies)
except Exception:
print("\n[Error] - Something wrong testing!\n")
# attack target -> exploit Open Redirect massively and connect all vulnerable servers to a target
if options.target:
try:
self.banner()
zombies = self.extract_zombies()
attack = self.attacking(zombies)
except Exception:
print("\n[Error] - Something wrong attacking!\n")
# check/update for latest stable version
if options.update:
self.banner()
try:
print(
"\nTrying to update automatically to the latest stable version\n"
)
Updater()
except:
print(
"\nSomething was wrong!. You should checkout UFONet manually with:\n"
)
print("$ git clone https://github.com/epsylon/ufonet\n")
def main(url, path, replace, push, html, update):
"""
Start vulnerability analysis using command line tool.
:param url: URL to a github repository
:param path: path to a locally stored project
:param replace: flag of whether detected vulnerabilities
should be automatically replaced with safe alternative
:param push: flag indicating whether pull-request should
automatically be created
:param html: path to html file which will contain report
"""
# analyze source code of provided project
print("Start analysis")
# setup logging
logger = logging.getLogger()
logHandler = logging.FileHandler('/home/metrics.json')
logger.addHandler(logHandler)
formatter = jsonlogger.JsonFormatter()
logHandler.setFormatter(formatter)
logger.setLevel(logging.INFO)
# store remote repo locally in /tmp
local_repo_path = '/tmp/' + str(uuid.uuid4())
gh_handler = None
if url:
# download remote repo
gh_handler = GithubRepoHandler(url)
gh_handler.download_repository(local_repo_path)
gh_handler.get_repository_metrics()
elif path:
# analyze local repo
local_repo_path = path
updater = None
try:
updater = Updater(local_repo_path)
except:
print("Cannot update due to error")
vulnerability_analyzer = VulnerabilityAnalyzer(local_repo_path)
try:
# check for vulnerable functions and vulnerable dependencies
vulnerability_analyzer.analyze()
except:
print("Python AST cannot be parsed. Terminating analysis")
if url:
logger.info(url, extra={'analysis_failed': True})
sys.exit(1)
vulnerable_functions = vulnerability_analyzer.detected_vulnerable_functions
vulnerable_imports = vulnerability_analyzer.detected_vulnerable_imports
vulnerable_installed_dependencies = vulnerability_analyzer.detected_vulnerable_installed_dependencies
outdated_dependencies = []
if updater:
outdated_dependencies = updater.outdated_dependencies
pre_test_results = {}
test_metrics_before = {}
if len(vulnerable_functions) > 0:
# run tests
pre_tester = TestInfo(local_repo_path)
try:
pre_tester.runToxTest()
except:
print("An error occured while executing tests")
print("Tests done")
pre_test_results = pre_tester.getTestLog()
test_metrics_before = pre_tester.get_test_metrics()
post_test_metrics = {}
post_test_results = {}
if replace and len(vulnerable_functions) > 0:
# automatically replace detected vulnerabilities if available
print("Replace detected vulnerabilities")
vulnerability_analyzer.replace_vulnerabilities_in_ast()
# run tests
post_tester = TestInfo(local_repo_path)
try:
post_tester.runToxTest()
post_test_results = post_tester.getTestLog()
post_test_metrics = post_tester.get_test_metrics()
except:
print("An error occured while executing tests")
report = Report(vulnerable_functions, vulnerable_imports, pre_test_results,
post_test_results, outdated_dependencies, [], replace)
# automatically create pull request
if push and (len(vulnerable_functions) > 0 or len(vulnerable_imports) > 0):
print("Create pull-request")
gh_handler.push_updates("*****@*****.**",
"bugrevelio", "Vulnerabilities",
report.pull_request_report(),
"bugrevelio:master", "master")
print(report.plain_text_report())
if html:
report.html_report(html)
if url:
# collect relevant metrics
repo_metrics = gh_handler.get_repository_metrics()
vulnerability_metrics = vulnerability_analyzer.get_vulnerability_metrics(
)
repo_metrics.update(vulnerability_metrics)
repo_metrics.update(test_metrics_before)
repo_metrics.update(post_test_metrics)
logger.info(url, extra=repo_metrics)
# delete downloaded repo
shutil.rmtree(local_repo_path)
