Example #1
0
    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)
Example #2
0
    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 = {}
Example #3
0
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()
Example #5
0
 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
Example #6
0
    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 = {}
Example #7
0
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
Example #8
0
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]
Example #10
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))
Example #11
0
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()
Example #12
0
#!/usr/bin/env python3
from ServerManager import ServerManager

if __name__ == "__main__":
    sm = ServerManager()

 def __init__(self):
     ServerManager.__init__(self)
Example #14
0
 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)
Example #15
0
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()
Example #16
0
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)
Example #17
0
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()
Example #18
0
 def __init__(self):
     ServerManager.__init__(self)