def check_ns_present(): try: Pyro4.locateNS(host=master_ip) except Pyro4.errors.NamingError: return False else: return True
def locate_ns(nsaddr, timeout=3): """ Locate a name server (ping) to ensure it actually exists. Parameters ---------- nsaddr : SocketAddress The address where the name server should be up and running. timeout : float Timeout in seconds before aborting location. Returns ------- nsaddr The address where the name server was located. Raises ------ NamingError If the name server could not be located. """ host, port = address_to_host_port(nsaddr) if nsaddr is None: host = '127.0.0.1' port = 9090 time0 = time.time() while time.time() - time0 < timeout: try: Pyro4.locateNS(host, port) return nsaddr except NamingError: continue raise NamingError('Could not find name server after timeout!')
def safe_start_name_server(): try: Pyro4.locateNS() except Pyro4.errors.NamingError: print "Starting naming server" p = Process(target=Pyro4.naming.startNSloop) p.start()
def locate_ns(nsaddr, timeout=3.): """ Locate a name server to ensure it actually exists. Parameters ---------- nsaddr : SocketAddress The address where the name server should be up and running. timeout : float Timeout in seconds before aborting location. Returns ------- nsaddr The address where the name server was located. Raises ------ NamingError If the name server could not be located. """ host, port = address_to_host_port(nsaddr) time0 = time.time() while True: try: Pyro4.locateNS(host, port) return nsaddr except NamingError: if time.time() - time0 < timeout: time.sleep(0.1) continue raise TimeoutError('Could not locate the name server!')
def connect_and_send_heartbeat_pg(pulse_generator_flag, pulse_generator_name): # connect to pacemaker if pulse_generator_flag: DAQ.pulse_generator_01 = Pyro4.Proxy(Pyro4.locateNS().lookup(pulse_generator_name)) return DAQ.pulse_generator_01.pulse_receiver(DAQ.heartbeat, pulse_generator_name) else: DAQ.pulse_generator_02 = Pyro4.Proxy(Pyro4.locateNS().lookup(pulse_generator_name)) return DAQ.pulse_generator_02.pulse_receiver(DAQ.heartbeat, pulse_generator_name)
def start(self): """Calls the appropriate start method using device_type provided""" if self.device_type == 'master': try: Pyro4.locateNS() except Pyro4.errors.NamingError: self.start_name_server() from pisync import master master.Master(self.config).start() elif self.device_type == 'slave': from pisync import slave slave.Slave(self.config).start() else: raise ValueError('device_type must be either master or slave')
def connectNameServer(nshost, nsport, hkey, timeOut=3.0): """ Connects to a NameServer. :param str nshost: IP address of nameServer :param int nsport: Nameserver port. :param str hkey: A password string :param float timeOut: Waiting time for response in seconds :return: NameServer :rtype: Pyro4.naming.Nameserver :except: Can not connect to a LISTENING port of nameserver """ try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(timeOut) s.connect((nshost, nsport)) s.close() logger.debug("Can connect to a LISTENING port of nameserver on " + nshost + ":" + str(nsport)) except Exception as e: msg = "Can not connect to a LISTENING port of nameserver on " + nshost + ":" + str(nsport) + ". Does a firewall block INPUT or OUTPUT on the port? Exiting." logger.debug(msg) logger.exception(e) exit(1) #locate nameserver try: ns = Pyro4.locateNS(host=nshost, port=nsport,hmac_key=hkey) msg = "Connected to NameServer on %s:%s. Pyro4 version on this computer is %s" %(nshost, nsport, Pyro4.constants.VERSION) logger.debug(msg) except Exception as e: msg = "Can not connect to NameServer on %s:%s. Is the NameServer running? Runs the NameServer on the same Pyro version as this version %s? Do you have the correct hmac_key (password is now %s)? Exiting." %(nshost, nsport, Pyro4.constants.VERSION, hkey) logger.debug(msg) logger.exception(e) exit(1) return ns
def SvcDoRun(self): self.ReportServiceStatus(win32service.SERVICE_START_PENDING) # read in the device config from config import objects self.objects = objects import servicemanager # create daemon self.daemon = Pyro4.Daemon(port=PORT, host=socket.gethostbyname(socket.gethostname())) # find the nameserver try: self.ns=Pyro4.locateNS() except: servicemanager.LogErrorMsg("Exception: could not locate Pyro nameserver.") # return self.SvcStop() for o in self.objects: # create the object instance, register it with daemon and nameserver try: o['handle'] = o['class'](*o['args'], **o['kwargs']) except: servicemanager.LogErrorMsg("Exception: could not create " + o['id']) return self.SvcStop() o['uri'] = self.daemon.register(o['handle'], objectId=o['id']) if self.ns: self.ns.register(o['id'], o['uri']) self.ReportServiceStatus(win32service.SERVICE_RUNNING) self.daemon.requestLoop()
def runSingleServerInstanceNoNat(): # Parse arguments args = parser.parse_args() sys.path.append(os.getcwd()) # Load config conf = args.configFile if conf[-3:] == ".py": conf = conf[:-3] print(conf) cfg = importlib.import_module(conf) app = MMPRaytracer("localhost") # Creates deamon, register the app in it daemon = Pyro4.Daemon(host=cfg.server, port=cfg.serverPort) uri = daemon.register(app) # Get nameserver ns = Pyro4.locateNS(host=cfg.nshost, port=cfg.nsport, hmac_key=cfg.hkey) # Register app ns.register(cfg.appName, uri) print(uri) # Deamon loops at the end daemon.requestLoop()
def main(): """ Create stockmarkets and run the Thread """ symbols = ["AAPL", "CSCO", "MSFT", "GOOG"] nasdaq = StockMarket("NASDAQ", symbols) symbols = ["IBM", "HPQ", "BP"] newyork = StockMarket("NYSE", symbols) # Create Pyro Daemon and register stockmarket objects to get the uri daemon = Pyro4.Daemon() nasdaq_uri = daemon.register(nasdaq) newyork_uri = daemon.register(newyork) # We need to locate the Name Server and register our objects. ns = Pyro4.locateNS() ns.register("example.stockmarket.nasdaq", nasdaq_uri) ns.register("example.stockmarket.newyork", newyork_uri) # run the stockmarkets and create a requestLoop. nasdaq.run() newyork.run() print("Stockmarkets are now online.") daemon.requestLoop()
def concurrent_task_file(task_name,instance_name,file_name, *task_args): employed_node_name = str(round_robin_next()) # Do the file transfer - get the IP address from the PyRO nameserver ns = Pyro4.locateNS(host=nameserver_ip) loc = ns.lookup("worker.node_"+employed_node_name).location ip_search = re.search('\d*[.]\d*[.]\d*[.]\d*',loc) ip_ad = ip_search.group(0) employed_node = Pyro4.Proxy("PYRONAME:worker.node_"+employed_node_name) employed_node.slave_receive_file(file_name) # Now start sending the file f = open("shared_files/" + file_name, 'rb') sock = socket.socket() sock.connect((ip_ad, 9870)) while True: chunk = f.read(65536) if not chunk: break sock.sendall(chunk) sock.close() # Make sure the file is completely copied?? employed_node.slave_do_concurrent_task(task_name,instance_name, *task_args) return employed_node
def settings_server(): daemon = Pyro4.Daemon() ns = Pyro4.locateNS() settings = ss.settings.Settings() uri = daemon.register(settings) ns.register("sc.settings", uri) daemon.requestLoop()
def print_name_server_object_list(): """ Use name_server function """ ns = Pyro4.locateNS(host='localhost') print(ns.lookup('maker')) print(ns.list())
def count(self, lines): # use the name server's prefix lookup to get all registered wordcounters with Pyro4.locateNS() as ns: all_counters = ns.list(prefix="example.dc.wordcount.") counters = [Pyro4.Proxy(uri) for uri in all_counters.values()] for c in counters: c._pyroAsync() # set proxy in asynchronous mode roundrobin_counters = cycle(counters) # chop the text into chunks that can be distributed across the workers # uses asynchronous proxy so that we can hand off everything in parallel # counter is selected in a round-robin fashion from list of all available counters # (This is a brain dead way because it doesn't scale - all the asynchronous calls are hogging # the worker threads in the server. That's why we've increased that a lot at the start # of this file, just for the sake of this example!) async_results = [] for chunk in grouper(100, lines): counter = next(roundrobin_counters) result = counter.count(chunk) async_results.append(result) # gather the results print("Collecting %d results..." % len(async_results)) totals = Counter() for result in async_results: try: totals.update(result.value) except Pyro4.errors.CommunicationError as x: raise Pyro4.errors.PyroError("Something went wrong in the server when collecting the async responses: "+str(x)) for proxy in counters: proxy._pyroRelease() return totals
def reconnect_to_server(self): disconnected = True while disconnected: try: name_server = Pyro4.locateNS() server_dict = name_server.list(prefix="shizuka.server.") server_name, server_uri = server_dict.popitem() if server_uri: logger.info("Found Server named: {} . Joining...".format(server_name)) reporting_server = Pyro4.Proxy(server_uri) self.set_server(reporting_server, server_name) try: self._reporting_server.ping() logger.info("Ping succeeded on server. Returning control to polling thread.") disconnected = False except AttributeError as e: logger.error("Unable to ping server: Error message: {}".format(str(e))) except KeyError as e: logger.error("Found Nameserver, but couldn't find Server Object. Error Message: {}".format(str(e))) except Pyro4.errors.NamingError as e: logger.error("Unable to find NameServer for Pyro4. Is it running? Error message: {}".format(str(e))) except Exception as e: logger.error("Unknown error occurred attempting to reconnect to server. Error Message : {}".format(e)) time.sleep(5)
def publishNet(self, host, pno): self.name = "net-%d" % pno print "** Waiting for the manager" waitForOnenetManager() daemon = Pyro4.Daemon(host=host) ns = Pyro4.locateNS() for node in (self.hosts + self.switches): uri = daemon.register(node) ns.register(node.name, uri) for intf in node.intfList(): uri = daemon.register(intf) ns.register("%s-intf-%s" % (node.name, intf.name), uri) print "** %s published at %s" % (node.name, uri) uri = daemon.register(self) ns.register(self.name, uri) print "** net-%d published at %s" % (pno, uri) manager = Pyro4.Proxy("PYRONAME:onenet-manager") manager.notifyNetUp(pno, "net-%d" % pno) print "** Entering Pyro loop" daemon.requestLoop()
def main(): global server1 global server2 global client global clientid client = Client() status, output=commands.getstatusoutput("hostname") Pyro4.config.HOST=output pyrodaemon = Pyro4.Daemon(host=output) uri = pyrodaemon.register(client) ns=Pyro4.locateNS() ns.register("client", uri) #get server object for pulling updates server1 = Pyro4.core.Proxy("PYRONAME:example2.server1") server2 = Pyro4.core.Proxy("PYRONAME:example2.server2") serverId = random.randint(1, 2) #give server id to which score is to be requested clientid = sys.argv[1] #assign an id to client from 3-10 threading.Timer(0.25, client.pullRequest, args=(str(serverId))).start() #threading.Timer(0.25, client.sendRequest, args=(client, serverId, 'event:curling')).start() #threading.Timer(0.25, client.sendRequest, args=(client, serverId, 'event:snowboard')).start() #threading.Timer(0.25, client.sendRequest, args=(client, serverId, 'medal:Gauls')).start() #threading.Timer(0.25, client.sendRequest, args=(client, serverId, 'medal:Romans')).start() pyrodaemon.requestLoop()
def _locate_neighbour(self, address): try: ns = Pyro4.locateNS(self.ns_hostname) agents = ns.list(AGENT + "." + address) return Pyro4.Proxy(agents.values().pop()) except: logging.warning("could not locate %s" % address)
def _launch_daemon(q): daemon = Pyro4.Daemon() graph_endpoint = GraphPlotEndpoint(q) graph_plot_uri = daemon.register(graph_endpoint) ns = Pyro4.locateNS() ns.register("info-overflow.graph_plot", graph_plot_uri) daemon.requestLoop()
def run(self): # Use QuiltConfig to read in configuration cfg = quilt_core.QuiltConfig() # access the registrar's host and port number from config registrarHost = cfg.GetValue('registrar', 'host', None) registrarPort = cfg.GetValue('registrar', 'port', None, int) # access the query master's name from the config file qmname = cfg.GetValue( 'query_master', 'name', 'QueryMaster') logging.debug("Creating query master") qm = query_master.QueryMaster(self.args) #TODO This is a hack, it will be fixed soon try: daemon = Pyro4.Daemon(Pyro4.socketutil.getIpAddress()) except: daemon = Pyro4.Daemon() with daemon: # register the query master with the local PyRo Daemon with uri = daemon.register(qm) logging.debug("Registering: " + qmname + ", at: " + str(uri)) with Pyro4.locateNS(registrarHost, registrarPort) as ns: # use the key name as the object name ns.register(qmname, uri) # start the Daemon's event loop daemon.requestLoop()
def start_server(name=None, pipe=None): """ starts a new Pyro server. If name is not None it will attempt to locate the Pyro nameserver and register this server with that name. If pipe is not None it should be a multiprocessing PipeConnection object and the URI of the remote API will be sent to it. """ daemon = get_daemon() api = MDFRemoteAPI(daemon) uri = daemon.register(api) if name: ns = Pyro4.locateNS() ns.register(name, uri) print "mdf.remote server started" print "URI=%s" % uri if name: print "Name=%s" % name sys.stdout.flush() if pipe: pipe.send(uri) pipe.close() daemon.requestLoop()
def main(): daemon = Pyro4.Daemon() try: ns = Pyro4.locateNS() except Exception, e: sys.exit('Nameserver is not found. Please ensure that it is running and accessible.')
def setup_pyro(self): """Sets up Pyro, sharing DeviceEnrollHandler""" handler = deviceenroll.DeviceEnrollHandler(self.config) ns = Pyro4.locateNS() uri = self.pyro_daemon.register(handler) #TODO: Handle NS not found error ns.register("pisync.device_enroll", uri)
def _servePyroRequests(self): """When called, start serving Pyro requests. """ while True: logger.info("Starting AndorCamera Pyro4 server") try: ns = Pyro4.locateNS() except: logger.error("Can't locate Pyro nameserver - waiting 10 sec to retry") time.sleep(10) break try: existing = ns.lookup("AndorCamera") logger.info("AndorCamera still exists in Pyro nameserver with id: %s" % existing.object) logger.info("Previous Pyro daemon socket port: %d" % existing.port) # start the daemon on the previous port pyro_daemon = Pyro4.Daemon(host='animal', port=existing.port) # register the object in the daemon with the old objectId pyro_daemon.register(self, objectId=existing.object) except Pyro4.errors.NamingError: # just start a new daemon on a random port pyro_daemon = Pyro4.Daemon(host='animal') # register the object in the daemon and let it get a new objectId # also need to register in name server because it's not there yet. uri = pyro_daemon.register(self) ns.register("AndorCamera", uri) try: pyro_daemon.requestLoop() except: logger.error("Exception in AndorCamera Pyro4 server. Restarting in 10 sec: %s" % (traceback.format_exc(),)) time.sleep(10)
def broadcast_customers(): global my_uri global order_json ns=Pyro4.locateNS() customer_list = ns.list("lavic.customer.") shout_limit = 3 count = 0 for count in range(0, shout_limit): if not order_json is None: token_number = str(order_json['order']['tokenNumber']) print_info("Token number " + token_number + " Please take your order - Announcement: " + str(count + 1)) for customer in customer_list: pyro_address = customer_list[customer] print_network("Announcing tokens to " + str(customer) + " : " + pyro_address) try: global my_uri customer_obj = Pyro4.Proxy(pyro_address) order_json['message'] = "Announcing token " + str(token_number) customer_obj.listen("server", my_uri, order_json ) print_success("Sent") except: print_error("Some problem connecting to customers :" + str(customer)) else: order_json = None return time.sleep(1) print_info("No takers. Sorry, disposing order.")
def __init__(self, task, jobrunner, callback): self.task = task ns = Pyro4.locateNS() self.jobrunner = retrieve_object(ns, jobrunner) self.callback = callback self.message = Queue() self.runner = Process(target=self.run_task)
def __init__(self, nameserver=None, filename=None): gui.SlabWindow.__init__(self) self.setupSlabWindow(autoparam=True) self.auto_register_gui() try: self.set_param("nameserver", str(Pyro4.locateNS()).split('@')[1].split(':')[0]) self.msg('Found nameserver at: ' + self.params['nameserver']) except: self.msg("No name server found.") self.set_param("nameserver", '') self.read_param_widgets() if nameserver is not None: self.set_param('nameserver', nameserver) if filename is not None: self.set_param('filename', filename) self.servershell = gui.IPythonWidget() self.servershell_dockWidget.setWidget(self.servershell) self.clientshell = gui.IPythonWidget() self.clientshell_dockWidget.setWidget(self.clientshell) self.im_process = None self.start_pushButton.clicked.connect(self.startInstrumentManagerServer) self.start_clientButton.clicked.connect(self.startInstrumentManagerClient) self.filename_pushButton.clicked.connect(self.selectFile) self.editInstrumentConfig_pushButton.clicked.connect(self.editInstrumentConfig)
def test_index(self): # a stupid first training set texts = ["Human machine interface for lab abc computer applications", "A survey of user opinion of computer system response time", "The EPS user interface management system", "System and human system engineering testing of EPS", "Relation of user perceived response time to error measurement", "The generation of random binary unordered trees", "The intersection graph of paths in trees", "Graph minors IV Widths of trees and well quasi ordering", "Graph minors A survey"] corpus = [{'id': 'doc_%i' % num, 'tokens': utils.simple_preprocess(text)} for num, text in enumerate(texts)] service_id = '1234' #from gensim.similarities.simserver import SessionServer # service = similarities.SessionServer('bla') # create a local server # service = SessionServer(self.rootlocation, autosession=True) import Pyro4 service = Pyro4.Proxy(Pyro4.locateNS().lookup('gensim.testserver')) service.train(corpus, method='lsi') ## TODO we don't have a corpus yet, but we definatly need one big ''' texts = ["Human machine interface for lab abc computer applications",
def main(): request_acceptor = RequestAcceptor() daemon = Pyro4.Daemon() acceptor_uri = daemon.register(request_acceptor) ns = Pyro4.locateNS() ns.register("example.request_acceptor", acceptor_uri) daemon.requestLoop()
def commit_indexing_set(self): ''' after filling an indexing set the actual indexing needs to be done ''' #indexing_data = c.fetchmany(500); #service = similarities.SessionServer(self.rootlocation, autosession=True) #service = SessionServer(self.rootlocation + 'gensimTraining'+str(self.training_id), autosession=True) # create a local server service = Pyro4.Proxy(Pyro4.locateNS().lookup('gensim.testserver')) indexing_data = self.get_indexing_set() keys = self.redis_con.smembers(self.s_redis_new_item_list) self.redis_con.srem(self.s_redis_new_item_list, keys) indexing_data = self.redis_con.hmget(self.h_redis_itemid_document_text, keys) corpus = [] #for (id, text) in indexing_data.iteritems(): # corpus.append({ 'id' : str(id), "tokens" : utils.simple_preprocess(text) }) for id in keys: corpus.append({ "id" : id, "tokens" : utils.simple_preprocess( self.redis_con.hget(self.h_redis_itemid_document_text, id) ) } ) # print corpus service.index(corpus) ## TODO we don't have a corpus yet, but we definatly need one big return 'indexing done'
return dict(x=self.get_x(), y=self.get_y(), radius=self.get_radius()) class BallBuilder(object): @staticmethod def test(*args): s = 'called test({})'.format(', '.join(map(str, args))) print(s) return s def create_ball(self, playfield): return Ball(playfield).as_proxy ball_builder = BallBuilder() daemon = Pyro4.Daemon(socket.gethostbyname( socket.gethostname())) # make a Pyro daemon ns = Pyro4.locateNS() # find the name server playfield = Pyro4.Proxy(ns.lookup('ping.playfield')) daemon_proxy = Pyro4.Proxy(daemon.register(daemon)) playfield.add_daemon(daemon_proxy) uri = daemon.register( ball_builder) # register the greeting object as a Pyro object ns.register("ping.balls", uri) # register the object with a name in the name server print("Ready. ball_builder uri = {}".format( uri)) # print the uri so we can use it in the client later daemon.requestLoop() # start the event loop of the server to wait for calls ns.remove("ping.balls")
def 專門服務(self, 服務名): pyro4主機 = getattr(settings, "PYRO4_TSU2_KI1", None) pyro4_naming主機 = Pyro4.locateNS(pyro4主機) pyro4的uri = pyro4_naming主機.lookup(服務名) return Pyro4.Proxy(pyro4的uri)
@Pyro4.expose def add_rating(self, user_id, movie_id, value): self.send_update(Update(user_id, movie_id, value)) @Pyro4.expose def delete_rating(self, user_id, movie_id): self.send_update(Delete(user_id, movie_id)) @Pyro4.expose def add_tag(self, user_id, movie_id, tag): self.send_update(AddTag(user_id, movie_id, tag)) @Pyro4.expose def remove_tag(self, user_id, movie_id, tag): self.send_update(RemoveTag(user_id, movie_id, tag)) @Pyro4.expose def add_movie(self, name, genres): id = generate_id(5) self.send_update(UpdateMovie(id, {"name": name, "genres": genres}), max=True) return id if __name__ == '__main__': with Pyro4.Daemon() as daemon: uri = daemon.register(Frontend, "frontend") with Pyro4.locateNS() as ns: ns.register("frontend", uri) unregister_at_exit("frontend") daemon.requestLoop()
def launchExecutor(executor): # Start executor that will run pipeline stages # getIpAddress is similar to socket.gethostbyname(...) # but uses a hack to attempt to avoid returning localhost (127....) network_address = Pyro4.socketutil.getIpAddress(socket.gethostname(), workaround127=True, ipVersion=4) daemon = Pyro4.core.Daemon(host=network_address) clientURI = daemon.register(executor) # find the URI of the server: if executor.ns: ns = Pyro4.locateNS() #ns.register("executor", executor, safe=True) serverURI = ns.lookup("pipeline") else: try: uf = open(executor.uri_file) serverURI = Pyro4.URI(uf.readline()) uf.close() except: logger.exception("Problem opening the specified uri file:") raise p = Pyro4.Proxy(serverURI) # Register the executor with the pipeline # the following command only works if the server is alive. Currently if that's # not the case, the executor will die which is okay, but this should be # more properly handled: a more elegant check to verify the server is running p.registerClient(clientURI.asString(), executor.mem) executor.registeredWithServer() executor.setClientURI(clientURI.asString()) executor.setServerURI(serverURI.asString()) executor.setProxyForServer(p) logger.info("Connected to %s", serverURI) logger.info("Client URI is %s", clientURI) executor.connection_time_with_server = time.time() logger.info("Connected to the server at: %s", datetime.isoformat(datetime.now(), " ")) # you'd think this could be done in __init__, but sometimes that's in the wrong process, # which causes an error when calling `join` ... executor.initializePool() logger.debug("Executor daemon running at: %s", daemon.locationStr) try: # run the daemon, not the executor mainLoop, in a new thread # so that mainLoop exceptions (e.g., if we lose contact with the server) # cause us to shutdown (as Python makes it tedious to re-throw to calling thread) def with_exception_logging(f, thread_description, crash_hook=None): def _f(*args, **kwargs): try: return f(*args, **kwargs) except Exception: logger.exception("Crash in '%s' thread! Details: " % thread_description) crash_hook() if crash_hook else () raise return _f t = threading.Thread( target=with_exception_logging(daemon.requestLoop, "Pyro daemon")) t.daemon = True t.start() executor.mainLoop() except KeyboardInterrupt: logger.exception( "Caught keyboard interrupt. Shutting down executor...") executor.generalShutdownCall() #daemon.shutdown() sys.exit(1) except Exception: logger.exception( "Error during executor loop. Shutting down executor...") executor.generalShutdownCall() #daemon.shutdown() sys.exit(1) else: executor.completeAndExitChildren() logger.info("Executor shutting down.") daemon.shutdown() t.join()
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) logging.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() logging.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) logging.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) logging.debug("Pyro4 name server started successfully with URI %s", ns_uri) nsd_running = False # main retrieval of the local object import importlib import inspect module = importlib.import_module(object_name) # decorator to autoproxy all callables def proxymethod(fn): def wrapper(*args, **kwargs): r = fn(*args, **kwargs) def proxify_type(r): if r is None or type(r) in (bool, int, float, str): return r if isinstance(r, tuple): return tuple(proxify_type(e) for e in r) if isinstance(r, list): return [proxify_type(e) for e in r] if isinstance(r, dict): return {proxify_type(k): proxify_type(v) for (k, v) in r.items()} pyro_daemon.register(r) return r import types if isinstance(r, types.GeneratorType): def generator_wrapper(): for n in r: yield proxify_type(n) return generator_wrapper() else: return proxify_type(r) return wrapper # module wrapped for transferability class ModuleObject: pass for fname, f in inspect.getmembers(module, inspect.isfunction): if not whitelist or (object_name, fname) in whitelist: setattr(ModuleObject, fname, staticmethod(proxymethod(f))) for cname, c in inspect.getmembers(module, inspect.isclass): if not whitelist or (object_name, cname) in whitelist: setattr(ModuleObject, cname, staticmethod(proxymethod(c))) 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) logging.info("Local object '%s' sharing - ready", object_name) loop.join()
# alguns algoritmos de consendo (probabilístico), como por exemplo o Proof of Work (PoW), o PoW torna a adição de um block # na chain uma tarefa difícil, por exemplo no Bitcoin que é apenas aceitos os hashes que começam com um específico # número de zeros, além do mesmo ter de ser realizado dentro de um tempo limite (encontrar um nonce adequado para ganhar o desafio) # então um block será adicionado a cada 10 minutos # a quantidade de números zeros no início dos hashes é chamada de dificuldade, então se tiver apenas 1 zero a dificuldade # será 1, se tiver dois zeros, a dificuldade será 2, etc. # Como a técnologia de processamento está sempre evoluindo o bitcoin, tem sua dificuldade aumentada a cada 2 ou 3 anodes. # o processo de encontrar um certo número de zeros no início do hash do block, é chamado de minerar. #daemon = Pyro4.Daemon("192.168.56.1") daemon = Pyro4.Daemon() blockchain = Blockchain( ) # passando o objeto já isntânciado para manter os data salvos de um acesso a outro do objeto remoto uri = daemon.register( blockchain ) #instanciando um objeto remoto, realizando o registrando dele. Vai ser retornando# #print(dir(daemon)) # uma URI do objeto para ele poder ser acessado, o método também vai checar se já não há um objeto registrado # para poder utilizar deve estar sendo executado o pyro-ns em um terminal ns = Pyro4.locateNS( ) # Get a proxy for a name server somewhere in the network. ns.register('b1', uri) # simplificando o nome do objeto print(uri) daemon.requestLoop()
def main(): try: print( ''' _____ _____ ______ ___ ___ / ____| __ \|____ / _ \ / _ \\ | (___ | |__) | / / | | | | | | \___ \| _ / / /| | | | | | | ____) | | \ \ / / | |_| | |_| | |_____/|_| \_\/_/ \___/ \___/ /\ | | (_) / \ _ __| |_ _ ___ __ _ _ __ / /\ \ | '__| __| / __|/ _` | '_ \\ / ____ \| | | |_| \__ \ (_| | | | | /_/ ___\_\_| \__|_|___/\__,_|_| |_| / ____| | (___ ___ _ ____ _____ _ __ \___ \ / _ \ '__\ \ / / _ \ '__| ____) | __/ | \ V / __/ | |_____/ \___|_| \_/ \___|_| ''') print('SR700 Artisan Server - Luca Pinello 2019 (@lucapinello)\n\n') print('Send bugs, suggestions or *green coffee* to lucapinello AT gmail DOT com\n') signal.signal(signal.SIGINT, signal_handler) parser = argparse.ArgumentParser(description='Parameters',formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--enable_extension', type=str, help='Running mode: phidget_simple,\ phidget_hub,max31865 if not specified no external sensor will be used,', default='simple',choices=['phidget_simple','phidget_hub', 'max31865'] ) parser.add_argument('--phidget_hub_port', type=int, default=0) parser.add_argument('--phidget_hub_channel', type=int, default=0) parser.add_argument('--kp', type=float, default=None) parser.add_argument('--ki', type=float, default=None) parser.add_argument('--kd', type=float, default=None) parser.add_argument('--max_31865_gpio_cs', type=int, default=8) parser.add_argument('--max_31865_gpio_miso', type=int, default=9) parser.add_argument('--max_31865_gpio_mosi', type=int, default=10) parser.add_argument('--max_31865_gpio_clk', type=int, default=11) args = parser.parse_args() assign_pid_param=lambda v_args,v_default: v_args if v_args else v_default use_max31865=False use_phidget_temp=False if args.enable_extension=='phidget_simple' or args.enable_extension=='phidget_hub': use_phidget_temp=True kp=assign_pid_param(args.kp,0.4) ki=assign_pid_param(args.ki,0.0075) kd=assign_pid_param(args.kd,0.9) elif args.enable_extension=='max31865': use_max31865=True kp=assign_pid_param(args.kp,0.4) ki=assign_pid_param(args.ki,0.0075) kd=assign_pid_param(args.kd,0.9) else: use_phidget_temp=False kp=assign_pid_param(args.kp,0.06) ki=assign_pid_param(args.ki,0.0075) kd=assign_pid_param(args.kd,0.01) if args.enable_extension=='phidget_hub': phidget_use_hub=True else: phidget_use_hub=False nameserver_process=None r=None # Set logging logging.getLogger("Pyro4.core").setLevel(logging.CRITICAL) logging.getLogger("Pyro4.name").setLevel(logging.ERROR) logging.basicConfig(level=logging.INFO, #format='%(levelname)-5s @ %(asctime)s:-[[\t%(message)s]]-', format='-[ %(message)s ]-', datefmt='%a, %d %b %Y %H:%M:%S', stream=sys.stderr, filemode="w" ) #logging.basicConfig(filename="RoastControl_debug_log.log",level=logging.DEBUG) logging.info('Starting Nameserver...') with open(os.devnull, 'w') as fp: nameserver_process=sb.Popen(['python', '-m','Pyro4.naming'],stdout=fp) ##Pyro4.naming.startNS() time.sleep(1) logging.info('Starting Server...') daemon = Pyro4.Daemon() # make a Pyro daemon ns = Pyro4.locateNS() logging.info("Initializing connection with the SR700...") # Create a roaster object. r = Roaster(use_phidget_temp=use_phidget_temp, phidget_use_hub=phidget_use_hub, phidget_hub_port=args.phidget_hub_port, phidget_hub_channel=args.phidget_hub_channel, use_max31865=use_max31865, max_31865_gpio_cs=args.max_31865_gpio_cs, max_31865_gpio_miso=args.max_31865_gpio_miso, max_31865_gpio_mosi=args.max_31865_gpio_mosi, max_31865_gpio_clk=args.max_31865_gpio_clk, kp=kp,ki=ki,kd=kd) r.roaster.log_info=False # Conenct to the roaster. r.roaster.auto_connect() # Wait for the roaster to be connected. while(not(r.roaster.connected)): if r.roaster.phidget_error: raise Exception('Phidget Error!') time.sleep(2) if not(r.roaster.connected): logging.info("Still waiting for connection...") time.sleep(2) if not(r.roaster.connected): logging.info('Please check if the roaster is connected.') if r.roaster.phidget_error: raise Exception('Phidget Error!') uri = daemon.register(r) ns.register("roaster.sr700", uri) logging.info('Server Ready!') r.roaster.log_info=True daemon.requestLoop() except Exception as e: logging.error(e) if nameserver_process: nameserver_process.kill() if r: r.roaster.terminate() print('\nSend bugs, suggestions or *green coffee* to lucapinello AT gmail DOT com\n') print('Bye!\n') sys.exit(0)
def __init__(self, remote_server_name='localhost', remote_port=None, remote_ns_port=50000, remote_ns_host='localhost', local_forwarding_port=None, tunnel_username=None, remote_username=None, loglevel=logging.INFO, **kwargs): """ Create a Pyro4ObjectDiscoverer object. Args: remote_server_name (str): Name or ip of remote server. Keyword Args: remote_port (int): The remote listening port. remote_ns_port (int): The remote nameserver port remote_ns_host (str): The remote nameserver host name local_forwarding_port (int): The local port on which to listen; the local port we used for port forwarding tunnel_username (str): The username for the creation of a support.tunneling.Tunnel. This could be, for example, a login to the JPL ops gateway. username (str): The username to use for port forwarding. On crux, this would be 'ops' **kwargs: For logging_util.logging_config """ self.remote_server_name = remote_server_name self.remote_ns_host = remote_ns_host self.remote_ns_port = remote_ns_port if not local_forwarding_port: local_forwarding_port = remote_ns_port self.local_forwarding_port = local_forwarding_port self.tunnel_username = tunnel_username self.remote_username = remote_username logger = logging.getLogger(module_logger.name + ".Pyro4Tunnel") self.logger = logging_config(logger=logger, loglevel=loglevel, **kwargs) self.processes = [] if remote_server_name in full_name.keys(): self.local = False self.logger.debug("Checking for existing Tunnel.") self.tunnel = Tunnel(remote_server_name, username=tunnel_username) self.remote_port = self.tunnel.port self.remote_server_ip = 'localhost' elif remote_server_name == 'localhost': self.remote_server_ip = 'localhost' if remote_port: self.local = False self.remote_port = remote_port else: self.local = True else: self.local = False self.logger.debug("Provided server name not on JPL network.") self.tunnel = None self.remote_server_ip = remote_server_name self.remote_port = remote_port if self.local: self.logger.debug("Local nameserver host:port: {}:{}".format( self.remote_ns_host, self.remote_ns_port)) self.ns = Pyro4.locateNS(host=self.remote_ns_host, port=self.remote_ns_port) else: self.ns = self.find_nameserver(self.remote_server_ip, self.remote_ns_host, self.remote_ns_port, self.local_forwarding_port, self.remote_port, self.remote_username) self.uris = {} self.requested_objects = []
def start(self, ip, port, password, retry=float("inf")): """Start WorkerServer and ssh daemon and connect to nameserver.""" self.logger.info("starting up and connecting to %s:%d" % (ip, port)) #store for reconnection attempts self._ip = ip self._port = port self._password = password #Pyro4.config.HMAC_KEY = password tries = 1 self._ns = None while not self._ns: try: self._ns = Pyro4.locateNS(ip, port, hmac_key=password) except Pyro4.errors.NamingError: if tries < retry: self.logger.warn( "Unable to locate Nameserver. Trying again in 5 seconds..." ) time.sleep(5) tries += 1 else: self.logger.error("Unable to locate Nameserver.") sys.exit() self.config = Pyro4.Proxy(self._ns.lookup("config")) self.config._pyroHmacKey = password self.ip = self.config.get_worker_ip(self.get_hostname()) if (not self.ip): self.ip = Tools.guess_ip() if not self.config.has_section(self.get_hostname()): self.config.add_section(self.get_hostname()) self.config.set(self.get_hostname(), "ip", self.ip) self.logger.warn( """FrontendServer did not know IP of this host (check configuration for hostname). Guessed: %s""" % self.ip) self.logger.info("configuring and starting ssh daemon...") self.sshManager = SSH_Manager(folder=self.ssh_folder, ip=self.ip, port=self.config.get_sshd_port(), user=self.config.get("all", "sshuser")) self.sshManager.start_sshd() self._pyrodaemon = Pyro4.Daemon(host=self.ip) self._pyrodaemon._pyroHmacKey = password uri = self._pyrodaemon.register(self) self._ns.register(self._get_pyroname(), uri) uri = self._pyrodaemon.register(self.mnManager) self._ns.register(self._get_pyroname() + ".mnManager", uri) uri = self._pyrodaemon.register(self.sshManager) self._ns.register(self._get_pyroname() + ".sshManager", uri) atexit.register(self._stop) self.logger.info("looking for manager application...") manager_uri = self._ns.lookup("MaxiNetManager") if (manager_uri): self._manager = Pyro4.Proxy(manager_uri) self._manager._pyroHmacKey = self._password self.logger.info("signing in...") if (self._manager.worker_signin(self._get_pyroname(), self.get_hostname())): self.logger.info("done. Entering requestloop.") self._started = True self._looping_thread = threading.Thread( target=self._pyrodaemon.requestLoop) self._looping_thread.daemon = True self._looping_thread.start() else: self.logger.error("signin failed.") else: self.logger.error("no manager found.")
def run(self): daemon = Pyro4.Daemon() ns = Pyro4.locateNS() uri = daemon.register(self) ns.register('scone', uri) daemon.requestLoop()
# -*- coding: utf-8 -*- """ Created on Thu Sep 13 11:25:42 2018 @author: afcarl """ import Pyro4 service = Pyro4.Proxy(Pyro4.locateNS().lookup('gensim.testserver')) print(service.status()) print(service.find_similar('doc_0')) #[('doc_0', 1.0000001192092896, None), ('doc_2', 0.11294261366128922, None), ('doc_1', 0.09881372004747391, None), ('doc_3', 0.08786644041538239, None)]
def _get_random_aggregate(self, agent): ns = Pyro4.locateNS(self.ns_hostname) agents = ns.list(AGENT) logger.debug(agents) del agents[AGENT + "." + agent.parent.address] return Pyro4.Proxy(random.choice(agents.values()))
return replica overloaded = None registered_replicas = len(self.replicas) for new_replica_pos in range( self.default_replica + 1, self.default_replica + registered_replicas): new_replica = self.replicas[new_replica_pos % registered_replicas] new_status = replica.get_status() if new_status == 'active': if status == 'offline': self.default_replica = new_replica_pos return new_replica if new_status == 'overloaded': overloaded = new_replica if status == 'overloaded': return replica if overloaded: return overloaded raise ConnectionRefusedError('ERROR: All replicas offline') if __name__ == '__main__': print('Starting front-end server...') FRONT_END_SERVER = FrontEndServer() NS = Pyro4.locateNS() DAEMON = Pyro4.Daemon() URI = DAEMON.register(FRONT_END_SERVER) NS.register("front_end_server", URI, safe=True) print('Ready to receive requests\n') DAEMON.requestLoop()
def count(self, lines): # use the name server's prefix lookup to get all registered wordcounters all_counters = Pyro4.locateNS().list(prefix="example.dc.wordcount.") counters = [ Pyro4. async (Pyro4.Proxy(uri)) for uri in all_counters.values() ]
items = self.server.forward_request("show_items") NB_COLS = 5 print("Available Items:") for i, item in enumerate(items): print(item + '\n' if not i % NB_COLS and not i == 0 or i == len(items) - 1 else item + ', ', end='') print() return True # Set the remote exception hook sys.excepthook = Pyro4.util.excepthook if __name__ == "__main__": ns = Pyro4.locateNS() # Locate the name server if not ns: print("ERROR: Cannot find Name Server!") exit() servers = [ (name, uri) for name, uri in ns.list(prefix="just_hungry.front_end").items() ] if not len(servers): print("ERROR: Cannot find frontend server!") exit() front_server = Pyro4.Proxy(servers[0][1]) try: front_server._pyroBind()
args = [ "localhost", str(first_redis_port + i), "localhost", "2232", node_name ] cmd = ["python3", node_py] cmd.extend(args) n = subprocess.Popen(cmd) pid.append(n.pid) time.sleep(1) ##################################################### # Example client activity # Single client hitting multiple nodes ##################################################### # Locate the nodes. ns = Pyro4.locateNS("localhost", 2232) ns_list = ns.list() uri_str = ns_list['node0'] node0 = Pyro4.Proxy(uri_str) uri_str = ns_list['node1'] node1 = Pyro4.Proxy(uri_str) uri_str = ns_list['node2'] node2 = Pyro4.Proxy(uri_str) # Helps show the propagation (includes the artificial delay # in NodeEventual that is used to show propagation) time.sleep(1) print(node0.set("test", "hello hello--")) print(node0.get("test")) print(node1.get("test")) print(node2.get("test"))
def compare_chains(self): try: ns = Pyro4.locateNS() # localizando o servidor de nomes except Pyro4.errors.NamingError: # caso o servidor de nomes não esteja sendo executado print( "Falha para localizar o servidor de nomes! - Execute o servidor de nomes (pyro4-ns)" ) exit() total = 1 # para contar com o próprio processo na porcentagem total n_elementos = 1 # para contar com o próprio processo na porcentagem total for no in nodes: #percorrendo a lista de processos if not no == current: try: uri = ns.lookup(no) # obtendo a uri do objeto remoto o = Pyro4.Proxy(uri) #pegando o objeto remoto if o.get_chain_size() == self.get_chain_size(): if o.get_chain() == self.get_chain( ): # se as cadeias forem iguai total += 1 # soma 1 no somatótio total n_elementos += 1 # incremaneta o número de elementos somados else: total += 0 # soma zero no somatório total n_elementos += 1 # Os dois próximos elifs são para dar uma tolerância de atraso de um block nas chain, ele vai verificar a diferença entre os tamanhos da chains elif ( o.get_chain_size() - self.get_chain_size() ) == 1: # se a chain REMOTA for um block maior do que a chain LOCAL, tendo 1 como tolerância de atraso na rede r = o.get_chain_json() objR = json.loads(r) del objR[ -1] # removendo o block que está sobrando na comparação teste = True for x in len(self.get_chain_size): if not self.chain[x].hash == objR[ x].hash: # caso em alguma posição da chain, as duas chain não estejam iguais total += 0 # soma zero no somatório total n_elementos += 1 else: total += 1 # soma 1 no somatótio total n_elementos += 1 elif ( self.get_chain_size() - o.get_chain_size() ) == 1: # se a chain LOCAL for um block maior do que a chain REMOTA, tendo 1 como tolerância de atraso na rede objL = self.chain del objL[ -1] # removendo o block que está sobrando na comparação teste = True for x in len(self.get_chain_size): if not objL.chain[x].hash == objR[ x].hash: # caso em alguma posição da chain, as duas chain não estejam iguais total += 0 # soma zero no somatório total n_elementos += 1 else: total += 1 # soma 1 no somatótio total n_elementos += 1 else: # caso a diferença for maior que 1 total += 0 # soma zero no somatório total n_elementos += 1 except: # caso não consiga se comunicar com o processo da rede, subtrai um do número total de nós, assim evitando que a quantidade total não seja dividida pela quantidade errada de elementos, ocasionando em uma porcentagem errada print("Não foi possível acessar o nó", no) porcentagem = (total * 100) / n_elementos print("Pocentagem de nós com a mesma chain: ", porcentagem) return porcentagem # retorna a porcentagem de processos que tem a chain igual a do processo current
def test_set(key, value, node): ns = Pyro4.locateNS("localhost", 2232) ns_list = ns.list() uri_str = ns_list[node] n = Pyro4.Proxy(uri_str) return n.set(key, value)
def look_for_server(): ns = Pyro4.locateNS() uri = ns.lookup('servidor') server = Pyro4.Proxy(uri) return server
def __init__(self): ns = Pyro4.locateNS() uri = ns.lookup('obj') self.__server_interface = Pyro4.Proxy(uri)
def _run_on_vm(self, vm_name, func, args): nameserver = Pyro4.locateNS(host=args['name_server']) uri = nameserver.lookup('runner.%s.%s' % (vm_name, self.__class__.__name__)) tc = Pyro4.Proxy(uri) return getattr(tc, func)(args)
def discover_workers(self): self.discover_cond.acquire() sleep_interval = 1 while True: self.logger.debug('DISPATCHER: Starting worker discovery') update = False with Pyro4.locateNS(host=self.nameserver, port=self.nameserver_port) as ns: worker_names = ns.list(prefix="hpbandster.run_%s.worker."%self.run_id) self.logger.debug("DISPATCHER: Found %i potential workers, %i currently in the pool."%(len(worker_names), len(self.worker_pool))) for wn, uri in worker_names.items(): if not wn in self.worker_pool: w = Worker(wn, uri) if not w.is_alive(): self.logger.debug('DISPATCHER: skipping dead worker, %s'%wn) continue update = True self.logger.info('DISPATCHER: discovered new worker, %s'%wn) self.worker_pool[wn] = w # check the current list of workers crashed_jobs = set() all_workers = list(self.worker_pool.keys()) for wn in all_workers: # remove dead entries from the nameserver if not self.worker_pool[wn].is_alive(): self.logger.info('DISPATCHER: removing dead worker, %s'%wn) update = True # todo check if there were jobs running on that that need to be rescheduled current_job = self.worker_pool[wn].runs_job if not current_job is None: self.logger.info('Job %s was not completed'%str(current_job)) crashed_jobs.add(current_job) del self.worker_pool[wn] self.idle_workers.discard(wn) continue if not self.worker_pool[wn].is_busy(): self.idle_workers.add(wn) # try to submit more jobs if something changed if update: if not self.queue_callback is None: self.discover_cond.release() self.queue_callback(len(self.worker_pool)) self.discover_cond.acquire() self.runner_cond.notify() for crashed_job in crashed_jobs: self.discover_cond.release() self.register_result(crashed_job, {'result': None, 'exception': 'Worker died unexpectedly.'}) self.discover_cond.acquire() self.logger.debug('DISPATCHER: Finished worker discovery') #if (len(self.worker_pool) == 0 ): # ping for new workers if no workers are currently available # self.logger.debug('No workers available! Keep pinging') # self.discover_cond.wait(sleep_interval) # sleep_interval *= 2 #else: self.discover_cond.wait(self.ping_interval) if self.shutdown_all_threads: self.logger.debug('DISPATCHER: discover_workers shutting down') self.runner_cond.notify() self.discover_cond.release() return
def __init__(self): self.ns = Pyro4.locateNS() self.ts = {} self._replica = None
def connect_proxies(self): ns = Pyro4.locateNS(self.ns_address) for name, uri in list(ns.list().items()): self[name] = Pyro4.Proxy(uri)
else: print(server) options = {"get": get, "add": add, "update": update} return options[request](userId, movie, review, server) #functions to call server to execute request def add(userId, movie, review, server): Function = Pyro4.Proxy("PYRONAME:" + server) return Function.addReview(userId, movie, review, "1") def get(userId, movie, review, server): Function = Pyro4.Proxy("PYRONAME:" + server) return Function.getReview(movie) def update(userId, movie, review, server): Function = Pyro4.Proxy("PYRONAME:" + server) return Function.updateReview(userId, movie, review, "1") #register server object in RMI daemon = Pyro4.Daemon() ns = Pyro4.locateNS() uri = daemon.register(functions) ns.register("frontServer", uri) print("ready") daemon.requestLoop()
from dbUI import dbUI from bookDB import BookDB import Pyro4 BookDBremote = Pyro4.expose(BookDB) remoteStorage = BookDBremote() ns = Pyro4.locateNS("127.0.0.1") daemon = Pyro4.Daemon("127.0.0.1") uri = daemon.register(remoteStorage, "DBserver") ns.register("DBserver", uri) print(uri) daemon.requestLoop()
def _launch_daemon(daemon, q): graph_endpoint = GraphPlotEndpoint(q) graph_plot_uri = daemon.register(graph_endpoint) ns = Pyro4.locateNS() ns.register("info-overflow.graph_plot", graph_plot_uri) daemon.requestLoop()
import Pyro4 serverList = [] print("POPULATING SERVER LIST") with Pyro4.locateNS() as ns:#initialises list of servers using name server servers = ns.list(prefix = "SERVER") for server in servers.keys(): serverList.append(Pyro4.Proxy(servers.get(server))) print("SERVERS FOUND AND CONNECTED") @Pyro4.expose class FrontEnd: #initialising timestamp and update ID ts = [0,0,0] uID = 0 #this function takes a user query action and attempts to execute it on one of the servers def userQuery(self,action,movie,userID): for server in serverList:#attempts each server in the list to see if one is online if server.getStatus() == "online": return server.query(FrontEnd.ts,action,movie,userID) #if all servers are offline or overloaded it tells the client return "All servers are currently busy, please try again later" #this function takes a user update and attempts to send it to a server def userUpdate(self,action,movie,userID,rating): for server in serverList: if server.getStatus() == "online":
import Pyro4 as p4 import platform as plat # @ is a decorator, decorator @p4.expose class myServ(object): # self is the python equivalent of this. in java def sayHi(self): return "Hello There" # # ----------------------------------------------------- # daemon = p4.Daemon(host=plat.node()) # avoid hardcoded IP address ns = p4.locateNS() uri = daemon.register(myServ) # come up with an internal name ns.register("Server.server", uri) daemon.requestLoop()
def test_lookup(self): site = SiteRMI.SiteRMI(1) site.register() ns = Pyro4.locateNS() self.assertTrue(ns.lookup("site.1"))