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()