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