예제 #1
0
    def test_rpc_protobuf(self):

        def echo(value):
            value.string = "received"
            return value

        def raw_received(session, event):
            msg = '\0' + base64.b64encode(event.data[1]).decode('ascii')
            res = session.call_rpc('/test/rpc', 'echo',  msg, 'rst.generic.Value', 'rst.generic.Value')
            session.scopes['/test/out'].on_wamp_message(res)

        def protobuf_received(passed, lock, event):
            if hasattr(event.data, 'type') and event.data.string == 'received':
                passed()
            lock.release()

        rsb.converter.registerGlobalConverter(
            rsb.converter.ProtocolBufferConverter(messageClass=Value), True)
        self.session.register_scope('/test/scope', 'rst.generic.Value')
        self.session.register_scope('/test/out', 'rst.generic.Value')
        with rsb.createLocalServer('/test/rpc') as server:
            server.addMethod('echo', echo, Value, Value)
            with rsb.createListener('/test/scope', config=self.session.rsb_conf) as listener:
                listener.addHandler(partial(raw_received, self.session))
                with rsb.createListener('/test/out') as out:
                    out.addHandler(partial(protobuf_received, self.passed, self.lock))
                    with rsb.createInformer('/test/scope', dataType=Value) as informer:
                        v = Value()
                        v.type = Value.STRING
                        v.string = "hello"
                        informer.publishData(v)
                        self.lock.acquire()
        self.assertTrue(self.passed.called)
예제 #2
0
    def testParallelCallOfOneMethod(self):

        numParallelCalls = 3
        runningCalls = [0]
        callLock = Condition()

        with rsb.createLocalServer('/takesometime',
                                   inProcessNoIntrospectionConfig) \
                as localServer:

            def takeSomeTime(e):
                with callLock:
                    runningCalls[0] = runningCalls[0] + 1
                    callLock.notifyAll()
                with callLock:
                    while runningCalls[0] < numParallelCalls:
                        callLock.wait()

            localServer.addMethod("takeSomeTime",
                                  takeSomeTime,
                                  str,
                                  allowParallelExecution=True)

            with rsb.createRemoteServer('/takesometime',
                                        inProcessNoIntrospectionConfig) \
                    as remoteServer:

                results = [
                    remoteServer.takeSomeTime. async ('call{}'.format(x))
                    for x in range(numParallelCalls)
                ]
                for r in results:
                    r.get(10)
예제 #3
0
    def testConstruction(self):

        # Test creating a server without methods
        with rsb.createLocalServer('/some/scope',
                                   inProcessNoIntrospectionConfig) as server:
            self.assertEqual(server.methods, [])

        with rsb.createLocalServer(rsb.Scope('/some/scope'),
                                   inProcessNoIntrospectionConfig) as server:
            self.assertEqual(server.methods, [])

        # Test creating a server with directly specified methods
        with rsb.createLocalServer(rsb.Scope('/some/scope'),
                                   methods=[('foo', lambda x: x, str, str)],
                                   config=inProcessNoIntrospectionConfig) \
                as server:
            self.assertEqual([m.name for m in server.methods], ['foo'])

        # Test creating a server that exposes method of an existing
        # object
        class SomeClass(object):
            def bar(x):
                pass

        someObject = SomeClass()
        with rsb.createLocalServer(rsb.Scope('/some/scope'),
                                   object=someObject,
                                   expose=[('bar', str, None)],
                                   config=inProcessNoIntrospectionConfig) \
                as server:
            self.assertEqual([m.name for m in server.methods], ['bar'])

            # Cannot supply expose without object
            self.assertRaises(ValueError,
                              rsb.createLocalServer,
                              '/some/scope',
                              expose=[('bar', str, None)])

            # Cannot supply these simultaneously
            self.assertRaises(ValueError,
                              rsb.createLocalServer,
                              '/some/scope',
                              object=someObject,
                              expose=[('bar', str, None)],
                              methods=[('foo', lambda x: x, str, str)])
예제 #4
0
    def testLocalServer(self):
        server = None
        method = None
        with rsb.createLocalServer('/') as participant:
            server = participant
            self.assertEqual(self.creationCalls, [(server, None)])

            method = server.addMethod('echo', lambda x: x)
            self.assertTrue((method, server) in self.creationCalls)

        self.assertTrue(server in self.destructionCalls)
        self.assertTrue(method in self.destructionCalls)
