Sync with oslo-incubator 9a7f2f85

Excludes oslo's policy module

Change-Id: I64c4e754fb6339928a28a6b31c8830e8053a1f82

designate/openstack/common/fixture/config.py

@@ -32,7 +32,12 @@ class Config(fixtures.Fixture):
 
     def setUp(self):
         super(Config, self).setUp()
+        # NOTE(morganfainberg): unregister must be added to cleanup before
+        # reset is because cleanup works in reverse order of registered items,
+        # and a reset must occur before unregistering options can occur.
+        self.addCleanup(self._unregister_config_opts)
         self.addCleanup(self.conf.reset)
+        self._registered_config_opts = {}
 
     def config(self, **kw):
         """Override configuration values.
@@ -49,3 +54,32 @@ class Config(fixtures.Fixture):
         group = kw.pop('group', None)
         for k, v in six.iteritems(kw):
             self.conf.set_override(k, v, group)
+
+    def _unregister_config_opts(self):
+        for group in self._registered_config_opts:
+            self.conf.unregister_opts(self._registered_config_opts[group],
+                                      group=group)
+
+    def register_opt(self, opt, group=None):
+        """Register a single option for the test run.
+
+        Options registered in this manner will automatically be unregistered
+        during cleanup.
+
+        If a `group` argument is supplied, it will register the new option
+        to that group, otherwise the option is registered to the ``default``
+        group.
+        """
+        self.conf.register_opt(opt, group=group)
+        self._registered_config_opts.setdefault(group, set()).add(opt)
+
+    def register_opts(self, opts, group=None):
+        """Register multiple options for the test run.
+
+        This works in the same manner as register_opt() but takes a list of
+        options as the first argument. All arguments will be registered to the
+        same group if the ``group`` argument is supplied, otherwise all options
+        will be registered to the ``default`` group.
+        """
+        for opt in opts:
+            self.register_opt(opt, group=group)

designate/openstack/common/fixture/logging.py

@@ -0,0 +1,34 @@
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      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.
+
+import fixtures
+
+
+def get_logging_handle_error_fixture():
+    """returns a fixture to make logging raise formatting exceptions.
+
+    Usage:
+    self.useFixture(logging.get_logging_handle_error_fixture())
+    """
+    return fixtures.MonkeyPatch('logging.Handler.handleError',
+                                _handleError)
+
+
+def _handleError(self, record):
+    """Monkey patch for logging.Handler.handleError.
+
+    The default handleError just logs the error to stderr but we want
+    the option of actually raising an exception.
+    """
+    raise

designate/openstack/common/fixture/moxstubout.py

@@ -16,7 +16,7 @@
 # under the License.
 
 import fixtures
-import mox
+from six.moves import mox  # noqa
 
 
 class MoxStubout(fixtures.Fixture):

designate/openstack/common/gettextutils.py

@@ -23,6 +23,7 @@ Usual usage in an openstack.common module:
 """
 
 import copy
+import functools
 import gettext
 import locale
 from logging import handlers
@@ -35,6 +36,17 @@ import six
 _localedir = os.environ.get('designate'.upper() + '_LOCALEDIR')
 _t = gettext.translation('designate', localedir=_localedir, fallback=True)
 
+# We use separate translation catalogs for each log level, so set up a
+# mapping between the log level name and the translator. The domain
+# for the log level is project_name + "-log-" + log_level so messages
+# for each level end up in their own catalog.
+_t_log_levels = dict(
+    (level, gettext.translation('designate' + '-log-' + level,
+                                localedir=_localedir,
+                                fallback=True))
+    for level in ['info', 'warning', 'error', 'critical']
+)
+
 _AVAILABLE_LANGUAGES = {}
 USE_LAZY = False
 
@@ -60,6 +72,28 @@ def _(msg):
         return _t.ugettext(msg)
 
 
