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 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 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_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 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 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 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 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_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 _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 _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 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 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 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 _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 _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)
