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 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
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 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()
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 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()
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)
#!/usr/bin/env python3
from ServerManager import ServerManager
if __name__ == "__main__":
sm = ServerManager()
