def process_request(self, req):
# We only handle POST requests
if req.method != 'POST':
return
# Extract webhook (receiver) ID and params
results = self._parse_url(req.url)
if not results:
return
(receiver_id, params) = results
api_version = str(req.version_request)
ctx = context.RequestContext(is_admin=True, api_version=api_version)
req.context = ctx
obj = util.parse_request(
'ReceiverGetRequest', req, {'identity': receiver_id})
rpcc = rpc.EngineClient()
receiver = rpcc.call(ctx, 'receiver_get', obj)
svc_ctx = context.get_service_credentials()
kwargs = {
'auth_url': svc_ctx['auth_url'],
'username': svc_ctx['username'],
'user_domain_name': svc_ctx['user_domain_name'],
'password': svc_ctx['password']
}
kwargs.update(receiver['actor'])
# Get token and fill it into the request header
token = self._get_token(**kwargs)
req.headers['X-Auth-Token'] = token
def test_cast(self, mock_client):
client = mock.Mock()
mock_client.return_value = client
method = 'fake_method'
kwargs = {'key': 'value'}
rpcapi = rpc_client.EngineClient()
msg = rpcapi.make_msg(method, **kwargs)
# with no version
res = rpcapi.cast(self.context, msg)
self.assertEqual(client, rpcapi._client)
client.cast.assert_called_once_with(self.context,
'fake_method',
key='value')
self.assertEqual(res, client.cast.return_value)
# with version
res = rpcapi.cast(self.context, msg, version='123')
client.prepare.assert_called_once_with(version='123')
new_client = client.prepare.return_value
new_client.cast.assert_called_once_with(self.context,
'fake_method',
key='value')
self.assertEqual(res, new_client.cast.return_value)
def process_request(self, req):
# We only handle POST requests
if req.method != 'POST':
return
# Extract webhook (receiver) ID and params
results = self._parse_url(req.url)
if not results:
return
(receiver_id, params) = results
dbctx = context.RequestContext(is_admin=True)
rpcc = rpc.EngineClient()
receiver = rpcc.receiver_get(dbctx, receiver_id, project_safe=False)
svc_ctx = context.get_service_context()
kwargs = {
'auth_url': svc_ctx['auth_url'],
'username': svc_ctx['username'],
'user_domain_name': svc_ctx['user_domain_name'],
'password': svc_ctx['password']
}
kwargs.update(receiver['actor'])
# Get token and fill it into the request header
token = self._get_token(**kwargs)
req.headers['X-Auth-Token'] = token
def __init__(self, project_id, cluster_id):
self.filter_rule = messaging.NotificationFilter(
publisher_id='^compute.*',
event_type='^compute\.instance\..*',
context={'project_id': '^%s$' % project_id})
self.project_id = project_id
self.cluster_id = cluster_id
self.rpc = rpc_client.EngineClient()
def setUp(self):
messaging.setup("fake://", optional=True)
self.addCleanup(messaging.cleanup)
self.context = utils.dummy_context()
# self.stubs = stubout.StubOutForTesting()
self.rpcapi = rpc_client.EngineClient()
super(EngineRpcAPITestCase, self).setUp()
def __init__(self, project_id, cluster_id, recover_action):
self.filter_rule = messaging.NotificationFilter(
publisher_id='^orchestration.*',
event_type='^orchestration\.stack\..*',
context={'project_id': '^%s$' % project_id})
self.project_id = project_id
self.cluster_id = cluster_id
self.rpc = rpc_client.EngineClient()
self.recover_action = recover_action
def __init__(self, project_id, engine_id, recover_action):
self.filter_rule = messaging.NotificationFilter(
publisher_id='^orchestration.*',
event_type='^orchestration\.stack\..*',
context={'project_id': '^%s$' % project_id})
self.project_id = project_id
self.engine_id = engine_id
self.rpc = rpc_client.EngineClient()
self.recover_action = recover_action
self.exchange = cfg.CONF.health_manager.heat_control_exchange
self.target = messaging.Target(topic='notifications',
exchange=self.exchange)
def __init__(self, engine_service, topic, version):
super(HealthManager, self).__init__()
self.TG = threadgroup.ThreadGroup()
self.engine_id = engine_service.engine_id
self.topic = topic
self.version = version
self.ctx = context.get_admin_context()
self.rpc_client = rpc_client.EngineClient()
self.rt = {
'registries': [],
}
def __init__(self, project_id, cluster_id, recover_action):
super(NovaNotificationEndpoint, self).__init__(project_id, cluster_id,
recover_action)
self.filter_rule = messaging.NotificationFilter(
publisher_id='^compute.*',
event_type='^compute\.instance\..*',
context={'project_id': '^%s$' % project_id})
self.rpc = rpc_client.EngineClient()
self.target = messaging.Target(
topic=cfg.CONF.health_manager.nova_notification_topic,
exchange=cfg.CONF.health_manager.nova_control_exchange,
)
def __init__(self, engine_service, topic, version):
super(HealthManager, self).__init__()
self.TG = threadgroup.ThreadGroup(
thread_pool_size=cfg.CONF.health_manager_thread_pool_size)
self.engine_id = engine_service.engine_id
self.topic = topic
self.version = version
self.ctx = context.get_admin_context()
self.rpc_client = rpc_client.EngineClient()
self.health_registry = RuntimeHealthRegistry(ctx=self.ctx,
engine_id=self.engine_id,
thread_group=self.TG)
def test_call(self, mock_client):
client = mock.Mock()
mock_client.return_value = client
method = 'fake_method'
req = mock.Mock()
rpcapi = rpc_client.EngineClient()
# with no version
res = rpcapi.call(self.context, method, req)
self.assertEqual(client, rpcapi._client)
client.call.assert_called_once_with(self.context, 'fake_method',
req=req)
self.assertEqual(res, client.call.return_value)
def test_call_with_version(self, mock_client):
client = mock.Mock()
mock_client.return_value = client
method = 'fake_method'
req = mock.Mock()
rpcapi = rpc_client.EngineClient()
# with version
res = rpcapi.call(self.context, method, req, version='123')
rpcapi._client.prepare.assert_called_once_with(version='123')
new_client = client.prepare.return_value
new_client.call.assert_called_once_with(self.context, 'fake_method',
req=req)
self.assertEqual(res, new_client.call.return_value)
def _get_trust(self, req):
"""List trusts with current user as the trustor.
:param req: The WSGI request object.
:return: ID of the trust or exception of InternalError.
"""
rpcc = rpc.EngineClient()
ctx = req.context
params = {'user': ctx.user_id, 'project': ctx.project_id}
obj = util.parse_request('CredentialGetRequest', req, params)
res = rpcc.call(ctx, 'credential_get', obj)
if res:
trust_id = res.get('trust', None)
if trust_id:
return trust_id
params = {
'auth_url': ctx.auth_url,
'token': ctx.auth_token,
'project_id': ctx.project_id,
'user_id': ctx.user_id,
}
kc = driver_base.SenlinDriver().identity(params)
service_cred = context.get_service_credentials()
admin_id = kc.get_user_id(**service_cred)
try:
trust = kc.trust_get_by_trustor(ctx.user_id, admin_id,
ctx.project_id)
except exception.InternalError as ex:
if ex.code == 400:
trust = None
else:
raise
if not trust:
# Create a trust if no existing one found
trust = kc.trust_create(ctx.user_id, admin_id, ctx.project_id,
ctx.roles)
# If credential not exists, create it, otherwise update it.
cred = {'openstack': {'trust': trust.id}}
params = {'cred': cred}
obj = util.parse_request('CredentialCreateRequest', req, params)
rpcc.call(ctx, 'credential_create', obj)
return trust.id
def __init__(self, ctx, engine_id, cluster_id, check_type, interval,
node_update_timeout, params, enabled):
self.rpc_client = rpc_client.EngineClient()
self.ctx = ctx
self.engine_id = engine_id
self.cluster_id = cluster_id
self.check_type = check_type
self.interval = interval
self.node_update_timeout = node_update_timeout
self.params = params
self.enabled = enabled
self.timer = None
self.listener = None
self.health_check_types = []
self.recover_action = {}
self.type = None
self.get_health_check_types()
self.get_recover_actions()
def _get_trust(self, ctx):
"""List trusts with current user as the trustor.
:param ctx: The requesting context.
:return: ID of the trust or exception of InternalError.
"""
rpcc = rpc.EngineClient()
res = rpcc.credential_get(ctx)
if res:
trust_id = res.get('trust', None)
if trust_id:
return trust_id
params = {
'auth_url': ctx.auth_url,
'token': ctx.auth_token,
'project_id': ctx.project,
'user_id': ctx.user,
}
kc = driver_base.SenlinDriver().identity(params)
service_cred = context.get_service_context()
admin_id = kc.get_user_id(**service_cred)
try:
trust = kc.trust_get_by_trustor(ctx.user, admin_id, ctx.project)
except exception.InternalError as ex:
if ex.code == 400:
trust = None
else:
raise ex
if not trust:
# Create a trust if no existing one found
trust = kc.trust_create(ctx.user, admin_id, ctx.project, ctx.roles)
# If credential not exists, create it, otherwise update it.
rpcc.credential_create(ctx, trust.id)
return trust.id
def process_request(self, req):
# We only handle POST requests
if req.method != 'POST':
return
# Extract webhook (receiver) ID and params
results = self._parse_url(req.url)
if not results:
return
(receiver_id, params) = results
dbctx = context.RequestContext(is_admin=True)
rpcc = rpc.EngineClient()
try:
norm_req = obj_base.SenlinObject.normalize_req(
'ReceiverGetRequest', {'identity': receiver_id})
obj = vorr.ReceiverGetRequest.obj_from_primitive(norm_req)
jsonschema.validate(norm_req, obj.to_json_schema())
except (ValueError) as ex:
raise exc.HTTPBadRequest(six.text_type(ex))
except jsonschema.exceptions.ValidationError as ex:
raise exc.HTTPBadRequest(six.text_type(ex.message))
receiver = rpcc.call2(dbctx, 'receiver_get', obj)
svc_ctx = context.get_service_context()
kwargs = {
'auth_url': svc_ctx['auth_url'],
'username': svc_ctx['username'],
'user_domain_name': svc_ctx['user_domain_name'],
'password': svc_ctx['password']
}
kwargs.update(receiver['actor'])
# Get token and fill it into the request header
token = self._get_token(**kwargs)
req.headers['X-Auth-Token'] = token
def __init__(self, options):
self.options = options
self.rpc_client = rpc_client.EngineClient()
