def log_run_test(self):
TestServer.TESTS_RAN += 1
self.start_time = time.strftime('%Y-%m-%d_%H:%M:%S')
self.write_start = time.time()
self.test = self.client_message[0]
self.test_args = self.client_message[1]
server_log.debug(self.client_id + ': Running {} {}'.format(self.test, self.test_args))
def run(self):
""" If setup succeeds, continue asyncore loop until exit status is reached. """
server_log.debug('Starting session')
if self.setup():
self.start_time = time.strftime('%Y-%m-%d_%H:%M:%S')
while self.check_for_exit():
asyncore.loop(timeout=Config.LOOP_TIMEOUT, count=Config.LOOP_COUNT)
def handle_accept(self):
""" Spawn TestClient instance with unique id to handle connected client. """
pair = self.accept()
if pair is not None:
sock, address = pair
server_log.debug('Connection from %s' % repr(address))
ClientAPI(sock, uuid.uuid4(), self.test_queue, self.db_cursor)
self.connections_total += 1
self.connection_made = True
def handle_close(self):
""" Records test status and shutdowns socket. """
server_log.debug(self.client_id + ': stop')
if self.test_completed:
self.test_status = 'COMPLETED'
else:
self.test_status = 'ABORTED'
self.end_time = time.strftime('%Y-%m-%d_%H:%M:%S')
self.write_to_db()
self.close()
def setup(self):
""" Create/bind socket and initialize sqlite database.
Return:
bool: True if no errors occur with sockets or db.
"""
server_log.debug('Setting up server')
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.bind((self.host, self.port))
self.set_reuse_addr()
self.listen(5)
self.initialize_database()
server_log.debug('Setup successful')
return True
def send_client_test(self):
""" Sends test from queue if non empty, otherwise sends None. """
if not self.test_queue.empty():
self.test = self.test_queue.get()
self.test_args = ", ".join([str(arg) for arg in self.test])
# Must guarantee that self.test is no longer a namedtuple after pulling information
# this eases the write out to the db for both paths (client test or server test)
self.test = type(self.test).__name__
test_string = self.test + Config.API_DELIMITER + self.test_args
server_log.debug(self.client_id + ': Sending test-' + test_string)
self.send(Config.API_TEST_REQUEST + Config.API_DELIMITER + test_string + Config.TERMINATOR)
else:
server_log.debug(self.client_id + ': test queue is empty, no test sent')
self.send(Config.API_TEST_REQUEST + Config.TERMINATOR)
def check_for_exit(self):
""" Called in run() after every loop of asyncore.
Return:
bool: True if clients are present or no client has connected,
False otherwise.
"""
if len(asyncore.socket_map) > 1:
return True
elif not self.connection_made:
return True
else:
server_log.debug('No Clients Remain')
return False
def log_unknown(self):
server_log.debug(self.client_id + ': Unknown command from client({})'.format(self.client_header))
def log_bad_timeout(self):
server_log.debug(self.client_id + ': timeout too low, timeout set to ' + self.client_message[0])
def log_test_info(self):
self.files_written += 1
self.write_stop = time.time()
server_log.debug(self.client_id + ': file roll over')
def log_test_stats(self):
self.stat_tick += 1
self.cpu_total += float(self.client_message[1])
self.mem_total += float(self.client_message[3])
server_log.debug(self.client_id + ': ' + ' '.join(str(msg) for msg in self.client_message))
def log_heartbeat(self):
server_log.debug(self.client_id + ': heartbeat')
def log_client_end(self):
server_log.debug(self.client_id + ': test finished')
self.test_completed = True
TestServer.TESTS_COMPLETED += 1
self.handle_close()
def log_client_start(self):
server_log.debug(self.client_id + ': start')
def send_client_id(self):
""" Sends self.client_id. """
server_log.debug(self.client_id + ': sending id')
self.send(Config.API_ID_REQUEST + Config.API_DELIMITER +
self.client_id + Config.TERMINATOR)
def end(self):
""" Commit statements to database and then close the connection """
self.end_time = time.strftime('%Y-%m-%d_%H:%M:%S')
server_log.debug('Ending Session: Server Metrics')
server_log.debug('\tstart time: {}'.format(self.start_time))
server_log.debug('\tend time: {}'.format(self.end_time))
server_log.debug('\tconnections made: {}'.format(self.connections_total))
server_log.debug('\ttests ran: {}'.format(TestServer.TESTS_RAN))
server_log.debug('\ttests completed: {}'.format(TestServer.TESTS_COMPLETED))
if self.db:
self.db.commit()
self.db.close()
self.close()
def log_client_system_info(self):
self.client_cpu_info = self.client_message[0]
server_log.debug(self.client_id + ': system info gathered')
def log_bad_timeout(self):
server_log.debug(self.client_id + ': timeout too low, timeout set to ' + self.client_message[0])
def log_unknown(self):
server_log.debug(self.client_id + ': Unknown command from client({})'.format(self.client_header))
def write_to_db(self):
""" Write out test information to database. """
if self.test:
if self.stat_tick:
self.avg_cpu = self.mem_total / self.stat_tick
self.avg_mem = self.cpu_total / self.stat_tick
if self.test == Config.TEST_FILE_WRITE_NAME:
arg_dict = literal_eval(self.test_args)
self.avg_write_speed = (self.files_written * arg_dict['file_size']) / (self.write_stop - self.write_start)
entries = (self.test + '\n' + self.test_args, self.start_time, self.end_time, self.files_written,
self.avg_write_speed, self.avg_cpu, self.avg_mem, self.client_cpu_info, self.test_status)
self.db_cursor.execute('INSERT INTO tests VALUES (?,?,?,?,?,?,?,?,?);', entries)
if __name__ == '__main__':
server = TestServer(Config.HOST, Config.PORT)
try:
server.run()
except KeyboardInterrupt:
print "Ended via keyboard interrupt"
except Exception as e:
print server_log.debug('Faulted during execution.')
raise e
finally:
server.end()
