def test_tacker_context_overwrite(self):
ctx1 = context.Context('user_id', 'tenant_id')
self.assertEqual(ctx1.request_id, local.store.context.request_id)
# If overwrite is not specified, request_id should be updated.
ctx2 = context.Context('user_id', 'tenant_id')
self.assertNotEqual(ctx2.request_id, ctx1.request_id)
self.assertEqual(ctx2.request_id, local.store.context.request_id)
# If overwrite is specified, request_id should be kept.
ctx3 = context.Context('user_id', 'tenant_id', overwrite=False)
self.assertNotEqual(ctx3.request_id, ctx2.request_id)
self.assertEqual(ctx2.request_id, local.store.context.request_id)
def setUp(self):
super(PolicyFileTestCase, self).setUp()
policy.reset()
self.addCleanup(policy.reset)
self.context = context.Context('fake', 'fake', is_admin=False)
self.target = {}
self.tempdir = self.useFixture(fixtures.TempDir())
def test_tacker_context_to_dict_with_name(self):
ctx = context.Context('user_id', 'tenant_id',
tenant_name='tenant_name', user_name='user_name')
ctx_dict = ctx.to_dict()
self.assertEqual('user_name', ctx_dict['user_name'])
self.assertEqual('tenant_name', ctx_dict['tenant_name'])
self.assertEqual('tenant_name', ctx_dict['project_name'])
def setUp(self):
super(TackerPolicyTestCase, self).setUp()
self.skipTest("Not ready yet")
policy.reset()
policy.init()
self.addCleanup(policy.reset)
self.admin_only_legacy = "role:admin"
self.admin_or_owner_legacy = "role:admin or tenant_id:%(tenant_id)s"
# Add a Fake 'something' resource to RESOURCE_ATTRIBUTE_MAP
attributes.RESOURCE_ATTRIBUTE_MAP.update(FAKE_RESOURCE)
self.rules = dict((k, common_policy.parse_rule(v)) for k, v in {
"context_is_admin": "role:admin",
"admin_or_network_owner": "rule:context_is_admin or "
"tenant_id:%(network:tenant_id)s",
"admin_or_owner": ("rule:context_is_admin or "
"tenant_id:%(tenant_id)s"),
"admin_only": "rule:context_is_admin",
"regular_user": "******",
"shared": "field:networks:shared=True",
"external": "field:networks:router:external=True",
"default": '@',
"create_network": "rule:admin_or_owner",
"create_network:shared": "rule:admin_only",
"update_network": '@',
"update_network:shared": "rule:admin_only",
"get_network": "rule:admin_or_owner or "
"rule:shared or "
"rule:external",
"create_port:mac": "rule:admin_or_network_owner",
"create_something": "rule:admin_or_owner",
"create_something:attr": "rule:admin_or_owner",
"create_something:attr:sub_attr_1": "rule:admin_or_owner",
"create_something:attr:sub_attr_2": "rule:admin_only",
"get_firewall_policy": "rule:admin_or_owner or "
"rule:shared",
"get_firewall_rule": "rule:admin_or_owner or "
"rule:shared"
}.items())
def fakepolicyinit():
common_policy.set_rules(common_policy.Rules(self.rules))
def remove_fake_resource():
del attributes.RESOURCE_ATTRIBUTE_MAP["%ss" % FAKE_RESOURCE_NAME]
self.patcher = mock.patch.object(tacker.policy,
'init',
new=fakepolicyinit)
self.patcher.start()
self.addCleanup(remove_fake_resource)
self.context = context.Context('fake', 'fake', roles=['user'])
plugin_klass = importutils.import_class(
"tacker.db.db_base_plugin_v2.TackerDbPluginV2")
self.manager_patcher = mock.patch('tacker.manager.TackerManager')
fake_manager = self.manager_patcher.start()
fake_manager_instance = fake_manager.return_value
fake_manager_instance.plugin = plugin_klass()
def _test_nonadmin_action_on_attr(self,
action,
attr,
value,
exception=None):
user_context = context.Context('', "user", roles=['user'])
self._test_action_on_attr(user_context, action, attr, value, exception)
def setUp(self):
super(PolicyTestCase, self).setUp()
self.skipTest("Not ready yet")
policy.reset()
self.addCleanup(policy.reset)
# NOTE(vish): preload rules to circumvent reloading from file
policy.init()
rules = {
"true": '@',
"example:allowed": '@',
"example:denied": '!',
"example:get_http": "http:http://www.example.com",
"example:my_file": "role:compute_admin or tenant_id:%(tenant_id)s",
"example:early_and_fail": "! and @",
"example:early_or_success": "@ or !",
"example:lowercase_admin": "role:admin or role:sysadmin",
"example:uppercase_admin": "role:ADMIN or role:sysadmin",
}
# NOTE(vish): then overload underlying rules
common_policy.set_rules(
common_policy.Rules(
dict((k, common_policy.parse_rule(v))
for k, v in rules.items())))
self.context = context.Context('fake', 'fake', roles=['member'])
self.target = {}
def __call__(self, req):
# Determine the user ID
user_id = req.headers.get('X_USER_ID')
if not user_id:
LOG.debug(_("X_USER_ID is not found in request"))
return webob.exc.HTTPUnauthorized()
# Determine the tenant
tenant_id = req.headers.get('X_PROJECT_ID')
# Suck out the roles
roles = [r.strip() for r in req.headers.get('X_ROLES', '').split(',')]
# Human-friendly names
tenant_name = req.headers.get('X_PROJECT_NAME')
user_name = req.headers.get('X_USER_NAME')
# Use request_id if already set
req_id = req.environ.get(request_id.ENV_REQUEST_ID)
# Create a context with the authentication data
ctx = context.Context(user_id,
tenant_id,
roles=roles,
user_name=user_name,
tenant_name=tenant_name,
request_id=req_id)
# Inject the context...
req.environ['tacker.context'] = ctx
return self.application
def test_tacker_context_get_admin_context_not_update_local_store(self):
ctx = context.Context('user_id', 'tenant_id')
req_id_before = local.store.context.request_id
self.assertEqual(ctx.request_id, req_id_before)
ctx_admin = context.get_admin_context()
self.assertEqual(req_id_before, local.store.context.request_id)
self.assertNotEqual(req_id_before, ctx_admin.request_id)
def test_tacker_context_get_admin_context_not_update_local_store(self):
ctx = context.Context('user_id', 'tenant_id')
req_id_before = oslo_context.get_current().request_id
self.assertEqual(req_id_before, ctx.request_id)
ctx_admin = context.get_admin_context()
self.assertEqual(req_id_before, oslo_context.get_current().request_id)
self.assertNotEqual(req_id_before, ctx_admin.request_id)
def test_ignore_case_role_check(self):
lowercase_action = "example:lowercase_admin"
uppercase_action = "example:uppercase_admin"
# NOTE(dprince) we mix case in the Admin role here to ensure
# case is ignored
admin_context = context.Context('admin', 'fake', roles=['AdMiN'])
policy.enforce(admin_context, lowercase_action, self.target)
policy.enforce(admin_context, uppercase_action, self.target)
def test_tacker_context_elevated_retains_request_id(self):
ctx = context.Context('user_id', 'tenant_id')
self.assertFalse(ctx.is_admin)
req_id_before = ctx.request_id
elevated_ctx = ctx.elevated()
self.assertTrue(elevated_ctx.is_admin)
self.assertEqual(req_id_before, elevated_ctx.request_id)
def test_tacker_context_create_with_name(self):
ctx = context.Context('user_id', 'tenant_id',
tenant_name='tenant_name', user_name='user_name')
# Check name is set
self.assertEqual('user_name', ctx.user_name)
self.assertEqual('tenant_name', ctx.tenant_name)
# Check user/tenant contains its ID even if user/tenant_name is passed
self.assertEqual('user_id', ctx.user)
self.assertEqual('tenant_id', ctx.tenant)
def test_tacker_context_create(self):
ctx = context.Context('user_id', 'tenant_id')
self.assertEqual('user_id', ctx.user_id)
self.assertEqual('tenant_id', ctx.project_id)
self.assertEqual('tenant_id', ctx.tenant_id)
self.assertThat(ctx.request_id, matchers.StartsWith('req-'))
self.assertEqual('user_id', ctx.user)
self.assertEqual('tenant_id', ctx.tenant)
self.assertIsNone(ctx.user_name)
self.assertIsNone(ctx.tenant_name)
def deserialize_context(self, ctxt):
rpc_ctxt_dict = ctxt.copy()
user_id = rpc_ctxt_dict.pop('user_id', None)
if not user_id:
user_id = rpc_ctxt_dict.pop('user', None)
tenant_id = rpc_ctxt_dict.pop('tenant_id', None)
if not tenant_id:
tenant_id = rpc_ctxt_dict.pop('project_id', None)
return context.Context(user_id, tenant_id,
load_admin_roles=False, **rpc_ctxt_dict)
def test_tacker_context_to_dict(self):
ctx = context.Context('user_id', 'tenant_id')
ctx_dict = ctx.to_dict()
self.assertEqual('user_id', ctx_dict['user_id'])
self.assertEqual('tenant_id', ctx_dict['project_id'])
self.assertEqual(ctx.request_id, ctx_dict['request_id'])
self.assertEqual('user_id', ctx_dict['user'])
self.assertEqual('tenant_id', ctx_dict['tenant'])
self.assertIsNone(ctx_dict['user_name'])
self.assertIsNone(ctx_dict['tenant_name'])
self.assertIsNone(ctx_dict['project_name'])
def setUp(self):
super(DefaultPolicyTestCase, self).setUp()
policy.reset()
policy.init()
self.addCleanup(policy.reset)
self.rules = {
"default": '',
"example:exist": '!',
}
self._set_rules('default')
self.context = context.Context('fake', 'fake')
def test_tacker_context_create_with_request_id(self):
ctx = context.Context('user_id', 'tenant_id', request_id='req_id_xxx')
self.assertEqual('req_id_xxx', ctx.request_id)
def test_tacker_context_create_logs_unknown_kwarg(self):
with mock.patch.object(context.LOG, 'debug') as mock_log:
context.Context('user_id', 'tenant_id', foo=None)
self.assertEqual(1, mock_log.call_count)
class TestMgmtProxyDriver(test_rpc.TestMgmtRpcDriver):
_TENANT_ID = _uuid()
_CONTEXT = context.Context('', _TENANT_ID)
_NETWORK_ID = _uuid(),
_SUBNET_ID = _uuid()
_DEVICE_PORT_ID = _uuid()
_DEVICE = {
'id':
_uuid(),
'mgmt_address':
'device-address',
'service_context': [{
'network_id': _NETWORK_ID,
'port_id': _DEVICE_PORT_ID,
'role': 'mgmt',
}],
}
_PORT_ID = _uuid()
_IP_ADDRESS = '1.1.1.1'
_PORT = {
'id': _PORT_ID,
'fixed_ips': [{
'subnet_id': _SUBNET_ID,
'ip_address': _IP_ADDRESS,
}],
}
_PROXY_ID = [_uuid(), _uuid(), _uuid(), _uuid()]
_NS_PROXY_ID = [_uuid(), _uuid(), _uuid(), _uuid()]
def setUp(self):
super(TestMgmtProxyDriver, self).setUp()
self.mock_proxy_api_p = mock.patch(
'tacker.vm.proxy_api.ServiceVMPluginApi')
self.mock_proxy_api = self.mock_proxy_api_p.start()
mock_proxy_api_instance = mock.Mock()
self.mock_proxy_api.return_value = mock_proxy_api_instance
self.mock_proxy_api_instance = mock_proxy_api_instance
mock_proxy_api_instance.create_namespace_agent.return_value = (
self._PORT_ID)
mock_proxy_api_instance.create_rpc_proxy = mock.Mock(
side_effect=self._PROXY_ID)
mock_proxy_api_instance.create_rpc_namespace_proxy = mock.Mock(
side_effect=self._NS_PROXY_ID)
self.plugin.proxy_api = proxy_api.ServiceVMPluginApi('fake-topic')
self.plugin._core_plugin.get_port.return_value = self._PORT
self.mgmt_driver = proxy.AgentRpcProxyMGMTDriver()
def test_mgmt_create_post_delete_post(self):
mgmt_driver = self.mgmt_driver
mock_instance = self.mock_proxy_api_instance
mgmt_driver.mgmt_create_post(self.plugin, self._CONTEXT, self._DEVICE)
mock_instance.create_namespace_agent.assert_called_once_with(
self.plugin._core_plugin, self._CONTEXT, self._NETWORK_ID)
target = 'topic=%s,server=%s' % (topics.SERVICEVM_AGENT,
self._DEVICE['id'])
mock_instance.create_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, target, target, 'receive'),
mock.call(self._CONTEXT, self._PORT_ID, target, target, 'send')
])
dst_transport_url = cfg.CONF.dst_transport_url % {
'host': self._IP_ADDRESS
}
mock_instance.create_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'receive'),
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'send')
])
mgmt_address = mgmt_driver.mgmt_address(self.plugin, self._CONTEXT,
self._DEVICE)
self.assertEqual(
mgmt_address,
'%s.%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id']))
mgmt_driver.mgmt_call(self.plugin, self._CONTEXT, self._DEVICE,
self._KWARGS)
msg = {
'args': self._KWARGS['kwargs'],
'namespace': None,
'method': 'action-name'
}
self.mock_rpc_proxy_cast.assert_called_once_with(
self._CONTEXT, msg, topic='device-address')
mgmt_driver.mgmt_delete_post(self.plugin, self._CONTEXT, self._DEVICE)
mock_instance.destroy_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[1]),
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[0])
])
mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[1]),
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[0])
])
mock_instance.destroy_namespace_agent.assert_called_once_with(
self.plugin._core_plugin, self._CONTEXT, self._PORT_ID)
def test_mgmt_service_create_pre_delete_post(self):
mgmt_driver = self.mgmt_driver
mock_instance = self.mock_proxy_api_instance
mgmt_driver.mgmt_create_post(self.plugin, self._CONTEXT, self._DEVICE)
mock_instance.create_namespace_agent.assert_called_once_with(
self.plugin._core_plugin, self._CONTEXT, self._NETWORK_ID)
target = 'topic=%s,server=%s' % (topics.SERVICEVM_AGENT,
self._DEVICE['id'])
mock_instance.create_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, mock.ANY, target, target, 'receive'),
mock.call(self._CONTEXT, mock.ANY, target, target, 'send')
])
dst_transport_url = cfg.CONF.dst_transport_url % {
'host': self._IP_ADDRESS
}
mock_instance.create_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'receive'),
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'send')
])
mock_instance.create_rpc_proxy.reset_mock()
mock_instance.create_rpc_namespace_proxy.reset_mock()
mgmt_driver.mgmt_service_create_pre(self.plugin, self._CONTEXT,
self._DEVICE,
self._SERVICE_INSTANCE)
target = 'topic=%s-%s,server=%s' % (topics.SERVICEVM_AGENT,
self._DEVICE['id'],
self._SERVICE_INSTANCE['id'])
mock_instance.create_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, target, target, 'receive'),
mock.call(self._CONTEXT, self._PORT_ID, target, target, 'send')
])
dst_transport_url = cfg.CONF.dst_transport_url % {
'host': self._IP_ADDRESS
}
mock_instance.create_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'receive'),
mock.call(self._CONTEXT, self._PORT_ID, target, dst_transport_url,
target, 'send')
])
mgmt_service_address = mgmt_driver.mgmt_service_address(
self.plugin, self._CONTEXT, self._DEVICE, self._SERVICE_INSTANCE)
self.assertEqual(
mgmt_service_address,
'%s-%s.%s' % (topics.SERVICEVM_AGENT, self._DEVICE['id'],
self._SERVICE_INSTANCE['id']))
mgmt_driver.mgmt_service_call(self.plugin, self._CONTEXT, self._DEVICE,
self._SERVICE_INSTANCE, self._KWARGS)
msg = {
'args': self._KWARGS['kwargs'],
'namespace': None,
'method': 'action-name'
}
self.mock_rpc_proxy_cast.assert_called_once_with(
self._CONTEXT, msg, topic='service-instance-address')
mgmt_driver.mgmt_service_delete_post(self.plugin, self._CONTEXT,
self._DEVICE,
self._SERVICE_INSTANCE)
mock_instance.destroy_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[3]),
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[2])
])
mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[3]),
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[2])
])
mock_instance.destroy_rpc_proxy.reset.mock()
mock_instance.destroy_rpc_namespace_proxy.reset_mock()
mgmt_driver.mgmt_delete_post(self.plugin, self._CONTEXT, self._DEVICE)
mock_instance.destroy_rpc_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[1]),
mock.call(self._CONTEXT, self._PORT_ID, self._PROXY_ID[0])
])
mock_instance.destroy_rpc_namespace_proxy.assert_has_calls([
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[1]),
mock.call(self._CONTEXT, self._PORT_ID, self._NS_PROXY_ID[0])
])
mock_instance.destroy_namespace_agent.assert_called_once_with(
self.plugin._core_plugin, self._CONTEXT, self._PORT_ID)
class TestVMService(base.BaseTestCase):
ctxt = context.Context('user', 'tenant')
network_id = str(uuid.uuid4())
subnet_id = str(uuid.uuid4())
port_id = str(uuid.uuid4())
mac_address = '00:00:00:00:00:01'
netmask = '/24'
network_address = '192.168.1.0'
cidr = network_address + netmask
ip_address = '192.168.1.3'
gw_address = '192.168.1.1'
port = {
'id': port_id,
'network_id': network_id,
'mac_address': mac_address,
'fixed_ips': [{'subnet_id': subnet_id,
'ip_address': ip_address,
'subnet': {
'cidr': cidr,
'ip_version': 4,
'gateway_ip': gw_address}}]
}
def setUp(self):
super(TestVMService, self).setUp()
conf = cfg.CONF
# NOTE(yamahata): work around. rpc driver-dependent config variables
# remove this line once tacker are fully ported to oslo.messaging
from tacker.openstack.common import rpc
conf.unregister_opts(rpc.rpc_opts)
conf.register_opts(transport._transport_opts)
conf.set_override('rpc_backend',
'tacker.openstack.common.rpc.impl_fake')
self.addCleanup(mock.patch.stopall)
self.mock_get_transport_p = mock.patch('oslo.messaging.get_transport')
self.mock_get_transport = self.mock_get_transport_p.start()
self.mock_import_object_p = mock.patch(
'tacker.openstack.common.importutils.import_object')
self.mock_import_object = self.mock_import_object_p.start()
self.vif_driver = mock.create_autospec(
tacker.agent.linux.interface.NullDriver)
self.mock_import_object.return_value = self.vif_driver
self.agent = agent.ServiceVMAgent('host', conf=conf)
self.mock_process_manager_p = mock.patch.object(
tacker.agent.linux.external_process, 'ProcessManager')
self.mock_process_manager = self.mock_process_manager_p.start()
self.mock_process_manager_instance = (
self.mock_process_manager.return_value)
self.mock_device_exists_p = mock.patch(
'tacker.agent.linux.ip_lib.device_exists')
self.mock_device_exists = self.mock_device_exists_p.start()
self.mock_device_exists.return_value = False
self.mock_ipwrapper_p = mock.patch.object(tacker.agent.linux.ip_lib,
'IPWrapper')
self.mock_ipwrapper = self.mock_ipwrapper_p.start()
self.mock_ipwrapper_instance = self.mock_ipwrapper.return_value
self.mock_rpc_client_p = mock.patch.object(oslo.messaging.rpc,
'RPCClient')
self.mock_rpc_client = self.mock_rpc_client_p.start()
self.mock_rpc_client_instance = self.mock_rpc_client.return_value
def test_create_destroy_namespace_agent(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
self.vif_driver.plug.assert_called_once_with(
self.network_id, self.port_id, mock.ANY, self.mac_address,
namespace=mock.ANY)
self.vif_driver.init_l3.assert_called_once_with(
mock.ANY, [self.ip_address + self.netmask], namespace=mock.ANY)
self.mock_ipwrapper.assert_called_once_with(
mock.ANY, namespace=mock.ANY)
self.mock_ipwrapper_instance.netns.execute.assert_called_once_with(
['route', 'add', 'default', 'gw', self.gw_address],
check_exit_code=False)
self.assertTrue(self.mock_process_manager_instance.enable.called)
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
self.vif_driver.unplug.assert_called_once_with(mock.ANY,
namespace=mock.ANY)
self.mock_process_manager_instance.disable.assert_called_once_with()
def test_create_rpc_proxy_wrong_port_id(self):
func = lambda: self.agent.create_rpc_proxy(
self.ctxt, self.port_id, 'topic=src_topic,server=src_server',
'topic=dst_topic,server=dst_server', 'wrong-direction')
self.assertRaises(RuntimeError, func)
def test_create_rpc_proxy_wrong_direction(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
func = lambda: self.agent.create_rpc_proxy(
self.ctxt, self.port_id, 'topic=src_topic,server=src_server',
'topic=dst_topic,server=dst_server', 'wrong-direction')
self.assertRaises(RuntimeError, func)
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
def test_create_destroy_rpc_proxy_send(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
with mock.patch('oslo.messaging.proxy.get_proxy_server'
) as mock_get_proxy_server:
mock_transport = self.mock_get_transport.return_value
mock_instance = mock_get_proxy_server.return_value
proxy_id = self.agent.create_rpc_proxy(
self.ctxt, self.port_id, 'topic=src_topic,server=src_server',
'topic=dst_topic,server=dst_server', 'send')
src_target = target.Target(topic='src_topic', server='src_server')
dst_target = target.Target(topic='dst_topic', server='dst_server')
mock_get_proxy_server.assert_called_once_with(
mock_transport, src_target, None,
mock_transport, dst_target, None, executor=mock.ANY)
mock_instance.start.assert_called_once_with()
self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id)
mock_instance.stop.assert_called_once_with()
mock_instance.wait.assert_called_once_with()
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
def test_create_destroy_rpc_proxy_receive(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
with mock.patch('oslo.messaging.proxy.get_proxy_server'
) as mock_get_proxy_server:
mock_transport = self.mock_get_transport.return_value
mock_instance = mock_get_proxy_server.return_value
proxy_id = self.agent.create_rpc_proxy(
self.ctxt, self.port_id, 'topic=src_topic,server=src_server',
'topic=dst_topic,server=dst_server', 'receive')
src_target = target.Target(topic='src_topic', server='src_server')
dst_target = target.Target(topic='dst_topic', server='dst_server')
mock_get_proxy_server.assert_called_once_with(
mock_transport, dst_target, None,
mock_transport, src_target, None, executor=mock.ANY)
mock_instance.start.assert_called_once_with()
self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id)
mock_instance.stop.assert_called_once_with()
mock_instance.wait.assert_called_once_with()
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
def test_create_destroy_rpc_proxy(self):
self.mock_device_exists.return_value = False
self.agent.create_namespace_agent(self.ctxt, self.port)
with mock.patch('oslo.messaging.proxy.get_proxy_server'
) as mock_get_proxy_server:
mock_transport = self.mock_get_transport.return_value
proxy_id_send = self.agent.create_rpc_proxy(
self.ctxt, self.port_id,
'topic=src_topic_send,server=src_server_send',
'topic=dst_topic_send,server=dst_server_send', 'send')
src_target_send = target.Target(topic='src_topic_send',
server='src_server_send')
dst_target_send = target.Target(topic='dst_topic_send',
server='dst_server_send')
self.agent.create_rpc_proxy(
self.ctxt, self.port_id,
'topic=src_topic_receive,server=src_server_receive',
'topic=dst_topic_receive,server=dst_server_receive', 'receive')
src_target_recv = target.Target(topic='src_topic_receive',
server='src_server_receive')
dst_target_recv = target.Target(topic='dst_topic_receive',
server='dst_server_receive')
self.agent.destroy_rpc_proxy(self.ctxt,
self.port_id, proxy_id_send)
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
mock_get_proxy_server.assert_has_calls([
mock.call(mock_transport, src_target_send, None,
mock_transport, dst_target_send, None,
executor=mock.ANY),
mock.call().start(),
mock.call(mock_transport, dst_target_recv, None,
mock_transport, src_target_recv, None,
executor=mock.ANY),
mock.call().start(),
mock.call().stop(), mock.call().wait(),
mock.call().stop(), mock.call().wait()])
def _test_create_destroy_rpc_namespace_proxy_direction(self, direction):
self.agent.create_namespace_agent(self.ctxt, self.port)
src_target = 'topic=src_topic,server=src_server'
dst_transport_url = 'rabbit://*****:*****@host:5672'
dst_target = 'topic=dst_topic,server=dst_server'
ns_proxy_id = self.agent.create_rpc_namespace_proxy(
self.ctxt, self.port_id, src_target,
dst_transport_url, dst_target, direction)
kwargs = {
'src_target': src_target,
'dst_transport_url': dst_transport_url,
'dst_target': dst_target,
'direction': direction,
}
self.mock_rpc_client_instance.call.assert_called_once_with(
{}, 'create_rpc_namespace_proxy', **kwargs)
self.agent.destroy_rpc_namespace_proxy(self.ctxt,
self.port_id, ns_proxy_id)
self.mock_rpc_client_instance.call.assert_has_calls([
mock.call({}, 'create_rpc_namespace_proxy', **kwargs),
mock.call({}, 'destroy_rpc_namespace_proxy',
namespace_proxy_id=ns_proxy_id)])
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
def test_create_destroy_rpc_namespace_proxy_send(self):
self._test_create_destroy_rpc_namespace_proxy_direction('send')
def test_create_destroy_rpc_namespace_proxy_receive(self):
self._test_create_destroy_rpc_namespace_proxy_direction('receive')
def test_create_destroy_rpc_namespace_proxy(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
src_target_send = 'topic=src_topic_send,server=src_server_send'
dst_transport_url_send = 'rabbit://*****:*****@sendhost:5672'
dst_target_send = 'topic=dst_topic_send,server=dst_server_send'
direction_send = 'send'
ns_proxy_id_send = self.agent.create_rpc_namespace_proxy(
self.ctxt, self.port_id, src_target_send,
dst_transport_url_send, dst_target_send, direction_send)
kwargs_send = {
'src_target': src_target_send,
'dst_transport_url': dst_transport_url_send,
'dst_target': dst_target_send,
'direction': direction_send,
}
src_target_recv = 'topic=src_topic_recv,server=src_server_recv'
dst_transport_url_recv = 'rabbit://*****:*****@recvhost:5672'
dst_target_recv = 'topic=dst_topic_recv,server=dst_server_recv'
direction_recv = 'receive'
self.agent.create_rpc_namespace_proxy(
self.ctxt, self.port_id, src_target_recv,
dst_transport_url_recv, dst_target_recv, direction_recv)
kwargs_recv = {
'src_target': src_target_recv,
'dst_transport_url': dst_transport_url_recv,
'dst_target': dst_target_recv,
'direction': direction_recv,
}
self.agent.destroy_rpc_namespace_proxy(self.ctxt,
self.port_id, ns_proxy_id_send)
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
self.mock_rpc_client_instance.call.assert_has_calls([
mock.call({}, 'create_rpc_namespace_proxy', **kwargs_send),
mock.call({}, 'create_rpc_namespace_proxy', **kwargs_recv),
mock.call({}, 'destroy_rpc_namespace_proxy',
namespace_proxy_id=ns_proxy_id_send),
mock.call({}, 'destroy_namespace_agent')])
def test_context_with_tacker_context(self):
ctxt = context.Context('fake_user', 'fake_tenant')
self.req.environ['tacker.context'] = ctxt
self.assertEqual(self.req.context, ctxt)
def test_context_with_tacker_context(self):
self.skip("Not ready yet")
ctxt = context.Context('fake_user', 'fake_tenant')
self.req.environ['tacker.context'] = ctxt
self.assertEqual(ctxt, self.req.context)
