def test_multiple_servers_calls(self):
# start server A
server_a = callme.Server(server_id='server_a')
server_a.register_function(lambda: 'a', 'f')
p_a = self._run_server_thread(server_a)
# start server B
server_b = callme.Server(server_id='server_b')
server_b.register_function(lambda: 'b', 'f')
p_b = self._run_server_thread(server_b)
try:
proxy = callme.Proxy(server_id='server_a')
result = proxy.f()
self.assertEqual(result, 'a')
result = proxy.use_server('server_b').f()
self.assertEqual(result, 'b')
finally:
server_a.stop()
server_b.stop()
p_a.join()
p_b.join()
def test_serial_server_concurrent_calls(self):
def madd(a):
time.sleep(0.1)
return a
server = callme.Server(server_id='fooserver')
server.register_function(madd, 'madd')
p = self._run_server_thread(server)
def threaded_call(i, results):
proxy = callme.Proxy(server_id='fooserver')
results.append((i, proxy.madd(i)))
results = []
threads = []
try:
# start 5 threads who call "parallel"
for i in range(5):
t = threading.Thread(target=threaded_call, args=(i, results))
t.daemon = True
t.start()
threads.append(t)
# wait until all threads are finished
[thread.join() for thread in threads]
finally:
server.stop()
p.join()
# check results
for i, result in results:
self.assertEqual(i, result)
def __init__(self, service_name, url='localhost', table_names=None,
owned_tables=None, db_connector=None, console_debug=True, callables=None):
"""
:param service_name:
:param url:
:param table_names:
:param owned_tables:
:param db_connector:
:param console_debug:
"""
self.service_name = service_name
self.table_names = table_names
self.db_con = db_connector
if owned_tables is not None:
self.owned_tables = owned_tables
else:
self.owned_tables = []
# Opening connection with RabbotMQ for events handling
self.url = url
connection = pika.BlockingConnection(pika.ConnectionParameters(host=url))
self.channel = connection.channel()
self.rpc_channel = None
self.console_debug = console_debug
# Subscribig to events that concern tables that are not owned by this
# service. Assuming that only an owner can edit a table and there is
# only one owner per table, owner does not have to listen to events.
# Listening would cause the owner to react to events that it has fired
# itself
if callables is None:
callables = {}
if table_names is not None:
for table_name in table_names:
self.channel.exchange_declare(exchange=table_name,
exchange_type='fanout')
if table_name not in self.owned_tables:
if table_name in callables.keys():
self._subscribe_to_table(table_name, callables[table_name])
else:
self._subscribe_to_table(table_name)
# initiate RPC server
self.server = callme.Server(server_id=service_name, amqp_host=url,
threaded=True)
self.registered_tasks = []
# initiating log exchange in case it does not yet exist
self.channel.exchange_declare(exchange='log',
exchange_type='fanout')
t = threading.Thread(target=self.start_rpc_server, daemon=True)
t.start()
#registering tasks for admin interface
self.register_task(self.create_record, 'create')
self.register_task(self.update_record, 'update')
self.register_task(self.delete_record, 'delete')
self.register_task(self.clear_table, 'clear')
self.register_task(self.select, 'select')
def test_method_single_call(self):
server = callme.Server(server_id='fooserver')
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
try:
result = callme.Proxy(server_id='fooserver').madd(1, 1)
self.assertEqual(result, 2)
finally:
server.stop()
p.join()
def test_remote_exception_call(self):
server = callme.Server(server_id='fooserver')
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
try:
proxy = callme.Proxy(server_id='fooserver')
self.assertRaises(TypeError, proxy.madd)
finally:
server.stop()
p.join()
def test_method_multiple_calls(self):
server = callme.Server(server_id='fooserver')
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
try:
proxy = callme.Proxy(server_id='fooserver')
result = proxy.use_server(timeout=3).madd(1, 2)
self.assertEqual(result, 3)
result = proxy.use_server(timeout=2).madd(2, 2)
self.assertEqual(result, 4)
result = proxy.use_server(timeout=1).madd(2, 3)
self.assertEqual(result, 5)
finally:
server.stop()
p.join()
def __init__(self, service_name, url='localhost', table_names=None,
owned_tables=None, db_connector=None, console_debug=True):
"""
:param service_name:
:param url:
:param table_names:
:param owned_tables:
:param db_connector:
:param console_debug:
"""
self.service_name = service_name
self.table_names = table_names
self.db_con = db_connector
if owned_tables is not None:
self.owned_tables = owned_tables
else:
self.owned_tables = []
# Opening connection with RabbotMQ for events handling
connection = pika.BlockingConnection(pika.ConnectionParameters(host=url))
self.channel = connection.channel()
self.console_debug = console_debug
# Subscribig to events that concern tables that are not owned by this
# service. Assuming that only an owner can edit a table and there is
# only one owner per table, owner does not have to listen to events.
# Listening would cause the owner to react to events that it has fired
# itself
if table_names is not None:
for table_name in table_names:
self.channel.exchange_declare(exchange=table_name,
exchange_type='fanout')
if table_name not in self.owned_tables:
self._subscribe_to_table(table_name)
# initiate RPC server
self.server = callme.Server(server_id=service_name, amqp_host=url,
threaded=True)
self.registered_tasks = []
# initiating log exchange in case it does not yet exist
self.channel.exchange_declare(exchange='log',
exchange_type='fanout')
import callme
import time
def add(a, b):
time.sleep(5)
return a + b
server = callme.Server(server_id='fooserver',
amqp_host='localhost', threaded=True)
server.register_function(add, 'add')
server.start()
def test_timeout_call(self):
callme.Server(server_id='fooserver')
proxy = callme.Proxy(server_id='fooserver', timeout=1)
self.assertRaises(exc.RpcTimeout, proxy.madd, 1, 2)
:param a: The first number to add
:param b: The second number to add
:return: The result of the addition
:Example:
>>> add(3, 2)
5
"""
return a + b
def fib(n):
"""Calculate Fibonacci sequence.
:param n: number
:Example:
>>> fib(10)
55
"""
if n <= 1:
return n
else:
return fib(n - 1) + fib(n - 2)
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
server = callme.Server(server_id='fooserver')
server.register_function(add, 'add')
server.register_function(fib, 'fib')
server.start()
import code_exec
from code_exec import execute_user_script
import traceback
def enveloppe_extract(func_str):
import os
os.system('rm uploaded_custom.py | touch uploaded_custom.py')
ret = open('uploaded_custom.py', 'wb')
ret.write(func_str)
ret.close()
val_ret = {'score': 10000000000, 'duration': 0, 'error_msg': ""}
try:
val_ret = execute_user_script()
print(val_ret)
except Exception as e:
print(e)
return val_ret
#server = callme.Server(server_id='fooserver2',amqp_host='localhost')
server = callme.Server(server_id='fooserver',
amqp_host='salamander.rmq.cloudamqp.com',
amqp_vhost='spwlpmyp',
amqp_user='******',
amqp_password='******')
server.register_function(enveloppe_extract, 'enveloppe_extract')
server.start()
import callme
import subprocess
import numpy as np
from PIL import Image
import code_exec
from code_exec import execute_user_script
def enveloppe_extract(func_str):
import os
os.system('rm uploaded_custom.py | touch uploaded_custom.py')
ret = open('uploaded_custom.py', 'wb')
ret.write(func_str)
ret.close()
val_ret = {'score':10000000000,'duration': 0}
try:
val_ret = execute_user_script()
print(val_ret)
except Exception as e:
print("Script Error - trigger Exception:")
print(e)
pass
return val_ret
server = callme.Server(server_id='fooserver2',
amqp_host='localhost')
server.register_function(enveloppe_extract, 'enveloppe_extract')
server.start()
