Exemplo n.º 1
0
    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()
Exemplo n.º 2
0
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()
Exemplo n.º 3
0
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()
Exemplo n.º 4
0
    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)
Exemplo n.º 5
0
    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)
Exemplo n.º 6
0
    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)
Exemplo n.º 7
0
    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)
Exemplo n.º 8
0
    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)
Exemplo n.º 9
0
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()
Exemplo n.º 10
0
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()
Exemplo n.º 11
0
    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()
Exemplo n.º 12
0
    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)
Exemplo n.º 13
0
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)
Exemplo n.º 14
0
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)
Exemplo n.º 15
0
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)
Exemplo n.º 16
0
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)