def __init__(self, args): self.env = simpy.Environment() self.args = args self.client_params = {} self.server_params = {} self.misc_params = {} self.parse_file() self.check_settings() self.print_session_summary() self.requests = {} self.__parse_requests() self.client_params[Contract.C_CLIENT_COUNT] = len(self.requests) random.seed(args.seed) self.__clients = [] logpath = args.logpath if logpath[:-1] != '/': logpath += '/' self.servers_manager = ServerManager(self.env, self.server_params, self.client_params, self.misc_params, self.__clients, logpath) client_logger = Logger(self.env, logpath) parity_group_creator = ParityGroupCreator(self.client_params, self.server_params) for i in range(len(self.requests)): self.__clients.append( Client(self.env, i, client_logger, self.servers_manager, self.client_params, self.misc_params, parity_group_creator)) self.servers_manager.add_requests_to_clients(self.requests)
def __init__(self): # ServerManager Object self.server = ServerManager() # Dictionary of characters to respective buffer number self.symbols = {} # Dictionary of buffer numbers to character self.buffers = {}
def main(): '''connect = UserManager('localhost', 'root', 'radio88', 'yate') connect.reset_table() print connect.list_users()''' server = ServerManager() if server.run()[1] == 0: call = CallToServer() #call.generic_comnand('status', ['\r\n', ]) time.sleep(2) call.stop_remote()
def main(): process_args() server = ServerManager(results.path, mc_server, results.memmin, results.memmax, results.gui) global current_ver print '*' * 40 print '* Simple Minecraft Server Wrapper' print '*' * 40 latest_ver = str(get_version()) if current_ver != latest_ver: download_server(latest_ver) current_ver = latest_ver if not server.online: server.start() time.sleep(5) while server.online: print '--- Checking for new versions in ' + str(check_for_new_versions_frequency) + ' seconds.' time.sleep(check_for_new_versions_frequency) if server.crash_check(): del server main() print '--- Checking for a new version...' server.message('Checking for a new version...') # Checking for new version if not up_to_date(current_ver): # new version detected time.sleep(30) server.shutdown() del server time.sleep(5) print '--- Server stopped' main()
def ManageClients(self, NewSocket, NewAddress): ''' 描述:开启新的进程,处理新的客户端请求 参数:无 返回:无 ''' print("New Client has linked in, the client is ", NewAddress) TheServerManager = ServerManager(NewSocket, NewAddress) print("A Client has disconnected, the client is ", NewAddress) return
class BufferManager: def __init__(self): # ServerManager Object self.server = ServerManager() # Dictionary of characters to respective buffer number self.symbols = {} # Dictionary of buffer numbers to character self.buffers = {} def from_file(self, configFile="./Settings/sample_names.txt", offset=0): """ Reads in a config file """ with open(path(configFile)) as f: lines = f.readlines() for bufnum, line in enumerate(lines): bufnum = bufnum + offset + 1 # 0 is the empty buffer try: char, fn = line.strip().split() self.symbols[char] = bufnum self.buffers[bufnum] = fn except: pass return self def __call__(self, server): self.server = server return self def load(self): for buf, fn in self.buffers.items(): self.server.bufferRead(buf, path("./Samples/" + fn)) def bufnum(self, char): b = 0 for ch, buf in self.symbols.items(): if ch == char: b = buf return b
def __init__(self, job_parms, **job_prop): """To support the 2 ways of gamess job creation.""" name = "Gamess Job 1" [self.job_batfile, self.job_outputfile] = job_prop.get('job_from_file', [None, None]) if self.job_outputfile: self.job_outputfile = self.job_outputfile.strip('"') self.gamessJig = job_prop.get('jig', None) if self.job_batfile: server_id = job_parms['Server_id'] from ServerManager import ServerManager self.server = ServerManager().getServerById(int(server_id)) if not self.server: raise ValueError, "The server of %d can't be found." % server_id SimJob.__init__(self, name, job_parms) self.edit_cntl = GamessProp() #Huaicai 7/6/05: try to fix the problem when run a gamess jig coming from mmp file #and without openning the jig property windows and save it. if not self.__dict__.has_key('server'): from ServerManager import ServerManager sManager = ServerManager() self.server = sManager.getServers()[0]
class Server: def __init__(self, local_addr, remote_addr, loop): self.local_addr = local_addr self.remote_addr = remote_addr self.loop = loop or asyncio.get_event_loop() self.manager = ServerManager(local_addr=local_addr, loop=self.loop) async def start(self): await self.manager.start() while True: kcp = await self.manager.accept() self.loop.create_task(self.dispatcher(kcp)) async def dispatcher(self, kcp): reader, writer = await asyncio.open_connection(self.remote_addr[0], self.remote_addr[1], loop=self.loop) pending = {self.manager.recv(kcp), self.read(reader)} try: while True: done, pending = await asyncio.wait( pending, return_when=asyncio.FIRST_COMPLETED, loop=self.loop) for task in done: flag, data = task.result() if flag == 'recv': writer.write(data) await writer.drain() pending.add(self.manager.recv(kcp)) elif flag == 'read': self.manager.send(kcp, data) pending.add(self.read(reader)) else: pass except (asyncio.CancelledError, Exception) as err: print(err) finally: writer.close() self.manager.close(kcp) async def read(self, reader): return 'read', (await reader.read(1024))
def run(): # 初始化日志配置 Log.create_log_file() Log.logger.info(u"加载设备及用户配置信息") DataProvider.init_data() Log.logger.info(u"获得ADB连接的设备") DeviceManager.get_connect_deviceid() if 0 == len(DeviceManager.connectdeviceid): Log.logger.info(u"没有连接的设备") sys.exit() else: Log.logger.info(u"当前已连接设备数: %s" % len(DeviceManager.connectdeviceid)) Log.logger.info(u"获得待测试的设备") DeviceManager.get_test_device() servermanager = ServerManager() servermanager.list_devices() servermanager.start_all_server()
#!/usr/bin/env python3 from ServerManager import ServerManager if __name__ == "__main__": sm = ServerManager()
def __init__(self): ServerManager.__init__(self)
def __init__(self, local_addr, remote_addr, loop): self.local_addr = local_addr self.remote_addr = remote_addr self.loop = loop or asyncio.get_event_loop() self.manager = ServerManager(local_addr=local_addr, loop=self.loop)
class Simulator: def __init__(self, args): self.env = simpy.Environment() self.args = args self.client_params = {} self.server_params = {} self.misc_params = {} self.parse_file() self.check_settings() self.print_session_summary() self.requests = {} self.__parse_requests() self.client_params[Contract.C_CLIENT_COUNT] = len(self.requests) random.seed(args.seed) self.__clients = [] logpath = args.logpath if logpath[:-1] != '/': logpath += '/' self.servers_manager = ServerManager(self.env, self.server_params, self.client_params, self.misc_params, self.__clients, logpath) client_logger = Logger(self.env, logpath) parity_group_creator = ParityGroupCreator(self.client_params, self.server_params) for i in range(len(self.requests)): self.__clients.append( Client(self.env, i, client_logger, self.servers_manager, self.client_params, self.misc_params, parity_group_creator)) self.servers_manager.add_requests_to_clients(self.requests) def print_session_summary(self): print("Server Count: {}".format( self.server_params[Contract.S_SERVER_COUNT])) print( "Devices per server: {} ({} MBps Reading, {} MBps Writing)".format( self.server_params[Contract.S_HDD_DATA_COUNT], self.server_params[Contract.S_HDD_DATA_READ_MBPS], self.server_params[Contract.S_HDD_DATA_WRITE_MBPS])) print("Geometry {}+{}".format( self.client_params[Contract.C_GEOMETRY_BASE], self.client_params[Contract.C_GEOMETRY_PLUS])) print("Request file: {}".format(self.args.request)) print() def check_settings(self): # geometry must be less or equal than server number assert (self.client_params[Contract.C_GEOMETRY_BASE] + self.client_params[Contract.C_GEOMETRY_PLUS]) \ <= self.server_params[Contract.S_SERVER_COUNT] def parse_file(self): configuration = open(self.args.config, "r") for line in configuration: couple = line.strip().split('=') try: field = couple[0].strip() value = couple[1].strip() if field[0] == "C": # Client options self.client_params[field] = int(value) elif field[0] == "S": # Server options self.server_params[field] = int(value) elif field[0] == "M": # Misc Options self.misc_params[field] = value # self.params[couple[0].strip()] = int(couple[1].strip()) except Exception: if line[0] == '#': continue def __from_human(self, human_number: str): """ Replace human readable format with machine readable numbers. Used to improve request file readability :param human_number: the string representing the number :return: the integer represented """ r = human_number.replace("P", "GG").replace("T", "GM").replace( "G", "MM").replace("M", "000") return int(r) def __parse_requests(self): requests = open(self.args.request, 'r') # parses the file once to create an empty container of requests clients_count = 0 for line in requests: try: if line == "" or line.startswith('#'): continue if line.strip()[0] != '*': clients_count += 1 except Exception: pass for i in range(clients_count): self.requests[i] = [] requests.seek(0) line_number = 0 for line in requests: line = line.strip() try: if line == "" or line.startswith('#'): continue words = line.split(" ") if words[0] == '*': req = (self.__from_human(words[1]), self.__from_human(words[2])) if req[0] != 0 and req[1] != 0: for i in range(clients_count): self.requests[i].append(req) else: req = (self.__from_human(words[0]), self.__from_human(words[1])) if req[0] != 0 and req[1] != 0: self.requests[line_number].append(req) line_number += 1 except Exception: if line[0] == '#': continue def print_params(self, verbose=False): if args.verbose or verbose: for key, value in self.client_params.items(): print('{:>30} : {:d}'.format(key, value)) print() print("- - - - - - - - - - - - - - - - - - - -") print() for key, value in self.server_params.items(): print('{:>30} : {:d}'.format(key, value)) def run(self): self.env.run()
def main(): # Parsing command line parameters and necessary configuration parser = argparse.ArgumentParser() parser.add_argument("--configuration", help="JSON file configuring the program (triplestore, ...)", required=True, dest="conf_file_path") parser.add_argument("--max-rows", dest="max_rows", help="Value of the parameter ResultSetMaxRows in virtuoso.ini", required=True, type=int, default=10000) parser.add_argument("--output", dest="output_dir", help="Base directory for output files", required=True) parser.add_argument("--self-signed-ssl", dest="self_signed_ssl", help="Enable querying a server with self-signed SSL certificate", action="store_true", default=False) parser.add_argument("--debug", dest="debug", help="Enable debug output", action="store_true") args = parser.parse_args() # Logging parameters logger = get_logger(args.debug) # Configuration parameters configuration_parameters = load_configuration_parameters(args.conf_file_path) # Server manager server_manager = ServerManager(configuration_parameters, args.max_rows, args.self_signed_ssl) # CacheManagers cache_managers = { "predicates": CacheManager(), # CacheManager for predicates "rdf_nodes": CacheManager() # CacheManager for RDF nodes } # Get RDF graph adjacency logger.info("Get RDF graph adjacency") rdf_graph_adjacency = get_rdf_graph_adjacency(server_manager, cache_managers, logger) logger.info("Compute statistics") rdf_edges_before_completion = get_number_of_edges(rdf_graph_adjacency) # Complete RDF graph adjacency with owl:sameAs symmetry and transitivity logger.info("Complete RDF graph adjacency with owl:sameAs symmetry and transitivity") rdf_graph_adjacency = same_as_adjacency_completion(rdf_graph_adjacency, cache_managers["predicates"]) # Canonicalize RDF graph by transforming nodes in owl:sameAs connected components into one node logger.info("Get canonical RDF graph") canonical_graph = get_canonical_graph(rdf_graph_adjacency, cache_managers["predicates"]) # Saving data logger.info("Saving data") output_dir = args.output_dir if output_dir[-1] != "/": output_dir += "/" pickle.dump(canonical_graph["rdf_to_canonical_index"], open(output_dir + "rdf_to_canonical_index", "wb")) pickle.dump(canonical_graph["canonical_to_rdf_index"], open(output_dir + "canonical_to_rdf_index", "wb")) pickle.dump(canonical_graph["adjacency"], open(output_dir + "canonical_graph_adjacency", "wb")) pickle.dump(canonical_graph["inv_adjacency"], open(output_dir + "canonical_graph_inv_adjacency", "wb")) cache_managers["rdf_nodes"].save_to_csv(output_dir + "rdf_nodes_cache_manager.csv") cache_managers["predicates"].save_to_csv(output_dir + "predicates_cache_manager.csv") # Computing and saving statistics logger.info("Compute and save final statistics on RDF graph and canonical graph") with open(output_dir + "graphs_statistics.md", "w") as file: file.write("# Graphs statistics\n") file.write("Generated on {}\n".format(datetime.datetime.now())) file.write("## RDF graph\n") file.write("* Number of nodes: {}\n".format(len(canonical_graph["rdf_to_canonical_index"]))) file.write("* Number of edges (before sameAs completion): {}\n".format(rdf_edges_before_completion)) file.write("* Number of edges (after sameAs completion): {}\n".format(get_number_of_edges(rdf_graph_adjacency))) file.write("* Number of types of edges: {}\n".format(len(rdf_graph_adjacency))) file.write("## Canonical graph\n") file.write("* Number of nodes: {}\n".format(len(canonical_graph["canonical_to_rdf_index"]))) file.write("* Number of edges: {}\n".format(get_number_of_edges(canonical_graph["adjacency"]))) file.write("* Number of types of edges: {}\n".format(len(canonical_graph["adjacency"]))) logger.info("Done") if args.debug: print_debug_output(canonical_graph, cache_managers, logger)
async def handle_echo(reader, writer): """ TCP SERVER connections are binded to this method this method utilizes the ServerManager module to handle all the read and write operations for the connected clients """ addr = writer.get_extra_info('peername') message = f"{addr} is connected !!!!" writer.write( ('Proceed with command(login <username> <password>).\n').encode()) await writer.drain() writer.write(( 'To register a new user, use command (register <username> <password> <privilige>)\n' ).encode()) await writer.drain() manager = ServerManager() try: while True: data = await reader.read(100) message = data.decode().strip() if message == 'quit': break elif message.startswith('help'): data = manager.help() elif message.startswith('change_folder'): if len(message.split(' ')) == 2: data = manager.changeFolder(message.split(' ')[1]) else: data = "Please provide a folder name" elif message.startswith('list'): if len(message.split(' ')) == 1: data = manager.list() else: data = "Please provide a filename" elif message.startswith('read_file'): if len(message.split(' ')) == 2: data = manager.readFile(message.split(' ')[1]) else: data = "Please provide a filename" elif message.startswith('write_file'): if len(message.split(' ')) == 3: data = manager.writeFile( message.split(' ')[1], message.split(' ')[2]) else: data = "Please provide a filename and data" elif message.startswith('create_folder'): if len(message.split(' ')) == 2: data = manager.createFolder(message.split(' ')[1]) else: data = "Please provide a foldername" elif message.startswith('register'): if len(message.split(' ')) == 4: data = manager.register( message.split(' ')[1], message.split(' ')[2], message.split()[3]) else: data = "Please provide a username, password and privilege." elif message.startswith('login'): if len(message.split(' ')) == 3: data = manager.login( message.split(' ')[1], message.split(' ')[2]) else: data = "Please provide a username and password." elif message.startswith('delete'): if len(message.split(' ')) == 3: data = manager.delete( message.split(' ')[1], message.split(' ')[2]) else: data = "Please provide a username and password." else: data = 'Command not recognized' if data: writer.write((data + '\n').encode()) await writer.drain() else: writer.write(( 'There was an error. you can user command help to get available commands' + '\n').encode()) await writer.drain() except ConnectionRefusedError: await asyncio.sleep(0.1) return except asyncio.CancelledError: return except ConnectionAbortedError: print("A Connection was closed") return except ConnectionResetError: print(f"A Connection was closed :{addr}") return except Exception: raise else: print("Close the connection") writer.close()