openstack/heat
Code Issues Proposed changes

Add console_scripts entry points for all heat services

Browse Source 
As a follow-up to Ibfd54e7b1bae700e4fb49a32e5bf7c00d1f104d9,
moving all the scripts from bin/ to setuptools entry points.

The devstack change is here: Iffb6d09bfef593d854b38e68200ae6039c4727e7

partial blueprint upgrade-tests

Change-Id: Ic8f5b8dc85098de752bbf673c4b15c06fdc4162a
This commit is contained in:
Sirushti Murugesan 2015-09-02 08:21:25 +05:30 committed by Rico Lin
parent c79bd02e28
commit 063f80ffdf
9 changed files with 360 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
bin/heat-api
View File

@ -1,73 +1,39 @@
#!/usr/bin/env python #!/usr/bin/env python
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License");
# not use this file except in compliance with the License. You may obtain # you may not use this file except in compliance with the License.
# a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS,
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# License for the specific language governing permissions and limitations # implied.
# under the License. # See the License for the specific language governing permissions and
# limitations under the License.
import warnings
warnings.warn("DEPRECATED: This script is deprecated. Please use the "
"system level heat binaries installed to start "
"any of the heat services.", DeprecationWarning)
""" """
Heat API Server. An OpenStack REST API to Heat. Heat API Server. An OpenStack REST API to Heat.
""" """
import eventlet
eventlet.monkey_patch(os=False)
import os import os
import sys import sys
# If ../heat/__init__.py exists, add ../ to Python search path, so that # If ../heat/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python... # it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir, os.pardir,
os.pardir)) os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')):
sys.path.insert(0, possible_topdir)
from oslo_config import cfg if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')):
import oslo_i18n as i18n sys.path.insert(0, POSSIBLE_TOPDIR)
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config from heat.cmd import api
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy() api.main()
LOG = logging.getLogger('heat.api')
if __name__ == '__main__':
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat', prog='heat-api',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api')
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api.bind_port
host = cfg.CONF.heat_api.bind_host
LOG.info(_LI('Starting Heat REST API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api', cfg.CONF.heat_api)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

76
bin/heat-api-cfn
View File

@ -1,16 +1,22 @@
#!/usr/bin/env python #!/usr/bin/env python
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License");
# not use this file except in compliance with the License. You may obtain # you may not use this file except in compliance with the License.
# a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS,
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# License for the specific language governing permissions and limitations # implied.
# under the License. # See the License for the specific language governing permissions and
# limitations under the License.
import warnings
warnings.warn("DEPRECATED: This script is deprecated. Please use the "
"system level heat binaries installed to start "
"any of the heat services.", DeprecationWarning)
""" """
Heat API Server. This implements an approximation of the Amazon Heat API Server. This implements an approximation of the Amazon
@ -18,60 +24,18 @@ CloudFormation API and translates it into a native representation. It then
calls the heat-engine via AMQP RPC to implement them. calls the heat-engine via AMQP RPC to implement them.
""" """
import eventlet
eventlet.monkey_patch(os=False)
import os import os
import sys import sys
# If ../heat/__init__.py exists, add ../ to Python search path, so that # If ../heat/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python... # it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir, os.pardir,
os.pardir)) os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')):
sys.path.insert(0, possible_topdir)
from oslo_config import cfg if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')):
import oslo_i18n as i18n sys.path.insert(0, POSSIBLE_TOPDIR)
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config from heat.cmd import api_cfn
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy() api_cfn.main()
LOG = logging.getLogger('heat.api.cfn')
if __name__ == '__main__':
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat',
prog='heat-api-cfn',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api-cfn')
logging.set_defaults()
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api_cfn.bind_port
host = cfg.CONF.heat_api_cfn.bind_host
LOG.info(_LI('Starting Heat API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api-cfn', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api-cfn', cfg.CONF.heat_api_cfn)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

77
bin/heat-api-cloudwatch
View File

@ -1,16 +1,22 @@
#!/usr/bin/env python #!/usr/bin/env python
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License");
# not use this file except in compliance with the License. You may obtain # you may not use this file except in compliance with the License.
# a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS,
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# License for the specific language governing permissions and limitations # implied.
# under the License. # See the License for the specific language governing permissions and
# limitations under the License.
import warnings
warnings.warn("DEPRECATED: This script is deprecated. Please use the "
"system level heat binaries installed to start "
"any of the heat services.", DeprecationWarning)
""" """
Heat API Server. This implements an approximation of the Amazon Heat API Server. This implements an approximation of the Amazon
@ -18,61 +24,18 @@ CloudWatch API and translates it into a native representation. It then
calls the heat-engine via AMQP RPC to implement them. calls the heat-engine via AMQP RPC to implement them.
""" """
import eventlet
eventlet.monkey_patch(os=False)
import os import os
import sys import sys
# If ../heat/__init__.py exists, add ../ to Python search path, so that # If ../heat/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python... # it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir, os.pardir,
os.pardir)) os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'heat', '__init__.py')):
sys.path.insert(0, possible_topdir)
from oslo_config import cfg if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')):
import oslo_i18n as i18n sys.path.insert(0, POSSIBLE_TOPDIR)
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config from heat.cmd import api_cloudwatch
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy() api_cloudwatch.main()
LOG = logging.getLogger('heat.api.cloudwatch')
if __name__ == '__main__':
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat',
prog='heat-api-cloudwatch',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api-cloudwatch')
logging.set_defaults()
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api_cloudwatch.bind_port
host = cfg.CONF.heat_api_cloudwatch.bind_host
LOG.info(_LI('Starting Heat CloudWatch API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api-cloudwatch', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api-cloudwatch',
cfg.CONF.heat_api_cloudwatch)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

77
bin/heat-engine
View File

@ -1,16 +1,22 @@
#!/usr/bin/env python #!/usr/bin/env python
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License");
# not use this file except in compliance with the License. You may obtain # you may not use this file except in compliance with the License.
# a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # distributed under the License is distributed on an "AS IS" BASIS,
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# License for the specific language governing permissions and limitations # implied.
# under the License. # See the License for the specific language governing permissions and
# limitations under the License.
import warnings
warnings.warn("DEPRECATED: This script is deprecated. Please use the "
"system level heat binaries installed to start "
"any of the heat services.", DeprecationWarning)
""" """
Heat Engine Server. This does the work of actually implementing the API Heat Engine Server. This does the work of actually implementing the API
@ -18,9 +24,6 @@ calls made by the user. Normal communications is done via the heat API
which then calls into this engine. which then calls into this engine.
""" """
import eventlet
eventlet.monkey_patch()
import os import os
import sys import sys
@ -29,54 +32,10 @@ import sys
POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]), POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir, os.pardir,
os.pardir)) os.pardir))
if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')): if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'heat', '__init__.py')):
sys.path.insert(0, POSSIBLE_TOPDIR) sys.path.insert(0, POSSIBLE_TOPDIR)
from oslo_config import cfg from heat.cmd import engine
import oslo_i18n as i18n
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import service
from heat.common import config engine.main()
from heat.common.i18n import _LC
from heat.common import messaging
from heat.common import profiler
from heat.engine import template
from heat.rpc import api as rpc_api
from heat import version
i18n.enable_lazy()
LOG = logging.getLogger('heat.engine')
if __name__ == '__main__':
logging.register_options(cfg.CONF)
cfg.CONF(project='heat', prog='heat-engine',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-engine')
logging.set_defaults()
messaging.setup()
config.startup_sanity_check()
mgr = None
try:
mgr = template._get_template_extension_manager()
except template.TemplatePluginNotRegistered as ex:
LOG.critical(_LC("%s"), ex)
if not mgr or not mgr.names():
sys.exit("ERROR: No template format plugins registered")
from heat.engine import service as engine # noqa
profiler.setup('heat-engine', cfg.CONF.host)
gmr.TextGuruMeditation.setup_autorun(version)
srv = engine.EngineService(cfg.CONF.host, rpc_api.ENGINE_TOPIC)
launcher = service.launch(cfg.CONF, srv,
workers=cfg.CONF.num_engine_workers)
if cfg.CONF.enable_cloud_watch_lite:
# We create the periodic tasks here, which mean they are created
# only in the parent process when num_engine_workers>1 is specified
srv.create_periodic_tasks()
launcher.wait()

65
heat/cmd/api.py Executable file
View File

@ -0,0 +1,65 @@
#!/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.
"""
Heat API Server. An OpenStack ReST API to Heat.
"""
import eventlet
eventlet.monkey_patch(os=False)
import sys
from oslo_config import cfg
import oslo_i18n as i18n
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy()
LOG = logging.getLogger('heat.api')
def main():
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat', prog='heat-api',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api')
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api.bind_port
host = cfg.CONF.heat_api.bind_host
LOG.info(_LI('Starting Heat REST API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api', cfg.CONF.heat_api)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

69
heat/cmd/api_cfn.py Executable file
View File

@ -0,0 +1,69 @@
#!/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.
"""
Heat API Server. This implements an approximation of the Amazon
CloudFormation API and translates it into a native representation. It then
calls the heat-engine via AMQP RPC to implement them.
"""
import eventlet
eventlet.monkey_patch(os=False)
import sys
from oslo_config import cfg
import oslo_i18n as i18n
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy()
LOG = logging.getLogger('heat.api.cfn')
def main():
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat',
prog='heat-api-cfn',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api-cfn')
logging.set_defaults()
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api_cfn.bind_port
host = cfg.CONF.heat_api_cfn.bind_host
LOG.info(_LI('Starting Heat API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api-cfn', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api-cfn', cfg.CONF.heat_api_cfn)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

70
heat/cmd/api_cloudwatch.py Executable file
View File

@ -0,0 +1,70 @@
#!/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.
"""
Heat API Server. This implements an approximation of the Amazon
CloudWatch API and translates it into a native representation. It then
calls the heat-engine via AMQP RPC to implement them.
"""
import eventlet
eventlet.monkey_patch(os=False)
import sys
from oslo_config import cfg
import oslo_i18n as i18n
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import systemd
import six
from heat.common import config
from heat.common.i18n import _LI
from heat.common import messaging
from heat.common import profiler
from heat.common import wsgi
from heat import version
i18n.enable_lazy()
LOG = logging.getLogger('heat.api.cloudwatch')
def main():
try:
logging.register_options(cfg.CONF)
cfg.CONF(project='heat',
prog='heat-api-cloudwatch',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-api-cloudwatch')
logging.set_defaults()
messaging.setup()
app = config.load_paste_app()
port = cfg.CONF.heat_api_cloudwatch.bind_port
host = cfg.CONF.heat_api_cloudwatch.bind_host
LOG.info(_LI('Starting Heat CloudWatch API on %(host)s:%(port)s'),
{'host': host, 'port': port})
profiler.setup('heat-api-cloudwatch', host)
gmr.TextGuruMeditation.setup_autorun(version)
server = wsgi.Server('heat-api-cloudwatch',
cfg.CONF.heat_api_cloudwatch)
server.start(app, default_port=port)
systemd.notify_once()
server.wait()
except RuntimeError as e:
msg = six.text_type(e)
sys.exit("ERROR: %s" % msg)

74
heat/cmd/engine.py Executable file
View File

@ -0,0 +1,74 @@
#!/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.
"""
Heat Engine Server. This does the work of actually implementing the API
calls made by the user. Normal communications is done via the heat API
which then calls into this engine.
"""
import eventlet
eventlet.monkey_patch()
import sys
from oslo_config import cfg
import oslo_i18n as i18n
from oslo_log import log as logging
from oslo_reports import guru_meditation_report as gmr
from oslo_service import service
from heat.common import config
from heat.common.i18n import _LC
from heat.common import messaging
from heat.common import profiler
from heat.engine import template
from heat.rpc import api as rpc_api
from heat import version
i18n.enable_lazy()
LOG = logging.getLogger('heat.engine')
def main():
logging.register_options(cfg.CONF)
cfg.CONF(project='heat', prog='heat-engine',
version=version.version_info.version_string())
logging.setup(cfg.CONF, 'heat-engine')
logging.set_defaults()
messaging.setup()
config.startup_sanity_check()
mgr = None
try:
mgr = template._get_template_extension_manager()
except template.TemplatePluginNotRegistered as ex:
LOG.critical(_LC("%s"), ex)
if not mgr or not mgr.names():
sys.exit("ERROR: No template format plugins registered")
from heat.engine import service as engine # noqa
profiler.setup('heat-engine', cfg.CONF.host)
gmr.TextGuruMeditation.setup_autorun(version)
srv = engine.EngineService(cfg.CONF.host, rpc_api.ENGINE_TOPIC)
launcher = service.launch(cfg.CONF, srv,
workers=cfg.CONF.num_engine_workers)
if cfg.CONF.enable_cloud_watch_lite:
# We create the periodic tasks here, which mean they are created
# only in the parent process when num_engine_workers>1 is specified
srv.create_periodic_tasks()
launcher.wait()

8
setup.cfg
View File

@ -21,16 +21,16 @@ classifier =
packages = packages =
heat heat
scripts = scripts =
bin/heat-api
bin/heat-api-cfn
bin/heat-api-cloudwatch
bin/heat-db-setup bin/heat-db-setup
bin/heat-engine
bin/heat-keystone-setup bin/heat-keystone-setup
bin/heat-keystone-setup-domain bin/heat-keystone-setup-domain
[entry_points] [entry_points]
console_scripts = console_scripts =
heat-api = heat.cmd.api:main
heat-api-cfn = heat.cmd.api_cfn:main
heat-api-cloudwatch = heat.cmd.api_cloudwatch:main
heat-engine = heat.cmd.engine:main
heat-manage = heat.cmd.manage:main heat-manage = heat.cmd.manage:main
oslo.config.opts = oslo.config.opts =