def reset_sr(session, host_uuid, sr_uuid, is_sr_master): from vhdutil import LOCK_TYPE_SR from cleanup import LOCK_TYPE_RUNNING cleanup.abort(sr_uuid) gc_lock = lock.Lock(LOCK_TYPE_RUNNING, sr_uuid) sr_lock = lock.Lock(LOCK_TYPE_SR, sr_uuid) gc_lock.acquire() sr_lock.acquire() sr_ref = session.xenapi.SR.get_by_uuid(sr_uuid) host_ref = session.xenapi.host.get_by_uuid(host_uuid) host_key = "host_%s" % host_ref util.SMlog("RESET for SR %s (master: %s)" % (sr_uuid, is_sr_master)) vdi_recs = session.xenapi.VDI.get_all_records_where( \ "field \"SR\" = \"%s\"" % sr_ref) for vdi_ref, vdi_rec in vdi_recs.iteritems(): vdi_uuid = vdi_rec["uuid"] sm_config = vdi_rec["sm_config"] if sm_config.get(host_key): util.SMlog("Clearing attached status for VDI %s" % vdi_uuid) session.xenapi.VDI.remove_from_sm_config(vdi_ref, host_key) if is_sr_master and sm_config.get("paused"): util.SMlog("Clearing paused status for VDI %s" % vdi_uuid) session.xenapi.VDI.remove_from_sm_config(vdi_ref, "paused") sr_lock.release() gc_lock.release()
def detach(self, sr_uuid): if self._checkmount(): try: util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) os.chdir(SR.MOUNT_BASE) util.pread(["umount", self.path]) os.rmdir(self.path) except Exception, e: raise xs_errors.XenError('SRInUse', opterr=str(e))
def detach(self, sr_uuid): if not self.checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) self.unmount(self.mountpoint, True) os.unlink(self.path) self.attached = False
def detach(self, sr_uuid): """Detach the SR: Unmounts and removes the mountpoint""" if not self._checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) try: nfs.unmount(self.path, True) except nfs.NfsException, exc: raise xs_errors.XenError('NFSUnMount', opterr=exc.errstr)
def detach(self, sr_uuid): """Detach the SR: Unmounts and removes the mountpoint""" if not self._checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) cmd = ["umount", self.path] try: ret = util.pread(cmd) except util.CommandException, inst: raise xs_errors.XenError("OCFSUnMount", opterr="Failed to umount FS. Errno is %d" % os.strerror(inst.code))
def _kickGC(self): # don't bother if an instance already running (this is just an # optimization to reduce the overhead of forking a new process if we # don't have to, but the process will check the lock anyways) lockRunning = Lock(cleanup.LOCK_TYPE_RUNNING, self.uuid) if not lockRunning.acquireNoblock(): if cleanup.should_preempt(self.session, self.uuid): util.SMlog( "Aborting currently-running coalesce of garbage VDI") try: if not cleanup.abort(self.uuid, soft=True): util.SMlog("The GC has already been scheduled to " "re-start") except util.CommandException as e: if e.code != errno.ETIMEDOUT: raise util.SMlog('failed to abort the GC') finally: return else: util.SMlog("A GC instance already running, not kicking") return else: lockRunning.release() util.SMlog("Kicking GC") cleanup.gc(self.session, self.uuid, True)
def detach(self, sr_uuid): """Detach the SR: Unmounts and removes the mountpoint""" if not self._checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) cmd = ['umount', self.path ] try: ret = util.pread(cmd) except util.CommandException, inst: raise xs_errors.XenError('OCFSUnMount', \ opterr='Failed to umount FS. Errno is %d' % \ os.strerror(inst.code))
def _kickGC(self): # don't bother if an instance already running (this is just an # optimization to reduce the overhead of forking a new process if we # don't have to, but the process will check the lock anyways) lockRunning = Lock(cleanup.LOCK_TYPE_RUNNING, self.uuid) if not lockRunning.acquireNoblock(): if cleanup.should_preempt(self.session, self.uuid): util.SMlog("Aborting currently-running coalesce of garbage VDI") cleanup.abort(self.uuid) else: util.SMlog("A GC instance already running, not kicking") return else: lockRunning.release() util.SMlog("Kicking GC") cleanup.gc(self.session, self.uuid, True)
def detach(self, sr_uuid): """Detach the SR: Unmounts and removes the mountpoint""" if not self.checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) try: self.unmount(self.mountpoint, True) os.unlink(self.path) except SMBException as exc: raise xs_errors.XenError('SMBUnMount', opterr=exc.errstr) self.attached = False
def _kickGC(self): # don't bother if an instance already running (this is just an # optimization to reduce the overhead of forking a new process if we # don't have to, but the process will check the lock anyways) lockRunning = Lock(cleanup.LOCK_TYPE_RUNNING, self.uuid) if not lockRunning.acquireNoblock(): if cleanup.should_preempt(self.session, self.uuid): util.SMlog( "Aborting currently-running coalesce of garbage VDI") cleanup.abort(self.uuid) else: util.SMlog("A GC instance already running, not kicking") return else: lockRunning.release() util.SMlog("Kicking GC") cleanup.gc(self.session, self.uuid, True)
def detach(self, sr_uuid): if not self._checkmount(): return cleanup.abort(self.uuid) try: # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) # unmount the device util.pread(["umount", self.path]) # remove the mountpoint os.rmdir(self.path) self.path = None # deactivate SR try: cmd = ["lvchange", "-an", self.remotepath] util.pread2(cmd) except util.CommandException, inst: raise xs_errors.XenError('LVMUnMount', \ opterr='lvm -an failed errno is %d' % inst.code) self.attached = False
def _kickGC(self): # don't bother if an instance already running (this is just an # optimization to reduce the overhead of forking a new process if we # don't have to, but the process will check the lock anyways) lockRunning = Lock(cleanup.LOCK_TYPE_RUNNING, self.uuid) if not lockRunning.acquireNoblock(): if cleanup.should_preempt(self.session, self.uuid): util.SMlog("Aborting currently-running coalesce of garbage VDI") try: if not cleanup.abort(self.uuid, soft=True): util.SMlog("The GC has already been scheduled to " "re-start") except util.CommandException, e: if e.code != errno.ETIMEDOUT: raise util.SMlog("failed to abort the GC") finally:
def test_lock_not_released_by_abort_when_not_held( self, mock_abort, mock_sr): """ If _abort returns False don't release lockActive and ensure that False returned by _abort is passed on. """ self.setup_mock_sr(mock_sr) # Fake _abort returning False. mock_abort.return_value = False # Mock lock release function. cleanup.lockActive = TestRelease() cleanup.lockActive.release = mock.Mock(return_value=None) ret = cleanup.abort(mock_sr, False) # Make sure pass on False returned by _abort self.assertEquals(False, ret) # Make sure we did not release the lock as we don't have it. self.assertEquals(cleanup.lockActive.release.call_count, 0)
def test_lock_released_by_abort_when_held( self, mock_abort, mock_sr): """ If _abort returns True make sure we release the lockActive which will have been held by _abort, also check that we return True. """ self.setup_mock_sr(mock_sr) # Fake that abort returns True, so we hold lockActive. mock_abort.return_value = True # Setup mock of release function. cleanup.lockActive = TestRelease() cleanup.lockActive.release = mock.Mock(return_value=None) ret = cleanup.abort(mock_sr, False) # Pass on the return from _abort. self.assertEquals(True, ret) # We hold lockActive so make sure we release it. self.assertEquals(cleanup.lockActive.release.call_count, 1)