os-brick/tools/generate_connector_list.py
Lucian Petrut 9e8657dd6e Split connector list by platform
We'll keep separate lists of connectors for each of the supported
operating systems so that we don't end up trying to use unsupported
connectors.

Since Cinder is explicitly trying to use the iSCSI/FC connectors,
we'll have to include those as well, for now.

Change-Id: Ibec2b798e8c5c3457cebea12cfd2f5813e62fb9e
Closes-Bug: #1850109
2019-11-12 13:18:32 +02:00

205 lines
6.0 KiB
Python
Executable File

#! /usr/bin/env python
#
# 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.
"""Generate list of os-brick connectors"""
import argparse
import inspect
import json
import operator
import os
from pydoc import locate
import textwrap
from os_brick.initiator import connector
parser = argparse.ArgumentParser(prog="generate_connector_list")
parser.add_argument("--format", default='str', choices=['str', 'dict'],
help="Output format type")
# Keep backwards compatibilty with the gate-docs test
# The tests pass ['docs'] on the cmdln, but it's never been used.
parser.add_argument("output_list", default=None, nargs='?')
def _ensure_loaded(connector_list):
"""Loads everything in a given path.
This will make sure all classes have been loaded and therefore all
decorators have registered class.
:param start_path: The starting path to load.
"""
classes = []
for conn in connector_list:
try:
conn_class = locate(conn)
classes.append(conn_class)
except Exception:
pass
return classes
def get_connectors():
"""Get a list of all connectors."""
classes = _ensure_loaded(connector._get_connector_list())
return [DriverInfo(x) for x in classes]
class DriverInfo(object):
"""Information about Connector implementations."""
def __init__(self, cls):
self.cls = cls
self.desc = cls.__doc__
self.class_name = cls.__name__
self.class_fqn = '{}.{}'.format(inspect.getmodule(cls).__name__,
self.class_name)
self.platform = getattr(cls, 'platform', None)
self.os_type = getattr(cls, 'os_type', None)
def __str__(self):
return self.class_name
def __repr__(self):
return self.class_fqn
def __hash__(self):
return hash(self.class_fqn)
class Output(object):
def __init__(self, base_dir, output_list):
# At this point we don't care what was passed in, just a trigger
# to write this out to the doc tree for now
self.connector_file = None
if output_list:
self.connector_file = open(
'%s/doc/source/connectors.rst' % base_dir, 'w+')
self.connector_file.write('===================\n')
self.connector_file.write('Available Connectors\n')
self.connector_file.write('===================\n\n')
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
if self.connector_file:
self.connector_file.close()
def write(self, text):
if self.connector_file:
self.connector_file.write('%s\n' % text)
else:
print(text)
def format_description(desc, output):
desc = desc or '<None>'
lines = desc.rstrip('\n').split('\n')
output.write('* Description: %s' % lines[0])
output.write('')
output.write(textwrap.dedent('\n'.join(lines[1:])))
def format_options(connector_options, output):
if connector_options and len(connector_options) > 0:
output.write('* Driver Configuration Options:')
output.write('')
output.write('.. list-table:: **Driver configuration options**')
output.write(' :header-rows: 1')
output.write(' :widths: 14 30')
output.write('')
output.write(' * - Name = Default Value')
output.write(' - (Type) Description')
sorted_options = sorted(connector_options,
key=operator.attrgetter('name'))
for opt in sorted_options:
output.write(' * - %s = %s' %
(opt.name, opt.default))
output.write(' - (%s) %s' % (opt.type, opt.help))
output.write('')
def print_connectors(connectors, config_name, output, section_char='-'):
for conn in sorted(connectors, key=lambda x: x.class_name):
conn_name = conn.class_name
output.write(conn_name)
output.write(section_char * len(conn_name))
if conn.platform:
output.write('* Platform: %s' % conn.platform)
if conn.os_type:
output.write('* OS Type: %s' % conn.os_type)
output.write('* %s=%s' % (config_name, conn.class_fqn))
format_description(conn.desc, output)
output.write('')
output.write('')
def output_str(cinder_root, args):
with Output(cinder_root, args.output_list) as output:
output.write('Connectors')
output.write('==============')
connectors = get_connectors()
print_connectors(connectors, 'connector', output, '~')
def collect_connector_info(connector):
"""Build the dictionary that describes this connector."""
info = {'name': connector.class_name,
'fqn': connector.class_fqn,
'description': connector.desc,
'platform': connector.platform,
'os_type': connector.os_type,
}
return info
def output_dict():
"""Output the results as a JSON dict."""
connector_list = []
connectors = get_connectors()
for conn in connectors:
connector_list.append(collect_connector_info(conn))
print(json.dumps(connector_list))
def main():
tools_dir = os.path.dirname(os.path.abspath(__file__))
brick_root = os.path.dirname(tools_dir)
cur_dir = os.getcwd()
os.chdir(brick_root)
args = parser.parse_args()
try:
if args.format == 'str':
output_str(brick_root, args)
elif args.format == 'dict':
output_dict()
finally:
os.chdir(cur_dir)
if __name__ == '__main__':
main()