+def _log_translation(msg, level):
+    """Build a single translation of a log message
+    """
+    if USE_LAZY:
+        return Message(msg, domain='designate' + '-log-' + level)
+    else:
+        translator = _t_log_levels[level]
+        if six.PY3:
+            return translator.gettext(msg)
+        return translator.ugettext(msg)
+
+# Translators for log levels.
+#
+# The abbreviated names are meant to reflect the usual use of a short
+# name like '_'. The "L" is for "log" and the other letter comes from
+# the level.
+_LI = functools.partial(_log_translation, level='info')
+_LW = functools.partial(_log_translation, level='warning')
+_LE = functools.partial(_log_translation, level='error')
+_LC = functools.partial(_log_translation, level='critical')
+
+
 def install(domain, lazy=False):
     """Install a _() function using the given translation domain.
 

designate/openstack/common/importutils.py

@@ -58,6 +58,13 @@ def import_module(import_str):
     return sys.modules[import_str]
 
 
+def import_versioned_module(version, submodule=None):
+    module = 'designate.v%s' % version
+    if submodule:
+        module = '.'.join((module, submodule))
+    return import_module(module)
+
+
 def try_import(import_str, default=None):
     """Try to import a module and if it fails return default."""
     try:

designate/openstack/common/log.py

@@ -304,17 +304,38 @@ class ContextAdapter(BaseLoggerAdapter):
         self.logger = logger
         self.project = project_name
         self.version = version_string
+        self._deprecated_messages_sent = dict()
 
     @property
     def handlers(self):
         return self.logger.handlers
 
     def deprecated(self, msg, *args, **kwargs):
+        """Call this method when a deprecated feature is used.
+
+        If the system is configured for fatal deprecations then the message
+        is logged at the 'critical' level and :class:`DeprecatedConfig` will
+        be raised.
+
+        Otherwise, the message will be logged (once) at the 'warn' level.
+
+        :raises: :class:`DeprecatedConfig` if the system is configured for
+                 fatal deprecations.
+
+        """
         stdmsg = _("Deprecated: %s") % msg
         if CONF.fatal_deprecations:
             self.critical(stdmsg, *args, **kwargs)
             raise DeprecatedConfig(msg=stdmsg)
-        else:
+
+        # Using a list because a tuple with dict can't be stored in a set.
+        sent_args = self._deprecated_messages_sent.setdefault(msg, list())
+
+        if args in sent_args:
+            # Already logged this message, so don't log it again.
+            return
+
+        sent_args.append(args)
         self.warn(stdmsg, *args, **kwargs)
 
     def process(self, msg, kwargs):

designate/openstack/common/network_utils.py

@@ -17,7 +17,17 @@
 Network-related utilities and helper functions.
 """
 
-from designate.openstack.common.py3kcompat import urlutils
+# TODO(jd) Use six.moves once
+# https://bitbucket.org/gutworth/six/pull-request/28
+# is merged
+try:
+    import urllib.parse
+    SplitResult = urllib.parse.SplitResult
+except ImportError:
+    import urlparse
+    SplitResult = urlparse.SplitResult
+
+from six.moves.urllib import parse
 
 
 def parse_host_port(address, default_port=None):
@@ -70,10 +80,10 @@ def urlsplit(url, scheme='', allow_fragments=True):
 
     The parameters are the same as urlparse.urlsplit.
     """
-    scheme, netloc, path, query, fragment = urlutils.urlsplit(
+    scheme, netloc, path, query, fragment = parse.urlsplit(
         url, scheme, allow_fragments)
     if allow_fragments and '#' in path:
         path, fragment = path.split('#', 1)
     if '?' in path:
         path, query = path.split('?', 1)
-    return urlutils.SplitResult(scheme, netloc, path, query, fragment)
+    return SplitResult(scheme, netloc, path, query, fragment)

designate/openstack/common/strutils.py

@@ -17,6 +17,7 @@
 System-level utilities and helper functions.
 """
 
+import math
 import re
 import sys
 import unicodedata
