def test_check_env_with_null_environment_id(self, mock_db_session):
"""Test check env with null environment id throws exception."""
mock_request = mock.MagicMock(context=test_utils.dummy_context())
mock_db_session.get_session().query().get.return_value = None
test_env_id = 'test_env_id'
expected_error_message = 'Environment with id {env_id} not found'\
.format(env_id=test_env_id)
with self.assertRaisesRegexp(exc.HTTPNotFound, expected_error_message):
utils.check_env(mock_request, test_env_id)
def test_check_env_with_mismatching_tenant_id(self, mock_db_session):
"""Test check env without matching tenant ids throws exception."""
mock_request = mock.MagicMock(context=test_utils.dummy_context())
mock_env = mock.MagicMock(environment_id='test_env_id',
tenant_id='another_test_tenant_id')
mock_db_session.get_session().query().get.return_value = mock_env
expected_error_message = 'User is not authorized to access these '\
'tenant resources'
with self.assertRaisesRegexp(exc.HTTPForbidden,
expected_error_message):
utils.check_env(mock_request, mock_env.environment_id)
def _check_session(self, request, environment_id, session, session_id):
if session is None:
msg = _('Session <SessionId {0}> is not found').format(session_id)
LOG.error(msg)
raise exc.HTTPNotFound(explanation=msg)
if session.environment_id != environment_id:
msg = _('Session <SessionId {0}> is not tied with Environment '
'<EnvId {1}>').format(session_id, environment_id)
LOG.error(msg)
raise exc.HTTPNotFound(explanation=msg)
check_env(request, environment_id)
def delete(self, request, environment_id):
target = {"environment_id": environment_id}
policy.check('delete_environment', request.context, target)
if request.GET.get('abandon', '').lower() == 'true':
check_env(request, environment_id)
LOG.debug('Environments:Abandon <Id: {0}>'.format(environment_id))
envs.EnvironmentServices.remove(environment_id)
else:
LOG.debug('Environments:Delete <Id: {0}>'.format(environment_id))
sessions_controller = sessions.Controller()
session = sessions_controller.configure(request, environment_id)
session_id = session['id']
envs.EnvironmentServices.delete(environment_id, session_id)
sessions_controller.deploy(request, environment_id, session_id)
def delete(self, request, environment_id):
target = {"environment_id": environment_id}
policy.check("delete_environment", request.context, target)
if request.GET.get("abandon", "").lower() == "true":
check_env(request, environment_id)
LOG.debug("Environments:Abandon <Id: {0}>".format(environment_id))
envs.EnvironmentServices.remove(environment_id)
else:
LOG.debug("Environments:Delete <Id: {0}>".format(environment_id))
sessions_controller = sessions.Controller()
session = sessions_controller.configure(request, environment_id)
session_id = session["id"]
envs.EnvironmentServices.delete(environment_id, session_id)
sessions_controller.deploy(request, environment_id, session_id)
def delete(self, request, environment_id):
target = {"environment_id": environment_id}
policy.check('delete_environment', request.context, target)
if request.GET.get('abandon', '').lower() == 'true':
check_env(request, environment_id)
LOG.debug('Environments:Abandon <Id: {0}>'.format(environment_id))
envs.EnvironmentServices.remove(environment_id)
else:
LOG.debug('Environments:Delete <Id: {0}>'.format(environment_id))
sessions_controller = sessions.Controller()
session = sessions_controller.configure(request, environment_id)
session_id = session['id']
envs.EnvironmentServices.delete(environment_id, session_id)
sessions_controller.deploy(request, environment_id, session_id)
def test_check_env(self, mock_db_session):
"""Test check env."""
mock_request = mock.MagicMock(context=test_utils.dummy_context())
mock_env = mock.MagicMock(environment_id='test_env_id',
tenant_id=mock_request.context.tenant)
mock_db_session.get_session().query().get.return_value = mock_env
env = utils.check_env(mock_request, mock_env.environment_id)
self.assertEqual(mock_env, env)
def configure(self, request, environment_id):
LOG.debug('Session:Configure <EnvId: {0}>'.format(environment_id))
check_env(request, environment_id)
# no new session can be opened if environment has deploying status
env_status = envs.EnvironmentServices.get_status(environment_id)
if env_status in (states.EnvironmentStatus.DEPLOYING,
states.EnvironmentStatus.DELETING):
msg = _('Could not open session for environment <EnvId: {0}>,'
'environment has deploying status.').format(environment_id)
LOG.error(msg)
raise exc.HTTPForbidden(explanation=msg)
user_id = request.context.user
session = sessions.SessionServices.create(environment_id, user_id)
return session.to_dict()
def configure(self, request, environment_id):
LOG.debug('Session:Configure <EnvId: {0}>'.format(environment_id))
check_env(request, environment_id)
# no new session can be opened if environment has deploying status
env_status = envs.EnvironmentServices.get_status(environment_id)
if env_status in (states.EnvironmentStatus.DEPLOYING,
states.EnvironmentStatus.DELETING):
msg = _('Could not open session for environment <EnvId: {0}>,'
'environment has deploying status.').format(environment_id)
LOG.error(msg)
raise exc.HTTPForbidden(explanation=msg)
user_id = request.context.user
session = sessions.SessionServices.create(environment_id, user_id)
return session.to_dict()
def index(self, request, environment_id=None):
all_environments = environment_id is None
LOG.debug('Deployments:List <all_environments: {0}>'.format(
all_environments))
if all_environments:
policy.check("list_deployments_all_environments", request.context)
else:
check_env(request, environment_id)
target = {"environment_id": environment_id}
policy.check("list_deployments", request.context, target)
unit = db_session.get_session()
if all_environments:
query = unit.query(models.Environment) \
.options(load_only('tenant_id')) \
.filter_by(tenant_id=request.context.tenant) \
.join(models.Task) \
.order_by(desc(models.Task.created))
result = query.all()
# The join statement above fetches the deployments into
# Environment.tasks. Iterate over that to get the deployments.
deployments = []
for row in result:
for deployment in row.tasks:
deployment = set_dep_state(deployment, unit).to_dict()
deployments.append(deployment)
else:
query = unit.query(models.Task) \
.filter_by(environment_id=environment_id) \
.order_by(desc(models.Task.created))
result = query.all()
deployments = [
set_dep_state(deployment, unit).to_dict()
for deployment in result
]
return {'deployments': deployments}
def delete(self, request, environment_id):
target = {"environment_id": environment_id}
policy.check('delete_environment', request.context, target)
environment = check_env(request, environment_id)
if request.GET.get('abandon', '').lower() == 'true':
LOG.debug(
'Environments:Abandon <Id: {id}>'.format(id=environment_id))
envs.EnvironmentServices.remove(environment_id)
else:
LOG.debug(
'Environments:Delete <Id: {id}>'.format(id=environment_id))
sessions_controller = sessions.Controller()
session = sessions_controller.configure(request, environment_id)
session_id = session['id']
envs.EnvironmentServices.delete(environment_id, session_id)
sessions_controller.deploy(request, environment_id, session_id)
env = environment.to_dict()
env['deleted'] = datetime.datetime.utcnow()
self._notifier.report('environment.delete.end', env)
