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"))
