def generate_json(self):
report_obj = {}
report_obj['version'] = \
version.VersionInfo('dovetail').version_string()
report_obj['testsuite'] = self.runner.name
report_obj['dashboard'] = None
report_obj['build_tag'] = self.runner.build_tag
report_obj['upload_date'] =\
datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
report_obj['duration'] = self.runner.end - self.runner.start
report_obj['testcases_list'] = []
for testcase_name in self.runner.testcases:
testcase_runner = self.runner.get_testcase_runner(testcase_name)
testcase_inreport = {}
testcase_inreport['name'] = testcase_name
if not testcase_runner:
testcase_inreport['result'] = 'Undefined'
testcase_inreport['objective'] = ''
testcase_inreport['sub_testcase'] = []
report_obj['testcases_list'].append(testcase_inreport)
continue
testcase_inreport['result'] = testcase_runner.result.get(
'criteria')
testcase_inreport['objective'] = testcase_runner.conf.get(
'objective')
testcase_inreport['sub_testcase'] = []
report_obj['testcases_list'].append(testcase_inreport)
return report_obj
def __init__(self):
super(Main, self).__init__(
description='Tempest cli application',
version=version.VersionInfo('tempest').version_string(),
command_manager=commandmanager.CommandManager('tempest.cm'),
deferred_help=True,
)
def __init__(self):
super(ParserMainApp, self).__init__(
description='Dlux CLI to parse a file into a different format.',
version=vr.VersionInfo('dluxparser').version_string_with_vcs(),
command_manager=commandmanager.CommandManager('dluxparser.cm'),
deferred_help=True,
)
def __init__(self):
super(Main, self).__init__(
description="A Benchmarking and Performance Analysis Framework",
version=version.VersionInfo('pbench').version_string_with_vcs(),
command_manager=commandmanager.CommandManager('pbench.cm'),
deferred_help=True,
)
def __init__(self):
super(KanboardShell, self).__init__(
description='Kanboard Command Line Client',
version=app_version.VersionInfo('kanboard_cli').version_string(),
command_manager=commandmanager.CommandManager('kanboard.cli'),
deferred_help=True)
self.client = None
self.is_super_user = True
def __init__(self, **kwargs):
super(FuelBootstrap, self).__init__(
description='Command line Fuel bootstrap manager',
version=version.VersionInfo('fuel-bootstrap').version_string(),
command_manager=CommandManager('fuel_bootstrap',
convert_underscores=True),
**kwargs
)
def setup_logging():
logging.setup(CONF, 'kuryr-kubernetes')
logging.set_defaults(default_log_levels=logging.get_default_log_levels())
version_k8s = pbr_version.VersionInfo('kuryr-kubernetes').version_string()
LOG.info(_LI("Logging enabled!"))
LOG.info(_LI("%(prog)s version %(version)s"), {
'prog': sys.argv[0],
'version': version_k8s
})
def test_get_db_status_success_er_green(self, status_check_mock, er_mock):
expected_response = {'status': {
'availability': {
'database': True,
'elastic-recheck': {'Configured': {'elastic-search': 'green'}}
},
'version': version.VersionInfo(
'openstack_health').version_string_with_vcs()
}}
response = self.app.get('/status')
self.assertEqual(response.status_code, 200)
output = json.loads(response.data.decode('utf-8'))
self.assertEqual(output, expected_response)
def test_get_status_failure_er_not_installed(self, status_check_mock,
er_mock):
expected_response = {'status': {
'availability': {
'database': False,
'elastic-recheck': 'NotInstalled'
},
'version': version.VersionInfo(
'openstack_health').version_string_with_vcs()
}}
response = self.app.get('/status')
self.assertEqual(response.status_code, 500)
self.assertEqual(json.loads(response.data.decode('utf-8')),
expected_response)
def main():
"""Main cli entry point for distributing cli commands."""
args = docopt.docopt(__doc__,
options_first=True,
version=version.VersionInfo('ospt').release_string())
cmd_name = args.pop('<command>')
cmd_args = args.pop('<args>')
cmd_class = commands.CMD_DICT.get(cmd_name, None)
if cmd_class is None:
raise docopt.DocoptExit(
message="Not supported command: {}".format(cmd_name))
cmd_args = [cmd_name] + cmd_args
cmd = cmd_class(cmd_args, args)
return cmd.do()
def inject_common_paths():
"""Discover the path to the common/ directory provided by infrared core."""
def override_conf_path(common_path, envvar, specific_dir):
conf_path = os.environ.get(envvar, '')
additional_conf_path = os.path.join(common_path, specific_dir)
if conf_path:
full_conf_path = ':'.join([additional_conf_path, conf_path])
else:
full_conf_path = additional_conf_path
os.environ[envvar] = full_conf_path
version_info = version.VersionInfo('infrared')
common_path = pkg.resource_filename(version_info.package, 'common')
override_conf_path(common_path, 'ANSIBLE_ROLES_PATH', 'roles')
override_conf_path(common_path, 'ANSIBLE_FILTER_PLUGINS', 'filter_plugins')
override_conf_path(common_path, 'ANSIBLE_CALLBACK_PLUGINS',
'callback_plugins')
override_conf_path(common_path, 'ANSIBLE_LIBRARY', 'library')
def detect_from_metadata(package):
"""
Detect a package version number from the metadata.
If the version number cannot be detected, the function returns 0.
:param str package: package name
:returns str: the package version number.
"""
try:
try:
version_info = version.VersionInfo(package)
package_version = version_info.release_string()
except (ModuleNotFoundError, pkg_resources.DistributionNotFound):
distribution_info = pkg_resources.get_distribution(package)
package_version = distribution_info.version
except Exception:
package_version = 0
return package_version
def get_status():
is_db_available = _check_db_availability()
is_er_available = _check_er_availability()
status = {
'status': {
'availability': {
'database': is_db_available,
'elastic-recheck': is_er_available,
},
'version':
version.VersionInfo('openstack_health').version_string_with_vcs()
}
}
response = jsonify(status)
if not is_db_available:
response.status_code = 500
return response
def generate_json(cls, testcase_list, duration):
report_obj = {}
report_obj['version'] = \
version.VersionInfo('dovetail').version_string()
report_obj['build_tag'] = dt_cfg.dovetail_config['build_tag']
report_obj['upload_date'] =\
datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
report_obj['duration'] = duration
report_obj['testcases_list'] = []
if not testcase_list:
return report_obj
for testcase_name in testcase_list:
testcase = Testcase.get(testcase_name)
testcase_inreport = {}
testcase_inreport['name'] = testcase_name
if testcase is None:
testcase_inreport['result'] = 'Undefined'
testcase_inreport['objective'] = ''
testcase_inreport['sub_testcase'] = []
report_obj['testcases_list'].append(testcase_inreport)
continue
testcase_inreport['result'] = testcase.passed()
testcase_inreport['objective'] = testcase.objective()
testcase_inreport['sub_testcase'] = []
if testcase.sub_testcase() is not None:
for sub_test in testcase.sub_testcase():
testcase_inreport['sub_testcase'].append({
'name':
sub_test,
'result':
testcase.sub_testcase_passed(sub_test)
})
report_obj['testcases_list'].append(testcase_inreport)
cls.logger.debug(json.dumps(report_obj))
return report_obj
# 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 pbr import version as pbr_version
MONITORS_VENDOR = "OpenStack Foundation"
MONITORS_PRODUCT = "OpenStack Masakari Monitors"
MONITORS_PACKAGE = None # OS distro package version suffix
loaded = False
version_info = pbr_version.VersionInfo('masakari-monitors')
version_string = version_info.version_string
def _load_config():
# Don't load in global context, since we can't assume
# these modules are accessible when distutils uses
# this module
from six.moves import configparser
from oslo_config import cfg
from oslo_log import log as logging
global loaded, MONITORS_VENDOR, MONITORS_PRODUCT, MONITORS_PACKAGE
if loaded:
from pbr import version as pbr_version
loaded = False
version_info = pbr_version.VersionInfo('nezha')
version_string = version_info.version_string
help='Run id to use for the specified subunit stream, can only'
' be used if a single stream is provided'),
cfg.StrOpt('attr_regex', default='\[(.*)\]',
help='The regex to use to extract the comma separated list of '
'test attributes from the test_id'),
cfg.StrOpt('test_attr_prefix', short='p', default=None,
help='An optional prefix to identify global test attrs '
'and treat it as test metadata instead of test_run '
'metadata'),
cfg.StrOpt('run_at', default=None,
help="The optional datetime string for the run was started, "
"If one isn't provided the date and time of when "
"subunit2sql is called will be used")
]
_version_ = version.VersionInfo('subunit2sql').version_string()
def cli_opts():
for opt in SHELL_OPTS:
CONF.register_cli_opt(opt)
def list_opts():
"""Return a list of oslo.config options available.
The purpose of this is to allow tools like the Oslo sample config file
generator to discover the options exposed to users.
"""
return [('DEFAULT', copy.deepcopy(SHELL_OPTS))]
# Copyright 2014
# The Cloudscaling Group, 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.
from pbr import version
version_info = version.VersionInfo('python-watcherclient')
__version__ = version_info.version_string()
# Copyright 2011 OpenStack Foundation
#
# 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 pbr import version as pbr_version
SGSERVICE_VENDOR = "Huawei"
SGSERVICE_PRODUCT = "Huawei SGService"
SGSERVICE_PACKAGE = None # OS distro package version suffix
loaded = False
version_info = pbr_version.VersionInfo('sgservice')
version_string = version_info.version_string
# Copyright 2013: Mirantis 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.
from pbr import version as pbr_version
RALLY_VENDOR = "OpenStack Foundation"
RALLY_PRODUCT = "OpenStack Rally"
RALLY_PACKAGE = None # OS distro package version suffix
loaded = False
version_info = pbr_version.VersionInfo("rally")
def version_string():
return version_info.semantic_version().debian_string()
"""Define the top-level cli command."""
import os
import click
from pbr import version
import pkg_resources
from bids2datapackage.cli.base import AbstractCommand
from bids2datapackage import config
# Retrieve the project version from packaging.
try:
try:
version_info = version.VersionInfo('bids2datapackage')
__version__ = version_info.release_string()
except pkg_resources.DistributionNotFound:
distribution_info = pkg_resources.get_distribution('pip')
__version__ = distribution_info.version
except Exception:
__version__ = None
APP_NAME = 'bids2datapackage'
# pylint: disable=unused-argument
# The arguments are used via the `self.args` dict of the `AbstractCommand` class.
@click.group()
@click.version_option(version=__version__)
@click.option('--log-level',
'-l',
default='NOTSET',
def run(self):
log.info("[pbr] Extracting deb version")
name = self.distribution.get_name()
print(version.VersionInfo(name).semantic_version().debian_string())
:param username: A string containing the username to use.
:param password: A string containing the password to use.
:param host: A string containing host to connect.
:param fromurl: A boolean to determine if the WSDL should
be fetched from the `host`.
:returns: BigIP
"""
return pc.BIGIP(username=username,
password=password,
hostname=host,
fromurl=fromurl,
wsdls=self.WSDL_LIST)
if __name__ == '__main__':
version = 'Load Balancer {0}'.format(version.VersionInfo('bigpyp'))
args = docopt(__doc__, version=version)
f = '../conf/{0}_vips.yml'.format(args['<name>'])
with open(f, 'r') as file:
vips_dict = yaml.load(file)
b = BigIP(host='192.168.112.62', password=os.environ['PASS'])
cert.Cert(b, vips_dict).create()
profile.Profile(b, vips_dict).create()
system.System(b).create()
rule.Rule(b).create()
monitor.Monitor(b).create()
pool.Pool(b, vips_dict).create()
virtual_server.VirtualServer(b, vips_dict).create()
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2011 OpenStack Foundation
#
# 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 pbr import version as pbr_version
CINDER_VENDOR = "OpenStack Foundation"
CINDER_PRODUCT = "OpenStack Cinder"
CINDER_PACKAGE = None # OS distro package version suffix
loaded = False
version_info = pbr_version.VersionInfo('cinder')
version_string = version_info.version_string
# Copyright 2011 OpenStack Foundation
#
# 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 pbr import version as pbr_version
SDS_VENDOR = "OpenStack Foundation"
SDS_PRODUCT = "OpenStack Sds"
SDS_PACKAGE = None # OS distro package version suffix
loaded = False
version_info = pbr_version.VersionInfo('sds')
version_string = version_info.version_string
help='project name of the coverage files'),
cfg.StrOpt('coverage_file',
positional=True,
help='A coverage file to put into the database'),
cfg.StrOpt('test-type',
default='py27',
help='test_type like a task name of tox e.g. py27'),
]
DATABASE_OPTS = [
cfg.StrOpt('connection', default=None),
cfg.IntOpt('max_pool_size', default=20),
cfg.IntOpt('idle_timeout', default=3600),
]
_version_ = version.VersionInfo('coverage2sql').version_string()
def cli_opts():
CONF.register_cli_opts(SHELL_OPTS)
CONF.register_cli_opts(DATABASE_OPTS, 'database')
def list_opts():
"""Return a list of oslo.config options available.
The purpose of this is to allow tools like the Oslo sample config file
generator to discover the options exposed to users.
"""
return [('DEFAULT', copy.deepcopy(SHELL_OPTS))]
# Copyright (c) 2014 Mirantis 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.
from pbr import version
version_info = version.VersionInfo('driverlog')
# Holds the default variables
from pbr import version as pbr_version
import platform
import os
_v = pbr_version.VersionInfo("infrared").semantic_version()
__version__ = _v.release_string()
version_info = _v.version_tuple()
def version_details():
from infrared import __version__ # noqa
from ansible import __version__ as ansible_version # noqa
python_version = platform.python_version()
python_revision = ', '.join(platform.python_build())
return "{__version__} (" \
"ansible-{ansible_version}, " \
"python-{python_version})".format(**locals())
__all__ = (
'__version__', # string, standard across most modules
'version_info', # version tuple, same format as python sys.version_info
'version_details' # detailed version information, which may include major deps or plugins, used for bug reporting
)
SHARED_GROUPS = [
{
'title': 'Debug Options',
'options': {
'debug': {
'action': 'store_true',
# Copyright (c) 2017 Intel, 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.
from pbr import version
version_info = version.VersionInfo('valence')
# -*- coding: utf-8 -*-
# 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 pbr import version
version_info = version.VersionInfo('bork_api')
version_string = version_info.cached_version_string()
