def get_cluster_latest_ssc(*args, **kwargs): """Updates volumes including ssc.""" backend = args[0] na_server = args[1] vserver = args[2] identity = six.text_type(id(backend)) lock_pr = '%s_%s' % ('refresh_ssc', identity) # As this depends on stale job running state # set flag as soon as job starts to avoid # job accumulation. try: job_set = na_utils.set_safe_attr(backend, 'ssc_job_running', True) if not job_set: return @utils.synchronized(lock_pr) def get_latest_ssc(): LOG.info(_LI('Running cluster latest ssc job for %(server)s' ' and vserver %(vs)s'), {'server': na_server, 'vs': vserver}) ssc_vols = get_cluster_ssc(na_server, vserver) backend.refresh_ssc_vols(ssc_vols) backend.ssc_run_time = timeutils.utcnow() LOG.info(_LI('Successfully completed ssc job for %(server)s' ' and vserver %(vs)s'), {'server': na_server, 'vs': vserver}) get_latest_ssc() finally: na_utils.set_safe_attr(backend, 'ssc_job_running', False)
def refresh_cluster_stale_ssc(*args, **kwargs): """Refreshes stale ssc volumes with latest.""" backend = args[0] na_server = args[1] vserver = args[2] identity = six.text_type(id(backend)) lock_pr = "%s_%s" % ("refresh_ssc", identity) try: job_set = na_utils.set_safe_attr(backend, "refresh_stale_running", True) if not job_set: return @utils.synchronized(lock_pr) def refresh_stale_ssc(): stale_vols = backend._update_stale_vols(reset=True) LOG.info( _LI("Running stale ssc refresh job for %(server)s" " and vserver %(vs)s") % {"server": na_server, "vs": vserver} ) # refreshing single volumes can create inconsistency # hence doing manipulations on copy ssc_vols_copy = copy.deepcopy(backend.ssc_vols) refresh_vols = set() expired_vols = set() for vol in stale_vols: name = vol.id["name"] res = get_cluster_vols_with_ssc(na_server, vserver, name) if res: refresh_vols.add(res.pop()) else: expired_vols.add(vol) for vol in refresh_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) if k == "mirrored" and vol.mirror.get("mirrored"): vol_set.add(vol) if k == "dedup" and vol.sis.get("dedup"): vol_set.add(vol) if k == "compression" and vol.sis.get("compression"): vol_set.add(vol) if k == "thin" and vol.space.get("thin_provisioned"): vol_set.add(vol) if k == "all": vol_set.add(vol) for vol in expired_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) backend.refresh_ssc_vols(ssc_vols_copy) LOG.info( _LI("Successfully completed stale refresh job for" " %(server)s and vserver %(vs)s") % {"server": na_server, "vs": vserver} ) refresh_stale_ssc() finally: na_utils.set_safe_attr(backend, "refresh_stale_running", False)
def refresh_cluster_stale_ssc(*args, **kwargs): """Refreshes stale ssc volumes with latest.""" backend = args[0] na_server = args[1] vserver = args[2] identity = str(id(backend)) lock_pr = '%s_%s' % ('refresh_ssc', identity) try: job_set = na_utils.set_safe_attr( backend, 'refresh_stale_running', True) if not job_set: return @utils.synchronized(lock_pr) def refresh_stale_ssc(): stale_vols = backend._update_stale_vols(reset=True) LOG.info(_('Running stale ssc refresh job for %(server)s' ' and vserver %(vs)s') % {'server': na_server, 'vs': vserver}) # refreshing single volumes can create inconsistency # hence doing manipulations on copy ssc_vols_copy = copy.deepcopy(backend.ssc_vols) refresh_vols = set() expired_vols = set() for vol in stale_vols: name = vol.id['name'] res = get_cluster_vols_with_ssc(na_server, vserver, name) if res: refresh_vols.add(res.pop()) else: expired_vols.add(vol) for vol in refresh_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) if k == "mirrored" and vol.mirror.get('mirrored'): vol_set.add(vol) if k == "dedup" and vol.sis.get('dedup'): vol_set.add(vol) if k == "compression" and vol.sis.get('compression'): vol_set.add(vol) if k == "thin" and vol.space.get('thin_provisioned'): vol_set.add(vol) if k == "all": vol_set.add(vol) for vol in expired_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) backend.refresh_ssc_vols(ssc_vols_copy) LOG.info(_('Successfully completed stale refresh job for' ' %(server)s and vserver %(vs)s') % {'server': na_server, 'vs': vserver}) refresh_stale_ssc() finally: na_utils.set_safe_attr(backend, 'refresh_stale_running', False)
def _garbage_collect_tmp_vols(self): """Removes tmp vols with no snapshots.""" try: if not utils.set_safe_attr(self, "clean_job_running", True): LOG.warn(_("Returning as clean tmp vol job already running.")) return for label in self._objects["volumes"]["label_ref"].keys(): if label.startswith("tmp-") and not self._is_volume_containing_snaps(label): try: self._delete_volume(label) except exception.NetAppDriverException: LOG.debug("Error deleting vol with label %s.", label) finally: utils.set_safe_attr(self, "clean_job_running", False)
def _garbage_collect_tmp_vols(self): """Removes tmp vols with no snapshots.""" try: if not utils.set_safe_attr(self, 'clean_job_running', True): LOG.warn(_('Returning as clean tmp vol job already running.')) return for label in self._objects['volumes']['label_ref'].keys(): if (label.startswith('tmp-') and not self._is_volume_containing_snaps(label)): try: self._delete_volume(label) except exception.NetAppDriverException: LOG.debug("Error deleting vol with label %s.", label) finally: utils.set_safe_attr(self, 'clean_job_running', False)
def _garbage_collect_tmp_vols(self): """Removes tmp vols with no snapshots.""" try: if not na_utils.set_safe_attr(self, "clean_job_running", True): LOG.warning(_LW("Returning as clean tmp " "vol job already running.")) return for vol in self._client.list_volumes(): label = vol["label"] if label.startswith("tmp-") and not self._is_volume_containing_snaps(label): try: self._client.delete_volume(vol["volumeRef"]) except exception.NetAppDriverException as e: LOG.debug("Error deleting vol with label %s: %s", (label, e)) finally: na_utils.set_safe_attr(self, "clean_job_running", False)
def _garbage_collect_tmp_vols(self): """Removes tmp vols with no snapshots.""" try: if not na_utils.set_safe_attr(self, 'clean_job_running', True): LOG.warning(_LW('Returning as clean tmp ' 'vol job already running.')) return for label in self._objects['volumes']['label_ref'].keys(): if (label.startswith('tmp-') and not self._is_volume_containing_snaps(label)): try: self._delete_volume(label) except exception.NetAppDriverException: LOG.debug("Error deleting vol with label %s.", label) finally: na_utils.set_safe_attr(self, 'clean_job_running', False)
def test_set_safe_attr(self): fake_object = mock.Mock() fake_object.fake_attr = None # test initial checks self.assertFalse(na_utils.set_safe_attr(None, fake_object, None)) self.assertFalse(na_utils.set_safe_attr(fake_object, None, None)) self.assertFalse(na_utils.set_safe_attr(fake_object, "fake_attr", None)) # test value isn't changed if it shouldn't be and retval is False fake_object.fake_attr = "fake_value" self.assertFalse(na_utils.set_safe_attr(fake_object, "fake_attr", "fake_value")) self.assertEqual(fake_object.fake_attr, "fake_value") # test value is changed if it should be and retval is True self.assertTrue(na_utils.set_safe_attr(fake_object, "fake_attr", "new_fake_value")) self.assertEqual(fake_object.fake_attr, "new_fake_value")
def _garbage_collect_tmp_vols(self): """Removes tmp vols with no snapshots.""" try: if not na_utils.set_safe_attr(self, 'clean_job_running', True): LOG.warning(_LW('Returning as clean tmp ' 'vol job already running.')) return for vol in self._client.list_volumes(): label = vol['label'] if (label.startswith('tmp-') and not self._is_volume_containing_snaps(label)): try: self._client.delete_volume(vol['volumeRef']) except exception.NetAppDriverException as e: LOG.debug("Error deleting vol with label %s: %s", (label, e)) finally: na_utils.set_safe_attr(self, 'clean_job_running', False)
def _refresh_volume_info(self): """Saves the volume information for the filer.""" if (self.vol_refresh_time is None or self.vol_refresh_voluntary or timeutils.is_newer_than(self.vol_refresh_time, self.vol_refresh_interval)): try: job_set = na_utils.set_safe_attr(self, 'vol_refresh_running', True) if not job_set: LOG.warning(_LW("Volume refresh job already running. " "Returning...")) return self.vol_refresh_voluntary = False self.vols = self.zapi_client.get_filer_volumes() self.vol_refresh_time = timeutils.utcnow() except Exception as e: LOG.warning(_LW("Error refreshing volume info. Message: %s"), e) finally: na_utils.set_safe_attr(self, 'vol_refresh_running', False)
def test_set_safe_attr(self): fake_object = mock.Mock() fake_object.fake_attr = None # test initial checks self.assertFalse(na_utils.set_safe_attr(None, fake_object, None)) self.assertFalse(na_utils.set_safe_attr(fake_object, None, None)) self.assertFalse(na_utils.set_safe_attr(fake_object, 'fake_attr', None)) # test value isn't changed if it shouldn't be and retval is False fake_object.fake_attr = 'fake_value' self.assertFalse( na_utils.set_safe_attr(fake_object, 'fake_attr', 'fake_value')) self.assertEqual('fake_value', fake_object.fake_attr) # test value is changed if it should be and retval is True self.assertTrue( na_utils.set_safe_attr(fake_object, 'fake_attr', 'new_fake_value')) self.assertEqual('new_fake_value', fake_object.fake_attr)
def _refresh_volume_info(self): """Saves the volume information for the filer.""" if (self.vol_refresh_time is None or self.vol_refresh_voluntary or timeutils.is_newer_than( self.vol_refresh_time, self.vol_refresh_interval)): try: job_set = na_utils.set_safe_attr(self, 'vol_refresh_running', True) if not job_set: LOG.warning("Volume refresh job already running. " "Returning...") return self.vol_refresh_voluntary = False self.vols = self.zapi_client.get_filer_volumes() self.volume_list = self._get_filtered_pools() self.vol_refresh_time = timeutils.utcnow() except Exception as e: LOG.warning("Error refreshing volume info. Message: %s", e) finally: na_utils.set_safe_attr(self, 'vol_refresh_running', False)
def get_cluster_latest_ssc(*args, **kwargs): """Updates volumes including ssc.""" backend = args[0] na_server = args[1] vserver = args[2] identity = six.text_type(id(backend)) lock_pr = '%s_%s' % ('refresh_ssc', identity) # As this depends on stale job running state # set flag as soon as job starts to avoid # job accumulation. try: job_set = na_utils.set_safe_attr(backend, 'ssc_job_running', True) if not job_set: return @utils.synchronized(lock_pr) def get_latest_ssc(): LOG.info( _LI('Running cluster latest ssc job for %(server)s' ' and vserver %(vs)s'), { 'server': na_server, 'vs': vserver }) ssc_vols = get_cluster_ssc(na_server, vserver) backend.refresh_ssc_vols(ssc_vols) backend.ssc_run_time = timeutils.utcnow() LOG.info( _LI('Successfully completed ssc job for %(server)s' ' and vserver %(vs)s'), { 'server': na_server, 'vs': vserver }) get_latest_ssc() finally: na_utils.set_safe_attr(backend, 'ssc_job_running', False)
def refresh_cluster_stale_ssc(*args, **kwargs): """Refreshes stale ssc volumes with latest.""" backend = args[0] na_server = args[1] vserver = args[2] identity = six.text_type(id(backend)) lock_pr = '%s_%s' % ('refresh_ssc', identity) try: job_set = na_utils.set_safe_attr(backend, 'refresh_stale_running', True) if not job_set: return @utils.synchronized(lock_pr) def refresh_stale_ssc(): stale_vols = backend._update_stale_vols(reset=True) LOG.info( _LI('Running stale ssc refresh job for %(server)s' ' and vserver %(vs)s'), { 'server': na_server, 'vs': vserver }) # refreshing single volumes can create inconsistency # hence doing manipulations on copy ssc_vols_copy = copy.deepcopy(backend.ssc_vols) refresh_vols = set() expired_vols = set() for vol in stale_vols: name = vol.id['name'] res = get_cluster_vols_with_ssc(na_server, vserver, name) if res: refresh_vols.add(res.pop()) else: expired_vols.add(vol) for vol in refresh_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) if k == "mirrored" and vol.mirror.get('mirrored'): vol_set.add(vol) if k == "dedup" and vol.sis.get('dedup'): vol_set.add(vol) if k == "compression" and vol.sis.get('compression'): vol_set.add(vol) if k == "thin" and vol.space.get('thin_provisioned'): vol_set.add(vol) if k == "all": vol_set.add(vol) for vol in expired_vols: for k in ssc_vols_copy: vol_set = ssc_vols_copy[k] vol_set.discard(vol) backend.refresh_ssc_vols(ssc_vols_copy) LOG.info( _LI('Successfully completed stale refresh job for' ' %(server)s and vserver %(vs)s'), { 'server': na_server, 'vs': vserver }) refresh_stale_ssc() finally: na_utils.set_safe_attr(backend, 'refresh_stale_running', False)