def test_does_not_set_extension_logger_level_if_none(self): logger = Mock() config = ConfigManager() config.set(LOG_LEVEL, 'warning') config.set(LOG_FORMAT, None) config.set(LOG_DIR, '.') config.set(APPLICATION_NAME, 'k2') config.set(ENABLED_EXTENSIONS, ['extensionname']) config.set(EXTENSION_LOG_LEVEL, None, entity='extensionname') with patch('logging.getLogger', return_value=logger) as get_logger, \ patch('zaf.builtin.logging.logging.Filter', return_value=filter) as get_filter: with ExtensionTestHarness(RootLogger, config=config): get_logger.assert_any_call(get_logger_name('zaf', 'extensionname')) get_logger.assert_any_call(get_logger_name('k2', 'extensionname')) logger.setLevel.assert_called_with(logging.DEBUG) get_filter.assert_called_with({'': 30})
def __init__(self, config, instances): log_level = map_level(config.get(LOG_LEVEL)) log_format = config.get(LOG_FORMAT) application_name = config.get(APPLICATION_NAME) root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) formatter = logging.Formatter(log_format) exclude_dict = {} if log_level: exclude_dict[''] = log_level else: exclude_dict[''] = LOG_LEVEL_OFF for extension in config.get(ENABLED_EXTENSIONS, []): extension_log_level = config.get(EXTENSION_LOG_LEVEL, entity=extension) for name in {'zaf', application_name}: extension_logger = logging.getLogger( get_logger_name(name, extension)) extension_logger.setLevel(logging.DEBUG) if extension_log_level: exclude_dict[get_logger_name( name, extension)] = map_level(extension_log_level) for logger_name in config.get(LOG_ERROR): exclude_dict[logger_name] = logging.ERROR for logger_name in config.get(LOG_WARNING): exclude_dict[logger_name] = logging.WARNING for logger_name in config.get(LOG_INFO): exclude_dict[logger_name] = logging.INFO for logger_name in config.get(LOG_DEBUG): exclude_dict[logger_name] = logging.DEBUG ch = logging.StreamHandler(sys.stderr) ch.setFormatter(formatter) ch.addFilter(Filter(exclude_dict)) root_logger.addHandler(ch)
def test_sets_extension_logger_level(self): logger = Mock() filter = Mock() config = ConfigManager() config.set(APPLICATION_NAME, 'k2') config.set(ENABLED_EXTENSIONS, ['extensionname']) config.set(EXTENSION_LOG_LEVEL, 'error', entity='extensionname') with patch('logging.getLogger', return_value=logger) as get_logger, \ patch('zaf.builtin.logging.logging.Filter', return_value=filter) as get_filter: with ExtensionTestHarness(RootLogger, config=config): get_logger.assert_any_call(get_logger_name('zaf', 'extensionname')) get_logger.assert_any_call(get_logger_name('k2', 'extensionname')) logger.setLevel.assert_called_with(logging.DEBUG) get_filter.assert_called_with( { '': 20, 'k2.extension.extensionname': 40, 'zaf.extension.extensionname': 40 })
def _log_file_config(self, config, file_id, file_path, extension_configs, logger_name=None, level='debug', format=None, additional_logger_levels={}, filetype='text'): if logger_name is None: logger_name = get_logger_name('k2', file_id) log_file_config_name = '.'.join([LOG_FILES.namespace, LOG_FILES.name]) log_file_path_config_name = self._get_config_name( file_id, LOG_FILE_PATH) log_file_loggers_config_name = self._get_config_name( file_id, LOG_FILE_LOGGERS) log_file_level_config_name = self._get_config_name( file_id, LOG_FILE_LEVEL) log_file_format_config_name = self._get_config_name( file_id, LOG_FILE_FORMAT) log_file_debug_config_name = self._get_config_name( file_id, LOG_FILE_DEBUG) log_file_info_config_name = self._get_config_name( file_id, LOG_FILE_INFO) log_file_warning_config_name = self._get_config_name( file_id, LOG_FILE_WARNING) log_file_type_config_name = self._get_config_name( file_id, LOG_FILE_TYPE) extension_configs[log_file_config_name].append(file_id) extension_configs[log_file_path_config_name] = os.path.join( config.get(LOG_DIR), file_path) extension_configs[log_file_loggers_config_name].append(logger_name) extension_configs[log_file_level_config_name] = level extension_configs[log_file_debug_config_name].extend( additional_logger_levels.get('debug', [])) extension_configs[log_file_info_config_name].extend( additional_logger_levels.get('info', [])) extension_configs[log_file_warning_config_name].extend( additional_logger_levels.get('warning', [])) extension_configs[log_file_type_config_name] = filetype if format is not None: extension_configs[log_file_format_config_name] = format
def __init__(self, ip, port=23, timeout=DEFAULT_TIMEOUT, endmark=DEFAULT_END_MARK, context_name=''): self.ip = ip self.port = port self.telnet = None self.timeout = timeout self.endmark = re.compile(endmark) if endmark is not None else None if context_name: context_name = '.' + context_name self.logger = logging.getLogger( get_logger_name('k2', 'telnet') + context_name) self.logger.addHandler(logging.NullHandler()) self.rawlogger = logging.getLogger('rawtelnet' + context_name) self.rawlogger.addHandler(logging.NullHandler()) self.rawlogger_file = None
import logging import re from collections import Counter, defaultdict from time import time from zaf.component.decorator import component, requires from zaf.config.options import ConfigOption, ConfigOptionId from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2.cmd.run import RUN_COMMAND from k2.sut import SUT, SUT_RESET_DONE from monitor import MONITOR_ENDPOINT, PERFORM_MEASUREMENT logger = logging.getLogger(get_logger_name('k2', 'monitor', 'process')) logger.addHandler(logging.NullHandler()) class SystemNetworkMonitorError(Exception): pass @component @requires(exec='Exec', can=['telnet']) class SystemNetworkStatisticsCollector(object): """Figure out the network RX and TX statistics by reading /proc/net/dev.""" def __init__(self, exec): self._exec = exec self._matcher = re.compile((r'\s+?' r'(?P<interface>\S+):\s+' r'(?P<rx_bytes>\S+)\s+'
import logging from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from healthcheck import HealthCheckError from k2.cmd.run import RUN_COMMAND from k2.runner import TEST_CASE_FINISHED from k2.runner.testcase import Verdict from k2.sut import SUT, SUT_RECOVERY_PERFORM from . import HEALTH_CHECK_ENDPOINT, PERFORM_HEALTH_CHECK logger = logging.getLogger(get_logger_name('k2', 'healthcheck')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='healthcheck', extends=[RUN_COMMAND], config_options=[ ConfigOption(SUT, required=False, instantiate_on=True), ], endpoints_and_messages={HEALTH_CHECK_ENDPOINT: [PERFORM_HEALTH_CHECK]}) class HealthMonitor(AbstractExtension): """Monitor SUT health.""" def __init__(self, config, instances): self._entity = instances.get(SUT)
from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2.finder.testfinder import RUN_COMMAND from k2.results.results import TestCaseFinished, TestCaseStarted from k2.runner import TEST_CASE_FINISHED, TEST_CASE_STARTED from k2.runner.testcase import Verdict from multirunner import MULTI_RUNNER_ENABLED, MULTI_RUNNER_ENDPOINT, TEST_SUBRUN from . import CONSOLE_BINARY_ERROR_PATTERN, CONSOLE_BINARY_FAILED_PATTERN, \ CONSOLE_BINARY_IGNORED_PATTERN, CONSOLE_BINARY_PASSED_PATTERN, CONSOLE_BINARY_PATH, \ CONSOLE_BINARY_PENDING_PATTERN, CONSOLE_BINARY_SKIPPED_PATTERN, CONSOLE_BINARY_TIMEOUT, \ CONSOLE_binaryid logger = logging.getLogger(get_logger_name('k2', 'consolerunner')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='consolerunner', extends=[RUN_COMMAND], config_options=[ ConfigOption(CONSOLE_binaryid, required=False, instantiate_on=True), ConfigOption(CONSOLE_BINARY_PATH, required=True), ConfigOption(CONSOLE_BINARY_TIMEOUT, required=True), ConfigOption(CONSOLE_BINARY_PASSED_PATTERN, required=False), ConfigOption(CONSOLE_BINARY_FAILED_PATTERN, required=False), ConfigOption(CONSOLE_BINARY_ERROR_PATTERN, required=False), ConfigOption(CONSOLE_BINARY_PENDING_PATTERN, required=False), ConfigOption(CONSOLE_BINARY_SKIPPED_PATTERN, required=False),
from zaf.component.util import add_cans from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, ExtensionConfig, \ FrameworkExtension, get_logger_name from zaf.messages.dispatchers import SequentialDispatcher from k2.cmd.run import RUN_COMMAND from k2.sut import SUT from powermeter import AVAILABLE_POWER_METERS, K2_POWER_METER_COMPONENT, POWER_METER, \ POWER_METER_POWER from powermeter.powermeter import PowerMeter from powermeter.powermetercommand import POWER_METER_COMMAND from . import DUMMY_POWER_METER_ENDPOINT, DUMMY_POWER_METER_VALUE logger = logging.getLogger(get_logger_name('k2', 'dummypowermeter')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='dummypowermeter', extends=[RUN_COMMAND, POWER_METER_COMMAND], config_options=[ ConfigOption(SUT, required=True, instantiate_on=True), ConfigOption(POWER_METER, required=False), ConfigOption(DUMMY_POWER_METER_VALUE, required=False) ], endpoints_and_messages={DUMMY_POWER_METER_ENDPOINT: [POWER_METER_POWER]}, groups=['powermeter'], ) class DummyPowerMeter(AbstractExtension):
import logging import re from zaf.component.decorator import component, requires from zaf.extensions.extension import get_logger_name from .common import wait_for logger = logging.getLogger(get_logger_name('k2', 'waitfor', 'file')) logger.addHandler(logging.NullHandler()) @component() @requires(exec='Exec') class WaitForFile: def __init__(self, exec): self._exec = exec def wait_for_match(self, file, regex, timeout=60, poll_interval=1.0): """ Wait for a match in the file and return Match object. :param file: The file to look in :param regex: The regex pattern to use :param timeout: the timeout in seconds :param poll_interval: the interval in seconds to use when polling the file :return: Match object :raises: TimeoutError if match is not found before timeout """ compiled_regex = re.compile(regex)
"""Provides the *noop* (no operation) command.""" import logging from zaf.application import ApplicationContext from zaf.commands.command import CommandId from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name logger = logging.getLogger(get_logger_name('zaf', 'noop')) logger.addHandler(logging.NullHandler()) def noop(core): """Noop (no operation) command. Does nothing. Takes no arguments.""" return 0 NOOP_COMMAND = CommandId('noop', noop.__doc__, noop, [], hidden=True, application_contexts=ApplicationContext.EXTENDABLE) @FrameworkExtension(name='noop', commands=[NOOP_COMMAND]) class NoopExtension(AbstractExtension): """Provides the noop (no operation) command.""" def __init__(self, config, instances): pass
import logging import time from zaf.component.decorator import component, requires from zaf.extensions.extension import get_logger_name from powerswitch import POWER_SWITCH_POWER_STATE, POWER_SWITCH_POWEROFF, POWER_SWITCH_POWERON, \ POWER_SWITCH_TIMEOUT logger = logging.getLogger(get_logger_name('k2', 'powerswitch')) POWER_CYCLE_TIME = 30 class NoPowerSwitch(Exception): pass class MultiplePowerSwitches(Exception): pass class PowerSwitch(object): def __init__(self, messagebus, entity, receiver_endpoint_id): self.messagebus = messagebus self.entity = entity self.receiver_endpoint_id = receiver_endpoint_id def _return_or_raise(self, futures, message): if len(futures) == 0: msg = 'Trying to use powerswitch failed due to no powerswitch available for sut {entity}'.format(
import logging from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from connectioncheck import CONNECTIONCHECK_RUN_CHECK from connectioncheck.connectioncheck import ConnectionCheckResult from k2.cmd.run import RUN_COMMAND from k2.sut import SUT, SUT_IP from . import TELNET_CONNECTION_CHECK_ENABLED, TELNET_CONNECTION_CHECK_ENDPOINT, \ TELNET_CONNECTION_CHECK_REQUIRED, TELNET_ENABLED, TELNET_PORT from .client import TelnetClient logger = logging.getLogger(get_logger_name('k2', 'telnetcc')) @CommandExtension( name='telnetcc', extends=[RUN_COMMAND], config_options=[ ConfigOption(SUT, required=True, instantiate_on=True), ConfigOption(SUT_IP, required=True), ConfigOption(TELNET_ENABLED, required=True), ConfigOption(TELNET_CONNECTION_CHECK_ENABLED, required=True), ConfigOption(TELNET_CONNECTION_CHECK_REQUIRED, required=True), ConfigOption(TELNET_PORT, required=True), ], endpoints_and_messages={ TELNET_CONNECTION_CHECK_ENDPOINT: [
import threading from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2 import ABORT, CRITICAL_ABORT from k2.cmd.run import RUN_COMMAND, TEST_RUN from k2.runner import ABORT_TEST_CASE_REQUEST, EXTENSION_NAME, RUNNER_PARALLEL_WORKERS, messages from k2.runner.runner import TestRunner from k2.sut import SUT_RESET_DONE, SUT_RESET_STARTED from . import RUNNER_SUITE_NAME logger = logging.getLogger(get_logger_name('k2', EXTENSION_NAME, 'manager')) logger.addHandler(logging.NullHandler()) class AbortedBeforeStartException(Exception): pass @CommandExtension( name=EXTENSION_NAME, config_options=[ ConfigOption(RUNNER_SUITE_NAME, required=True), ConfigOption(RUNNER_PARALLEL_WORKERS, required=True), ], extends=[RUN_COMMAND], endpoints_and_messages=messages.runner_endpoint_with_messages())
import logging import tempfile from unittest.mock import patch from k2.cmd.run import RUN_COMMAND from zaf.component.decorator import component from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name logger = logging.getLogger(get_logger_name('k2', 'workspacecomponent')) logger.addHandler(logging.NullHandler()) @CommandExtension('workspacecomponent', extends=[RUN_COMMAND]) class WorkspaceExtension(AbstractExtension): def __init__(self, config, instances): @component() class Workspace(object): def __init__(self): self.temp_dir = None self.path = None self.env = None def __enter__(self): self.temp_dir = tempfile.TemporaryDirectory(prefix='pycred-') self.path = self.temp_dir.__enter__() self.env = patch.dict('os.environ', {'PYCRED_STORE_PATH': self.path}) self.env.__enter__() logger.info("Creating workspace {d}".format(d=self.path)) return self
import logging from zaf.component.decorator import requires from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2.cmd.run import RUN_COMMAND from k2.runner.messages import TEST_RUN_FINISHED from metrics import GENERATE_METRICS_AGGREGATE, GENERATE_METRICS_REPORT, METRICS_ENDPOINT logger = logging.getLogger(get_logger_name('k2', 'metrics', 'triggers')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='metrics', extends=[RUN_COMMAND], groups=['metrics'], ) class TriggerMetricsReportGenerationOnTestRunFinished(AbstractExtension): """Triggers metrics reports generation when a test run is finished.""" @callback_dispatcher([TEST_RUN_FINISHED], priority=-1) @requires(messagebus='MessageBus') def trigger_report_generation(self, message, messagebus): logger.info('Test run finished, triggering metrics report generation') messagebus.trigger_event(GENERATE_METRICS_REPORT, METRICS_ENDPOINT, data=None) @CommandExtension(
"""Provides the run command that is used to run K2 tests.""" import logging from collections import namedtuple from zaf.commands.command import CommandId from zaf.config.options import ConfigOption, ConfigOptionId from zaf.extensions.extension import FrameworkExtension, get_logger_name from zaf.messages.message import EndpointId, MessageId from k2.sut import SUT logger = logging.getLogger(get_logger_name('k2', 'runcommand')) logger.addHandler(logging.NullHandler()) EXIT_CODE_FROM_VERDICT = ConfigOptionId( 'exitcode.from.verdict', 'Give the verdict of the test run as exit code', option_type=bool, default=False) RUN_COMMAND_ENDPOINT = EndpointId('runcommand', """ The K2 run command """) PRE_INITIALIZE_SUT = MessageId( 'PRE_INITIALIZE_SUT', """ Triggered before the initialize the SUT. This message is sent once for each sut entity. data: None
import logging import os from zaf.config.options import ConfigOption, ConfigOptionId from zaf.extensions.extension import FrameworkExtension, get_logger_name from k2.utils.writers import JsonWriter from ..messages import collect_metrics from .reporter import AbstractMetricsReportExtension logger = logging.getLogger(get_logger_name('k2', 'metrics.json')) logger.addHandler(logging.NullHandler()) JSON_REPORTER_ID = ConfigOptionId( name='ids', description='Names a JSON metrics reporter instance', multiple=True, entity=True, namespace='metrics.json', ) JSON_DIRECTORY = ConfigOptionId( name='dir', description='Directory to write the JSON reports to', default='${output.dir}/metrics/json', at=JSON_REPORTER_ID, ) JSON_FILENAME = ConfigOptionId( name='filename',
""" import logging from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2.cmd.run import RUN_COMMAND from k2.reports.z2 import Z2_INTERNAL_PUBLISH_REPORT_REQUEST, Z2_REPORTS, Z2_REPORTS_BUILD_NUMBER, \ Z2_REPORTS_ENDPOINT, Z2_REPORTS_FILE, Z2_REPORTS_JOB_NAME, Z2_REPORTS_URL from k2.reports.z2.writer import generate_report, upload_report, write_report from k2.results import RESULTS_ENDPOINT, TEST_RESULTS_COLLECTED logger = logging.getLogger(get_logger_name('k2', 'z2report')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='z2report', extends=[RUN_COMMAND], config_options=[ ConfigOption(Z2_REPORTS, required=True), ConfigOption(Z2_REPORTS_JOB_NAME, required=False), ConfigOption(Z2_REPORTS_BUILD_NUMBER, required=False), ], endpoints_and_messages={ Z2_REPORTS_ENDPOINT: [Z2_INTERNAL_PUBLISH_REPORT_REQUEST], }, groups=['test-results'],
from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.dispatchers import CallbackDispatcher from k2.finder.testfinder import RUN_COMMAND from k2.results.results import TestCaseFinished, TestCaseStarted from k2.runner import TEST_CASE_FINISHED, TEST_CASE_STARTED from k2.runner.testcase import Verdict from multirunner import MULTI_RUNNER_ENABLED, MULTI_RUNNER_ENDPOINT, TEST_SUBRUN from . import GTEST_BINARY_PATH, GTEST_FILTER, GTEST_SERIAL_ENDMARK, GTEST_TIMEOUT, \ GTEST_USE_SERIAL, GTEST_XML_REPORT_PATH, GTEST_binaryid logger = logging.getLogger(get_logger_name('k2', 'gtesbinarytrunner')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='gtestbinaryrunner', extends=[RUN_COMMAND], config_options=[ ConfigOption(GTEST_binaryid, required=False, instantiate_on=True), ConfigOption(GTEST_BINARY_PATH, required=True), ConfigOption(GTEST_TIMEOUT, required=True), ConfigOption(GTEST_XML_REPORT_PATH, required=False), ConfigOption(GTEST_FILTER, required=False), ConfigOption(GTEST_USE_SERIAL, required=False), ConfigOption(GTEST_SERIAL_ENDMARK, required=False), ConfigOption(MULTI_RUNNER_ENABLED, required=False),
from zaf.component.util import add_cans from zaf.config import MissingConditionalConfigOption from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.dispatchers import SequentialDispatcher from k2.cmd.run import RUN_COMMAND from k2.sut import SUT from powerswitch import K2_POWER_COMPONENT, POWER_SWITCH, POWER_SWITCH_POWER_STATE, \ POWER_SWITCH_POWEROFF, POWER_SWITCH_POWERON from powerswitch.powercommand import POWER_COMMAND from powerswitch.powerswitch import PowerSwitch from . import GUDE_IP, GUDE_PORT, GUDE_POWER_SWITCH_ENDPOINT, GudePowerState logger = logging.getLogger(get_logger_name('k2', 'gude')) @CommandExtension( name='gude', extends=[RUN_COMMAND, POWER_COMMAND], config_options=[ ConfigOption(SUT, required=True, instantiate_on=True), ConfigOption(POWER_SWITCH, required=False), ConfigOption(GUDE_IP, required=False), ConfigOption(GUDE_PORT, required=False), ], endpoints_and_messages={ GUDE_POWER_SWITCH_ENDPOINT: [POWER_SWITCH_POWERON, POWER_SWITCH_POWEROFF, POWER_SWITCH_POWER_STATE] },
from sutevents import LOG_LINE_RECEIVED from zserial import SERIAL_RAW_LINE, SERIAL_RECONNECT from . import SERIAL_BAUDRATE, SERIAL_CONNECTED, SERIAL_CONNECTION_LOST, SERIAL_DEVICE, \ SERIAL_ENABLED, SERIAL_ENDPOINT, SERIAL_FILTERS, SERIAL_LOG_ENABLED, SERIAL_PORT_IDS, \ SERIAL_PROMPT, SERIAL_RESUME, SERIAL_SEND_COMMAND, SERIAL_SUSPEND, SERIAL_TIMEOUT, \ SUT_SERIAL_PORTS from .client import SerialClient from .connection import find_serial_port, start_serial_connection from .log import serial_log_line_entity from .messages import SendSerialCommandData from .sut import SUT_SERIAL_BAUDRATE, SUT_SERIAL_DEVICE, SUT_SERIAL_ENABLED, SUT_SERIAL_FILTERS, \ SUT_SERIAL_LOG_ENABLED, SUT_SERIAL_PROMPT, SUT_SERIAL_TIMEOUT, \ add_sut_options_to_extension_config logger = logging.getLogger(get_logger_name('k2', 'zserial')) NUMBER_OF_RECONNECTION_TRIES = 30 TIMEOUT_BETWEEN_CONNECTIONS = 1 class SerialException(Exception): pass @requires(port='SerialPort') @requires(messagebus='MessageBus') @component(name='Exec', can=['serial'], provided_by_extension='zserial', priority=-1) def serial_exec(port, messagebus): """Exec component using serial.""" return SerialClient(messagebus, port.entity, port.serial.timeout, port.serial.prompt)
A wrapper around the GitPython module. Provides a component that holds a GitPython Repo instance and provides some helper methods for interacting with it """ import datetime import logging import os from contextlib import contextmanager from tempfile import TemporaryDirectory from zaf.component.decorator import component from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name logger = logging.getLogger(get_logger_name('k2', 'gitrepo')) logger.addHandler(logging.NullHandler()) @component(provided_by_extension='gitrepo') class GitRepo(object): """A helper/wrapper component around the GitPython module.""" def __init__(self, repodir, remote_name=None): from git import Repo self.path = repodir self.remote_name = remote_name self.repo = Repo.init(repodir) self.user = None
""" import logging import os import threading import re from http.server import BaseHTTPRequestHandler, HTTPServer from socketserver import ThreadingMixIn from urllib.parse import parse_qs, urlparse from zaf.commands.command import CommandId from zaf.component.decorator import component, requires from zaf.config.options import ConfigOption, ConfigOptionId from zaf.extensions.extension import AbstractExtension, FrameworkExtension, get_logger_name logger = logging.getLogger(get_logger_name('k2', 'httpfileserver')) logger.addHandler(logging.NullHandler()) HTTP_CODE_200 = 200 # OK HTTP_CODE_302 = 302 # Redirection HTTP_CODE_404 = 404 # Not found error HTTP_CODE_500 = 500 # Server error class ServerContent(object): """ POD class for keeping track of served content. Only path and queries are used for equality and hash. """ def __init__(self, path, queries, status_code):
import logging import subprocess from zaf.extensions.extension import get_logger_name logger = logging.getLogger(get_logger_name('k2', 'hostshellexec')) logger.addHandler(logging.NullHandler()) class HostShellExecutorError(Exception): pass class HostShellExecutor(object): def __init__(self, timeout=60, encoding='utf-8'): self._timeout = timeout self._encoding = encoding def send_line(self, line, timeout=None, expected_exit_code=None, extended_process_information=False): timeout = timeout if timeout is not None else self._timeout try: logger.debug('Sending line: {line}'.format(line=line)) process = self._send_line_nowait(line) stdout, stderr = process.communicate(timeout=timeout) stdout = stdout.decode(self._encoding) stderr = stderr.decode(self._encoding)
import enum import inspect import logging import threading import uuid from textwrap import dedent from zaf.extensions.extension import get_logger_name from k2.runner import EXTENSION_NAME from k2.runner.exceptions import DisabledException, SkipException from k2.runner.timeout import get_timeout from k2.utils.string import make_valid_filename logger = logging.getLogger(get_logger_name('k2', EXTENSION_NAME, 'testcase')) logger.addHandler(logging.NullHandler()) @enum.unique class Verdict(enum.IntEnum): # Starting at zero to be able to map to exit code PASSED = 0 FAILED = 1 # An AssertionError exception was raised ERROR = 2 # Any non-AssertionError exception was raised PENDING = 3 # Test case has not yet run SKIPPED = 4 # Not run due to missing but not failing precondition IGNORED = 5 # Not run due to configuration def combine(self, other): if self == Verdict.ERROR or other == Verdict.ERROR:
import logging import re import sys import click from zaf.application import APPLICATION_CONTEXT, APPLICATION_VERSION, ENTRYPOINT_NAME from zaf.builtin.click.check_duplicates import check_for_ambiguous_duplicates from zaf.commands import COMMAND from zaf.config.options import ConfigOption from zaf.config.types import Choice, ConfigChoice, Count, Entity, Flag, GlobPattern, Path from zaf.extensions.extension import AbstractExtension, ExtensionConfig, FrameworkExtension, \ get_logger_name from zaf.utils.bashcompletion import is_bash_completion logger = logging.getLogger(get_logger_name('zaf', 'click')) logger.addHandler(logging.NullHandler()) CLICK_CONFIG_PRIORITY = 100 IS_BASH_COMPLETION = is_bash_completion() HELP_OPTIONS = ['-h', '--help', '--full-help'] FULL_HELP_OPTIONS = ['--full-help'] VERSION_OPTIONS = ['--version'] @FrameworkExtension( name='click', load_order=1, config_options=[ConfigOption(ENTRYPOINT_NAME, required=True)]) class ClickInitPluginPath(AbstractExtension):
import logging import os from zaf.component.decorator import component, requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from k2.cmd.run import RUN_COMMAND from zk2component import LOG_DIR_TESTS logger = logging.getLogger(get_logger_name('k2', 'zk2component')) logger.addHandler(logging.NullHandler()) @CommandExtension('zk2component', extends=[RUN_COMMAND], config_options=[ConfigOption(LOG_DIR_TESTS, required=True)]) class Zk2Component(AbstractExtension): def __init__(self, config, instances): @component @requires(zk2='PyProc', args=['zk2']) @requires(context='ComponentContext') class Zk2(object): logdir_tests = config.get(LOG_DIR_TESTS) def __init__(self, zk2, config, context): self.zk2 = zk2 self.config = config self.context = context
import logging from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher from k2 import CRITICAL_ABORT from k2.cmd.run import RUN_COMMAND from k2.sut import SUT_RESET_STARTED from . import ABORT_ON_UNEXPECTED_SUT_RESET, ABORT_ON_UNEXPECTED_SUT_RESET_ENDPOINT logger = logging.getLogger(get_logger_name('k2', 'aborttestrun')) logger.addHandler(logging.NullHandler()) @CommandExtension(name='aborttestrun', extends=[RUN_COMMAND], config_options=[ ConfigOption(ABORT_ON_UNEXPECTED_SUT_RESET, required=True) ], endpoints_and_messages={ ABORT_ON_UNEXPECTED_SUT_RESET_ENDPOINT: [CRITICAL_ABORT] }, activate_on=[ABORT_ON_UNEXPECTED_SUT_RESET]) class AbortOnUnexpectedSutReset(AbstractExtension): """ Aborts test run on unexpected sut reset.
import logging from k2.cmd.run import INITIALIZE_SUT, RUN_COMMAND from k2.sut import SUT from zaf.component.decorator import requires from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from zaf.messages.decorator import callback_dispatcher logger = logging.getLogger(get_logger_name('k2', 'initializejenkins')) logger.addHandler(logging.NullHandler()) @CommandExtension( name='initializejenkins', extends=[RUN_COMMAND], config_options=[ConfigOption(SUT, required=True, instantiate_on=True)]) class InitializeJenkins(AbstractExtension): def __init__(self, config, instances): logger.info('Intializing Jenkins') @callback_dispatcher([INITIALIZE_SUT], entity_option_id=SUT) @requires(jenkins='Jenkins') def initialize_jenkins(self, message, jenkins): logger.info('Jenkins initialization complete')
import logging import subprocess from k2.cmd.run import RUN_COMMAND from zaf.component.decorator import component from zaf.config.options import ConfigOption from zaf.extensions.extension import AbstractExtension, CommandExtension, get_logger_name from . import COVERAGE_CONFIG_FILE, COVERAGE_ENABLED logger = logging.getLogger(get_logger_name('k2', 'pycredcomponent')) logger.addHandler(logging.NullHandler()) @CommandExtension( 'pycredcomponent', extends=[RUN_COMMAND], config_options=[ ConfigOption(COVERAGE_CONFIG_FILE, required=False), ConfigOption(COVERAGE_ENABLED, required=False), ]) class PyCredExtension(AbstractExtension): def __init__(self, config, instances): @component() class PyCred(object): coverage_enabled = config.get(COVERAGE_ENABLED, False) coverage_config_file = config.get(COVERAGE_CONFIG_FILE)