def test_request_context_init(self):
ctx = context.RequestContext(
auth_token=self.ctx.get('auth_token'),
auth_token_info=self.ctx.get('auth_token_info'),
user=self.ctx.get('user'),
user_name=self.ctx.get('user_name'),
user_domain=self.ctx.get('user_domain'),
user_domain_name=self.ctx.get('user_domain_name'),
domain=self.ctx.get('domain'),
domain_name=self.ctx.get('domain_name'),
project_domain=self.ctx.get('project_domain'),
project_domain_name=self.ctx.get('project_domain_name'),
project=self.ctx.get('project'),
project_name=self.ctx.get('project_name'),
is_admin=self.ctx.get('is_admin'),
password=self.ctx.get('password'),
show_deleted=self.ctx.get('show_deleted'),
roles=self.ctx.get('roles'),
auth_url=self.ctx.get('auth_url'),
trusts=self.ctx.get('trusts'),
region_name=self.ctx.get('region_name'))
ctx_dict = ctx.to_dict()
del (ctx_dict['request_id'])
self.assertEqual(self.ctx, ctx_dict)
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 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 process_request(self, req):
'''Build context from authentication info extracted from request.'''
headers = req.headers
environ = req.environ
try:
auth_url = headers.get('X-Auth-Url')
if not auth_url:
# Use auth_url defined in senlin.conf
auth_url = cfg.CONF.authentication.auth_url
auth_token = headers.get('X-Auth-Token')
auth_token_info = environ.get('keystone.token_info')
project = headers.get('X-Project-Id')
project_name = headers.get('X-Project-Name')
project_domain = headers.get('X-Project-Domain-Id')
project_domain_name = headers.get('X-Project-Domain-Name')
user = headers.get('X-User-Id')
user_name = headers.get('X-User-Name')
user_domain = headers.get('X-User-Domain-Id')
user_domain_name = headers.get('X-User-Domain-Name')
domain = headers.get('X-Domain-Id')
domain_name = headers.get('X-Domain-Name')
region_name = headers.get('X-Region-Name')
roles = headers.get('X-Roles')
if roles is not None:
roles = roles.split(',')
env_req_id = environ.get(oslo_request_id.ENV_REQUEST_ID)
if env_req_id is None:
request_id = None
else:
request_id = encodeutils.safe_decode(env_req_id)
except Exception:
raise exception.NotAuthenticated()
req.context = context.RequestContext(
auth_token=auth_token,
user=user,
project=project,
domain=domain,
user_domain=user_domain,
project_domain=project_domain,
request_id=request_id,
auth_url=auth_url,
user_name=user_name,
project_name=project_name,
domain_name=domain_name,
user_domain_name=user_domain_name,
project_domain_name=project_domain_name,
auth_token_info=auth_token_info,
region_name=region_name,
roles=roles)
def __init__(self):
super(ThreadGroupManager, self).__init__()
self.group = threadgroup.ThreadGroup()
# Create dummy service task, because when there is nothing queued
# on self.tg the process exits
self.add_timer(cfg.CONF.periodic_interval, self._service_task)
# TODO(Yanyan Hu): Build a DB session with full privilege
# for DB accessing in scheduler module
self.db_session = context.RequestContext(is_admin=True)
def setUp(self):
super(TestPolicyEnforce, self).setUp()
self.req = wsgi.Request({})
self.req.context = context.RequestContext(project='foo',
is_admin=False)
class DummyController(object):
REQUEST_SCOPE = 'test'
@util.policy_enforce
def an_action(self, req):
return 'woot'
self.controller = DummyController()
def __init__(self, host, topic):
super(EngineService, self).__init__(self.service_name,
host,
topic,
threads=CONF.engine.threads)
self.version = consts.RPC_API_VERSION
self.server = None
self.service_id = None
self.target = None
# TODO(Yanyan Hu): Build a DB session with full privilege
# for DB accessing in scheduler module
self.db_session = context.RequestContext(is_admin=True)
# Initialize the global environment
EVENT.load_dispatcher()
def test_request_context_init(self):
ctx = context.RequestContext(
auth_url=self.ctx.get('auth_url'),
auth_token_info=self.ctx.get('auth_token_info'),
user_name=self.ctx.get('user_name'),
user_domain_name=self.ctx.get('user_domain_name'),
project_id=self.ctx.get('project_id'),
project_name=self.ctx.get('project_name'),
project_domain_name=self.ctx.get('project_domain_name'),
domain_name=self.ctx.get('domain_name'),
trusts=self.ctx.get('trusts'),
region_name=self.ctx.get('region_name'),
password=self.ctx.get('password'),
is_admin=self.ctx.get('is_admin')) # need for tests to work
ctx_dict = ctx.to_dict()
for k, v in self.ctx.items():
self.assertEqual(v, ctx_dict.get(k))
def info(self, ctxt, publisher_id, event_type, payload, metadata):
meta = payload['metadata']
if meta.get('cluster_id') == self.cluster_id:
if event_type not in self.VM_FAILURE_EVENTS:
return
params = {
'event': self.VM_FAILURE_EVENTS[event_type],
'state': payload.get('state', 'Unknown'),
'instance_id': payload.get('instance_id', 'Unknown'),
'timestamp': metadata['timestamp'],
'publisher': publisher_id,
}
node_id = meta.get('cluster_node_id')
if node_id:
LOG.info(_LI("Requesting node recovery: %s"), node_id)
ctx_value = context.get_service_context(
project=self.project_id, user=payload['user_id'])
ctx = context.RequestContext(**ctx_value)
self.rpc.node_recover(ctx, node_id, params)
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
