Esempio n. 1
0
 def run(self):
     self.uri, self.ns_daemon, self.bc_server = naming.startNS(
         self.hostname)
     self.started.set()
     if self.bc_server:
         self.bc_server.runInThread()
     self.ns_daemon.requestLoop()
Esempio n. 2
0
 def run(self):
     # start the nameserver, it configures a broadcast server for us
     self.uri, self.ns_daemon, self.bc_server = naming.startNS(
         host=self.hostname)
     # start this broadcast server in its own thread
     self.bc_server.runInThread()
     # signal the main thread that setup is done
     self.started.set()
     # serve away...
     self.ns_daemon.requestLoop()
Esempio n. 3
0
    def __init__(self, group=None, target=None, name=None, **kwargs):

        super().__init__(group=group, target=target, name=name)

        self.ns_uri, self.ns_daemon, self.bc_server_daemon = naming.startNS(host=kwargs['host'])

        self.daemon =  Pyro4.Daemon(host=kwargs['host'])

        self.data_manager = managers.DataManager(sys.path[0])

        self.uri_dm = self.daemon.register(self.data_manager)
        self.ns_daemon.nameserver.register('data_manager', self.uri_dm)

        chord_hash = int(hashlib.sha1(bytes('{host}:{port}'.format_map({'host': kwargs['host'],
                                            'port': str(self.uri_dm).split('@')[1].split(':')[1]}),
                                            'utf-8')).hexdigest(), 16)

        self.chord_widgets = Chord(kwargs['host'], int(str(self.uri_dm).split('@')[1].split(':')[1]), chord_hash, 160,
                                   widget=True)

        self.chord_widgets.data_manager_uri = str(self.uri_dm)

        self.chord_widgets.uri = 'PYRO:{name}@{ip}:{port}'.format_map({'name': 'chord_widgets', 'ip': kwargs['host'],
                                                               'port': str(self.uri_dm).split('@')[1].split(':')[1]})


        self.chord_pages = Chord(kwargs['host'], int(str(self.uri_dm).split('@')[1].split(':')[1]), chord_hash, 160,
                                 widget=False)

        self.chord_pages.data_manager_uri = str(self.uri_dm)

        self.chord_pages.uri = 'PYRO:{name}@{ip}:{port}'.format_map({'name': 'chord_pages', 'ip': kwargs['host'],
                                                               'port': str(self.uri_dm).split('@')[1].split(':')[1]})


        daemon_thread = threading.Thread(target=self.daemon_instance, args=(self.daemon,), name='demonio')

        ns_thread = threading.Thread(target=self.name_server_daemon, args=(self.ns_daemon,),
                                     name='demonio del name server')

        bc_thread = threading.Thread(target=self.broadcast_server_daemon, args=(self.bc_server_daemon,),
                                     name='demonio del broadcast')


        daemon_thread.start()
        ns_thread.start()
        bc_thread.start()
Esempio n. 4
0
def main():
    uris_list = []

    ns_uri, ns_daemon, bc_server = naming.startNS(
        socketutil.getIpAddress('localhost', workaround127=True))

    daemon = Pyro4.Daemon(
        socketutil.getIpAddress('localhost', workaround127=True))

    algo1 = Tester()
    algo2 = Tester()

    for item in [algo1]:
        uri = daemon.register(item, 'algo')
        uris_list.append(uri)  # se dejan las uris en una lista

    daemon_thread = threading.Thread(target=daemon_instance,
                                     args=(daemon, ),
                                     name='demonio')
    daemon_thread.start()

    print(ns_uri)
    print(uris_list)

    for uri in uris_list:
        print(uri)
        ns_daemon.nameserver.register('tester', uri)

    ns_thread = threading.Thread(target=name_server_daemon,
                                 args=(ns_daemon, ),
                                 name='demonio del name server')

    bc_thread = threading.Thread(target=broadcast_server_daemon,
                                 args=(bc_server, ),
                                 name='demonio del broadcast')

    ns_thread.start()
    bc_thread.start()
