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_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)
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()
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()
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()