def factory(cls, vm_name, provider, template_name=None, template=False):
"""Factory class method that determines the correct subclass for given provider.
For reference how does that work, refer to the entrypoints in the setup.py
Args:
vm_name: Name of the VM/Instance as it appears in the UI
provider: The provider object (not the string!)
template_name: Source template name. Useful when the VM/Instance does not exist and you
want to create it.
template: Whether the generated object class should be VM/Instance or a template class.
"""
try:
return all_types(template)[provider.type](vm_name, provider,
template_name)
except KeyError:
# Matching via provider type failed. Maybe we have some generic classes for infra/cloud?
try:
return all_types(template)[provider.category](vm_name,
provider,
template_name)
except KeyError:
raise UnknownProviderType(
'Unknown type of provider CRUD object: {}'.format(
provider.__class__.__name__))
def factory(cls, vm_name, provider, template_name=None, template=False):
"""Factory class method that determines the correct subclass for given provider.
For reference how does that work, refer to :py:meth:`register_for_provider_type`
Args:
vm_name: Name of the VM/Instance as it appears in the UI
provider: The provider object (not the string!)
template_name: Source template name. Useful when the VM/Instance does not exist and you
want to create it.
template: Whether the generated object class should be VM/Instance or a template class.
"""
# Ensure the classes are loaded:
import cfme.cloud.instance # NOQA
import cfme.infrastructure.virtual_machines # NOQA
try:
return (
cls._registered_types[provider.type]["template" if template else "vm"]
(vm_name, provider, template_name))
except KeyError:
# Matching via provider type failed. Maybe we have some generic classes for infra/cloud?
try:
return (
cls._registered_types[provider.category]["template" if template else "vm"]
(vm_name, provider, template_name))
except KeyError:
raise UnknownProviderType(
'Unknown type of cloud provider CRUD object: {}'
.format(provider.__class__.__name__))
def instance_factory(vm_name, provider_crud, template_name=None):
if isinstance(provider_crud, OpenStackProvider):
instance = OpenStackInstance(vm_name, provider_crud, template_name)
elif isinstance(provider_crud, EC2Provider):
instance = EC2Instance(vm_name, provider_crud, template_name)
else:
raise UnknownProviderType(
'Unknown type of cloud provider CRUD object: {}'.format(
provider_crud.__class__.__name__))
return instance
def auth_class_from_type(auth_prov_type):
"""Using the registered auth provider classes, fetch a class by its type key
Args:
auth_prov_type: string key matching a registered type in entry_points
Raises:
UnknownProviderType when the given type isn't registered in entry_points
"""
try:
return auth_provider_types()[auth_prov_type]
except KeyError:
raise UnknownProviderType('Unknown auth provider type: {}'.format(auth_prov_type))
def get_class_from_type(prov_type):
try:
return all_types()[prov_type]
except KeyError:
raise UnknownProviderType(
"Unknown provider type: {}!".format(prov_type))
def get_crud(provider_config_name):
"""
Creates a Provider object given a yaml entry in cfme_data.
Usage:
get_crud('ec2east')
Returns: A Provider object that has methods that operate on CFME
"""
prov_config = conf.cfme_data.get('management_systems', {})[provider_config_name]
credentials_key = prov_config['credentials']
credentials = process_credential_yaml_key(credentials_key)
prov_type = prov_config.get('type')
if prov_type != 'ec2':
if prov_config.get('discovery_range', None):
start_ip = prov_config['discovery_range']['start']
end_ip = prov_config['discovery_range']['end']
else:
start_ip = end_ip = prov_config.get('ipaddress')
if prov_type == 'ec2':
from cfme.cloud.provider import EC2Provider
return EC2Provider(name=prov_config['name'],
region=prov_config['region'],
credentials={'default': credentials},
zone=prov_config['server_zone'],
key=provider_config_name)
if prov_type == 'gce':
from cfme.cloud.provider import GCEProvider
ser_acc_creds = get_credentials_from_config(
prov_config['credentials'], cred_type='service_account')
return GCEProvider(name=prov_config['name'],
project=prov_config['project'],
zone=prov_config['zone'],
region=prov_config['region'],
credentials={'default': ser_acc_creds},
key=provider_config_name)
elif prov_type == 'azure':
from cfme.cloud.provider import AzureProvider
return AzureProvider(name=prov_config['name'],
region=prov_config['region'],
tenant_id=prov_config['tenant_id'],
credentials={'default': credentials},
key=provider_config_name)
elif prov_type == 'openstack':
from cfme.cloud.provider import OpenStackProvider
if 'amqp_credentials' in prov_config:
amqp_credentials = process_credential_yaml_key(
prov_config['amqp_credentials'], cred_type='amqp')
return OpenStackProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
api_port=prov_config['port'],
credentials={
'default': credentials,
'amqp': amqp_credentials},
zone=prov_config['server_zone'],
key=provider_config_name,
sec_protocol=prov_config.get('sec_protocol', "Non-SSL"),
infra_provider=prov_config.get('infra_provider'))
elif prov_type == 'virtualcenter':
return VMwareProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
credentials={'default': credentials},
zone=prov_config['server_zone'],
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip)
elif prov_type == 'scvmm':
return SCVMMProvider(
name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
credentials={'default': credentials},
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip,
sec_protocol=prov_config['sec_protocol'],
sec_realm=prov_config['sec_realm'])
elif prov_type == 'rhevm':
credential_dict = {'default': credentials}
if prov_config.get('candu_credentials', None):
credential_dict['candu'] = process_credential_yaml_key(
prov_config['candu_credentials'], cred_type='candu')
return RHEVMProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
api_port='',
credentials=credential_dict,
zone=prov_config['server_zone'],
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip)
elif prov_type == "openstack-infra":
credential_dict = {'default': credentials}
if 'ssh_credentials' in prov_config:
credential_dict['ssh'] = process_credential_yaml_key(
prov_config['ssh_credentials'], cred_type='ssh')
if 'amqp_credentials' in prov_config:
credential_dict['amqp'] = process_credential_yaml_key(
prov_config['amqp_credentials'], cred_type='amqp')
return OpenstackInfraProvider(
name=prov_config['name'],
sec_protocol=prov_config.get('sec_protocol', "Non-SSL"),
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
credentials=credential_dict,
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip)
elif prov_type == 'kubernetes':
token_creds = process_credential_yaml_key(prov_config['credentials'], cred_type='token')
return KubernetesProvider(
name=prov_config['name'],
credentials={'token': token_creds},
key=provider_config_name,
zone=prov_config['server_zone'],
hostname=prov_config.get('hostname', None) or prov_config['ip_address'],
port=prov_config['port'],
provider_data=prov_config)
elif prov_type == 'openshift':
token_creds = process_credential_yaml_key(prov_config['credentials'], cred_type='token')
return OpenshiftProvider(
name=prov_config['name'],
credentials={'token': token_creds},
key=provider_config_name,
zone=prov_config['server_zone'],
hostname=prov_config.get('hostname', None) or prov_config['ip_address'],
port=prov_config['port'],
provider_data=prov_config)
elif prov_type == 'hawkular':
return HawkularProvider(
name=prov_config['name'],
key=provider_config_name,
hostname=prov_config['hostname'],
port=prov_config['port'],
credentials={'default': credentials})
else:
raise UnknownProviderType('{} is not a known provider type'.format(prov_type))
def get_crud(provider_config_name):
"""
Creates a Provider object given a yaml entry in cfme_data.
Usage:
get_crud('ec2east')
Returns: A Provider object that has methods that operate on CFME
"""
prov_config = conf.cfme_data.get('management_systems',
{})[provider_config_name]
credentials = get_credentials_from_config(prov_config['credentials'])
prov_type = prov_config.get('type')
if prov_type != 'ec2':
if prov_config.get('discovery_range', None):
start_ip = prov_config['discovery_range']['start']
end_ip = prov_config['discovery_range']['end']
else:
start_ip = end_ip = prov_config.get('ipaddress')
if prov_type == 'ec2':
return EC2Provider(name=prov_config['name'],
region=prov_config['region'],
credentials={'default': credentials},
zone=prov_config['server_zone'],
key=provider_config_name)
elif prov_type == 'openstack':
return OpenStackProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
api_port=prov_config['port'],
credentials={'default': credentials},
zone=prov_config['server_zone'],
key=provider_config_name)
elif prov_type == 'virtualcenter':
return VMwareProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
credentials={'default': credentials},
zone=prov_config['server_zone'],
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip)
elif prov_type == 'scvmm':
return SCVMMProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
credentials={'default': credentials},
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip,
sec_protocol=prov_config['sec_protocol'],
sec_realm=prov_config['sec_realm'])
elif prov_type == 'rhevm':
if prov_config.get('candu_credentials', None):
candu_credentials = get_credentials_from_config(
prov_config['candu_credentials'])
candu_credentials.candu = True
else:
candu_credentials = None
return RHEVMProvider(name=prov_config['name'],
hostname=prov_config['hostname'],
ip_address=prov_config['ipaddress'],
api_port='',
credentials={
'default': credentials,
'candu': candu_credentials
},
zone=prov_config['server_zone'],
key=provider_config_name,
start_ip=start_ip,
end_ip=end_ip)
else:
raise UnknownProviderType(
'{} is not a known infra provider type'.format(prov_type))
