cfg.BoolOpt('allow_bulk', default=True),
cfg.IntOpt('max_dns_nameservers', default=5),
cfg.IntOpt('max_subnet_host_routes', default=20),
+ cfg.StrOpt('state_path', default='.'),
]
# Register the configuration options
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2011 Citrix Systems, Inc.
-# 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.
-
-"""Command-line flag library.
-
-Wraps gflags.
-Global flags should be defined here, the rest are defined where they're used.
-
-"""
-import getopt
-import gflags
-import os
-import string
-import sys
-
-
-class FlagValues(gflags.FlagValues):
- """Extension of gflags.FlagValues that allows undefined and runtime flags.
-
- Unknown flags will be ignored when parsing the command line, but the
- command line will be kept so that it can be replayed if new flags are
- defined after the initial parsing.
-
- """
-
- def __init__(self, extra_context=None):
- gflags.FlagValues.__init__(self)
- self.__dict__['__dirty'] = []
- self.__dict__['__was_already_parsed'] = False
- self.__dict__['__stored_argv'] = []
- self.__dict__['__extra_context'] = extra_context
-
- def __call__(self, argv):
- # We're doing some hacky stuff here so that we don't have to copy
- # out all the code of the original verbatim and then tweak a few lines.
- # We're hijacking the output of getopt so we can still return the
- # leftover args at the end
- sneaky_unparsed_args = {"value": None}
- original_argv = list(argv)
-
- if self.IsGnuGetOpt():
- orig_getopt = getattr(getopt, 'gnu_getopt')
- orig_name = 'gnu_getopt'
- else:
- orig_getopt = getattr(getopt, 'getopt')
- orig_name = 'getopt'
-
- def _sneaky(*args, **kw):
- optlist, unparsed_args = orig_getopt(*args, **kw)
- sneaky_unparsed_args['value'] = unparsed_args
- return optlist, unparsed_args
-
- try:
- setattr(getopt, orig_name, _sneaky)
- args = gflags.FlagValues.__call__(self, argv)
- except gflags.UnrecognizedFlagError:
- # Undefined args were found, for now we don't care so just
- # act like everything went well
- # (these three lines are copied pretty much verbatim from the end
- # of the __call__ function we are wrapping)
- unparsed_args = sneaky_unparsed_args['value']
- if unparsed_args:
- if self.IsGnuGetOpt():
- args = argv[:1] + unparsed_args
- else:
- args = argv[:1] + original_argv[-len(unparsed_args):]
- else:
- args = argv[:1]
- finally:
- setattr(getopt, orig_name, orig_getopt)
-
- # Store the arguments for later, we'll need them for new flags
- # added at runtime
- self.__dict__['__stored_argv'] = original_argv
- self.__dict__['__was_already_parsed'] = True
- self.ClearDirty()
- return args
-
- def Reset(self):
- gflags.FlagValues.Reset(self)
- self.__dict__['__dirty'] = []
- self.__dict__['__was_already_parsed'] = False
- self.__dict__['__stored_argv'] = []
-
- def SetDirty(self, name):
- """Mark a flag as dirty so that accessing it will case a reparse."""
- self.__dict__['__dirty'].append(name)
-
- def IsDirty(self, name):
- return name in self.__dict__['__dirty']
-
- def ClearDirty(self):
- self.__dict__['__is_dirty'] = []
-
- def WasAlreadyParsed(self):
- return self.__dict__['__was_already_parsed']
-
- def ParseNewFlags(self):
- if '__stored_argv' not in self.__dict__:
- return
- new_flags = FlagValues(self)
- for k in self.__dict__['__dirty']:
- new_flags[k] = gflags.FlagValues.__getitem__(self, k)
-
- new_flags(self.__dict__['__stored_argv'])
- for k in self.__dict__['__dirty']:
- setattr(self, k, getattr(new_flags, k))
- self.ClearDirty()
-
- def __setitem__(self, name, flag):
- gflags.FlagValues.__setitem__(self, name, flag)
- if self.WasAlreadyParsed():
- self.SetDirty(name)
-
- def __getitem__(self, name):
- if self.IsDirty(name):
- self.ParseNewFlags()
- return gflags.FlagValues.__getitem__(self, name)
-
- def __getattr__(self, name):
- if self.IsDirty(name):
- self.ParseNewFlags()
- val = gflags.FlagValues.__getattr__(self, name)
- if type(val) is str:
- tmpl = string.Template(val)
- context = [self, self.__dict__['__extra_context']]
- return tmpl.substitute(StrWrapper(context))
- return val
-
-
-class StrWrapper(object):
- """Wrapper around FlagValues objects.
-
- Wraps FlagValues objects for string.Template so that we're
- sure to return strings.
-
- """
- def __init__(self, context_objs):
- self.context_objs = context_objs
-
- def __getitem__(self, name):
- for context in self.context_objs:
- val = getattr(context, name, False)
- if val:
- return str(val)
- raise KeyError(name)
-
-
-# Copied from gflags with small mods to get the naming correct.
-# Originally gflags checks for the first module that is not gflags that is
-# in the call chain, we want to check for the first module that is not gflags
-# and not this module.
-def _GetCallingModule():
- """Returns the name of the module that's calling into this module.
-
- We generally use this function to get the name of the module calling a
- DEFINE_foo... function.
-
- """
- # Walk down the stack to find the first globals dict that's not ours.
- for depth in range(1, sys.getrecursionlimit()):
- if not sys._getframe(depth).f_globals is globals():
- module_name = __GetModuleName(sys._getframe(depth).f_globals)
- if module_name == 'gflags':
- continue
- if module_name is not None:
- return module_name
- raise AssertionError("No module was found")
-
-
-# Copied from gflags because it is a private function
-def __GetModuleName(globals_dict):
- """Given a globals dict, returns the name of the module that defines it.
-
- Args:
- globals_dict: A dictionary that should correspond to an environment
- providing the values of the globals.
-
- Returns:
- A string (the name of the module) or None (if the module could not
- be identified.
-
- """
- for name, module in sys.modules.iteritems():
- if getattr(module, '__dict__', None) is globals_dict:
- if name == '__main__':
- return sys.argv[0]
- return name
- return None
-
-
-def _wrapper(func):
- def _wrapped(*args, **kw):
- kw.setdefault('flag_values', FLAGS)
- func(*args, **kw)
- _wrapped.func_name = func.func_name
- return _wrapped
-
-
-FLAGS = FlagValues()
-gflags.FLAGS = FLAGS
-gflags._GetCallingModule = _GetCallingModule
-
-
-DEFINE = _wrapper(gflags.DEFINE)
-DEFINE_string = _wrapper(gflags.DEFINE_string)
-DEFINE_integer = _wrapper(gflags.DEFINE_integer)
-DEFINE_bool = _wrapper(gflags.DEFINE_bool)
-DEFINE_boolean = _wrapper(gflags.DEFINE_boolean)
-DEFINE_float = _wrapper(gflags.DEFINE_float)
-DEFINE_enum = _wrapper(gflags.DEFINE_enum)
-DEFINE_list = _wrapper(gflags.DEFINE_list)
-DEFINE_spaceseplist = _wrapper(gflags.DEFINE_spaceseplist)
-DEFINE_multistring = _wrapper(gflags.DEFINE_multistring)
-DEFINE_multi_int = _wrapper(gflags.DEFINE_multi_int)
-DEFINE_flag = _wrapper(gflags.DEFINE_flag)
-HelpFlag = gflags.HelpFlag
-HelpshortFlag = gflags.HelpshortFlag
-HelpXMLFlag = gflags.HelpXMLFlag
-
-
-def DECLARE(name, module_string, flag_values=FLAGS):
- if module_string not in sys.modules:
- __import__(module_string, globals(), locals())
- if name not in flag_values:
- raise gflags.UnrecognizedFlag(
- "%s not defined by %s" % (name, module_string))
-
-
-# __GLOBAL FLAGS ONLY__
-# Define any app-specific flags in their own files, docs at:
-# http://code.google.com/p/python-gflags/source/browse/trunk/gflags.py#a9
-
-DEFINE_string('state_path', os.path.join(os.path.dirname(__file__), '../../'),
- "Top-level directory for maintaining quantum's state")
import uuid
from quantum.common import exceptions as exception
-from quantum.common import flags
+from quantum.openstack.common import cfg
from quantum.openstack.common.exception import ProcessExecutionError
-
TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
-FLAGS = flags.FLAGS
def boolize(subject):
return cache_info['data']
-class LazyPluggable(object):
- """A pluggable backend loaded lazily based on some value."""
-
- def __init__(self, pivot, **backends):
- self.__backends = backends
- self.__pivot = pivot
- self.__backend = None
-
- def __get_backend(self):
- if not self.__backend:
- backend_name = self.__pivot.value
- if backend_name not in self.__backends:
- raise exception.Error('Invalid backend: %s' % backend_name)
-
- backend = self.__backends[backend_name]
- if isinstance(backend, tuple):
- name = backend[0]
- fromlist = backend[1]
- else:
- name = backend
- fromlist = backend
-
- self.__backend = __import__(name, None, None, fromlist)
- logging.info('backend %s', self.__backend)
- return self.__backend
-
- def __getattr__(self, key):
- backend = self.__get_backend()
- return getattr(backend, key)
-
-
def find_config_file(options, config_file):
"""
Return the first config file found.
fix_path(os.path.join('~', '.quantum-venv', 'etc',
'quantum')),
fix_path('~'),
- os.path.join(FLAGS.state_path, 'etc'),
- os.path.join(FLAGS.state_path, 'etc', 'quantum'),
+ os.path.join(cfg.CONF.state_path, 'etc'),
+ os.path.join(cfg.CONF.state_path, 'etc', 'quantum'),
fix_path(os.path.join('~', '.local',
'etc', 'quantum')),
'/usr/etc/quantum',
setattr(__builtin__, '_', lambda x: x)
-from quantum.common import flags
+from quantum.openstack.common import cfg
-FLAGS = flags.FLAGS
reldir = os.path.join(os.path.dirname(__file__), '..', '..', '..')
absdir = os.path.abspath(reldir)
-FLAGS.state_path = absdir
+cfg.CONF.state_path = absdir
class BaseTest(unittest.TestCase):
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-from quantum.common import flags
-
-FLAGS = flags.FLAGS
-
-flags.DEFINE_integer('answer', 42, 'test flag')
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# 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.
-
-from quantum.common import flags
-
-
-FLAGS = flags.FLAGS
-
-flags.DEFINE_integer('runtime_answer', 54, 'test flag')
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-# Copyright 2011 Red Hat, Inc.
-#
-# 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 os
-import tempfile
-import unittest
-
-import gflags
-
-from quantum.common import flags
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('flags_unittest', 'foo', 'for testing purposes only')
-
-
-class FlagsTestCase(unittest.TestCase):
-
- def flags(self, **kw):
- """Override flag variables for a test."""
- for k, v in kw.iteritems():
- setattr(FLAGS, k, v)
-
- def reset_flags(self):
- """Resets all flag variables for the test.
-
- Runs after each test.
-
- """
- FLAGS.Reset()
- for k, v in self._original_flags.iteritems():
- setattr(FLAGS, k, v)
-
- def setUp(self):
- super(FlagsTestCase, self).setUp()
- self.FLAGS = flags.FlagValues()
- self.global_FLAGS = flags.FLAGS
- self._original_flags = FLAGS.FlagValuesDict()
-
- def test_define(self):
- self.assert_('string' not in self.FLAGS)
- self.assert_('int' not in self.FLAGS)
- self.assert_('false' not in self.FLAGS)
- self.assert_('true' not in self.FLAGS)
-
- flags.DEFINE_string('string', 'default', 'desc',
- flag_values=self.FLAGS)
- flags.DEFINE_integer('int', 1, 'desc', flag_values=self.FLAGS)
- flags.DEFINE_bool('false', False, 'desc', flag_values=self.FLAGS)
- flags.DEFINE_bool('true', True, 'desc', flag_values=self.FLAGS)
-
- self.assert_(self.FLAGS['string'])
- self.assert_(self.FLAGS['int'])
- self.assert_(self.FLAGS['false'])
- self.assert_(self.FLAGS['true'])
- self.assertEqual(self.FLAGS.string, 'default')
- self.assertEqual(self.FLAGS.int, 1)
- self.assertEqual(self.FLAGS.false, False)
- self.assertEqual(self.FLAGS.true, True)
-
- argv = ['flags_test',
- '--string', 'foo',
- '--int', '2',
- '--false',
- '--notrue']
-
- self.FLAGS(argv)
- self.assertEqual(self.FLAGS.string, 'foo')
- self.assertEqual(self.FLAGS.int, 2)
- self.assertEqual(self.FLAGS.false, True)
- self.assertEqual(self.FLAGS.true, False)
-
- def test_define_float(self):
- flags.DEFINE_float('float', 6.66, 'desc', flag_values=self.FLAGS)
- self.assertEqual(self.FLAGS.float, 6.66)
-
- def test_define_multistring(self):
- flags.DEFINE_multistring('multi', [], 'desc', flag_values=self.FLAGS)
-
- argv = ['flags_test', '--multi', 'foo', '--multi', 'bar']
- self.FLAGS(argv)
-
- self.assertEqual(self.FLAGS.multi, ['foo', 'bar'])
-
- def test_define_list(self):
- flags.DEFINE_list('list', ['foo'], 'desc', flag_values=self.FLAGS)
-
- self.assert_(self.FLAGS['list'])
- self.assertEqual(self.FLAGS.list, ['foo'])
-
- argv = ['flags_test', '--list=a,b,c,d']
- self.FLAGS(argv)
-
- self.assertEqual(self.FLAGS.list, ['a', 'b', 'c', 'd'])
-
- def test_error(self):
- flags.DEFINE_integer('error', 1, 'desc', flag_values=self.FLAGS)
-
- self.assertEqual(self.FLAGS.error, 1)
-
- argv = ['flags_test', '--error=foo']
- self.assertRaises(gflags.IllegalFlagValue, self.FLAGS, argv)
-
- def test_declare(self):
- self.assert_('answer' not in self.global_FLAGS)
- flags.DECLARE('answer', 'quantum.tests.unit.declare_flags')
- self.assert_('answer' in self.global_FLAGS)
- self.assertEqual(self.global_FLAGS.answer, 42)
-
- # Make sure we don't overwrite anything
- self.global_FLAGS.answer = 256
- self.assertEqual(self.global_FLAGS.answer, 256)
- flags.DECLARE('answer', 'quantum.tests.unit.declare_flags')
- self.assertEqual(self.global_FLAGS.answer, 256)
-
- def test_getopt_non_interspersed_args(self):
- self.assert_('runtime_answer' not in self.global_FLAGS)
-
- argv = ['flags_test', 'extra_arg', '--runtime_answer=60']
- args = self.global_FLAGS(argv)
- self.assertEqual(len(args), 3)
- self.assertEqual(argv, args)
-
- def test_runtime_and_unknown_flags(self):
- self.assert_('runtime_answer' not in self.global_FLAGS)
-
- argv = ['flags_test', '--runtime_answer=60', 'extra_arg']
- args = self.global_FLAGS(argv)
- self.assertEqual(len(args), 2)
- self.assertEqual(args[1], 'extra_arg')
-
- self.assert_('runtime_answer' not in self.global_FLAGS)
-
- import quantum.tests.unit.runtime_flags
-
- self.assert_('runtime_answer' in self.global_FLAGS)
- self.assertEqual(self.global_FLAGS.runtime_answer, 60)
-
- def test_flag_overrides(self):
- self.assertEqual(FLAGS.flags_unittest, 'foo')
- self.flags(flags_unittest='bar')
- self.assertEqual(FLAGS.flags_unittest, 'bar')
- self.assertEqual(FLAGS['flags_unittest'].value, 'bar')
- self.assertEqual(FLAGS.FlagValuesDict()['flags_unittest'], 'bar')
- self.reset_flags()
- self.assertEqual(FLAGS.flags_unittest, 'foo')
- self.assertEqual(FLAGS['flags_unittest'].value, 'foo')
- self.assertEqual(FLAGS.FlagValuesDict()['flags_unittest'], 'foo')
-
- def test_flagfile(self):
- flags.DEFINE_string('string', 'default', 'desc',
- flag_values=self.FLAGS)
- flags.DEFINE_integer('int', 1, 'desc', flag_values=self.FLAGS)
- flags.DEFINE_bool('false', False, 'desc', flag_values=self.FLAGS)
- flags.DEFINE_bool('true', True, 'desc', flag_values=self.FLAGS)
-
- (fd, path) = tempfile.mkstemp(prefix='nova', suffix='.flags')
-
- try:
- os.write(fd, '--string=foo\n--int=2\n--false\n--notrue\n')
- os.close(fd)
-
- self.FLAGS(['flags_test', '--flagfile=' + path])
-
- self.assertEqual(self.FLAGS.string, 'foo')
- self.assertEqual(self.FLAGS.int, 2)
- self.assertEqual(self.FLAGS.false, True)
- self.assertEqual(self.FLAGS.true, False)
- finally:
- os.remove(path)
-
- def test_defaults(self):
- flags.DEFINE_string('foo', 'bar', 'help', flag_values=self.FLAGS)
- self.assertEqual(self.FLAGS.foo, 'bar')
-
- self.FLAGS['foo'].SetDefault('blaa')
- self.assertEqual(self.FLAGS.foo, 'blaa')
-
- def test_templated_values(self):
- flags.DEFINE_string('foo', 'foo', 'help', flag_values=self.FLAGS)
- flags.DEFINE_string('bar', 'bar', 'help', flag_values=self.FLAGS)
- flags.DEFINE_string('blaa', '$foo$bar', 'help', flag_values=self.FLAGS)
- self.assertEqual(self.FLAGS.blaa, 'foobar')
iso8601>=0.1.4
lxml
netaddr
-python-gflags==1.3
python-quantumclient>=0.1,<0.2
pyudev
sqlalchemy>0.6.4
Code Review / openstack-build / neutron-build.git / commitdiff