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 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 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 __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 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 _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
def _get_cache_region(conf):
region = cache.create_region()
cache.configure_cache_region(conf, region)
return region
def _init_cache_region(self):
self.cache_region = cache_core.create_region()
cache_core.configure_cache_region(CONF, self.cache_region)
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
def setup_cache(conf):
global CACHE_REGION
core.configure(conf)
region = core.create_region()
CACHE_REGION = core.configure_cache_region(conf, 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 _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)
