def test_from_config_verify(self):
self._prepare_test_config()
sot = connection.from_config(cloud_name="insecure")
self.assertFalse(sot.session.verify)
sot = connection.from_config(cloud_name="cacert")
self.assertEqual(CONFIG_CACERT, sot.session.verify)
def test_from_config_verify(self):
self._prepare_test_config()
sot = connection.from_config(cloud_name="insecure")
self.assertFalse(sot.session.verify)
sot = connection.from_config(cloud_name="cacert")
self.assertEqual(CONFIG_CACERT, sot.session.verify)
def __init__(self, config_name):
opts = Opts(cloud_name=config_name)
cc = cloud_config.OpenStackConfig()
LOG.debug("defaults: %s", cc.defaults)
# clouds.yaml file should either be in the
# current directory or
# ~/.config/openstack directory or
# /etc/openstack directory.
cloud = cc.get_one_cloud(opts.cloud)
LOG.debug("cloud cfg: %s", cloud.config)
# Create a context for a connection to the cloud provider
self.conn = connection.from_config(cloud_config=cloud,
options=opts)
identity_api_version = cloud.config['identity_api_version']
if identity_api_version != '3':
LOG.error('Only Identity version 3 is supported.')
# We still need to use aodhclient until alarming APIs
# are added to openstackclient
self.aodh_conn = aodh_client.Client(
session=cloud.get_session_client('alarming'))
self.aodh_conn.alarm.url = '/alarms'
def get_connection(self):
"""Get an OpenStackSDK connection"""
conn = connection.from_config(cloud_name='default')
self.conn = conn
return conn
def hypervisors():
global HYPERVISORS
if HYPERVISORS:
return True
HYPERVISORS = connection.Connection.list_hypervisors(
connection.from_config(cloud_name=base.TEST_CLOUD_NAME))
return bool(HYPERVISORS)
def _get_sdk_connection(request):
"""Creates an SDK connection based on the request.
:param request: Django request object
:returns: SDK connection object
"""
# NOTE(mordred) Nothing says love like two inverted booleans
# The config setting is NO_VERIFY which is, in fact, insecure.
# get_one_cloud wants verify, so we pass 'not insecure' to verify.
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None)
# Pass interface to honor 'OPENSTACK_ENDPOINT_TYPE'
interface = getattr(settings, 'OPENSTACK_ENDPOINT_TYPE', 'publicURL')
# Pass load_yaml_config as this is a Django service with its own config
# and we don't want to accidentally pick up a clouds.yaml file. We want to
# use the settings we're passing in.
cloud_config = occ.OpenStackConfig(load_yaml_config=False).get_one_cloud(
verify=not insecure,
cacert=cacert,
interface=interface,
region_name=request.user.services_region,
auth_type='token',
auth=dict(project_id=request.user.project_id,
project_domain_id=request.user.domain_id,
token=request.user.token.unscoped_token,
auth_url=request.user.endpoint),
app_name='octavia-dashboard',
app_version=octavia_dashboard.__version__)
return connection.from_config(cloud_config=cloud_config)
def get_openstack_connection(region_name):
"""
Get the OpenStack Connection object.
This is the new, all-powerful Python API for OpenStack. It should be used
instead of the service-specific APIs such as the Nova API below.
The returned Connection object has an attribute for each available service,
e.g. "compute", "network", etc.
"""
loader = occ.OpenStackConfig(load_yaml_config=False,
app_name='opencraft-im',
app_version='1.0')
cloud_region = loader.get_one_cloud(
region_name=region_name,
auth_type='password',
auth=dict(
auth_url=settings.OPENSTACK_AUTH_URL,
username=settings.OPENSTACK_USER,
project_name=settings.OPENSTACK_TENANT,
password=settings.OPENSTACK_PASSWORD,
))
conn = connection.from_config(cloud_config=cloud_region)
conn.session.user_agent = "opencraft-im"
# API queries via the nova client occasionally get connection errors from the OpenStack provider.
# To gracefully recover when the unavailability is short-lived, ensure safe requests (as per
# urllib3's definition) are retried before giving up.
adapter = requests.adapters.HTTPAdapter(max_retries=get_requests_retry())
conn.session.session.mount('http://', adapter)
conn.session.session.mount('https://', adapter)
return conn
def hypervisors():
global HYPERVISORS
if HYPERVISORS:
return True
HYPERVISORS = connection.Connection.list_hypervisors(
connection.from_config(cloud_name=base.TEST_CLOUD_NAME))
return bool(HYPERVISORS)
def __init__(self, config_name):
opts = Opts(cloud_name=config_name)
cc = cloud_config.OpenStackConfig()
LOG.debug("defaults: %s", cc.defaults)
# clouds.yaml file should either be in the
# current directory or
# ~/.config/openstack directory or
# /etc/openstack directory.
cloud = cc.get_one_cloud(opts.cloud)
LOG.debug("cloud cfg: %s", cloud.config)
# Create a context for a connection to the cloud provider
self.conn = connection.from_config(cloud_config=cloud, options=opts)
identity_api_version = cloud.config['identity_api_version']
if identity_api_version != '3':
LOG.error('This version of OpenStack User Management Library '
'only supports Identity version 3.')
# We still need to use neutronclient until openstackclient
# is able to add interface router, and keystoneclient
# until openstackclient is able to grant roles to users
self.neutron_conn = neutron_client.Client(
session=cloud.get_session_client('network'))
self.keystone_conn = keystone_client.Client(
session=cloud.get_session_client('identity'))
def get_connection(self):
"""Get an OpenStackSDK connection"""
conn = connection.from_config(cloud_name='default')
self.conn = conn
return conn
def test_from_config_given_options(self):
version = "100"
class Opts(object):
compute_api_version = version
sot = connection.from_config(cloud="sample", options=Opts)
self.assertEqual(version, sot.compute.version)
def os_sdk():
import os_client_config
occ = os_client_config.OpenStackConfig(config_files=['../samples/0000-0000-0000-0000.os.yaml'])
cloud = occ.get_one_cloud('os')
from openstack import connection
conn = connection.from_config(cloud_config=cloud)
for server in conn.compute.servers():
print(server.instance_name)
return "GET /os/sdk"
def test_from_config_given_options(self):
version = "100"
class Opts(object):
compute_api_version = version
sot = connection.from_config(cloud="sample", options=Opts)
self.assertEqual(version, sot.compute.version)
def test_from_config_given_name(self):
self._prepare_test_config()
sot = connection.from_config(cloud_name="sample")
self.assertEqual(CONFIG_USERNAME, sot.authenticator._username)
self.assertEqual(CONFIG_PASSWORD, sot.authenticator._password)
self.assertEqual(CONFIG_AUTH_URL, sot.authenticator.auth_url)
self.assertEqual(CONFIG_PROJECT, sot.authenticator._project_name)
def CreateConnection():
"""
Create a connection to the Nectar Cloud using a clouds.yaml configuration file
clouds.yaml file can be stored in any of:
* Current Directory
* ~/.config/openstack
* /etc/openstack
or a user-defined location by using "export OS_CLIENT_CONFIG_FILE=/path/to/my/config/my-clouds.yaml"
"""
return connection.from_config(cloud_name='nectar')
def setUpClass(cls):
opts = cls.ImageOpts()
cls.conn = connection.from_config(opts)
cls.img = cls.conn.image.upload_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r'))
def setUpClass(cls):
opts = cls.ImageOpts()
cls.conn = connection.from_config(opts)
cls.img = cls.conn.image.upload_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r')
)
def make_sdk(options=None, **kwargs):
"""Simple wrapper for getting an OpenStack SDK Connection.
For completeness, provide a mechanism that matches make_client and
make_rest_client. The heavy lifting here is done in openstacksdk.
:rtype: :class:`~openstack.connection.Connection`
"""
from openstack import connection
cloud = get_config(options=options, **kwargs)
return connection.from_config(cloud_config=cloud, options=options)
def test_from_config_given_cloud_name(self):
sot = connection.from_config(cloud_name="sample-cloud")
self.assertEqual(CONFIG_USERNAME,
sot.config.config['auth']['username'])
self.assertEqual(CONFIG_PASSWORD,
sot.config.config['auth']['password'])
self.assertEqual(CONFIG_AUTH_URL,
sot.config.config['auth']['auth_url'])
self.assertEqual(CONFIG_PROJECT,
sot.config.config['auth']['project_name'])
def test_from_config_given_data(self):
self._prepare_test_config()
data = os_client_config.OpenStackConfig().get_one_cloud("sample")
sot = connection.from_config(cloud_config=data)
self.assertEqual(CONFIG_USERNAME, sot.authenticator._username)
self.assertEqual(CONFIG_PASSWORD, sot.authenticator._password)
self.assertEqual(CONFIG_AUTH_URL, sot.authenticator.auth_url)
self.assertEqual(CONFIG_PROJECT, sot.authenticator._project_name)
def test_from_config_given_cloud_name(self):
sot = connection.from_config(cloud_name="sample")
self.assertEqual(CONFIG_USERNAME,
sot.config.config['auth']['username'])
self.assertEqual(CONFIG_PASSWORD,
sot.config.config['auth']['password'])
self.assertEqual(CONFIG_AUTH_URL,
sot.config.config['auth']['auth_url'])
self.assertEqual(CONFIG_PROJECT,
sot.config.config['auth']['project_name'])
def make_connection(options=None, **kwargs):
"""Simple wrapper for getting an OpenStack SDK Connection.
For completeness, provide a mechanism that matches make_client and
make_rest_client. The heavy lifting here is done in openstacksdk.
:rtype: :class:`~openstack.connection.Connection`
"""
from openstack import connection
cloud = get_config(options=options, **kwargs)
return connection.from_config(cloud_config=cloud, options=options)
def test_from_config_given_cloud_config(self):
cloud_region = openstack.config.OpenStackConfig().get_one("sample")
sot = connection.from_config(cloud_config=cloud_region)
self.assertEqual(CONFIG_USERNAME,
sot.config.config['auth']['username'])
self.assertEqual(CONFIG_PASSWORD,
sot.config.config['auth']['password'])
self.assertEqual(CONFIG_AUTH_URL,
sot.config.config['auth']['auth_url'])
self.assertEqual(CONFIG_PROJECT,
sot.config.config['auth']['project_name'])
def test_from_config_given_name(self):
self._prepare_test_config()
sot = connection.from_config(cloud_name="sample")
self.assertEqual(CONFIG_USERNAME,
sot.authenticator._username)
self.assertEqual(CONFIG_PASSWORD,
sot.authenticator._password)
self.assertEqual(CONFIG_AUTH_URL,
sot.authenticator.auth_url)
self.assertEqual(CONFIG_PROJECT,
sot.authenticator._project_name)
def setUp(self):
super(TestImage, self).setUp()
opts = self.ImageOpts()
self.conn = connection.from_config(cloud_name=base.TEST_CLOUD,
options=opts)
self.img = self.conn.image.upload_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r'))
self.addCleanup(self.conn.image.delete_image, self.img)
def test_from_config_given_cloud_config(self):
cloud_region = openstack.config.OpenStackConfig().get_one("sample")
sot = connection.from_config(cloud_config=cloud_region)
self.assertEqual(CONFIG_USERNAME,
sot.config.config['auth']['username'])
self.assertEqual(CONFIG_PASSWORD,
sot.config.config['auth']['password'])
self.assertEqual(CONFIG_AUTH_URL,
sot.config.config['auth']['auth_url'])
self.assertEqual(CONFIG_PROJECT,
sot.config.config['auth']['project_name'])
def main():
parser = argparse.ArgumentParser(
description='Migrate a random instance from host x to host y.')
parser.add_argument(
'--dest',
dest='host_to_move_to',
default='capstone1',
help='hostname destination to move to (default: capstone1')
parser.add_argument('--source',
dest='host_to_move_from',
default='capstone0',
help='hostname source (default: capstone0')
args = parser.parse_args()
host_to_move_to = args.host_to_move_to
host_to_move_from = args.host_to_move_from
#create a connection object for the given cloud - devstack (found in clouds.yaml)
# so we're creating with user admin
conn = connection.from_config(cloud_name='devstack-admin')
nova = os_client_config.make_client('compute', cloud='devstack-admin')
# finding the server to move -----------------
server_to_move = None
for server in nova.servers.list():
# check that the hostname is the same
dd = server.to_dict()
if (dd['OS-EXT-SRV-ATTR:host'] == host_to_move_from):
server_to_move = server
break
# other variables ---------------------------
# flavor id. we're using "tiny" by default
fid = '1'
#image id (cirros): there's only one
iid = conn.compute.images().next().id
# destination host logic -------------------
if server_to_move == None:
print "There are no servers on " + host_to_move_from
sys.exit()
print("now migrating " + server_to_move.human_id + " to: " +
host_to_move_to)
print("that's id: " + str(server_to_move.id))
server_to_move.live_migrate(host=host_to_move_to, block_migration=True)
def setUp(self):
super(TestImage, self).setUp()
opts = self.ImageOpts()
self.conn = connection.from_config(
cloud_name=base.TEST_CLOUD_NAME, options=opts)
self.img = self.conn.image.upload_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r')
)
self.addCleanup(self.conn.image.delete_image, self.img)
def test_from_config_given_options(self):
self._prepare_test_config()
version = "100"
class Opts(object):
compute_api_version = version
sot = connection.from_config(cloud_name="sample", options=Opts)
pref = sot.session.profile.get_filter("compute")
# NOTE: Along the way, the `v` prefix gets added so we can build
# up URLs with it.
self.assertEqual("v" + version, pref.version)
def test_from_config_given_data(self):
self._prepare_test_config()
data = os_client_config.OpenStackConfig().get_one_cloud("sample")
sot = connection.from_config(cloud_config=data)
self.assertEqual(CONFIG_USERNAME,
sot.authenticator._username)
self.assertEqual(CONFIG_PASSWORD,
sot.authenticator._password)
self.assertEqual(CONFIG_AUTH_URL,
sot.authenticator.auth_url)
self.assertEqual(CONFIG_PROJECT,
sot.authenticator._project_name)
def test_from_config_given_options(self):
self._prepare_test_config()
version = "100"
class Opts(object):
compute_api_version = version
sot = connection.from_config(cloud_name="sample", options=Opts)
pref = sot.session.profile.get_filter("compute")
# NOTE: Along the way, the `v` prefix gets added so we can build
# up URLs with it.
self.assertEqual("v" + version, pref.version)
def setUp(self):
super(TestZone, self).setUp()
self.require_service('dns')
self.conn = connection.from_config(cloud_name=base.TEST_CLOUD_NAME)
# Note: zone deletion is not an immediate operation, so each time
# chose a new zone name for a test
# getUniqueString is not guaranteed to return unique string between
# different tests of the same class.
self.ZONE_NAME = 'example-{0}.org.'.format(random.randint(1, 100))
self.zone = self.conn.dns.create_zone(name=self.ZONE_NAME,
email='*****@*****.**',
type='PRIMARY',
ttl=7200,
description='example zone')
self.addCleanup(self.conn.dns.delete_zone, self.zone)
def setUp(self):
super(TestImage, self).setUp()
opts = self.ImageOpts()
self.conn = connection.from_config(cloud_name=base.TEST_CLOUD_NAME,
options=opts)
self.img = self.conn.image.create_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
# TODO(mordred): This is not doing what people think it is doing.
# This is EPICLY broken. However, rather than fixing it as it is,
# we need to just replace the image upload code with the stuff
# from shade. Figuring out mapping the crap-tastic arbitrary
# extra key-value pairs into Resource is going to be fun.
properties=dict(description="This is not an image"),
data=open('CONTRIBUTING.rst', 'r'))
self.addCleanup(self.conn.image.delete_image, self.img)
def setUp(self):
super(TestImage, self).setUp()
opts = self.ImageOpts()
self.conn = connection.from_config(
cloud_name=base.TEST_CLOUD_NAME, options=opts)
self.img = self.conn.image.upload_image(
name=TEST_IMAGE_NAME,
disk_format='raw',
container_format='bare',
# TODO(mordred): This is not doing what people think it is doing.
# This is EPICLY broken. However, rather than fixing it as it is,
# we need to just replace the image upload code with the stuff
# from shade. Figuring out mapping the crap-tastic arbitrary
# extra key-value pairs into Resource is going to be fun.
properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r')
)
self.addCleanup(self.conn.image.delete_image, self.img)
def service_exists(**kwargs):
"""Decorator function to check whether a service exists
Usage:
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestMeter(base.BaseFunctionalTest):
...
:param kwargs: The kwargs needed to filter an endpoint.
:returns: True if the service exists, otherwise False.
"""
try:
conn = connection.from_config(cloud_name=TEST_CLOUD)
conn.session.get_endpoint(**kwargs)
return True
except _exceptions.EndpointNotFound:
return False
def setUpClass(cls):
os.environ.setdefault(
'OS_CLOUD_EYE_ENDPOINT_OVERRIDE',
'https://ces.eu-de.otc.t-systems.com/V1.0/%(project_id)s')
os.environ.setdefault('OS_AUTO_SCALING_ENDPOINT_OVERRIDE',
('https://as.eu-de.otc.t-systems.com'
'/autoscaling-api/v1/%(project_id)s'))
os.environ.setdefault('OS_DNS_ENDPOINT_OVERRIDE',
'https://dns.eu-de.otc.t-systems.com')
os.environ.setdefault(
'OS_VOLUME_BACKUP_ENDPOINT_OVERRIDE',
'https://vbs.eu-de.otc.t-systems.com/v2/%(project_id)s')
os.environ.setdefault(
'OS_LOAD_BALANCER_ENDPOINT_OVERRIDE',
'https://elb.eu-de.otc.t-systems.com/v1.0/%(project_id)s')
os.environ.setdefault(
'OS_MAP_REDUCE_ENDPOINT_OVERRIDE',
'https://mrs.eu-de.otc.t-systems.com/v1.1/%(project_id)s')
cls.conn = connection.from_config(cloud_name=TEST_CLOUD)
def service_exists(**kwargs):
"""Decorator function to check whether a service exists
Usage:
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestMeter(base.BaseFunctionalTest):
...
:param kwargs: The kwargs needed to filter an endpoint.
:returns: True if the service exists, otherwise False.
"""
try:
conn = connection.from_config(cloud_name=TEST_CLOUD)
conn.session.get_endpoint(**kwargs)
return True
except _exceptions.EndpointNotFound:
return False
def setUp(self):
super(TestZone, self).setUp()
self.require_service('dns')
self.conn = connection.from_config(cloud_name=base.TEST_CLOUD_NAME)
# Note: zone deletion is not an immediate operation, so each time
# chose a new zone name for a test
# getUniqueString is not guaranteed to return unique string between
# different tests of the same class.
self.ZONE_NAME = 'example-{0}.org.'.format(random.randint(1, 100))
self.zone = self.conn.dns.create_zone(
name=self.ZONE_NAME,
email='*****@*****.**',
type='PRIMARY',
ttl=7200,
description='example zone'
)
self.addCleanup(self.conn.dns.delete_zone, self.zone)
def get_openstack_sdk_connection(
parser_or_options=None, load_envvars=False, load_yaml_config=False,
cloud_config=None, session=None,
**kwargs
):
if session is not None:
return os_connection.Connection(session=session, **kwargs)
if cloud_config is None:
# we could return
# `openstack.connect(load_envvars=load_envvars, load_yaml_config=load_yaml_config, **kwargs)` # noqa
# but by doing so magic things are lacking in the config and we have
# random failing methods on the instance. See comments in
# get_openstack_config_with_envvars for more information.
cloud_config = get_openstack_config(
parser_or_options=parser_or_options, load_envvars=load_envvars,
load_yaml_config=load_yaml_config,
**kwargs
)
if isinstance(parser_or_options, dict):
parser_or_options = utils.dict_to_options(parser_or_options)
return os_connection.from_config(
cloud_config=cloud_config, options=parser_or_options
)
def setUpClass(cls):
cls.conn = connection.from_config(cloud_name=TEST_CLOUD)
def create_connection_from_config():
return connection.from_config(cloud_config=cloud, options=opts)
def create_project(self, tenant_id):
conn = connection.from_config(cloud_config=self._cloud_config)
pass
def setUpClass(cls):
cls.conn = connection.from_config(cloud_name=TEST_CLOUD)
def setUpClass(cls):
opts = cls.Opts()
cls.conn = connection.from_config(opts)
def connectToCloud(cloudName):
occ = os_client_config.OpenStackConfig()
cloud = occ.get_one_cloud(cloudName)
return connection.from_config(cloud_config=cloud)
def setUpClass(cls):
cls.conn = connection.from_config(cloud_name=CLOUD_NAME)
def _hypervisors(self):
hypervisors = _OpenStackCloudMixin.list_hypervisors(
connection.from_config(cloud_name=TEST_CLOUD_NAME))
return hypervisors
def create_connection_from_args():
parser = argparse.ArgumentParser()
config = os_client_config.OpenStackConfig()
config.register_argparse_arguments(parser, sys.argv[1:])
args = parser.parse_args()
return connection.from_config(options=args)
def setUp(self):
super(BaseFunctionalTest, self).setUp()
self.conn = connection.from_config(cloud_name=TEST_CLOUD)
# 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.
import etcd
import re
from openstack import connection
from oslo_serialization import jsonutils
conn = connection.from_config()
etcd_client = etcd.Client(port=2379)
port_paths = set()
for port in conn.network.ports():
id = port.id
binding_host = port.binding_host_id
if binding_host is not None and binding_host != '':
if port.binding_vif_type == 'binding_failed':
print('WARN: binding failed on %s' % id)
continue
def test_from_config_verify(self):
sot = connection.from_config(cloud="insecure-cloud")
self.assertFalse(sot.session.verify)
sot = connection.from_config(cloud="cacert-cloud")
self.assertEqual(CONFIG_CACERT, sot.session.verify)
def make_connection(opts):
return connection.from_config(opts)
def create_connection_from_config():
opts = Opts(cloud_name=TEST_CLOUD)
occ = os_client_config.OpenStackConfig()
cloud = occ.get_one_cloud(opts.cloud)
return connection.from_config(cloud_config=cloud, options=opts)
def setUpClass(cls):
opts = cls.Opts()
cls.conn = connection.from_config(opts)
def create_connection_from_args():
parser = argparse.ArgumentParser()
config = os_client_config.OpenStackConfig()
config.register_argparse_arguments(parser, sys.argv[1:])
args = parser.parse_args()
return connection.from_config(options=args)
def create_connection_from_config():
opts = Opts(cloud_name=TEST_CLOUD)
occ = os_client_config.OpenStackConfig()
cloud = occ.get_one_cloud(opts.cloud)
return connection.from_config(cloud_config=cloud, options=opts)
def create_connection_from_config(name=None):
""" Creates a new open stack connection """
occ = config.OpenStackConfig()
cloud = occ.get_one_cloud(name)
return connection.from_config(cloud_config=cloud)
def test_from_config_insecure(self):
# Ensure that the "insecure=True" flag implies "verify=False"
sot = connection.from_config("insecure-cloud-alternative-format")
self.assertFalse(sot.session.verify)
def _load_connection_openstack(conn_name: str, args=None) -> Connection:
connection = from_config(cloud=conn_name, options=args)
if connection is None:
raise Exception(f"Unable to connect to ${conn_name}")
return connection
def connectToCloud(cloudName):
occ = os_client_config.OpenStackConfig()
cloud = occ.get_one_cloud(cloudName)
return connection.from_config(cloud_config=cloud)
