-----
- Test PyPi upload
+1.0.3
+-----
+- Fix a bug in core.py
+- Update db_manager
+
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-__version__ = "1.0.2"
+__version__ = "1.0.3"
import json
from uuid import uuid4
from oslo_log import log as logging
-from oslo_config import cfg
-from moon_utilities import exceptions
+from moon_utilities import exceptions, configuration
from moon_db.api.managers import Managers
from moon_utilities.security_functions import filter_input, login, logout
-LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
+LOG = logging.getLogger("moon.db.api.keystone")
class KeystoneManager(Managers):
def __init__(self, connector=None):
self.driver = connector.driver
Managers.KeystoneManager = self
- self.__url = CONF.keystone.url
- self.__user = CONF.keystone.user
- self.__password = CONF.keystone.password
- self.__domain = CONF.keystone.domain
- self.__project = CONF.keystone.project
+ conf = configuration.get_configuration("openstack/keystone")['openstack/keystone']
+
+ self.__url = conf['url']
+ self.__user = conf['user']
+ self.__password = conf['password']
+ self.__domain = conf['domain']
+ self.__project = conf['project']
try:
os.environ.pop("http_proxy")
os.environ.pop("https_proxy")
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
from oslo_log import log as logging
-LOG = logging.getLogger(__name__)
+LOG = logging.getLogger("moon.db.api.managers")
class Managers(object):
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-import os
-import re
-import types
-import json
-import copy
from uuid import uuid4
-from oslo_config import cfg
from oslo_log import log as logging
-import requests
from moon_utilities import exceptions
from moon_utilities.security_functions import filter_input, enforce
-# from moon_db.api import algorithms
from moon_db.api.managers import Managers
-LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
+LOG = logging.getLogger("moon.db.api.model")
class ModelManager(Managers):
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-import os
-import re
-import types
-import json
-import copy
from uuid import uuid4
-from oslo_config import cfg
from oslo_log import log as logging
-import requests
-from moon_utilities import exceptions
from moon_utilities.security_functions import filter_input, enforce
-# from moon_db.api import algorithms
from moon_db.api.managers import Managers
-LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
+LOG = logging.getLogger("moon.db.api.pdp")
class PDPManager(Managers):
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-import os
-import re
-import types
-import json
-import copy
from uuid import uuid4
-from oslo_config import cfg
from oslo_log import log as logging
-import requests
-from moon_utilities import exceptions
from moon_utilities.security_functions import filter_input, enforce
-# from moon_db.api import algorithms
from moon_db.api.managers import Managers
-LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
+LOG = logging.getLogger("moon.db.api.policy")
class PolicyManager(Managers):
from moon_utilities.security_functions import filter_input, enforce
from oslo_log import log as logging
-LOG = logging.getLogger(__name__)
+LOG = logging.getLogger("moon.db.api.tenants")
class TenantManager(Managers):
from oslo_config import cfg
from moon_db.core import ConfigurationDriver
-LOG = logging.getLogger(__name__)
+LOG = logging.getLogger("moon.db.driver.memory")
CONF = cfg.CONF
import copy
import json
from uuid import uuid4
-from moon_db.exception import *
+from moon_utilities.exceptions import *
from moon_db.core import PDPDriver, PolicyDriver, ModelDriver
import sqlalchemy as sql
import logging
from sqlalchemy import create_engine
from contextlib import contextmanager
from sqlalchemy import types as sql_types
-from oslo_config import cfg
-# from moon_utilities.exceptions import IntraExtensionUnknown
+from moon_utilities import configuration
-# from sqlalchemy.orm.exc import UnmappedInstanceError
-# from keystone.contrib.moon import InterExtensionDriver
-CONF = cfg.CONF
-LOG = logging.getLogger(__name__)
+LOG = logging.getLogger("moon.db.driver.sql")
Base = declarative_base()
+DEBUG = True if configuration.get_configuration("logging")['logging']['loggers']['moon']['level'] == "DEBUG" else False
class DictBase:
def session_scope(engine):
"""Provide a transactional scope around a series of operations."""
if type(engine) is str:
- echo = True if CONF.debug else False
+ echo = DEBUG
engine = create_engine(engine, echo=echo)
session = sessionmaker(bind=engine)()
try:
engine = ""
def __init__(self, engine_name):
- echo = True if CONF.debug else False
+ echo = DEBUG
self.engine = create_engine(engine_name, echo=echo)
def init_db(self):
# license which can be found in the file 'LICENSE' in this package distribution
# or at 'http://www.apache.org/licenses/LICENSE-2.0'.
-from moon_db.exception import *
from oslo_log import log as logging
from oslo_config import cfg
from stevedore.driver import DriverManager
-from moon_utilities import options # noqa
+from moon_utilities import configuration
from moon_db.api import model, policy, pdp, keystone
CONF = cfg.CONF
-LOG = logging.getLogger(__name__)
+LOG = logging.getLogger("moon.db")
class Driver(DriverManager):
super(KeystoneDriver, self).__init__(driver_name, engine_name)
-# TODO (asteroide): we may use an other driver like the SQL driver
-# so we can change the driver to directly interrogate the Keystone database.
+conf = configuration.get_configuration("database")['database']
KeystoneManager = keystone.KeystoneManager(
- KeystoneDriver(CONF.database.driver, CONF.database.url)
+ KeystoneDriver(conf['driver'], conf['url'])
)
ModelManager = model.ModelManager(
- ModelDriver(CONF.database.driver, CONF.database.url)
+ ModelDriver(conf['driver'], conf['url'])
)
PolicyManager = policy.PolicyManager(
- PolicyDriver(CONF.database.driver, CONF.database.url)
+ PolicyDriver(conf['driver'], conf['url'])
)
PDPManager = pdp.PDPManager(
- PDPDriver(CONF.database.driver, CONF.database.url)
+ PDPDriver(conf['driver'], conf['url'])
)
import os
import glob
import importlib
-from oslo_config import cfg
-from oslo_log import log as logging
+import argparse
+import logging
from sqlalchemy import create_engine
from moon_db.migrate_repo import versions
+from moon_utilities import configuration
-# Note (asteroide): The next line must be called before the next import
-# aka before registering all the options
-cfg.CONF.register_cli_opt(cfg.StrOpt('command', positional=True,
- help="The command to execute (upgrade, downgrade)"))
-from moon_utilities import options # noqa
+parser = argparse.ArgumentParser()
+parser.add_argument('command', help='command (upgrade or downgrade)', nargs=1)
+parser.add_argument("--verbose", "-v", action='store_true', help="verbose mode")
+parser.add_argument("--debug", "-d", action='store_true', help="debug mode")
+args = parser.parse_args()
-LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
+FORMAT = '%(asctime)-15s %(levelname)s %(message)s'
+if args.debug:
+ logging.basicConfig(
+ format=FORMAT,
+ level=logging.DEBUG)
+elif args.verbose:
+ logging.basicConfig(
+ format=FORMAT,
+ level=logging.INFO)
+else:
+ logging.basicConfig(
+ format=FORMAT,
+ level=logging.WARNING)
-engine = create_engine(CONF.database.url)
+requests_log = logging.getLogger("requests.packages.urllib3")
+requests_log.setLevel(logging.WARNING)
+requests_log.propagate = True
+
+logger = logging.getLogger("moon.db.manager")
+
+db_conf = configuration.get_configuration("database")["database"]
+engine = create_engine(db_conf['url'])
def format_data(ext):
def run():
files = glob.glob(versions.__path__[0] + "/[0-9][0-9][0-9]*.py")
- # args = set_options()
for filename in files:
filename = os.path.basename(filename).replace(".py", "")
o = importlib.import_module("moon_db.migrate_repo.versions.{}".format(filename))
- LOG.info("Command is {}".format(CONF.command))
- if CONF.command in ("upgrade", "u", "up"):
- LOG.info("upgrading moon_db.migrate_repo.versions.{}".format(filename))
+ logger.info("Command is {}".format(args.command[0]))
+ if args.command[0] in ("upgrade", "u", "up"):
+ logger.info("upgrading moon_db.migrate_repo.versions.{}".format(filename))
o.upgrade(engine)
- elif CONF.command in ("downgrade", "d", "down"):
- LOG.info("downgrading moon_db.migrate_repo.versions.{}".format(filename))
+ elif args.command[0] in ("downgrade", "d", "down"):
+ logger.info("downgrading moon_db.migrate_repo.versions.{}".format(filename))
o.downgrade(engine)
- LOG.info("Done!")
+ else:
+ logger.critical("Cannot understand the command!")
Code Review / moon.git / commitdiff