def Start(self, objects):
daemon = Pyro4.Daemon(self.host)
ns = Pyro4.locateNS(self.host, self.port)
for obj in objects:
Pyro4.expose(obj.__class__)
objAddress = daemon.register(obj)
ns.register("%s%s" % (self.identifier, type(obj).__name__), objAddress)
daemon.requestLoop()
def _generate_proxy_class(module_or_class, name, ignore_classes=False):
"""Generates a safe proxyable class from given module or class."""
if module_or_class not in memo:
# Pyro4 doesn't allow private module names to be exposed, so a little hackery is in order.
klass = type(name.strip("_"), (IDAProxy,), {})
add_module(module_or_class, klass, ignore_classes=ignore_classes)
Pyro4.expose(klass)
memo[module_or_class] = klass
return klass
else:
return memo[module_or_class]
def start_with_ns(peers: list, nameserver: str = "localhost", port: int = 7777):
# name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
# gunakan URI untuk referensi name server yang akan digunakan
# untuk mengetahui instance apa saja yang aktif gunakan pyro4-nsc -n localhost -p 7777 list
try:
os.mkdir(namainstance)
except FileExistsError:
pass
daemon = Pyro4.Daemon(host=nameserver)
ns = Pyro4.locateNS(nameserver, port)
FileServer.PEERS = peers
FileServer.NAMESERVER = nameserver
FileServer.PORT = str(port)
FileServer.ROOTDIR = namainstance + "/"
x_FileServer = Pyro4.expose(FileServer)
print(type(ns))
uri_fileserver = daemon.register(x_FileServer)
ns.register("{}" . format(namainstance), uri_fileserver)
# add ins to peer list
with open("instance_hosts", "a+") as f:
f.writelines(namainstance+"\n")
# new thread for PeerSearch
ps = PeerSearch(namainstance, peers)
ps.start()
daemon.requestLoop()
ps.kill()
ps.join()
print("Removing", namainstance, "from NS")
ns.remove("{}".format(namainstance))
def __call__(self, callback):
def inner(*args, **kwargs):
# Determine if session ID is present in current context and the session object has
# been set
if Expose.SESSION_OBJECT is not None and Expose.SESSION_OBJECT._get_session_id(
):
# Renew session expiry
Expose.SESSION_OBJECT.USER_SESSIONS[
Expose.SESSION_OBJECT._get_session_id()].disable()
if self.locking:
return_value = lock_log_and_call(callback, args, kwargs,
self.instance_method,
self.object_type)
else:
return_value = callback(*args, **kwargs)
# Determine if session ID is present in current context and the session object has
# been set
if Expose.SESSION_OBJECT is not None and Expose.SESSION_OBJECT._get_session_id(
):
# Renew session expiry
Expose.SESSION_OBJECT.USER_SESSIONS[
Expose.SESSION_OBJECT._get_session_id()].renew()
return return_value
# Expose the function
return Pyro4.expose(inner)
def start_with_ns():
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
Class = Pyro4.expose(GServers)
uri_greetserver = daemon.register(Class)
print("URI greetserver : ", uri_greetserver)
ns.register("greetserver", uri_greetserver)
daemon.requestLoop()
def start_server():
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 1337)
x_file_controller = Pyro4.expose(FileController)
uri_file_controller = daemon.register(x_file_controller)
print('URI file controller server: ', uri_file_controller)
ns.register("fileControllerServer", uri_file_controller)
daemon.requestLoop()
def pyro_expose(c, port, name):
c = p4.behavior(instance_mode='single')(c)
exposed = p4.expose(c)
p4.Daemon.serveSimple({exposed: name}, ns=False, port=port)
daemon = p4.Daemon()
uri = daemon.register(c, name)
daemon.requestLoop()
def server():
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
x_GreetServer = Pyro4.expose(Backend)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("mypyro", uri_greetserver)
daemon.requestLoop()
def run_server(hostname):
daemon = Pyro4.Daemon(host="localhost")
name_server = Pyro4.locateNS("localhost", 7777)
exposed_master_server = Pyro4.expose(ttt)
uri_host_server = daemon.register(exposed_master_server)
print("URI host server : ", uri_host_server)
name_server.register(hostname, uri_host_server)
daemon.requestLoop()
def _register(daemon):
"""
Sets up IDA/kordesii modules to be expose to given Pyro4 daemon.
:returns: uri information returned by Pyro4
:raises: An exception could be raised if we fail to import a module.
"""
for module_name in proxied_modules:
logging.debug("registering {}".format(module_name))
module = importlib.import_module(module_name)
klass = _generate_proxy_class(module, module_name)
daemon.register(klass, objectId=module_name)
# Now expose the main Proxy controller.
Pyro4.expose(MainProxy)
uri = daemon.register(MainProxy, objectId="main")
return uri
def server():
#run name server local pyro4-ns -n localhost -p 7777
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
x_GreetServer = Pyro4.expose(crudnisa)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("nisa", uri_greetserver)
daemon.requestLoop()
def server():
# JALANIN NAMESERVER LOCAL pyro4-ns -n localhost -p 7777
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
x_GreetServer = Pyro4.expose(Backend)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("elknhns", uri_greetserver)
daemon.requestLoop()
def server_start():
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost",7777)
x_GreetServer = Pyro4.expose(CRUDList)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("crud", uri_greetserver)
daemon.requestLoop()
def start_with_ns():
# name server harus di start dulu dengan pyro4-ns -n localhost -p 8888
# untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 8888 list
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 8888)
serverClass = Pyro4.expose(ServerApi)
uri_greetserver = daemon.register(serverClass)
print("URI greet server : ", uri_greetserver)
ns.register("greetserver", uri_greetserver)
daemon.requestLoop()
def start_server(host='localhost', port=50001):
#name server harus di start dulu dengan pyro4-ns -n [host] -p [port]
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n [host] -p [port] list
daemon = Pyro4.Daemon(host=host)
ns = Pyro4.locateNS(host, port)
expose_server = Pyro4.expose(FileManager)
uri = daemon.register(expose_server)
print("URI FileManager : ", uri)
ns.register("filemanager", uri)
daemon.requestLoop()
def start_server(host_address):
# name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
# untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host=host_address)
name_server = Pyro4.locateNS(host_address, 7777)
server = Pyro4.expose(Grid)
server_uri = daemon.register(server)
print("server URI: ", server_uri)
name_server.register("game_server", server_uri)
daemon.requestLoop()
def start_with_ns():
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengetahui instance apa saja yang aktif gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
x_FileServer = Pyro4.expose(FileServer)
uri_fileserver = daemon.register(x_FileServer)
ns.register("{}".format(namainstance), uri_fileserver)
daemon.requestLoop()
def start_with_ns():
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host="localhost")
ns = Pyro4.locateNS("localhost", 7777)
x_GreetServer = Pyro4.expose(GreetServer)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("greetserver", uri_greetserver)
daemon.requestLoop()
def start_server(host='localhost', port=50001):
#name server harus di start dulu dengan pyro4-ns -n [host] -p [port]
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n [host] -p [port] list
daemon = Pyro4.Daemon(host=host)
ns = Pyro4.locateNS(host, port)
service2 = Pyro4.expose(Service2)
uri_s2 = daemon.register(service2)
ns.register("service2", uri_s2)
daemon.requestLoop()
def _register(daemon):
"""
Sets up IDA/kordesii modules to be expose to given Pyro4 daemon.
:returns: uri information returned by Pyro4
:raises: An exception could be raised if we fail to import a module.
"""
for module_name in proxied_modules:
logging.debug("registering {}".format(module_name))
module = importlib.import_module(module_name)
# Pyro4 doesn't allow private module names to be exposed, so a little hackery is in order.
klass = type(module_name.strip("_"), (IDAProxy,), {})
add_module(module, klass)
Pyro4.expose(klass)
daemon.register(klass, objectId=module_name)
# Now expose the main Proxy controller.
Pyro4.expose(MainProxy)
uri = daemon.register(MainProxy, objectId="main")
return uri
def __init__(self, **kwargs):
'''
Constructor for agent
Params:
- params -> dict : Config name of the sensor
- pyro4_params -> dict : Pyro4 parameters
'''
# Arguments
params = kwargs.get('params')
pyro4_params = kwargs['pyro4_params'] # Pyro4 parameter
#local variables
self.__alive = True # IF sensor is running
# Initialize this thread
threading.Thread.__init__(self)
self.daemon = True # End if main loop stops
self.start() # Start agent thread
# Configure to pickle and pyro4
Pyro4.config.REQUIRE_EXPOSE = False
Pyro4.config.SERIALIZER = "pickle"
Pyro4.config.SERIALIZERS_ACCEPTED = ["pickle"]
class_ = Pyro4.expose(imm.IMM_API) # Expose class methods
# Create an instance
self.__inst = class_(**params)
# Get Pyro4 deamon and register daemon
self.__daemon = Pyro4.core.Daemon(host=get_ip(pyro4_params['ns'][0]))
uri = self.__daemon.register(self.__inst)
# Locate the nameserver
ns = Pyro4.locateNS(host=pyro4_params['ns'][0],
port=pyro4_params['ns'][1])
# Register instance
ns.register(pyro4_params['name'], uri)
print(
"Servername(LINK) = {} and serializer = {}, use this servername, if you want to subscribe it"
.format(pyro4_params['name'], Pyro4.config.SERIALIZER))
# Initialize emi interface
#if kwargs.get('initialize',True):
# self.__initialize()
# Enter the service loop.
print('Entering the service loop')
try:
self.__daemon.requestLoop()
except:
pass
print('{} Ending'.format(self.__inst))
del self.__inst
def start_server():
# name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
# gunakan URI untuk referensi name server yang akan digunakan
# untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host="localhost")
name_server = Pyro4.locateNS("localhost", 7777)
server = Pyro4.expose(ServiceModel)
server_uri = daemon.register(server)
print("server URI: ", server_uri)
name_server.register("myserver", server_uri)
daemon.requestLoop()
def start_with_ns():
#ganti "localhost dengan ip yang akan anda gunakan sebagai server"
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
_host = "127.0.0.1"
daemon = Pyro4.Daemon(host=_host)
ns = Pyro4.locateNS(_host, 7777)
x_tictactoedasar = Pyro4.expose(tictactoedasar)
uri_tictactoedasar = daemon.register(x_tictactoedasar)
ns.register("tictactoedasar", tictactoedasar)
daemon.requestLoop()
def main(args):
AccepterE = Pyro4.expose(Accepter)
with Pyro4.Daemon() as daemon:
ns = Pyro4.locateNS(host="localhost", port=9090)
uri = daemon.register(AccepterE())
ns.register(args.name, uri, metadata={"accepter"}) # add parameters
daemon.requestLoop()
def start_with_ns():
#ganti "localhost dengan ip yang akan anda gunakan sebagai server"
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
_host = "10.151.252.177"
daemon = Pyro4.Daemon(host=_host)
ns = Pyro4.locateNS(_host, 7777)
x_GreetServer = Pyro4.expose(GreetServer)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("greetserver", uri_greetserver)
daemon.requestLoop()
def start_with_ns():
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengecek service apa yang ada di ns, gunakan pyro4-nsc -n localhost -p 7777 list
#multi device tinggal ganti localhost jadi ip, client dan server pakai ip yg sama
# jalankan command pyro4-ns -n ipmu -p 7777
daemon = Pyro4.Daemon(host='10.151.254.50')
ns = Pyro4.locateNS("10.151.254.50", 7777)
x_GreetServer = Pyro4.expose(FileManage)
uri_greetserver = daemon.register(x_GreetServer)
print("URI greet server : ", uri_greetserver)
ns.register("ubutserver", uri_greetserver)
daemon.requestLoop()
def start_with_ns(hostname="localhost", port=50001):
#name server harus di start dulu dengan pyro4-ns -n localhost -p 7777
#gunakan URI untuk referensi name server yang akan digunakan
#untuk mengetahui instance apa saja yang aktif gunakan pyro4-nsc -n localhost -p 7777 list
daemon = Pyro4.Daemon(host=hostname)
ns = Pyro4.locateNS(hostname,port)
x_FileServer = Pyro4.expose(FileServer)
uri_fileserver = daemon.register(x_FileServer, force=True)
ns.register("{}" . format(namainstance), uri_fileserver)
print("PYRONAME:{}@{}:{}" . format(namainstance, hostname, str(port)))
t = threading.Thread(target=daemon.requestLoop())
t.start()
t.join()
def pyro_expose(c, port, name):
def stop():
print('stop() called')
import os
os._exit(1)
from triggerbox import TriggerBox
tb = TriggerBox(name + ' server on ' + str(port), ['stop server'], [stop])
c = p4.behavior(instance_mode='single')(c)
exposed = p4.expose(c)
p4.Daemon.serveSimple({exposed: name}, ns=False, port=port)
daemon = p4.Daemon()
daemon.register(c, name)
daemon.requestLoop()
def main():
daemon = Pyro4.Daemon(host="194.210.158.48")
remoteLibrary = Pyro4.expose(bookDB.bookDB)
#uri = daemon.register(remoteLibrary, 'FranciscoDB-123')
uri = daemon.register(bookDB.bookDB, 'FranciscoDB-123')
ns = Pyro4.locateNS(host="146.193.41.139", port=9090)
print(uri)
ns.register('FranciscoDB-123', uri)
db = bookDB.bookDB("mylib")
try:
daemon.requestLoop()
finally:
daemon.shutdown(True)
def serve_pyro4(p4_args):
'''
start a Pyro4 server that exposes a :class:`,NetemInterface>` instance
for each interface definition present in the command line arguments
need to convince Pyro4 to use pickle for serialization; otherwise we
won't be able to pass emulation objects directly on the client side. yes,
that is not secure but then this entire package is not secure to begin
with
'''
configure_pyro4()
netem_interfaces = []
if not isinstance(p4_args, _Args):
raise TypeError('invalid arguments %s' % p4_args)
p4_args.logger.info('starting simple_netem Pyro4 daemon...')
if p4_args.name_server:
name_server = _locate_pyro4_ns(p4_args)
p4_netem_interface_class = Pyro4.expose(NetemInterface)
for interface in p4_args.interfaces:
netem_interfaces.append(
p4_netem_interface_class(interface=interface[0],
side=interface[1],
logger=p4_args.logger))
with Pyro4.Daemon(host=p4_args.server, port=p4_args.port) as p4_daemon:
p4_daemon._pyroHmacKey = config.P4_HMAC # pylint:disable=W0212
for netem_interface in netem_interfaces:
uri = p4_daemon.register(netem_interface,
objectId=netem_interface.interface)
p4_args.logger.info('Pyro4 URI for interface %s: %s' %
(netem_interface.interface, uri))
if name_server:
p4_args.logger.debug('registering with name server')
try:
name_server.register('bala', uri)
except Exception as err:
p4_args.logger.error(err)
p4_args.logger.info('simple_netem Pyro4 daemon running...')
p4_daemon.requestLoop()
def __call__(self, callback):
"""Run when object is created. The returned value is the method that is executed"""
def inner(self_obj, *args, **kwargs):
"""Run when the wrapping method is called"""
# Create function object and run
function = Function(function=callback, obj=self_obj,
args=args, kwargs=kwargs,
locking=self.locking,
object_type=self.object_type,
instance_method=self.instance_method,
remote_nodes=self.remote_nodes,
support_callback=self.support_callback,
undo_method=self.undo_method,
remote_method=self.remote_method,
remote_undo_method=self.remote_undo_method)
return_val = function.run()
function.unregister()
return return_val
# Expose the function
if self.expose:
return Pyro4.expose(inner)
else:
return inner
def expose(func):
return Pyro4.expose(func)
from __future__ import print_function
from awesome_thirdparty_library import AwesomeClass
import Pyro4
# expose the class from the library using @expose as wrapper function:
ExposedClass = Pyro4.expose(AwesomeClass)
# you can even use instance mode tweaking if required:
# ExposedClass = Pyro4.expose(instance_mode="percall", instance_creator=my_factory_function)(AwesomeClass)
with Pyro4.Daemon() as daemon:
# register the wrapped class instead of the library class itself:
uri = daemon.register(ExposedClass, "example.thirdpartylib")
print("wrapped class registered, uri: ", uri)
daemon.requestLoop()
