def display_acs_version(option, opt_str, value, parser):
"""
:param option:
:param opt_str:
:param value:
:param parser:
:return:
"""
print "ACS " + Util.get_acs_release_version()
sys.exit(0)
def _log_acs_param_extra(self, acs_params):
"""
Log all ACS input parameters
"""
params = self.__log_acs_param(acs_params, False)
if platform.system() == "Windows":
release = platform.release()
elif platform.dist():
release = "{0}_{1}".format(platform.dist()[0], platform.dist()[1])
params += "; os={0}_{1}".format(platform.system(), release)
params += "; python_vers={0}_{1}".format(platform.python_version(), platform.architecture()[0])
params += "; hostname={0}".format(socket.getfqdn())
params += "; version={0}".format(Util.get_acs_release_version())
user_home = os.path.split(os.path.expanduser('~'))
if user_home:
params += "; user={0}".format(user_home[-1])
LOGGER_FWK_STATS.info("event=START; {0}".format(params))
def _init_bench_info_node(self):
"""
Initialize the DeviceInfo Node with theses values:
DeviceInfo:
- Bench Name (hostname)
- Bench user
- Bench IP
- Bench OS
- ACS Version (host)
:rtype: None
"""
# Create the <BenchInfo> element
self.bench_info = etree.SubElement(self.document, "BenchInfo")
# Create the <BenchName> node for hostInfo
bench_name = etree.SubElement(self.bench_info, "BenchName")
# Set BenchName value
bench_name.text = clean_xml_text(self.__get_bench_name())
# Create the <BenchUser> node for hostInfo
bench_user = etree.SubElement(self.bench_info, "BenchUser")
# Set BenchUser value
bench_user.text = clean_xml_text(self.__get_bench_user())
# Create the <BenchIp> node for hostInfo
bench_ip = etree.SubElement(self.bench_info, "BenchIp")
# Set BenchIp value
bench_ip.text = self.__get_bench_ip()
# Create the <BenchOs> node for hostInfo
bench_os = etree.SubElement(self.bench_info, "BenchOs")
# Set BenchName value
bench_os.text = self.__get_bench_os()
# Create the <AcsVersion> node for hostInfo
acs_version = etree.SubElement(self.bench_info, "AcsVersion")
# Set AcsVersion value
acs_version.text = Util.get_acs_release_version()
def _setup(self, **kwargs):
"""
This function initializes all global variables used in acs execution.
It parses the arguments given to CampaignEngine,
parses XML files associated & read the campaign content
for the TestCaseManager to execute.
:param device_name: Device model under test.
:type device_name: str
:param serial_number: Device id or serial number of the DUT.
:type serial_number: str
:param campaign_name: Campaign xml file to execute.
:type campaign_name: str
:param campaign_relative_path: Campaign relative path.
:type campaign_relative_path: str
:param bench_config: Bench Config file to use.
:type bench_config: str
:param device_parameters: List of device parameters to override default values in Device_Catalog.
:type device_parameters: list
:param flash_file_path: Flash file full path.
:type flash_file_path: str
:param random_mode: Enable random mode if your campaign is configured to run random TC.
:type random_mode: bool
:param user_email: Valid user email.
:type user_email: str
:param credentials: Credentials in User:Password format.
:type credentials: str
:rtype: bool
:return: True if setup is correctly done, else False
"""
status = None
device_name = kwargs["device_name"]
serial_number = kwargs["serial_number"]
campaign_name = kwargs["campaign_name"]
campaign_relative_path = kwargs["campaign_relative_path"]
device_parameters = kwargs["device_parameter_list"]
random_mode = kwargs["random_mode"]
user_email = kwargs["user_email"]
credentials = kwargs["credentials"]
log_level_param = kwargs["log_level"]
# In case the uuid is not set, generate it to ensure that the campaign has an id
# This id is used for reporting purpose
self.__logger.info('Checking metacampaign UUID integrity...')
metacampaign_uuid = kwargs["metacampaign_uuid"]
valid_uuid = is_uuid4(metacampaign_uuid)
if not valid_uuid:
self.__logger.warning("Metacampaign UUID is empty or not a valid UUID4; a new one is generated ...")
metacampaign_uuid = metacampaign_uuid if valid_uuid else str(uuid.uuid4())
self.__logger.info("Metacampaign UUID is {0}".format(metacampaign_uuid))
self.__init_configuration(**kwargs)
# Init Campaign report path
self.__init_report_path(campaign_name)
# Instantiate a live reporting interface
campaign_name = os.path.splitext(os.path.basename(campaign_name))[0]
self.__init_live_reporting(campaign_name,
metacampaign_uuid,
user_email,
kwargs.get("live_reporting_plugin"))
self.__stop_on_critical_failure = Util.str_to_bool(
self.__global_config.campaignConfig.get("stopCampaignOnCriticalFailure", "False"))
self.__stop_on_first_failure = Util.str_to_bool(
self.__global_config.campaignConfig.get("stopCampaignOnFirstFailure", "False"))
# Provide the global configuration for equipment manager and device manager
# They will use it to retrieve or set values in it.
EquipmentManager().set_global_config(self.__global_config)
DeviceManager().set_global_config(self.__global_config)
# Initialize equipments necessary to control DUT (io card, power supply, usb hub)
EquipmentManager().initialize()
# Read serial number if given as ACS command line
if serial_number not in ["", None]:
# Priority to serialNumber from --sr parameter
device_parameters.append("serialNumber=%s" % str(serial_number))
# Load the device
device = DeviceManager().load(device_name, device_parameters)[Util.AcsConstants.DEFAULT_DEVICE_NAME]
# store the device config file
device_conf_list = []
for dev in DeviceManager().get_all_devices():
device_config_file = dev.get_config("DeviceConfigPath")
if device_config_file:
device_conf_list.append(device_config_file)
self._campaign_elements.update({"devices": device_conf_list})
# Init the logger
self.__init_logger(device.hw_variant_name, serial_number, self.campaign_report_path, metacampaign_uuid)
self.__logger.info('Checking acs version : %s' % str(Util.get_acs_release_version()))
if self.__test_case_conf_list:
if random_mode:
self.__test_case_conf_list = self.__randomize_test_cases(self.__test_case_conf_list)
# Parse parameter catalog
parameter_catalog_parser = ParameterCatalogParser()
self.__global_config.__setattr__("parameterConfig", parameter_catalog_parser.parse_catalog_folder())
# Retrieve MTBF custom parameter to align logging level between the console and the log file
is_logging_level_aligned = Util.str_to_bool(
self.__global_config.campaignConfig.get("isLoggingLevelAligned", "False"))
# Set log level according to global_config file content
if log_level_param:
logging_level = log_level_param
else:
logging_level = self.__global_config.campaignConfig.get("loggingLevel", "DEBUG")
ACSLogging.set_log_level(logging_level, is_logging_level_aligned)
# Set campaign_type when it exists
campaign_type = self.__global_config.campaignConfig.get("CampaignType")
# Set credentials
self.__global_config.__setattr__("credentials", credentials)
# Init reports
self.__init_reports(self.campaign_report_path,
device_name, campaign_name, campaign_relative_path,
campaign_type, user_email, metacampaign_uuid)
# Creates Test case Manager object
self.__test_case_manager = TestCaseManager(self.__test_report,
live_reporting_interface=self._live_reporting_interface)
# Setup Test Case Manager
tcm_stop_execution = self.__test_case_manager.setup(self.__global_config,
self.__debug_report,
self.__test_case_conf_list[0].do_device_connection)
status = tcm_stop_execution
else:
status = AcsBaseException.NO_TEST
return status