Esempio n. 5
0
def share_local_object(object_name,
                       whitelist=None,
                       host="localhost",
                       port=9090):
    """
    Share a local object of the given name over the network.

    :param str object_name: name of the local object
    :param whitelist: shared functions/classes of the local object as tuple
                      pairs (module, function) or (module, class); whitelist
                      all (do not filter) if None or empty
    :type whitelist: [(str,str)] or None
    :param str host: ip address of the local name server
    :param port: port of the local sharing server
    :type port: int or str

    This function shares a custom object with whitelisted attributes through a
    custom implementation. It is more secure but more limited as functionality
    since it requires serialization extensions.
    """
    Pyro4.config.AUTOPROXY = True
    Pyro4.config.REQUIRE_EXPOSE = False
    port = int(port) if isinstance(port, str) else port

    # pyro daemon
    try:
        pyro_daemon = Pyro4.Daemon(host=host)
        LOG.debug("Pyro4 daemon started successfully")
        pyrod_running = False
    # address already in use OS error
    except OSError:
        pyro_daemon = Pyro4.Proxy("PYRO:" + Pyro4.constants.DAEMON_NAME + "@" +
                                  host)
        pyro_daemon.ping()
        LOG.debug("Pyro4 daemon already started, available objects: %s",
                  pyro_daemon.registered())
        pyrod_running = True

    # name server
    try:
        ns_server = Pyro4.locateNS(host=host, port=port)
        LOG.debug("Pyro4 name server already started")
        nsd_running = True
    # network unreachable and failed to locate the nameserver error
    except (OSError, Pyro4.errors.NamingError):
        from Pyro4 import naming
        ns_uri, ns_daemon, _bc_server = naming.startNS(host=host, port=port)
        ns_server = Pyro4.Proxy(ns_uri)
        LOG.debug("Pyro4 name server started successfully with URI %s", ns_uri)
        nsd_running = False

    # main retrieval of the local object
    module = importlib.import_module(object_name)

    def proxymethod(fun):
        """Decorator to autoproxy all callables."""
        def wrapper(*args, **kwargs):
            rarg = fun(*args, **kwargs)

            def proxify_type(rarg):
                if rarg is None or type(rarg) in (bool, int, float, str):  # pylint: disable=C0123
                    return rarg
                if isinstance(rarg, tuple):
                    return tuple(proxify_type(e) for e in rarg)
                if isinstance(rarg, list):
                    return [proxify_type(e) for e in rarg]
                if isinstance(rarg, dict):
                    return {
                        proxify_type(k): proxify_type(v)
                        for (k, v) in rarg.items()
                    }
                pyro_daemon.register(rarg)
                return rarg

            import types
            if isinstance(rarg, types.GeneratorType):

                def generator_wrapper():
                    for nxt in rarg:
                        yield proxify_type(nxt)

                return generator_wrapper()
            return proxify_type(rarg)

        return wrapper

    class ModuleObject:  # pylint: disable=R0903
        """Module wrapped for transferability."""

    for fname, fobj in inspect.getmembers(module, inspect.isfunction):
        if not whitelist or (object_name, fname) in whitelist:
            setattr(ModuleObject, fname, staticmethod(proxymethod(fobj)))
    for cname, cobj in inspect.getmembers(module, inspect.isclass):
        if not whitelist or (object_name, cname) in whitelist:
            setattr(ModuleObject, cname, staticmethod(proxymethod(cobj)))
    local_object = ModuleObject()

    # we should register to the pyro daemon before entering its loop
    uri = pyro_daemon.register(local_object)
    if not pyrod_running:
        loop = DaemonLoop(pyro_daemon)
        loop.start()
    if not nsd_running:
        loop = DaemonLoop(ns_daemon)
        loop.start()
    # we should register to the name server after entering its loop
    ns_server.register(object_name, uri)

    LOG.info("Local object '%s' sharing - ready", object_name)
    loop.join()
Esempio n. 6
0
 def run(self):
     self.uri, self.ns_daemon, self.bc_server = naming.startNS(self.hostname)
     self.started.set()
     if self.bc_server:
         self.bc_server.runInThread()
     self.ns_daemon.requestLoop()