def test_2(self): """basic resource loading test.""" pool = ResourcePool(cache_size=None) pool.register_resource(ResourceA) pool.register_resource(ResourceB) # test that resource matches our request, and its data isn't loaded variables = dict(foo="hey", bah="ho") resource = pool.get_resource("resource.a", variables) self.assertTrue(isinstance(resource, ResourceA)) self.assertEqual(resource.variables, variables) # test that a request via a resource's own handle gives the same resource resource_ = pool.get_resource_from_handle(resource.handle) self.assertTrue(resource_ is resource) # test that the same request again gives the cached resource resource_ = pool.get_resource("resource.a", variables) self.assertTrue(resource_ is resource) # clear caches, then test that the same request gives a new resource pool.clear_caches() resource_ = pool.get_resource("resource.a", variables) self.assertEqual(resource_.variables, variables) self.assertTrue(resource_ is not resource)
def __init__(self, resource_pool=None): """Create a package repo manager. Args: resource_pool (`ResourcePool`): Provide your own resource pool. If None, a default pool is created based on config settings. """ if resource_pool is None: cache_size = config.resource_caching_maxsize if cache_size < 0: # -1 == disable caching cache_size = None resource_pool = ResourcePool(cache_size=cache_size) self.pool = resource_pool self.repositories = {}
def test_1(self): """resource registration test.""" pool = ResourcePool(cache_size=None) with self.assertRaises(ResourceError): pool.get_resource("resource.a") pool.register_resource(ResourceA) pool.register_resource(ResourceB) with self.assertRaises(ResourceError): pool.register_resource(ResourceBad) resource_a = pool.get_resource("resource.a") resource_b = pool.get_resource("resource.b") self.assertTrue(isinstance(resource_a, ResourceA)) self.assertTrue(isinstance(resource_b, ResourceB))
def create_repository(cls, repository_data): """Create a standalone, in-memory repository. Using this function bypasses the `package_repository_manager` singleton. This is usually desired however, since in-memory repositories are for temporarily storing programmatically created packages, which we do not want to cache and that do not persist. Args: repository_data (dict): Repository data, see class docstring. Returns: `MemoryPackageRepository` object. """ location = "memory{%s}" % hex(id(repository_data)) resource_pool = ResourcePool(cache_size=None) repo = MemoryPackageRepository(location, resource_pool) repo.data = repository_data return repo
def __init__(self): cache_size = config.resource_caching_maxsize if cache_size < 0: cache_size = None self.cache_size = cache_size self.pool = ResourcePool(cache_size=cache_size)
def __init__(self): self.pool = ResourcePool(cache_size=None) self.repo = PetRepository(self.pool)