def log_commons_version(self):
"""Report version of commons for pod's forgerock product."""
logger.debug('Check commons version for {name}:{commons_jar}'.format(
name=self.name, commons_jar=AmsterPod.REPRESENTATIVE_COMMONS_JAR))
test_temp = os.path.join(AmsterPod.LOCAL_TEMP, self.name)
stdout, ignored = kubectl.exec(Pod.NAMESPACE, [
self.name, '-c', self.product_type, '--', 'find', AmsterPod.ROOT,
'-name', 'amster-*.jar'
])
amster_filepath = stdout[0]
head, tail = os.path.split(
amster_filepath) # get versioned amster jar name
exploded_directory = os.path.join(test_temp, 'exploded')
amster_jar_filepath = os.path.join(test_temp, tail)
with zipfile.ZipFile(amster_jar_filepath) as commons_zip_file:
commons_zip_file.extractall(exploded_directory)
test_jar_properties_path = os.path.join(
exploded_directory, 'META-INF', 'maven', 'org.forgerock.commons',
AmsterPod.REPRESENTATIVE_COMMONS_JAR_NAME, 'pom.properties')
logger.debug('Checking commons version in {path}'.format(
path=test_jar_properties_path))
assert os.path.isfile(
test_jar_properties_path), 'Failed to find {path}'.format(
path=test_jar_properties_path)
with open(test_jar_properties_path) as file_pointer:
lines = file_pointer.readlines()
attribute_of_interest = {'version', 'groupId', 'artifactId'}
os_metadata = Pod.get_metadata_of_interest('Commons', self.name, lines,
attribute_of_interest)
Pod.print_table(os_metadata)
def version(self):
"""
Return the product version information.
:return: Dictionary
"""
logger.test_step(
'Report Amster version for pod {name}'.format(name=self.name))
stdout, ignored = kubectl.exec(Pod.NAMESPACE, [
self.name, '--', './amster', '-c', self.product_type, '--version'
])
version_text = stdout[0].strip()
version_key = 'Amster OpenAM Shell v'
build_key = ' build '
revision_length = 10
build_position = version_text.find(build_key)
version = version_text[len(version_key):build_position]
start = build_position + len(build_key)
revision = version_text[start:start + revision_length]
amster_metadata = {
'TITLE': self.product_type,
'DESCRIPTION': self.name,
'VERSION_TEXT': version_text,
'VERSION': version,
'REVISION': revision
}
return amster_metadata
def cleanup_commons_check(self, temp_directory):
"""
:param temp_directory Directory to be deleted
Cleanup after checking commons library version
"""
logger.debug('Cleaning up after commons version check')
ignored, ignored = kubectl.exec(' '.join([self.name, '-- rm', '-rf', temp_directory]))
def is_expected_legal_notices(self, namespace):
"""
:param namespace The kubernetes namespace.
Return True if the representative license file is present on the pod, otherwise assert.
:return: True if file present
"""
ignored, ignored = kubectl.exec(namespace, ' '.join([self.name, '--', 'find', '.', '-name', 'Forgerock_License.txt']))
return True
def setup_commons_check(self, filepath, temp_directory):
"""
:param filepath Path to a common .jar
:param temp_directory directory used for exploding the sample .jar file
Setup for checking commons library version
"""
logger.debug('Setting up for commons version check')
ignored = kubectl.exec(' '.join([self.name, '-- unzip', filepath, '-d', temp_directory]))
def log_os(self, attributes_of_interest):
"""
Report Operating System on the pod.
:param attributes_of_interest: Set of attribute keys to check.
"""
logger.debug('Check OS version for {name}'.format(name=self.name))
metadata, ignored = kubectl.exec(
Pod.NAMESPACE, [self.name, '-c', self.product_type, '--', 'cat', '/etc/os-release'])
os_metadata = Pod.get_metadata_of_interest('OS', self.name, metadata, attributes_of_interest)
Pod.print_table(os_metadata)
def log_jdk(self, attributes_of_interest):
"""
Report Java versions for pod.
:param attributes_of_interest: Set of attribute keys to check.
"""
logger.debug('Check Jaa version for {name}'.format(name=self.name))
ignored, metadata = kubectl.exec(
Pod.NAMESPACE, [self.name, '-c', self.product_type, '--', 'java', '-version']) # TODO: why stderr
java_metadata = Pod.get_metadata_of_interest('Java', self.name, metadata, attributes_of_interest)
Pod.print_table(java_metadata)
def log_jdk(self):
"""Report Java version on the pod."""
logger.debug('Report Java version for {name}'.format(name=self.name))
metadata, ignored = kubectl.exec(
Pod.NAMESPACE,
[self.name, '-c', self.product_type, '--', 'bin/start-ds', '-s'])
attribute_of_interest = {'JAVA Version', 'JAVA Vendor', 'JVM Version'}
os_metadata = Pod.get_metadata_of_interest('JAVA', self.name, metadata,
attribute_of_interest)
Pod.print_table(os_metadata)
def are_legal_notices_present(self):
"""
Check if the representative license file is present on the pod, otherwise assert.
"""
file_of_interest = 'Forgerock_License.txt'
stdout, ignored = kubectl.exec(
Pod.NAMESPACE, [self.name, '-c', self.product_type, '--', 'find', '.', '-name', file_of_interest])
file_path = stdout[0].strip()
logger.debug('Found legal notice: {file}'.format(file=file_path))
assert (file_path.endswith('legal-notices/{file}'.format(file=file_of_interest))),\
'Unable to find {file_of_interest}'.format(file_of_interest=file_of_interest)
def is_expected_jdk(self, sub_command):
"""
:param sub_command: Command passed onto kubectl to obtain jdk version information.
Return True if jdk is as expected, otherwise assert.
:return: True if jdk is as expected
"""
stdout, stderr = kubectl.exec(' '.join([self.name, sub_command]))
logger.debug('Check JDK version for ' + self.name)
assert stderr[0].strip() == self.manifest['jdk_version'], 'Unexpected JDK in use' # TODO: why stderr
assert stderr[1].strip() == self.manifest['jre_version'], 'Unexpected JRE in use'
assert stderr[2].strip() == self.manifest['jdk_full_version'], 'Unexpected JDK in use'
return True
def is_expected_commons_version(self, namespace, subpath, temp_directory):
"""
:param namespace The kubernetes namespace.
Return true if the commons version is as expected, otherwise return assert.
This check inspects a sample commons .jar to see what version is in use.
:return: True is the commons version is as expected.
"""
test_filepath = os.path.join(temp_directory, subpath, temp_directory)
stdout, stderr = kubectl.exec(namespace, ' '.join([self.name, '--', 'cat', test_filepath]))
logger.debug('Check commons version for: ' + self.name)
assert stdout[2].strip() == 'version=' + self.manifest['commons_version'], 'Unexpected commons version'
assert stdout[3].strip() == 'groupId=org.forgerock.commons', ' Unexpected groupId for commons library'
return True
def version(self):
"""
Return the product version information.
:return: Dictionary
"""
logger.debug('Get version for {name}'.format(name=self.name))
stdout, ignored = kubectl.exec(
Pod.NAMESPACE,
[self.name, '-c', self.product_type, '--', 'bin/start-ds', '-F'])
logger.debug('{name} {product_type}: {version}'.format(
name=self.name, product_type=self.product_type, version=stdout[0]))
attribute_of_interest = {
'Build ID', 'Major Version', 'Minor Version', 'Point Version'
}
return Pod.get_metadata_of_interest('Version', self.name, stdout,
attribute_of_interest)
def log_versioned_commons_jar(self, lib_path, jar_name):
"""
Report version of commons; obtained from the name of a sample commons .jar.
:param lib_path: Path to jar library.
:param jar_name: Jar file to check.
"""
logger.debug('Check commons version for {name}*.jar'.format(name=jar_name))
stdout, ignored = kubectl.exec(
Pod.NAMESPACE, [self.name, '-c', self.product_type, '--', 'find', lib_path, '-name', jar_name + '-*.jar'])
config_filepath = stdout[0] # first line of output
start = config_filepath.find(jar_name)
end = config_filepath.find('.jar')
commons_version = config_filepath[start + len(jar_name) + 1: end]
metadata = {'TITLE': "Commons",
'DESCRIPTION': self.name,
'VERSION': commons_version,
'FILE': config_filepath}
Pod.print_table(metadata)
def is_expected_legal_notices(self, legal_notices_path):
"""
:param legal_notices_path: Path to legal notices
Return True if legal notices are as expected, otherwise assert.
:return: True if legal notices are as expected
"""
default_legal_notices = set(self._config["DEFAULT"]["legal_notices"].split())
legal_notices = multiset.Multiset(self._config[self.product_type]["legal_notices"].split())
legal_notices += default_legal_notices
stdout, stderr = kubectl.exec(' '.join([self.name, '-- ls -R ' + legal_notices_path]))
for line in stdout:
logger.debug('Found legal notice ' + self.name)
if line:
legal_notices.remove(line, 1)
assert len(legal_notices) == 0, 'Did not find all legal notices'
return True
def is_expected_version(self, namespace):
"""
:param namespace The kubernetes namespace.
Return True if the version is as expected, otherwise assert.
:return: True if the version is as expected.
"""
stdout, stderr = kubectl.exec(namespace, ' '.join([self.name, '--', './amster', '--version']))
version_strings = stdout[0].split()
version = version_strings[3].lstrip('v')
build = version_strings[5].rstrip(',')
jvm = version_strings[7]
logger.test_step('Check Amster version for pod: ' + self.name)
assert version == self.manifest['version'], 'Unexpected Amster version'
assert build == self.manifest['revision'], 'Unexpected Amster build revision'
assert jvm == self.manifest['amster_jvm'], 'Unexpected JVM for amster'
return True
def is_expected_commons_version(self, namespace):
"""
Return true if the commons version is as expected, otherwise return assert.
:param namespace The kubernetes namespace.
This check inspects a sample commons .jar to see what version is in use.
:return: True is the commons version is as expected.
"""
logger.debug('Setting up for commons version check')
config_version_jar = 'config-%s.jar' % self.manifest['commons_version']
test_jar_filepath = os.path.join(IDMPod.ROOT, 'bundle',
config_version_jar)
stdout, stderr = kubectl.exec(
namespace,
' '.join([self.name, '-c openidm', '-- ls', test_jar_filepath]))
logger.debug('Check commons version for: ' + self.name)
assert stderr[0].strip() == '', 'Did not find ' + test_jar_filepath
return True
def version(self):
"""
Return the product version information.
:return: Dictionary
"""
logger.test_step(
'Report IG version for pod {name}'.format(name=self.name))
test_jar_properties_path = os.path.join(IGPod.ROOT, 'webapps', 'ROOT',
'META-INF', 'maven',
'org.forgerock.openig',
'openig-war', 'pom.properties')
attributes_of_interest = {'version', 'groupId', 'artifactId'}
metadata, ignored = kubectl.exec(Pod.NAMESPACE, [
self.name, '-c', self.product_type, '--', 'cat',
test_jar_properties_path
])
version_metadata = Pod.get_metadata_of_interest(
self.product_type, self.name, metadata, attributes_of_interest)
return version_metadata
