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.
"""
profile = Profile()
profile.set_region(Profile.ALL, region_name)
connection = Connection(
profile=profile,
user_agent='opencraft-im',
auth_url=settings.OPENSTACK_AUTH_URL,
project_name=settings.OPENSTACK_TENANT,
username=settings.OPENSTACK_USER,
password=settings.OPENSTACK_PASSWORD,
)
# 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())
connection.session.session.mount('http://', adapter)
connection.session.session.mount('https://', adapter)
return connection
def read_input_inventory(self):
auth_url = os.environ.get('OS_AUTH_URL')
os_username = os.environ.get('OS_USERNAME')
os_project_name = os.environ.get('OS_PROJECT_NAME',
os.environ.get('OS_TENANT_NAME'))
os_password = os.environ.get('OS_PASSWORD')
os_auth_token = os.environ.get('OS_AUTH_TOKEN')
os_cacert = os.environ.get('OS_CACERT')
ansible_ssh_user = os.environ.get('ANSIBLE_SSH_USER', 'heat-admin')
self.osc_conn = Connection()
self.undercloud_stack = next(self.osc_conn.orchestration.stacks())
self.plan_name = (os.environ.get('TRIPLEO_PLAN_NAME')
or os.environ.get('STACK_NAME_NAME')
or self.get_tripleo_plan_name())
session = get_auth_session(auth_url, os_username, os_project_name,
os_password, os_auth_token, os_cacert)
heat_api_version = (
self.osc_conn.orchestration.get_api_major_version()[0])
self.hclient = heat_client.Client(heat_api_version, session=session)
inventory = TripleoInventory(session=session,
hclient=self.hclient,
auth_url=auth_url,
cacert=os_cacert,
project_name=os_project_name,
username=os_username,
ansible_ssh_user=ansible_ssh_user,
plan_name=self.plan_name)
return inventory.list()
def create_client():
return Client(Connection(
auth_url=config.openstack_auth_url,
domain_name=config.openstack_domain_name,
username=config.openstack_admin_username,
password=config.openstack_admin_password,
project_name=config.openstack_project_name,
))
def make_client(instance):
"""Returns a instance_ha proxy"""
LOG.debug('Instantiating masakari service client')
con = Connection(session=instance.session,
interface=instance.interface,
region_name=instance.region_name,
ha_api_version=instance._api_version[API_NAME])
return con.instance_ha
def os_connect():
prof = Profile()
prof.set_region(Profile.ALL, settings.OS_REGION_NAME)
return Connection(profile=prof,
user_agent='cloudvcl',
auth_url=settings.OS_AUTH_URL,
project_name=settings.OS_PROJECT_NAME,
username=settings.OS_USERNAME,
password=settings.OS_PASSWORD,
user_domain_name='default',
project_domain_name='default')
def __init__(self):
self.ansible = AnsibleModule(
swift_full_argument_spec(**self.argument_spec),
**self.module_kwargs)
self.params = self.ansible.params
self.module_name = self.ansible._name
self.results = {'changed': False}
self.exit = self.exit_json = self.ansible.exit_json
self.fail = self.fail_json = self.ansible.fail_json
self.cloud = OpenStackConfig().get_one()
self.client = Connection(config=self.cloud).object_store
def generate_env_specific_variables(self):
endpointmap_resource = self.hclient.resources.get(
self.plan_name, 'EndpointMap')
endpointmap_resource_dict = endpointmap_resource.to_dict(
)['attributes']['endpoint_map']
self.internal_lb_vip = endpointmap_resource_dict['KeystoneInternal'][
'host']
self.external_lb_vip = endpointmap_resource_dict['KeystonePublic'][
'host']
stack_env_dict = self.osc_conn.orchestration.get_stack_environment(
self.plan_name).to_dict()['parameter_defaults']
# get galera root password
self.galera_password = stack_env_dict['MysqlRootPassword']
# load overcloud env and osc
self.load_rc_file(stack_name=self.plan_name)
tmp_osc_conn = Connection()
# get cinder_backend_volume fact
self.cinder_backend_fact = {}
for cinder_backend_pool in tmp_osc_conn.volume.backend_pools():
backend_host = cinder_backend_pool.name.split('#')[0]
# (NOTE:tonytan4ever): skip transient legacy backends
if 'legacy' in backend_host:
continue
cinder_backend_pool_dict = cinder_backend_pool.to_dict(
)['capabilities']
if 'solidfire' in cinder_backend_pool_dict['volume_backend_name']:
self.cinder_backend_fact['solidfire'] = {
'volume_driver': 'abc',
'host': backend_host
}
if 'netapp' in cinder_backend_pool_dict['volume_backend_name']:
self.cinder_backend_fact['netapp'] = {
'volume_driver': 'abc',
'host': backend_host
}
if 'ceph' in cinder_backend_pool_dict['volume_backend_name']:
self.cinder_backend_fact['ceph'] = {
'volume_driver': 'abc',
'host': backend_host
}
# reset to undercloud rc for osc
self.load_rc_file()
cloud = 'default'
# (NOTE:tonytan4ever): for OSP cloud, cloud parameter needs to be None
if os.getenv('OS_CLOUDNAME') is not None:
cloud = None
if os.path.exists(OPENRC) or os.path.exists(STACKRC):
try:
OSC_CONFIG = get_cloud_region(cloud=cloud)
except ConfigException as e:
# (NOTE:tonytan4ever) Liberty cloud does not have 'default' config
if 'Cloud default was not found' in str(e):
OSC_CONFIG = get_cloud_region(cloud=None)
else:
raise e
OSC_CLIENT = Connection(config=OSC_CONFIG, verify=False)
def get_os_component_major_api_version(component_name):
supported_os_component_osc_mapping = {
'nova': 'compute',
'neutron': 'network',
'cinder': 'volume',
'glance': 'image',
'keystone': 'identity',
'ironic': 'baremetal_introspection',
'heat': 'orchestration',
'swfit': 'object_store'
}
if component_name not in supported_os_component_osc_mapping.keys():
raise NameError("Not a supported OpenStack component name: %s,"