172 lines
5.5 KiB
Python
172 lines
5.5 KiB
Python
# Copyright (c) 2014 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 re
|
|
|
|
import flask
|
|
import memcache
|
|
|
|
from driverlog.dashboard import memory_storage
|
|
from driverlog.openstack.common import log as logging
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
LEVELS = [
|
|
{
|
|
'level_id': 'self_verification',
|
|
'level_name': 'self-verification',
|
|
},
|
|
{
|
|
'level_id': '3rd_party_verification',
|
|
'level_name': '3rd-party verification',
|
|
},
|
|
{
|
|
'level_id': 'external_ci_verification',
|
|
'level_name': 'verified by external CI'
|
|
}
|
|
]
|
|
|
|
|
|
def _build_levels_map():
|
|
levels_map = dict()
|
|
index = 1
|
|
for level in LEVELS:
|
|
level['level'] = index
|
|
levels_map[level['level_id']] = level
|
|
index += 1
|
|
return levels_map
|
|
|
|
|
|
def _build_projects_map(default_data):
|
|
projects_map = {}
|
|
for project in default_data['projects']:
|
|
projects_map[project['id']] = project
|
|
return projects_map
|
|
|
|
|
|
def _build_drivers_map(default_data, levels_map, projects_map):
|
|
|
|
driver_map = {}
|
|
|
|
for driver in default_data['drivers']:
|
|
|
|
driver['project_name'] = projects_map[driver['project_id']]['name']
|
|
driver['os_versions_map'] = {}
|
|
|
|
max_level = LEVELS[0]
|
|
for os_version in driver['os_versions']:
|
|
level = levels_map[os_version['verification']]
|
|
os_version['verification_name'] = level['level_name']
|
|
os_version['level'] = level['level']
|
|
if 'os_version' not in os_version:
|
|
os_version['os_version'] = 'master'
|
|
|
|
if level['level'] > max_level['level']:
|
|
max_level = level
|
|
max_level['os_version'] = os_version['os_version']
|
|
|
|
driver['os_versions_map'][os_version['os_version']] = os_version
|
|
|
|
driver.update(max_level)
|
|
|
|
key = (driver['project_id'].lower(),
|
|
driver['vendor'].lower(),
|
|
driver['name'].lower())
|
|
driver_map[key] = driver
|
|
|
|
return driver_map
|
|
|
|
|
|
def get_vault():
|
|
vault = getattr(flask.current_app, 'driverlog_vault', None)
|
|
if not vault:
|
|
try:
|
|
vault = {}
|
|
vault['memory_storage'] = memory_storage.get_memory_storage(
|
|
memory_storage.MEMORY_STORAGE_CACHED)
|
|
|
|
if 'CONF' not in flask.current_app.config:
|
|
LOG.critical('Configure environment variable DRIVERLOG_CONF '
|
|
'with path to config file')
|
|
flask.abort(500)
|
|
|
|
conf = flask.current_app.config['CONF']
|
|
|
|
levels_map = _build_levels_map()
|
|
vault['levels_map'] = levels_map
|
|
|
|
MEMCACHED_URI_PREFIX = r'^memcached:\/\/'
|
|
stripped = re.sub(MEMCACHED_URI_PREFIX, '',
|
|
conf.runtime_storage_uri)
|
|
|
|
memcached_uri = stripped.split(',')
|
|
memcached = memcache.Client(memcached_uri)
|
|
vault['memcached'] = memcached
|
|
|
|
flask.current_app.driverlog_vault = vault
|
|
except Exception as e:
|
|
LOG.critical('Failed to initialize application: %s', e)
|
|
LOG.exception(e)
|
|
flask.abort(500)
|
|
|
|
if not getattr(flask.request, 'driverlog_updated', None):
|
|
flask.request.driverlog_updated = True
|
|
|
|
memcached = vault['memcached']
|
|
hashes = memcached.get_multi(['default_data_hash', 'update_hash'],
|
|
key_prefix='driverlog:')
|
|
|
|
if vault.get('default_data_hash') != hashes.get('default_data_hash'):
|
|
vault['default_data_hash'] = hashes['default_data_hash']
|
|
vault['default_data'] = memcached.get('driverlog:default_data')
|
|
|
|
projects_map = _build_projects_map(vault['default_data'])
|
|
vault['projects_map'] = projects_map
|
|
|
|
drivers_map = _build_drivers_map(
|
|
vault['default_data'], vault['levels_map'], projects_map)
|
|
vault['drivers_map'] = drivers_map
|
|
|
|
if vault.get('update_hash') != hashes.get('update_hash'):
|
|
vault['update_hash'] = hashes['update_hash']
|
|
update = memcached.get('driverlog:update')
|
|
|
|
levels_map = vault['levels_map']
|
|
|
|
for proj_vendor_driver, os_versions_map in update.iteritems():
|
|
ovm = os_versions_map['os_versions_map']
|
|
|
|
if proj_vendor_driver not in vault['drivers_map']:
|
|
vault['drivers_map'][proj_vendor_driver] = os_versions_map
|
|
else:
|
|
for os_version, info in ovm.iteritems():
|
|
level = levels_map[info['verification']]
|
|
info['verification_name'] = level['level_name']
|
|
info['level'] = level['level']
|
|
|
|
vault['drivers_map'][proj_vendor_driver][
|
|
'os_versions_map'].update(ovm)
|
|
|
|
if not vault.get('default_data'):
|
|
raise Exception('Memcached is not initialized. '
|
|
'Please run the processor')
|
|
|
|
return vault
|
|
|
|
|
|
def get_memory_storage():
|
|
return get_vault()['memory_storage']
|