def _do_cleanup(self, noisy):
screen('\nDoing Cleanup:', noisy)
for item in self.obj_list:
if item[0] == 'snap_id':
cleanup_snapshot(self.client, item[1], noisy)
if item[0] == 'vol_name':
cleanup_vol(self.client, item[1], noisy)
def _do_cleanup(self, encrypt_vol_name, master_key_name, grp_id, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_vol(self.client, encrypt_vol_name, noisy)
cleanup_master_key(self.client, master_key_name, noisy)
grp = self.client.groups.get(grp_id)
screen(
'\tCurrent encryption: {}'.format(grp.attrs['encryption_config']),
noisy)
def _do_cleanup(self, acr_id, noisy):
screen('\nDoing Cleanup:', noisy)
acr = self.client.access_control_records.get(acr_id)
cleanup_access_control_rec(self.client, acr.attrs['id'], noisy)
self.acr_id = None
cleanup_initiator_group(self.client, acr.attrs['initiator_group_name'],
noisy)
cleanup_vol(self.client, acr.attrs['vol_name'],
noisy) # Cleanup clone vol
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
create_vol(self.client, self.config[KEY_VOL], self.noisy)
if self.cleanup:
self._do_cleanup(self.config[KEY_VOL], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def _do_generate_objects(self):
screen('\nGenerating Objects...', self.noisy)
vol_count = 2
snap_count = 3
temp_noisy = True
vol_base_name = self.config[KEY_VOL]
snap_base_name = self.config[KEY_SNAP]
for i in range(vol_count):
vol = create_vol(self.client, vol_base_name + str(i), temp_noisy)
for j in range(snap_count):
snap = create_snap(self.client, snap_base_name + str(i) + '.' + str(j), vol.attrs['id'], temp_noisy)
self.obj_list.append(('snap_id', snap.attrs['id']))
self.obj_list.append(('vol_name', vol.attrs['name']))
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
# Create a volume
vol = create_vol(self.client, self.config[KEY_VOL], self.noisy)
# Create a snapshot
snap = create_snap(self.client, self.config[KEY_SNAP], vol.attrs['id'], self.noisy)
if self.cleanup:
self._do_cleanup(snap.id, vol.attrs['name'], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
# Create a volume
vol = create_vol(self.client, self.config[KEY_VOL], self.noisy)
# Create an initiator group
ig = create_initiator_group(self.client, self.config[KEY_IG], self.noisy)
# Create the ACR
acr = create_access_control_rec(self.client, ig.attrs['id'], vol.attrs['id'], self.noisy)
if self.cleanup:
self._do_cleanup(acr.attrs['id'], self.config[KEY_IG], self.config[KEY_VOL], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run(self, show_header=True):
if show_header:
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
vol = create_vol(self.client, self.config[KEY_VOL], self.noisy)
ig = create_initiator_group(self.client, self.config[KEY_IG],
self.noisy)
acr = create_access_control_rec(self.client, ig.attrs['id'],
vol.attrs['id'], self.noisy)
self.acr_id = acr.attrs['id']
if self.cleanup:
self._do_cleanup(acr.attrs['id'], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
self._do_generate_objects()
screen('\nRunning:', self.noisy)
try:
vol_list = self.client.volumes.list()
screen('\n\tObjects on Array:', self.noisy)
for vol in vol_list:
screen('\t\tVOLUME: {}, Id: {}'.format(vol.attrs['name'], vol.attrs['id']), self.noisy)
snap_list = self.client.snapshots.list(vol_name=vol.attrs['name'])
for snap in snap_list:
screen('\t\t\tSNAPSHOT: {}, Id: {}'.format(snap.attrs['name'], snap.attrs['id']), self.noisy)
if self.cleanup:
self._do_cleanup(self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run(self, show_header=True):
if show_header:
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
pubvol_wf = publish_volume(self.client, self.noisy, cleanup=False)
pubvol_wf.run(show_header=False)
acr_id = pubvol_wf.get_acr_id()
try:
# Get the ACR, we will need this to cleanup the initiator group
acr = self.client.access_control_records.get(acr_id)
cleanup_access_control_rec(self.client, acr_id, self.noisy)
cleanup_initiator_group(self.client, acr.attrs['initiator_group_name'], self.noisy)
cleanup_vol_prep(self.client, acr.attrs['vol_name'], self.noisy)
cleanup_vol(self.client, acr.attrs['vol_name'], self.noisy)
if self.cleanup:
self.do_cleanup(self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run_external(query_login, cleanup, noisy):
if query_login:
screen(
'\nERROR: --query_login is not supported in external mode. Please modify {} instead.\n'
.format(config_file), noisy)
usage(noisy)
cleanup_flag = '--cleanup' if cleanup is True else ''
screen('\nRunning All Workflows Externally:', noisy)
sep = '===================================================================================================='
wf_list = _get_workflow_files()
wf_count = len(wf_list)
for i in range(len(wf_list)):
screen('\n\n\n{}[{}/{}]'.format(sep, i + 1, wf_count), noisy)
screen('{} {}'.format(wf_list[i], cleanup_flag), noisy)
os.system('python3 {} {}'.format(wf_list[i], cleanup_flag))
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
# Create Volume
vol = create_vol(self.client, self.config[KEY_VOL], self.noisy)
# Create a volume collection
volcoll1 = create_volume_collection(self.client,
self.config[KEY_VOLCOLL],
self.noisy)
# Associate a volume with the volume collection
associate_vol(self.client, vol.id, volcoll1, self.noisy)
# Create a protection schedule
ps_name = self.config[KEY_PS]
create_protection_schedule(self.client, ps_name,
volcoll1.attrs['id'], self.noisy)
if self.cleanup:
self._do_cleanup(ps_name, self.config[KEY_VOLCOLL],
vol.attrs['name'], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def run_internal(query_login, cleanup, noisy):
screen('\nRunning All Workflows Internally:', noisy)
client = login(query_login, noisy)
sep = '===================================================================================================='
wf_list = _get_workflows(client, noisy, cleanup)
wf_count = len(wf_list)
success_count = 0
for i in range(len(wf_list)):
screen('\n\n\n{}[{}/{}]'.format(sep, i + 1, wf_count), noisy)
res = wf_list[i].run()
if res:
success_count += 1
screen('\n\n{} of {} workflows SUCCEEDED'.format(success_count, wf_count),
noisy)
return success_count, wf_count
def _do_cleanup(self, vol_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_vol(self.client, vol_name, noisy)
def _do_cleanup(self, ps_name, vc_name, vol_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_protection_schedule(self.client, ps_name, noisy)
cleanup_volume_collection(self.client, vc_name, noisy)
cleanup_vol(self.client, vol_name, noisy)
try:
# Create Volume
vol = create_vol(self.client, self.config[KEY_VOL], self.noisy)
# Create a volume collection
volcoll1 = create_volume_collection(self.client,
self.config[KEY_VOLCOLL],
self.noisy)
# Associate a volume with the volume collection
associate_vol(self.client, vol.id, volcoll1, self.noisy)
# Create a protection schedule
ps_name = self.config[KEY_PS]
create_protection_schedule(self.client, ps_name,
volcoll1.attrs['id'], self.noisy)
if self.cleanup:
self._do_cleanup(ps_name, self.config[KEY_VOLCOLL],
vol.attrs['name'], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
if __name__ == '__main__':
cur_noisy = True
filename = os.path.basename(__file__)
query_login, cleanup = handle_params(filename, sys.argv)
client = login(query_login, cur_noisy)
screen(' ', cur_noisy)
wf = protect_volume(client, cur_noisy, cleanup)
wf.run()
def _do_cleanup(self, acr_id, ig_name, vol_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_access_control_rec(self.client, acr_id, noisy)
cleanup_initiator_group(self.client, ig_name, noisy)
cleanup_vol(self.client, vol_name, noisy)
def usage(noisy):
screen('Usage:', noisy)
screen(
'\t{} [--cleanup] [--query_login] [--internal | --external]'.format(
__file__), noisy)
sys.exit(1)
def do_cleanup(self, noisy):
screen('\nDoing Cleanup:', noisy)
screen('\tNo cleanup required for detach_volume workflow', noisy)
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
initiator_count = 0
ig = create_initiator_group(self.client, self.config[KEY_IG],
self.noisy)
if ig.attrs['iscsi_initiators'] is not None:
initiator_count = len(ig.attrs['iscsi_initiators'])
screen('\tCurrent initiator count: {}'.format(initiator_count),
self.noisy)
initiators = ig.attrs['iscsi_initiators']
else:
screen('\tCurrent initiator count: 0', self.noisy)
initiators = []
initiator_count += 1
# Add an initiator to the list
new_initiator = {
"label":
"wftest-itor" + str(initiator_count),
"ip_address":
"1.1.1." + str(initiator_count),
"iqn":
"iqn.1992-0" + str(initiator_count) +
".com.example:storage.tape1.sys1.xyz"
}
initiators.append(new_initiator)
# Note that we re-assign ig so as to capture the update
ig = self.client.initiator_groups.update(
id=ig.attrs['id'],
description='add initiators',
iscsi_initiators=initiators)
screen(
'\tAdded initiator "{}": {}'.format(
ig.attrs['iscsi_initiators'][-1]['label'], initiators[-1]),
self.noisy)
screen(
'\tCurrent initiator count: {}'.format(
len(ig.attrs['iscsi_initiators'])), self.noisy)
if self.cleanup:
self._do_cleanup(self.config[KEY_IG], self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def _do_cleanup(self, ig_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_initiator_group(self.client, ig_name, noisy)
def _do_cleanup(self, clone_name, vol_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_vol(self.client, clone_name, noisy)
cleanup_snapshots(self.client, vol_name, noisy)
cleanup_vol(self.client, vol_name, noisy)
def run(self):
screen('WORKFLOW: {}'.format(self.title), self.noisy)
screen('\nRunning:', self.noisy)
try:
# Get a group and default encryption
grp_list = self.client.groups.list()
if len(grp_list) == 0:
screen('\tERROR: No groups configured on this system.')
screen(
'\t A group must be configured in order to configure encryption.'
)
return
grp_id = grp_list[0].attrs['id']
grp = self.client.groups.get(grp_id)
screen(
'\tGot group: "{}", Id: {}'.format(grp.attrs['name'], grp.id),
self.noisy)
orig_encryption = grp.attrs['encryption_config']
screen('\tCurrent encryption: {}'.format(orig_encryption),
self.noisy)
# Create a master key and create an encrypted volume
create_master_key(self.client, self.config[KEY_MK],
self.config[KEY_MK_PHRASE], self.noisy)
create_encrypted_vol(self.client, self.config[KEY_ENCRYPT_VOL],
self.noisy)
grp = self.client.groups.get(grp_id)
updated_encryption = grp.attrs['encryption_config']
if updated_encryption != orig_encryption:
screen('\tUpdated encryption: {}'.format(updated_encryption),
self.noisy)
# Modify the encryption (for test)
mod_encryption = grp.attrs['encryption_config']
mod_encryption.pop('master_key_set')
mod_encryption.pop('encryption_active')
mod_encryption.pop('encryption_key_manager', None)
if mod_encryption['mode'] == 'available':
mod_encryption['mode'] = 'secure'
elif mod_encryption['mode'] == 'secure':
mod_encryption['mode'] = 'available'
ue = self.client.groups.update(id=grp.id,
encryption_config=mod_encryption)
screen(
'\tModified encryption: {}'.format(
ue.attrs['encryption_config']), self.noisy)
if self.cleanup:
self._do_cleanup(self.config[KEY_ENCRYPT_VOL],
self.config[KEY_MK], grp_id, self.noisy)
except NimOSAPIError:
traceback.print_exc()
return False
return True
def _do_cleanup(self, snap_id, vol_name, noisy):
screen('\nDoing Cleanup:', noisy)
cleanup_snapshot(self.client, snap_id, noisy)
cleanup_vol(self.client, vol_name, noisy)
