def _exec_remote_with_pty(self, task_name, *args):
stream_proto = AttachStdinProtocol()
stdio.StandardIO(stream_proto)
from mcloud.remote import Client, Task
client = Client(host=self.host, port=self.port, settings=self.settings)
try:
yield txtimeout(client.connect(), 20, 'Can\'t connect to the server on host %s' % self.host)
task = Task(task_name)
task.on_progress = self.print_progress
task.on_stdout = stream_proto.write
stream_proto.listener = task.on_stdin
try:
yield client.call(task, *args, size=stream_proto.term.get_size())
res = yield task.wait_result()
yield client.shutdown()
yield sleep(0.1)
defer.returnValue(res)
except Exception as e:
print repr(e)
print('Failed to execute the task: %s' % e.message)
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
finally:
stream_proto.stop()
def test_request_response():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
def my_config(binder):
binder.bind('settings', None)
inject.configure(my_config)
# log.startLogging(sys.stdout)
server = Server(port=9998, no_ssl=True)
server.bind()
client = Client(port=9998, no_ssl=True)
yield client.connect()
response = yield client.call_sync('ping')
assert response == 'pong'
client.shutdown()
server.shutdown()
def test_request_response_no_such_command():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
def my_config(binder):
binder.bind('settings', None)
inject.configure(my_config)
log.startLogging(sys.stdout)
server = Server(port=9996, no_ssl=True)
server.bind()
client = Client(port=9996, no_ssl=True)
yield client.connect()
with pytest.raises(ApiError):
yield client.call_sync('hoho')
client.shutdown()
server.shutdown()
def ps(self, **kwargs):
from mcloud.remote import Client
client = Client(host=self.host, settings=self.settings)
try:
yield client.connect()
tasks = yield client.task_list()
print tasks
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
yield client.shutdown()
yield sleep(0.01)
def ps(self, **kwargs):
from mcloud.remote import Client
client = Client(host=self.host, settings=self.settings)
try:
yield client.connect()
tasks = yield client.task_list()
print tasks
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
yield client.shutdown()
yield sleep(0.01)
def kill(self, task_id=None, **kwargs):
from mcloud.remote import Client
client = Client(host=self.host, settings=self.settings)
try:
yield client.connect()
success = yield client.terminate_task(task_id)
if not success:
print 'Task not found by id'
else:
print 'Task successfully treminated.'
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
client.shutdown()
yield sleep(0.01)
def _remote_exec(self, task_name, *args, **kwargs):
from mcloud.remote import Client, Task
client = Client(host=self.host, port=self.port, settings=self.settings)
self.current_client = client
yield txtimeout(client.connect(), 20, 'Can\'t connect to the server on host %s' % self.host)
task = Task(task_name)
task.on_progress = self.print_progress
self.current_task = task
yield client.call(task, *args, **kwargs)
res = yield task.wait_result()
yield client.shutdown()
yield sleep(0.1)
defer.returnValue(res)
def _remote_exec(self, task_name, *args, **kwargs):
from mcloud.remote import Client, Task
client = Client(host=self.host, port=self.port, settings=self.settings)
self.current_client = client
yield txtimeout(client.connect(), 20,
'Can\'t connect to the server on host %s' % self.host)
task = Task(task_name)
task.on_progress = self.print_progress
self.current_task = task
yield client.call(task, *args, **kwargs)
res = yield task.wait_result()
yield client.shutdown()
yield sleep(0.1)
defer.returnValue(res)
def test_request_response():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
def my_config(binder):
binder.bind('settings', None)
inject.configure(my_config)
# log.startLogging(sys.stdout)
server = Server(port=9998, no_ssl=True)
server.bind()
client = Client(port=9998, no_ssl=True)
yield client.connect()
response = yield client.call_sync('ping')
assert response == 'pong'
client.shutdown()
server.shutdown()
def test_request_response_no_such_command():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
def my_config(binder):
binder.bind('settings', None)
inject.configure(my_config)
log.startLogging(sys.stdout)
server = Server(port=9996, no_ssl=True)
server.bind()
client = Client(port=9996, no_ssl=True)
yield client.connect()
with pytest.raises(ApiError):
yield client.call_sync('hoho')
client.shutdown()
server.shutdown()
def _exec_remote_with_pty(self, task_name, *args):
stream_proto = AttachStdinProtocol()
stdio.StandardIO(stream_proto)
from mcloud.remote import Client, Task
client = Client(host=self.host, port=self.port, settings=self.settings)
try:
yield txtimeout(
client.connect(), 20,
'Can\'t connect to the server on host %s' % self.host)
task = Task(task_name)
task.on_progress = self.print_progress
task.on_stdout = stream_proto.write
stream_proto.listener = task.on_stdin
try:
yield client.call(task,
*args,
size=stream_proto.term.get_size())
res = yield task.wait_result()
yield client.shutdown()
yield sleep(0.1)
defer.returnValue(res)
except Exception as e:
print repr(e)
print('Failed to execute the task: %s' % e.message)
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
finally:
stream_proto.stop()
def kill(self, task_id=None, **kwargs):
from mcloud.remote import Client
client = Client(host=self.host, settings=self.settings)
try:
yield client.connect()
success = yield client.terminate_task(task_id)
if not success:
print 'Task not found by id'
else:
print 'Task successfully treminated.'
except ConnectionRefusedError:
print 'Can\'t connect to mcloud server'
client.shutdown()
yield sleep(0.01)
def test_task_terminate():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
rc = yield redis.Connection(dbid=2)
eb = EventBus(rc)
yield eb.connect()
def my_config(binder):
binder.bind(redis.Connection, rc)
binder.bind(EventBus, eb)
binder.bind('settings', None)
inject.configure(my_config)
yield rc.flushdb()
api = inject.instance(ApiRpcServer)
#-----------------------------------
# Test itself
#-----------------------------------
# this will emulate some long-running process
task_defered = defer.Deferred()
# this is mock that will execute our long-running process
task = flexmock()
task.should_receive('foo').with_args(
int, 123, 'test').once().and_return(task_defered)
# register our task
api.tasks['baz'] = task.foo
# start server -> real server on tcp port
server = Server(port=9987, no_ssl=True)
server.bind()
# real client connecton here
client = Client(port=9987, no_ssl=True)
yield client.connect()
# client calls a task
task = Task('baz')
yield client.call(task, 123, 'test')
yield sleep(0.1)
assert task.id > 0
assert task.name == 'baz'
assert task.is_running is True
# now client terminates the task
yield sleep(0.1)
client.terminate_task(task.id)
yield sleep(0.1)
assert task.is_running is False
#-----------------------------------
# Cleanup
#-----------------------------------
client.shutdown()
server.shutdown()
yield sleep(0.1)
def test_tasks():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
rc = yield redis.Connection(dbid=2)
eb = EventBus(rc)
yield eb.connect()
def my_config(binder):
binder.bind(redis.Connection, rc)
binder.bind(EventBus, eb)
binder.bind('settings', None)
inject.configure(my_config)
yield rc.flushdb()
api = inject.instance(ApiRpcServer)
#-----------------------------------
# Test itself
#-----------------------------------
# this will emulate some long-running process
task_defered = defer.Deferred()
# this is mock that will execute our long-running process
task = flexmock()
task.should_receive('foo').with_args(
int, 123, 'test').once().and_return(task_defered)
# register our task
api.tasks['baz'] = task.foo
# start server -> real server on tcp port
server = Server(port=9997, no_ssl=True)
server.bind()
# real client connecton here
client = Client(port=9997, no_ssl=True)
yield client.connect()
# client calls a task
task = Task('baz')
yield client.call(task, 123, 'test')
yield sleep(0.1)
assert task.id > 0
assert task.name == 'baz'
assert task.is_running is True
assert len(server.rpc_server.tasks_running) == 1
assert server.rpc_server.tasks_running[task.id]['name'] == 'baz'
assert len(server.rpc_server.task_list()) == 1
# no data should be on client
yield sleep(0.1)
assert task.data == []
assert task.response is None
# now server sends some progress
yield server.clients[0].send_event('task.progress.%s' % task.id,
'nami-nami')
# and client should receive this data
yield sleep(0.1)
assert task.data == ['nami-nami']
assert task.is_running is True
assert task.response is None
# now our long-running process stopped and returned some result
yield task_defered.callback('this is respnse')
# and client should recieve this resul
yield sleep(0.1)
assert task.data == ['nami-nami']
assert task.is_running == False
assert task.response == 'this is respnse'
assert len(server.rpc_server.tasks_running) == 0
assert len(server.rpc_server.task_list()) == 0
#-----------------------------------
# Cleanup
#-----------------------------------
client.shutdown()
server.shutdown()
yield sleep(0.1)
def test_task_terminate():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
rc = yield redis.Connection(dbid=2)
eb = EventBus(rc)
yield eb.connect()
def my_config(binder):
binder.bind(redis.Connection, rc)
binder.bind(EventBus, eb)
binder.bind('settings', None)
inject.configure(my_config)
yield rc.flushdb()
api = inject.instance(ApiRpcServer)
#-----------------------------------
# Test itself
#-----------------------------------
# this will emulate some long-running process
task_defered = defer.Deferred()
# this is mock that will execute our long-running process
task = flexmock()
task.should_receive('foo').with_args(int, 123, 'test').once().and_return(task_defered)
# register our task
api.tasks['baz'] = task.foo
# start server -> real server on tcp port
server = Server(port=9987, no_ssl=True)
server.bind()
# real client connecton here
client = Client(port=9987, no_ssl=True)
yield client.connect()
# client calls a task
task = Task('baz')
yield client.call(task, 123, 'test')
yield sleep(0.1)
assert task.id > 0
assert task.name == 'baz'
assert task.is_running is True
# now client terminates the task
yield sleep(0.1)
client.terminate_task(task.id)
yield sleep(0.1)
assert task.is_running is False
#-----------------------------------
# Cleanup
#-----------------------------------
client.shutdown()
server.shutdown()
yield sleep(0.1)
def test_tasks():
#-----------------------------------
# preparations
#-----------------------------------
# cleanup a bit
inject.clear()
rc = yield redis.Connection(dbid=2)
eb = EventBus(rc)
yield eb.connect()
def my_config(binder):
binder.bind(redis.Connection, rc)
binder.bind(EventBus, eb)
binder.bind('settings', None)
inject.configure(my_config)
yield rc.flushdb()
api = inject.instance(ApiRpcServer)
#-----------------------------------
# Test itself
#-----------------------------------
# this will emulate some long-running process
task_defered = defer.Deferred()
# this is mock that will execute our long-running process
task = flexmock()
task.should_receive('foo').with_args(int, 123, 'test').once().and_return(task_defered)
# register our task
api.tasks['baz'] = task.foo
# start server -> real server on tcp port
server = Server(port=9997, no_ssl=True)
server.bind()
# real client connecton here
client = Client(port=9997, no_ssl=True)
yield client.connect()
# client calls a task
task = Task('baz')
yield client.call(task, 123, 'test')
yield sleep(0.1)
assert task.id > 0
assert task.name == 'baz'
assert task.is_running is True
assert len(server.rpc_server.tasks_running) == 1
assert server.rpc_server.tasks_running[task.id]['name'] == 'baz'
assert len(server.rpc_server.task_list()) == 1
# no data should be on client
yield sleep(0.1)
assert task.data == []
assert task.response is None
# now server sends some progress
yield server.clients[0].send_event('task.progress.%s' % task.id, 'nami-nami')
# and client should receive this data
yield sleep(0.1)
assert task.data == ['nami-nami']
assert task.is_running is True
assert task.response is None
# now our long-running process stopped and returned some result
yield task_defered.callback('this is respnse')
# and client should recieve this resul
yield sleep(0.1)
assert task.data == ['nami-nami']
assert task.is_running == False
assert task.response == 'this is respnse'
assert len(server.rpc_server.tasks_running) == 0
assert len(server.rpc_server.task_list()) == 0
#-----------------------------------
# Cleanup
#-----------------------------------
client.shutdown()
server.shutdown()
yield sleep(0.1)