예제 #5
0
    def testNonIdentifierMethodName(self):
        serverScope = '/non-identifier-server'
        methodName = 'non-identifier-method'
        with rsb.createLocalServer(serverScope,
                                   inProcessNoIntrospectionConfig) \
                as localServer:
            localServer.addMethod(methodName, lambda x: x, str, str)

            with rsb.createRemoteServer(serverScope,
                                        inProcessNoIntrospectionConfig) \
                    as remoteServer:
                self.assertEqual(
                    remoteServer.getMethod(methodName)('foo'), 'foo')
예제 #6
0
    def testVoidMethods(self):

        with rsb.createLocalServer('/void', inProcessNoIntrospectionConfig) \
                as localServer:

            def nothing(e):
                pass

            localServer.addMethod("nothing", nothing, str)

            with rsb.createRemoteServer('/void',
                                        inProcessNoIntrospectionConfig) \
                    as remoteServer:
                future = remoteServer.nothing. async ("test")
                future.get(1)
예제 #7
0
    def test_rpc(self):

        def echo(x):
            return x

        def squared(x):
            return x*x

        with rsb.createLocalServer('/test/rpc') as server:
            server.addMethod('echo', echo, str, str)
            server.addMethod('squared', squared, int, int)
            res = self.session.call_rpc('/test/rpc', 'echo', "foo", 'string', 'string')
            self.assertEqual(res, "foo")
            res = self.session.call_rpc('/test/rpc', 'squared', 5,  'string', 'integer')
            self.assertEqual(res, 25)
예제 #8
0
	def __init__(self, owning_component_name, channel=None, participant_config=None):
		'''Create an OutputBuffer.

		Keyword arguments:
		owning_component_name -- name of the entity that own this buffer
		participant_config -- RSB configuration
		'''
		super(OutputBuffer, self).__init__(owning_component_name, channel, participant_config)
		self._unique_name = '/ipaaca/component/' + str(owning_component_name) + 'ID' + self._uuid + '/OB'
		self._server = rsb.createLocalServer(rsb.Scope(self._unique_name))
		self._server.addMethod('updateLinks', self._remote_update_links, ipaaca.converter.IULinkUpdate, int)
		self._server.addMethod('updatePayload', self._remote_update_payload, ipaaca.converter.IUPayloadUpdate, int)
		self._server.addMethod('commit', self._remote_commit, ipaaca.ipaaca_pb2.IUCommission, int)
		self._server.addMethod('resendRequest', self._remote_request_resend, ipaaca.ipaaca_pb2.IUResendRequest, int)
		self._informer_store = {}
		self._id_prefix = str(owning_component_name)+'-'+str(self._uuid)+'-IU-'
		self.__iu_id_counter_lock = threading.Lock()
예제 #9
0
    def testRoundTrip(self):

        with rsb.createLocalServer('/roundtrip',
                                   methods=[('addone', lambda x: long(x + 1),
                                             long, long)],
                                   config=inProcessNoIntrospectionConfig):
            with rsb.createRemoteServer('/roundtrip',
                                        inProcessNoIntrospectionConfig) \
                    as remoteServer:

                # Call synchronously
                self.assertEqual(map(remoteServer.addone, range(100)),
                                 range(1, 101))

                # Call synchronously with timeout
                self.assertEqual(
                    [remoteServer.addone(x, timeout=10) for x in range(100)],
                    range(1, 101))

                # Call asynchronously
                self.assertEqual(
                    map(lambda x: x.get(),
                        map(remoteServer.addone. async, range(100))),
                    range(1, 101))
예제 #10
0
#
# ============================================================

# mark-start::body
import time
import logging

import rsb

if __name__ == '__main__':
    # Pacify logger.
    logging.basicConfig()

    # Create a LocalServer object that exposes its methods under the
    # scope /example/server.
    with rsb.createLocalServer('/example/server') as server:

        # Create a function which processes requests and returns a
        # result. Note that the name of the function does not determine
        # the name of the exposed method. See addMethod below.
        def echo(x):
            return x

        # Add the function to the server under the name "echo".
        server.addMethod('echo', echo, str, str)

        # Wait for method calls by clients.
        while True:
            time.sleep(1)
# mark-end::body