def NASShareApiDelete():
Failflag = False
# get NASShare id
NASShareId = []
ResponseInfo = server.webapi('get', 'nasshare?page_size=100')
NASShareInfo = json.loads(ResponseInfo['text'])
for info in NASShareInfo:
NASShareId.append(info["id"])
# To delete NASShare by api
tolog('To delete NASShare by aip')
for i in NASShareId:
tolog('Expect: Delete NASShare id is ' + str(i) + '\r\n')
server.webapiurl('delete', 'nasshare', str(i) + '?force=1')
check = server.webapi('get', 'nasshare')
result = json.loads(check["text"])
for r in result:
if r["id"] == i:
Failflag = True
tolog('Fail: NASShare ' + str(i) + ' is not deleted')
if Failflag:
tolog(Fail)
else:
tolog('Actual: NASShare ' + str(i) + ' is deleted \r\n')
tolog(Pass)
def post_global_spare_revertible_0():
FailFlag = False
tolog('add global spare drive that is not revertible by api\r\n')
# test data
pdId2, pdId4 = find_pd_id()
settings = {
"dedicated": 'Global',
"revertible": 0,
"pd_id": pdId4[-1],
"pool_list": []
}
# precondition
server.webapi(
'post', 'pool', {
'name': 'test_spare1',
'raid_level': 'RAID5',
'pds': [pdId2[0], pdId2[1], pdId2[2]]
})
tolog('Expect: ' + json.dumps(settings) + '\r\n')
result = server.webapi('post', 'spare', settings)
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
else:
spareResponse = server.webapi('get', 'spare')
if isinstance(spareResponse, dict):
spareInfo = json.loads(spareResponse["text"])
tolog('Actual: ' + json.dumps(spareInfo[0]) + '\r\n')
for value in settings.values():
if str(value) not in json.dumps(spareInfo[0]):
FailFlag = True
tolog("Fail: please check out parameter " + str(value) +
'\r\n')
server.webapiurl('post', 'phydrv', str(pdId2[0]) + '/offline')
time.sleep(3)
rbResponse = server.webapi('get', 'rebuild')
if isinstance(rbResponse, str):
FailFlag = True
tolog('Fail: ' + rbResponse + '\r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def findPlId():
# get physical drive id
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
for pd in pdInfo[1:]:
if 'Pool' in pd['cfg_status']:
plResponseInfo = server.webapi('get', 'pool')
plInfo = json.loads(plResponseInfo['text'])
for pl in plInfo:
server.webapiurl('delete', 'pool', str(pl['id']) + '?force=1')
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
pdId = []
for pd in pdInfo:
if pd['op_status'] == 'OK' and pd[
'cfg_status'] == 'Unconfigured' and pd['type'] == 'SAS HDD':
pdId.append(pd['id'])
# to create pool
plId = []
createPool1 = server.webapi(
'post', 'pool', {
'name': 'testVolumeApi1',
'sector': '512B',
'raid_level': 'RAID5',
'force_sync': 0,
'pds': [pdId[3], pdId[7], pdId[8]]
})
if isinstance(createPool1, str):
tolog(createPool1)
tolog('Fail: To create pool is failed')
else:
plId.append(0)
createPool2 = server.webapi(
'post', 'pool', {
'name': 'testVolumeApi2',
'sector': '512B',
'raid_level': 'RAID0',
'force_sync': 0,
'pds': [pdId[1]]
})
if isinstance(createPool2, str):
tolog(createPool2)
tolog('Fail: To create pool is failed')
else:
plId.append(1)
return plId
def unexportVolume():
FailFlag = False
tolog('Un-Export volume \r\n')
volumeResponse = server.webapi('get', 'volume/1')
volumeInfo = json.loads(volumeResponse["text"])[0]
if volumeInfo["status"] == "Un-Exported":
# precondition
server.webapiurl('post', 'volume/1', 'export')
time.sleep(1)
tolog('Expect: un-export volume \r\n')
result = server.webapiurl('post', 'volume/1', 'unexport')
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
check = server.webapi('get', 'volume/1')
checkResult = json.loads(check["text"])[0]
if checkResult["status"] != 'Un-Exported':
FailFlag = True
tolog('Fail: To un-export volume is failed\r\n')
else:
tolog('Actual: volume un-export successfully \r\n')
else:
tolog('Expect: un-export volume \r\n')
result = server.webapiurl('post', 'volume/1', 'unexport')
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
check = server.webapi('get', 'volume/1')
checkResult = json.loads(check["text"])[0]
if checkResult["status"] != 'Un-Exported':
FailFlag = True
tolog('Fail: To un-export volume is failed\r\n')
else:
tolog('Actual: un-volume export successfully \r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def NASShareApiFailedTest():
Failflag = False
# test data
settings = [
[5, '1GB', '128KB', 'always', 'latency', 'gzip', 'FailedTest'],
[0, '1KB', '128KB', 'always', 'latency', 'gzip', 'FailedTest'],
[0, '1GB', '1GB', 'always', 'latency', 'gzip', 'FailedTest'],
[0, '1GB', '128KB', 'test', 'latency', 'gzip', 'FailedTest'],
[0, '1GB', '128KB', 'always', 'test', 'gzip', 'FailedTest'],
[0, '1GB', '128KB', 'always', 'latency', 'test', 'FailedTest'],
[0, '1GB', '128KB', 'always', 'latency', 'gzip', '#$@*']
]
expectResult = [
'Empty query result, please check input parameters. Pool id=[5] is not existed',
'[capacity] must between 1GB to 1PB',
'invalid recsize',
'invalid sync',
'invalid logbias',
'invalid compress',
'name contain only alphanumeric characters and underscores'
]
for i in range(7):
tolog('Expect: ' + expectResult[i] + '\r\n')
parameters = {
"pool_id": settings[i][0],
"capacity": settings[i][1],
"recsize": settings[i][2],
"sync": settings[i][3],
"logbias":settings[i][4],
"compress": settings[i][5],
"name": settings[i][6]
}
result = server.webapi('post', 'nasshare', parameters)
if expectResult[i] not in result:
Failflag = True
tolog('Fail: ' + expectResult[i])
else:
tolog('Actual: ' + result + '\r\n')
if Failflag:
tolog(Fail)
else:
tolog(Pass)
# clean up environment
server.webapiurl('delete', 'pool', '0?force=1')
def deleteUser():
Failflag = False
userId = []
userResponse = server.webapi('get', 'user')
userInfo = json.loads(userResponse["text"])
for uId in userInfo:
if uId["id"] != "administrator":
userId.append(uId["id"])
tolog('Delete user by api \r\n')
for i in userId:
tolog('Expect: To delete user ' + i + '\r\n')
result = server.webapiurl('delete', 'user', i)
if isinstance(result, dict):
tolog('Actual: user ' + i + ' is deleted \r\n')
else:
Failflag = True
tolog('Fail: To delete user ' + i + ' is failed')
if Failflag:
tolog(Fail)
else:
tolog(Pass)
def delete_spare():
FailFlag = False
tolog('delete spare drive by api')
# precondition
spareResponse = server.webapi('get', 'spare')
spareInfo = json.loads(spareResponse["text"])
for spare in spareInfo:
tolog('Expect: delete spare drive ' + str(spare["id"]) + '\r\n')
result = server.webapiurl('delete', 'spare', str(spare["id"]))
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
else:
tolog('Actual: spare drive ' + str(spare["id"]) +
' is deleted\r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def delete_test(self, url_parameters, cases_file, sheet_name):
# Open cases file
# data = xlrd.open_workbook('/home/work/zach/clitest/' + data_file_name)
data = xlrd.open_workbook(cases_file)
table = data.sheet_by_name(sheet_name)
for i in range(1, table.nrows):
tolog('Expected: ' + str(table.cell(i, 0).value) +
' should be deleted\n')
result = server.webapiurl('delete', url_parameters,
str(table.cell(i, 0).value))
# Checking status of request
if str(result['response']) != '<Response [200]>':
self.flag = True
tolog('Fail: HTTP status code is ' + str(result['response']))
tolog('Error Message: ' + str(result['text']) + '\n')
continue
else:
tolog('Actual: HTTP status code is ' +
str(result['response']) + ', request is successful!\n')
if self.flag:
tolog(Fail)
else:
tolog(Pass)
def find_pd_id(physical_capacity = None):
pd_id = []
# delete pool
poolResponse = server.webapi('get', 'pool')
if isinstance(poolResponse, dict):
poolInfo = json.loads(poolResponse["text"])
for pool in poolInfo:
server.webapiurl('delete', 'pool', str(pool['id']) + '?force=1')
# delete spare
spareResponse = server.webapi('get', 'spare')
if isinstance(spareResponse, dict):
spareInfo = json.loads(spareResponse["text"])
for spare in spareInfo:
server.webapiurl('delete', 'spare', str(spare["id"]))
# find pd id
pdResponse = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponse["text"])
if physical_capacity == None:
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '2TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["physical_capacity"] == '2 TB' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '4TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["physical_capacity"] == '4 TB' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
return pd_id
def listVolume():
FailFlag = False
tolog('Expect: List all of the volume \r\n')
allResult = server.webapi('get', "volume")
result = json.loads(allResult["text"])
if isinstance(allResult, str):
FailFlag = True
tolog('Fail: ' + allResult)
else:
allVolumeInfo = str(result).replace('{', '').replace('u', '').replace(
'}', '\r\n')
tolog('Actual: All of volumes \r\n' + allVolumeInfo + '\r\n')
tolog('To list specify the volume \r\n')
volumeId = []
for r in result:
volumeId.append(r["id"])
if len(volumeId) > 0:
for i in volumeId:
tolog('Expect: list volume ' + str(i) + '\r\n')
oneResult = server.webapiurl('get', 'volume', str(i))
check = json.loads(oneResult["text"])[0]
if isinstance(oneResult, str) or check["id"] != i:
FailFlag = True
tolog('Fail: To list volume ' + str(i) + ' is failed \r\n')
else:
specifyResult = str(check).replace('u', '')
tolog('Actual: \r\n' + specifyResult + '\r\n')
tolog(
'Expect: Searching volume by volume name contains "n" and pool_name contains "t" \r\n'
)
searchResult = server.webapi(
'get',
"volume?page=1&page_size=25&search=name+like+'%n%' and pool_name+like+'%t%'"
)
if isinstance(searchResult, str):
FailFlag = True
tolog('Fail: ' + searchResult + '\r\n')
else:
search = str(json.loads(searchResult["text"]))
tolog('Actual:\r\n' + search.replace('u', ''))
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def failing_post_spare():
FailFlag = False
# test data
pdId2, pdId4 = find_pd_id()
# precondition
server.webapi(
'post', 'pool', {
'name': 'test_spare1',
'raid_level': 'RAID5',
'pds': [pdId2[0], pdId2[1], pdId2[2]]
})
key = ["dedicated", "revertible", "pd_id", "pool_list"]
values = [['test', 0, pdId2[-1], []], [0, 1, pdId4[0], []],
['Global', 2, pdId4[1], [0]],
['Dedicated', 'test', pdId4[2], [0]], ['Global', 0, 100, []],
['Dedicated', 1, 'test', []],
['Dedicated', 1, pdId4[2], ['10', '12']]]
for i in range(len(values)):
tolog('Expect: ' + json.dumps(dict(zip(key, values[i]))) + '\r\n')
result = server.webapi('post', 'spare', dict(zip(key, values[i])))
if isinstance(result, str):
tolog('Actual: ' + result + '\r\n')
else:
FailFlag = True
tolog('Fail: please ' + json.dumps(dict(zip(key, values[i]))) +
'\r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
# clean up environment
server.webapiurl('delete', 'pool', '0?force=1')
def deleteBgaschedule():
ResponseInfo = server.webapi('get', 'bgaschedule')
bgaInfo = json.loads(ResponseInfo['text'])
if len(bgaInfo) > 1:
for bga in bgaInfo:
if bga['id'] == 'brc':
server.webapiurl('delete', 'bgaschedule', 'brc')
elif bga['id'] == 'rc_1':
server.webapiurl('delete', 'bgaschedule', 'rc_1')
elif bga['id'] == 'rc_2':
server.webapiurl('delete', 'bgaschedule', 'rc_2')
elif bga['id'] == 'sc':
server.webapiurl('delete', 'bgaschedule', 'sc')
def findPlId():
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
for pd in pdInfo[1:]:
if 'Pool' in pd['cfg_status']:
plResponseInfo = server.webapi('get', 'pool')
plInfo = json.loads(plResponseInfo['text'])
for pl in plInfo:
server.webapiurl('delete', 'pool', str(pl['id']) + '?force=1')
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
pdId = []
for pd in pdInfo:
if pd['op_status'] == 'OK' and pd[
'cfg_status'] == 'Unconfigured' and pd['type'] == 'SAS HDD':
pdId.append(pd['id'])
return pdId
def findPlId():
# get physical drive id
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
for pd in pdInfo[1:]:
if 'Pool' in pd['cfg_status']:
plResponseInfo = server.webapi('get', 'pool')
plInfo = json.loads(plResponseInfo['text'])
for pl in plInfo:
server.webapiurl('delete', 'pool', str(pl['id']) + '?force=1')
pdResponseInfo = server.webapi('get', 'phydrv')
pdInfo = json.loads(pdResponseInfo['text'])
pdId = []
for pd in pdInfo:
if pd['op_status'] == 'OK' and pd['cfg_status'] == 'Unconfigured' and pd['type'] == 'SAS HDD':
pdId.append(pd['id'])
# to create pool
if len(pdId) >= 5:
server.webapi('post', 'pool', {
'name': 'testNASShareApi2',
'sector': '512B',
'raid_level': 'RAID5',
'ctrl_id': 1,
'force_sync': 0,
'pds': [pdId[0], pdId[1], pdId[2], pdId[3], pdId[4]]
})
else:
tolog('lack of physical drive')
exit()
# get pool id
plResponseInfo = server.webapi('get', 'pool')
plInfo = json.loads(plResponseInfo['text'])
plId = []
for pl in plInfo:
plId.append(pl['id'])
return plId
def deleteVolume():
FailFlag = False
tolog('delete volume by api \r\n')
volumeId = []
volumeResponse = server.webapi('get', 'volume?page=1&page_size=100')
volumeInfo = json.loads(volumeResponse["text"])
for info in volumeInfo:
volumeId.append(info["id"])
for i in volumeId:
tolog('Expect: To delete volume ' + str(i) + '\r\n')
result = server.webapiurl('delete', 'volume', str(i) + '?force=1')
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
checkResponse = server.webapi('get', 'volume?page=1&page_size=100')
checkResult = json.loads(checkResponse["text"])
for cR in checkResult:
if cR['id'] == i:
FailFlag = True
tolog('Fail: The volume ' + str(i) + ' is not deleted \r\n')
if not FailFlag:
tolog('volume ' + str(i) + ' is deleted \r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
# clean up environment
server.webapiurl('delete', 'pool', '0?force=1')
server.webapiurl('delete', 'pool', '1?force=1')
def settings_test_and_confirm(self,
method,
service,
cases_file,
sheet_name,
hold_time=0):
# Open cases file
# data = xlrd.open_workbook('/home/work/zach/clitest/' + data_file_name)
data = xlrd.open_workbook(cases_file)
table = data.sheet_by_name(sheet_name)
for j in range(1, table.nrows):
# Building body parameters
settings = dict((table.cell(0, i).value, table.cell(j, i).value)
for i in range(table.ncols))
# Conversion data type
for key in settings.keys():
if type(settings[key]) == float:
settings[key] = int(settings[key])
if type(settings[key]) == str and ',' in settings[key]:
settings[key] = settings[key].split(',')
# Expected result
tolog('Expect: ' + str(settings) + '\n')
# Sending request
result = server.webapi(method, service, settings)
time.sleep(hold_time)
# Verify expected results and actual results
if str(result['response']) == '<Response [200]>':
check_result = server.webapiurl(
'get', server + '/' + table.cell(j, 0).value)
response = json.loads(check_result['text'])[0]
for key in settings.keys():
if settings[key] != response[key]:
self.flag = True
tolog('Fail: Expected ' + key + ' is ' +
str(settings[key]) + '. Actuality is ' +
str(response[key]))
else:
tolog('Actual: ' + str(result['text']) + '\n')
if self.flag:
tolog(Fail)
else:
tolog(Pass)
def failing_delete_spare():
FailFlag = False
tolog('Expect: delete spare drive that is inexistent\r\n')
result = server.webapiurl('delete', 'spare', '1000')
if isinstance(result, str):
tolog('Actual: ' + result + '\r\n')
else:
FailFlag = True
tolog('Fail: ' + str(json.loads(result["text"])))
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def delete_test_and_confirm(self, url_parameters, cases_file, sheet_name):
# Open cases file
# data = xlrd.open_workbook('/home/work/zach/clitest/' + data_file_name)
data = xlrd.open_workbook(cases_file)
table = data.sheet_by_name(sheet_name)
for i in range(1, table.nrows):
tolog('Expected: ' + str(table.cell(i, 0).value) +
' should be deleted\n')
result = server.webapiurl('delete', url_parameters,
str(table.cell(i, 0).value))
# Checking status of request
if str(result['response']) != '<Response [200]>':
self.flag = True
tolog('Fail: HTTP status code is ' + str(result['response']))
tolog('Error Message: ' + str(result['text']) + '\n')
continue
else:
check_result = server.webapi('get', url_parameters)
response_info = json.loads(check_result['text'])
if str({table.cell(0, 0).value:
table.cell(i, 0).value}) in str(response_info):
self.flag = True
tolog('Fail: parameter ' + str(table.cell(i, 0).value) +
' is not deleted\n')
else:
tolog('Actual: parameter ' + str(table.cell(i, 0).value) +
' is deleted')
get_r = str(response_info).replace('},', '\n').replace(
'[', '\n').replace(']',
'').replace('{',
'').replace('}', '')
tolog('And get response: ' + get_r + '\n')
if self.flag:
tolog(Fail)
else:
tolog(Pass)
def deleteDSUser():
Failflag = False
dsUserId = []
snmpuserResponse = server.webapi('get', 'dsuser')
snmpuserInfo = json.loads(snmpuserResponse["text"])
for info in snmpuserInfo:
dsUserId.append(info["id"])
tolog('Delete DSUser by api \r\n')
for i in dsUserId:
tolog('Expect: To delete DSUser ' + i + '\r\n')
result = server.webapiurl('delete', 'dsuser', i)
if isinstance(result, dict):
tolog('Actual: DSUser ' + i + ' is deleted \r\n')
else:
Failflag = True
tolog('Fail: To delete DSUser ' + i + ' is failed')
if Failflag:
tolog(Fail)
else:
tolog(Pass)
def find_pd_id(physical_capacity=None):
pd_id = []
try:
pd_request = server.webapi('get', 'phydrv')
if isinstance(pd_request, dict):
pd_info = json.loads(pd_request["text"])
str_pd_info = str(pd_info)
# delete pool
if 'Pool' in str_pd_info:
vol_request = server.webapi('get',
'volume?page=1&page_size=100')
if isinstance(vol_request, dict):
for vol in json.loads(vol_request["text"]):
if 'adv_role' in vol.keys(
) and vol['adv_role'] == 'Source' and vol[
'adv_type'] == 'Migration':
server.webapi(
'post', 'migrate/' + str(vol['id']) + '/stop',
{"location": 1})
if vol['adv_type'] == 'Replication':
replica_request = server.webapi('get', 'replica')
if isinstance(replica_request, dict):
for replica in json.loads(
replica_request["text"]):
server.webapi(
'post', 'replicaloc/' +
str(replica["src_id"]) + '/stop')
pool_response = server.webapi('get', 'pool')
if isinstance(pool_response, dict):
pool_info = json.loads(pool_response["text"])
if len(pool_info) != 0:
for pool in pool_info:
server.webapiurl('delete', 'pool',
str(pool['id']) + '?force=1')
else:
tolog(str(pool_response))
# delete spare
if 'Spare' in str_pd_info:
spare_response = server.webapi('get', 'spare')
if isinstance(spare_response, dict):
spare_info = json.loads(spare_response["text"])
for spare in spare_info:
server.webapiurl('delete', 'spare', str(spare["id"]))
else:
tolog(str(spare_response))
# delete read cache
if 'ReadCache' in str_pd_info:
read_ache_response = server.webapi('get', 'rcache')
if isinstance(read_ache_response, dict):
cache_info = json.loads(
read_ache_response["text"])[0]["pd_list"][0]
sdd_id = cache_info["pd_id"]
server.webapi('post', 'rcache/detach',
{"pd_list": [sdd_id]})
else:
tolog(str(read_ache_response))
# delete write cache
if 'WriteCache' in str_pd_info:
server.webapi('post', 'wcache/detach', {"id": 'detach'})
else:
tolog(str(pd_request))
# find pd id
pdResponse = server.webapi('get', 'phydrv')
if isinstance(pdResponse, dict):
pdInfo = json.loads(pdResponse["text"])
if physical_capacity == None:
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd[
"media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '2TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd[
"physical_capacity"] == '2 TB' and pd[
"media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '4TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd[
"physical_capacity"] == '4 TB' and pd[
"media_type"] == 'HDD':
pd_id.append(pd["id"])
else:
tolog(str(pdResponse))
pool_response1 = server.webapi('get', 'pool')
ed_pool_info = json.loads(pool_response1['text'])
for ed_pool in ed_pool_info:
server.webapiurl('delete', 'pool', str(ed_pool['id']) + '?force=1')
except:
tolog('please check out physical drive ConfigStatus\n')
return pd_id
def get_spare():
FailFlag = False
# test data
pdId2, pdId4 = find_pd_id()
# precondition
server.webapi(
'post', 'pool', {
'name': 'test_spare1',
'raid_level': 'RAID5',
'pds': [pdId2[0], pdId2[1], pdId2[2]]
})
key = ["dedicated", "revertible", "pd_id", "pool_list"]
values = [['Global', 0, pdId2[-1], []], ['Global', 1, pdId4[0], []],
['Dedicated', 0, pdId4[1], [0]], ['Dedicated', 1, pdId4[2], [0]]]
for i in range(len(values)):
tolog('Expect: ' + json.dumps(dict(zip(key, values[i]))) + '\r\n')
pre = server.webapi('post', 'spare', dict(zip(key, values[i])))
if isinstance(pre, str):
tolog('please check out precondition: ' + pre + '\r\n')
# list all of spare
tolog('list all of spare drive\r\n')
result = server.webapi('get', 'spare')
if isinstance(result, str):
FailFlag = True
tolog('Fail: ' + result + '\r\n')
else:
checkResult = json.loads(result["text"])
if len(checkResult) < 4:
FailFlag = True
tolog('Fail: please check out spare drive quantity\r\n')
tolog('Actual:\r\n' + str(checkResult).replace('{', '').replace(
'u', '').replace('}', '\r\n') + '\r\n')
# list specific spare drive
tolog('list specific spare drive\r\n')
spareInfo = json.loads(result["text"])
for spare in spareInfo:
tolog('Expect: list spare drive ' + str(spare["id"]) + '\r\n')
one = server.webapiurl('get', 'spare', str(spare["id"]))
if isinstance(one, str):
FailFlag = True
tolog('Fail: ' + one + '\r\n')
else:
oneCheck = json.loads(one["text"])[0]
tolog('Actual: ' + json.dumps(oneCheck) + '\r\n')
if FailFlag:
tolog(Fail)
else:
tolog(Pass)
def BgascheduleApiDelete():
Failflag = False
ResponseInfo = server.webapi('get', 'bgaschedule')
bgaInfo = json.loads(ResponseInfo['text'])
tolog('To delete bgaschedule by api \r\n')
if len(bgaInfo) > 1:
for bga in bgaInfo:
if bga['id'] == 'brc':
# delete brc type
tolog('Expect: delete brc type \r\n')
server.webapiurl('delete', 'bgaschedule', 'brc')
check = server.webapi('get', 'bgaschedule')
result = json.loads(check["text"])
for r in result:
if 'brc' in r.values():
Failflag = True
tolog('Fail: Did not delete brc type')
else:
tolog('Actual: brc type deletes successfully \r\n')
break
elif bga['id'] == 'rc_1':
# delete rc type
tolog('Expect: delete rc type\r\n')
server.webapiurl('delete', 'bgaschedule', 'rc_1')
check = server.webapi('get', 'bgaschedule')
result = json.loads(check["text"])
for r in result:
if 'rc' in r.values():
Failflag = True
tolog('Fail: Did not delete rc type')
else:
tolog('Actual: rc type deletes successfully\r\n')
break
elif bga['id'] == 'rc_2':
# delete rc type
tolog('Expect: delete rc type\r\n')
server.webapiurl('delete', 'bgaschedule', 'rc_2')
check = server.webapi('get', 'bgaschedule')
result = json.loads(check["text"])
for r in result:
if 'rc' in r.values():
Failflag = True
tolog('Fail: Did not delete rc type')
else:
tolog('Actual: rc type deletes successfully\r\n')
break
elif bga['id'] == 'sc':
# delete sc type
tolog('Expect: delete sc type\r\n')
server.webapiurl('delete', 'bgaschedule', 'sc')
check = server.webapi('get', 'bgaschedule')
result = json.loads(check["text"])
for r in result:
if 'sc' in r.values():
Failflag = True
tolog('Fail: Did not delete sc type')
else:
tolog('Actual: sc type deletes successfully\r\n')
break
if Failflag:
tolog(Fail)
else:
tolog(Pass)
def find_pd_id(physical_capacity=None):
pd_id = []
pd_request = server.webapi('get', 'phydrv')
if isinstance(pd_request, dict):
pd_info = json.loads(pd_request["text"])
str_pd_info = str(pd_info)
# delete pool
if 'Pool' in str_pd_info:
pool_response = server.webapi('get', 'pool')
if isinstance(pool_response, dict):
pool_info = json.loads(pool_response["text"])
if len(pool_info) != 0:
for pool in pool_info:
server.webapiurl('delete', 'pool', str(pool['id']) + '?force=1')
else:
tolog(str(pool_response))
# delete spare
if 'Spare' in str_pd_info:
spare_response = server.webapi('get', 'spare')
if isinstance(spare_response, dict):
spare_info = json.loads(spare_response["text"])
for spare in spare_info:
server.webapiurl('delete', 'spare', str(spare["id"]))
else:
tolog(str(spare_response))
# delete read cache
if 'ReadCache' in str_pd_info:
read_ache_response = server.webapi('get', 'rcache')
if isinstance(read_ache_response, dict):
cache_info = json.loads(read_ache_response["text"])[0]["pd_list"][0]
sdd_id = cache_info["pd_id"]
server.webapi('post', 'rcache/detach', {"pd_list": [sdd_id]})
else:
tolog(str(read_ache_response))
# delete write cache
if 'WriteCache' in str_pd_info:
server.webapi('post', 'wcache/detach', {"id": 'detach'})
else:
tolog(str(pd_request))
# find pd id
pdResponse = server.webapi('get', 'phydrv')
if isinstance(pdResponse, dict):
pdInfo = json.loads(pdResponse["text"])
if physical_capacity == None:
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '2TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["physical_capacity"] == '2 TB' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
elif physical_capacity == '4TB':
for pd in pdInfo:
if pd["cfg_status"] == 'Unconfigured' and pd["physical_capacity"] == '4 TB' and pd["media_type"] == 'HDD':
pd_id.append(pd["id"])
else:
tolog(str(pdResponse))
return pd_id
