def serve_forking(options):
t = ForkingServer(SlaveService, hostname = options.host,
port = options.port, reuse_addr = True,
authenticator = options.authenticator, registrar = options.registrar,
auto_register = options.auto_register)
t.logger.quiet = options.quiet
if options.logfile:
t.logger.console = open(options.logfile, "w")
t.start()
def serve_forking(options):
t = ForkingServer(SlaveService, hostname=options.host,
port=options.port, reuse_addr=True,
authenticator=options.authenticator, registrar=options.registrar,
auto_register=options.auto_register)
t.logger.quiet = options.quiet
if options.logfile:
t.logger.console = open(options.logfile, "w")
t.start()
def start_server(options):
"""
Start RPyC server
"""
if options['daemonize'] and options['server_user'] and \
options['server_group']:
#ensure the that the daemon runs as specified user
change_uid_gid(options['server_user'], options['server_group'])
if options['threaded']:
serv = ThreadedServer(server.OpenProximityService,
options['host'],
port=options['port'],
auto_register=options['autoregister'])
else:
print "Forking server is not a tested server!"
serv = ForkingServer(server.OpenProximityService,
options['host'],
port=options['port'],
auto_register=options['autoregister'])
try:
serv.start()
except KeyboardInterrupt, err:
serv.stop()
def setup(self):
if sys.platform == "win32":
raise SkipTest("This test doesn't work on win32")
self.server = ForkingServer(SlaveService,
hostname = "localhost", port=18812, auto_register=False)
self.server.logger.quiet = False
t = threading.Thread(target=self.server.start)
t.start()
def start_slave(port, data_dir):
# set up data directory
data_dir = path.abspath(data_dir)
_mkdirp(data_dir)
# store some config for later
# (i don't really have anywhere better to put it)
SlaveServer._port = int(port)
SlaveServer._hostname = gethostname()
SlaveServer._datadir = data_dir
_mkdirp(path.join(data_dir, 'storage'))
s = ForkingServer(SlaveServer, port=int(port))
_register(SlaveServer._hostname, SlaveServer._port)
s.start()
_unregister(SlaveServer._hostname, SlaveServer._port)
class Test_ForkingServer(object):
def setup(self):
if sys.platform == "win32":
raise SkipTest("This test doesn't work on win32")
self.server = ForkingServer(SlaveService,
hostname = "localhost", port=18812, auto_register=False)
self.server.logger.quiet = False
t = threading.Thread(target=self.server.start)
t.start()
def teardown(self):
self.server.close()
def test_conenction(self):
c = rpyc.classic.connect("localhost", port=18812)
print c.modules.sys
print c.modules["xml.dom.minidom"].parseString("<a/>")
c.execute("x = 5")
assert c.namespace["x"] == 5
assert c.eval("1+x") == 6
c.close()
class DBList(rpyc.Service):
value = []
def exposed_append(self, data):
self.value = self.value + [data]
print("Valor Appended: ", data)
return self.value
def exposed_value(self):
return self.value
if __name__ == "__main__":
server = ForkingServer(DIR_SERVER, DIR_PORT)
conn = rpyc.connect(DIR_SERVER, DIR_PORT)
my_addr = socket.gethostbyname(socket.gethostname())
print(conn.root.exposed_register("DBList", my_addr, 12345))
server.start()
import rpyc
from constRPYC import *
from rpyc.utils.server import ForkingServer
class ServerDirectory(rpyc.Service):
registryDirectory = {}
def exposed_register(self, server_name, my_ip_adress, port_number):
self.registryDirectory[server_name] = (my_ip_adress, port_number)
print (self.registryDirectory)
def exposed_lookup(self, server_name):
if server_name in self.registryDirectory:
return self.registryDirectory[server_name]
else:
return None
if __name__ == "__main__":
server_dir = ForkingServer(ServerDirectory, port = '' )
server_dir.start()
def main():
from rpyc.utils.server import ForkingServer
server = ForkingServer(PrimeCalculatorWorker, port=PRIME_CALC_PORT)
server.start()
import rpyc
from rpyc.utils.server import ForkingServer
class DBList(rpyc.Service):
value = []
def exposed_append(self, data):
self.value = self.value + [data]
print("append", data)
return self.value
def exposed_value(self):
return self.value
if __name__ == "__main__":
server = ForkingServer(DBList, port=12345)
server.start()
if isPrime:
primes.append(possiblePrime)
batch += 1 #batch is the length of primes
if (batch % batchSize == 0): # one batch of primes == batchSize
stop_time = time.time()
elapsed = stop_time - start_time
cbfunc(batch, elapsed)
return primes
class MyService(rpyc.Service):
def on_connect(self, conn): #runs when a connection is started
print("\n>>> RPyC service connected ....")
def on_disconnect(self, conn): #runs after the connection has closed
print("<<< RPyC service disconnected ...")
def exposed_get_primes(self, lowerLimit, upperLimit,
callbackF): #exposed method
print(" Starting computation on server ..")
list_of_primes = primes(lowerLimit, upperLimit, 1000, callbackF)
print(" Computing finished.")
return list_of_primes
if __name__ == "__main__":
from rpyc.utils.server import ForkingServer
t = ForkingServer(MyService, port=18861)
t.start()
print("Trying to self-unregister...")
if serverName == "":
print("Failed. Server not registered.")
return False
dir_conn = rpyc.connect(const.DIR_IP, const.DIR_PORT)
if dir_conn.root.query_registry(serverName):
dir_conn.root.server_remove(serverName)
print("Sucess! Unregistered from directory server.")
serverName = ""
return True
else:
print("Falied. No register found with server name.")
serverName = ""
return False
def run_application(self, weight, height):
bmi = (weight/(height**2))
return bmi
def query_directory(self, name):
dir_conn = rpyc.connect(DIR_IP, DIR_PORT)
return dir_conn.root.query_registry(name)
if __name__ == "__main__":
server = ForkingServer(ApplicationServer, const.APP_PORT)
server.self_register(const.APP_NAME)
server.start()
'"{}"'.format(cmd)]).decode().strip()
def get_pids(p_name):
return shell_run(
'ps -A |grep {} |cut -d " " -f 1'.format(p_name).split('\n'))
def current_time():
# from common
return time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime())
def write_log(msg, print_=True, log=None):
# from common
with open(log, 'a') as lf:
lf.write(msg + '\n')
if print_: print(msg)
return
if __name__ == '__main__':
port = 9999 if len(sys.argv) < 2 else int(sys.argv[1])
from rpyc.utils.server import ForkingServer
t = ForkingServer(CrunchService, 'localhost', port=port)
print('Running CrunchService. Use Ctrl+C to quit.')
t.start()
print('Killing CrunchService.')
import rpyc
import socket
from constRPYC import * #-
from rpyc.utils.server import ForkingServer
class DBList(rpyc.Service):
value = [ ] #lista
def exposed_append(self, data): #metodo que anexa um valor na lista
self.value = self.value + [data]
print ("Appended value: ", data)
return self.value
def exposed_value(self):# metodo que obtém um valor na lista
return self.value
if __name__ == "__main__":
server = ForkingServer(DBList, port = 12345) #define o tipo de servidor
conn = rpyc.connect(DIR_SERVER, DIR_PORT) #conecta com o servidor de diretorio, os parametros vem do arquivo ConstRPYC.py
my_addr = socket.gethostbyname(socket.gethostname()) #Obtem o endereço IP da maquina que está rodando atraves da biblioteca de sockets
(registered, message) = conn.root.exposed_register('DBList', my_addr, HOST_PORT)
print (message)
if registered:
server.start()
~ ~ ~
print "Control message: Run"
bot = Bot(self.channel, self.host)
dummy(bot)
def make_exchange(self, name, channel, callback):
channel.exchange_declare(exchange=name, type ='fanout')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
channel.queue_bind(exchange=name, queue=queue_name)
channel.basic_consume(callback, queue=queue_name, no_ack=True)
def close(self):
self.connection.close()
class Ev3HostService(rpyc.Service):
__rabbit = None
__process = None
def exposed_start(self, host, broker, username='******', password='******'):
if not self.__rabbit is None:
self.__rabbit.close()
print "Rabbit start request on " + host + " for broker " + broker
if not self.__process is None:
self.__process.terminate()
self.__rabbit = Rabbit(host, broker, username, password)
self.__process = Process(target=self.__rabbit.work)
self.__process.start()
if __name__ == "__main__":
from rpyc.utils.server import ForkingServer
f = ForkingServer(Ev3HostService, port=12345)
print "Starting rpyc Ev3HostService"
f.start()
time.sleep(1)
chan.recv(1024)
# Retrieve signed certificate from server
try:
sftp.get('/home/{0}/{1}'.format(self.ssh_user, certfile),
os.getcwd() + '/{0}'.format(certfile))
except paramiko.SFTPError as e:
self.log.error('Unable to retrieve certificate from firewall: {0}'.format(str(e)))
chan.send('rm /home/{0}/{1}\n'.format(self.ssh_user, certfile))
chan.close()
sftp.close()
with open(certfile, 'r') as certificate:
cert = certificate.read()
os.remove(reqfile)
os.remove(certfile)
# Return signed cert to client
return cert
class RetryMethodError(Exception):
"""Custom exception used for signaling that the calling process should
perform another attempt at method execution."""
pass
if __name__ == '__main__':
# Connection requires an SSL certificate signed by the same CA as the server's certificate
authenticator = SSLAuthenticator('autovpn-server.key', 'autovpn-server.crt')
logging.basicConfig()
server = ForkingServer(AutoVPNServer, port=54321,
authenticator=authenticator)
server.start()
