diskimage-builder/diskimage_builder/elements/package-installs/bin/package-installs-squash
Ian Wienand 28ebd24844 Uncap hacking
This causes problems for other projects incorporating dib; we don't
have a specific need for a cap.

Fix a few issues, mostly spacing or regex matches.  No functional
changes.

W503 and W504 relate to leaving artithmetic operators at the start or
end of lines, and are mutually exclusive and, due to "ignore"
overriding the defaults both get enabled.  It seems everyone gets this
wrong (https://gitlab.com/pycqa/flake8/issues/466).  Don't take a
position on this and ignore both.

Use double # around comments including YAML snippets using "# type: "
which now gets detected as PEP484/mypy type hints.

Change-Id: I8b7ce6dee02dcce31c82427a2441c931d136ef57
2020-02-24 10:34:46 +11:00

197 lines
6.4 KiB
Python
Executable File

#!/usr/bin/env python
# Copyright 2014 Hewlett-Packard Development Company, L.P.
#
# 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 argparse
import collections
import functools
import json
import logging
import os
import re
import sys
import yaml
from diskimage_builder import logging_config
logger = logging.getLogger(__name__)
def get_element_installtype(element_name):
default = os.environ.get("DIB_DEFAULT_INSTALLTYPE", "source")
return os.environ.get(
"DIB_INSTALLTYPE_%s" % element_name.replace('-', '_'),
default)
def _is_arch_in_list(strlist):
"""Checks if os.environ['ARCH'] is in comma separated strlist"""
strlist = strlist.split(',')
map(str.strip, strlist)
return os.environ['ARCH'] in strlist
def _valid_for_arch(pkg_name, arch, not_arch):
"""Filter out incorrect ARCH versions"""
if arch is None and not_arch is None:
# nothing specified; always OK
return True
if arch and not_arch:
print("package-installs configuration error: arch and not_arch "
"given for package [%s]" % pkg_name)
sys.exit(1)
# if we have an arch list, our current arch must be in it
# to install.
if arch:
return _is_arch_in_list(arch)
# if we don't have an explicit arch list, we should
# install unless we are in the not-arch list.
return not _is_arch_in_list(not_arch)
def _when(statement):
'''evaulate a when: statement
Evaluate statements of the form
when: ENVIRONMENT_VARIABLE[!]=value
Returns True if the package should be installed, False otherwise
If the ENVIRONMENT_VARIABLE is unset, raises an error
'''
# No statement means install
if statement is None:
return True
# FOO = BAR
# var op val
match = re.match(
r"(?P<var>[\w]+)(\s*)(?P<op>=|!=)(\s*)(?P<val>.*)", statement)
if not match:
print("Malformed when line: <%s>" % statement)
sys.exit(1)
match = match.groupdict()
var = match['var']
op = match['op']
val = match['val']
if var not in os.environ:
raise RuntimeError("The variable <%s> is not set" % var)
logger.debug("when eval %s%s%s against <%s>" %
(var, op, val, os.environ[var]))
if op == '=':
if val == os.environ[var]:
return True
elif op == '!=':
if val != os.environ[var]:
return True
else:
print("Malformed when op: %s" % op)
sys.exit(1)
return False
def collect_data(data, objs, element_name):
for pkg_name, params in objs.items():
if not params:
params = {}
phase = params.get('phase', 'install.d')
install = "install"
if 'uninstall' in params:
install = "uninstall"
# Filter out incorrect installtypes
installtype = params.get('installtype', None)
elem_installtype = get_element_installtype(element_name)
valid_installtype = (installtype is None or
installtype == elem_installtype)
valid_arch = _valid_for_arch(pkg_name, params.get('arch', None),
params.get('not-arch', None))
dib_py_version = str(params.get('dib_python_version', ''))
dib_py_version_env = os.environ.get('DIB_PYTHON_VERSION', '')
valid_dib_python_version = (dib_py_version == '' or
dib_py_version == dib_py_version_env)
# True means install, false skip
if _when(params.get('when', None)) is False:
logger.debug("Skipped due to when: %s/%s" %
(element_name, pkg_name))
continue
if valid_installtype and valid_arch and valid_dib_python_version:
data[phase][install].append((pkg_name, element_name))
return data
def main():
parser = argparse.ArgumentParser(
description="Produce a single packages-installs file from all of"
" the available package-installs files")
parser.add_argument('--elements', required=True,
help="Which elements to squash")
parser.add_argument('--path', required=True,
help="Elements path to search for elements")
parser.add_argument('outfile', help="Location of the output file")
args = parser.parse_args()
logging_config.setup()
# Replicate the logic of finding the first element, because we can't
# operate on the post-copied hooks dir, since we lose element context
element_dirs = list()
for element_name in args.elements.split():
for elements_dir in args.path.split(':'):
potential_path = os.path.join(elements_dir, element_name)
if os.path.exists(potential_path):
element_dirs.append((elements_dir, element_name))
logger.debug("element_dirs -> %s" % element_dirs)
# Collect the merge of all of the existing install files in the elements
# that are the first on the ELEMENT_PATH
final_dict = collections.defaultdict(
functools.partial(collections.defaultdict, list))
for (elements_dir, element_name) in element_dirs:
for file_type in ('json', 'yaml'):
target_file = os.path.join(
elements_dir, element_name, "package-installs.%s" % file_type)
if not os.path.exists(target_file):
continue
logger.info("Squashing install file: %s" % target_file)
try:
objs = json.load(open(target_file))
except ValueError:
objs = yaml.safe_load(open(target_file))
final_dict = collect_data(final_dict, objs, element_name)
logger.debug("final_dict -> %s" % final_dict)
# Write the resulting file
with open(args.outfile, 'w') as outfile:
json.dump(
final_dict, outfile,
indent=True, separators=(',', ': '), sort_keys=False)
if __name__ == '__main__':
main()