def main():
"""
Do the work
"""
mvip, user, user_pass, mvip_node, duration_set, ssh_state = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload(mvip_node, ssh_state, duration_set)
connect_cluster(headers, url, payload)
set_ssh_state(ssh_state, mvip_node, duration_set)
def add_missing(qos_dict, headers, url):
if len(qos_dict) > 0:
for pol_name, pol_values in qos_dict['tiers'].items():
min_iops = pol_values[0]
max_iops = pol_values[1]
burst_iops = pol_values[2]
print(f"Creating missing policy: {pol_name}")
payload = build_payload(pol_name, min_iops, max_iops, burst_iops)
connect_cluster(headers, url, payload)
def process_actions(list_response_json, headers, url, force_reset):
"""
If a policy does not exist on a given cluster find the right values
defined in qos_dict and apply them
"""
qos_dict = {}
# This dictionary sets the tiers and min/max/burst settings
qos_dict['tiers'] = {
"bronze": [500, 5000, 10000],
"silver": [2000, 20000, 50000],
"gold": [5000, 100000, 150000]
}
# Check to see if there are no policies set
force_reset_dict = {}
if len(list_response_json['result']['qosPolicies']) == 0:
print(f"No existing QoS Policies found, implementing full install")
for qos_key, qos_val in qos_dict['tiers'].items():
pol_name = qos_key
min_iops = qos_val[0]
max_iops = qos_val[1]
burst_iops = qos_val[2]
payload = build_payload(pol_name, min_iops, max_iops, burst_iops)
connect_cluster(headers, url, payload)
# If there are policies ignore them if they match names, remove that
# name from the dict and move on
else:
for policy in list_response_json['result']['qosPolicies']:
pol_name = policy['name']
if pol_name in qos_dict['tiers'].keys():
pol_id = policy['qosPolicyID']
min_iops = qos_dict['tiers'][pol_name][0]
max_iops = qos_dict['tiers'][pol_name][1]
burst_iops = qos_dict['tiers'][pol_name][2]
pol_min = policy['qos']['minIOPS']
pol_max = policy['qos']['maxIOPS']
pol_burst = policy['qos']['burstIOPS']
if ((min_iops != pol_min or max_iops != pol_max
or burst_iops != pol_burst) and force_reset is True):
print(
f"Policy mismatch detected on {pol_name}... resetting "
f"as reset flag is set to True")
print(qos_dict['tiers'][pol_name])
modify_qos_policy(headers, url, pol_id, min_iops, max_iops,
burst_iops)
elif ((min_iops != pol_min or max_iops != pol_max
or burst_iops != pol_burst) and force_reset is False):
print(f"Policy mismatch detected on {pol_name}... Leaving "
f"as reset flag is set to false")
else:
print(f"QoS Policy {pol_name} found, policy is not in "
f"configuration dictionary. Ignoring")
pass
if policy['name'] in qos_dict['tiers'].keys():
qos_dict['tiers'].pop(pol_name)
return qos_dict
def main():
"""
Calling everything above here to get an output
"""
mvip, user, user_pass, mvip_node = get_inputs()
payload = build_payload()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
response_json = connect_cluster(headers, url, payload)
paired_vols = get_replication_status(response_json)
payload = get_vol_stats(paired_vols)
response_json = connect_cluster(headers, url, payload)
parse_volume_stats(paired_vols, response_json)
def main():
"""
Call the above functions
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
hw_payload = get_hw_payload()
hw_config_response = connect_cluster(headers, url, hw_payload)
node_dict = parse_hw_config(hw_config_response)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
(active_drive_dict, failed_drive_dict,
missing_drive_dict) = parse_drives(response_json, node_dict)
def main():
mvip, user, user_pass, mvip_node, force_reset = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
list_qos_payload = build_list_qos_payload()
list_response_json = connect_cluster(headers, url, list_qos_payload)
qos_dict = process_actions(list_response_json, headers, url, force_reset)
add_missing(qos_dict, headers, url)
def get_iscsi_session_info(headers, url):
"""
Get the iSCSI sessions
"""
vol_id_array = {}
node_session_array = {}
node_dict = node_dict = get_node_list(headers, url)
payload = json.dumps({
"method": "ListISCSISessions",
"params": {},
"id": 1
})
response_json = connect_cluster(headers, url, payload)
for iqn in response_json['result']['sessions']:
initiator_name = iqn['initiatorName']
node_id = iqn['nodeID']
if node_id in vol_id_array.keys():
vol_id_array[node_id] = vol_id_array[node_id] + 1
else:
vol_id_array[node_id] = 1
target_name = iqn['targetName']
vol_id = target_name.split(".")[5]
if len(vol_id_array) == 0:
print("No iSCSI sessions returned, script will now exit")
sys.exit(1)
for key in vol_id_array:
node_name = node_dict[key]
node_session_array[node_name] = vol_id_array[key]
return node_session_array
def main():
"""
Execute the functions from above
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
master_id_payload = build_master_id_payload()
ensemble_id_payload = build_ensemble_id_payload()
node_list_payload = build_node_list_payload()
response_json = connect_cluster(headers, url, master_id_payload)
master_id = get_master_id(response_json)
response_json = connect_cluster(headers, url, node_list_payload)
node_dict = get_active_nodes(response_json)
response_json = connect_cluster(headers, url, ensemble_id_payload)
ensemble_dict = get_ensemble(response_json)
master_locator(master_id, node_dict, ensemble_dict)
def build_auth(mvip, user, user_pass, mvip_node=None):
"""
Authorization for connecting to the cluster mvip on port 443
"""
try:
socket.gethostbyname(mvip)
if mvip_node is None:
mvip_node = "cluster"
token_url = "https://" + mvip + "/auth/connect/token"
m_url = "https://" + mvip + "/json-rpc/"
n_url = "https://" + mvip + ":442/json-rpc/"
files = {
'client_id': (None, 'element-automation'),
'grant_type': (None, 'password'),
'username': (None, user),
'password': (None, user_pass),
}
response = requests.post(url=token_url, files=files, verify=False)
res_code = response.status_code
if res_code is 200:
print("Using token authentication")
token_json = json.loads(response.text)
token_out = token_json['access_token']
auth_bear = "Bearer " + token_out
headers = {'Authorization': auth_bear}
else:
print("Using basic auth without token grant")
auth = (user + ":" + user_pass)
encode_key = base64.b64encode(auth.encode('utf-8'))
basic_auth = bytes.decode(encode_key)
headers = {
'Content-Type': "application/json",
'Authorization': "Basic %s" % basic_auth,
'Cache-Control': "no-cache",
}
if mvip_node == "cluster":
url = m_url + "9.0"
else:
url = n_url + "9.0"
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
# Return the latest API supported and provide that output to
# connect_cluster module
latest_api = get_version(response_json)
if mvip_node == "cluster":
url = m_url + latest_api
else:
url = n_url + latest_api
return headers, url
except Exception as my_except:
print(f"Unable to lookup {mvip}, please verify name/dns/etc, "
f"script will exit")
sys.exit(1)
def main():
"""
Call the functions from above
"""
mvip, user, user_pass, check_opt = get_inputs()
headers, url = build_auth(mvip, user, user_pass)
payload = build_payload(check_opt)
response_json = connect_cluster(headers, url, payload)
compare_pair_ids(response_json, check_opt)
def main():
"""
Call the functions created above
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
tbl_headers, vol_dict = build_output(response_json)
build_table(tbl_headers, vol_dict)
def main():
"""
Call the above functions
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
account_table = create_table(response_json)
print(account_table)
def main():
"""
Execute the above functions
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
cls_stat_dict = build_output(mvip, response_json)
build_table(cls_stat_dict)
def main():
"""
Do the work
"""
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_virt_net_payload()
response_json = connect_cluster(headers, url, payload)
tbl_headers, virt_net_list = get_virt_net(response_json)
build_table(tbl_headers, virt_net_list)
def main():
"""
Do the work
"""
mvip, user, user_pass, mvip_node = get_inputs()
fault_payload = build_cluster_events()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
response_json = connect_cluster(headers, url, fault_payload)
fault_dict = parse_events(response_json)
outfile_name = get_filename(mvip)
print_table(outfile_name, fault_dict)
def get_node_list(headers, url):
"""
Build the list of nodes
"""
node_dict = {}
payload = json.dumps({"method": "ListActiveNodes", "params": {}, "id": 1})
response_json = connect_cluster(headers, url, payload)
for node in response_json['result']['nodes']:
node_name = node['name']
node_id = node['nodeID']
node_dict[node_id] = node_name
return node_dict
def main():
"""
Call the functions from above
"""
mvip, user, user_pass, mvip_node = get_inputs()
if mvip_node == "cluster" or mvip_node is None:
print(f"This script must be run with --connect node -m <NODE_IP> "
f"as it cannot be run at a cluster level")
sys.exit(1)
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
get_switch_info(response_json)
get_cluster_info(response_json)
def modify_qos_policy(headers, url, pol_id, min_iops, max_iops, burst_iops):
payload = json.dumps({
"method": "ModifyQoSPolicy",
"params": {
"qosPolicyID": pol_id,
"qos": {
"minIOPS": min_iops,
"maxIOPS": max_iops,
"burstIOPS": burst_iops
}
},
"id": 1
})
qos_mod_response = connect_cluster(headers, url, payload)
print(qos_mod_response)
def get_iscsi_session_info(headers, url, search_id=None):
"""
Get the iSCSI sessions
"""
vol_id_array = {}
iscsi_session_list = []
sessions_lists = []
node_dict = node_dict = get_node_list(headers, url)
payload = json.dumps({
"method": "ListISCSISessions",
"params": {},
"id": 1
})
response_json = connect_cluster(headers, url, payload)
for iqn in response_json['result']['sessions']:
session_id = iqn['sessionID']
initiator_name = iqn['initiatorName']
node_id = iqn['nodeID']
node_name = node_dict[node_id]
if node_id in vol_id_array.keys():
vol_id_array[node_id] = vol_id_array[node_id] + 1
else:
vol_id_array[node_id] = 1
target_name = iqn['targetName']
target_host = (target_name.split(".")[0] + "." +
target_name.split(".")[1] + "." +
target_name.split(".")[2] + "." +
target_name.split(".")[3])
vol_name = target_name.split(".")[4]
vol_id = target_name.split(".")[5]
iscsi_session_list = [
session_id, node_id, node_name, vol_id, vol_name, initiator_name,
target_host
]
if search_id is not None:
if search_id in iscsi_session_list:
sessions_lists.append(iscsi_session_list)
else:
sessions_lists.append(iscsi_session_list)
if len(vol_id_array) == 0:
print("No iSCSI sessions returned, script will now exit")
sys.exit(1)
return sessions_lists
def get_outputs(headers, url):
"""
Loop through the calls required and output them all into a dictionary.
The call is the key and the output is the value for the dictionary
"""
output_dict = {}
api_calls = "GetClusterCapacity", "GetClusterInfo", "ListClusterPairs", \
"ListActivePairedVolumes", "GetSnmpTrapInfo", "GetNtpInfo", \
"ListDrives", "ListActiveNodes", "ListPendingNodes", \
"ListPendingActiveNodes", "GetClusterVersionInfo", \
"GetNetworkConfig", "ListVirtualNetworks", \
"GetClusterHardwareInfo", "GetHardwareInfo", \
"GetClusterSshInfo", "GetLdapConfiguration", \
"ListClusterAdmins"
for call in api_calls:
print(f"Gathering information from: {call}")
payload = build_payload(call)
response_json = connect_cluster(headers, url, payload)
output_dict[call] = response_json
return output_dict
def get_outputs(headers, url, acct_name):
"""
Generate output to provide to the table
"""
# Need all four of these API calls to merge the required data together
output_dict = {}
api_call_vols = [
"ListVolumes", "ListVolumeStats", "ListAllNodes", "ListServices"
]
if acct_name is not None:
api_call_vols.append("GetAccountByName")
for call_vols in api_call_vols:
if call_vols == "GetAccountByName":
params = {"username": acct_name}
else:
params = {"force": True}
print(f"Gathering information from: {call_vols}")
payload = build_payload(call_vols, params)
response_json = connect_cluster(headers, url, payload)
output_dict[call_vols] = response_json
return output_dict
def main():
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
payload = build_payload()
response_json = connect_cluster(headers, url, payload)
do_stuff(response_json)
def main():
mvip, user, user_pass, mvip_node = get_inputs()
headers, url = build_auth(mvip, user, user_pass, mvip_node)
hw_config_payload = build_payload()
hw_config_response = connect_cluster(headers, url, hw_config_payload)
parse_hw_config(hw_config_response)
