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 __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 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_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 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 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 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 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): 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 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