def setUp(self):
"""
Starts a framework in separate process to advertise a helloimpl
remote service. Then starts a local framework to register the
TestEndpointEventListener
"""
print("EtcdDiscoveryListenerTest etcd_hostname={0},toppath={1}".format(
TEST_ETCD_HOSTNAME, TEST_ETCD_TOPPATH))
# start external framework that publishes remote service
self.status_queue = Queue()
self.publisher_process = WrappedProcess(
target=start_framework_for_advertise, args=[self.status_queue])
self.publisher_process.start()
state = self.status_queue.get(10)
self.assertEqual(state, "ready")
# start a local framework
self.framework = create_framework(
[
"pelix.ipopo.core",
"pelix.rsa.remoteserviceadmin", # RSA implementation
"tests.rsa.endpoint_event_listener",
"pelix.rsa.providers.discovery.discovery_etcd",
],
{
"etcd.hostname": TEST_ETCD_HOSTNAME,
"etcd.toppath": TEST_ETCD_TOPPATH,
},
)
self.framework.start()
# Start the framework and return TestEndpointEventListener
context = self.framework.get_bundle_context()
# Start an HTTP server, required by XML-RPC
with use_ipopo(context) as ipopo:
# create endpoint event listener
self.listener = ipopo.instantiate(
"etcd-test-endpoint-event-listener-factory",
"etcd-test-endpoint-event-listener",
{
TopologyManager.ENDPOINT_LISTENER_SCOPE:
ENDPOINT_LISTENER_SCOPE
},
)
def setUp(self):
"""
Starts a framework in separate process to advertise a helloimpl
remote service. Then starts a local framework to register the
TestEndpointEventListener
"""
print(
"EtcdDiscoveryListenerTest etcd_hostname={0},toppath={1}".format(
TEST_ETCD_HOSTNAME, TEST_ETCD_TOPPATH
)
)
# start external framework that publishes remote service
self.status_queue = Queue()
self.publisher_process = WrappedProcess(
target=start_framework_for_advertise, args=[self.status_queue]
)
self.publisher_process.start()
state = self.status_queue.get(10)
self.assertEqual(state, "ready")
# start a local framework
self.framework = create_framework(
[
"pelix.ipopo.core",
"pelix.rsa.remoteserviceadmin", # RSA implementation
"tests.rsa.endpoint_event_listener",
"pelix.rsa.providers.discovery.discovery_etcd",
],
{
"etcd.hostname": TEST_ETCD_HOSTNAME,
"etcd.toppath": TEST_ETCD_TOPPATH,
},
)
self.framework.start()
# Start the framework and return TestEndpointEventListener
context = self.framework.get_bundle_context()
# Start an HTTP server, required by XML-RPC
with use_ipopo(context) as ipopo:
# create endpoint event listener
self.listener = ipopo.instantiate(
"etcd-test-endpoint-event-listener-factory",
"etcd-test-endpoint-event-listener",
{
TopologyManager.ENDPOINT_LISTENER_SCOPE: ENDPOINT_LISTENER_SCOPE
},
)
def _run_test(self,
transport_bundle,
exporter_factory,
importer_factory,
test_kwargs=True):
"""
Runs a remote service call test
:param transport_bundle: Transport implementation bundle to use
:param exporter_factory: Name of the RS exporter factory
:param importer_factory: Name of the RS importer factory
:param test_kwargs: Test keyword arguments
:raise queue.Empty: Peer took to long to answer
:raise ValueError: Test failed
"""
# Define components
components = [(exporter_factory, "rs-exporter"),
(importer_factory, "rs-importer")]
# Start the remote framework
status_queue = Queue()
peer = WrappedProcess(target=self._export_framework,
args=(status_queue, transport_bundle,
components))
peer.start()
try:
# Wait for the ready state
state = status_queue.get(4)
self.assertEqual(state, "ready")
# Load the local framework (after the fork)
framework = self._load_framework(transport_bundle, components)
context = framework.get_bundle_context()
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is not None:
break
time.sleep(.5)
else:
self.fail("Remote Service not found")
# Get it
svc = context.get_service(svc_ref)
# Dummy call
result = svc.dummy()
state = status_queue.get(2)
self.assertEqual(state, "call-dummy")
self.assertIsNone(result,
"Dummy didn't returned None: {0}".format(result))
# Echo call
for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}):
result = svc.echo(value)
# Check state
state = status_queue.get(2)
self.assertEqual(state, "call-echo")
# Check result
self.assertEqual(result, value)
if test_kwargs:
# Keyword arguments
sample_text = "SomeSampleText"
# Test as-is with default arguments
result = svc.keywords(text=sample_text)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.upper())
# Test with keywords in the same order as positional arguments
result = svc.keywords(text=sample_text, to_lower=True)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.lower())
result = svc.keywords(text=sample_text, to_lower=False)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.upper())
# Test with keywords in a different order
# than positional arguments
result = svc.keywords(to_lower=True, text=sample_text)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.lower())
# Exception handling
try:
svc.error()
except:
# The error has been propagated
state = status_queue.get(2)
self.assertEqual(state, "call-error")
else:
self.fail("No exception raised calling 'error'")
# Call undefined method
try:
svc.undefined()
except:
# The error has been propagated: OK
pass
else:
self.fail("No exception raised calling an undefined method")
# Stop the peer
svc.stop()
# Wait for the peer to stop
state = status_queue.get(2)
self.assertEqual(state, "stopping")
# Wait a bit more, to let coverage save its files
time.sleep(.1)
finally:
# Stop everything (and delete the framework in any case
FrameworkFactory.delete_framework()
peer.terminate()
status_queue.close()
def _run_test(self,
discovery_bundle,
discovery_factory,
discovery_opts=None):
"""
Runs a remote service call test
:param discovery_bundle: Discovery implementation bundle to use
:param discovery_factory: Name of the discovery factory
:param discovery_opts: Initial parameters of the discovery component
:raise queue.Empty: Peer took to long to answer
:raise ValueError: Test failed
"""
transport_bundle = "pelix.remote.json_rpc"
# Define components
components = [
(pelix.remote.FACTORY_TRANSPORT_JSONRPC_EXPORTER, "rs-exporter"),
(pelix.remote.FACTORY_TRANSPORT_JSONRPC_IMPORTER, "rs-importer"),
(discovery_factory, "discovery", discovery_opts)
]
# Start the remote framework
status_queue = Queue()
peer = WrappedProcess(target=self._export_framework,
args=(status_queue, transport_bundle,
discovery_bundle, components))
peer.start()
try:
# Wait for the ready state
state = status_queue.get(4)
self.assertEqual(state, "ready")
# Load the local framework (after the fork)
framework = self._load_framework(transport_bundle,
discovery_bundle, components)
context = framework.get_bundle_context()
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is not None:
break
time.sleep(.5)
else:
self.fail("Remote Service not found")
# Get it
svc = context.get_service(svc_ref)
# Echo call
for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}):
result = svc.echo(value)
# Check state
state = status_queue.get(2)
self.assertEqual(state, "call-echo")
# Check result
self.assertEqual(result, value)
# Stop the peer
svc.stop()
# Wait for the peer to stop
state = status_queue.get(2)
self.assertEqual(state, "stopping")
# Wait a bit more, to let coverage save its files
peer.join(1)
# Check the remote service
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is None:
break
time.sleep(2)
else:
self.fail("Remote Service still registered")
finally:
# Stop everything (and delete the framework in any case
try:
FrameworkFactory.delete_framework()
except:
pass
peer.terminate()
status_queue.close()
class EtcdDiscoveryListenerTest(unittest.TestCase):
def setUp(self):
"""
Starts a framework in separate process to advertise a helloimpl
remote service. Then starts a local framework to register the
TestEndpointEventListener
"""
print("EtcdDiscoveryListenerTest etcd_hostname={0},toppath={1}".format(
TEST_ETCD_HOSTNAME, TEST_ETCD_TOPPATH))
# start external framework that publishes remote service
self.status_queue = Queue()
self.publisher_process = WrappedProcess(
target=start_framework_for_advertise, args=[self.status_queue])
self.publisher_process.start()
state = self.status_queue.get(10)
self.assertEqual(state, "ready")
# start a local framework
self.framework = create_framework(
[
"pelix.ipopo.core",
"pelix.rsa.remoteserviceadmin", # RSA implementation
"tests.rsa.endpoint_event_listener",
"pelix.rsa.providers.discovery.discovery_etcd",
],
{
"etcd.hostname": TEST_ETCD_HOSTNAME,
"etcd.toppath": TEST_ETCD_TOPPATH,
},
)
self.framework.start()
# Start the framework and return TestEndpointEventListener
context = self.framework.get_bundle_context()
# Start an HTTP server, required by XML-RPC
with use_ipopo(context) as ipopo:
# create endpoint event listener
self.listener = ipopo.instantiate(
"etcd-test-endpoint-event-listener-factory",
"etcd-test-endpoint-event-listener",
{
TopologyManager.ENDPOINT_LISTENER_SCOPE:
ENDPOINT_LISTENER_SCOPE
},
)
def tearDown(self):
"""
Cleans up external publishing framework for next test
"""
self.status_queue.put(None)
self.publisher_process.join(1)
self.status_queue.close()
self.status_queue = None
self.publisher = None
# Stop the framework
self.framework.stop()
pelix.framework.FrameworkFactory.delete_framework()
self.framework = None
def test_etcd_discover(self):
test_done_event = threading.Event()
def test_handler_1(endpoint_event, matched_filter):
self.assertTrue(matched_filter, ENDPOINT_LISTENER_SCOPE)
self.assertIsNotNone(endpoint_event, "endpoint_event is None")
self.assertTrue(isinstance(endpoint_event, EndpointEvent))
ee_type = endpoint_event.get_type()
self.assertTrue(ee_type == EndpointEvent.ADDED
or ee_type == EndpointEvent.REMOVED)
ee_ed = endpoint_event.get_endpoint_description()
self.assertTrue(isinstance(ee_ed, EndpointDescription))
self.assertIsNotNone(ee_ed.get_id(),
"endpoint_description id is None")
self.assertIsNotNone(
ee_ed.get_framework_uuid(),
"endpoint_description framework uuid is None",
)
interfaces = ee_ed.get_interfaces()
# test that service interfaces is not None and is of type list
self.assertIsNotNone(interfaces)
self.assertTrue(isinstance(interfaces, type([])))
self.assertTrue(
"org.eclipse.ecf.examples.hello.IHello" in interfaces)
# set the test_done_event, so tester thread will continue
test_done_event.set()
# set the handler to the test code above
self.listener.set_handler(test_handler_1)
# wait as much as 50 seconds to complete
test_done_event.wait(50)
def test_etcd_discover_remove(self):
test_done_event = threading.Event()
def test_handler_2(endpoint_event, matched_filter):
if endpoint_event.get_type() == EndpointEvent.ADDED:
# send shutdown to trigger the removal
self.status_queue.put(None)
elif endpoint_event.get_type() == EndpointEvent.REMOVED:
# do tests
self.assertTrue(matched_filter, ENDPOINT_LISTENER_SCOPE)
self.assertIsNotNone(endpoint_event, "endpoint_event is None")
self.assertTrue(isinstance(endpoint_event, EndpointEvent))
ee_ed = endpoint_event.get_endpoint_description()
self.assertTrue(isinstance(ee_ed, EndpointDescription))
self.assertIsNotNone(ee_ed.get_id(),
"endpoint_description id is None")
self.assertIsNotNone(
ee_ed.get_framework_uuid(),
"endpoint_description framework uuid is None",
)
interfaces = ee_ed.get_interfaces()
# test that service interfaces is not None and is of type list
self.assertIsNotNone(interfaces)
self.assertTrue(isinstance(interfaces, type([])))
self.assertTrue(
"org.eclipse.ecf.examples.hello.IHello" in interfaces)
# finally set the test_done_event, so tester thread will
# continue
test_done_event.set()
# set the handler to the test code above
self.listener.set_handler(test_handler_2)
# wait as much as 60 seconds to complete
test_done_event.wait(60)
def _run_test(self, discovery_bundle, discovery_factory,
discovery_opts=None):
"""
Runs a remote service call test
:param discovery_bundle: Discovery implementation bundle to use
:param discovery_factory: Name of the discovery factory
:param discovery_opts: Initial parameters of the discovery component
:raise queue.Empty: Peer took to long to answer
:raise ValueError: Test failed
"""
transport_bundle = "pelix.remote.json_rpc"
# Define components
components = [
(pelix.remote.FACTORY_TRANSPORT_JSONRPC_EXPORTER, "rs-exporter"),
(pelix.remote.FACTORY_TRANSPORT_JSONRPC_IMPORTER, "rs-importer"),
(discovery_factory, "discovery", discovery_opts)]
# Start the remote framework
status_queue = Queue()
peer = WrappedProcess(target=self._export_framework,
args=(status_queue, transport_bundle,
discovery_bundle, components))
peer.start()
try:
# Wait for the ready state
state = status_queue.get(4)
self.assertEqual(state, "ready")
# Load the local framework (after the fork)
framework = self._load_framework(
transport_bundle, discovery_bundle, components)
context = framework.get_bundle_context()
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is not None:
break
time.sleep(.5)
else:
self.fail("Remote Service not found")
# Get it
svc = context.get_service(svc_ref)
# Echo call
for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}):
result = svc.echo(value)
# Check state
state = status_queue.get(2)
self.assertEqual(state, "call-echo")
# Check result
self.assertEqual(result, value)
# Stop the peer
svc.stop()
# Wait for the peer to stop
state = status_queue.get(2)
self.assertEqual(state, "stopping")
# Wait a bit more, to let coverage save its files
peer.join(1)
# Check the remote service
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is None:
break
time.sleep(2)
else:
self.fail("Remote Service still registered")
finally:
# Stop everything (and delete the framework in any case
try:
FrameworkFactory.delete_framework()
except:
pass
peer.terminate()
status_queue.close()
def __run_test(self, transport_bundle, exporter_factory, importer_factory,
test_kwargs=True):
"""
Runs a remote service call test
:param transport_bundle: Transport implementation bundle to use
:param exporter_factory: Name of the RS exporter factory
:param importer_factory: Name of the RS importer factory
:param test_kwargs: Test keyword arguments
:raise queue.Empty: Peer took to long to answer
:raise ValueError: Test failed
"""
# Define components
components = [(exporter_factory, "rs-exporter"),
(importer_factory, "rs-importer")]
# Start the remote framework
status_queue = Queue()
peer = WrappedProcess(target=export_framework,
args=(status_queue, transport_bundle,
components))
peer.start()
try:
# Wait for the ready state
state = status_queue.get(4)
self.assertEqual(state, "ready")
# Load the local framework (after the fork)
framework = load_framework(transport_bundle, components)
context = framework.get_bundle_context()
# Look for the remote service
for _ in range(10):
svc_ref = context.get_service_reference(SVC_SPEC)
if svc_ref is not None:
break
time.sleep(.5)
else:
self.fail("Remote Service not found")
# Get it
svc = context.get_service(svc_ref)
# Dummy call
result = svc.dummy()
state = status_queue.get(2)
self.assertEqual(state, "call-dummy")
self.assertIsNone(result, "Dummy didn't returned None: {0}"
.format(result))
# Echo call
for value in (None, "Test", 42, [1, 2, 3], {"a": "b"}):
result = svc.echo(value)
# Check state
state = status_queue.get(2)
self.assertEqual(state, "call-echo")
# Check result
self.assertEqual(result, value)
if test_kwargs:
# Keyword arguments
sample_text = "SomeSampleText"
# Test as-is with default arguments
result = svc.keywords(text=sample_text)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.upper())
# Test with keywords in the same order as positional arguments
result = svc.keywords(text=sample_text, to_lower=True)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.lower())
result = svc.keywords(text=sample_text, to_lower=False)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.upper())
# Test with keywords in a different order
# than positional arguments
result = svc.keywords(to_lower=True, text=sample_text)
state = status_queue.get(2)
self.assertEqual(state, "call-keyword")
self.assertEqual(result, sample_text.lower())
# Exception handling
try:
svc.error()
except:
# The error has been propagated
state = status_queue.get(2)
self.assertEqual(state, "call-error")
else:
self.fail("No exception raised calling 'error'")
# Call undefined method
try:
svc.undefined()
except:
# The error has been propagated: OK
pass
else:
self.fail("No exception raised calling an undefined method")
# Stop the peer
svc.stop()
# Wait for the peer to stop
state = status_queue.get(2)
self.assertEqual(state, "stopping")
# Wait a bit more, to let coverage save its files
time.sleep(.1)
finally:
# Stop everything (and delete the framework in any case
FrameworkFactory.delete_framework()
peer.terminate()
status_queue.close()
class EtcdDiscoveryListenerTest(unittest.TestCase):
def setUp(self):
"""
Starts a framework in separate process to advertise a helloimpl
remote service. Then starts a local framework to register the
TestEndpointEventListener
"""
print(
"EtcdDiscoveryListenerTest etcd_hostname={0},toppath={1}".format(
TEST_ETCD_HOSTNAME, TEST_ETCD_TOPPATH
)
)
# start external framework that publishes remote service
self.status_queue = Queue()
self.publisher_process = WrappedProcess(
target=start_framework_for_advertise, args=[self.status_queue]
)
self.publisher_process.start()
state = self.status_queue.get(10)
self.assertEqual(state, "ready")
# start a local framework
self.framework = create_framework(
[
"pelix.ipopo.core",
"pelix.rsa.remoteserviceadmin", # RSA implementation
"tests.rsa.endpoint_event_listener",
"pelix.rsa.providers.discovery.discovery_etcd",
],
{
"etcd.hostname": TEST_ETCD_HOSTNAME,
"etcd.toppath": TEST_ETCD_TOPPATH,
},
)
self.framework.start()
# Start the framework and return TestEndpointEventListener
context = self.framework.get_bundle_context()
# Start an HTTP server, required by XML-RPC
with use_ipopo(context) as ipopo:
# create endpoint event listener
self.listener = ipopo.instantiate(
"etcd-test-endpoint-event-listener-factory",
"etcd-test-endpoint-event-listener",
{
TopologyManager.ENDPOINT_LISTENER_SCOPE: ENDPOINT_LISTENER_SCOPE
},
)
def tearDown(self):
"""
Cleans up external publishing framework for next test
"""
self.status_queue.put(None)
self.publisher_process.join(1)
self.status_queue.close()
self.status_queue = None
self.publisher = None
# Stop the framework
self.framework.stop()
pelix.framework.FrameworkFactory.delete_framework()
self.framework = None
def test_etcd_discover(self):
test_done_event = threading.Event()
def test_handler_1(endpoint_event, matched_filter):
self.assertTrue(matched_filter, ENDPOINT_LISTENER_SCOPE)
self.assertIsNotNone(endpoint_event, "endpoint_event is None")
self.assertTrue(isinstance(endpoint_event, EndpointEvent))
ee_type = endpoint_event.get_type()
self.assertTrue(
ee_type == EndpointEvent.ADDED
or ee_type == EndpointEvent.REMOVED
)
ee_ed = endpoint_event.get_endpoint_description()
self.assertTrue(isinstance(ee_ed, EndpointDescription))
self.assertIsNotNone(
ee_ed.get_id(), "endpoint_description id is None"
)
self.assertIsNotNone(
ee_ed.get_framework_uuid(),
"endpoint_description framework uuid is None",
)
interfaces = ee_ed.get_interfaces()
# test that service interfaces is not None and is of type list
self.assertIsNotNone(interfaces)
self.assertTrue(isinstance(interfaces, type([])))
self.assertTrue(
"org.eclipse.ecf.examples.hello.IHello" in interfaces
)
# set the test_done_event, so tester thread will continue
test_done_event.set()
# set the handler to the test code above
self.listener.set_handler(test_handler_1)
# wait as much as 50 seconds to complete
test_done_event.wait(50)
def test_etcd_discover_remove(self):
test_done_event = threading.Event()
def test_handler_2(endpoint_event, matched_filter):
if endpoint_event.get_type() == EndpointEvent.ADDED:
# send shutdown to trigger the removal
self.status_queue.put(None)
elif endpoint_event.get_type() == EndpointEvent.REMOVED:
# do tests
self.assertTrue(matched_filter, ENDPOINT_LISTENER_SCOPE)
self.assertIsNotNone(endpoint_event, "endpoint_event is None")
self.assertTrue(isinstance(endpoint_event, EndpointEvent))
ee_ed = endpoint_event.get_endpoint_description()
self.assertTrue(isinstance(ee_ed, EndpointDescription))
self.assertIsNotNone(
ee_ed.get_id(), "endpoint_description id is None"
)
self.assertIsNotNone(
ee_ed.get_framework_uuid(),
"endpoint_description framework uuid is None",
)
interfaces = ee_ed.get_interfaces()
# test that service interfaces is not None and is of type list
self.assertIsNotNone(interfaces)
self.assertTrue(isinstance(interfaces, type([])))
self.assertTrue(
"org.eclipse.ecf.examples.hello.IHello" in interfaces
)
# finally set the test_done_event, so tester thread will
# continue
test_done_event.set()
# set the handler to the test code above
self.listener.set_handler(test_handler_2)
# wait as much as 60 seconds to complete
test_done_event.wait(60)