def test_resource_lock(self): with NamedTemporaryFile('rw') as file: with ResourceFile(file.name) as lock: self.assertEquals(lock.used(), False) lock.acquire({'foo': 'bar', 'pid': os.getpid()}) # Used should return a dict with ResourceFile(file.name) as lock: info = lock.used() self.assertEquals(info['foo'], 'bar') self.assertEquals(info['pid'], os.getpid())
def new_func(self, request): # Get some info about the controller call info = inspect(self, request, lock_file_path) # create a ResourceFile object to manage volume ownership resource = ResourceFile(info['lock_file']) try: # Attempt to claim exclusive ownership of the volume claim(resource, info) # Execute the controller method return func(self, request, resource) finally: # Remove the resource file if we own it resource.remove()
def test_interruptible_lock(self): resource = ResourceFile(self.lockfile) fake_controller = FakeController(volume_id='foo', id='bar', run_dir='somewhere') req_1 = FakeRequest(method='PUT', path="something") req_2 = FakeRequest(method='PUT', path="something/else") @lock(self.lockfile) def killable_func(obj, req, resource): with resource: resource.update({'interruptible': True}) while True: time.sleep(1) @lock(self.lockfile) def killing_func(obj, req, resource): while True: time.sleep(1) # Go killable func child! child1 = os.fork() if not child1: killable_func(fake_controller, req_1) else: self.children.append(child1) time.sleep(1) with resource: used = resource.used() self.assertEquals(used['interruptible'], True) self.assertEquals(used['uri'], 'PUT something') self.assertEquals(used['pid'], child1) # Go killing func child! child2 = os.fork() if not child2: killing_func(fake_controller, req_2) else: self.children.append(child2) time.sleep(1) with resource: used = resource.used() self.assertEquals(used['interruptible'], False) self.assertEquals(used['uri'], 'PUT something/else') self.assertEquals(used['pid'], child2)
def _in_use(self, volume_id): resource_file = self._resource_file(volume_id) if not exists(resource_file): return False with ResourceFile(resource_file) as lock: return lock.used()
def setUp(self): self.scratch = mkdtemp() self.storage = MockStorageNode(self.scratch) self._orig_subprocess = utils.subprocess utils.subprocess = MockSubprocess(storage=self.storage) self.conf = LunrConfig({ 'export': { 'ietd_config': os.path.join(self.scratch, 'ietd.conf'), 'proc_iet_volume': self.storage.proc_iet_volume, 'proc_iet_session': self.storage.proc_iet_session, 'device_prefix': self.storage.device_prefix, 'initiators_allow': os.path.join(self.scratch, 'initiators.allow'), }, 'storage': { 'skip_fork': True, 'run_dir': self.storage.run_dir }, 'volume': { 'device_prefix': self.storage.device_prefix }, 'disk': { 'path': os.path.join(self.scratch, 'backups') }, 'glance': { 'glance_urls': 'snet1,snet2', 'glance_mgmt_urls': 'mgmt1, mgmt2', } }) self.lockfile = os.path.join(self.scratch, 'lock') self.lock = ResourceFile(self.lockfile)
def test_lock_used(self): resource = ResourceFile(self.lockfile) child = os.fork() if not child: # Child grabs resource and sleeps until killed. with resource: resource.acquire({'pid': os.getpid()}) while True: time.sleep(5) time.sleep(0.2) with resource: used = resource.used() self.assert_(used) self.assertEquals(used['pid'], child) os.kill(child, signal.SIGTERM) os.waitpid(child, 0)
def lock(self, req): info = inspect(self, req, "volumes/%(id)s/resource") with ResourceFile(info['lock_file']) as lock: used = lock.used() if used: resp = {'in-use': True} resp.update(used) return Response(resp) pass return Response({'in-use': False})
def get(self, volume, backup_id): running = self._backup_is_running(volume['id'], backup_id) if not running: raise NotFound("no active backup running on '%s' called '%s'" % (volume['id'], backup_id)) stats_file = self._stats_file(volume['id']) with ResourceFile(stats_file) as lock: stats = lock.read() return { 'lock': self._resource_file(volume['id']), 'status': 'RUNNING', 'stats': stats }
def test_interruptible_claim(self): resource = ResourceFile(self.lockfile) child = os.fork() if not child: # Child grabs resource and sleeps until killed. with resource: resource.acquire({'pid': os.getpid(), 'uri': 'child'}) time.sleep(2) with resource: resource.acquire({'interruptible': True}) while(True): time.sleep(0.5) else: self.children.append(child) # This is racy. Child is originally uninterruptible, but after a short # sleep, he marks himself interruptible time.sleep(1) info = {'uri': 'parent', 'pid': os.getpid()} self.assertRaises(HTTPConflict, claim, resource, info) time.sleep(2) claim(resource, info) time.sleep(1) # should be killed by now. pid, status = os.waitpid(child, os.WNOHANG) self.assertEquals(pid, child) with resource: used = resource.used() self.assert_(used) self.assertEquals(used['pid'], os.getpid()) self.assertEquals(used['uri'], 'parent') # Bug: lock.acquire only updates the keys you give it. # So I'm marked interruptible unknowingly. # lunr.storage.controller.base.inspect was updated to always # set interruptible to False because of this. self.assertEquals(used['interruptible'], True)