@@ -26,16 +27,21 @@ import six
 from designate.openstack.common.gettextutils import _
 
 
-# Used for looking up extensions of text
+UNIT_PREFIX_EXPONENT = {
-# to their 'multiplied' byte amount
+    'k': 1,
-BYTE_MULTIPLIERS = {
+    'K': 1,
-    '': 1,
+    'Ki': 1,
-    't': 1024 ** 4,
+    'M': 2,
-    'g': 1024 ** 3,
+    'Mi': 2,
-    'm': 1024 ** 2,
+    'G': 3,
-    'k': 1024,
+    'Gi': 3,
+    'T': 4,
+    'Ti': 4,
+}
+UNIT_SYSTEM_INFO = {
+    'IEC': (1024, re.compile(r'(^[-+]?\d*\.?\d+)([KMGT]i?)?(b|bit|B)$')),
+    'SI': (1000, re.compile(r'(^[-+]?\d*\.?\d+)([kMGT])?(b|bit|B)$')),
 }
-BYTE_REGEX = re.compile(r'(^-?\d+)(\D*)')
 
 TRUE_STRINGS = ('1', 't', 'true', 'on', 'y', 'yes')
 FALSE_STRINGS = ('0', 'f', 'false', 'off', 'n', 'no')
@@ -167,34 +173,50 @@ def safe_encode(text, incoming=None,
     return text
 
 
-def to_bytes(text, default=0):
+def string_to_bytes(text, unit_system='IEC', return_int=False):
-    """Converts a string into an integer of bytes.
+    """Converts a string into an float representation of bytes.
 
-    Looks at the last characters of the text to determine
+    The units supported for IEC ::
-    what conversion is needed to turn the input text into a byte number.
+
-    Supports "B, K(B), M(B), G(B), and T(B)". (case insensitive)
+        Kb(it), Kib(it), Mb(it), Mib(it), Gb(it), Gib(it), Tb(it), Tib(it)
+        KB, KiB, MB, MiB, GB, GiB, TB, TiB
+
+    The units supported for SI ::
+
+        kb(it), Mb(it), Gb(it), Tb(it)
+        kB, MB, GB, TB
+
+    Note that the SI unit system does not support capital letter 'K'
 
     :param text: String input for bytes size conversion.
-    :param default: Default return value when text is blank.
+    :param unit_system: Unit system for byte size conversion.
+    :param return_int: If True, returns integer representation of text
+                       in bytes. (default: decimal)
+    :returns: Numerical representation of text in bytes.
+    :raises ValueError: If text has an invalid value.
 
     """
-    match = BYTE_REGEX.search(text)
+    try:
+        base, reg_ex = UNIT_SYSTEM_INFO[unit_system]
+    except KeyError:
+        msg = _('Invalid unit system: "%s"') % unit_system
+        raise ValueError(msg)
+    match = reg_ex.match(text)
     if match:
-        magnitude = int(match.group(1))
+        magnitude = float(match.group(1))
-        mult_key_org = match.group(2)
+        unit_prefix = match.group(2)
-        if not mult_key_org:
+        if match.group(3) in ['b', 'bit']:
-            return magnitude
+            magnitude /= 8
-    elif text:
-        msg = _('Invalid string format: %s') % text
-        raise TypeError(msg)
     else:
-        return default
+        msg = _('Invalid string format: %s') % text
-    mult_key = mult_key_org.lower().replace('b', '', 1)
+        raise ValueError(msg)
-    multiplier = BYTE_MULTIPLIERS.get(mult_key)
+    if not unit_prefix:
-    if multiplier is None:
+        res = magnitude
-        msg = _('Unknown byte multiplier: %s') % mult_key_org
+    else:
-        raise TypeError(msg)
+        res = magnitude * pow(base, UNIT_PREFIX_EXPONENT[unit_prefix])
-    return magnitude * multiplier
+    if return_int:
+        return int(math.ceil(res))
+    return res
 
 
 def to_slug(value, incoming=None, errors="strict"):