def setUp(self): super(CacheNoopBackendTest, self).setUp() self.config_fixture.config(group='cache', backend='oslo_cache.noop') self.region = cache._make_region() cache.configure_cache_region(self.config_fixture.conf, self.region)
def get_cache_region(): global _REGION if not _REGION: _REGION = core.create_region() _REGION.configure('oslo_cache.dict', arguments={'expiration_time': WEEK}) core.configure_cache_region(conf=register_cache_configurations( cfg.CONF), region=_REGION) return _REGION
def setUp(self): super().setUp() self.conf = self.config_fixture.conf self.region = cache.create_region() self.region_kwargs = cache.create_region( function=cache.kwarg_function_key_generator) cache.configure_cache_region(self.conf, self.region) cache.configure_cache_region(self.conf, self.region_kwargs)
def setUp(self): super(CacheRegionTest, self).setUp() self.region = cache.create_region() cache.configure_cache_region(self.config_fixture.conf, self.region) self.region.wrap(TestProxy) self.region_kwargs = cache.create_region( function=cache.kwarg_function_key_generator) cache.configure_cache_region(self.config_fixture.conf, self.region_kwargs) self.region_kwargs.wrap(TestProxy) self.test_value = TestProxyValue('Decorator Test')
def get_cache_region(): global _REGION if not _REGION: _REGION = core.configure_cache_region( conf=register_cache_configurations(cfg.CONF), region=core.create_region()) return _REGION
def configure_cache(region=None): if region is None: region = CACHE_REGION # NOTE(morganfainberg): running cache.configure_cache_region() # sets region.is_configured, this must be captured before # cache.configure_cache_region is called. configured = region.is_configured cache.configure_cache_region(CONF, region) # Only wrap the region if it was not configured. This should be pushed # to oslo_cache lib somehow. if not configured: region.wrap(_context_cache._ResponseCacheProxy) region_manager = RegionInvalidationManager(CACHE_INVALIDATION_REGION, region.name) region.key_mangler = key_mangler_factory(region_manager, region.key_mangler) region.region_invalidator = DistributedInvalidationStrategy( region_manager)
def more_config(): """Perform configuration that must be delayed until after import time. This code must be delayed until the config files have been loaded. They are in a separate file so that unit tests can run them without loading configuration from a file. """ cache.configure_cache_region(CONF, session_cache_region) for service_provider in CONF.proxy.service_providers: sp_group = cfg.OptGroup(name='sp_%s' % service_provider, title=service_provider) sp_opts = [ cfg.StrOpt('sp_name', default="default", help='SP ID in Keystone Catalog. Omit for local.'), cfg.StrOpt('messagebus', help='URI to connect to message bus'), cfg.StrOpt('services', default=None, help='Enabled services for this service provider.'), cfg.StrOpt('auth_url', default=None, help='Keystone AUTH URL for Service Provider'), cfg.StrOpt('image_endpoint', default=None, help="Image Endpoint for Service Provider"), cfg.StrOpt('volume_endpoint', default=None, help="Volume Endpoint for Service Provider") ] CONF.register_group(sp_group) CONF.register_opts(sp_opts, sp_group) log.setup(CONF, 'demo')
def test_cache_region_no_error_multiple_config(self): # Verify configuring the CacheRegion again doesn't error. cache.configure_cache_region(self.config_fixture.conf, self.region) cache.configure_cache_region(self.config_fixture.conf, self.region)
def setUp(self): super(CacheRegionTest, self).setUp() self.region = cache.create_region() cache.configure_cache_region(self.config_fixture.conf, self.region) self.region.wrap(TestProxy) self.test_value = TestProxyValue('Decorator Test')
def __init__(self): if not CONF.cache.enabled: LOG.warning("Metadata doesn't use cache. " "Configure cache options to use cache.") self.cache_region = cache_core.create_region() cache_core.configure_cache_region(CONF, self.cache_region)
def setup_cache(conf): global CACHE_REGION core.configure(conf) region = core.create_region() CACHE_REGION = core.configure_cache_region(conf, region)
def _get_cache_region(conf): region = cache.create_region() cache.configure_cache_region(conf, region) return region
LOG = logging.getLogger(__name__) vif_handler_caching_opts = [ oslo_cfg.BoolOpt('caching', default=True), oslo_cfg.IntOpt('cache_time', default=120), ] oslo_cfg.CONF.register_opts(vif_handler_caching_opts, "vif_handler_caching") cache.configure(oslo_cfg.CONF) vif_handler_cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator(oslo_cfg.CONF, vif_handler_cache_region, "vif_handler_caching") cache.configure_cache_region(oslo_cfg.CONF, vif_handler_cache_region) class VIFHandler(k8s_base.ResourceEventHandler): """Controller side of VIF binding process for Kubernetes pods. `VIFHandler` runs on the Kuryr-Kubernetes controller and together with the CNI driver (that runs on 'kubelet' nodes) is responsible for providing networking to Kubernetes pods. `VIFHandler` relies on a set of drivers (which are responsible for managing Neutron resources) to define the VIF objects and pass them to the CNI driver in form of the Kubernetes pod annotation. """ OBJECT_KIND = constants.K8S_OBJ_POD OBJECT_WATCH_PATH = "%s/%s" % (constants.K8S_API_BASE, "pods")
DEFAULT_TIMEOUT = 180 DEFAULT_INTERVAL = 3 subnet_caching_opts = [ cfg.BoolOpt('caching', default=True), cfg.IntOpt('cache_time', default=3600), ] CONF.register_opts(subnet_caching_opts, "subnet_caching") cache.configure(CONF) subnet_cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator( CONF, subnet_cache_region, "subnet_caching") cache.configure_cache_region(CONF, subnet_cache_region) def utf8_json_decoder(byte_data): """Deserializes the bytes into UTF-8 encoded JSON. :param byte_data: The bytes to be converted into the UTF-8 encoded JSON. :returns: The UTF-8 encoded JSON represented by Python dictionary format. """ return jsonutils.loads(byte_data.decode('utf8')) def convert_netns(netns): """Convert /proc based netns path to Docker-friendly path. When CONF.docker_mode is set this method will change /proc to
LOG = logging.getLogger(__name__) namespace_handler_caching_opts = [ oslo_cfg.BoolOpt('caching', default=True), oslo_cfg.IntOpt('cache_time', default=120), ] oslo_cfg.CONF.register_opts(namespace_handler_caching_opts, "namespace_handler_caching") cache.configure(oslo_cfg.CONF) namespace_handler_cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator( oslo_cfg.CONF, namespace_handler_cache_region, "namespace_handler_caching") cache.configure_cache_region(oslo_cfg.CONF, namespace_handler_cache_region) class NamespaceHandler(k8s_base.ResourceEventHandler): OBJECT_KIND = constants.K8S_OBJ_NAMESPACE OBJECT_WATCH_PATH = "%s/%s" % (constants.K8S_API_BASE, "namespaces") def __init__(self): super(NamespaceHandler, self).__init__() self._drv_project = drivers.NamespaceProjectDriver.get_instance() self._drv_subnets = drivers.PodSubnetsDriver.get_instance() self._drv_sg = drivers.PodSecurityGroupsDriver.get_instance() self._drv_vif_pool = drivers.VIFPoolDriver.get_instance( specific_driver='multi_pool') self._drv_vif_pool.set_vif_driver()
def post_config(conf): for _, region in _REGIONS.items(): core.configure_cache_region(conf, region)
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_cache import core as oslo_cache from oslo_config import cfg from capstone import conf user_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, user_region) token_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, token_region) # Ideally, this would be set to just under 24 hours (such as 23.5 hours), so # that we cache tokens for as long as possible without returning expired # tokens. token_region.expiration_time = 60 token_map_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, token_map_region) # Ideally, this would be set to just over 24 hours (such as 25 hours), so that # the cache invalidator can more confidently purge revoked token data from the # token_region. token_map_region.expiration_time = 90
def _init_cache_region(self): self.cache_region = cache_core.create_region() cache_core.configure_cache_region(CONF, self.cache_region)
return key return generate_key example_cache_region = cache.create_region(function=my_key_generator) MEMOIZE = cache.get_memoization_decorator(CONF, example_cache_region, "group1") backend = cfg.CONF.cache.backend print("------------------------------------------------------") print("Used backend: {}".format(backend)) print("------------------------------------------------------") # Load config file here cache.configure_cache_region(CONF, example_cache_region) print("Cache configuration done") @MEMOIZE def boom(x): print(x) return x @MEMOIZE def ohyeah(x): print(x) return x
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_cache import core as oslo_cache from oslo_config import cfg from capstone import conf user_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, user_region) token_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, token_region) # Ideally, this would be set to just under 24 hours (such as 23.5 hours), so # that we cache tokens for as long as possible without returning expired # tokens. token_region.expiration_time = 60 token_map_region = oslo_cache.create_region() oslo_cache.configure_cache_region(cfg.CONF, token_map_region) # Ideally, this would be set to just over 24 hours (such as 25 hours), so that # the cache invalidator can more confidently purge revoked token data from the # token_region. token_map_region.expiration_time = 90
CONF = cfg.CONF pod_ip_caching_opts = [ cfg.BoolOpt('caching', default=True), cfg.IntOpt('cache_time', default=3600), ] CONF.register_opts(pod_ip_caching_opts, "pod_ip_caching") cache.configure(CONF) pod_ip_cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator(CONF, pod_ip_cache_region, "pod_ip_caching") cache.configure_cache_region(CONF, pod_ip_cache_region) def get_network_id(subnets): ids = ovu.osvif_to_neutron_network_ids(subnets) if len(ids) != 1: raise k_exc.IntegrityError("Subnet mapping %(subnets)s is not valid: " "%(num_networks)s unique networks found" % { 'subnets': subnets, 'num_networks': len(ids) }) return ids[0]
def _get_default_cache_region(expiration_time): region = cache.create_region() if expiration_time != 0: CONF.cache.expiration_time = expiration_time cache.configure_cache_region(CONF, region) return region
from octavia.db import api as db_apis from octavia.i18n import _ from octavia.network import base from octavia.network.drivers.neutron import allowed_address_pairs as aap from octavia.network.drivers.neutron import utils from octavia_f5.common import constants from octavia_f5.db import repositories LOG = logging.getLogger(__name__) CONF = cfg.CONF PROJECT_ID_ALIAS = 'project-id' cache.configure(CONF) cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator(CONF, cache_region, "networking") cache.configure_cache_region(CONF, cache_region) class HierachicalPortBindingDriver(aap.AllowedAddressPairsDriver): def __init__(self): super(HierachicalPortBindingDriver, self).__init__() self.amp_repo = repositories.AmphoraRepository() def allocate_vip(self, load_balancer): port_id = load_balancer.vip.port_id if port_id: LOG.info('Port %s already exists. Nothing to be done.', port_id) port = self.get_port(port_id) return self._port_to_vip(port, load_balancer) fixed_ip = {}
node_vif_driver_caching_opts = [ oslo_cfg.BoolOpt('caching', default=True), oslo_cfg.IntOpt('cache_time', default=3600), ] oslo_cfg.CONF.register_opts(node_vif_driver_caching_opts, "node_driver_caching") cache.configure(oslo_cfg.CONF) node_driver_cache_region = cache.create_region() MEMOIZE = cache.get_memoization_decorator(oslo_cfg.CONF, node_driver_cache_region, "node_driver_caching") cache.configure_cache_region(oslo_cfg.CONF, node_driver_cache_region) class NoopVIFPool(base.VIFPoolDriver): """No pool VIFs for Kubernetes Pods""" def set_vif_driver(self, driver): self._drv_vif = driver def request_vif(self, pod, project_id, subnets, security_groups): return self._drv_vif.request_vif(pod, project_id, subnets, security_groups) def release_vif(self, pod, vif, *argv): self._drv_vif.release_vif(pod, vif) def activate_vif(self, pod, vif):
def get_cache(conf): region = core.create_region() return core.configure_cache_region(conf, region)