def __init__(self, socketio, rtklib_path = None, config_path=None, enable_led = True, log_path = None):
print("RTKLIB 1")
print(rtklib_path)
print(log_path)
if rtklib_path is None:
rtklib_path = os.path.join(os.path.expanduser("~"), "RTKLIB")
if config_path is None:
self.config_path = os.path.join(os.path.dirname(__file__), "rtklib_configs")
else:
self.config_path = config_path
if log_path is None:
#TODO find a better default location
self.log_path = "../data"
else:
self.log_path = log_path
# This value should stay below the timeout value or the Satellite/Coordinate broadcast
# thread will stop
self.sleep_count = 0
# default state for RTKLIB is "rover single"
self.state = "base"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path, self.config_path)
self.conm = ConfigManager(rtklib_path, self.config_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, self.log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
# self.enable_led = enable_led
# if self.enable_led:
# self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
# self.system_time_correct = True
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
class ConfigManagerTest(TestCase):
def setUp(self):
self.cm = ConfigManager()
def test_write(self):
flagOk=False
try:
self.cm.writeConfig("/dev/ttyUSB1","")
flagOk=True
except:
pass
self.assertEqual(True,flagOk)
def test_read(self):
try:
self.cm.writeConfig("/dev/ttyUSB1","")
except:
pass
conf = self.cm.readConfig()
self.assertEqual("/dev/ttyUSB1",conf["port"])
class PyGDB:
def __init__(self, project_config_filename):
# 创建配置文件管理器, 读取配置文件
self.conf = ConfigManager()
self.conf.load_project_config(project_config_filename)
# 从配置文件获取数据库信息
db_host = self.conf.dict['database']['host']
db_port = self.conf.dict['database']['port']
db_db = self.conf.dict['database']['db']
db_passwd = self.conf.dict['database']['password']
db_user = self.conf.dict['database']['user']
# 连接数据库, 创建数据库管理器
self.db = PyGdbDb(db_host, db_port, db_db, db_user, db_passwd)
# 结束项目
def release_project(self):
self.db.connection.close()
# 显示项目信息
def print_project_info(self):
print '------------------------------'
print ' 项目名称: ' + self.conf.pro_name
print ' 数据表前缀: ' + self.conf.pro_table_prefix
print '------------------------------'
class PyGDB:
def __init__(self, project_config_filename):
# 创建配置文件管理器, 读取配置文件
self.conf = ConfigManager()
self.conf.load_project_config(project_config_filename)
# 从配置文件获取数据库信息
db_host = self.conf.dict['database']['host']
db_port = self.conf.dict['database']['port']
db_db = self.conf.dict['database']['db']
db_passwd = self.conf.dict['database']['password']
db_user = self.conf.dict['database']['user']
# 连接数据库, 创建数据库管理器
self.db = PyGdbDb(db_host, db_port, db_db, db_user, db_passwd)
# 结束项目
def release_project(self):
self.db.connection.close()
# 显示项目信息
def print_project_info(self):
print '------------------------------'
print ' 项目名称: ' + self.conf.pro_name
print ' 数据表前缀: ' + self.conf.pro_table_prefix
print '------------------------------'
def __init__(self):
cm = ConfigManager()
self.voip_path = cm.getVoipFile()
self.bb_path = cm.getBbFile()
self.iptv_path = cm.getIptvFile()
self.con = cx_Oracle.connect('orcdb/[email protected]/orcl')
self.cur = self.con.cursor()
self.sep = ','
def __init__(self):
cm = ConfigManager()
self.voip_path = cm.getVoipFile()
self.bb_path = cm.getBbFile()
self.iptv_path = cm.getIptvFile()
self.con = cx_Oracle.connect('orcdb/[email protected]/orcl')
self.cur = self.con.cursor()
self.sep = ','
def __init__(self):
super(MainWindow, self).__init__()
self.grass_result: Grasser.GrassResult
self.settings_manager = SettingsManager()
self.settings_manager.setup_settings(self)
self.grasser = GoogleGrasser(
config_file_name=self.config_file_name,
service_url=self.google_translate_service_url,
no_english=self.random_grass_no_english)
self.config_manager = ConfigManager(self.config_file_name)
self.change_style(self.application_style)
self.ui = Ui_application()
self.ui.setupUi(self)
self.ui.select_config.addItems(["随机"] +
self.config_manager.return_all_config())
self.ui.select_google_translate_url.addItems(constants.SERVICE_URLS)
self.ui.select_application_style.addItems(QStyleFactory.keys())
self.GrassingThread = QThread(self)
self.OnClick = OnClick(self)
self.OnClick.moveToThread(self.GrassingThread)
self.ui.start_grass.clicked.connect(self.on_start_grass_click)
self.ui.open_file.clicked.connect(self.on_open_file_click)
self.ui.copy_result.clicked.connect(self.on_copy_result_click)
self.ui.save_this_grass_as_config.clicked.connect(
self.on_save_this_grass_as_config_click)
self.ui.save_result.clicked.connect(self.on_save_grass_result_click)
self.OnClick.set_grass_result.connect(self.set_grass_result)
self.OnClick.warning.connect(self.warning_dialog)
self.OnClick.quit.connect(self.quit_onclick_thread)
self.ui.select_google_translate_url.currentTextChanged.connect(
self.on_select_google_translate_url_current_index_changed)
self.GrassingThread.started.connect(
lambda: self.OnClick.on_start_grass_click(
self.grasser, self.ui.original_text_edit.toPlainText(),
self.ui.grass_frequency.value(),
self.ui.select_config.currentText()))
self.ui.second_setting_option_button_group.buttonClicked.connect(
self.on_second_setting_option_click)
self.ui.set_config_file_name.returnPressed.connect(
self.on_set_config_file_name_return_pressed)
self.ui.select_application_style.currentTextChanged.connect(
self.select_application_style_current_index_changed)
self.ui.select_google_translate_url.setCurrentIndex(
constants.SERVICE_URLS.index(self.google_translate_service_url))
self.ui.select_application_style.setCurrentIndex(
QStyleFactory.keys().index(self.application_style))
if self.random_grass_no_english:
self.ui.radio_first_setting_option.setChecked(True)
else:
self.ui.radio_second_setting_option.setChecked(True)
class VideoBrowser:
def __init__(self):
self.config = ConfigManager(os.environ['HOME']+'/.VideoBrowser/VideoBrowser.conf')
self.data = Data(self.config.get_value('FileSystem','moviedir'),self.config.get_value('FileSystem','cachedir'))
self.files = self.data.get_files("avi")
self.gui = Gui(self.files)
def main(self):
gtk.main()
return
def __init__(self):
configMgr = ConfigManager()
config = configMgr.read_config_file()
mongo_username = config["mongo_username"]
mongo_password = config["mongo_password"]
self.client = pymongo.MongoClient(serverSelectionTimeoutMS=1000 * 1)
self.client.admin.authenticate(mongo_username,
mongo_password,
mechanism="SCRAM-SHA-1")
self.db = self.client["Mmrz-Sync"]
def connect(self):
try:
cm = ConfigManager()
params = cm.get_db_params()
logging.debug("Connecting to PostgreSQL server...")
self.conn = psycopg2.connect(**params)
self.conn.set_isolation_level(
psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ)
logging.debug("Successfully connected to PostgreSQL server!")
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
def __init__(self,_ip):
cm = ConfigManager()
Log("Network manager started")
self.ip = cm.getSnmpIp()
self.ports = ()
self.cmdGen = cmdgen.CommandGenerator()
self.devices = []
self.inventory = []
self.getDevicePorts()
self.callDevices()
def __init__(self,
config_file_name: str = "Config",
service_url: str = "translate.google.cn",
no_english: bool = True):
from googletrans import Translator
from ConfigManager import ConfigManager
from constants import LANGUAGES
self.LANGUAGES = LANGUAGES
if no_english:
self.LANGUAGES.remove("en")
self.translator = Translator(service_urls=[service_url])
self.language_number = (len(self.LANGUAGES) - 1)
self.config_manager = ConfigManager(config_file_name)
class LoadingWindowTest(TestCase):
def setUp(self):
self.editor = Edile()
self.cm = ConfigManager()
self.cm.writeConfig("/dev/ttyUSB1","")
def tearDown(self):
pass
def test_sendScript_without_file(self):
plugin = ciaa_plugin.mnu_EDUCIAA()
plugin.item_Load_Script(None,self.editor.plugin_interface)
timeout=15
while(plugin.loadScriptWindow.lblStatus.get_text()!="ERROR: Save File first" and timeout>0):
time.sleep(1)
print(plugin.loadScriptWindow.lblStatus.get_text())
timeout-=1
self.assertGreater(timeout,0)
def test_sendScript(self):
self.editor.load_file("tests/test.py")
plugin = ciaa_plugin.mnu_EDUCIAA()
plugin.item_Load_Script(None,self.editor.plugin_interface)
print(">>>>>>>>>>>>>>> PRESS RESET BUTTON MANUALLY")
timeout=15
while(plugin.loadScriptWindow.lblStatus.get_text()!="File copied" and timeout>0):
time.sleep(1)
print(plugin.loadScriptWindow.lblStatus.get_text())
timeout-=1
self.assertGreater(timeout,0)
def test_sendScript_wrong_port(self):
self.editor.load_file("tests/test.py")
self.cm.writeConfig("/dev/ttyUSBXXXXXX","") # wrong port
plugin = ciaa_plugin.mnu_EDUCIAA()
plugin.item_Load_Script(None,self.editor.plugin_interface)
timeout=15
while(plugin.loadScriptWindow.lblStatus.get_text()!="Invalid PORT" and timeout>0):
time.sleep(1)
print(plugin.loadScriptWindow.lblStatus.get_text())
timeout-=1
self.assertGreater(timeout,0)
def __init__(self, project_config_filename):
# 创建配置文件管理器, 读取配置文件
self.conf = ConfigManager()
self.conf.load_project_config(project_config_filename)
# 从配置文件获取数据库信息
db_host = self.conf.dict['database']['host']
db_port = self.conf.dict['database']['port']
db_db = self.conf.dict['database']['db']
db_passwd = self.conf.dict['database']['password']
db_user = self.conf.dict['database']['user']
# 连接数据库, 创建数据库管理器
self.db = PyGdbDb(db_host, db_port, db_db, db_user, db_passwd)
def __init__(self,scannerMainWindow): cfg = ConfigManager() self.mw = scannerMainWindow self.threads = [] self.host = cfg.getServerHost() self.port = cfg.getServerPort() self.threadCount = 0 self.ssocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.ssocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.ssocket.bind((self.host, self.port)) self.ssocket.listen(5)
def __init__(self, scannerMainWindow):
cfg = ConfigManager()
self.mw = scannerMainWindow
self.threads = []
self.host = cfg.getServerHost()
self.port = cfg.getServerPort()
self.threadCount = 0
self.ssocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.ssocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.ssocket.bind((self.host, self.port))
self.ssocket.listen(5)
def init_selenium():
cm = ConfigManager()
crawler_config = cm.get_crawler_params()
options = webdriver.ChromeOptions()
options.headless = True # We have no GUI
options.add_argument('--disable-notifications') # Pls no alerts (might be deprecated and not work at all)
options.add_argument('--disable-dev-shm-usage') # Some resource/storage stuff
options.add_argument('--no-sandbox') # Rip security, but doesn't work otherwise
options.add_argument('user-agent=' + crawler_config['bot_name'] + repr(random.randint(0, 100)) + 't') # Course stuff
prefs = {"profile.managed_default_content_settings.images": 2}
options.add_experimental_option("prefs", prefs)
driver = webdriver.Chrome(crawler_config['chromedriver_path'], options=options)
driver.set_page_load_timeout(crawler_config['selenium_timeout'])
return driver
def run_crawl(event, context):
# Create the required config -- might use context instead of event
config = ConfigManager(event['queryStringParameters']['env'])
# Create a stock data collector
collector = StockDataCollector()
# Get which symbol should be crawled
symbol = event['queryStringParameters']['symbol']
# Get the headlines
headlines = collector.collectHeadlinesForSymbol(symbol, pages=50)
# Create dynamo connection
dynamo = createDynamoInstance(event, config)
# Store into DB
collector.storeHeadlinesForSymbol(symbol, headlines, dynamo)
# Return the headlines -- just to know what was posted
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json',
},
'body': json.dumps({
'symbol': symbol,
'headlines': headlines
})
}
def __init__(self, master: tk.Tk):
"""Instantiate a new application window"""
super().__init__(master)
self.master = master
self.place(x=0, y=0, relwidth=1, relheight=1)
self.configuration = ConfigManager.load(
os.path.realpath(os.path.dirname(__file__) + '/settings.json'),
ExpectedConfigKeys)
self.settings_dialog = SettingsDialog(self, self.configuration)
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.master.tk.call(
'wm', 'iconphoto', self.master._w,
ImageTk.PhotoImage(
Image.open(
os.path.realpath(
os.path.dirname(__file__) + '/../' +
self.configuration.getConfig()['icon']))))
self.is_fullscreen = False
self.master.bind('<F11>', lambda e: self.fullscreen('toggle'))
self.master.bind('<Escape>', lambda e: self.fullscreen('off'))
self.current_file = {}
self.file = None
self.progress = False
self.createWidgets()
self.master.update()
self.focus_set()
def getCompanies(event, context):
# Create the required config -- might use context instead of event
# Create the config using the event parameter (lambda proxy so full request is passed in)
config = ConfigManager(event['queryStringParameters']['env'])
# Create dynamo config
dynamo = createDynamoInstance(event, config)
collector = StockDataCollector()
# Collect the companies
try:
companies = collector.getAllCompanyInfo(fromDB=True, dynamo=dynamo)
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json',
},
'body': json.dumps({
'companies': companies
})
}
except:
return {
'statusCode': 404,
'headers': {
'Content-Type': 'application/json',
}
}
def __init__ (self): QtGui.QMainWindow.__init__ (self) self.btnCol = 1 self.radioCol = 0 self.upDirShortCutKey = "/" self.homeDirShortCutKey = "-" self.pyapplaunchConfigDir = ConfigManager.getPyapplaunchConfigDir() self.configManager = ConfigManager.ConfigManager() self.executionManager = ExecutionDelegateManager (self.configManager) self.scriptDatabasePath = self.pyapplaunchConfigDir + os.sep + "scripts.xml" self.tree = Tree (self.scriptDatabasePath) self.upButton = None self.homeButton = None self.initUI() self.buildAppButtons() self.createSysTray() self.restoreWindowPos() # This is an adaptor to call "self.tree.substituteEveryOccurrenceOfValue" # with the right parameters, since the signal we're connecting to can't # connect directly to the function. nameChangeAdaptor = lambda s1, s2: \ self.tree.substituteEveryOccurrenceOfValue (s1, s2, "exec_with") self.executionManager.delegateNameChanged.connect (nameChangeAdaptor)
def __init__ (self, filepath = None):
self.Registers = []
#get data from file
manager = ConfigManager(filepath)
root = manager.Tree.getroot()
#set prefixes and declare base number of registers
regPrefix = '$'
a = 'a'
aNum = None
f = 'f'
fNum = None
v = 'v'
vNUm = None
t = 't'
tNum = None
s = 's'
sNum = None
#add default registers
self.Registers.append({'assembly name': '$zero', 'value': 0, 'data type': 'Int'})
self.Registers.append({'assembly name': '$sp', 'value': None, 'data type': None})
self.Registers.append({'assembly name': '$ra', 'value': None, 'data type': None})
for Argument in root.iter('Argument'):
for things in Argument:
if things.tag == 'Number':
aNum = things.text
for i in range(int(aNum)):
self.Registers.append({'assembly name': regPrefix+a+str(i), 'value': None, 'data type' : None})
for Argument in root.iter('Return'):
for things in Argument:
if things.tag == 'Number':
vNum = things.text
for i in range(int(vNum)):
self.Registers.append({'assembly name': regPrefix+v+str(i), 'value': None, 'data type' : None})
for Argument in root.iter('Temporary'):
for things in Argument:
if things.tag == 'Number':
tNum = things.text
for i in range(int(tNum)):
self.Registers.append({'assembly name': regPrefix+t+str(i), 'value': None, 'data type' : None})
for Argument in root.iter('SavedTemporary'):
for things in Argument:
if things.tag == 'Number':
sNum = things.text
for i in range(int(sNum)):
self.Registers.append({'assembly name': regPrefix+s+str(i), 'value': None, 'data type' : None})
for Argument in root.iter('FTemp'):
for things in Argument:
if things.tag == 'Number':
fNum = things.text
for i in range(int(fNum)):
self.Registers.append({'assembly name': regPrefix+f+str(i), 'value': None, 'data type' : 'Float'})
def removeExpiredHeadlines(event, context):
# Handler to remove any headlines that are over 30 days old -- won't factor into prediction
# Create the required config -- might use context instead of event
config = ConfigManager(event['env'])
# Create dynamo config
dynamo = createDynamoInstance(event, config)
# Now scan and delete
collector = StockDataCollector()
stockInfo = collector.getAllCompanyInfo(fromDB=True, dynamo=dynamo)
for stock in stockInfo:
# Go through the headlines -- should be quick operation
stock['headlines'] = [headline for headline in stock['headlines'] if not datetime.strptime(headline['date'], '%Y-%m-%d').date() < datetime.now().date() - timedelta(days=30)]
# Update the stock in the Dynamo table -- should update with stale entries removed
collector.setHeadlinesForSymbol(stock['symbol'], stock['headlines'], dynamo)
print('Removed dead headlines')
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json'
}
}
def getHeadlines(event, context):
# Create the required config -- might use context instead of event
config = ConfigManager(event['queryStringParameters']['env'])
symbol = event['symbol']
# Create a stock data collector
collector = StockDataCollector()
dynamo = createDynamoInstance(event, config)
# Get the headlines from the dynamo table
headlines = collector.getHeadlinesForSymbol(symbol, dynamo)
# Return the headlines from the call
return {
'statusCode': 200,
'headers':{
'Content-Type': 'application/json',
},
'body': json.dumps({
'symbol': symbol,
'headlines': headlines
})
}
def __setup_fields(self):
config = ConfigManager.get_config()
cities = list(SeatFinder.cities.keys())
self.location_from['values'] = cities
self.location_from.set(config['from'])
self.location_to['values'] = cities
self.location_to.set(config['to'])
self.username.insert(0, config['username'])
self.password.insert(0, base64.b64decode(config['password']))
# Setting current date
self.date.insert(0, time.strftime("%d.%m."))
self.chrome_version['values'] = get_available_chrome_versions()
self.chrome_version.set(config['chrome_version'])
self.tariff['values'] = list(SeatFinder.tariffs.keys())
self.tariff.current(1 if config['tariff'] == 'student' else 0)
all_train_classes = SeatFinder.ticket_class_html_classes.keys()
for train_class in all_train_classes:
self.train_ticket_classes.insert('end', train_class)
for train_class in config['train_classes']:
self.train_ticket_classes.select_set(train_class)
def __init__(self, socketio, enable_led = True, path_to_rtkrcv = None, path_to_configs = None, path_to_str2str = None, path_to_gps_cmd_file = None):
# default state for RTKLIB is "inactive"
self.state = "inactive"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle base mode
self.rtkc = RtkController(path_to_rtkrcv)
self.conm = ConfigManager(path_to_configs)
# this one handles base settings
self.s2sc = Str2StrController(path_to_str2str, path_to_gps_cmd_file)
# basic synchronisation to prevent errors
self.saveState()
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
# we try to restore previous state
self.loadState()
def __init__(self, socketio, enable_led = True, rtkrcv_path = None, config_path = None, str2str_path = None, gps_cmd_file_path = None, log_path = None):
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtkrcv_path, config_path)
self.conm = ConfigManager(config_path)
# this one handles base settings
self.s2sc = Str2StrController(str2str_path, gps_cmd_file_path)
# take care of serving logs
self.logm = LogManager(log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
# we try to restore previous state
# in case we can't, we start as rover in single mode
self.loadState()
def __init__(self,files):
self.files = files
self.config = ConfigManager(os.environ['HOME']+'/.VideoBrowser/VideoBrowser.conf')
pixbuf = gtk.gdk.pixbuf_new_from_file(self.config.get_value('Appearance','bg_image'))
pixmap, mask = pixbuf.render_pixmap_and_mask()
width, height = pixmap.get_size()
del pixbuf
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_app_paintable(True)
if self.config.get_value('Appearance','fullscreen') == "true":
self.window.fullscreen()
else:
self.window.resize(width, height)
self.window.realize()
self.window.window.set_back_pixmap(pixmap, False)
del pixmap
self.window.set_keep_above(True)
self.window.connect("destroy",gtk.main_quit)
self.window.connect("key_press_event",self.key_pressed)
self.table = gtk.Table(3,2,False)
self.set_guiobjects()
self.window.add(self.table)
self.table.show()
self.window.show()
def __init__(self,
socketio,
rtklib_path=None,
enable_led=True,
log_path=None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target=self.setCorrectTime)
self.time_thread.start()
def __init__(self):
'''
Constructor
'''
Controller.controller = self
self.sysStatus = SystemStatus()
self.configMgr = ConfigManager()
self.statusMgr = StatusManager()
self.boardManager = RpiBoardManager()
self.eventProcessor = EventProcessor()
self.sensorMgr = SensorManager(self, self.eventProcessor)
self.scheduleManager = ScheduleManager(self, self.eventProcessor)
self.fileMon = FileMonitor(Constants.SYSTEM_CONFIG_FILE, self,
self.eventProcessor)
self.initializeStatus()
self.initializeScheduler()
self.controllerService = ControllerService(self)
def save_config(self):
config = {
'username':
self.username.get(),
'password':
base64.b64encode(
self.password.get().encode("utf-8")).decode('utf-8'),
'tariff':
self.tariff.get(),
'from':
self.location_from.get(),
'to':
self.location_to.get(),
'chrome_version':
self.chrome_version.get(),
'train_classes':
self.train_ticket_classes.curselection()
}
ConfigManager.set_config(config)
def __init__(self):
self.client = None
self.cfg = None
self.cmd_regex = re.compile('(?P<command>\w+)\s*(?P<args>.*)?')
self.settings = {}
self.data = {}
self.plugins = {}
# Set up logging
logging.basicConfig(filename='pixelbot.log',
format='[%(asctime)-15s] %(message)s',
level=logging.INFO)
logging.info('Pixel Bot initialized.')
# Load configuration
logging.info('Loading configuration file.')
self.cfg = ConfigManager('./config.ini')
# Load settings
logging.info('Loading settings.')
print('Loading settings.')
self.settings = {
'discord': {
'token':
self.cfg.get('token', section='discord'),
'mod_roles':
self.cfg.get('mod_roles', section='discord').split(',')
},
'options': {
'prefix': self.cfg.get('prefix', section='options')
},
'channels': {
'welcome': self.cfg.get('welcome', section='channels'),
}
}
# Load bot data
logging.info('Loading data.')
print('Loading data.')
self.data = json.loads(open('./data.json').read())
def __init__(self, config):
self.__config: ConfigManager = ConfigManager(config)
self.__yakuake = Yakuake(
sessions=QtDBus.QDBusInterface("org.kde.yakuake",
"/yakuake/sessions",
"org.kde.yakuake"),
tabs=QtDBus.QDBusInterface("org.kde.yakuake", "/yakuake/tabs",
"org.kde.yakuake"),
window=QtDBus.QDBusInterface("org.kde.yakuake", "/yakuake/window",
"org.kde.yakuake"))
def __init__(self, parent=None):
super(Scanner, self).__init__(parent)
self.cfg = ConfigManager()
self.progressbar = QProgressBar()
self.button = QPushButton('Start')
self.button.clicked.connect(self.handleButton)
self.clientIpComment = QLabel("Enter client IP:")
self.clientIpValue = QLineEdit()
self.clientIpValue.setText(self.cfg.getClientIp())
self.scanRangeLbl = QLabel("Choose port range:")
self.portFromLbl = QLabel("From")
self.portToLbl = QLabel("To")
self.portFromValue = QLineEdit('1')
self.portToValue = QLineEdit('90')
self.openedPortsLbl = QLabel('Open ports:')
self.openedPortsValue = QLineEdit()
self.closeBtn = QPushButton("Exit")
self.connect(self.closeBtn, SIGNAL("clicked()"), self, SLOT("close()"))
main_layout = QGridLayout()
main_layout.addWidget(self.clientIpComment, 0, 0)
main_layout.addWidget(self.clientIpValue, 0, 1)
main_layout.addWidget(self.scanRangeLbl, 1, 0)
main_layout.addWidget(self.portFromLbl, 2, 0)
main_layout.addWidget(self.portFromValue, 2, 1)
main_layout.addWidget(self.portToLbl, 2, 2)
main_layout.addWidget(self.portToValue, 2, 3)
main_layout.addWidget(self.button, 3, 0)
main_layout.addWidget(self.progressbar, 3, 1)
main_layout.addWidget(self.openedPortsLbl, 4, 0)
main_layout.addWidget(self.openedPortsValue, 4, 1)
main_layout.addWidget(self.closeBtn, 4, 3)
self.setLayout(main_layout)
self.setWindowTitle('Progress')
self._active = False
class Hydra(object):
'''
The big bad scary bot
'''
def __init__(self):
self.startChannel = '#hydra'
self.configManager = ConfigManager()
self.config = self.configManager.getConfig()
self.configManager.registerListener(self)
self.auth = Authenticator(self.configManager)
n = self.config['network']
p = self.config['port']
b = botFactory(self.startChannel, self.configManager, self.auth)
reactor.connectTCP(n, p, b) # @UndefinedVariable
reactor.run() # @UndefinedVariable
def reloadConfig(self):
self.config = self.configManager.getConfig()
def __init__(self):
self.cm = ConfigManager()
#print sys.argv[1]
self.logger = logging.getLogger('insert')
hdlr = logging.FileHandler(self.cm.getInsertLog())
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
self.logger.setLevel(logging.WARNING)
self.logger.setLevel(logging.INFO)
self.con = cx_Oracle.connect(self.cm.getDBConnection())
self.logger.info('connect to db')
self.cur = self.con.cursor()
self.parse()
self.cur.close()
#print "End."
self.con.close()
self.logger.info('disconnect db')
class ConfigManagerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
"""Runs once for this class"""
print "Testing ConfigManager"
def setUp(self):
"""Runs before every test case"""
self.configManager = ConfigManager()
self.configManager.read("application.config")
def tearDown(self):
"""Runs after every test case"""
self.configManager = None
def test_if_config_file_has_content(self):
self.assertNotEqual(len(self.configManager._dictionary), 0,
"Config file content could not be loaded")
def test_if_value_is_returned_for_an_existing_property(self):
self.assertEqual(
self.configManager.getPropertyValue("log", "log_file_name"),
"application.log")
def test_if_None_is_returned_for_a_non_existing_property(self):
self.assertEqual(
self.configManager.getPropertyValue("log", "non_existing_key"),
None)
def test_if_None_is_returned_for_a_non_existing_section(self):
self.assertEqual(
self.configManager.getPropertyValue("non_existing_section",
"log_file_name"), None)
def test_if_None_is_returned_for_a_non_existing_section_and_property(self):
self.assertEqual(
self.configManager.getPropertyValue("non_existing_section",
"non_existing_key"), None)
def test_if_list_is_returned_for_a_property(self):
to_email_ids = ast.literal_eval(
self.configManager.getPropertyValue('emails', 'to.email.ids.list'))
to_cc_email_ids = ast.literal_eval(
self.configManager.getPropertyValue(
'emails', 'to.cc.email.ids.list')) # CC Email Ids
self.assertEqual(len(to_email_ids), 2)
self.assertEqual(len(to_cc_email_ids), 2)
class ConfigManagerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
"""Runs once for this Class"""
def setUp(self):
"""Runs before every test case"""
self.configManager = ConfigManager()
self.configManager.read("application.config")
def tearDown(self):
"""Runs after every test case"""
self.configManager = None
def test_if_config_file_has_content(self):
self.assertNotEqual(len(self.configManager._dictionary), 0, "Config file content could not be loaded")
def test_if_value_is_returned_for_an_existing_property(self):
self.assertEqual(self.configManager.getPropertyValue("log", "log_file_name"), "application.log")
def test_if_None_is_returned_for_a_non_existing_property(self):
self.assertEqual(self.configManager.getPropertyValue("log", "non_existing_key"), None)
def test_if_None_is_returned_for_a_non_existing_section(self):
self.assertEqual(self.configManager.getPropertyValue("non_existing_section", "log_file_name"), None)
@unittest.skip("Non Existent Section and Key. A sub test")
def test_if_None_is_returned_for_a_non_existing_section_and_property(self):
self.assertEqual(self.configManager.getPropertyValue("non_existing_section", "non_existing_key"), None)
def main():
log = setup_logging("sentinal.log")
parser = argparse.ArgumentParser(description='Grabs sentinal images from the ESA stite',
epilog='-h for help',
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('-c', action="store_true", help='create db table only', dest='create_db')
parser.add_argument('-C', type=str, help='path to the configuration file', dest='configuration_file')
parser.add_argument('-f', action="store_true", help='force', dest='force')
parser.add_argument('-v', action="store_true", help='run verbosely', dest='verbose')
parser.add_argument('-o', action="store_true", help='overwrite data .zip file even if it exists', dest='overwrite')
args = parser.parse_args()
db = Database(args)
if args.create_db:
db.createDb(args.verbose)
sys.exit(0)
config = ConfigManager(args.configuration_file,log)
auth = config.getAuth()
if not len(auth):
log.error('Missing ESA SCIHUB authentication information')
sys.exit(7)
types = config.getTypes()
polygons = config.getPolygons()
if len(types) != len(polygons):
log.error( 'Incorrect number of polygons and types in configuration file' )
sys.exit(6)
downloader = Downloader(args, config, db, log)
downloader.getProducts()
downloader.downloadProducts()
def __init__(self, project_config_filename):
# 创建配置文件管理器, 读取配置文件
self.conf = ConfigManager()
self.conf.load_project_config(project_config_filename)
# 从配置文件获取数据库信息
db_host = self.conf.dict['database']['host']
db_port = self.conf.dict['database']['port']
db_db = self.conf.dict['database']['db']
db_passwd = self.conf.dict['database']['password']
db_user = self.conf.dict['database']['user']
# 连接数据库, 创建数据库管理器
self.db = PyGdbDb(db_host, db_port, db_db, db_user, db_passwd)
def __init__(self):
self.config = ConfigManager()
self.db = DBManager()
self.report = Report(self.config, self.db)
if self.config.hostsToPing[0] is '' and len(
self.config.hostsToPing) is 1:
print("No hosts to ping")
sys.exit()
# Perform pings
for host in self.config.hostsToPing:
self.ping(host)
# self.db.PrintResultsTable() # Used for testing
self.report.SendReport() # Send report if needed
def initializeCompanies(event, context):
# Create the required config -- might use context instead of event
config = ConfigManager(event['env'])
# Create a stock data collector
collector = StockDataCollector()
dynamo = createDynamoInstance(event, config)
# Store the company info
collector.storeAllCompanyInfo(dynamo)
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json'
}
}
def __init__(self, socketio, rtklib_path = None, enable_led = True, log_path = None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
class ConfigManagerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
"""Runs once for this class"""
print "Testing ConfigManager"
def setUp(self):
"""Runs before every test case"""
self.configManager = ConfigManager()
self.configManager.read("application.config")
def tearDown(self):
"""Runs after every test case"""
self.configManager = None
def test_if_config_file_has_content(self):
self.assertNotEqual(len(self.configManager._dictionary), 0, "Config file content could not be loaded")
def test_if_value_is_returned_for_an_existing_property(self):
self.assertEqual(self.configManager.getPropertyValue("log", "log_file_name"), "application.log")
def test_if_None_is_returned_for_a_non_existing_property(self):
self.assertEqual(self.configManager.getPropertyValue("log", "non_existing_key"), None)
def test_if_None_is_returned_for_a_non_existing_section(self):
self.assertEqual(self.configManager.getPropertyValue("non_existing_section", "log_file_name"), None)
def test_if_None_is_returned_for_a_non_existing_section_and_property(self):
self.assertEqual(self.configManager.getPropertyValue("non_existing_section", "non_existing_key"), None)
def test_if_list_is_returned_for_a_property(self):
to_email_ids = ast.literal_eval(self.configManager.getPropertyValue('emails', 'to.email.ids.list'))
to_cc_email_ids = ast.literal_eval(
self.configManager.getPropertyValue('emails', 'to.cc.email.ids.list')) # CC Email Ids
self.assertEqual(len(to_email_ids), 2)
self.assertEqual(len(to_cc_email_ids), 2)
def __init__(self, parent=None):
super(Scanner, self).__init__(parent)
self.cfg = ConfigManager()
self.progressbar = QProgressBar()
self.button = QPushButton('Start')
self.button.clicked.connect(self.handleButton)
self.clientIpComment = QLabel("Enter client IP:")
self.clientIpValue = QLineEdit()
self.clientIpValue.setText(self.cfg.getClientIp())
self.scanRangeLbl = QLabel("Choose port range:")
self.portFromLbl = QLabel("From")
self.portToLbl = QLabel("To")
self.portFromValue = QLineEdit('1')
self.portToValue = QLineEdit('90')
self.openedPortsLbl = QLabel('Open ports:')
self.openedPortsValue = QLineEdit()
self.closeBtn = QPushButton("Exit")
self.connect(self.closeBtn,SIGNAL("clicked()"),self,SLOT("close()"))
main_layout = QGridLayout()
main_layout.addWidget(self.clientIpComment,0,0)
main_layout.addWidget(self.clientIpValue,0,1)
main_layout.addWidget(self.scanRangeLbl,1,0)
main_layout.addWidget(self.portFromLbl,2,0)
main_layout.addWidget(self.portFromValue,2,1)
main_layout.addWidget(self.portToLbl,2,2)
main_layout.addWidget(self.portToValue,2,3)
main_layout.addWidget(self.button, 3, 0)
main_layout.addWidget(self.progressbar, 3, 1)
main_layout.addWidget(self.openedPortsLbl,4,0)
main_layout.addWidget(self.openedPortsValue,4,1)
main_layout.addWidget(self.closeBtn,4,3)
self.setLayout(main_layout)
self.setWindowTitle('Progress')
self._active = False
def __init__(self):
self.cm = ConfigManager()
#print sys.argv[1]
self.logger = logging.getLogger('insert')
hdlr = logging.FileHandler(self.cm.getInsertLog())
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
self.logger.setLevel(logging.WARNING)
self.logger.setLevel(logging.INFO)
self.con = cx_Oracle.connect(self.cm.getDBConnection())
self.logger.info('connect to db')
self.cur = self.con.cursor()
self.parse()
self.cur.close()
#print "End."
self.con.close()
self.logger.info('disconnect db')
def __init__(self, parent=None):
super(ScannerMainWindow, self).__init__(parent)
self.engine = Engine(self)
self.setMinimumSize(850, 200)
cfg = ConfigManager()
self.currentRowIndex = 0
self.headerCount = 5
header = QStringList()
header = [
"Client adress", "Connection status", "Thread number",
"Requested host", "Request status"
]
self.tableView = QTableWidget(10, 5)
closeBtn = QPushButton("Exit")
for section in xrange(self.headerCount):
self.tableView.horizontalHeader().resizeSection(section, 150)
self.tableView.setHorizontalHeaderLabels(header)
layout = QGridLayout()
layoutH = QHBoxLayout()
layout.addWidget(self.tableView)
layout.addWidget(closeBtn, 1, 2)
self.setLayout(layout)
self.connect(closeBtn, SIGNAL("clicked()"), self, SLOT("close()"))
print "Active threads:", threading.activeCount()
self.engine_thread = threading.Thread(target=self.engine.run)
self.engine_thread.daemon = True
self.engine_thread.start()
parser.add_argument('--swarm-master', dest='swarm_master',
action='store_true', default=False,
help='Whether or not this machine will be a swarm '
'master.')
parser.add_argument('action', choices=action_mappings,
help='The action to perform: {actions}'.format(
', '.join(action_mappings)))
parser.add_argument('name', nargs='?',
help='The name of the machine to use.')
args = parser.parse_args()
if args.debug is True:
os.environ['UTILS_DEBUG'] = 'true'
elif args.debug is False:
os.environ['UTILS_DEBUG'] = 'false'
config_manager = ConfigManager(args.config_directory, filter='machine')
if args.action not in actions_without_name and not args.name:
printe('Action "%s" requires a name.' % args.action)
printe(parser.format_usage(), terminate=2)
if args.action == 'kinds':
printe("Here's a list of available kinds to create machines from:",
flush=True)
print('\n'.join(config_manager.listMachines()), flush=True)
printe('To create one, use the "create" action, supply a name, and '
'put kind:flavor on the end.')
elif args.action in actions_without_name:
action_mappings[args.action]()
elif args.action == 'create':
machine_config = dict(vars(args))
if 'consul_machine' in machine_config:
class RTKLIB:
# we will save RTKLIB state here for later loading
state_file = "/home/reach/.reach/rtk_state"
def __init__(self, socketio, enable_led = True, path_to_rtkrcv = None, path_to_configs = None, path_to_str2str = None, path_to_gps_cmd_file = None):
# default state for RTKLIB is "inactive"
self.state = "inactive"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle base mode
self.rtkc = RtkController(path_to_rtkrcv)
self.conm = ConfigManager(path_to_configs)
# this one handles base settings
self.s2sc = Str2StrController(path_to_str2str, path_to_gps_cmd_file)
# basic synchronisation to prevent errors
self.saveState()
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
# we try to restore previous state
self.loadState()
def launchRover(self, config_name = None):
# config_name may be a name, or a full path
# if the parameter contains "/", then we consider it a full path
# else, we will be looking for it one directory higher than the rtkrcv bin
self.semaphore.acquire()
print("Attempting to launch rtkrcv...")
if config_name == None:
res = self.rtkc.launch()
else:
res = self.rtkc.launch(config_name)
if res < 0:
print("rtkrcv launch failed")
elif res == 1:
print("rtkrcv launch successful")
self.state = "rover"
elif res == 2:
print("rtkrcv already launched")
self.state = "rover"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode launched")
self.semaphore.release()
return res
def shutdownRover(self):
self.stopRover()
self.semaphore.acquire()
print("Attempting rtkrcv shutdown")
res = self.rtkc.shutdown()
if res < 0:
print("rtkrcv shutdown failed")
elif res == 1:
print("rtkrcv shutdown successful")
self.state = "inactive"
elif res == 2:
print("rtkrcv already shutdown")
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode shutdown")
self.semaphore.release()
return res
def startRover(self):
self.semaphore.acquire()
print("Attempting to start rtkrcv...")
res = self.rtkc.start()
if res == -1:
print("rtkrcv start failed")
elif res == 1:
print("rtkrcv start successful")
print("Starting coordinate and satellite broadcast")
elif res == 2:
print("rtkrcv already started")
# start fresh data broadcast
self.server_not_interrupted = True
if self.satellite_thread is None:
self.satellite_thread = Thread(target = self.broadcastSatellites)
self.satellite_thread.start()
if self.coordinate_thread is None:
self.coordinate_thread = Thread(target = self.broadcastCoordinates)
self.coordinate_thread.start()
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopRover(self):
self.semaphore.acquire()
print("Attempting to stop RTKLIB...")
res = self.rtkc.stop()
if res == -1:
print("rtkrcv stop failed")
elif res == 1:
print("rtkrcv stop successful")
elif res == 2:
print("rtkrcv already stopped")
self.server_not_interrupted = False
if self.satellite_thread is not None:
self.satellite_thread.join()
self.satellite_thread = None
if self.coordinate_thread is not None:
self.coordinate_thread.join()
self.coordinate_thread = None
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def launchBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this launchBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.semaphore.acquire()
self.state = "base"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode launched")
self.semaphore.release()
def shutdownBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this shutdownBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.stopBase()
self.semaphore.acquire()
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode shutdown")
self.semaphore.release()
def startBase(self, rtcm3_messages = None, base_position = None, gps_cmd_file = None):
self.semaphore.acquire()
print("Attempting to start str2str...")
if not self.rtkc.started:
res = self.s2sc.start(rtcm3_messages, base_position, gps_cmd_file)
if res < 0:
print("str2str start failed")
elif res == 1:
print("str2str start successful")
elif res == 2:
print("str2str already started")
else:
print("Can't start str2str with rtkrcv still running!!!!")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopBase(self):
self.semaphore.acquire()
print("Attempting to stop str2str...")
res = self.s2sc.stop()
if res == -1:
print("str2str stop failed")
elif res == 1:
print("str2str stop successful")
elif res == 2:
print("str2str already stopped")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def readConfigBase(self):
self.semaphore.acquire()
print("Got signal to read current base config")
self.socketio.emit("current config base", self.s2sc.readConfig(), namespace = "/test")
self.semaphore.release()
def writeConfigBase(self, config):
self.semaphore.acquire()
print("Got signal to write current base config")
self.s2sc.writeConfig(config)
print("Restarting str2str...")
res = self.s2sc.stop() + self.s2sc.start()
if res > 1:
print("Restart successful")
else:
print("Restart failed")
self.saveState()
self.semaphore.release()
return res
def writeConfigRover(self, config):
# config dict must include config_name field
self.semaphore.acquire()
print("Got signal to write current rover config")
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
self.conm.writeConfig(config_file, config)
print("Reloading with new config...")
res = self.rtkc.loadConfig(self.rtkc.current_config) + self.rtkc.restart()
if res == 2:
print("Restart successful")
elif res == 1:
print("rtkrcv started instead of restart")
elif res == -1:
print("rtkrcv restart failed")
self.saveState()
self.semaphore.release()
return res
def readConfigRover(self, config):
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to read the current rover config")
self.conm.readConfig(config_file)
# after this, to preserve the order of the options in the frontend we send a special order message
print("Sending rover config order")
options_order = {}
# create a structure the corresponds to the options order
for index, value in enumerate(self.conm.buff_dict_order):
options_order[str(index)] = value
# send the options order
self.socketio.emit("current config rover order", options_order, namespace="/test")
# send the options comments
print("Sending rover config comments")
self.socketio.emit("current config rover comments", self.conm.buff_dict_comments, namespace="/test")
# now we send the whole config with values
print("Sending rover config values")
self.socketio.emit("current config rover", self.conm.buff_dict, namespace="/test")
self.semaphore.release()
def saveState(self):
# save current state for future resurrection:
# state is a list of parameters:
# rover state example: ["rover", "started", "reach_single_default.conf"]
# base state example: ["base", "stopped", "input_stream", "output_stream"]
state = {}
# save "rover", "base" or "inactive" state
state["state"] = self.state
if self.state == "rover":
started = self.rtkc.started
elif self.state == "base":
started = self.s2sc.started
elif self.state == "inactive":
started = False
state["started"] = "yes" if started else "no"
# dump rover state
state["rover"] = {"current_config": self.rtkc.current_config}
# dump rover state
state["base"] = {
"input_stream": self.s2sc.input_stream,
"output_stream": self.s2sc.output_stream,
"rtcm3_messages": self.s2sc.rtcm3_messages,
"base_position": self.s2sc.base_position,
"gps_cmd_file": self.s2sc.gps_cmd_file
}
with open(self.state_file, "w") as f:
json.dump(state, f, sort_keys = True, indent = 4)
return state
def byteify(self, input):
# thanks to Mark Amery from StackOverFlow for this awesome function
if isinstance(input, dict):
return {self.byteify(key): self.byteify(value) for key, value in input.iteritems()}
elif isinstance(input, list):
return [self.byteify(element) for element in input]
elif isinstance(input, unicode):
return input.encode('utf-8')
else:
return input
def readState(self):
# load previously saved state
# we assume this function is not to be run until the very end of __init__ of RTKLIB
print("Trying to load previously saved state...")
try:
f = open(self.state_file, "r")
except IOError:
# can't find the file, let's create a new one with default state
print("Could not find existing state, saving default...")
self.saveState()
return -1
else:
print("Found existing state...")
json_state = json.load(f)
f.close()
# convert unicode strings to normal
json_state = self.byteify(json_state)
return json_state
def loadState(self):
# load previously saved state
# we assume this function is not to be run until the very end of __init__ of RTKLIB
print("Trying to load previously saved state...")
try:
f = open(self.state_file, "r")
except IOError:
# can't find the file, let's create a new one with default state
print("Could not find existing state, saving default...")
return self.saveState()
else:
print("Found existing state...")
json_state = json.load(f)
f.close()
# convert unicode strings to normal
json_state = self.byteify(json_state)
# first, we restore the base state, because no matter what we end up doing,
# we need to restore base state
self.s2sc.input_stream = json_state["base"]["input_stream"]
self.s2sc.output_stream = json_state["base"]["output_stream"]
self.s2sc.rtcm3_messages = json_state["base"]["rtcm3_messages"]
self.s2sc.base_position = json_state["base"]["base_position"]
self.s2sc.gps_cmd_file = json_state["base"]["gps_cmd_file"]
if json_state["state"] == "rover":
saved_config = json_state["rover"]["current_config"]
if saved_config == "":
saved_config = None
self.launchRover(saved_config)
if json_state["started"] == "yes":
self.startRover()
elif json_state["state"] == "base":
self.launchBase()
if json_state["started"] == "yes":
self.startBase()
print("State loaded")
return json_state
# if we are "inactive", don't do anything as this the default state
def sendState(self):
# send current state to every connecting browser
state = self.loadState()
self.socketio.emit("current state", state, namespace = "/test")
def updateLED(self):
blink_pattern = ""
delay = 0.5
if self.state == "base":
if self.s2sc.started:
# we have a started base
blink_pattern = "green,off,magenta,off"
else:
# we have a stopped base
blink_pattern = "red,off,magenta,off"
elif self.state == "rover":
if self.rtkc.started:
# we have a started rover
status_pattern_dict = {
"fix": "blue,off,green,off",
"float": "blue,off,green,off,yellow,off",
"single": "blue,off,yellow,off"
}
# we need to acquire RtkController in case it's currently updating info dict
self.rtkc.semaphore.acquire()
current_rover_solutuon_status = self.rtkc.info.get("solution_status", "")
self.rtkc.semaphore.release()
blink_pattern = status_pattern_dict.get(current_rover_solutuon_status, "blue,off")
else:
# we have a stopped rover
blink_pattern = "blue,off,red,off"
elif self.state == "inactive":
blink_pattern = "yellow, off"
delay = 1
if blink_pattern:
# check blink_pattern contains something new
if blink_pattern != self.led.current_blink_pattern:
# if we decided we need a new pattern, then start blinking it
self.led.startBlinker(blink_pattern, delay)
# thread workers for broadcasing rtkrcv status
# this function reads satellite levels from an exisiting rtkrcv instance
# and emits them to the connected browser as messages
def broadcastSatellites(self):
count = 0
while self.server_not_interrupted:
# update satellite levels
self.rtkc.getObs()
if count % 10 == 0:
print("Sending sat rover levels:\n" + str(self.rtkc.obs_rover))
print("Sending sat base levels:\n" + str(self.rtkc.obs_base))
self.socketio.emit("satellite broadcast rover", self.rtkc.obs_rover, namespace = "/test")
self.socketio.emit("satellite broadcast base", self.rtkc.obs_base, namespace = "/test")
count += 1
time.sleep(1)
# this function reads current rtklib status, coordinates and obs count
def broadcastCoordinates(self):
count = 0
while self.server_not_interrupted:
# update RTKLIB status
self.rtkc.getStatus()
if count % 10 == 0:
print("Sending RTKLIB status select information:")
print(self.rtkc.info)
self.socketio.emit("coordinate broadcast", self.rtkc.info, namespace = "/test")
if self.enable_led:
self.updateLED()
count += 1
time.sleep(1)
os.environ['UTILS_DEBUG'] = 'false'
if args.action == 'create' or args.action == 'run' \
and not vars(args)['kind:flavor']:
printe('No kind provided for action "create".')
printe(parser.format_usage(), terminate=2)
if args.action not in actions_without_name and not args.name:
if args.action in ('desc', 'describe'):
printe('Container kind:flavor required for action "{action}". Use '
'action "kinds" to list available options.'.format(
args.action), terminate=2)
printe('Container name required for action "{action}".'.format(
args.action), terminate=2)
config_manager = ConfigManager(args.config_directory, filter='container')
if args.action in ('run', 'create', 'describe', 'desc'):
# if not args.machine and args.host:
# args.machine = re.search(r"\w+\://([^:]+)(?:\:[0-9]+)?",
# args.host).group(1)
# else:
# print('"', args.machine, '"')
# print('"', args.host, '"')
if args.action == 'create' or args.action == 'run':
kind_and_flavor = vars(args)['kind:flavor']
else:
kind_and_flavor = args.name
(kind, _, flavor) = kind_and_flavor.partition(':')
if args.action == 'create' or args.action == 'run':
config = config_manager.getContainerConfig(kind, flavor)
def __init__(self): self.configManager = ConfigManager() self.console = None self.loadScriptWindow = None self.interface=None self.p = None
class mnu_EDUCIAA:
def __init__(self):
self.configManager = ConfigManager()
self.console = None
self.loadScriptWindow = None
self.interface=None
self.p = None
def item_Console(self,menuItem,interface):
self.console = Console(interface.get_base_path())
config = self.__getConfigData()
if self.console.showConsole(config["port"]):
self.console.addText(config["port"] + " Opened.\n")
else:
interface.message("Error opening serial port: "+config["port"])
self.console.closeConsole()
self.console = None
def item_Load_Script(self,menuItem,interface):
if self.console!=None:
self.console.closeConsole()
self.console = None
config = self.__getConfigData()
if self.loadScriptWindow==None:
protocol = Protocol(config["port"])
self.loadScriptWindow = LoadScriptWindow(protocol,interface.get_filename(),self.__loadScriptWindowCloseEvent,interface.get_base_path()) # show status window
def item_Snippets(self,menuItem,interface):
self.interface=interface
self.snippetsW = SnippetsWindow(self.__callbackInsertSnippet,interface.get_base_path())
def item_Configuration(self,menuItem,interface):
config = self.configManager.readConfig()
print(config)
self.configW = ConfigWindow(self.__callbackPort,config["port"],interface.get_base_path(),config["pathEmulator"]) # show config window
def item_Emulator(self,menuItem,interface):
config = self.__getConfigData()
signal.signal(signal.SIGINT,signal.SIG_IGN)
signal.signal(signal.SIGTERM,signal.SIG_IGN)
try:
parts = config["pathEmulator"].split(" ")
if len(parts)>=2 and parts[0]=="python":
self.p = subprocess.Popen(["python",parts[1], interface.get_filename()])
else:
self.p = subprocess.Popen([config["pathEmulator"], interface.get_filename()])
#self.p.communicate()
except Exception as e:
interface.message("Error opening emulator:"+str(e))
def item_Tips(self,menuItem,interface):
self.interface=interface
self.tipsWindow = TipsWindow(None,interface.get_base_path())
self.tipsWindow.showTips(True)
def __callbackInsertSnippet(self,data):
code = data[0]
self.interface.insert(code)
def __callbackPort(self,data):
self.configManager.writeConfig(data[0],data[1])
def __getConfigData(self):
config = self.configManager.readConfig()
if config.has_key("port")==False:
ports = list(serial.tools.list_ports.comports())
config["port"] = ports[0][0] #default port
return config
def __loadScriptWindowCloseEvent(self):
self.loadScriptWindow = None
class Scanner(QWidget):
def __init__(self, parent=None):
super(Scanner, self).__init__(parent)
self.cfg = ConfigManager()
self.progressbar = QProgressBar()
self.button = QPushButton('Start')
self.button.clicked.connect(self.handleButton)
self.clientIpComment = QLabel("Enter client IP:")
self.clientIpValue = QLineEdit()
self.clientIpValue.setText(self.cfg.getClientIp())
self.scanRangeLbl = QLabel("Choose port range:")
self.portFromLbl = QLabel("From")
self.portToLbl = QLabel("To")
self.portFromValue = QLineEdit('1')
self.portToValue = QLineEdit('90')
self.openedPortsLbl = QLabel('Open ports:')
self.openedPortsValue = QLineEdit()
self.closeBtn = QPushButton("Exit")
self.connect(self.closeBtn,SIGNAL("clicked()"),self,SLOT("close()"))
main_layout = QGridLayout()
main_layout.addWidget(self.clientIpComment,0,0)
main_layout.addWidget(self.clientIpValue,0,1)
main_layout.addWidget(self.scanRangeLbl,1,0)
main_layout.addWidget(self.portFromLbl,2,0)
main_layout.addWidget(self.portFromValue,2,1)
main_layout.addWidget(self.portToLbl,2,2)
main_layout.addWidget(self.portToValue,2,3)
main_layout.addWidget(self.button, 3, 0)
main_layout.addWidget(self.progressbar, 3, 1)
main_layout.addWidget(self.openedPortsLbl,4,0)
main_layout.addWidget(self.openedPortsValue,4,1)
main_layout.addWidget(self.closeBtn,4,3)
self.setLayout(main_layout)
self.setWindowTitle('Progress')
self._active = False
def handleButton(self):
if not self._active:
self._active = True
self.button.setText('Stop')
if self.progressbar.value() == self.progressbar.maximum():
self.progressbar.reset()
QTimer.singleShot(0, self.startLoop)
else:
self._active = False
def closeEvent(self, event):
self._active = False
def startLoop(self):
host= self.cfg.getClientIp()
ports=[]
openPorts=[]
minimum = int(self.portFromValue.text())
maximum = int(self.portToValue.text())
if minimum > maximum:
self.show_info("Minimum is bigger than maximum. Please check the values.")
self.button.setText('Start')
self._active = False
self.openedPortsValue.setText('0')
return
self.progressbar.setMinimum(minimum)
self.progressbar.setMaximum(maximum)
# generate ports set
for i in xrange(minimum,maximum+1):
ports.append(i)
while True:
time.sleep(0.05)
for port in ports:
print port
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.settimeout(0.1)
if not sock.connect_ex((host,port)):
print("Port %s is closed" % port )
else:
openPorts.append(port)
print("Port %s is open" % port)
sock.close()
value = port
print 'value',value
self.progressbar.setValue(value)
qApp.processEvents()
if (not self._active or
value >= self.progressbar.maximum()):
self.savePorts(openPorts)
self.show_info("Scanning finished.")
self.openedPortsValue.setText(str(len(openPorts)))
self.button.setText('Start')
self._active = False
break
def savePorts(self,openPorts):
fileName = self.cfg.getSaveFile()+'_'+str(int(time.time()))
with open(fileName,'w') as f:
for port in openPorts:
f.write(str(port)+'\n')
def show_info(self,e):
msgBox = QMessageBox()
msgBox.setText(str(e))
msgBox.setStandardButtons(QMessageBox.Ok)
ret = msgBox.exec_();
class RTKLIB:
# we will save RTKLIB state here for later loading
state_file = "/home/reach/.reach/rtk_state"
def __init__(self, socketio, enable_led = True, rtkrcv_path = None, config_path = None, str2str_path = None, gps_cmd_file_path = None, log_path = None):
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtkrcv_path, config_path)
self.conm = ConfigManager(config_path)
# this one handles base settings
self.s2sc = Str2StrController(str2str_path, gps_cmd_file_path)
# take care of serving logs
self.logm = LogManager(log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
# we try to restore previous state
# in case we can't, we start as rover in single mode
self.loadState()
def launchRover(self, config_name = None):
# config_name may be a name, or a full path
# if the parameter contains "/", then we consider it a full path
# else, we will be looking for it one directory higher than the rtkrcv bin
self.semaphore.acquire()
print("Attempting to launch rtkrcv...")
if config_name == None:
res = self.rtkc.launch()
else:
res = self.rtkc.launch(config_name)
if res < 0:
print("rtkrcv launch failed")
elif res == 1:
print("rtkrcv launch successful")
self.state = "rover"
elif res == 2:
print("rtkrcv already launched")
self.state = "rover"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode launched")
self.semaphore.release()
return res
def shutdownRover(self):
self.stopRover()
self.semaphore.acquire()
print("Attempting rtkrcv shutdown")
res = self.rtkc.shutdown()
if res < 0:
print("rtkrcv shutdown failed")
elif res == 1:
print("rtkrcv shutdown successful")
self.state = "inactive"
elif res == 2:
print("rtkrcv already shutdown")
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode shutdown")
self.semaphore.release()
return res
def startRover(self):
self.semaphore.acquire()
print("Attempting to start rtkrcv...")
res = self.rtkc.start()
if res == -1:
print("rtkrcv start failed")
elif res == 1:
print("rtkrcv start successful")
print("Starting coordinate and satellite broadcast")
elif res == 2:
print("rtkrcv already started")
# start fresh data broadcast
self.server_not_interrupted = True
if self.satellite_thread is None:
self.satellite_thread = Thread(target = self.broadcastSatellites)
self.satellite_thread.start()
if self.coordinate_thread is None:
self.coordinate_thread = Thread(target = self.broadcastCoordinates)
self.coordinate_thread.start()
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopRover(self):
self.semaphore.acquire()
print("Attempting to stop RTKLIB...")
res = self.rtkc.stop()
if res == -1:
print("rtkrcv stop failed")
elif res == 1:
print("rtkrcv stop successful")
elif res == 2:
print("rtkrcv already stopped")
self.server_not_interrupted = False
if self.satellite_thread is not None:
self.satellite_thread.join()
self.satellite_thread = None
if self.coordinate_thread is not None:
self.coordinate_thread.join()
self.coordinate_thread = None
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def launchBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this launchBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.semaphore.acquire()
self.state = "base"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode launched")
self.semaphore.release()
def shutdownBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this shutdownBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.stopBase()
self.semaphore.acquire()
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode shutdown")
self.semaphore.release()
def startBase(self, rtcm3_messages = None, base_position = None, gps_cmd_file = None):
self.semaphore.acquire()
print("Attempting to start str2str...")
if not self.rtkc.started:
res = self.s2sc.start(rtcm3_messages, base_position, gps_cmd_file)
if res < 0:
print("str2str start failed")
elif res == 1:
print("str2str start successful")
elif res == 2:
print("str2str already started")
else:
print("Can't start str2str with rtkrcv still running!!!!")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopBase(self):
self.semaphore.acquire()
print("Attempting to stop str2str...")
res = self.s2sc.stop()
if res == -1:
print("str2str stop failed")
elif res == 1:
print("str2str stop successful")
elif res == 2:
print("str2str already stopped")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def readConfigBase(self):
self.semaphore.acquire()
print("Got signal to read base config")
self.socketio.emit("current config base", self.s2sc.readConfig(), namespace = "/test")
self.semaphore.release()
def writeConfigBase(self, config):
self.semaphore.acquire()
print("Got signal to write base config")
self.s2sc.writeConfig(config)
print("Restarting str2str...")
res = self.s2sc.stop() + self.s2sc.start()
if res > 1:
print("Restart successful")
else:
print("Restart failed")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def writeConfigRover(self, config):
# config dict must include config_name field
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to write rover config to file " + config_file)
self.conm.writeConfig(config_file, config)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
self.semaphore.release()
def loadConfigRover(self, config_file = None):
# we might want to write the config, but dont need to load it every time
self.semaphore.acquire()
if config_file == None:
config_file == self.conm.default_rover_config
print("Loading config " + config_file)
# loading config to rtkrcv
if self.rtkc.loadConfig(config_file) < 0:
print("ERROR: failed to load config!!!")
print("abort load")
self.semaphore.release()
return -1
print("load successful!")
print("Now we need to restart rtkrcv for the changes to take effect")
if self.rtkc.started:
print("rtkrcv is already started, we need to do a simple restart!")
res = self.rtkc.restart()
if res == 3:
print("Restart successful")
print(config_file + " config loaded")
elif res == 1:
print("rtkrcv started instead of restart")
elif res < 1:
print("ERROR: rtkrcv restart failed")
self.semaphore.release()
self.saveState()
return res
else:
print("We were not started before, so we need to perform a full start")
self.semaphore.release()
return self.startRover()
def readConfigRover(self, config):
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to read the rover config")
print("Sending rover config " + config_file)
# read from file
self.conm.readConfig(config_file)
# send to the browser
self.socketio.emit("current config rover", self.conm.buffered_config.items, namespace="/test")
self.semaphore.release()
def shutdown(self):
# shutdown whatever mode we are in. stop broadcast threads
# clean up broadcast and blink threads
self.server_not_interrupted = False
self.led.blinker_not_interrupted = False
if self.coordinate_thread is not None:
self.coordinate_thread.join()
if self.satellite_thread is not None:
self.satellite_thread.join()
if self.led.blinker_thread is not None:
self.led.blinker_thread.join()
# shutdown base or rover
if self.state == "rover":
return self.shutdownRover()
elif self.state == "base":
return self.shutdownBase()
# otherwise, we are inactive
return 1
def deleteConfig(self, config_name):
# pass deleteConfig to conm
print("Got signal to delete config " + config_name)
self.conm.deleteConfig(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def resetConfigToDefault(self, config_name):
# pass reset config to conm
print("Got signal to reset config " + config_name)
self.conm.resetConfigToDefault(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def saveState(self):
# save current state for future resurrection:
# state is a list of parameters:
# rover state example: ["rover", "started", "reach_single_default.conf"]
# base state example: ["base", "stopped", "input_stream", "output_stream"]
state = {}
# save "rover", "base" or "inactive" state
state["state"] = self.state
if self.state == "rover":
started = self.rtkc.started
elif self.state == "base":
started = self.s2sc.started
elif self.state == "inactive":
started = False
state["started"] = "yes" if started else "no"
# dump rover state
state["rover"] = {"current_config": self.rtkc.current_config}
# dump rover state
state["base"] = {
"input_stream": self.s2sc.input_stream,
"output_stream": self.s2sc.output_stream,
"rtcm3_messages": self.s2sc.rtcm3_messages,
"base_position": self.s2sc.base_position,
"gps_cmd_file": self.s2sc.gps_cmd_file
}
print("DEBUG saving state")
print(str(state))
with open(self.state_file, "w") as f:
json.dump(state, f, sort_keys = True, indent = 4)
return state
def byteify(self, input):
# thanks to Mark Amery from StackOverFlow for this awesome function
if isinstance(input, dict):
return {self.byteify(key): self.byteify(value) for key, value in input.iteritems()}
elif isinstance(input, list):
return [self.byteify(element) for element in input]
elif isinstance(input, unicode):
return input.encode('utf-8')
else:
return input
def getState(self):
# get the state, currently saved in the state file
print("Trying to read previously saved state...")
try:
f = open(self.state_file, "r")
except IOError:
# can't find the file, let's create a new one with default state
print("Could not find existing state, Launching default single rover mode...")
return 1
else:
print("Found existing state...trying to decode...")
try:
json_state = json.load(f)
except ValueError:
# could not properly decode current state
print("Could not decode json state. Launching single rover mode as default...")
f.close()
return 1
else:
print("Decoding succesful")
f.close()
# convert unicode strings to normal
json_state = self.byteify(json_state)
print("That's what we found:")
print(str(json_state))
return json_state
def loadState(self):
# get current state
json_state = self.getState()
if json_state == 1:
# we dont need to load as we were forced to start
# as default single rover due to corrupt/missing state file
self.launchRover()
# for the first start, just let it be green
self.updateLED("green")
return
print("Now loading the state printed above... ")
# first, we restore the base state, because no matter what we end up doing,
# we need to restore base state
self.s2sc.input_stream = json_state["base"]["input_stream"]
self.s2sc.output_stream = json_state["base"]["output_stream"]
self.s2sc.rtcm3_messages = json_state["base"]["rtcm3_messages"]
self.s2sc.base_position = json_state["base"]["base_position"]
self.s2sc.gps_cmd_file = json_state["base"]["gps_cmd_file"]
if json_state["state"] == "rover":
saved_config = json_state["rover"]["current_config"]
if saved_config == "":
saved_config = None
self.launchRover(saved_config)
if json_state["started"] == "yes":
self.startRover()
elif json_state["state"] == "base":
self.launchBase()
if json_state["started"] == "yes":
self.startBase()
else:
# in case we are inactive
self.launchRover()
print(str(json_state["state"]) + " state loaded")
def sendState(self):
# send current state to every connecting browser
state = self.getState()
self.conm.updateAvailableConfigs()
state["available_configs"] = self.conm.available_configs
print("Available configs to send: ")
print(str(state["available_configs"]))
self.socketio.emit("current state", state, namespace = "/test")
def updateLED(self, pattern = None):
# this forms a distinctive and informative blink pattern showing following info:
# network_status/rtk_mode/started?/solution_status
# network: self-hosted AP or connected? green/blue
# rtk mode: rover or base? blue/magenta
# started: yes or no? green/red
# solution status: -, single, float, fix? red/cyan/yellow/green
blink_pattern = []
delay = 0.5
# get wi-fi connection status for the first signal
cmd = ["configure_edison", "--showWiFiMode"]
cmd = " ".join(cmd)
proc = Popen(cmd, stdout = PIPE, shell = True, bufsize = 2048)
out = proc.communicate()
out = out[0].split("\n")[0]
if out == "Master":
blink_pattern.append("green")
elif out == "Managed":
blink_pattern.append("blue")
if self.state == "base":
blink_pattern.append("magenta")
if self.s2sc.started:
# we have a started base
blink_pattern.append("green")
else:
# we have a stopped base
blink_pattern.append("red")
# for now, the base doesn't have solution
blink_pattern.append("off")
elif self.state == "rover":
blink_pattern.append("blue")
if self.rtkc.started:
# we have a started rover
blink_pattern.append("green")
status_pattern_dict = {
"fix": "green,off",
"float": "yellow,off",
"single": "cyan,off",
"-": "read,off"
}
# we need to acquire RtkController in case it's currently updating info dict
self.rtkc.semaphore.acquire()
current_rover_solutuon_status = self.rtkc.info.get("solution_status", "")
self.rtkc.semaphore.release()
# if we don't know this status, we just pass
blink_pattern.append(status_pattern_dict.get(current_rover_solutuon_status, "off"))
else:
# we have a stopped rover
blink_pattern.append("red")
# we are not started, meaning no status just yet
blink_pattern.append("off")
# sync color for better comprehension
blink_pattern.append("white")
# concatenate all that into one big string
blink_pattern = ",off,".join(blink_pattern) + ",off"
if pattern is not None:
blink_pattern = pattern
if blink_pattern:
# check blink_pattern contains something new
if blink_pattern != self.led.current_blink_pattern:
# if we decided we need a new pattern, then start blinking it
self.led.startBlinker(blink_pattern, delay)
# thread workers for broadcasing rtkrcv status
# this function reads satellite levels from an exisiting rtkrcv instance
# and emits them to the connected browser as messages
def broadcastSatellites(self):
count = 0
while self.server_not_interrupted:
# update satellite levels
self.rtkc.getObs()
if count % 10 == 0:
print("Sending sat rover levels:\n" + str(self.rtkc.obs_rover))
print("Sending sat base levels:\n" + str(self.rtkc.obs_base))
self.socketio.emit("satellite broadcast rover", self.rtkc.obs_rover, namespace = "/test")
self.socketio.emit("satellite broadcast base", self.rtkc.obs_base, namespace = "/test")
count += 1
time.sleep(1)
# this function reads current rtklib status, coordinates and obs count
def broadcastCoordinates(self):
count = 0
while self.server_not_interrupted:
# update RTKLIB status
self.rtkc.getStatus()
if count % 10 == 0:
print("Sending RTKLIB status select information:")
print(self.rtkc.info)
self.socketio.emit("coordinate broadcast", self.rtkc.info, namespace = "/test")
if self.enable_led:
self.updateLED()
count += 1
time.sleep(1)
class Gui:
def __init__(self,files):
self.files = files
self.config = ConfigManager(os.environ['HOME']+'/.VideoBrowser/VideoBrowser.conf')
pixbuf = gtk.gdk.pixbuf_new_from_file(self.config.get_value('Appearance','bg_image'))
pixmap, mask = pixbuf.render_pixmap_and_mask()
width, height = pixmap.get_size()
del pixbuf
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_app_paintable(True)
if self.config.get_value('Appearance','fullscreen') == "true":
self.window.fullscreen()
else:
self.window.resize(width, height)
self.window.realize()
self.window.window.set_back_pixmap(pixmap, False)
del pixmap
self.window.set_keep_above(True)
self.window.connect("destroy",gtk.main_quit)
self.window.connect("key_press_event",self.key_pressed)
self.table = gtk.Table(3,2,False)
self.set_guiobjects()
self.window.add(self.table)
self.table.show()
self.window.show()
def rotate_right(self,widget,data=None):
self.files.insert(0,self.files.pop())
self.reset_images()
def rotate_left(self,widget,data=None):
self.files.reverse()
self.files.insert(0,self.files.pop())
self.files.reverse()
self.reset_images()
def reset_images(self):
children = self.table.get_children()
for i in children:
if type(i).__name__ == 'EventBox':
for j in i.get_children():
i.remove(j)
self.table.remove(i)
self.set_guiobjects()
def key_pressed(self,widget,data=None):
if str(data.keyval) == self.config.get_value('Keys','right'):
self.rotate_right(self)
elif str(data.keyval) == self.config.get_value('Keys','left'):
self.rotate_left(self)
elif str(data.keyval) == self.config.get_value('Keys','quit1') or str(data.keyval) == self.config.get_value('Keys','quit2'):
gtk.main_quit()
elif str(data.keyval) == self.config.get_value('Keys','play'):
self.play_video(self)
# else:
# print "Key pressed:", data.keyval
def set_guiobjects(self):
if len(self.files) > 2:
show = 3
else:
show = len(self.files)
for i in range(show):
label = gtk.Label()
eventbox = gtk.EventBox()
eventbox.set_visible_window(False)
if i != 1:
tmp_image = self.__getGtkImage(self.files[i], 240, 180)
tmp_image.show()
eventbox.add(tmp_image)
if i == 0:
eventbox.connect("button_press_event",self.rotate_right)
else:
eventbox.connect("button_press_event",self.rotate_left)
if len(self.files[i].get_movie_name()) > 40:
label.set_markup('<span color="'+self.config.get_value('Appearance','font_color')+'" size="'+self.config.get_value('Appearance','font_small')+'000">'+self.files[i].get_movie_name()[:40]+"..."+'</span>')
else:
label.set_markup('<span color="'+self.config.get_value('Appearance','font_color')+'" size="'+self.config.get_value('Appearance','font_small')+'000">'+self.files[i].get_movie_name()+'</span>')
else:
tmp_image = self.__getGtkImage(self.files[i], 320,240)
tmp_image.show()
eventbox.add(tmp_image)
eventbox.connect("button_press_event",self.play_video)
if len(self.files[i].get_movie_name()) > 40:
label.set_markup('<span color="'+self.config.get_value('Appearance','font_color')+'" size="'+self.config.get_value('Appearance','font_big')+'000">'+self.files[i].get_movie_name()[:40]+"..."+'</span>')
else:
label.set_markup('<span color="white" size="15000">'+self.files[i].get_movie_name()+'</span>')
eventbox.show()
self.table.attach(eventbox,i,i+1,0,1)
label.show()
self.table.attach(label,i,i+1,1,2)
def __getGtkImage(self, image_file, sizeX, sizeY):
tmp_image = gtk.Image()
try:
tmp_pixbuf = image_file.get_snapshot().get_pixbuf().scale_simple(sizeX,sizeY,gtk.gdk.INTERP_HYPER)
tmp_image.set_from_pixbuf(tmp_pixbuf)
except ValueError:
print "Could not set thumbnail for file "+image_file.get_movie_name()+"!"
return tmp_image
def play_video(self,widget,data=None):
os.system(self.config.get_value('External','player')+" \""+self.files[1].get_path()+"/"+self.files[1].get_movie_name()+".avi\"")
def setUp(self):
self.cm = ConfigManager()
def setUp(self):
self.editor = Edile()
self.cm = ConfigManager()
self.cm.writeConfig("/dev/ttyUSB1","")
'last_build': date.today().isoformat() }
self.write(response)
class IndexHandler(tornado.web.RequestHandler):
def get(self):
self.write("This is the index page.")
class DonutHandler(tornado.web.RequestHandler):
def get(self, donutName):
self.write("Yes this is donut." + donutName)
application = tornado.web.Application([
(r"/version", VersionHandler),
(r'/donut/(\w+)$', DonutHandler),
(r'/$', IndexHandler),
])
if __name__ == "__main__":
if(USE_SSL):
sslConf = ConfigManager()
print "using ssl"
http_server = tornado.httpserver.HTTPServer(application, ssl_options={
"certfile": sslConf.getValue("SSL","SSL","SSL_CERT"),
"keyfile": sslConf.getValue("SSL","SSL","SSL_KEY"),
})
http_server.listen(8888)
else:
application.listen(8888)
print 'Starting on port 8888'
tornado.ioloop.IOLoop.instance().start()
class RTKLIB:
# we will save RTKLIB state here for later loading
state_file = "/home/reach/.reach/rtk_state"
# if the state file is not available, these settings are loaded
default_state = {
"base": {
"base_position": [],
"gps_cmd_file": "GPS_10Hz.cmd",
"input_stream": "serial://ttyMFD1:230400:8:n:1:off#ubx",
"output_stream": "tcpsvr://:9000#rtcm3",
"rtcm3_messages": [
"1002",
"1006",
"1008",
"1010",
"1019",
"1020"
]
},
"rover": {
"current_config": "reach_single_default.conf"
},
"started": "no",
"state": "rover"
}
def __init__(self, socketio, rtklib_path = None, enable_led = True, log_path = None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
# we try to restore previous state
# in case we can't, we start as rover in single mode
# self.loadState()
def setCorrectTime(self):
# determine if we have ntp service ready or we need gps time
if not gps_time.time_synchronised_by_ntp():
# wait for gps time
print("Time is not synced by NTP")
self.updateLED("orange,off")
gps_time.set_gps_time("/dev/ttyMFD1", 230400)
print("Time is synced by NTP!")
self.system_time_correct = True
self.socketio.emit("system time corrected", {}, namespace="/test")
self.loadState()
self.socketio.emit("system state reloaded", {}, namespace="/test")
def launchRover(self, config_name = None):
# config_name may be a name, or a full path
# if the parameter contains "/", then we consider it a full path
# else, we will be looking for it one directory higher than the rtkrcv bin
self.semaphore.acquire()
print("Attempting to launch rtkrcv...")
if config_name == None:
res = self.rtkc.launch()
else:
res = self.rtkc.launch(config_name)
if res < 0:
print("rtkrcv launch failed")
elif res == 1:
print("rtkrcv launch successful")
self.state = "rover"
elif res == 2:
print("rtkrcv already launched")
self.state = "rover"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode launched")
self.semaphore.release()
return res
def shutdownRover(self):
self.stopRover()
self.semaphore.acquire()
print("Attempting rtkrcv shutdown")
res = self.rtkc.shutdown()
if res < 0:
print("rtkrcv shutdown failed")
elif res == 1:
print("rtkrcv shutdown successful")
self.state = "inactive"
elif res == 2:
print("rtkrcv already shutdown")
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode shutdown")
self.semaphore.release()
return res
def startRover(self):
self.semaphore.acquire()
print("Attempting to start rtkrcv...")
res = self.rtkc.start()
if res == -1:
print("rtkrcv start failed")
elif res == 1:
print("rtkrcv start successful")
print("Starting coordinate and satellite broadcast")
elif res == 2:
print("rtkrcv already started")
# start fresh data broadcast
self.server_not_interrupted = True
if self.satellite_thread is None:
self.satellite_thread = Thread(target = self.broadcastSatellites)
self.satellite_thread.start()
if self.coordinate_thread is None:
self.coordinate_thread = Thread(target = self.broadcastCoordinates)
self.coordinate_thread.start()
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopRover(self):
self.semaphore.acquire()
print("Attempting to stop RTKLIB...")
res = self.rtkc.stop()
if res == -1:
print("rtkrcv stop failed")
elif res == 1:
print("rtkrcv stop successful")
elif res == 2:
print("rtkrcv already stopped")
self.server_not_interrupted = False
if self.satellite_thread is not None:
self.satellite_thread.join()
self.satellite_thread = None
if self.coordinate_thread is not None:
self.coordinate_thread.join()
self.coordinate_thread = None
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def launchBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this launchBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.semaphore.acquire()
self.state = "base"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode launched")
self.semaphore.release()
def shutdownBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this shutdownBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.stopBase()
self.semaphore.acquire()
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode shutdown")
self.semaphore.release()
def startBase(self, rtcm3_messages = None, base_position = None, gps_cmd_file = None):
self.semaphore.acquire()
print("Attempting to start str2str...")
if not self.rtkc.started:
res = self.s2sc.start(rtcm3_messages, base_position, gps_cmd_file)
if res < 0:
print("str2str start failed")
elif res == 1:
print("str2str start successful")
elif res == 2:
print("str2str already started")
else:
print("Can't start str2str with rtkrcv still running!!!!")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopBase(self):
self.semaphore.acquire()
print("Attempting to stop str2str...")
res = self.s2sc.stop()
if res == -1:
print("str2str stop failed")
elif res == 1:
print("str2str stop successful")
elif res == 2:
print("str2str already stopped")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def readConfigBase(self):
self.semaphore.acquire()
print("Got signal to read base config")
self.socketio.emit("current config base", self.s2sc.readConfig(), namespace = "/test")
self.semaphore.release()
def writeConfigBase(self, config):
self.semaphore.acquire()
print("Got signal to write base config")
self.s2sc.writeConfig(config)
print("Restarting str2str...")
res = self.s2sc.stop() + self.s2sc.start()
if res > 1:
print("Restart successful")
else:
print("Restart failed")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def writeConfigRover(self, config):
# config dict must include config_name field
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to write rover config to file " + config_file)
self.conm.writeConfig(config_file, config)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
self.semaphore.release()
def loadConfigRover(self, config_file = None):
# we might want to write the config, but dont need to load it every time
self.semaphore.acquire()
if config_file == None:
config_file == self.conm.default_rover_config
print("Loading config " + config_file)
# loading config to rtkrcv
if self.rtkc.loadConfig(config_file) < 0:
print("ERROR: failed to load config!!!")
print("abort load")
self.semaphore.release()
return -1
print("load successful!")
print("Now we need to restart rtkrcv for the changes to take effect")
if self.rtkc.started:
print("rtkrcv is already started, we need to do a simple restart!")
res = self.rtkc.restart()
if res == 3:
print("Restart successful")
print(config_file + " config loaded")
elif res == 1:
print("rtkrcv started instead of restart")
elif res < 1:
print("ERROR: rtkrcv restart failed")
self.semaphore.release()
self.saveState()
return res
else:
print("We were not started before, so we need to perform a full start")
self.semaphore.release()
return self.startRover()
def readConfigRover(self, config):
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to read the rover config by the name " + str(config_file))
print("Sending rover config " + str(config_file))
# read from file
self.conm.readConfig(config_file)
# send to the browser
self.socketio.emit("current config rover", self.conm.buffered_config.items, namespace="/test")
self.semaphore.release()
def shutdown(self):
# shutdown whatever mode we are in. stop broadcast threads
# clean up broadcast and blink threads
self.server_not_interrupted = False
self.led.blinker_not_interrupted = False
if self.coordinate_thread is not None:
self.coordinate_thread.join()
if self.satellite_thread is not None:
self.satellite_thread.join()
if self.led.blinker_thread is not None:
self.led.blinker_thread.join()
# shutdown base or rover
if self.state == "rover":
return self.shutdownRover()
elif self.state == "base":
return self.shutdownBase()
# otherwise, we are inactive
return 1
def deleteConfig(self, config_name):
# pass deleteConfig to conm
print("Got signal to delete config " + config_name)
self.conm.deleteConfig(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def resetConfigToDefault(self, config_name):
# pass reset config to conm
print("Got signal to reset config " + config_name)
self.conm.resetConfigToDefault(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def cancelLogConversion(self, raw_log_path):
if self.logm.log_being_converted:
print("Canceling log conversion for " + raw_log_path)
self.logm.convbin.child.kill(signal.SIGINT)
self.conversion_thread.join()
self.logm.convbin.child.close(force = True)
print("Thread killed")
self.logm.cleanLogFiles(raw_log_path)
self.logm.log_being_converted = ""
print("Canceled msg sent")
def processLogPackage(self, raw_log_path):
currently_converting = False
try:
print("conversion thread is alive " + str(self.conversion_thread.isAlive()))
currently_converting = self.conversion_thread.isAlive()
except AttributeError:
pass
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
can_send_file = True
# can't send if there is no converted package and we are busy
if (not os.path.isfile(potential_zip_path)) and (currently_converting):
can_send_file = False
if can_send_file:
print("Starting a new bg conversion thread for log " + raw_log_path)
self.logm.log_being_converted = raw_log_path
self.conversion_thread = Thread(target = self.getRINEXPackage, args = (raw_log_path, ))
self.conversion_thread.start()
else:
error_msg = {
"name": os.path.basename(raw_log_path),
"conversion_status": "A log is being converted at the moment. Please wait",
"messages_parsed": ""
}
self.socketio.emit("log conversion failed", error_msg, namespace="/test")
def conversionIsRequired(self, raw_log_path):
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
print("Comparing " + raw_log_path + " and " + potential_zip_path + " for conversion")
if os.path.isfile(potential_zip_path):
print("Raw logs differ " + str(self.rawLogsDiffer(raw_log_path, potential_zip_path)))
return self.rawLogsDiffer(raw_log_path, potential_zip_path)
else:
print("No zip file!!! Conversion required")
return True
def rawLogsDiffer(self, raw_log_path, zip_package_path):
# check if the raw log is the same size in the zip and in filesystem
log_name = os.path.basename(raw_log_path)
raw_log_size = os.path.getsize(raw_log_path)
zip_package = zipfile.ZipFile(zip_package_path)
raw_file_inside_info = zip_package.getinfo("Raw/" + log_name)
raw_file_inside_size = raw_file_inside_info.file_size
print("Sizes:")
print("Inside: " + str(raw_file_inside_size))
print("Raw: " + str(raw_log_size))
if raw_log_size == raw_file_inside_size:
return False
else:
return True
def getRINEXPackage(self, raw_log_path):
# if this is a solution log, return the file right away
if "sol" in raw_log_path:
log_url_tail = "/logs/download/" + os.path.basename(raw_log_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
return raw_log_path
# return RINEX package if it already exists
# create one if not
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
result_path = ""
if self.conversionIsRequired(raw_log_path):
print("Conversion is Required!")
result_path = self.createRINEXPackage(raw_log_path)
# handle canceled conversion
if result_path is None:
log_url_tail = "/logs/download/" + os.path.basename(raw_log_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
return None
else:
result_path = potential_zip_path
print("Conversion is not Required!")
already_converted_package = {
"name": log_filename,
"conversion_status": "Log already converted. Details inside the package",
"messages_parsed": ""
}
self.socketio.emit("log conversion results", already_converted_package, namespace="/test")
log_url_tail = "/logs/download/" + os.path.basename(result_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
self.cleanBusyMessages()
self.logm.log_being_converted = ""
return result_path
def cleanBusyMessages(self):
# if user tried to convert other logs during conversion, he got an error message
# this function clears them to show it's ok to convert again
self.socketio.emit("clean busy messages", {}, namespace="/test")
def createRINEXPackage(self, raw_log_path):
# create a RINEX package before download
# in case we fail to convert, return the raw log path back
result = raw_log_path
log_filename = os.path.basename(raw_log_path)
conversion_time_string = self.logm.calculateConversionTime(raw_log_path)
start_package = {
"name": log_filename,
"conversion_time": conversion_time_string
}
conversion_result_package = {
"name": log_filename,
"conversion_status": "",
"messages_parsed": "",
"log_url_tail": ""
}
self.socketio.emit("log conversion start", start_package, namespace="/test")
try:
log = self.logm.convbin.convertRTKLIBLogToRINEX(raw_log_path, self.logm.getRINEXVersion())
except ValueError, IndexError:
print("Conversion canceled")
conversion_result_package["conversion_status"] = "Conversion canceled, downloading raw log"
self.socketio.emit("log conversion results", conversion_result_package, namespace="/test")
return None
print("Log conversion done!")
if log is not None:
result = log.createLogPackage()
if log.isValid():
conversion_result_package["conversion_status"] = "Log converted to RINEX"
conversion_result_package["messages_parsed"] = log.log_metadata.formValidMessagesString()
else:
conversion_result_package["conversion_status"] = "Conversion successful, but log does not contain any useful data. Downloading raw log"
else:
print("Could not convert log. Is the extension wrong?")
conversion_result_package["conversion_status"] = "Log conversion failed. Downloading raw log"
self.socketio.emit("log conversion results", conversion_result_package, namespace="/test")
print("Log conversion results:")
print(str(log))
return result
