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 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 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 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'
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 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 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 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 settings_server(): daemon = Pyro4.Daemon() ns = Pyro4.locateNS() settings = ss.settings.Settings() uri = daemon.register(settings) ns.register("sc.settings", uri) daemon.requestLoop()
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 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 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 print_name_server_object_list(): """ Use name_server function """ ns = Pyro4.locateNS(host='localhost') print(ns.lookup('maker')) print(ns.list())
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 _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 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 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 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 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 _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 __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 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 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 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 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 _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 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 export_data(self, path=None): logging.debug("Instantiating export_data()") if path == None or os.path.exists(path) == False: logging.warning("Valid path was not provided: " + str(path) + ". Writing to /tmp/") path = "/tmp/" logging.debug("Exporting data to: " + str(path)) self.engine.export(path) logging.debug("Completed export_data()") def remove_data(self): logging.debug("Instantiating remove_data()") self.engine.delete_all() logging.debug("Completed remove_data()") if __name__ == '__main__': logging.getLogger().setLevel(logging.DEBUG) daemon = Pyro4.Daemon() # make a Pyro daemon try: output = Popen("pyro4-ns") except: logging.error("Pyro name server already running or could not be started") exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback) ns = Pyro4.locateNS() # find the name server uri = daemon.register(ECELDaemon) # register the greeting maker as a Pyro object ns.register("ecel.service", uri) # register the object with a name in the name server logging.debug("ECELd Engine Started") daemon.requestLoop() # start the event loop of the server to wait for calls
def e_rm_target(self, graph_name, uid, type_name, vertex_uid, vertex_type): #remove target vertex from edge if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.e_rm_target(graph_name, uid, type_name, vertex_uid, vertex_type)
def say_hello(self): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.say_hello()
def get_vertex(self, graph_name, uid, vertex_type): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.get_vertex(graph_name, uid, vertex_type)
def insert_vertex(self, graph_name, vertex_type, attributes): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.insert_vertex(graph_name, vertex_type, attributes)
def create_edge_type(self, graph_name, type_name, edge_type_def): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.create_edge_type(graph_name, type_name, edge_type_def)
def get_edge_type(self, graph_name, edge_type): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.get_edge_type(graph_name, edge_type)
def shutdown(self, code): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.shutdown(code)
def get_read(filename): gserver = Pyro4.Proxy(uri) print(gserver.read_file(filename))
def remove(self, graph_name, uid, type_name): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.remove(graph_name, uid, type_name)
def get_create(filename): gserver = Pyro4.Proxy(uri) print(gserver.create_file(filename))
def e_get_target(self, graph_name, uid, type_name): #return the edge object's target vertices if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.e_get_target(graph_name, uid, type_name)
def v_rm_edge(self, graph_name, uid, type_name, edge_uid, edge_type): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.v_rm_edge(graph_name, uid, type_name, edge_uid, edge_type)
def e_get_source(self, graph_name, uid, type_name): #return the edge object's source vertex if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.e_get_source(graph_name, uid, type_name)
Util.changeRootLogger('thermal.log') import Pyro4 import argparse #Read int for mode as number behind '-m' argument: 0-local (default), 1-ssh, 2-VPN mode = argparse.ArgumentParser( parents=[Util.getParentParser()]).parse_args().mode from Config import config cfg = config(mode) #locate nameserver ns = PyroUtil.connectNameServer(nshost=cfg.nshost, nsport=cfg.nsport, hkey=cfg.hkey) #Run a daemon for jobManager on this machine daemon = Pyro4.Daemon(host=cfg.server, port=cfg.serverPort, nathost=cfg.serverNathost, natport=cfg.serverNatport) #Run job manager on a server jobMan = SimpleJobManager.SimpleJobManager2( daemon, ns, None, cfg.jobManName, cfg.portsForJobs, cfg.jobManWorkDir, os.getcwd(), 'thermalServerConfig', mode, cfg.jobMan2CmdPath, cfg.maxJobs, cfg.socketApps) PyroUtil.runJobManagerServer(server=cfg.server, port=cfg.serverPort, nathost=cfg.serverNathost, natport=cfg.serverNatport, nshost=cfg.nshost, nsport=cfg.nsport, appName=cfg.jobManName,
def v_get_incoming_edges(self, graph_name, uid, type_name, edge_type): #return edges if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.v_get_incoming_edges(graph_name, uid, type_name, edge_type)
def get_list(): gserver = Pyro4.Proxy(uri) print(gserver.list_dir())
def copyFiles(src_dir, src_file_list, target_dir, prefix='', keep_old=False): """ Copy files in *src_file_list* from *src_dir* to *target_dir* with an optional prefix. If *keep_old* is ``True``, existing files in *target_dir* will not be overridden, otherwise files can be clobbered (default). Wild-cards in file name specification are allowed. """ global remote_copy_fun use_data_server = os.getenv('USE_DATA_SERVER', "DATA_SERVER_NOT_USED") if use_data_server != "DATA_SERVER_NOT_USED": if not remote_copy_fun: data_server = Pyro4.Proxy("PYRONAME:DataServer") return data_server.copyFiles(src_dir, src_file_list, target_dir, prefix, keep_old) try: file_list = src_file_list.split() except AttributeError: # srcFileList is not a string file_list = src_file_list globbed_file_list = [] for src_file in file_list: if not target_dir == src_dir: src_file_full = os.path.join(src_dir, src_file) if os.path.isfile(src_file_full): globbed_file_list += [src_file_full] else: globbed_files = glob.glob(src_file_full) if (len(globbed_files) > 0): globbed_file_list += globbed_files else: raise Exception('No such file : %s' % (src_file_full)) #------------------------------------------------------------------# # for each file in globbed_file_list, copy it from src_dir to target_dir # #------------------------------------------------------------------# for src_file in globbed_file_list: target = prefix + os.path.basename(src_file) target_file = os.path.join(target_dir, target) if (os.path.isfile(target_file) and os.path.samefile(src_file, target_file)): continue # Do not overwrite existing target files. if (keep_old and os.path.isfile(target_file)): for i in range(1000): new_name = target_file + '.' + str(i) if os.path.isfile(new_name): continue target_file = new_name break (head, tail) = os.path.split(os.path.abspath(target_file)) try: os.makedirs(head) except OSError, (errno, strerror): if (errno != 17): print 'Error creating directory %s : %s' % (head, strerror) raise try: #print 'trying to copy...' #print 'src_file =', src_file #print 'target_file =', target_file shutil.copy(src_file, target_file) except: raise
def get_update(filename, content): gserver = Pyro4.Proxy(uri) print(gserver.update_file(filename, content))
import Pyro4 from time import gmtime, strftime #strftime("%Y-%m-%d %H:%M:%S", gmtime()) fEnd = Pyro4.Proxy("PYRONAME:front_end") confirmation = input("Welcome to JustHungry, do you want to order? (y/n)") if confirmation=='y' or confirmation=='yes' or confirmation=='Y'or confirmation=='Yes': product = '' order = [[],0] name = input("What is your name?") print("Hello %s!"%name) while True: # Need retrieving throug RMI from Front-end now done localy categories = fEnd.getCategories() print("Choose a category number: (type \"quit\" to finish)") for i in range(len(categories)): print("%i. %s"%(i+1,categories[i])) catnum = input() if catnum.isdigit(): catnum = int(catnum) if catnum > 0 and catnum <= len(categories): selected_category = categories[catnum-1] print("You have chosen %s"% selected_category) category_products = fEnd.getProducts(selected_category) print("Choose a product number: (type \"quit\" to finish)") for i in range(len(category_products)): print("%i. %s (£%d)"%(i+1,category_products[i][0],category_products[i][2])) prodnum = input() if prodnum.isdigit():
import Pyro4 uri = input("What is the Pyro uri of the greeting object? ").strip() n = 8 greeting_maker = Pyro4.Proxy(uri) print(greeting_maker.Factor(n))
def __init__(self): self.ProxyEnv = Pyro4.Proxy("PYRONAME:GymEnvProxy.Env1") self.action_space = action_space self.observation_space = observation_space
import time import Pyro4 if sys.version_info < (3, 0): input = raw_input def asyncFunction(values): results = [value + 1 for value in values] print(">>> async batch function called, returning:", results) return results uri = input("enter async server object uri: ").strip() proxy = Pyro4.Proxy(uri) print("\n* batch async call:") batch = Pyro4.batch(proxy) batch.divide(100, 5) batch.divide(99, 9) batch.divide(555, 2) print("getting results...") asyncresults = batch(async=True) # returns immediately print("result value available?", asyncresults.ready) # prints False because the server is still 'busy' print("client can do other stuff here.") time.sleep(2) print("such as sleeping ;-)") time.sleep(2) print("sleeping some more, batch takes a while")
self.logger.info("Creating Message Bus, uri = {}".format(uri)) self.logger.info("Finding nameserver, at host {}, port {}".format(self.ns_host, self.ns_port)) ns = Pyro4.locateNS(host=self.ns_host,port=self.ns_port) ns.register(PYRO_MSGBUS_NAME, uri) self.logger.info("Message bus registered on nameserver.") daemon.requestLoop() if __name__ == '__main__': from support.arguments import simple_parse_args parsed = simple_parse_args("Start the messagebus server.") print("Starting the MessageBus server") make_messagebus.storagetype = 'memory' daemon = Pyro4.Daemon(host=parsed.ns_host, port=0, unixsocket=None) uri = daemon.register(MessageBus) print("MessageBus URI: {}".format(uri)) ns = Pyro4.locateNS(host=parsed.ns_host, port=parsed.ns_port) ns.register(PYRO_MSGBUS_NAME, uri) daemon.requestLoop()
def get_delete(filename): gserver = Pyro4.Proxy(uri) print(gserver.delete_file(filename))
def __init__(self, corpus=None, num_topics=200, id2word=None, chunksize=20000, decay=1.0, distributed=False, onepass=True, power_iters=P2_EXTRA_ITERS, extra_samples=P2_EXTRA_DIMS): """ `num_topics` is the number of requested factors (latent dimensions). After the model has been trained, you can estimate topics for an arbitrary, unseen document, using the ``topics = self[document]`` dictionary notation. You can also add new training documents, with ``self.add_documents``, so that training can be stopped and resumed at any time, and the LSI transformation is available at any point. If you specify a `corpus`, it will be used to train the model. See the method `add_documents` for a description of the `chunksize` and `decay` parameters. Turn `onepass` off to force a multi-pass stochastic algorithm. `power_iters` and `extra_samples` affect the accuracy of the stochastic multi-pass algorithm, which is used either internally (`onepass=True`) or as the front-end algorithm (`onepass=False`). Increasing the number of power iterations improves accuracy, but lowers performance. See [3]_ for some hard numbers. Turn on `distributed` to enable distributed computing. Example: >>> lsi = LsiModel(corpus, num_topics=10) >>> print(lsi[doc_tfidf]) # project some document into LSI space >>> lsi.add_documents(corpus2) # update LSI on additional documents >>> print(lsi[doc_tfidf]) .. [3] http://nlp.fi.muni.cz/~xrehurek/nips/rehurek_nips.pdf """ self.id2word = id2word self.num_topics = int(num_topics) self.chunksize = int(chunksize) self.decay = float(decay) if distributed: if not onepass: logger.warning("forcing the one-pass algorithm for distributed LSA") onepass = True self.onepass = onepass self.extra_samples, self.power_iters = extra_samples, power_iters if corpus is None and self.id2word is None: raise ValueError('at least one of corpus/id2word must be specified, to establish input space dimensionality') if self.id2word is None: logger.warning("no word id mapping provided; initializing from corpus, assuming identity") self.id2word = utils.dict_from_corpus(corpus) self.num_terms = len(self.id2word) else: self.num_terms = 1 + max([-1] + self.id2word.keys()) self.docs_processed = 0 self.projection = Projection(self.num_terms, self.num_topics, power_iters=self.power_iters, extra_dims=self.extra_samples) self.numworkers = 1 if not distributed: logger.info("using serial LSI version on this node") self.dispatcher = None else: if not onepass: raise NotImplementedError("distributed stochastic LSA not implemented yet; " "run either distributed one-pass, or serial randomized.") try: import Pyro4 dispatcher = Pyro4.Proxy('PYRONAME:gensim.lsi_dispatcher') dispatcher._pyroOneway.add("exit") logger.debug("looking for dispatcher at %s" % str(dispatcher._pyroUri)) dispatcher.initialize(id2word=self.id2word, num_topics=num_topics, chunksize=chunksize, decay=decay, power_iters=self.power_iters, extra_samples=self.extra_samples, distributed=False, onepass=onepass) self.dispatcher = dispatcher self.numworkers = len(dispatcher.getworkers()) logger.info("using distributed version with %i workers" % self.numworkers) except Exception as err: # distributed version was specifically requested, so this is an error state logger.error("failed to initialize distributed LSI (%s)" % err) raise RuntimeError("failed to initialize distributed LSI (%s)" % err) if corpus is not None: self.add_documents(corpus)
def get_type_definition(self, graph_name, type_name): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.get_type_definition(graph_name, type_name)
def runNodeService(): global pyroUri, pyroLoopCondition d = Pyro4.Daemon(host=host, port=port) pyroUri = d.register(NodeService(self.node), self.node.name) d.requestLoop(checkPyroLoopCondition)
def count(self, graph_name, type_name): if (self.pyro is None): self.pyro = Pyro4.Proxy(self.proxy_uri) return self.pyro.count(graph_name, type_name)
def main(): new_roaster_temperature = sys.argv[1] roast_control = Pyro4.Proxy("PYRONAME:roaster.sr700") if int(new_roaster_temperature) > -1 and int(new_roaster_temperature) <551: roast_control.set_temperature(new_roaster_temperature)