def send_report(self, report): if isinstance(report, WebsiteReport): self.send_website_report(report) elif isinstance(report, ServiceReport): self.send_service_report(report) else: g_logger.debug("Unable to recognize the report type.")
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 check_username(self, username="", password=""): """ check username and password in DB, the information is got from Login-Window """ rs = g_db_helper.select( "select * from peer_info where username='******' and \ password='******'" % (username, password)) if not rs: g_logger.info("No matching peer info in db.\ icm-agent will register the username or password") return False else: g_logger.info("Match the username and password, \ we will change the default credentials") g_logger.debug(rs[0]) self.peer_info.ID = rs[0][0] self.peer_info.Username = rs[0][1] self.peer_info.Password = rs[0][2] self.peer_info.Email = rs[0][3] self.peer_info.CipheredPublicKeyHash = rs[0][4] self.peer_info.Type = rs[0][5] self.peer_info.is_registered = True return True
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 _normal_peer_connected(self, peer_id, ip, port, ciphered_public_key=None, network_id=0): if self.agent_is_banned(peer_id) or self.network_is_banned(ip): g_logger.info("Desktop agent %s is banned or is running from " "a banned network %s" % (peer_id, ip)) if peer_id in self.normal_peers: self.remove_normal_peer(peer_id) return False if peer_id in self.normal_peers and \ self.normal_peers[peer_id].status == 'Connected': g_logger.warning("Peer %s already connected." % peer_id) return False if peer_id in self.normal_peers: g_logger.debug("Peer id %s already exists in normal peer list." % peer_id) self.normal_peers[peer_id].status = 'Connected' else: peer_entry = PeerEntry() peer_entry.Type = 2 peer_entry.ID = peer_id peer_entry.IP = ip peer_entry.Port = port peer_entry.CipheredPublicKey = ciphered_public_key peer_entry.status = 'Connected' peer_entry.network_id = network_id self.normal_peers[peer_entry.ID] = peer_entry self.connected_peer_num = self.connected_peer_num + 1 return True
def _super_peer_connected(self, peer_id, ip, port, ciphered_public_key=None, network_id=0): if self.agent_is_banned(peer_id) or self.network_is_banned(ip): g_logger.info("Super agent %s is banned or is running from " "a banned network %s" % (peer_id, ip)) if peer_id in self.super_peers: self.remove_super_peer(peer_id) return False if peer_id in self.super_peers and \ self.super_peers[peer_id].status == 'Connected': g_logger.warning("Peer %s already connected." % peer_id) return False if peer_id in self.super_peers: g_logger.debug("Peer id %s already exists in super peer list." % peer_id) self.super_peers[peer_id].status = 'Connected' else: peer_entry = PeerEntry() peer_entry.Type = 1 peer_entry.ID = peer_id peer_entry.IP = ip peer_entry.Port = port peer_entry.CipheredPublicKey = ciphered_public_key peer_entry.status = 'Connected' peer_entry.network_id = network_id self.super_peers[peer_entry.ID] = peer_entry self.connected_speer_num = self.connected_speer_num + 1 return True
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 _send_auth_response_message(self): response_msg = AuthenticatePeerResponse() response_msg.token = str(theApp.peer_info.ID) response_msg.cipheredPublicKey.mod = str(theApp.key_manager.public_key.mod) response_msg.cipheredPublicKey.exp = str(theApp.key_manager.public_key.exp) g_logger.debug("Sending AuthenticatePeerResponse message:\n%s" % \ response_msg) self._send_message(response_msg)
def _handle_register(self, result): if result: self.peer_info.ID = result['id'] self.peer_info.CipheredPublicKeyHash = result['hash'] self.peer_info.is_registered = True g_logger.debug("Register to Aggregator: %s" % result['id']) return result
def _handle_check_software(self,message): if message == None: return g_logger.debug("Finish check the software update.") self.progress_bar.set_value(100) #self.progress_bar = gtk.ProgressBar(100) #show the record self._load_updates()
def _handle_check_software(self, message): if message == None: return g_logger.debug("Finish check the software update.") self.progress_bar.set_value(100) #self.progress_bar = gtk.ProgressBar(100) #show the record self._load_updates()
def connectionLost(self, reason): self.factory.connectionNum = self.factory.connectionNum - 1 g_logger.debug("Connection #%d closed." % self.factory.connectionNum) if self._session is not None: g_logger.debug("Session %s ended." % self.remote_id) if self.remote_type == 1: theApp.peer_manager._super_peer_disconnected(self.remote_id) elif self.remote_type == 2: theApp.peer_manager._normal_peer_disconnected(self.remote_id)
def _send_auth_message(self): request_msg = AuthenticatePeer() request_msg.agentID = str(theApp.peer_info.ID) request_msg.agentType = theApp.peer_info.Type request_msg.agentPort = theApp.listen_port request_msg.cipheredPublicKey.mod = str(theApp.key_manager.public_key.mod) request_msg.cipheredPublicKey.exp = str(theApp.key_manager.public_key.exp) g_logger.debug("Sending AuthenticatePeer message:\n%s" % request_msg) self._send_message(request_msg) self._auth_sent = True
def onerror(func, path, exec_info): """ shutil.rmtree callback(Attention:The rmtree cannot remove the readonly files in windows) """ import stat if not os.access(path, os.W_OK): os.chmod(path, stat.S_IWUSR) func(path) else: g_logger.debug("rm:path%s" % path) #ignore errors
def send_report(self, report): if isinstance(report, WebsiteReport): self.pending_report_ids.append(report.header.reportID) self.send_website_report(report) elif isinstance(report, ServiceReport): print report self.pending_report_ids.append(report.header.reportID) self.send_service_report(report) else: g_logger.debug("Unable to recognize the report type.")
def time_to_run(self, cur_time): if cur_time.tm_min in self.RunTime.minute and \ cur_time.tm_hour in self.RunTime.hour and \ cur_time.tm_mday in self.RunTime.day and \ cur_time.tm_mon in self.RunTime.month and \ cur_time.tm_wday in self.RunTime.weekday: g_logger.debug("It's time to run '%s'" % self) return True else: return False
def open(self, timeout=3000): """Connect to the database""" if not os.path.exists(self.db_path): raise IOError("Cannot find database at '%s'." % self.db_path) self.conn = sqlite3.connect(self.db_path, timeout) if not self.conn: raise IOError("Unable to open database '%s'." % self.db_path) g_logger.debug("Database connected '%s'." % self.db_path) self.is_open = True self.cur = self.conn.cursor()
def onerror(func,path,exec_info): """ shutil.rmtree callback(Attention:The rmtree cannot remove the readonly files in windows) """ import stat if not os.access(path, os.W_OK): os.chmod(path, stat.S_IWUSR) func(path) else: g_logger.debug("rm:path%s"%path) #ignore errors
def _send_auth_response_message(self): response_msg = AuthenticatePeerResponse() response_msg.token = str(theApp.peer_info.ID) response_msg.cipheredPublicKey.mod = str( theApp.key_manager.public_key.mod) response_msg.cipheredPublicKey.exp = str( theApp.key_manager.public_key.exp) g_logger.debug("Sending AuthenticatePeerResponse message:\n%s" % \ response_msg) self._send_message(response_msg)
def _handle_get_task_response(self,message): if message in None: return print message print message.header print message.tests g_logger.debug("We have got tasks from aggregator") return message
def _handle_get_events_response(self, message): if message is None: return #print message #print message.events g_logger.debug("We have got events from aggregator") for event in message.events: theApp.event_manager.add_event(event) return message
def _send_auth_message(self): request_msg = AuthenticatePeer() request_msg.agentID = str(theApp.peer_info.ID) request_msg.agentType = theApp.peer_info.Type request_msg.agentPort = theApp.listen_port request_msg.cipheredPublicKey.mod = str( theApp.key_manager.public_key.mod) request_msg.cipheredPublicKey.exp = str( theApp.key_manager.public_key.exp) g_logger.debug("Sending AuthenticatePeer message:\n%s" % request_msg) self._send_message(request_msg) self._auth_sent = True
def time_to_run(self, cur_time): if ( cur_time.tm_min in self.RunTime.minute and cur_time.tm_hour in self.RunTime.hour and cur_time.tm_mday in self.RunTime.day and cur_time.tm_mon in self.RunTime.month and cur_time.tm_wday in self.RunTime.weekday ): g_logger.debug("It's time to run '%s'" % self) return True else: return False
def _handle_check_aggregator_response(self, message): if message is None: return if message.status == "ON": self.available = True else: self.available = False g_logger.info("Aggregator status: %s" % message.status) g_logger.debug("Aggregator version: %s" % message.header.currentVersionNo) g_logger.debug("Aggregator test version: %s" % message.header.currentTestVersionNo) return message
def lineReceived(self, line): g_logger.debug("[FTP Test]:%s"%str(line)) FTPClient.lineReceived(self, line) if line.startswith('230'): # Logged in self.quit() task_done(self.test.__class__.__name__, TEST_SERVICE_TYPE, self.test) if self.reportDeferred: result = {'status_code': 0, 'time_end': default_timer()} self.reportDeferred.callback(result) elif line.startswith('530'): # Login failed task_failed(self.test.__class__.__name__, TEST_SERVICE_TYPE, self.test) if self.reportDeferred: result = {'status_code': 1, 'time_end': default_timer()} self.reportDeferred.callback(result)
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 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 _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 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 load_from_db(self): rs = g_db_helper.select("select * from peer_info") if not rs: g_logger.info("No peer info in db.") else: if len(rs) > 1: g_logger.warning("More than one record in user_info. " "Use the first one.") g_logger.debug(rs[0]) self.ID = rs[0][0] self.Username = rs[0][1] self.Password = rs[0][2] self.Email = rs[0][3] self.CipheredPublicKeyHash = rs[0][4] self.Type = rs[0][5] self.is_registered = True
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 insert_update_item_in_db(record): """""" sql_commit = "insert into updates (version,news_date,software_name, "\ "description, download_url, is_update, check_code ) "\ "values ('%s', '%s' , '%s', '%s','%s', '%s', '%s') " % \ (record["version"], record["news_date"], record["software_name"], record["description"], record["download_url"], record["is_update"], record["check_code"]) print sql_commit g_db_helper.execute(sql_commit) g_db_helper.commit() g_logger.debug("insert a new record(%s) into updates of DB." % sql_commit)
def lineReceived(self, line): g_logger.debug("[FTP Test]:%s" % str(line)) FTPClient.lineReceived(self, line) if line.startswith('230'): # Logged in self.quit() task_done(self.test.__class__.__name__, TEST_SERVICE_TYPE, self.test) if self.reportDeferred: result = {'status_code': 0, 'time_end': default_timer()} self.reportDeferred.callback(result) elif line.startswith('530'): # Login failed task_failed(self.test.__class__.__name__, TEST_SERVICE_TYPE, self.test) if self.reportDeferred: result = {'status_code': 1, 'time_end': default_timer()} self.reportDeferred.callback(result)
def load_from_db(self): rs = g_db_helper.select('select * from peer_info') if not rs: g_logger.info("No peer info in db.") else: if len(rs) > 1: g_logger.warning("More than one record in user_info. " \ "Use the first one.") g_logger.debug(rs[0]) self.ID = rs[0][0] self.Username = rs[0][1] self.Password = rs[0][2] self.Email = rs[0][3] self.CipheredPublicKeyHash = rs[0][4] self.Type = rs[0][5] self.is_registered = True
def save_report_to_db(self, table_name, report_entry): sql_stmt = "insert into %s (report_id, test_id, time_gen, content, "\ "source_id, source_ip, status) values "\ "('%s', '%s', '%s', '%s', '%s', '%s', '%s')" % \ (table_name, report_entry.ID, report_entry.TestID, datetime.datetime.fromtimestamp(report_entry.TimeGen), base64.b64encode(MessageFactory.encode(report_entry.Report)), report_entry.SourceID, report_entry.SourceIP, report_entry.Status) g_db_helper.execute(sql_stmt) g_db_helper.commit() g_logger.debug("Save report '%s' to table '%s'." % (report_entry.ID, table_name))
def execute_test(self,message): """ execute this test right now or randomly timeout """ if message is None: return g_logger.debug("The received Test Sets are:%s"%str(message)) if message.testVersionNo > self.current_test_version: g_logger.info("[Higher Version]Start to execute the tests(%d > %d)"%(message.testVersionNo,self.current_test_version)) self.set_test_version(message.testVersionNo) for test in message.tests: #tests is a list self.parse_test_message(test) else: g_logger.info("[Lower Version]Avoid these tests(%d <= %d)"%(message.testVersionNo,self.current_test_version))
def _handle_send_service_report_response(self, message): g_logger.debug("Handle Send Service Report: %s" % message) if message is None: return theApp.statistics.reports_sent_to_aggregator = \ theApp.statistics.reports_sent_to_aggregator + 1 if len(self.pending_report_ids): report_id = self.pending_report_ids.pop(0) # assume FIFO g_logger.info("ServiceReport '%s' has been sent to aggregator" % \ report_id) theApp.report_manager.remove_report(report_id, ReportStatus.SENT_TO_AGGREGATOR) else: g_logger.info("ServiceReport has been sent to aggregator") return message
def add_event(self, message): event_entry = EventEntry() event_entry.TestType = message.testType event_entry.EventType = message.eventType event_entry.TimeUTC = message.timeUTC event_entry.SinceTimeUTC = message.sinceTimeUTC for location in message.locations: event_entry.Locations.append((location.longitude, location.latitude)) if message.HasField('websiteReport'): event_entry.WebsiteReport = WebsiteReportDetail() event_entry.WebsiteReport.CopyFrom(message.websiteReport) if message.HasField('serviceReport'): event_entry.ServiceReport = ServiceReportDetail() event_entry.ServiceReport.CopyFrom(message.serviceReport) self.event_repository.append(event_entry) self.save_event_to_db(event_entry) g_logger.debug("Add one message into database. Details:(%s,%s)"%(message.testType,message.eventType))
def calculate_different(self): """ calculate the different http download: sum, average, variance We can add more complicated algorithm """ g_logger.debug("finish all benchmark http download throttled test") diff_value = 0 sum = 0 for key in range(1, self.benchmark_num + 1): sum = sum + self.benchmark_bandwidth[key]["bandwidth"] diff_value = self.benchmark_bandwidth[self.test_id]["bandwidth"] - sum / (self.benchmark_num) # print diff_value # print diff_value*1000*1000 self.report.report.bandwidth = int(diff_value * 1000 * 1000) print self.report.report
def calculate_different(self): """ calculate the different http download: sum, average, variance We can add more complicated algorithm """ g_logger.debug("finish all benchmark http download throttled test") diff_value = 0 sum = 0 for key in range(1, self.benchmark_num + 1): sum = sum + self.benchmark_bandwidth[key]['bandwidth'] diff_value = self.benchmark_bandwidth[ self.test_id]['bandwidth'] - sum / (self.benchmark_num) #print diff_value #print diff_value*1000*1000 self.report.report.bandwidth = int(diff_value * 1000 * 1000) print self.report.report
def execute_test(self, message): """ execute this test right now or randomly timeout """ if message is None: return g_logger.debug("The received Test Sets are:%s" % str(message)) if message.testVersionNo > self.current_test_version: g_logger.info( "[Higher Version]Start to execute the tests(%d > %d)" % (message.testVersionNo, self.current_test_version)) self.set_test_version(message.testVersionNo) for test in message.tests: #tests is a list self.parse_test_message(test) else: g_logger.info("[Lower Version]Avoid these tests(%d <= %d)" % (message.testVersionNo, self.current_test_version))
def _handle_login(self, result, username, password, save_login, login_only=False): """ """ #login successfully if result: self.peer_info.Username = username if username != "" and username != None else self.peer_info.Username self.peer_info.Password = password if password != "" and password != None else self.peer_info.Password #print self.peer_info.Username, self.peer_info.Password self.peer_info.is_logged_in = True #self.peer_info.clear_db() self.peer_info.save_to_db() g_logger.debug("Login Successfully :%s@%s" % (username, password)) if save_login: g_config.set('application', 'auto_login_swittch', True) else: g_config.set('application', 'auto_login_swittch', False) if self.use_gui: self.gtk_main.set_login_status(True) if login_only: return result #Load peers and reports from DB self._load_from_db() #check the new software(should appear after login successfully) self.check_software_auto() #mark login-successful self.is_successful_login = True #Task Looping manager self.task_loop_manager() return result
def _load_updates(self): """ load the information from the DB """ self.software_list_dict = {} cnt = 0 # get details from the DB rs = g_db_helper.select("select * from updates where is_update = %d" % no_updated) for record in rs: self.software_list_dict[cnt] = {} self.software_list_dict[cnt]["version"] = record[0] self.software_list_dict[cnt]["news_date"] = record[1] self.software_list_dict[cnt]["software_name"] = record[2] self.software_list_dict[cnt]["description"] = record[3] self.software_list_dict[cnt]["download_url"] = record[4] self.software_list_dict[cnt]["is_update"] = record[5] self.software_list_dict[cnt]["check_code"] = record[6] cnt = cnt + 1 g_logger.info("Loaded %d updates from DB." % len(rs)) # output in the window if len(self.software_list_dict) == 0: self.install_btn.set_sensitive(False) g_logger.info("No new updates from UpdateMoule") else: self.treeview.set_sensitive(True) self.check_btn.set_sensitive(False) g_logger.debug("Show the records in the tree-view") self.store.clear() for line in self.software_list_dict.keys(): self.store.append( [ self.software_list_dict[line]["news_date"], self.software_list_dict[line]["version"], self.software_list_dict[line]["software_name"], ] ) self.treeview.set_model(self.store) # It must be after the store update
def _load_updates(self): """ load the information from the DB """ self.software_list_dict = {} cnt = 0 #get details from the DB rs = g_db_helper.select("select * from updates where is_update = %d" % no_updated) for record in rs: self.software_list_dict[cnt] = {} self.software_list_dict[cnt]["version"] = record[0] self.software_list_dict[cnt]["news_date"] = record[1] self.software_list_dict[cnt]["software_name"] = record[2] self.software_list_dict[cnt]["description"] = record[3] self.software_list_dict[cnt]["download_url"] = record[4] self.software_list_dict[cnt]["is_update"] = record[5] self.software_list_dict[cnt]["check_code"] = record[6] cnt = cnt + 1 g_logger.info("Loaded %d updates from DB." % len(rs)) #output in the window if len(self.software_list_dict) == 0: self.install_btn.set_sensitive(False) g_logger.info("No new updates from UpdateMoule") else: self.treeview.set_sensitive(True) self.check_btn.set_sensitive(False) g_logger.debug("Show the records in the tree-view") self.store.clear() for line in self.software_list_dict.keys(): self.store.append([ self.software_list_dict[line]["news_date"], self.software_list_dict[line]["version"], self.software_list_dict[line]["software_name"] ]) self.treeview.set_model( self.store) #It must be after the store update
def add_event(self, message): event_entry = EventEntry() event_entry.TestType = message.testType event_entry.EventType = message.eventType event_entry.TimeUTC = message.timeUTC event_entry.SinceTimeUTC = message.sinceTimeUTC for location in message.locations: event_entry.Locations.append( (location.longitude, location.latitude)) if message.HasField('websiteReport'): event_entry.WebsiteReport = WebsiteReportDetail() event_entry.WebsiteReport.CopyFrom(message.websiteReport) if message.HasField('serviceReport'): event_entry.ServiceReport = ServiceReportDetail() event_entry.ServiceReport.CopyFrom(message.serviceReport) self.event_repository.append(event_entry) self.save_event_to_db(event_entry) g_logger.debug("Add one message into database. Details:(%s,%s)" % (message.testType, message.eventType))
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 parse_test_message(self, test): """ parse the test message and add it into task_manager """ from umit.icm.agent.test import * ############## ##Execute Time if test.executeAtTimeUTC == None: executeAtTimeUTC = 0 else: executeAtTimeUTC = test.executeAtTimeUTC #################### ##Website Task Parse if test.website and test.testType == TEST_WEB_TYPE: args = { 'url': str(test.website.url).strip(), 'unitied_test_id': test.testID } #crontime = self.random_cron_time(executeAtTimeUTC) #In test.py logical , we can call the according test functions g_logger.debug( "[Parse Test sets]:The authorized WebsiteTest from aggregator:%s" % str(test)) test_moduler = WebsiteTest() test_moduler.prepare(args) defer_website_ = test_moduler.execute() if defer_website_ is not None: defer_website_.addCallback(self.report_manager.add_report) #################### ##Service Task Parse #elif test.service and (test.testType).upper() == TEST_SERVICE_TYPE: elif test.service and (test.testType) == TEST_SERVICE_TYPE: args = { #'service':test.service.name, 'host': test.service.ip, 'port': test.service.port, 'unitied_test_id': test.testID, } #crontime = self.random_cron_time(executeAtTimeUTC) #In test.py logical , we can call the according test functions service_name = ( test.service.name).upper() #we unify the service name if service_name in service_name_by_id.keys(): g_logger.debug( "[Parse Test sets]:The authorized Service(%s) from aggregator:%s" % (service_name, str(test))) test_moduler = test_by_id[service_name_by_id[service_name]]() test_moduler.prepare(args) defer_service_ = test_moduler.execute() if defer_service_ is not None: defer_service_.addCallback(self.report_manager.add_report) else: g_logger.debug( 'Sorry, the current version cannot support %s service now' % (service_name))
def _install_software(self): """""" self.progress_bar.set_value(0) if self.current_record == None or len(self.current_record) == 0: self.install_btn.set_sensitive(False) g_logger.info("No new updates to be installed") return print self.current_record # download and install if compare_version(self.current_record["version"],VERSION) == higher_version: g_logger.debug("The version is right for icm-agent") download_update(url=self.current_record["download_url"], check_code = self.current_record["check_code"], version=self.current_record["version"]) self.install_btn.set_sensitive(False) else: g_logger.debug("The version is low than current icm-agent") self.statusbar.push(0,'The current is the lastest version!') self.install_btn.set_sensitive(False) self.check_btn.set_sensitive(True)