Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def setUp(self):
enable_splitbrain()
server_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "bin", "rpyc_classic.py")
self.proc = subprocess.Popen([sys.executable, server_file, "--mode=oneshot", "--host=localhost", "-p0"],
stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
line = self.proc.stdout.readline().strip()
if not line:
print (self.proc.stderr.read())
self.fail("server failed to start")
self.assertEqual(line, b("rpyc-oneshot"), "server failed to start")
host, port = self.proc.stdout.readline().strip().split(b("\t"))
self.conn = rpyc.classic.connect(host, int(port))
def test_parallelism(self):
conns = [rpyc.classic.connect("localhost", port=18878)
for _ in range(50)]
try:
start = time.time()
gevent.joinall([
gevent.spawn(c.modules.time.sleep, 1)
for c in conns
])
stop = time.time()
self.assertLessEqual(stop - start, 2)
finally:
for c in conns:
c.close()
It waits for tasks (function, data, arguments) at the input queue "inqueue"
evaluates the result and passes it to the output queue "outqueue". It
optionally evaluates the function on a remote host.
"""
put = outqueue.put
get = inqueue.get
if hasattr(inqueue, '_writer'):
inqueue._writer.close()
outqueue._reader.close()
if host:
host_port = host.split(':')
try:
host_port = [host_port[0], int(host_port[1])]
except IndexError:
pass
conn = rpyc.classic.connect(*host_port)
conn.execute(getsource(imports)) # provide @imports on server
while True:
try:
#gc.disable()
task = get()
#gc.enable()
except (EOFError, IOError):
break
if task is None:
put(None)
break
if task[1] is None:
put(task)
#! /usr/bin/env python
import rpyc
import sys
import os
CLIENT_IP = sys.argv[1]
PATH = "/home/u1/onedata/s1"
conn = rpyc.classic.connect(CLIENT_IP)
for i in range(10):
conn.modules.os.mkdir(os.path.join(PATH, str(i)))
conn.close()
import rpyc
import time
c = rpyc.classic.connect("localhost")
t = rpyc.BgServingThread(c)
start = time.time()
for i in range(100):
c.execute("newObj = %d" % (i))
stop = time.time()
print "added %d simple objects one by one, %f seconds" % (100, stop - start)
t.stop()
re.compile(r'.*pid\<(?P[0-9]+)\>')])
time.sleep(0.2)
seconds += 0.2
if not done:
self.kill()
with open(self.std.errPath, 'r') as err:
errStr = err.read()
raise Exception('Timed out trying to launch rpyc on {0} - stderr contents: {1}'.format(
self.host, errStr))
self.port = int(extracts['port'])
self.pid = int(extracts['pid'])
pwd = os.environ['PWD']
self.connection = rpyc.classic.connect(self.host, self.port, keepalive=self.keepalive)
self.connection.modules.sys.stdout = sys.stdout
if self.chdir:
self.connection.modules.os.chdir(pwd)
self.connection.modules.os.environ['PWD'] = pwd
return self
def spawn_child():
port = random.randint(30000, 39999)
cmd = ['python', '-c', '''from rpyc.core import SlaveService
#import logging
#logging.basicConfig(filename='child.log', level=logging.DEBUG)
from rpyc.utils.server import OneShotServer
OneShotServer(SlaveService, hostname='localhost', port={}).start()
'''.format(port)]
subprocess.Popen(cmd)
time.sleep(2.0)
return rpyc.classic.connect('localhost', port)
#! /usr/bin/env python
import rpyc
import sys
import subprocess
import os
CLIENT_IP = sys.argv[1]
CLIENT = sys.argv[2]
OP = sys.argv[3]
OZ = sys.argv[4]
PATH = "/home/u1/onedata/s1"
REMOUNT_SCRIPT = "./profiling/remount_client.sh"
conn = rpyc.classic.connect(CLIENT_IP)
file = os.path.join(PATH, "file")
subprocess.check_output([REMOUNT_SCRIPT, CLIENT, OP, OZ])
with conn.builtins.open(file, 'r') as f:
f.read()
conn.close()
#! /usr/bin/env python
import rpyc
import sys
import os
CLIENT_IP = sys.argv[1]
PATH = "/home/u1/onedata/s1"
conn = rpyc.classic.connect(CLIENT_IP)
dir_path=os.path.join(PATH, 'dir')
conn.modules.os.mkdir(dir_path)
for i in range(10):
conn.modules.os.mkdir(os.path.join(dir_path, str(i)))
conn.close()