def find_elements(self, *loc):
try:
if len(self.driver.find_elemnts(*loc)):
return self.driver.find_elemnts(*loc)
except AttributeError as e:
logger.error(str(e))
print('Страница не найдена %s' % e)
def _search(self, query, context=None):
"""Search the iTunes API for an album track matching the provided query
"""
if context is not None:
self.context.update(context)
results = itunes.search_track(query)
track = self._filter_results(results)
LOGGER.info('iTunes Search Result: %s', str(track))
if track is None:
LOGGER.error('{} not found in iTunes'.format(query))
return
self.context.update(dict(Album=track.album,
Genre=track.genre,
contentID=track.id,
Copyright=track.album.copyright))
# Albumart
url = track.artwork.get('600', '')
artwork = self.has_artwork(url.value)
if artwork:
self.context['Artwork'] = artwork
self.context['Track #'] = '{}/{}'.format(self.context['Track #'],
track.album.track_count)
self.context['Release Date'] = track.album.release_date_raw
self.context['Album Artist'] = self.context['Artist']
if track.json['trackExplicitness'].lower() == 'explicit':
self.context['_explicit'] = 'Explicit'
def execute_script(self, *loc):
try:
return self.driver.execute_script(*loc)
except AttributeError as e:
logger.error(str(e))
print('except execute_script %s' % e)
return None
def download_and_unzip(url: str) -> str:
"""Download and unzip a multi-zip file"""
dest_dir = mkdtemp(prefix=f"{settings.tmp_file_prefix}")
logger.info(f"Saving to {dest_dir}")
filename = get_filename_from_url(url)
try:
response = http.get(url)
except Exception as e:
logger.error(e)
save_path = Path(dest_dir) / filename
with save_path.open("wb+") as fh:
fh.write(response.content)
logger.info(f"Wrote file to {save_path}")
with ZipFile(save_path) as zf:
zf.extractall(dest_dir)
os.remove(save_path)
for _, _, files in os.walk(dest_dir):
for file in files:
file_path = Path(dest_dir) / file
if file_path.suffix.lower() == ".zip":
with ZipFile(file_path) as zf:
zf.extractall(dest_dir)
os.remove(file_path)
return dest_dir
def get_solar_capacities() -> pd.DataFrame:
solar_capacity_base_url = "https://opendata.cbs.nl/ODataApi/odata/82610ENG/UntypedDataSet?$filter=((EnergySourcesTechniques+eq+%27E006590+%27))+and+("
START_YEAR = 2010
end_year = arrow.now().year
years = list(range(START_YEAR, end_year + 1))
url_solar_capacity = copy(solar_capacity_base_url)
for i, year in enumerate(years):
if i == len(years) - 1:
url_solar_capacity += f"(Periods+eq+%27{year}JJ00%27))"
else:
url_solar_capacity += f"(Periods+eq+%27{year}JJ00%27)+or+"
solar_capacity_df = pd.DataFrame(columns=["datetime", "capacity (MW)"])
try:
r = requests.get(url_solar_capacity)
per_year_capacity = r.json()["value"]
except Exception as e:
logger.error(f"Error fetching solar capacities: {e}")
return solar_capacity_df
for yearly_row in per_year_capacity:
capacity = float(yearly_row["ElectricalCapacityEndOfYear_8"])
datetime = arrow.get(yearly_row["Periods"].split("JJ")[0]).format()
solar_capacity_df = solar_capacity_df.append(
{"datetime": datetime, "capacity (MW)": capacity}, ignore_index=True
)
solar_capacity_df.datetime = pd.to_datetime(solar_capacity_df.datetime)
solar_capacity_df = solar_capacity_df.set_index("datetime")
return solar_capacity_df
async def _set_video_call_status(
self,
params: dict,
):
result = {
'result': 'OK',
}
stopped_status = params['stopped_status'] \
if 'stopped_status' in params else None
paused_status = params['paused_status'] \
if 'paused_status' in params else None
try:
chat_id = int(params['chat_id'])
await self._app.set_video_call_status(
chat_id,
stopped_status,
paused_status,
self._cache_user_peer.get(chat_id),
)
except Exception as e:
logger.error(f'SetVideoCallStatus: {e}')
result = {
'result': str(e),
}
return result
def find_elements(self, *loc):
try:
if len(self.driver.find_elemnts(*loc)):
return self.driver.find_elemnts(*loc)
except AttributeError as e:
logger.error(str(e))
print('页面找不到 %s' %e)
def verify_cdn_vic_fw_update(self, cimc_util_obj, config, common_config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-020
Test Case: Check CDN upgrade VIC Firmware
Pass/Fail Criteria: CDN Name should retain even after Firmware upgrade
'''
logger.info('To Verify CDN after VIC Firmware Upgrade')
#vic_fw_image = '/auto/savbu-rack-builds01/firmware-containers/delnorte1/freel_peak_mr2/3.0.2.26/images/Palo/fw/serenofw.bin'
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
try:
vic_fw_image = os.environ['VIC_FW_IMAGE']
logger.info('VIC FW Image:' + vic_fw_image)
except KeyError:
self.skipped('VIC FW IMAGE not provided in the env, please set system image and run',\
goto=['cleanup'])
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
fw_utils_obj = FirmwareUtils(cimc_util_obj, common_config)
vic_list = config.inventory_detail
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating vNIC interface'''
dev_list = ['7', '8']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
logger.info('Fetch CDN info before VIC Update')
cdn_before_update = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_before_update is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
logger.info('Start updating VIC firmware component')
if fw_utils_obj.update_vic_firmware(slot_no,
vic_fw_image) is not True:
self.failed('Failed to Update the VIC firmware',
goto=['cleanup'])
logger.info('Fetch CDN info after VIC Update')
cdn_after_update = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_after_update is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
match = True
for key in cdn_before_update.keys():
if key in cdn_after_update.keys():
if cdn_before_update[key] != cdn_after_update[key]:
logger.error('CDN name Before:' +cdn_before_update[key] + 'After Update: '\
+ cdn_after_update[key])
match = False
else:
logger.info('CDN name before update:' +cdn_before_update[key] + \
'After Update:' + cdn_after_update[key])
if match is True:
logger.info('CDN Name retained before and after BIOS upgrade')
self.passed('Test Passed')
else:
logger.info('CDN Name failed to retain after BIOS upgrade')
self.failed('Test Failed')
def execute_async_script(self, *loc):
try:
self.driver.set_script_timeout(60) #120
data = self.driver.execute_async_script(*loc)
except AttributeError as e:
logger.error(str(e))
print('except execute_async_script %s' % e)
data = None
return data
def connect(self) -> str:
if not self.db.isValid():
self.db = QSqlDatabase.addDatabase("QSQLITE")
if not self.db.isValid():
logger.error("Cannot add db")
write_dir = QDir("")
if not write_dir.mkpath("."):
logger.error("Failed to create writable directory")
return write_dir.absoluteFilePath(f"{self.name}.db")
def verify_cdn_cimc_Reboot(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-007
Test Case: To create maximum vNIC
'''
logger.info('To Verify CDN after CIMC reboot')
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
bios_obj = cimc_util_obj.bios_util_obj
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating vNIC interface'''
dev_list = ['11']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
logger.info('Fetch CDN info before cimc reboot')
cdn_before_reboot = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_before_reboot is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
logger.info('Reboot BMC')
res = cimc_util_obj.reboot_bmc_and_connect(config)
if res is not True:
self.failed('Failed to reboot and connect back',
goto=['cleanup'])
logger.info('Fetch CDN info after CIMC reboot')
cdn_after_reboot = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_after_reboot is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
match = True
for key in cdn_before_reboot.keys():
if key in cdn_after_reboot.keys():
if cdn_before_reboot[key] != cdn_after_reboot[key]:
logger.error('CDN name Before:' +cdn_before_reboot[key] + \
'After Reboot: ' + cdn_after_reboot[key])
match = False
else:
logger.info('CDN name before reboot:' +cdn_before_reboot[key] + \
'After Reboot:' + cdn_after_reboot[key])
if match is True:
logger.info('CDN Name retained before and after CIMC reboot')
self.passed('Test Passed')
else:
logger.info('CDN Name failed to retain after CIMC reboot')
self.failed('Test Failed')
def configure_modify_delete_cdn(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-004
RACK-BIOS-DN-CDN-VIC-005
RACK-BIOS-DN-CDN-VIC-006
Test Case: To Configure CDN for vNIC
To Modify CDN for vNIC
To Delete CDN for vNIC
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
logger.info('VIC list: ' + str(vic_list))
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating 2 vNIC interface'''
self.created_vnic_list = []
'''creating 2 vNIC interface'''
dev_list = ['1', '2']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
res1 = vic_obj.powercycle_and_verify_cdn_on_cimc_and_host(slot_no)
''' modify one vnic and delete one vnic and verify'''
val = self.created_vnic_list[0]
slot_no = val.split(' ')[0]
dev_name = val.split(' ')[1]
res = vic_obj.modify_vnic_properties(slot_no, dev_name, 'CDN',
'modified_' + dev_name)
if res is not True:
logger.error('Failed to modify the CDN name attribute of vNIC')
else:
self.created_vnic_list.append(slot_no + ' ' + dev_name)
'''Deleting the vNIC interface'''
val = self.created_vnic_list[1]
slot_no = val.split(' ')[0]
dev_name = val.split(' ')[1]
if vic_obj.delete_vnic(slot_no, dev_name) != True:
logger.error('Failed to delete vNIC ethernet interface ' +
dev_name)
res2 = vic_obj.powercycle_and_verify_cdn_on_cimc_and_host(slot_no)
if res1 == False & res2 == False:
self.failed('Test cases failed')
else:
self.passed('Test Case Passed')
def configure_modify_delete_cdn(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-004
RACK-BIOS-DN-CDN-VIC-005
RACK-BIOS-DN-CDN-VIC-006
Test Case: To Configure CDN for vNIC
To Modify CDN for vNIC
To Delete CDN for vNIC
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['next_tc'])
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
logger.info('Creating vNIC interface with unique name and verify')
for dev in ['one_', 'two_']:
dev_name = 'eth_dev_' + dev + str(i)
cdnname = 'cdn_' + dev_name
res = vic_obj.create_vnic(slot_no, dev_name, cdn_name=cdnname)
if res is not True:
logger.error('Failed to create vNIC interface')
self.failed('Failed to create vNIC', goto=['cleanup'])
else:
self.created_vnic_list.append(dev_name)
logger.info(
'Successfully created vNIC with device name: ' +
dev_name)
res1 = vic_obj.powercycle_and_verify_cdn_on_windows(slot_no)
# Windows requires driver re-installation on every modification to vNIC CDN
# Hence commenting out modify delete verification part on windows side.
'''
logger.info('Modify the CDN name for vNIC and verify')
for x, dev_name in enumerate(self.created_vnic_list, 1):
if vic_obj.modify_vnic_properties(slot_no, dev_name, 'CDN', 'modified_cdn_'+str(x)) is not True:
logger.warning('Failed to modify the CDN name attribute of vNIC')
res2 = vic_obj.powercycle_and_verify_cdn_on_windows(slot_no)
logger.info('Deleting the vNIC interface and verify')
for dev in created_vnic_list:
if vic_obj.delete_vnic(slot_no, dev) != True:
logger.warning('Failed to delete vNIC ethernet interface ' + dev)
res3 = vic_obj.powercycle_and_verify_cdn_on_windows(slot_no)
'''
if res1 == False:
self.failed('Test cases failed')
else:
self.passed('Test Case Passed')
def handle(self, line):
if self.type == "one_line":
if self.pattern.search(line):
self.state = "passed"
elif self.type == "multi_line" and self.ordered:
if (self.next_pattern < len(self.patterns)
and self.patterns[self.next_pattern].search(line)):
self.next_pattern += 1
if self.next_pattern >= len(self.patterns):
self.state = "passed"
elif self.type == "multi_line" and not self.ordered:
for i, pattern in enumerate(self.patterns):
r = self.regex[i]
if pattern.search(line) and not r in self.matches:
self.matches[r] = line
if len(self.matches) == len(self.regex):
self.state = "passed"
else:
logger.error("Unknown harness_config type")
if self.fail_on_fault:
if self.FAULT in line:
self.fault = True
if self.GCOV_START in line:
self.capture_coverage = True
elif self.GCOV_END in line:
self.capture_coverage = False
if self.record:
pattern = re.compile(self.record.get("regex", ""))
match = pattern.search(line)
if match:
csv = []
if not self.fieldnames:
for k, v in match.groupdict().items():
self.fieldnames.append(k)
for k, v in match.groupdict().items():
csv.append(v.strip())
self.recording.append(csv)
self.process_test(line)
tc = self.instance.get_case_or_create(self.id)
if self.state == "passed":
tc.status = "passed"
else:
tc.status = "failed"
def cdn_enable_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-003
Test Case: To Check CDN is Enabled from CIMC
'''
vic_list = config.inventory_detail
logger.info('VIC list are: ' + str(vic_list))
bios_obj = cimc_util_obj.bios_util_obj
host_util = HostUtils()
boot_order_obj = BootOrder(cimc_util_obj)
status = host_util.check_host_up(cimc_util_obj, boot_order_obj, config)
if status is False:
logger.warning(
'Host OS is not pinging after setting the boot order to HDD ')
bios_token = 'cdnEnable'
token_new_value = 'Enabled'
logger.info('Power on the host')
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
host_ip = get_host_mgmt_ip(config)
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == token_new_value:
logger.info('CDN is already enabled on CIMC')
else:
logger.info('Set the cdnEnable token Enable and Reboot the host')
res = bios_obj.set_bios_token_value(bios_token, token_new_value)
if res is False:
logger.error('Failed to set bios token value')
self.failed('Failed to set bios token value', goto=['cleanup'])
'''Wait for host to reboot'''
res = cimc_util_obj.verify_host_up(host_ip,
wait_for_ping_fail=False,
wait_time=400)
if res is False:
logger.warning('Failed to ping the host after host reboot')
self.failed('Failed to ping host', goto=['cleanup'])
scope = 'advanced'
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == token_new_value:
self.passed(
'Successfully verified that CDN token can be enabled from CIMC'
)
else:
self.failed('Failed to verify that CDN token,\
Expected is:' + token_new_value + ' But got as: ' +
token_val)
def HuuCompare(self, cimc_util_obj, testbed_name, config):
config_parser = ConfigParser(testbed_name)
config_parser.load_config(testbed_name)
mgmt_handle = cimc_util_obj.handle
output = mgmt_handle.execute_cmd_list('top', 'scope chassis',
'show pci-adapter detail')
logger.info(output)
pci_card_details_cimc = {}
pci_card_details_toc = {}
pci_card = re.findall(r'product-name:*\s+([^\r\n]+)', output)
pci_card_version = re.findall(r'fw-version:*\s+([^\r\n]+)', output)
for (card, version) in zip(pci_card, pci_card_version):
pci_card_details_cimc[card] = version
#cmd_str = 'cat /data/home/kgeevane/grit_code/rackauto/tests/TOC_DELNORTE1.xml'
#toc_out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT).decode(encoding='utf_8', errors='strict')
toc_out = cimc_util_obj.get_release_note_content(config)
for pci_card in pci_card_details_cimc.keys():
card_name_toc = config_parser.config.get('PciAdapterFWVersion',
pci_card)
logger.info(card_name_toc)
regex = r'component\s*name\=\"' + \
card_name_toc + r'\".*?version\s*\=\"(.*?)\"'
# Getting version from TOC file.
pci_card_details_toc[pci_card] = re.search(regex, toc_out).group(1)
logger.info("######## PCI CARD CIMC##############")
logger.info(pci_card_details_cimc)
logger.info("######## PCI CARD TOC ##############")
logger.info(pci_card_details_toc)
logger.info("####################################")
pass_flag = 1
for pci_card_cimc in pci_card_details_cimc.keys():
if pci_card_details_cimc[pci_card_cimc] in pci_card_details_toc[
pci_card_cimc]:
logger.info("PCI card " +
pci_card_details_cimc[pci_card_cimc] +
" version matches with TOC file")
else:
logger.error("PCI card " +
pci_card_details_cimc[pci_card_cimc] +
" version not matches with TOC file")
pass_flag = 0
if pass_flag == 1:
self.passed(
"Successfully verified all the cards versions with TOC xml")
else:
self.failed("Card verification with TOC xml got failed")
async def main():
redis = await aioredis.create_redis_pool(REDIS_URI)
async def publish(number):
await redis.lpush(NUMBERS_QUEUE, number)
async with aiohttp.ClientSession(
headers={'Authorization': f'JWT {ACCESS_TOKEN}'}) as session:
while True:
try:
numbers = await limit_wrap(session)
product = numbers[0] * numbers[1]
if product > 100000:
await publish(product)
except Exception as e:
logger.error(e)
await sleep(RATE_LIMIT)
def create_vnic_interface(self, vic_obj, slot_no, dev_list=[]):
vnic_create = None
#for dev in dev_list:
for dev in dev_list:
dev_name = 'eth_dev_' + dev + str(slot_no)
cdnname = 'cdn_' + dev_name
res = vic_obj.create_vnic(slot_no, dev_name, cdn_name=cdnname)
if res is not True:
logger.error('Failed to create vNIC interface for dev name: ' +
dev_name)
vnic_create = 'failed'
else:
logger.info('Successfully created vNIC with device name: ' +
dev_name)
self.created_vnic_list.append(slot_no + ' ' + dev_name)
if vnic_create == 'failed':
return False
else:
return True
def get_wind_capacities() -> pd.DataFrame:
url_wind_capacities = "https://api.windstats.nl/stats"
capacities_df = pd.DataFrame(columns=["datetime", "capacity (MW)"])
try:
r = requests.get(url_wind_capacities)
per_year_split_capacity = r.json()["combinedPowerPerYearSplitByLandAndSea"]
except Exception as e:
logger.error(f"Error fetching wind capacities: {e}")
return capacities_df
per_year_capacity = {
f"{year}-01-01 00:00:00+00:00": sum(split.values())
for (year, split) in per_year_split_capacity.items()
}
capacities_df["datetime"] = pd.to_datetime(list(per_year_capacity.keys()))
capacities_df["capacity (MW)"] = list(per_year_capacity.values())
capacities_df = capacities_df.set_index("datetime")
return capacities_df
def cdn_duplicate_name_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-014
Test Case: Create Duplicate CDN Names
Pass/Fail Criteria: Should not able to create Duplicate Names
Author: lakkris2
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
for dev_ in ['3']:
dev_name = 'ethi_dev_' + str(dev_) + str(slot_no)
cdnname = 'cdnk_' + dev_name
res = vic_obj.create_vnic(slot_no, dev_name, cdn_name=cdnname)
if res is not True:
logger.error('Failed to create vNIC interface')
self.failed('Failed to create vNIC', goto=['cleanup'])
else:
self.created_vnic_list.append(slot_no + ' ' + dev_name)
logger.info(
'Successfully created vNIC with device name: ' +
dev_name)
''' Creating vnic interface with Duplicate cdn name '''
dev_name1 = 'dup_vnic_name'
logger.info('Creating vnic interface {} with duplicate CDN {} name'\
.format(dev_name1, cdnname))
out = vic_obj.create_vnic(slot_no, dev_name1, cdn_name=cdnname)
if 'Duplicate CDN name exists, discarding it' in out:
self.passed(
'Failed to created duplicate CDN name, as expected')
else:
self.failed('Able to create duplicate vNIC interface, Not expected',\
goto=['cleanup'])
def browse(self,
origin,
getFile=False,
windowTitle="Browse",
fStr="All files (*)",
uiEdit=None,
subscribe_callable=None):
browse_dir = getattr(uiEdit, "text", lambda: "")()
if getFile:
selectedPath = QFileDialog.getOpenFileName(origin, windowTitle,
browse_dir, fStr)[0]
else:
selectedPath = QFolderDialog.getExistingDirectory(
origin, windowTitle, browse_dir)[0]
if getattr(uiEdit, "setText"):
uiEdit.setText(self.resolvePath(selectedPath))
if subscribe_callable:
try:
subscribe_callable(self.resolvePath(selectedPath))
except Exception as why:
logger.error(why)
def parse(self, combinations):
self.logger.info("Parsing using %s" % self.__class__.__name__)
data = list()
try:
dfs = list()
for comb_dir_path, comb in combinations:
comb_dir_path = Path(comb_dir_path)
is_valid = True
for filepath in comb_dir_path.rglob('filebench*'):
metadata, df_operations = self.parse_filebench_format(
filepath)
if metadata is None and df_operations is None:
is_valid = False
break
df_operations['_id'] = comb['_id']
dfs.append(df_operations)
if not is_valid:
logger.error('Combination: %s is not valid' %
comb_dir_path)
continue
df_operations = pd.concat(dfs)
for (_id, op_name), group in df_operations.groupby(['_id',
'name']):
operation = {
'op_name': op_name,
'ops': group['ops'].sum(),
'ops_per_sec': group['ops_per_sec'].mean(),
'mb_per_sec': group['mb_per_sec'].mean(),
'latency': group['latency'].mean(),
'_id': _id,
}
if op_name != 'summary':
operation['range_lower'] = group['range_lower'].min()
operation['range_upper'] = group['range_upper'].max()
data.append(operation)
except IOError as e:
self.logger.error(str(e))
return pd.DataFrame(data)
def click_button(self, *loc):
try:
self.find_element(*loc).click()
except AttributeError as e:
logger.error(str(e))
print('Страница не найдена %s' % e)
def load_default_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-011
Test Case: Check CDN by setting to BIOS Load default
Pass/Fail Criteria: 1. CDN setting should go to Defaut Value Disabled
2. Existing CDN Names should get retain
author: lakkris2
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
bios_obj = cimc_util_obj.bios_util_obj
bios_token = 'cdnEnable'
cdn_token_enable = 'Enabled'
scope = 'advanced'
host_ip = get_host_mgmt_ip(config)
bios_obj.set_bios_token_value(bios_token, cdn_token_enable)
token_val = bios_obj.get_bios_token_value(bios_token)
if token_val == cdn_token_enable:
logger.info(
'Successfully verified that CDN token can be enabled from CIMC'
)
else:
self.failed('Failed to verify that CDN token,\
Expected is:' + cdn_token_enable + ' But got as: ' + token_val,
goto=[cleanup])
res = cimc_util_obj.verify_host_up(host_ip, wait_for_ping_fail=False)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
test_fail = '0'
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating vNIC interface'''
dev_list = ['13']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
logger.info('Fetch VIC and CDN info before bios load defaults')
cdn_before_default = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_before_default is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
'''performing Bios default '''
if bios_obj.load_bios_defaults() is not True:
self.failed('Failed to run bios defaults', goto=['cleanup'])
res = cimc_util_obj.verify_host_up(host_ip,
wait_for_ping_fail=False,
wait_time=400)
if res is False:
logger.warning('Failed to ping the host after host reboot')
else:
logger.info("Host name IP pinging successfully")
'''After Bios Default checking CDN name and CDN setting '''
out = bios_obj.get_bios_token_value(bios_token)
if "Enabled" in out:
self.passed(
"CDN token Enabled after Loading Default bios setting")
else:
self.failed(
'Failed to Set CDN to Enabled after bios default, but got as:'
+ out)
logger.info('Fetch VIC and CDN info after bios load default')
cdn_after_default = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_after_disbale is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
test_fail = '0'
host_dict = vic_obj.host_cdn_mac_dict(cimc_util_obj.host_handle,
'biosdevname -d')
cdn_name_from_host = []
for cdn_name_from_host1 in host_dict.values():
cdn_name_from_host.append(cdn_name_from_host1)
if "LOMPort1" and "LOMPort2" not in cdn_name_from_host:
logger.info(
"LOMPort1 and LOMPort2 available in Host OS, when CDN Enabled"
)
else:
logger.error(
'LOMPort1 and LOMPort2 are not available in Host OS, when CDN Enabled'
)
test_fail = '1'
match = True
for key in cdn_before_default.keys():
if key in cdn_after_default.keys():
if cdn_before_default[key] != cdn_after_default[key]:
logger.error('CDN name Before:' +cdn_before_default[key] + \
'After Disable: ' + cdn_after_default[key])
match = False
else:
logger.info('CDN name before reboot:' +cdn_before_default[key] + \
'After Disable:' + cdn_after_default[key])
if match is True:
logger.info(
'CDN Name retained before and after bios load default')
else:
logger.info('Failed to retain Vnic after bios load default')
test_fail = '1'
mac_match = True
for mac in cdn_before_default.values():
if mac in cdn_after_default.values():
if cdn_before_default[mac] != cdn_after_default[mac]:
logger.error('CDN name Before:' +cdn_before_default[mac] + \
'After Disable: ' + cdn_after_default[mac])
mac_match = False
else:
logger.info('CDN name before reboot:' +cdn_before_default[mac] + \
'After Disable:' + cdn_after_default[mac])
if mac_match is True:
logger.info(
'CDN Name retained before and after bios load default')
else:
logger.info('Failed to retain Vnic after bios load default')
test_fail = '1'
if test_fail == '1':
self.failed('Test case failed')
else:
self.passed('Test case passed')
def disable_cdn_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-010
Test Case: To Verify CDN token Disabled
Pass/Fail: Existing CDN named should be retained and
CDN name should not get changed.
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
self.created_vnic_list = []
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
bios_obj = cimc_util_obj.bios_util_obj
bios_token = 'cdnEnable'
token_new_value = 'Disabled'
host_ip = get_host_mgmt_ip(config)
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
'''creating vNIC interface'''
dev_list = ['12']
if create_vnic_interface(self, vic_obj, slot_no,
dev_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
logger.info(
'Fetch VIC and CDN info before disabling the CDN token')
cdn_before_disable = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_before_disable is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
logger.info('Disable the Bios CDN token')
if bios_obj.set_bios_token_value(bios_token,
token_new_value) is not True:
self.failed('Failed to set bios token value', goto=['cleanup'])
'''Wait for host to reboot'''
res = cimc_util_obj.verify_host_up(host_ip,
wait_for_ping_fail=False,
wait_time=400)
if res is not True:
self.failed('Failed to ping host', goto=['cleanup'])
logger.info('Fetch VIC and CDN info after disabling CDN token')
cdn_after_disbale = vic_obj.cimc_cdn_mac_dict(slot_no)
if cdn_after_disbale is False:
self.failed('CIMC CDN mac list is empty', goto=['cleanup'])
match = True
for key in cdn_before_disable.keys():
if key in cdn_after_disbale.keys():
if cdn_before_disable[key] != cdn_after_disbale[key]:
logger.error('CDN name Before:' +cdn_before_disable[key] + \
'After Disable: ' + cdn_after_disbale[key])
match = False
else:
logger.info('CDN name before reboot:' +cdn_before_disable[key] + \
'After Disable:' + cdn_after_disbale[key])
if match is True:
logger.info(
'CDN Name retained before and after disable of bios CDN token'
)
self.passed('Test Passed')
else:
logger.info(
'Failed to retain Vnic after disabling CDN bios token')
self.failed('Test Failed')
def click_button(self, *loc):
try:
self.find_element(*loc).click()
except AttributeError as e:
logger.error(str(e))
print('页面找不到 %s' %e)
def execute_script(self, *loc):
try:
return self.driver.execute_script(*loc)
except AttributeError as e:
logger.error(str(e))
print('execute_script %s' %e)
def max_vnic_cdn_test(self, cimc_util_obj, config):
'''
Logical ID: RACK-BIOS-DN-CDN-VIC-007
Test Case: Create CDN with max vNIC and OS Reboot Stress
Pass/Fail Criteria: CDN naming should appearing correcly in CIMC WebUI and in windows OS also
author: lakkris2
'''
vic_list = []
vic_obj = VicLib(cimc_util_obj, config)
vic_list = config.inventory_detail
os_reboot_count = 1 #For OS reboot stress
if cimc_util_obj.set_host_power('on') is False:
self.failed('Failed to power on host', goto=['cleanup'])
logger.info('VIC list are =============>>> ' + str(vic_list))
test_fail = '0'
for vic in vic_list:
logger.info('vic slot number is: ' + vic.slot_number)
slot_no = vic.slot_number
out = vic_obj.cimc_cdn_mac_dict(slot_no)
cdn_name_from_cimc = []
del cdn_name_from_cimc[:]
for name in out.values():
cdn_name_from_cimc.append(name)
logger.info('CDN name from CIMC are')
logger.info(cdn_name_from_cimc)
length_exist_vnic = len(cdn_name_from_cimc)
logger.info(length_exist_vnic)
Remaining_vnic = 16 - length_exist_vnic
logger.info('Remaining vnic count: ' + str(Remaining_vnic))
remain_vnic_list = []
for val in range(Remaining_vnic):
remain_vnic_list.append(str(val))
logger.info('remaining vnics to be created' +
str(remain_vnic_list))
'''creating vNIC interface '''
self.created_vnic_list = []
if create_vnic_interface(self, vic_obj, slot_no,
remain_vnic_list) is not True:
self.failed('Failed to create vnic interface',
goto=['cleanup'])
#for dev_list in range(Remaining_vnic):
# logger.info('Device list are:' + str(dev_list))
# if create_vnic_interface(self, vic_obj, slot_no, str(dev_list)) is not True:
# self.failed('Failed to create vnic interface', goto=['cleanup'])
test_fail = '0'
for power_cycle_cnt in range(os_reboot_count):
logger.info("System reboot count #: " + str(power_cycle_cnt))
res = vic_obj.powercycle_and_verify_cdn_on_cimc_and_host(
slot_no)
if res is False:
logger.error('CDN name miss match between OS and CIMC after max vnic creation',\
goto=['cleanup'])
test_fail = '1'
else:
logger.info(
'CDN name matched between OS and CIMC after max vnic creation'
)
if test_fail == '1':
self.failed('Test Failed')
else:
self.passed('Test Passed')
def wait_activity(self, *loc):
try:
return self.driver.wait_activity(*loc)
except AttributeError as e:
logger.error(str(e))
print('Страница не найдена %s' % e)
with engine.connect() as conn:
query = text("SELECT * FROM Mymacnode WHERE "
"ID < 100 AND "
"parentID = 1 "
"ORDER BY ID ASC")
rs = conn.execute(query)
r = rs.first()
if r is not None:
print("ok")
else:
print("error")
except Exception as ex:
logger.error("Error querying for next queued task: %s" % str(ex),
exc_info=True)
for i in range(10):
pnode = s.query(Mymacnode).filter(Mymacnode.ID == i).first()
pid = pnode.ID
pAddress = pnode.Address
node = s.query(Mymacnode).filter(Mymacnode.ID % 10 == i,
Mymacnode.ID > 10).update({
Mymacnode.parentID:
f"{pid}",
Mymacnode.parentAddress:
f"{pAddress}"
})
#node = s.query(Mymacnode).filter(Mymacnode.ID==2).update({Mymacnode.parentID:"1"})
#node = s.query(Mymacnode).filter(Mymacnode.ID<=10, Mymacnode.ID >2).update({Mymacnode.parentID:"1"})
# 此处的node表示更新的行数
def wait_activity(self, *loc):
try:
return self.driver.wait_activity(*loc)
except AttributeError as e:
logger.error(str(e))
print('页面找不到 %s' %e)
def swipe(self, *loc):
try:
return self.driver.swipe(*loc)
except AttributeError as e:
logger.error(str(e))
print('ошибка эмуляции мобильника %s' % e)
def swipe(self, *loc):
try:
return self.driver.swipe(*loc)
except AttributeError as e:
logger.error(str(e))
print('swipe %s' %e)
distrFolletos[elem] = (elem+1,len(hojas)+1,0,0)
anchoLocal = m-folletos[elem][1]
hojas.append((anchoLocal,altoLocal,0))
break
else:
distrFolletos[elem] = (elem+1,i+1,m-anchoLocal,pivote)
anchoLocal -= folletos[elem][1]
hojas[i] = (anchoLocal,altoLocal,pivote) #guardamos estado
break
return distrFolletos
def muestra_solucion(solucion: "List<PosicionFolleto>"):
path = "C:\\Users\\Abrahan\\PycharmProjects\\Practicas-Algoritmia\\entregable2\\e2_aux\\solution\\" # windows
# path = "solution/" #linux
title = 'Solution.txt'
new_file = open(path + title, 'w')
for elem in solucion:
new_file.write("{0} {1} {2} {3}\n".format(elem[0],elem[1],elem[2],elem[3]))
new_file.close()
if(len(sys.argv) < 2):
logger.error("Te has dejado el argumento del fichero.")
exit(1)
m,folletos = lee_fichero_imprenta(sys.argv[1])
solucion = optimiza_folletos(m, folletos)
muestra_solucion(solucion)
