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)
