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