def connect_to_peer(self, peer_id): if self.agent_is_banned(peer_id): g_logger.info("Agent %s is banned." % peer_id) if peer_id == theApp.peer_info.ID: g_logger.error("Can't connect to self.") if peer_id not in self.sessions: peer_entry = None if peer_id in self.super_peers: peer_entry = self.super_peers[peer_id] elif peer_id in self.normal_peers: peer_entry = self.normal_peers[peer_id] elif peer_id in self.mobile_peers: peer_entry = self.mobile_peers[peer_id] else: g_logger.error( "Peer id '%s' doesn't exist in all peer lists." % peer_id) return if self.network_is_banned(peer_entry.IP): g_logger.info("Agent %s is banned in network grounds (%s)." % \ (peer_id, peer_entry.IP)) return reactor.connectTCP(peer_entry.IP, peer_entry.Port, theApp.factory) g_logger.debug("Connecting to %s:%d..." % (peer_entry.IP, peer_entry.Port))
def update_test_mod(result, *args, **kw): g_logger.info("Updating Test Module...") # args = ((version, check_code=0), {}) version = args[0] if len(args) == 2: check_code = args[1] else: check_code = 0 filename = 'test_' + version + '.py' path = os.path.join(TMP_DIR, filename) if not os.path.exists(path): g_logger.error("Test mod %s can't be found under '/tmp' folder." % filename) return if check_code != 0: # Verify if the file is the correct one content = open(filename, 'rb').read() crc = zlib.crc32(content) & 0xffffffff if crc != check_code: g_logger.error( "Test mod %s is corrupt. Try to download it again." % filename) return # Rename the original test.py to test.py.bak, # and replace test.py with new one origin = os.path.join(ROOT_DIR, 'umit', 'icm', 'agent', 'test.py') shutil.copy(origin, origin + '.bak') shutil.copy(path, origin) if 'umit.icm.agent.test' in sys.modules: reload(sys.modules['umit.icm.agent.test']) g_logger.info("Test Module updated.")
def _handle_response(self, response): """Result Handler (generate report)""" time_end = default_timer() self.status_code = response.code self.response_time = time_end - self.time_start g_logger.debug(self.url) g_logger.debug((str(self.status_code) + ' ' + response.phrase)) g_logger.debug("Response time: %f" % (self.response_time)) #g_logger.debug(response.headers) result = {'status_code': 0, 'time_end': time_end} self.report = self._generate_report(result) HTTP_SUCCESS_CODE = (200, 302) if int(response.code) in HTTP_SUCCESS_CODE: g_logger.debug('task done %s' % response.code) task_done(self.__class__.__name__, TEST_WEB_TYPE, self) #if self.pattern is not None: #response.deliverBody(ContentExaminer(self.url,self.pattern)) #Here we can test the HTTP throttled self._throttled_http_test() else: task_failed(self.__class__.__name__, TEST_WEB_TYPE, self) g_logger.error("task failed!") return self.report
def connect_to_peer(self, peer_id): if self.agent_is_banned(peer_id): g_logger.info("Agent %s is banned." % peer_id) if peer_id == theApp.peer_info.ID: g_logger.error("Can't connect to self.") if peer_id not in self.sessions: peer_entry = None if peer_id in self.super_peers: peer_entry = self.super_peers[peer_id] elif peer_id in self.normal_peers: peer_entry = self.normal_peers[peer_id] elif peer_id in self.mobile_peers: peer_entry = self.mobile_peers[peer_id] else: g_logger.error("Peer id '%s' doesn't exist in all peer lists." % peer_id) return if self.network_is_banned(peer_entry.IP): g_logger.info("Agent %s is banned in network grounds (%s)." % \ (peer_id, peer_entry.IP)) return reactor.connectTCP(peer_entry.IP, peer_entry.Port, theApp.factory) g_logger.debug("Connecting to %s:%d..." % (peer_entry.IP, peer_entry.Port))
def _on_activated(self,widget,row,col): """""" self.install_btn.set_sensitive(True) #choice selection = self.treeview.get_selection() (model,iter) = selection.get_selected() if iter == None: return else: cur_version = self.store.get_value(iter,1) #fill self.current_record rs = g_db_helper.select("select * from updates where version = '%s'" % cur_version) if len(rs) != 1: g_logger.error("Record is ERROR in DB!!!! The window will be closed!!!") self.destroy() self.current_record = {} self.current_record["version"] = rs[0][0] self.current_record["news_date"] = rs[0][1] self.current_record["software_name"] = rs[0][2] self.current_record["description"] = rs[0][3] self.current_record["download_url"] = rs[0][4] self.current_record["is_update"] = rs[0][5] self.current_record["check_code"] = rs[0][6] self.statusbar.push(0,_("You have selected the %s version" % \ self.current_record["version"])) self.details_textview.set_buffer(self._set_details_content(_(self.current_record["description"] + "\n" + "download:"+self.current_record["download_url"] + "\n" + "Designed by Umit!" ))) self.details_textview.show_all() g_logger.debug("Selected the item %s" % (self.current_record))
def login_failed_autologin(self, message): """ """ g_logger.error( "[Login Failed]Wrong username or password,will login again") g_logger.error("[Login Failed]More information:%s" % (message)) self._alter_network_informaiton(message)
def _handle_response(self, response): """Result Handler (generate report)""" time_end = default_timer() self.status_code = response.code self.response_time = time_end - self.time_start g_logger.debug(self.url) g_logger.debug((str(self.status_code) + ' ' + response.phrase)) g_logger.debug("Response time: %f" % (self.response_time)) #g_logger.debug(response.headers) result = {'status_code': 0, 'time_end': time_end} self.report = self._generate_report(result) HTTP_SUCCESS_CODE = (200,302) if int(response.code) in HTTP_SUCCESS_CODE: g_logger.debug('task done %s'%response.code) task_done(self.__class__.__name__,TEST_WEB_TYPE,self) #if self.pattern is not None: #response.deliverBody(ContentExaminer(self.url,self.pattern)) #Here we can test the HTTP throttled self._throttled_http_test() else: task_failed(self.__class__.__name__,TEST_WEB_TYPE,self) g_logger.error("task failed!") return self.report
def update_test_mod(result, *args, **kw): g_logger.info("Updating Test Module...") # args = ((version, check_code=0), {}) version = args[0] if len(args) == 2: check_code = args[1] else: check_code = 0 filename = 'test_' + version + '.py' path = os.path.join(TMP_DIR, filename) if not os.path.exists(path): g_logger.error("Test mod %s can't be found under '/tmp' folder." % filename) return if check_code != 0: # Verify if the file is the correct one content = open(filename, 'rb').read() crc = zlib.crc32(content) & 0xffffffff if crc != check_code: g_logger.error("Test mod %s is corrupt. Try to download it again." % filename) return # Rename the original test.py to test.py.bak, # and replace test.py with new one origin = os.path.join(ROOT_DIR, 'umit', 'icm', 'agent', 'test.py') shutil.copy(origin, origin + '.bak') shutil.copy(path, origin) if 'umit.icm.agent.test' in sys.modules: reload(sys.modules['umit.icm.agent.test']) g_logger.info("Test Module updated.")
def _handle_forward_message_response(self, message): if message.identifier not in self.forwarding_defers: g_logger.error("message id '%s' not in the forwarding list" % \ message.identifier) defer_ = self.forwarding_defers[message.identifier] response_msg = MessageFactory.decode(\ base64.b64decode(message.encodedMessage)) defer_.callback(response_msg)
def _linux_clear(self): file = self.auto_sys_path + self.desktop_name if os.path.exists(file): try: os.remove(file) g_logger.info("Cancel Auto StartUP icm-agent in Linux (%s)" % (file)) except Exception, e: g_logger.error("[Failed] Cancel Auto StartUP icm-agent in Linux (%s)" % (file))
def _handle_register_response(self, message): if message is None: g_logger.error("Empty response while trying to register.") return g_logger.info("RegisterAgent response: (%s, %s)" % (message.agentID, message.publicKeyHash)) return {'id': message.agentID, 'hash': message.publicKeyHash}
def _get_value_from_db (self,key): """ get value from the config in DB """ rs = g_db_helper.select("select * from config where key = '%s'" % key) if rs == None or len(rs) != 1: g_logger.error("Wrong get the value from key:%s in config DB " % (key)) return return str(rs[0][1])
def _get_value_from_db(self, key): """ get value from the config in DB """ rs = g_db_helper.select("select * from config where key = '%s'" % key) if rs == None or len(rs) != 1: g_logger.error("Wrong get the value from key:%s in config DB " % (key)) return return str(rs[0][1])
def fetch_task(self): """ fetch task from Aggregator by using Aggregator AssignTask API """ if theApp.aggregator.available: g_logger.info("Fetching assigned task from aggregator") # defer_ = theApp.aggregator.get_task() # defer_.addCallback(self.task_append) # defer_.addErrback(self._handler_error(failure)) else: g_logger.error("Cannot connect to Aggregator")
def set_run_time(self, cron_time): time_ = cron_time.split() try: self.RunTime.minute = self.parser.parse_minute(time_[0]) self.RunTime.hour = self.parser.parse_hour(time_[1]) self.RunTime.day = self.parser.parse_day(time_[2]) self.RunTime.month = self.parser.parse_month(time_[3]) self.RunTime.weekday = self.parser.parse_weekday(time_[4]) except: g_logger.error("Error in parsing cron time: %s" % cron_time) self.CronTimeStr = cron_time
def _linux_clear(self): file = self.auto_sys_path + self.desktop_name if os.path.exists(file): try: os.remove(file) g_logger.info("Cancel Auto StartUP icm-agent in Linux (%s)" % (file)) except Exception, e: g_logger.error( "[Failed] Cancel Auto StartUP icm-agent in Linux (%s)" % (file))
def _connectionFailed(self, failure): g_logger.error("[WebsiteTest]connection failed:%s"%failure) task_failed(self.__class__.__name__, TEST_WEB_TYPE, self) result = {'status_code': 1, 'time_end': default_timer()} self.status_code = 1 return self._generate_report(result)
def _connectionFailed(self, failure): g_logger.error("[WebsiteTest]connection failed:%s" % failure) task_failed(self.__class__.__name__, TEST_WEB_TYPE, self) result = {'status_code': 1, 'time_end': default_timer()} self.status_code = 1 return self._generate_report(result)
def _linux_set(self): import shutil if not os.path.exists(self.auto_sys_path): os.mkdir(self.auto_sys_path) try: shutil.copy(self.auto_desktop_file, self.auto_sys_path + self.desktop_name) g_logger.info("Auto StartUP icm-agent in Linux (%s,%s)" % (self.auto_desktop_file, self.auto_sys_path)) except Exception, e: g_logger.error( "[Failed]Auto StartUP icm-agent in Linux (%s,%s,%s)" % (self.auto_desktop_file, self.auto_sys_path, e) )
def _linux_set(self): import shutil if not os.path.exists(self.auto_sys_path): os.mkdir(self.auto_sys_path) try: shutil.copy(self.auto_desktop_file, self.auto_sys_path + self.desktop_name) g_logger.info("Auto StartUP icm-agent in Linux (%s,%s)" % (self.auto_desktop_file, self.auto_sys_path)) except Exception, e: g_logger.error( "[Failed]Auto StartUP icm-agent in Linux (%s,%s,%s)" % (self.auto_desktop_file, self.auto_sys_path, e))
def store_bandwidth(self,result,key): g_logger.debug('finish %s'%benchmark_url_dict[key]) start_time = self.benchmark_bandwidth[key]['start_time'] end_time = self.benchmark_bandwidth[key]['end_time'] size = self.benchmark_bandwidth[key]['size'] if size == 0 or size == None: g_logger.error("Error in filesize!!!") size = 1 self.benchmark_bandwidth[key]['bandwidth'] =(float)((end_time - start_time) / size) g_logger.debug(str(key)+':'+str(self.benchmark_bandwidth[key]))
def store_bandwidth(self, result, key): g_logger.debug("finish %s" % benchmark_url_dict[key]) start_time = self.benchmark_bandwidth[key]["start_time"] end_time = self.benchmark_bandwidth[key]["end_time"] size = self.benchmark_bandwidth[key]["size"] if size == 0 or size == None: g_logger.error("Error in filesize!!!") size = 1 self.benchmark_bandwidth[key]["bandwidth"] = (float)((end_time - start_time) / size) g_logger.debug(str(key) + ":" + str(self.benchmark_bandwidth[key]))
def get_task_sets(self,task_type = None): """ Tasks (All, done, wait)for Dashboard Window """ from umit.icm.agent.gui.dashboard.DashboardListBase import TASK_ALL,TASK_SUCCESSED,TASK_FAILED from umit.icm.agent.test import TASK_STATUS_DONE,TASK_STATUS_FAILED if task_type == TASK_ALL: return self.db_conn.select("SELECT * from tasks") elif task_type == TASK_SUCCESSED: return self.db_conn.select("SELECT * from tasks where done_status = '%s' "%(TASK_STATUS_DONE)) elif task_type == TASK_FAILED: return self.db_conn.select("SELECT * from tasks where done_status = '%s' "%(TASK_STATUS_FAILED)) else: g_logger.error("Didn't input any legal task type for query :%s"%(task_type)) return None
def store_bandwidth(self, result, key): g_logger.debug('finish %s' % benchmark_url_dict[key]) start_time = self.benchmark_bandwidth[key]['start_time'] end_time = self.benchmark_bandwidth[key]['end_time'] size = self.benchmark_bandwidth[key]['size'] if size == 0 or size == None: g_logger.error("Error in filesize!!!") size = 1 self.benchmark_bandwidth[key]['bandwidth'] = (float)( (end_time - start_time) / size) g_logger.debug(str(key) + ':' + str(self.benchmark_bandwidth[key]))
def get_report_sets(self,report_type = None): """ Reports for Dashboar Window (sent, unsent, maybe received) """ from umit.icm.agent.gui.dashboard.DashboardListBase import REPORT,REPORT_SENT,REPORT_UNSENT,REPORT_RECEIVED if report_type == REPORT: return None elif report_type == REPORT_SENT: return self.db_conn.select("SELECT * from reports") elif report_type == REPORT_UNSENT: return self.db_conn.select("SELECT * from unsent_reports") elif report_type == REPORT_RECEIVED: return self.db_conn.select("SELECT * from received_reports") else: g_logger.error("Didn't input any legal report type for query :%s"%(report_type)) return None
def changes_by_category_in_range(self, args,choice_tab=None): """ Generic function for changes_anything (choice_tab can provide report, task tab choice) (This method also received the range ) """ if len(args) == 1: # yearly return self.changes_in_year(args[0], choice_tab) elif len(args) == 2: # monthly return self.changes_in_month(args[0], args[1], choice_tab) elif len(args) == 3: # daily return self.changes_in_day(args[0], args[1], args[2], choice_tab) elif len(args) == 4: # hourly return self.changes_in_hour(args[0], args[1], args[2], args[3],choice_tab) else: g_logger.error("Invalid number of parameters specified")
def get_report_sets(self, report_type=None): """ Reports for Dashboar Window (sent, unsent, maybe received) """ from umit.icm.agent.gui.dashboard.DashboardListBase import REPORT, REPORT_SENT, REPORT_UNSENT, REPORT_RECEIVED if report_type == REPORT: return None elif report_type == REPORT_SENT: return self.db_conn.select("SELECT * from reports") elif report_type == REPORT_UNSENT: return self.db_conn.select("SELECT * from unsent_reports") elif report_type == REPORT_RECEIVED: return self.db_conn.select("SELECT * from received_reports") else: g_logger.error("Didn't input any legal report type for query :%s" % (report_type)) return None
def timerange_changes_count_generic(self,start,end,choice_tab): """ Selects what method to use to grab changes count. """ #start and end should always if not start or not end: g_logger.error("You should specify range start and range end") return #check choice_tab if not choice_tab: g_logger.error("You should specify choice_tab") return #Call DB return g_db_helper.timerange_changes_count_generic(start,end,choice_tab)
def task_done(name,task_type=None,task_detail=None): """ Task Done """ ####################### #Statistics Information theApp.statistics.tasks_done = theApp.statistics.tasks_done + 1 theApp.statistics.tasks_done_by_type[name] = \ theApp.statistics.tasks_done_by_type.get(name, 0) + 1 ################################# #Write task details into database now = (str(datetime.datetime.fromtimestamp(time.time()))).split('.')[0] print "--------------------------------------------" if task_type == TEST_WEB_TYPE: task_web_info = { 'test_id': str(theApp.test_sets.current_test_version), 'website_url' : task_detail.url, 'test_type' : TEST_WEB_TYPE, 'done_status' : TASK_STATUS_DONE, 'done_result' : TASK_STATUS_DONE, 'execute_time' : now, 'unique_id':task_detail.unitied_test_id, } g_db_helper.task_web(task_web_info) elif task_type == TEST_SERVICE_TYPE: task_service_info = { 'test_id': str(theApp.test_sets.current_test_version), 'service_name' : task_detail.service_name, 'service_ip':task_detail.host, 'service_port':task_detail.port, 'test_type' : TEST_SERVICE_TYPE, 'done_status' : TASK_STATUS_DONE, 'done_result' : TASK_STATUS_DONE, 'execute_time' : now, 'unique_id':task_detail.unitied_test_id, } g_db_helper.task_service(task_service_info) else: g_logger.error("New Test Type, cannot recognize" )
def task_done(name, task_type=None, task_detail=None): """ Task Done """ ####################### #Statistics Information theApp.statistics.tasks_done = theApp.statistics.tasks_done + 1 theApp.statistics.tasks_done_by_type[name] = \ theApp.statistics.tasks_done_by_type.get(name, 0) + 1 ################################# #Write task details into database now = (str(datetime.datetime.fromtimestamp(time.time()))).split('.')[0] print "--------------------------------------------" if task_type == TEST_WEB_TYPE: task_web_info = { 'test_id': str(theApp.test_sets.current_test_version), 'website_url': task_detail.url, 'test_type': TEST_WEB_TYPE, 'done_status': TASK_STATUS_DONE, 'done_result': TASK_STATUS_DONE, 'execute_time': now, 'unique_id': task_detail.unitied_test_id, } g_db_helper.task_web(task_web_info) elif task_type == TEST_SERVICE_TYPE: task_service_info = { 'test_id': str(theApp.test_sets.current_test_version), 'service_name': task_detail.service_name, 'service_ip': task_detail.host, 'service_port': task_detail.port, 'test_type': TEST_SERVICE_TYPE, 'done_status': TASK_STATUS_DONE, 'done_result': TASK_STATUS_DONE, 'execute_time': now, 'unique_id': task_detail.unitied_test_id, } g_db_helper.task_service(task_service_info) else: g_logger.error("New Test Type, cannot recognize")
def timerange_changes_count_generic(self, start, end, choice_tab): """ Selects what method to use to grab changes count. """ #start and end should always if not start or not end: g_logger.error("You should specify range start and range end") return #check choice_tab if not choice_tab: g_logger.error("You should specify choice_tab") return #Call DB return g_db_helper.timerange_changes_count_generic( start, end, choice_tab)
def changes_by_category_in_range(self, args, choice_tab=None): """ Generic function for changes_anything (choice_tab can provide report, task tab choice) (This method also received the range ) """ if len(args) == 1: # yearly return self.changes_in_year(args[0], choice_tab) elif len(args) == 2: # monthly return self.changes_in_month(args[0], args[1], choice_tab) elif len(args) == 3: # daily return self.changes_in_day(args[0], args[1], args[2], choice_tab) elif len(args) == 4: # hourly return self.changes_in_hour(args[0], args[1], args[2], args[3], choice_tab) else: g_logger.error("Invalid number of parameters specified")
def _handler_error(self,failure): g_logger.error("fetch task error %s"%str(failure))
def get_test_sets(self,test_type = None): """ Test sets for Dashboard Window(successful or failed) """ from umit.icm.agent.gui.dashboard.DashboardListBase import CAPA_THROTTLED,CAPACITY,CAPA_SERVICE from umit.icm.agent.test import TASK_STATUS_DONE,TASK_STATUS_FAILED if test_type == CAPA_THROTTLED: return self.db_conn.select("SELECT \ sequence,test_id,website_url,test_type,done_status,done_result,execute_time \ from tasks where test_type = 'WEB' ") elif test_type == CAPACITY: return None elif test_type == CAPA_SERVICE: return self.db_conn.select("SELECT \ sequence,test_id,service_name,service_port,service_ip,test_type,done_status,done_result,execute_time \ from tasks where test_type = 'Service' ") else: g_logger.error("Didn't input any legal test sets type for query :%s"%(test_type)) return None
def task_failed(name, task_type=None, task_detail=None): """ Task Failed """ ####################### # Statistics Information theApp.statistics.tasks_failed = theApp.statistics.tasks_failed + 1 theApp.statistics.tasks_failed_by_type[name] = theApp.statistics.tasks_failed_by_type.get(name, 0) + 1 ################################# # Write task details into database now = (str(datetime.datetime.fromtimestamp(time.time()))).split(".")[0] if task_type == TEST_WEB_TYPE: task_web_info = { "test_id": str(theApp.test_sets.current_test_version), "website_url": task_detail.url, "test_type": TEST_WEB_TYPE, "done_status": TASK_STATUS_FAILED, "done_result": TASK_STATUS_FAILED, "execute_time": now, "unique_id": task_detail.unitied_test_id, } g_db_helper.task_web(task_web_info) elif task_type == TEST_SERVICE_TYPE: task_service_info = { "test_id": str(theApp.test_sets.current_test_version), "service_name": task_detail.service_name, "service_ip": task_detail.host, "service_port": task_detail.port, "test_type": TEST_SERVICE_TYPE, "done_status": TASK_STATUS_FAILED, "done_result": TASK_STATUS_FAILED, "execute_time": now, "unique_id": task_detail.unitied_test_id, } g_db_helper.task_service(task_service_info) else: g_logger.error("New Test Type, cannot recognize")
def _win_clear(self): import _winreg as Regedit regedit = Regedit.ConnectRegistry(None, Regedit.HKEY_LOCAL_MACHINE) try: tag = self.regedit_path key = Regedit.OpenKey(regedit, tag, 0, Regedit.KEY_WRITE) try: try: Regedit.SetValueEx(key, self.key_name, 0, Regedit.REG_SZ, self.exe_path) Regedit.DeleteValue(key, self.key_name) g_logger.info("Cancel Auto StartUP") except EnvironmentError: g_logger.error("Cancel Auto StartUP Error in Windows (%s,%s)" % (tag, self.key_name)) raise finally: Regedit.CloseKey(key) finally: Regedit.CloseKey(regedit)
def _win_set(self): import _winreg as Regedit regedit = Regedit.ConnectRegistry(None, Regedit.HKEY_LOCAL_MACHINE) try: tag = self.regedit_path key = Regedit.OpenKey(regedit, tag, 0, Regedit.KEY_WRITE) try: try: Regedit.SetValueEx(key, self.key_name, 0, Regedit.REG_SZ, self.exe_path) g_logger.info("Auto StartUP icm-agent in Windows (%s,%s,%s)" % (tag, self.key_name, self.exe_path)) except EnvironmentError: g_logger.error( "Write Regedit key Error in Windows (%s,%s,%s)" % (tag, self.key_name, self.exe_path) ) raise finally: Regedit.CloseKey(key) finally: Regedit.CloseKey(regedit)
def get_task_sets(self, task_type=None): """ Tasks (All, done, wait)for Dashboard Window """ from umit.icm.agent.gui.dashboard.DashboardListBase import TASK_ALL, TASK_SUCCESSED, TASK_FAILED from umit.icm.agent.test import TASK_STATUS_DONE, TASK_STATUS_FAILED if task_type == TASK_ALL: return self.db_conn.select("SELECT * from tasks") elif task_type == TASK_SUCCESSED: return self.db_conn.select( "SELECT * from tasks where done_status = '%s' " % (TASK_STATUS_DONE)) elif task_type == TASK_FAILED: return self.db_conn.select( "SELECT * from tasks where done_status = '%s' " % (TASK_STATUS_FAILED)) else: g_logger.error("Didn't input any legal task type for query :%s" % (task_type)) return None
def _win_clear(self): import _winreg as Regedit regedit = Regedit.ConnectRegistry(None, Regedit.HKEY_LOCAL_MACHINE) try: tag = self.regedit_path key = Regedit.OpenKey(regedit, tag, 0, Regedit.KEY_WRITE) try: try: Regedit.SetValueEx(key, self.key_name, 0, Regedit.REG_SZ, self.exe_path) Regedit.DeleteValue(key, self.key_name) g_logger.info("Cancel Auto StartUP") except EnvironmentError: g_logger.error( "Cancel Auto StartUP Error in Windows (%s,%s)" % (tag, self.key_name)) raise finally: Regedit.CloseKey(key) finally: Regedit.CloseKey(regedit)
def get_test_sets(self, test_type=None): """ Test sets for Dashboard Window(successful or failed) """ from umit.icm.agent.gui.dashboard.DashboardListBase import CAPA_THROTTLED, CAPACITY, CAPA_SERVICE from umit.icm.agent.test import TASK_STATUS_DONE, TASK_STATUS_FAILED if test_type == CAPA_THROTTLED: return self.db_conn.select("SELECT \ sequence,test_id,website_url,test_type,done_status,done_result,execute_time \ from tasks where test_type = 'WEB' ") elif test_type == CAPACITY: return None elif test_type == CAPA_SERVICE: return self.db_conn.select("SELECT \ sequence,test_id,service_name,service_port,service_ip,test_type,done_status,done_result,execute_time \ from tasks where test_type = 'Service' ") else: g_logger.error( "Didn't input any legal test sets type for query :%s" % (test_type)) return None
def update_agent(result, *args, **kw): """ update back """ g_logger.info("Close task looping...") theApp.task_assgin_lc.stop() theApp.task_run_lc.stop() theApp.report_proc_lc.stop() theApp.test_sets_fetch_lc() g_logger.info("Updating Desktop Agent...") # args = ((version, check_code=0), {}) version = args[0] if len(args) == 2: check_code = args[1] else: check_code = 0 filename = 'icm-agent_' + version + '.tar.gz' path = os.path.join(TMP_DIR, filename) if not os.path.exists(path): g_logger.error("Package %s can't be found under '/tmp' folder." % filename) return if check_code != 0: # Verify if the file is the correct one content = open(filename, 'rb').read() crc = zlib.crc32(content) & 0xffffffff if crc != check_code: g_logger.error("Package %s is corrupt. Try to download it again." % filename) return # Stop current agent open(os.path.join( ROOT_DIR, 'umit', 'icm', 'agent', 'agent_restart_mark'), 'w').close() from twisted.internet import reactor reactor.callInThread(restart_agent, path) reactor.stop() g_logger.debug("reactor stopped.")
def update_agent(result, *args, **kw): """ update back """ g_logger.info("Close task looping...") theApp.task_assgin_lc.stop() theApp.task_run_lc.stop() theApp.report_proc_lc.stop() theApp.test_sets_fetch_lc() g_logger.info("Updating Desktop Agent...") # args = ((version, check_code=0), {}) version = args[0] if len(args) == 2: check_code = args[1] else: check_code = 0 filename = 'icm-agent_' + version + '.tar.gz' path = os.path.join(TMP_DIR, filename) if not os.path.exists(path): g_logger.error("Package %s can't be found under '/tmp' folder." % filename) return if check_code != 0: # Verify if the file is the correct one content = open(filename, 'rb').read() crc = zlib.crc32(content) & 0xffffffff if crc != check_code: g_logger.error("Package %s is corrupt. Try to download it again." % filename) return # Stop current agent open(os.path.join(ROOT_DIR, 'umit', 'icm', 'agent', 'agent_restart_mark'), 'w').close() from twisted.internet import reactor reactor.callInThread(restart_agent, path) reactor.stop() g_logger.debug("reactor stopped.")
def _win_set(self): import _winreg as Regedit regedit = Regedit.ConnectRegistry(None, Regedit.HKEY_LOCAL_MACHINE) try: tag = self.regedit_path key = Regedit.OpenKey(regedit, tag, 0, Regedit.KEY_WRITE) try: try: Regedit.SetValueEx(key, self.key_name, 0, Regedit.REG_SZ, self.exe_path) g_logger.info( "Auto StartUP icm-agent in Windows (%s,%s,%s)" % (tag, self.key_name, self.exe_path)) except EnvironmentError: g_logger.error( "Write Regedit key Error in Windows (%s,%s,%s)" % (tag, self.key_name, self.exe_path)) raise finally: Regedit.CloseKey(key) finally: Regedit.CloseKey(regedit)
def _on_activated(self, widget, row, col): """""" self.install_btn.set_sensitive(True) #choice selection = self.treeview.get_selection() (model, iter) = selection.get_selected() if iter == None: return else: cur_version = self.store.get_value(iter, 1) #fill self.current_record rs = g_db_helper.select( "select * from updates where version = '%s'" % cur_version) if len(rs) != 1: g_logger.error( "Record is ERROR in DB!!!! The window will be closed!!!") self.destroy() self.current_record = {} self.current_record["version"] = rs[0][0] self.current_record["news_date"] = rs[0][1] self.current_record["software_name"] = rs[0][2] self.current_record["description"] = rs[0][3] self.current_record["download_url"] = rs[0][4] self.current_record["is_update"] = rs[0][5] self.current_record["check_code"] = rs[0][6] self.statusbar.push(0,_("You have selected the %s version" % \ self.current_record["version"])) self.details_textview.set_buffer( self._set_details_content( _(self.current_record["description"] + "\n" + "download:" + self.current_record["download_url"] + "\n" + "Designed by Umit!"))) self.details_textview.show_all() g_logger.debug("Selected the item %s" % (self.current_record))
def _alter_show(self,primary_text,secondary_text): #Add the user-friendly information to the user to check the problem. if theApp.use_gui == False: g_logger.error(primary_text+secondary_text) theApp.login_without_gui() return import gtk from higwidgets.higwindows import HIGAlertDialog alter = HIGAlertDialog(primary_text = primary_text,\ secondary_text = secondary_text) alter.show() alter.run() #clear db theApp.peer_info.clear_db() theApp.is_auto_login = False #show login window again theApp.gtk_main.show_login()
def _connection_errback(self, failure): g_logger.error("[AggregatorAPI connection] - %s" % failure) if isinstance(failure, error.ConnectError) or \ isinstance(failure, error.DNSLookupError): g_logger.error("Connecting to the aggregator failed.") self.available = False theApp.statistics.aggregator_fail_num = \ theApp.statistics.aggregator_fail_num + 1 try: failure.raiseException() except Exception, err: if isinstance(err, Error): g_logger.error(">>> The Aggregator had an Internal Error:") g_logger.error(err.response) self._alter_network_informaiton(err.response)
def _connection_errback(self, failure): g_logger.error("[AggregatorAPI connection] - %s - %s" % (failure, failure.printDetailedTraceback())) if isinstance(failure, error.ConnectError) or \ isinstance(failure, error.DNSLookupError): g_logger.error("Connecting to the aggregator failed.") self.available = False theApp.statistics.aggregator_fail_num = \ theApp.statistics.aggregator_fail_num + 1 try: failure.raiseException() except Exception, err: if isinstance(err, Error): g_logger.error(">>> The Aggregator had an Internal Error:") g_logger.error(err.response) self._alter_network_informaiton(err.response)
def build_super_connection(self,host=None,port=None): """ this method will connect to host:port, to get necessary super peer information, and add them into peer list and super peer session. we will get peer_id, token, ciphered_public_key from super peer """ if host == None or host == "" or port == None or port == "": g_logger.error("Wrong super peer conection information: host->%s, port->%d"%(host,port)) return from umit.icm.agent.rpc.message import * from umit.icm.agent.rpc.MessageFactory import MessageFactory g_logger.error('Try to connect to super peer...., to get necessary information!!!') from umit.icm.agent.utils.CreateDB import mod,exp try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP) s.connect((host,port)) except: g_logger.error('Cannot connect to the super peer, maybe it down!') return request_msg = AuthenticatePeer() request_msg.agentID = self.application.peer_info.ID request_msg.agentType = 2 request_msg.agentPort = 5895 request_msg.cipheredPublicKey.mod = str(mod) request_msg.cipheredPublicKey.exp = str(exp) data = MessageFactory.encode(request_msg) length = struct.pack('!I', len(data)) s.send(length) s.send(data) length = struct.unpack('!i', s.recv(4))[0] data = s.recv(length) response_msg = MessageFactory.decode(data) g_logger.error('Get the super peer information (ip:%s,port:%s,agentID:%s)\ with build_super_connection process'%(host,port,response_msg.token)) self.application.peer_manager.add_super_peer(peer_id=response_msg.token,ip=host,port=port)
def _handle_errback(self, failure): g_logger.error("Aggregator failure: %s" % str(failure))
def _handler_error(self, failure): g_logger.error("fetch task error %s" % str(failure))
def _handler_error(self, failure): print failure g_logger.error("Fetch new test sets error %s" % str(failure))
def _handle_errback(self, failure): """ """ failure.printTraceback() g_logger.error(">>> Failure from Application: %s" % failure)
def handler_err(self, failure): g_logger.error("[WebsiteTest]bench handle failed:%s" % failure)