154 lines
5.4 KiB
Python
154 lines
5.4 KiB
Python
# Copyright (c) 2013 Mirantis, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
import collections
|
|
|
|
from muranoapi.common.helpers import token_sanitizer
|
|
from muranoapi.common import rpc
|
|
from muranoapi.db import models
|
|
from muranoapi.db import session as db_session
|
|
|
|
|
|
SessionState = collections.namedtuple('SessionState', [
|
|
'open', 'deploying', 'deployed'
|
|
])(
|
|
open='open', deploying='deploying', deployed='deployed'
|
|
)
|
|
|
|
|
|
class SessionServices(object):
|
|
@staticmethod
|
|
def get_sessions(environment_id, state=None):
|
|
"""
|
|
Get list of sessions for specified environment
|
|
|
|
:param environment_id: Environment Id
|
|
:param state: glazierapi.db.services.environments.EnvironmentStatus
|
|
:return: Sessions for specified Environment, if SessionState is
|
|
not defined all sessions for specified environment is returned.
|
|
"""
|
|
|
|
unit = db_session.get_session()
|
|
# Here we duplicate logic for reducing calls to database
|
|
# Checks for validation is same as in validate.
|
|
environment = unit.query(models.Environment).get(environment_id)
|
|
|
|
return unit.query(models.Session).filter(
|
|
#Get all session for this environment
|
|
models.Session.environment_id == environment_id,
|
|
#in this state, if state is not specified return in all states
|
|
models.Session.state.in_(SessionState
|
|
if state is None else [state]),
|
|
#Only sessions with same version as current env version are valid
|
|
models.Session.version == environment.version
|
|
).all()
|
|
|
|
@staticmethod
|
|
def create(environment_id, user_id):
|
|
"""
|
|
Creates session object for specific environment for specified user.
|
|
|
|
:param environment_id: Environment Id
|
|
:param user_id: User Id
|
|
:return: Created session
|
|
"""
|
|
unit = db_session.get_session()
|
|
environment = unit.query(models.Environment).get(environment_id)
|
|
|
|
session = models.Session()
|
|
session.environment_id = environment.id
|
|
session.user_id = user_id
|
|
session.state = SessionState.open
|
|
# used for checking if other sessions was deployed before this one
|
|
session.version = environment.version
|
|
# all changes to environment is stored here, and translated to
|
|
# environment only after deployment completed
|
|
session.description = environment.description
|
|
|
|
with unit.begin():
|
|
unit.add(session)
|
|
|
|
return session
|
|
|
|
@staticmethod
|
|
def validate(session):
|
|
"""
|
|
Session is valid only if no other session for same
|
|
environment was already deployed on in deploying state,
|
|
|
|
:param session: Session for validation
|
|
"""
|
|
|
|
#if other session is deploying now current session is invalid
|
|
unit = db_session.get_session()
|
|
|
|
#if environment version is higher then version on which current session
|
|
#is created then other session was already deployed
|
|
current_env = unit.query(models.Environment).\
|
|
get(session.environment_id)
|
|
if current_env.version > session.version:
|
|
return False
|
|
|
|
#if other session is deploying now current session is invalid
|
|
other_is_deploying = unit.query(models.Session).filter_by(
|
|
environment_id=session.environment_id, state=SessionState.deploying
|
|
).count() > 0
|
|
if session.state == SessionState.open and other_is_deploying:
|
|
return False
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def deploy(session, unit, token):
|
|
"""
|
|
Prepares environment for deployment and send deployment command to
|
|
orchestration engine
|
|
|
|
:param session: session that is going to be deployed
|
|
:param unit: SQLalchemy session
|
|
:param token: auth token that is going to be used by orchestration
|
|
"""
|
|
|
|
#Set X-Auth-Token for conductor
|
|
environment = unit.query(models.Environment).get(
|
|
session.environment_id)
|
|
|
|
data = {
|
|
'model': session.description,
|
|
'token': token,
|
|
'tenant_id': environment.tenant_id
|
|
}
|
|
|
|
data['model']['Objects']['?']['id'] = environment.id
|
|
data['model']['Objects']['applications'] = \
|
|
data['model']['Objects'].get('services', [])
|
|
|
|
if 'services' in data['model']['Objects']:
|
|
del data['model']['Objects']['services']
|
|
|
|
session.state = SessionState.deploying
|
|
deployment = models.Deployment()
|
|
deployment.environment_id = session.environment_id
|
|
deployment.description = token_sanitizer.TokenSanitizer().sanitize(
|
|
dict(session.description.get('Objects')))
|
|
status = models.Status()
|
|
status.text = "Deployment scheduled"
|
|
status.level = "info"
|
|
deployment.statuses.append(status)
|
|
|
|
with unit.begin():
|
|
unit.add(session)
|
|
unit.add(deployment)
|
|
|
|
rpc.engine().handle_task(data)
|