functest: /home/opnfv/functest
functest_test: /home/opnfv/repos/functest/functest/opnfv_tests
results: /home/opnfv/functest/results
- functest_logging_cfg: /home/opnfv/repos/functest/functest/ci/logging.json
+ functest_logging_cfg: /home/opnfv/repos/functest/functest/ci/logging.ini
functest_conf: /home/opnfv/functest/conf
functest_data: /home/opnfv/functest/data
ims_data: /home/opnfv/functest/data/ims/
# http://www.apache.org/licenses/LICENSE-2.0
#
import json
+import logging
import re
+import sys
import urllib2
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from functest.utils.constants import CONST
# and then we can print the url to the specific test result
-logger = ft_logger.Logger("generate_report").getLogger()
+logger = logging.getLogger(__name__)
def init(tiers_to_run=[]):
if __name__ == '__main__':
- import sys
+ logging.basicConfig()
main(sys.argv[1:])
--- /dev/null
+[loggers]
+keys=root,functest,ci,cli,core,opnfv_tests,utils
+
+[handlers]
+keys=console,wconsole,file,null
+
+[formatters]
+keys=standard
+
+[logger_root]
+level=NOTSET
+handlers=null
+
+[logger_functest]
+level=NOTSET
+handlers=file
+qualname=functest
+
+[logger_ci]
+level=NOTSET
+handlers=console
+qualname=functest.ci
+
+[logger_cli]
+level=NOTSET
+handlers=wconsole
+qualname=functest.cli
+
+[logger_core]
+level=NOTSET
+handlers=console
+qualname=functest.core
+
+[logger_opnfv_tests]
+level=NOTSET
+handlers=wconsole
+qualname=functest.opnfv_tests
+
+[logger_utils]
+level=NOTSET
+handlers=wconsole
+qualname=functest.utils
+
+[handler_null]
+class=NullHandler
+level=NOTSET
+formatter=standard
+args=()
+
+[handler_console]
+class=StreamHandler
+level=INFO
+formatter=standard
+args=(sys.stdout,)
+
+[handler_wconsole]
+class=StreamHandler
+level=WARN
+formatter=standard
+args=(sys.stdout,)
+
+[handler_file]
+class=FileHandler
+level=DEBUG
+formatter=standard
+args=("/home/opnfv/functest/results/functest.log",)
+
+[formatter_standard]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+datefmt=
+++ /dev/null
-{
- "version": 1,
- "disable_existing_loggers": false,
- "formatters": {
- "standard": {
- "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
- }
- },
- "handlers": {
- "console": {
- "level": "INFO",
- "class": "logging.StreamHandler",
- "formatter": "standard"
- },
- "file": {
- "level": "DEBUG",
- "class": "logging.FileHandler",
- "formatter": "standard",
- "filename": "/home/opnfv/functest/results/functest.log"
- }
- },
- "loggers": {
- "": {
- "handlers": ["console", "file"],
- "level": "DEBUG",
- "propagate": "yes"
- }
- }
-}
import argparse
import json
+import logging
+import logging.config
import os
import re
import subprocess
import yaml
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
from functest.utils.constants import CONST
actions = ['start', 'check']
""" logging configuration """
-logger = ft_logger.Logger("prepare_env").getLogger()
+logger = logging.getLogger('functest.ci.prepare_env')
handler = None
# set the architecture to default
pod_arch = None
if __name__ == '__main__':
+ logging.config.fileConfig(
+ CONST.__getattribute__('dir_functest_logging_cfg'))
parser = PrepareEnvParser()
args = parser.parse_args(sys.argv[1:])
sys.exit(main(**args))
import datetime
import enum
import importlib
+import logging
+import logging.config
import os
import re
import sys
import functest.ci.generate_report as generate_report
import functest.ci.tier_builder as tb
import functest.core.testcase as testcase
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_clean as os_clean
import functest.utils.openstack_snapshot as os_snapshot
import functest.utils.openstack_utils as os_utils
from functest.utils.constants import CONST
-
-""" logging configuration """
-logger = ft_logger.Logger("run_tests").getLogger()
+# __name__ cannot be used here
+logger = logging.getLogger('functest.ci.run_tests')
class Result(enum.Enum):
if __name__ == '__main__':
+ logging.config.fileConfig(
+ CONST.__getattribute__('dir_functest_logging_cfg'))
parser = RunTestsParser()
args = parser.parse_args(sys.argv[1:])
sys.exit(main(**args).value)
#
import click
+import logging.config
from functest.cli.commands.cli_env import CliEnv
from functest.cli.commands.cli_os import CliOpenStack
from functest.cli.commands.cli_testcase import CliTestcase
from functest.cli.commands.cli_tier import CliTier
+from functest.utils.constants import CONST
+
CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
@click.group(context_settings=CONTEXT_SETTINGS)
@click.version_option(version='opnfv colorado.0.1 ')
def cli():
- pass
+ logging.config.fileConfig(
+ CONST.__getattribute__('dir_functest_logging_cfg'))
_env = CliEnv()
helpers to run any python method or any bash command.
"""
+import logging
import time
import functest.core.testcase as base
import functest.utils.functest_utils as ft_utils
-import functest.utils.functest_logger as ft_logger
from functest.utils.constants import CONST
__author__ = ("Serena Feng <feng.xiaowei@zte.com.cn>, "
class Feature(base.TestCase):
"""Base model for single feature."""
+ logger = logging.getLogger(__name__)
+
def __init__(self, **kwargs):
super(Feature, self).__init__(**kwargs)
self.result_file = "{}/{}.log".format(
CONST.__getattribute__('dir_results'), self.project_name)
- self.logger = ft_logger.Logger(self.project_name).getLogger()
def execute(self, **kwargs):
"""Execute the Python method.
"""Define the parent class of all Functest TestCases."""
+import logging
import os
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
EX_TESTCASE_FAILED = os.EX_SOFTWARE - 2
"""results are false"""
- logger = ft_logger.Logger(__name__).getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self, **kwargs):
self.details = {}
# http://www.apache.org/licenses/LICENSE-2.0
import inspect
+import logging
import time
import functest.core.testcase as base
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
class VnfOnBoardingBase(base.TestCase):
- logger = ft_logger.Logger(__name__).getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self, **kwargs):
super(VnfOnBoardingBase, self).__init__(**kwargs)
#
import json
+import logging
import os
import re
import subprocess
from functest.core import testcase
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
-logger = ft_logger.Logger('Rally').getLogger()
+logger = logging.getLogger(__name__)
class RallyBase(testcase.TestCase):
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
import argparse
+import logging
import os
import re
import sys
from functest.core import testcase
from functest.opnfv_tests.openstack.tempest import conf_utils
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from tempest_conf import TempestConf
""" logging configuration """
-logger = ft_logger.Logger("refstack_defcore").getLogger()
+logger = logging.getLogger(__name__)
class RefstackClient(testcase.TestCase):
if __name__ == '__main__':
+ logging.basicConfig()
refstackclient = RefstackClient()
parser = RefstackClientParser()
args = parser.parse_args(sys.argv[1:])
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import os
from functest.opnfv_tests.openstack.tempest import conf_utils
from functest.utils import openstack_utils
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
""" logging configuration """
-logger = ft_logger.Logger("refstack_defcore").getLogger()
+logger = logging.getLogger(__name__)
class TempestConf(object):
if __name__ == '__main__':
+ logging.basicConfig()
tempestconf = TempestConf()
tempestconf.main()
# http://www.apache.org/licenses/LICENSE-2.0
#
import ConfigParser
+import logging
import os
import re
import shutil
import subprocess
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
CI_INSTALLER_IP = CONST.INSTALLER_IP
""" logging configuration """
-logger = ft_logger.Logger("Tempest").getLogger()
+logger = logging.getLogger(__name__)
def create_tempest_resources(use_custom_images=False,
# http://www.apache.org/licenses/LICENSE-2.0
#
+import logging
import os
import re
import shutil
from functest.core import testcase
from functest.opnfv_tests.openstack.tempest import conf_utils
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
""" logging configuration """
-logger = ft_logger.Logger("Tempest").getLogger()
+logger = logging.getLogger(__name__)
class TempestCommon(testcase.TestCase):
#
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import os
import re
import sys
import paramiko
from scp import SCPClient
-import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
import vping_base
import functest.core.testcase as testcase
if "case_name" not in kwargs:
kwargs["case_name"] = "vping_ssh"
super(VPingSSH, self).__init__(**kwargs)
- self.logger = ft_logger.Logger(self.case_name).getLogger()
+ self.logger = logging.getLogger(__name__)
def do_vping(self, vm, test_ip):
floatip = self.add_float_ip(vm)
if __name__ == '__main__':
+ logging.basicConfig()
args_parser = argparse.ArgumentParser()
args_parser.add_argument("-r", "--report",
help="Create json result file",
#
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import sys
import time
import argparse
-import functest.utils.functest_logger as ft_logger
import vping_base
if "case_name" not in kwargs:
kwargs["case_name"] = "vping_userdata"
super(VPingUserdata, self).__init__(**kwargs)
- self.logger = ft_logger.Logger(self.case_name).getLogger()
+ self.logger = logging.getLogger(__name__)
def boot_vm_preparation(self, config, vmname, test_ip):
config['config_drive'] = True
if __name__ == '__main__':
+ logging.basicConfig()
args_parser = argparse.ArgumentParser()
args_parser.add_argument("-r", "--report",
help="Create json result file",
import argparse
import errno
import fileinput
+import logging
import os
import re
import sys
from robot.utils.robottime import timestamp_to_secs
from functest.core import testcase
-import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as op_utils
__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
"csit/suites/integration/basic")
default_suites = [basic_suite_dir, neutron_suite_dir]
res_dir = '/home/opnfv/functest/results/odl/'
- logger = ft_logger.Logger("opendaylight").getLogger()
+ logger = logging.getLogger(__name__)
@classmethod
def set_robotframework_vars(cls, odlusername="admin", odlpassword="admin"):
if __name__ == '__main__':
+ logging.basicConfig()
ODL = ODLTests()
PARSER = ODLParser()
ARGS = PARSER.parse_args(sys.argv[1:])
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import os
import re
import subprocess
from functest.core import testcase
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as openstack_utils
onos_sfc_path = os.path.join(CONST.__getattribute__('dir_repo_functest'),
CONST.__getattribute__('dir_onos_sfc'))
installer_type = CONST.__getattribute__('INSTALLER_TYPE')
- logger = ft_logger.Logger(__name__).getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self, **kwargs):
if "case_name" not in kwargs:
-"""Script to Test the SFC scenarios in ONOS."""
# !/usr/bin/python
#
# Copyright (c) CREATED5 All rights reserved
# Testcase 7 : Cleanup
# ###########################################################################
#
+"""Script to Test the SFC scenarios in ONOS."""
+import logging
import time
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from sfc_onos import SfcOnos
-logger = ft_logger.Logger("sfc").getLogger()
+logger = logging.getLogger(__name__)
Sfc_obj = SfcOnos()
OK = 200
if __name__ == '__main__':
+ logging.basicConfig()
main()
+import logging
import os
import re
import time
from multiprocessing import Queue
from pexpect import pxssh
-import functest.utils.functest_logger as ft_logger
-
from functest.utils.constants import CONST
OK = 200
def __init__(self):
"""Initialization of variables."""
- self.logger = ft_logger.Logger("sfc_fun").getLogger()
+ self.logger = logging.getLogger(__name__)
self.osver = "v2.0"
self.token_id = 0
self.net_id = 0
#
"""
import json
+import logging
import pexpect
import requests
import time
from environment import Environment
-import functest.utils.functest_logger as ft_logger
class Client(Environment):
- logger = ft_logger.Logger("client").getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self):
Environment.__init__(self)
# http://www.apache.org/licenses/LICENSE-2.0
#
"""
+import logging
import os
import pexpect
import re
from foundation import Foundation
-import functest.utils.functest_logger as ft_logger
class Connection(Foundation):
- logger = ft_logger.Logger("connection").getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self):
Foundation.__init__(self)
#
"""
+import logging
import pexpect
import pxssh
import re
import time
from connection import Connection
-import functest.utils.functest_logger as ft_logger
class Environment(Connection):
- logger = ft_logger.Logger("environment").getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self):
Connection.__init__(self)
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import sys
import argparse
import functest.core.testcase as testcase
import functest.core.vnf_base as vnf_base
-import functest.utils.functest_logger as ft_logger
class AaaVnf(vnf_base.VnfOnBoardingBase):
- logger = ft_logger.Logger("VNF AAA").getLogger()
+ logger = logging.getLogger(__name__)
def __init__(self, **kwargs):
if "case_name" not in kwargs:
if __name__ == '__main__':
+ logging.basicConfig()
parser = argparse.ArgumentParser()
args = vars(parser.parse_args())
aaa_vnf = AaaVnf()
#
# http://www.apache.org/licenses/LICENSE-2.0
import json
+import logging
import os
import shutil
import functest.core.vnf_base as vnf_base
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
class ClearwaterOnBoardingBase(vnf_base.VnfOnBoardingBase):
def __init__(self, **kwargs):
- self.logger = ft_logger.Logger(__name__).getLogger()
+ self.logger = logging.getLogger(__name__)
super(ClearwaterOnBoardingBase, self).__init__(**kwargs)
self.case_dir = os.path.join(CONST.dir_functest_test, 'vnf', 'ims')
self.data_dir = CONST.dir_ims_data
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
+import logging
import os
import sys
import time
import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
from functest.opnfv_tests.vnf.ims.orchestrator_cloudify import Orchestrator
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
if "case_name" not in kwargs:
kwargs["case_name"] = "cloudify_ims"
super(CloudifyIms, self).__init__(**kwargs)
- self.logger = ft_logger.Logger(__name__).getLogger()
+ self.logger = logging.getLogger(__name__)
# Retrieve the configuration
try:
# http://www.apache.org/licenses/LICENSE-2.0
import json
+import logging
import os
import time
import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
class OperaIms(clearwater_ims_base.ClearwaterOnBoardingBase):
def __init__(self, project='functest', case_name='opera_ims',
repo=CONST.dir_repo_opera, cmd=''):
super(OperaIms, self).__init__(project, case_name, repo, cmd)
- self.logger = ft_logger.Logger(__name__).getLogger()
+ self.logger = logging.getLogger(__name__)
self.ellis_file = os.path.join(self.result_dir, 'ellis.info')
self.live_test_file = os.path.join(self.result_dir,
'live_test_report.json')
# http://www.apache.org/licenses/LICENSE-2.0
import json
+import logging
import socket
import sys
import time
import yaml
import functest.core.vnf_base as vnf_base
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
import os
self.ob_port = "8080"
self.ob_ip = "localhost"
self.ob_instance_id = ""
- self.logger = ft_logger.Logger("orchestra_ims").getLogger()
+ self.logger = logging.getLogger(__name__)
self.case_dir = os.path.join(CONST.dir_functest_test, 'vnf/ims/')
self.data_dir = CONST.dir_ims_data
self.test_dir = CONST.dir_repo_vims_test
if __name__ == '__main__':
+ logging.basicConfig()
test = ImsVnf()
test.deploy_orchestrator()
test.deploy_vnf()
# http://www.apache.org/licenses/LICENSE-2.0
########################################################################
+import logging
import os
import shutil
import subprocess32 as subprocess
from git import Repo
-import functest.utils.functest_logger as ft_logger
-
class Orchestrator(object):
self.input_file = 'inputs.yaml'
self.manager_blueprint = False
self.config = inputs
- self.logger = ft_logger.Logger("Orchestrator").getLogger()
+ self.logger = logging.getLogger(__name__)
self.manager_up = False
def set_credentials(self, username, password, tenant_name, auth_url):
+++ /dev/null
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-import logging
-import unittest
-
-import mock
-
-from functest.utils import functest_logger
-from functest.utils.constants import CONST
-
-
-class OSUtilsLogger(unittest.TestCase):
-
- logging.disable(logging.CRITICAL)
-
- def setUp(self):
- with mock.patch('__builtin__.open', mock.mock_open()):
- with mock.patch('functest.utils.functest_logger.os.path.exists',
- return_value=True), \
- mock.patch('functest.utils.functest_logger.'
- 'json.load'), \
- mock.patch('functest.utils.functest_logger.'
- 'logging.config.dictConfig') as m:
- self.logger = functest_logger.Logger('os_utils')
- self.assertTrue(m.called)
- with mock.patch('functest.utils.functest_logger.os.path.exists',
- return_value=False), \
- mock.patch('functest.utils.functest_logger.'
- 'logging.basicConfig') as m:
- self.logger = functest_logger.Logger('os_utils')
- self.assertTrue(m.called)
-
- def test_is_debug_false(self):
- CONST.CI_DEBUG = False
- self.assertFalse(self.logger.is_debug())
-
- def test_is_debug_true(self):
- CONST.CI_DEBUG = "True"
- self.assertTrue(self.logger.is_debug())
-
-
-if __name__ == "__main__":
- unittest.main(verbosity=2)
+++ /dev/null
-#!/usr/bin/env python
-#
-# jose.lausuch@ericsson.com
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Logging levels:
-# Level Numeric value
-# CRITICAL 50
-# ERROR 40
-# WARNING 30
-# INFO 20
-# DEBUG 10
-# NOTSET 0
-#
-# Usage:
-# import functest_logger as fl
-# logger = fl.Logger("script_name").getLogger()
-# logger.info("message to be shown with - INFO - ")
-# logger.debug("message to be shown with - DEBUG -")
-import logging
-import logging.config
-import os
-
-import json
-
-from functest.utils.constants import CONST
-
-ignore = ["paramiko",
- "stevedore.extension",
- "keystoneauth.session",
- "keystoneauth.identity.v3.base",
- "novaclient.v2.client",
- "neutronclient.v2_0.client",
- "glanceclient.common.http",
- "cinderclient.v2.client",
- "cinderclient.client"]
-
-
-class Logger(object):
-
- instance = None
-
- def __new__(cls, logger_name):
- if cls.instance is None:
- cls.instance = object.__new__(cls)
- return cls.instance
-
- def __init__(self, logger_name):
- self.setup_logging()
- self.logger = logging.getLogger(logger_name)
- for module_name in ignore:
- logging.getLogger(module_name).setLevel(logging.WARNING)
-
- def getLogger(self):
- return self.logger
-
- def is_debug(self):
- if CONST.CI_DEBUG and CONST.CI_DEBUG.lower() == "true":
- return True
- return False
-
- def setup_logging(self, default_path=CONST.dir_functest_logging_cfg,
- default_level=logging.INFO,
- env_key='LOG_CFG'):
- path = default_path
- value = os.getenv(env_key, None)
- if value:
- path = value
- if os.path.exists(path):
- with open(path, 'rt') as f:
- config = json.load(f)
- if (config['handlers'] and
- config['handlers']['console']):
- stream_level = logging.INFO
- if self.is_debug():
- stream_level = logging.DEBUG
- config['handlers']['console']['level'] = stream_level
- logging.config.dictConfig(config)
- else:
- logging.basicConfig(level=default_level)
#
import functools
import json
+import logging
import os
import re
import shutil
from git import Repo
from functest.utils import decorators
-import functest.utils.functest_logger as ft_logger
-logger = ft_logger.Logger("functest_utils").getLogger()
+logger = logging.getLogger(__name__)
# ----------------------------------------------------------
import time
+import logging
import yaml
-import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
from functest.utils.constants import CONST
-logger = ft_logger.Logger("openstack_clean").getLogger()
+logger = logging.getLogger(__name__)
OS_SNAPSHOT_FILE = CONST.openstack_snapshot_file
if __name__ == '__main__':
+ logging.basicConfig()
main()
# http://www.apache.org/licenses/LICENSE-2.0
#
+import logging
import yaml
-import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
from functest.utils.constants import CONST
-logger = ft_logger.Logger("openstack_snapshot").getLogger()
+logger = logging.getLogger(__name__)
OS_SNAPSHOT_FILE = CONST.openstack_snapshot_file
if __name__ == '__main__':
+ logging.basicConfig()
main()
# http://www.apache.org/licenses/LICENSE-2.0
##########################################################################
+import logging
from tackerclient.v1_0 import client as tackerclient
-import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
import time
-logger = ft_logger.Logger("tacker_utils").getLogger()
+logger = logging.getLogger(__name__)
def get_tacker_client(other_creds={}):
# http://www.apache.org/licenses/LICENSE-2.0
#
-import os
+import logging
import os.path
import re
import sys
from keystoneclient import client as keystoneclient
from neutronclient.neutron import client as neutronclient
-import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
-logger = ft_logger.Logger("openstack_utils").getLogger()
+logger = logging.getLogger(__name__)
DEFAULT_API_VERSION = '2'
DEFAULT_HEAT_API_VERSION = '1'
Code Review / functest.git / commitdiff