def initialize_cloud(cloud_name):
"""Initialize cloud object.
Cloud configs are read with os-client-config.
:param cloud_name: the cloud name
"""
if not cloud_name:
return shade.openstack_cloud()
else:
return shade.openstack_cloud(cloud=cloud_name)
def setUp(self):
super(TestImage, self).setUp()
self.cloud = shade.openstack_cloud(validate=False)
self.image_id = str(uuid.uuid4())
self.fake_search_return = [{
u'image_state': u'available',
u'container_format': u'bare',
u'min_ram': 0,
u'ramdisk_id': None,
u'updated_at': u'2016-02-10T05:05:02Z',
u'file': '/v2/images/' + self.image_id + '/file',
u'size': 3402170368,
u'image_type': u'snapshot',
u'disk_format': u'qcow2',
u'id': self.image_id,
u'schema': u'/v2/schemas/image',
u'status': u'active',
u'tags': [],
u'visibility': u'private',
u'locations': [{
u'url': u'http://127.0.0.1/images/' + self.image_id,
u'metadata': {}}],
u'min_disk': 40,
u'virtual_size': None,
u'name': u'fake_image',
u'checksum': u'ee36e35a297980dee1b514de9803ec6d',
u'created_at': u'2016-02-10T05:03:11Z',
u'protected': False}]
self.output = six.BytesIO()
self.output.write(uuid.uuid4().bytes)
self.output.seek(0)
def _get_cloud(cloud, region, project=None):
if project:
domain_id = project.domain_id
domain_name = project.domain_name
project_id = project.id
project_name = project.name
kwargs = dict(
project_domain_id=domain_id,
project_domain_name=domain_name,
project_id=project_id,
project_name=project_name,
)
else:
domain_id = domain_name = project_id = project_name = None
kwargs = {}
key = _make_cloud_key(
cloud, region,
domain_id or domain_name,
project_id or project_name
)
if key not in all_clouds:
all_clouds[key] = shade.openstack_cloud(
cloud=cloud, region_name=region,
debug=True, strict=True, **kwargs)
return all_clouds[key]
def main():
argument_spec = openstack_full_argument_spec(
display_name=dict(required=True, aliases=['name']),
display_description=dict(default=None, aliases=['description']),
volume=dict(required=True),
force=dict(required=False, default=False, type='bool'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
try:
cloud = shade.openstack_cloud(**module.params)
if cloud.volume_exists(module.params['volume']):
if module.check_mode:
module.exit_json(changed=_system_state_change(module, cloud))
if state == 'present':
_present_volume_snapshot(module, cloud)
if state == 'absent':
_absent_volume_snapshot(module, cloud)
else:
module.fail_json(
msg="No volume with name or id '{0}' was found.".format(
module.params['volume']))
except (shade.OpenStackCloudException, shade.OpenStackCloudTimeout) as e:
module.fail_json(msg=e.message)
def main():
''' Main module function '''
module = AnsibleModule(
argument_spec=dict(
trunk_name=dict(default=False, type='str'),
),
supports_check_mode=True,
)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
try:
cloud = shade.openstack_cloud()
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to connect to the cloud')
try:
adapter = keystoneauth1.adapter.Adapter(
session=cloud.keystone_session,
service_type=cloud.cloud_config.get_service_type('network'),
interface=cloud.cloud_config.get_interface('network'),
endpoint_override=cloud.cloud_config.get_endpoint('network'),
version=cloud.cloud_config.get_api_version('network'))
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to get an adapter to talk to the Neutron '
'API')
try:
trunk_response = adapter.get('/trunks')
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to retrieve Neutron trunk information')
subports = []
for trunk in trunk_response.json()['trunks']:
if trunk['name'] == module.params['trunk_name']:
trunk_id = trunk['id']
for subport in trunk['sub_ports']:
subports.append(subport['port_id'])
data = _get_data(subports)
try:
adapter.put('/trunks/' + trunk_id + '/remove_subports',
**data)
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to detach subports')
try:
for port in subports:
adapter.delete('/ports/' + port)
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to delete Neutron subports')
module.exit_json(
changed=True)
def main():
argument_spec = openstack_full_argument_spec(
security_group=dict(required=False),
filters=dict(required=False, type='dict', default=None),
)
# module_kwargs = openstack_module_kwargs()
# module = AnsibleModule(argument_spec, **module_kwargs)
module = AnsibleModule(argument_spec)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
# security_group =module.params.pop('security_group')
# filters = module.params.pop('filters')
try:
cloud = shade.openstack_cloud(**module.params)
openstack_security_groups = cloud.list_security_groups()
module.exit_json(changed=False, ansible_facts=dict(
openstack_security_groups=openstack_security_groups))
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def main():
argument_spec = openstack_full_argument_spec(
size=dict(default=None),
volume_type=dict(default=None),
display_name=dict(required=True, aliases=['name']),
display_description=dict(default=None, aliases=['description']),
image=dict(default=None),
snapshot_id=dict(default=None),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs(
mutually_exclusive=[
['image', 'snapshot_id'],
],
)
module = AnsibleModule(argument_spec=argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
if state == 'present' and not module.params['size']:
module.fail_json(msg="Size is required when state is 'present'")
try:
cloud = shade.openstack_cloud(**module.params)
if state == 'present':
_present_volume(module, cloud)
if state == 'absent':
_absent_volume(module, cloud)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def __init__(self, molecule):
super(OpenstackDriver, self).__init__(molecule)
self._provider = self._get_provider()
self._platform = self._get_platform()
self._openstack = shade.openstack_cloud()
self._keypair_name = self.get_keypair_name()
self._molecule_generated_ssh_key = False
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-r', '--max_routers', type=int, default=100)
args = parser.parse_args()
agent_status = STATE_OK
search_opts = {
'all_tenants': True,
}
cloud = shade.openstack_cloud()
neutron = cloud.neutron_client
router_list = neutron.list_routers()
if len(router_list['routers']) > args.max_routers:
print("WARNING: Number of routers more than the max: %d"
% args.max_routers)
sys.exit(STATE_WARNING)
for router in router_list['routers']:
search_opts['router'] = router['id']
router_agents = neutron.list_l3_agent_hosting_routers(**search_opts)
agent_status = check_router(router, router_agents)
if agent_status == STATE_CRITICAL:
sys.exit(STATE_CRITICAL)
elif agent_status == STATE_WARNING:
sys.exit(STATE_WARNING)
if agent_status == STATE_OK:
print("OK: No routers with multiple active or all inactive l3 agents")
sys.exit(STATE_OK)
def setUp(self):
super(TestNetwork, self).setUp()
self.cloud = openstack_cloud(cloud='devstack-admin')
if not self.cloud.has_service('network'):
self.skipTest('Network service not supported by cloud')
self.network_name = self.getUniqueString('network')
self.addCleanup(self._cleanup_networks)
def main():
argument_spec = openstack_full_argument_spec(
server=dict(required=False),
detailed=dict(required=False, type='bool'),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
try:
cloud = shade.openstack_cloud(**module.params)
openstack_servers = cloud.list_servers(
detailed=module.params['detailed'])
if module.params['server']:
# filter servers by name
pattern = module.params['server']
openstack_servers = [server for server in openstack_servers
if fnmatch.fnmatch(server['name'], pattern)]
module.exit_json(changed=False, ansible_facts=dict(
openstack_servers=openstack_servers))
except shade.OpenStackCloudException as e:
module.fail_json(msg=e.message)
def _getClient(self):
kwargs = {}
if self.provider.region_name:
kwargs['region_name'] = self.provider.region_name
if self.provider.api_timeout:
kwargs['api_timeout'] = self.provider.api_timeout
# These are named from back when we only talked to Nova. They're
# actually compute service related
if self.provider.service_type:
kwargs['compute_service_type'] = self.provider.service_type
if self.provider.service_name:
kwargs['compute_service_name'] = self.provider.service_name
if self.provider.cloud is not None:
kwargs['cloud'] = self.provider.cloud
auth_kwargs = {}
for auth_attr in ('username', 'password', 'auth_url'):
auth_val = getattr(self.provider, auth_attr)
if auth_val is not None:
auth_kwargs[auth_attr] = auth_val
if self.provider.project_id is not None:
auth_kwargs['project_name'] = self.provider.project_id
kwargs['auth'] = auth_kwargs
return shade.openstack_cloud(**kwargs)
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
description=dict(required=False, default=None),
domain_id=dict(required=False, default=None, aliases=['domain']),
enabled=dict(default=True, type='bool'),
state=dict(default='present', choices=['absent', 'present'])
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(
argument_spec,
supports_check_mode=True,
**module_kwargs
)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
name = module.params['name']
description = module.params['description']
domain = module.params['domain_id']
enabled = module.params['enabled']
state = module.params['state']
try:
cloud = shade.openstack_cloud(**module.params)
project = cloud.get_project(name)
if module.check_mode:
module.exit_json(changed=_system_state_change(module, project))
if state == 'present':
if project is None:
project = cloud.create_project(
name=name, description=description,
domain_id=domain,
enabled=enabled)
changed = True
else:
if _needs_update(module, project):
project = cloud.update_project(
project['id'], description=description,
enabled=enabled)
changed = True
else:
changed = False
module.exit_json(changed=changed, project=project)
elif state == 'absent':
if project is None:
changed=False
else:
cloud.delete_project(project['id'])
changed=True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=e.message, extra_data=e.extra_data)
def main():
''' Main module function '''
module = AnsibleModule(argument_spec={}, supports_check_mode=True)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
try:
cloud = shade.openstack_cloud()
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to connect to the cloud')
try:
service_catalog = cloud.cloud_config.get_service_catalog()
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to retrieve the service catalog')
try:
endpoints = service_catalog.get_endpoints()
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to retrieve the service catalog '
'endpoints')
module.exit_json(
changed=False,
ansible_facts={'openstack_service_catalog': endpoints})
def main():
argument_spec = openstack_full_argument_spec(
server=dict(required=True),
state=dict(default='present', choices=['absent', 'present']),
network=dict(required=False, default=None),
floating_ip_address=dict(required=False, default=None),
reuse=dict(required=False, type='bool', default=False),
fixed_address=dict(required=False, default=None),
wait=dict(required=False, type='bool', default=False),
timeout=dict(required=False, type='int', default=60),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
server_name_or_id = module.params['server']
state = module.params['state']
network = module.params['network']
floating_ip_address = module.params['floating_ip_address']
reuse = module.params['reuse']
fixed_address = module.params['fixed_address']
wait = module.params['wait']
timeout = module.params['timeout']
cloud = shade.openstack_cloud(**module.params)
try:
server = cloud.get_server(server_name_or_id)
if server is None:
module.fail_json(
msg="server {0} not found".format(server_name_or_id))
if state == 'present':
server = cloud.add_ips_to_server(
server=server, ips=floating_ip_address, ip_pool=network,
reuse=reuse, fixed_address=fixed_address, wait=wait,
timeout=timeout)
fip_address = cloud.get_server_public_ip(server)
# Update the floating IP status
f_ip = _get_floating_ip(cloud, fip_address)
module.exit_json(changed=True, floating_ip=f_ip)
elif state == 'absent':
if floating_ip_address is None:
module.fail_json(msg="floating_ip_address is required")
f_ip = _get_floating_ip(cloud, floating_ip_address)
cloud.detach_ip_from_server(
server_id=server['id'], floating_ip_id=f_ip['id'])
# Update the floating IP status
f_ip = cloud.get_floating_ip(id=f_ip['id'])
module.exit_json(changed=True, floating_ip=f_ip)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
def main():
argument_spec = openstack_full_argument_spec(
name = dict(required=True),
public_key = dict(default=None),
public_key_file = dict(default=None),
state = dict(default='present',
choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs(
mutually_exclusive=[['public_key', 'public_key_file']])
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
name = module.params['name']
public_key = module.params['public_key']
if module.params['public_key_file']:
public_key = open(module.params['public_key_file']).read()
public_key = public_key.rstrip()
try:
cloud = shade.openstack_cloud(**module.params)
keypair = cloud.get_keypair(name)
if module.check_mode:
module.exit_json(changed=_system_state_change(module, keypair))
if state == 'present':
if keypair and keypair['name'] == name:
if public_key and (public_key != keypair['public_key']):
module.fail_json(
msg="Key name %s present but key hash not the same"
" as offered. Delete key first." % name
)
else:
changed = False
else:
keypair = cloud.create_keypair(name, public_key)
changed = True
module.exit_json(changed=changed,
key=keypair,
id=keypair['id'])
elif state == 'absent':
if keypair:
cloud.delete_keypair(name)
module.exit_json(changed=True)
module.exit_json(changed=False)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def setUp(self):
super(TestNetwork, self).setUp()
self.cloud = openstack_cloud(cloud='devstack-admin')
if not self.cloud.has_service('network'):
self.skipTest('Network service not supported by cloud')
self.network_prefix = 'test_network' + ''.join(
random.choice(string.ascii_lowercase) for _ in range(5))
self.addCleanup(self._cleanup_networks)
def get_cloud(self):
""" Get shade openstack and operator cloud objects
:return: cloud, opcloud are the shade openstack and operator objects
"""
cloud = shade.openstack_cloud()
opcloud = shade.operator_cloud()
return cloud, opcloud
def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
accessIPv4=PUBLIC_V4))
ip = meta.get_server_external_ipv4(
cloud=shade.openstack_cloud(validate=False), server=srv)
self.assertEqual(PUBLIC_V4, ip)
def build_inventory():
'''Build the dynamic inventory.'''
cloud = shade.openstack_cloud()
# TODO(shadower): filter the servers based on the `OPENSHIFT_CLUSTER`
# environment variable.
cluster_hosts = [
server for server in cloud.list_servers()
if 'metadata' in server and 'clusterid' in server.metadata]
inventory = base_openshift_inventory(cluster_hosts)
inventory['_meta'] = {'hostvars': {}}
# Some clouds don't have Cinder. That's okay:
try:
volumes = cloud.list_volumes()
except EndpointNotFound:
volumes = []
# cinder volumes used for docker storage
docker_storage_mountpoints = get_docker_storage_mountpoints(volumes)
for server in cluster_hosts:
inventory['_meta']['hostvars'][server.name] = _get_hostvars(
server,
docker_storage_mountpoints)
stout = _get_stack_outputs(cloud)
if stout is not None:
try:
inventory['localhost'].update({
'openshift_openstack_api_lb_provider':
stout['api_lb_provider'],
'openshift_openstack_api_lb_port_id':
stout['api_lb_vip_port_id'],
'openshift_openstack_api_lb_sg_id':
stout['api_lb_sg_id']})
except KeyError:
pass # Not an API load balanced deployment
try:
inventory['OSEv3']['vars'][
'openshift_master_cluster_hostname'] = stout['private_api_ip']
except KeyError:
pass # Internal LB not specified
inventory['localhost']['openshift_openstack_private_api_ip'] = \
stout.get('private_api_ip')
inventory['localhost']['openshift_openstack_public_api_ip'] = \
stout.get('public_api_ip')
inventory['localhost']['openshift_openstack_public_router_ip'] = \
stout.get('public_router_ip')
try:
inventory['OSEv3']['vars'] = _get_kuryr_vars(cloud, stout)
except KeyError:
pass # Not a kuryr deployment
return inventory
def main():
parser = argparse.ArgumentParser()
parser.add_argument("name", help="server name")
options = parser.parse_args()
import shade
cloud = shade.openstack_cloud()
server = cloud.get_server(options.name)
print_dns(cloud, server)
def setUp(self):
super(TestFlavor, self).setUp()
self.demo_cloud = shade.openstack_cloud(cloud="devstack")
self.operator_cloud = shade.operator_cloud(cloud="devstack-admin")
# Generate a random name for flavors in this test
self.new_item_name = "flavor_" + "".join(random.choice(string.ascii_lowercase) for _ in range(5))
self.addCleanup(self._cleanup_flavors)
def setUp(self):
super(TestFloatingIPPool, self).setUp()
self.cloud = openstack_cloud(cloud='devstack')
if not self.cloud._has_nova_extension('os-floating-ip-pools'):
# Skipping this test is floating-ip-pool extension is not
# available on the testing cloud
self.skip(
'Floating IP pools extension is not available')
def setUp(self):
super(TestFloatingIPPool, self).setUp()
# Shell should have OS-* envvars from openrc, typically loaded by job
self.cloud = openstack_cloud()
if not self.cloud._has_nova_extension("os-floating-ip-pools"):
# Skipping this test is floating-ip-pool extension is not
# available on the testing cloud
self.skip("Floating IP pools extension is not available")
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
template=dict(default=None),
environment=dict(default=None, type='list'),
parameters=dict(default={}, type='dict'),
rollback=dict(default=False, type='bool'),
timeout=dict(default=3600, type='int'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
# stack API introduced in 1.8.0
if not HAS_SHADE or (StrictVersion(shade.__version__) < StrictVersion('1.8.0')):
module.fail_json(msg='shade 1.8.0 or higher is required for this module')
state = module.params['state']
name = module.params['name']
# Check for required parameters when state == 'present'
if state == 'present':
for p in ['template']:
if not module.params[p]:
module.fail_json(msg='%s required with present state' % p)
try:
cloud = shade.openstack_cloud(**module.params)
stack = cloud.get_stack(name)
if module.check_mode:
module.exit_json(changed=_system_state_change(module, stack,
cloud))
if state == 'present':
if not stack:
stack = _create_stack(module, stack, cloud)
else:
stack = _update_stack(module, stack, cloud)
changed = True
module.exit_json(changed=changed,
stack=stack,
id=stack.id)
elif state == 'absent':
if not stack:
changed = False
else:
changed = True
if not cloud.delete_stack(name, wait=module.params['wait']):
module.fail_json(msg='delete stack failed for stack: %s' % name)
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def setUp(self):
super(TestCompute, self).setUp()
self.cloud = openstack_cloud(cloud='devstack')
self.nova = self.cloud.nova_client
self.flavor = pick_flavor(self.nova.flavors.list())
if self.flavor is None:
self.assertFalse('no sensible flavor available')
self.image = pick_image(self.nova.images.list())
if self.image is None:
self.assertFalse('no sensible image available')
def setUp(self):
super(TestCompute, self).setUp()
self.cloud = openstack_cloud(cloud='devstack')
self.flavor = pick_flavor(self.cloud.list_flavors())
if self.flavor is None:
self.assertFalse('no sensible flavor available')
self.image = pick_image(self.cloud.list_images())
if self.image is None:
self.assertFalse('no sensible image available')
self.server_name = self.getUniqueString()
def __init__(self, options: argparse.Namespace) -> None:
self.options = options
self.revoke_role_after_purge = False
self.disable_project_after_purge = False
self.cloud = None # type: Optional[shade.OpenStackCloud]
self.operator_cloud = None # type: Optional[shade.OperatorCloud]
if options.purge_own_project:
self.cloud = shade.openstack_cloud(argparse=options)
self.user_id = self.cloud.keystone_session.get_user_id()
self.project_id = self.cloud.keystone_session.get_project_id()
else:
self.operator_cloud = shade.operator_cloud(argparse=options)
self.user_id = self.operator_cloud.keystone_session.get_user_id()
project = self.operator_cloud.get_project(options.purge_project)
if not project:
raise exceptions.OSProjectNotFound(
"Unable to find project '{}'".format(options.purge_project)
)
self.project_id = project['id']
# If project is not enabled, we must disable it after purge.
self.disable_project_after_purge = not project.enabled
# Reuse the information passed to get the `OperatorCloud` but
# change the project. This way we bind/re-scope to the project
# we want to purge, not the project we authenticated to.
self.cloud = shade.openstack_cloud(
**utils.replace_project_info(
self.operator_cloud.cloud_config.config,
self.project_id
)
)
auth_args = self.cloud.cloud_config.get_auth_args()
logging.warning(
"Going to list and/or delete resources from project '%s'",
options.purge_project or auth_args.get('project_name')
or auth_args.get('project_id')
)
def main():
''' Main module function '''
module = AnsibleModule(
argument_spec=dict(
router_id=dict(default=False, type='str'),
subnet_id=dict(default=False, type='str'),
net_id=dict(default=False, type='str'),
sg_id=dict(default=False, type='str'),
),
supports_check_mode=True,
)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
try:
cloud = shade.openstack_cloud()
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to connect to the cloud')
try:
adapter = keystoneauth1.adapter.Adapter(
session=cloud.keystone_session,
service_type=cloud.cloud_config.get_service_type('network'),
interface=cloud.cloud_config.get_interface('network'),
endpoint_override=cloud.cloud_config.get_endpoint('network'),
version=cloud.cloud_config.get_api_version('network'))
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to get an adapter to talk to the Neutron '
'API')
try:
subnet_info = {"subnet_id": module.params['subnet_id'].encode('ascii')}
data = {'data': str(subnet_info).replace('\'', '\"')}
adapter.put('/routers/' + module.params['router_id'] + '/remove_router_interface', **data)
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to detach subnet from the router')
try:
adapter.delete('/networks/' + module.params['net_id'])
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to delete Neutron Network associated to the namespace')
try:
adapter.delete('/security-groups/' + module.params['sg_id'])
# pylint: disable=broad-except
except Exception:
module.fail_json(msg='Failed to delete Security groups associated to the namespace')
module.exit_json(
changed=True)
def main():
argument_spec = openstack_full_argument_spec(
stack_name=dict(required=True),
template=dict(default=None),
environment_files=dict(default=None, type='dict'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
stack_name = module.params['stack_name']
template = module.params['template']
environment_files = module.params['environment_files']
# Check for required parameters when state == 'present'
if state == 'present':
for p in ['stack_name', 'template']:
if not module.params[p]:
module.fail_json(msg='%s required with present state' % p)
try:
cloud = shade.openstack_cloud(**module.params)
stack = cloud.get_stack(stack_name)
if module.check_mode:
module.exit_json(changed=_system_state_change(module, stack,
cloud))
if state == 'present':
if not stack:
stack = _create_stack(module, stack, cloud)
changed = True
else:
changed = False
module.exit_json(changed=changed,
stack=stack,
id=stack['id'])
elif state == 'absent':
if not stack:
changed = False
else:
changed = True
cloud.delete_stack(stack_name)
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=e.message)
import shade
shade.simple_logging(http_debug=True)
cloud = shade.openstack_cloud(
cloud='my-vexxhost', region_name='ca-ymq-1')
cloud.get_image('Ubuntu 16.04.1 LTS [2017-03-03]')
def setUp(self):
super(TestImage, self).setUp()
self.cloud = openstack_cloud(cloud='devstack')
self.image = pick_image(self.cloud.nova_client.images.list())
import shade
shade.simple_logging(debug=True)
cloud = shade.openstack_cloud(cloud='rax', region_name='DFW')
print(cloud.has_service('network'))
#!/usr/bin/python import shade shade.simple_logging(debug=True) cloud = shade.openstack_cloud(cloud='defaults') print(cloud.get_flavor_by_ram(512))
def create_openstack_instance(instance_name,
image_name,
volume_size,
flavor_name=None,
ssh_key=None,
network_name=None):
"""Creates openstack Instance from Image and Assigns a floating IP
to instance. Also It ensures that instance is ready for testing.
:param instance_name: A string. Openstack Instance name to create.
:param image_name: A string. Openstack image name from which instance
to be created.
:param volume_size: A string. Volume size to be created for osp instance
:param flavor_name: A string. Openstack flavor_name for instance.
e.g m1.small.
:param ssh_key: A string. ssh_key 'name' that required to add
into this instance.
:param network_name: A string. Network 'name' that required to create
this instance.
ssh_key should be added to openstack project before running automation.
Else the automation will fail.
The following environment variables affect this command:
FLAVOR_NAME
Openstack flavor name to create compute settings for instance
NETWORK_NAME
Name of the network where the instance is created
SSH_KEY
ssh key to be added into the instance from openstack
"""
if float(re.search(r'\d{1,2}.\d{1,2}',
os.environ["RHEL7_IMAGE"]).group()) >= 7.7:
env.user = "******"
else:
env.user = '******'
env.disable_known_hosts = True
if flavor_name is None:
flavor_name = flavor_name or os.environ.get('FLAVOR_NAME')
if network_name is None:
network_name = network_name or os.environ.get('NETWORK_NAME')
if ssh_key is None:
ssh_key = ssh_key or os.environ.get('OSP_SSHKEY')
openstack_client = shade.openstack_cloud(cloud='satellite-jenkins')
# Validate image is added into openstack project
image = openstack_client.get_image(image_name)
volume_name = '{0}_volume'.format(instance_name)
logger.info('Creating new Openstack Volume {0}'.format(volume_name))
openstack_client.create_volume(size=volume_size,
name=volume_name,
bootable=True,
image=image.id)
# Create instance from the given parameters
logger.info('Creating new Openstack instance {0}'.format(instance_name))
instance = openstack_client.create_server(name=instance_name,
flavor=flavor_name,
boot_from_volume=True,
key_name=ssh_key,
network=network_name,
boot_volume=volume_name,
terminate_volume=True,
wait=True)
if instance.interface_ip:
ip_addr = instance.interface_ip
else:
logger.error("No floating Ip assigned")
# Wait till DNS resolves the IP
logger.info('Pinging the Host by IP:{0} ..........'.format(ip_addr))
host_ssh_availability_check(ip_addr)
host_pings(str(ip_addr))
logger.info('SUCCESS !! The given IP has been pinged!!\n')
logger.info('Now, Getting the hostname from IP......\n')
hostname = get_osp_hostname(ip_addr)
if not hostname:
sys.exit(1)
logger.info('Pinging the Hostname:{0} ..........'.format(hostname))
host_pings(hostname)
logger.info('SUCCESS !! The obtained hostname from IP is pinged !!')
if env.user == "cloud-user":
# Copied the authorized key from cloud-user to root
execute(lambda: run(
"sudo cp ~/.ssh/authorized_keys /root/.ssh/authorized_keys"),
host=hostname)
# To activate the root access need to execute cloud-init init
execute(lambda: run("sudo cloud-init init 2>/dev/null 1>/dev/null"),
host=hostname)
env.user = "******"
# Update the /etc/hosts file
execute(lambda: run("hostnamectl set-hostname {0}".format(hostname)),
host=hostname)
execute(
lambda: run("echo {0} {1} >> /etc/hosts".format(ip_addr, hostname)),
host=hostname)
with open('/tmp/instance.info', 'w') as outfile:
outfile.write('OSP_HOSTNAME={0}'.format(hostname))
return instance
def main():
argument_spec = openstack_full_argument_spec(
security_group = dict(required=True),
# NOTE(Shrews): None is an acceptable protocol value for
# Neutron, but Nova will balk at this.
protocol = dict(default=None,
choices=[None, 'tcp', 'udp', 'icmp', '112']),
port_range_min = dict(required=False, type='int'),
port_range_max = dict(required=False, type='int'),
remote_ip_prefix = dict(required=False, default=None),
remote_group = dict(required=False, default=None),
ethertype = dict(default='IPv4',
choices=['IPv4', 'IPv6']),
direction = dict(default='ingress',
choices=['egress', 'ingress']),
state = dict(default='present',
choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs(
mutually_exclusive=[
['remote_ip_prefix', 'remote_group'],
]
)
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
security_group = module.params['security_group']
remote_group = module.params['remote_group']
changed = False
try:
cloud = shade.openstack_cloud(**module.params)
secgroup = cloud.get_security_group(security_group)
if remote_group:
remotegroup = cloud.get_security_group(remote_group)
else:
remotegroup = { 'id' : None }
if module.check_mode:
module.exit_json(changed=_system_state_change(module, secgroup, remotegroup))
if state == 'present':
if not secgroup:
module.fail_json(msg='Could not find security group %s' %
security_group)
rule = _find_matching_rule(module, secgroup, remotegroup)
if not rule:
rule = cloud.create_security_group_rule(
secgroup['id'],
port_range_min=module.params['port_range_min'],
port_range_max=module.params['port_range_max'],
protocol=module.params['protocol'],
remote_ip_prefix=module.params['remote_ip_prefix'],
remote_group_id=remotegroup['id'],
direction=module.params['direction'],
ethertype=module.params['ethertype']
)
changed = True
module.exit_json(changed=changed, rule=rule, id=rule['id'])
if state == 'absent' and secgroup:
rule = _find_matching_rule(module, secgroup, remotegroup)
if rule:
cloud.delete_security_group_rule(rule['id'])
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
password=dict(required=False, default=None, no_log=True),
email=dict(required=False, default=None),
default_project=dict(required=False, default=None),
domain=dict(required=False, default=None),
enabled=dict(default=True, type='bool'),
state=dict(default='present', choices=['absent', 'present']),
update_password=dict(default='always', choices=['always',
'on_create']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
name = module.params['name']
password = module.params.pop('password')
email = module.params['email']
default_project = module.params['default_project']
domain = module.params['domain']
enabled = module.params['enabled']
state = module.params['state']
update_password = module.params['update_password']
try:
cloud = shade.openstack_cloud(**module.params)
user = cloud.get_user(name)
domain_id = None
if domain:
opcloud = shade.operator_cloud(**module.params)
domain_id = _get_domain_id(opcloud, domain)
if state == 'present':
if update_password in ('always', 'on_create'):
if not password:
msg = ("update_password is %s but a password value is "
"missing") % update_password
module.fail_json(msg=msg)
default_project_id = None
if default_project:
default_project_id = _get_default_project_id(
cloud, default_project)
if user is None:
user = cloud.create_user(name=name,
password=password,
email=email,
default_project=default_project_id,
domain_id=domain_id,
enabled=enabled)
changed = True
else:
params_dict = {
'email': email,
'enabled': enabled,
'password': password,
'update_password': update_password
}
if domain_id is not None:
params_dict['domain_id'] = domain_id
if default_project_id is not None:
params_dict['default_project_id'] = default_project_id
if _needs_update(params_dict, user):
if update_password == 'always':
user = cloud.update_user(
user['id'],
password=password,
email=email,
default_project=default_project_id,
domain_id=domain_id,
enabled=enabled)
else:
user = cloud.update_user(
user['id'],
email=email,
default_project=default_project_id,
domain_id=domain_id,
enabled=enabled)
changed = True
else:
changed = False
module.exit_json(changed=changed, user=user)
elif state == 'absent':
if user is None:
changed = False
else:
cloud.delete_user(user['id'])
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
# get options
argparser = argparse.ArgumentParser()
argparser.add_argument('--criticality',
'-z',
help='Set sensu alert level, critical is default',
default='critical')
options = argparser.parse_args()
# set alert level
if options.criticality == 'critical':
exit_alert_state = STATE_CRITICAL
else:
exit_alert_state = STATE_WARNING
# get cinder service list with down state
cloud = shade.openstack_cloud()
cinder = cloud.cinder_client
services_down = []
for service in cinder.services.list():
if service.state == 'down':
services_down.append(service)
if len(services_down) > 0:
print "Alert: %d Cinder service(s) down" % len(services_down)
print services_down
sys.exit(exit_alert_state)
else:
print "OK: No Cinder service(s) down"
sys.exit(STATE_OK)
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
zone_type=dict(required=False, choice=['primary', 'secondary']),
email=dict(required=False, default=None),
description=dict(required=False, default=None),
ttl=dict(required=False, default=None, type='int'),
masters=dict(required=False, default=None, type='list'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
if StrictVersion(shade.__version__) < StrictVersion('1.8.0'):
module.fail_json(msg="To utilize this module, the installed version of"
"the shade library MUST be >=1.8.0")
name = module.params.get('name')
state = module.params.get('state')
try:
cloud = shade.openstack_cloud(**module.params)
zone = cloud.get_zone(name)
if state == 'present':
zone_type = module.params.get('zone_type')
email = module.params.get('email')
description = module.params.get('description')
ttl = module.params.get('ttl')
masters = module.params.get('masters')
if module.check_mode:
module.exit_json(changed=_system_state_change(
state, email, description, ttl, masters, zone))
if zone is None:
zone = cloud.create_zone(name=name,
zone_type=zone_type,
email=email,
description=description,
ttl=ttl,
masters=masters)
changed = True
else:
if masters is None:
masters = []
pre_update_zone = zone
changed = _system_state_change(state, email, description, ttl,
masters, pre_update_zone)
if changed:
zone = cloud.update_zone(name,
email=email,
description=description,
ttl=ttl,
masters=masters)
module.exit_json(changed=changed, zone=zone)
elif state == 'absent':
if module.check_mode:
module.exit_json(changed=_system_state_change(
state, None, None, None, None, zone))
if zone is None:
changed = False
else:
cloud.delete_zone(name)
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def main():
argument_spec = openstack_full_argument_spec(
zone=dict(required=True),
name=dict(required=True),
recordset_type=dict(required=False),
records=dict(required=False, type='list'),
description=dict(required=False, default=None),
ttl=dict(required=False, default=None, type='int'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
required_if=[
('state', 'present',
['recordset_type', 'records'])],
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
if StrictVersion(shade.__version__) <= StrictVersion('1.8.0'):
module.fail_json(msg="To utilize this module, the installed version of "
"the shade library MUST be >1.8.0")
zone = module.params.get('zone')
name = module.params.get('name')
state = module.params.get('state')
try:
cloud = shade.openstack_cloud(**module.params)
recordset = cloud.get_recordset(zone, name + '.' + zone)
if state == 'present':
recordset_type = module.params.get('recordset_type')
records = module.params.get('records')
description = module.params.get('description')
ttl = module.params.get('ttl')
if module.check_mode:
module.exit_json(changed=_system_state_change(state,
records, description,
ttl, zone,
recordset))
if recordset is None:
recordset = cloud.create_recordset(
zone=zone, name=name, recordset_type=recordset_type,
records=records, description=description, ttl=ttl)
changed = True
else:
if records is None:
records = []
pre_update_recordset = recordset
changed = _system_state_change(state, records,
description, ttl,
zone, pre_update_recordset)
if changed:
zone = cloud.update_recordset(
zone, name + '.' + zone,
records=records,
description=description,
ttl=ttl)
module.exit_json(changed=changed, recordset=recordset)
elif state == 'absent':
if module.check_mode:
module.exit_json(changed=_system_state_change(state,
None, None,
None,
None, recordset))
if recordset is None:
changed=False
else:
cloud.delete_recordset(zone, name + '.' + zone)
changed=True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def __init__(self):
self.cloud = shade.openstack_cloud()
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
shared=dict(default=False, type='bool'),
admin_state_up=dict(default=True, type='bool'),
external=dict(default=False, type='bool'),
provider_physical_network=dict(required=False),
provider_network_type=dict(required=False),
provider_segmentation_id=dict(required=False),
state=dict(default='present', choices=['absent', 'present']),
project=dict(default=None))
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
if (module.params['project']
and StrictVersion(shade.__version__) < StrictVersion('1.6.0')):
module.fail_json(msg="To utilize project, the installed version of"
"the shade library MUST be >=1.6.0")
state = module.params['state']
name = module.params['name']
shared = module.params['shared']
admin_state_up = module.params['admin_state_up']
external = module.params['external']
provider_physical_network = module.params['provider_physical_network']
provider_network_type = module.params['provider_network_type']
provider_segmentation_id = module.params['provider_segmentation_id']
project = module.params.pop('project')
try:
cloud = shade.openstack_cloud(**module.params)
if project is not None:
proj = cloud.get_project(project)
if proj is None:
module.fail_json(msg='Project %s could not be found' % project)
project_id = proj['id']
filters = {'tenant_id': project_id}
else:
project_id = None
filters = None
net = cloud.get_network(name, filters=filters)
if state == 'present':
if not net:
provider = {}
if provider_physical_network:
provider['physical_network'] = provider_physical_network
if provider_network_type:
provider['network_type'] = provider_network_type
if provider_segmentation_id:
provider['segmentation_id'] = provider_segmentation_id
if provider and StrictVersion(
shade.__version__) < StrictVersion('1.5.0'):
module.fail_json(
msg="Shade >= 1.5.0 required to use provider options")
if project_id is not None:
net = cloud.create_network(name, shared, admin_state_up,
external, provider, project_id)
else:
net = cloud.create_network(name, shared, admin_state_up,
external, provider)
changed = True
else:
changed = False
module.exit_json(changed=changed, network=net, id=net['id'])
elif state == 'absent':
if not net:
module.exit_json(changed=False)
else:
cloud.delete_network(name)
module.exit_json(changed=True)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def setUp(self):
super(TestRangeSearch, self).setUp()
self.cloud = shade.openstack_cloud(cloud='devstack')
def main():
argument_spec = openstack_full_argument_spec(
server=dict(required=True),
state=dict(default='present', choices=['absent', 'present']),
network=dict(required=False, default=None),
floating_ip_address=dict(required=False, default=None),
reuse=dict(required=False, type='bool', default=False),
fixed_address=dict(required=False, default=None),
wait=dict(required=False, type='bool', default=False),
timeout=dict(required=False, type='int', default=60),
purge=dict(required=False, type='bool', default=False),
internal_network=dict(required=False, default=None),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
server_name_or_id = module.params['server']
state = module.params['state']
network = module.params['network']
floating_ip_address = module.params['floating_ip_address']
reuse = module.params['reuse']
fixed_address = module.params['fixed_address']
wait = module.params['wait']
timeout = module.params['timeout']
purge = module.params['purge']
internal_network = module.params['internal_network']
# cloud = shade.openstack_cloud(**module.params)
# shade breaks when key "internal_network" is supplied
cloud_keywargs = dict((k, module.params[k]) for k in module.params
if k != 'internal_network')
if internal_network:
cloud_keywargs["networks"] = [
dict(name=internal_network, routes_externally=False)
]
cloud = shade.openstack_cloud(**cloud_keywargs)
try:
server = cloud.get_server(server_name_or_id)
if server is None:
module.fail_json(
msg="server {0} not found".format(server_name_or_id))
if state == 'present':
# This part was added to support 'internal_network_name'
# as in Ansible 1.9.x. This entire file should be removed
# after this option added to Ansible 2.x
if internal_network:
internal_net_info = cloud.list_networks(
{'name': internal_network})
internal_network_id = internal_net_info[0]['id']
port_filter = {'device_id': server['id']}
port_filter['network_id'] = internal_network_id
ports = cloud.search_ports(filters=port_filter)
port = ports[0]
for address in port.get('fixed_ips', list()):
try:
ip = ipaddress.ip_address(address['ip_address'])
except Exception:
continue
if ip.version == 4:
fixed_address = address['ip_address']
break
# If f_ip already assigned to server, check that it matches
# requirements.
f_ip = cloud.get_server_public_ip(server)
f_ip = _get_floating_ip(cloud, f_ip) if f_ip else f_ip
if f_ip:
if network:
network_id = cloud.get_network(name_or_id=network)["id"]
else:
network_id = None
if all([
fixed_address, f_ip.fixed_ip_address == fixed_address,
network, f_ip.network != network_id
]):
# Current state definitely conflicts with requirements
module.fail_json(
msg="server {server} already has a "
"floating-ip on requested "
"interface but it doesn't match "
"requested network {network: {fip}".format(
server=server_name_or_id,
network=network,
fip=remove_values(f_ip, module.no_log_values)))
if not network or f_ip.network == network_id:
# Requirements are met
module.exit_json(changed=False, floating_ip=f_ip)
# Requirments are vague enough to ignore exisitng f_ip and try
# to create a new f_ip to the server.
server = cloud.add_ips_to_server(server=server,
ips=floating_ip_address,
ip_pool=network,
reuse=reuse,
fixed_address=fixed_address,
wait=wait,
timeout=timeout)
fip_address = cloud.get_server_public_ip(server)
# Update the floating IP status
f_ip = _get_floating_ip(cloud, fip_address)
module.exit_json(changed=True, floating_ip=f_ip)
elif state == 'absent':
if floating_ip_address is None:
if not server_name_or_id:
module.fail_json(
msg="either server or floating_ip_address are required"
)
server = cloud.get_server(server_name_or_id)
floating_ip_address = cloud.get_server_public_ip(server)
f_ip = _get_floating_ip(cloud, floating_ip_address)
if not f_ip:
# Nothing to detach
module.exit_json(changed=False)
changed = False
if f_ip["fixed_ip_address"]:
cloud.detach_ip_from_server(server_id=server['id'],
floating_ip_id=f_ip['id'])
# Update the floating IP status
f_ip = cloud.get_floating_ip(id=f_ip['id'])
changed = True
if purge:
cloud.delete_floating_ip(f_ip['id'])
module.exit_json(changed=True)
module.exit_json(changed=changed, floating_ip=f_ip)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
import shade
cloud = shade.openstack_cloud(cloud='envvars')
print("\nListando imagens...")
images = cloud.list_images()
for image in images:
print(image.id + '\t' + image.name)
print("\nListando sabores...")
flavors = cloud.list_flavors()
for flavor in flavors:
print("{}\t{} vcpus \t{} MB \t{}".format(flavor.id, flavor.vcpus,
flavor.ram, flavor.name))
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
shared=dict(default=False, type='bool'),
admin_state_up=dict(default=True, type='bool'),
external=dict(default=False, type='bool'),
provider_physical_network=dict(required=False),
provider_network_type=dict(required=False,
default=None,
choices=['flat', 'vlan', 'vxlan', 'gre']),
provider_segmentation_id=dict(required=False),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
name = module.params['name']
shared = module.params['shared']
admin_state_up = module.params['admin_state_up']
external = module.params['external']
provider_physical_network = module.params['provider_physical_network']
provider_network_type = module.params['provider_network_type']
provider_segmentation_id = module.params['provider_segmentation_id']
try:
cloud = shade.openstack_cloud(**module.params)
net = cloud.get_network(name)
if state == 'present':
if not net:
provider = {}
if provider_physical_network:
provider['physical_network'] = provider_physical_network
if provider_network_type:
provider['network_type'] = provider_network_type
if provider_segmentation_id:
provider['segmentation_id'] = provider_segmentation_id
if provider and StrictVersion(
shade.__version__) < StrictVersion('1.5.0'):
module.fail_json(
msg="Shade >= 1.5.0 required to use provider options")
net = cloud.create_network(name, shared, admin_state_up,
external, provider)
changed = True
else:
changed = False
module.exit_json(changed=changed, network=net, id=net['id'])
elif state == 'absent':
if not net:
module.exit_json(changed=False)
else:
cloud.delete_network(name)
module.exit_json(changed=True)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def __init__(self, scheme):
self.cloud = shade.openstack_cloud()
self._scheme = scheme
def main():
argument_spec = openstack_full_argument_spec(
server=dict(required=True),
action=dict(required=True,
choices=[
'stop', 'start', 'pause', 'unpause', 'lock', 'unlock',
'suspend', 'resume', 'rebuild'
]),
image=dict(required=False),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
required_if=[('action', 'rebuild', ['image'])],
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
action = module.params['action']
wait = module.params['wait']
timeout = module.params['timeout']
image = module.params['image']
try:
if action in _admin_actions:
cloud = shade.operator_cloud(**module.params)
else:
cloud = shade.openstack_cloud(**module.params)
server = cloud.get_server(module.params['server'])
if not server:
module.fail_json(msg='Could not find server %s' % server)
status = server.status
if module.check_mode:
module.exit_json(changed=_system_state_change(action, status))
if action == 'stop':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.stop(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
if action == 'start':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.start(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
if action == 'pause':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.pause(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
elif action == 'unpause':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.unpause(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
elif action == 'lock':
# lock doesn't set a state, just do it
cloud.nova_client.servers.lock(server=server.id)
module.exit_json(changed=True)
elif action == 'unlock':
# unlock doesn't set a state, just do it
cloud.nova_client.servers.unlock(server=server.id)
module.exit_json(changed=True)
elif action == 'suspend':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.suspend(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
elif action == 'resume':
if not _system_state_change(action, status):
module.exit_json(changed=False)
cloud.nova_client.servers.resume(server=server.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
elif action == 'rebuild':
image = cloud.get_image(image)
if image is None:
module.fail_json(msg="Image does not exist")
# rebuild doesn't set a state, just do it
cloud.nova_client.servers.rebuild(server=server.id, image=image.id)
if wait:
_wait(timeout, cloud, server, action)
module.exit_json(changed=True)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
def build_inventory():
'''Build the dynamic inventory.'''
cloud = shade.openstack_cloud()
# Use an environment variable to optionally skip returning the app nodes.
show_compute_nodes = os.environ.get('OPENSTACK_SHOW_COMPUTE_NODES',
'true').lower() == "true"
# If `OPENSHIFT_CLUSTER` env variable is defined then it's used to
# filter servers by metadata.clusterid attribute value.
cluster_hosts = [
server for server in cloud.list_servers()
if 'clusterid' in server.get('metadata', []) and (
OPENSHIFT_CLUSTER is None
or server.metadata.clusterid == OPENSHIFT_CLUSTER) and
(show_compute_nodes or server.metadata.get('sub-host-type') != 'app')
]
inventory = base_openshift_inventory(cluster_hosts)
inventory['_meta'] = {'hostvars': {}}
# Some clouds don't have Cinder. That's okay:
try:
volumes = cloud.list_volumes()
except EndpointNotFound:
volumes = []
# cinder volumes used for docker storage
docker_storage_mountpoints = get_docker_storage_mountpoints(volumes)
for server in cluster_hosts:
inventory['_meta']['hostvars'][server.name] = _get_hostvars(
server, docker_storage_mountpoints)
stout = _get_stack_outputs(cloud)
if stout is not None:
try:
inventory['localhost'].update({
'openshift_openstack_api_lb_provider':
stout['api_lb_provider'],
'openshift_openstack_api_lb_port_id':
stout['api_lb_vip_port_id'],
'openshift_openstack_api_lb_sg_id':
stout['api_lb_sg_id']
})
except KeyError:
pass # Not an API load balanced deployment
try:
inventory['OSEv3']['vars'][
'openshift_master_cluster_hostname'] = stout['private_api_ip']
except KeyError:
pass # Internal LB not specified
inventory['localhost']['openshift_openstack_private_api_ip'] = \
stout.get('private_api_ip')
inventory['localhost']['openshift_openstack_public_api_ip'] = \
stout.get('public_api_ip')
inventory['localhost']['openshift_openstack_public_router_ip'] = \
stout.get('public_router_ip')
try:
inventory['OSEv3']['vars'] = _get_kuryr_vars(cloud, stout)
except KeyError:
pass # Not a kuryr deployment
return inventory
def setUp(self):
super(TestMagnumServices, self).setUp()
self.cloud = shade.openstack_cloud(validate=False)
# Modify these values below (or read them in from the command line)
cloud_names = ['indiana', 'tacc', 'marana']
server_name_pattern = 'demo_worker-{}'
for cloud_name in cloud_names:
print('Finding & deleting servers and keypairs in cloud: {}'.format(
cloud_name))
server_search_pattern = server_name_pattern.format('*')
# Initialize. Set debug=True & http_debug=True if you want to see more detailed cloud activity
shade.simple_logging(debug=False, http_debug=False)
# shade.simple_logging(debug=True, http_debug=True)
# Initialize cloud
cloud = shade.openstack_cloud(cloud=cloud_name)
# Find all servers matching a pattern
for server in cloud.search_servers(server_search_pattern):
# print(server.__dict__)
print('Deleting {}...'.format(server.name))
delete_result = cloud.delete_server(server, wait=True, delete_ips=True)
print(delete_result)
else:
print('No servers found')
# Delete keypair
key_name = 'shade-key'
keypair = cloud.get_keypair(key_name)
if keypair:
print('Deleting keypair {}...'.format(keypair.name))
def main():
argument_spec = openstack_full_argument_spec(
network=dict(required=False),
name=dict(required=False),
fixed_ips=dict(type='list', default=None),
admin_state_up=dict(type='bool', default=None),
mac_address=dict(default=None),
security_groups=dict(default=None, type='list'),
no_security_groups=dict(default=False, type='bool'),
allowed_address_pairs=dict(type='list', default=None),
extra_dhcp_opts=dict(type='list', default=None),
device_owner=dict(default=None),
device_id=dict(default=None),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs(mutually_exclusive=[
['no_security_groups', 'security_groups'],
])
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
name = module.params['name']
state = module.params['state']
try:
cloud = shade.openstack_cloud(**module.params)
if module.params['security_groups']:
# translate security_groups to UUID's if names where provided
module.params['security_groups'] = [
get_security_group_id(module, cloud, v)
for v in module.params['security_groups']
]
port = None
network_id = None
if name:
port = cloud.get_port(name)
if module.check_mode:
module.exit_json(changed=_system_state_change(module, port, cloud))
changed = False
if state == 'present':
if not port:
network = module.params['network']
if not network:
module.fail_json(
msg="Parameter 'network' is required in Port Create")
port_kwargs = _compose_port_args(module, cloud)
network_object = cloud.get_network(network)
if network_object:
network_id = network_object['id']
else:
module.fail_json(msg="Specified network was not found.")
port = cloud.create_port(network_id, **port_kwargs)
changed = True
else:
if _needs_update(module, port, cloud):
port_kwargs = _compose_port_args(module, cloud)
port = cloud.update_port(port['id'], **port_kwargs)
changed = True
module.exit_json(changed=changed, id=port['id'], port=port)
if state == 'absent':
if port:
cloud.delete_port(port['id'])
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
#!/usr/bin/env python
# Copyright (c) 2016 IBM Corp.
#
# 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.
import shade
for cloud in ('osic-cloud1', 'bluebox-sjc1'):
cloud = shade.openstack_cloud(cloud=cloud)
cleaned = [cloud.delete_floating_ip(ip.id) for ip in
cloud.list_floating_ips() if ip.attached is False]
print("Cleaned {num} FIPs from {cloud}".format(
num=len(cleaned), cloud=cloud.name))
def default_ovn_provider_client(openstack_client_config):
"""
Returns a shade connection configured to connect
to the default ovn provider.
"""
return shade.openstack_cloud(cloud=openstack_client_config)
def test_get_server_ip(self):
srv = meta.obj_to_dict(FakeServer())
cloud = shade.openstack_cloud(validate=False)
self.assertEqual(PRIVATE_V4, meta.get_server_private_ip(srv, cloud))
self.assertEqual(PUBLIC_V4, meta.get_server_external_ipv4(cloud, srv))
def main():
ipv6_mode_choices = ['dhcpv6-stateful', 'dhcpv6-stateless', 'slaac']
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
network_name=dict(default=None),
cidr=dict(default=None),
ip_version=dict(default='4', choices=['4', '6']),
enable_dhcp=dict(default='true', type='bool'),
gateway_ip=dict(default=None),
dns_nameservers=dict(default=None, type='list'),
allocation_pool_start=dict(default=None),
allocation_pool_end=dict(default=None),
host_routes=dict(default=None, type='list'),
ipv6_ra_mode=dict(default=None, choice=ipv6_mode_choices),
ipv6_address_mode=dict(default=None, choice=ipv6_mode_choices),
state=dict(default='present', choices=['absent', 'present']),
project=dict(default=None))
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
network_name = module.params['network_name']
cidr = module.params['cidr']
ip_version = module.params['ip_version']
enable_dhcp = module.params['enable_dhcp']
subnet_name = module.params['name']
gateway_ip = module.params['gateway_ip']
dns = module.params['dns_nameservers']
pool_start = module.params['allocation_pool_start']
pool_end = module.params['allocation_pool_end']
host_routes = module.params['host_routes']
ipv6_ra_mode = module.params['ipv6_ra_mode']
ipv6_a_mode = module.params['ipv6_address_mode']
project = module.params.pop('project')
# Check for required parameters when state == 'present'
if state == 'present':
for p in ['network_name', 'cidr']:
if not module.params[p]:
module.fail_json(msg='%s required with present state' % p)
if pool_start and pool_end:
pool = [dict(start=pool_start, end=pool_end)]
elif pool_start or pool_end:
module.fail_json(msg='allocation pool requires start and end values')
else:
pool = None
try:
cloud = shade.openstack_cloud(**module.params)
if project is not None:
proj = cloud.get_project(project)
if proj is None:
module.fail_json(msg='Project %s could not be found' % project)
project_id = proj['id']
filters = {'tenant_id': project_id}
else:
project_id = None
filters = None
subnet = cloud.get_subnet(subnet_name, filters=filters)
if module.check_mode:
module.exit_json(
changed=_system_state_change(module, subnet, cloud))
if state == 'present':
if not subnet:
subnet = cloud.create_subnet(network_name,
cidr,
ip_version=ip_version,
enable_dhcp=enable_dhcp,
subnet_name=subnet_name,
gateway_ip=gateway_ip,
dns_nameservers=dns,
allocation_pools=pool,
host_routes=host_routes,
ipv6_ra_mode=ipv6_ra_mode,
ipv6_address_mode=ipv6_a_mode,
tenant_id=project_id)
changed = True
else:
if _needs_update(subnet, module, cloud):
cloud.update_subnet(subnet['id'],
subnet_name=subnet_name,
enable_dhcp=enable_dhcp,
gateway_ip=gateway_ip,
dns_nameservers=dns,
allocation_pools=pool,
host_routes=host_routes)
changed = True
else:
changed = False
module.exit_json(changed=changed, subnet=subnet, id=subnet['id'])
elif state == 'absent':
if not subnet:
changed = False
else:
changed = True
cloud.delete_subnet(subnet_name)
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e))
def build_inventory():
'''Build the dynamic inventory.'''
cloud = shade.openstack_cloud()
# TODO(shadower): filter the servers based on the `OPENSHIFT_CLUSTER`
# environment variable.
cluster_hosts = [
server for server in cloud.list_servers()
if 'metadata' in server and 'clusterid' in server.metadata
]
inventory = base_openshift_inventory(cluster_hosts)
for server in cluster_hosts:
if 'group' in server.metadata:
group = server.metadata.get('group')
if group not in inventory:
inventory[group] = {'hosts': []}
inventory[group]['hosts'].append(server.name)
inventory['_meta'] = {'hostvars': {}}
# Some clouds don't have Cinder. That's okay:
try:
volumes = cloud.list_volumes()
except EndpointNotFound:
volumes = []
# cinder volumes used for docker storage
docker_storage_mountpoints = get_docker_storage_mountpoints(volumes)
for server in cluster_hosts:
inventory['_meta']['hostvars'][server.name] = _get_hostvars(
server, docker_storage_mountpoints)
stout = _get_stack_outputs(cloud)
if stout is not None:
try:
inventory['localhost'].update({
'openshift_openstack_api_lb_provider':
stout['api_lb_provider'],
'openshift_openstack_api_lb_port_id':
stout['api_lb_vip_port_id'],
'openshift_openstack_api_lb_sg_id':
stout['api_lb_sg_id']
})
except KeyError:
pass # Not an API load balanced deployment
try:
inventory['OSEv3']['vars'][
'openshift_master_cluster_hostname'] = stout['private_api_ip']
except KeyError:
pass # Internal LB not specified
inventory['localhost']['openshift_openstack_public_api_ip'] = \
stout.get('public_api_ip')
inventory['localhost']['openshift_openstack_public_router_ip'] = \
stout.get('public_router_ip')
try:
inventory['OSEv3']['vars'] = _get_kuryr_vars(cloud, stout)
except KeyError:
pass # Not a kuryr deployment
return inventory
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
disk_format=dict(default='qcow2',
choices=[
'ami', 'ari', 'aki', 'vhd', 'vmdk', 'raw',
'qcow2', 'vdi', 'iso', 'vhdx', 'ploop'
]),
container_format=dict(
default='bare',
choices=['ami', 'aki', 'ari', 'bare', 'ovf', 'ova', 'docker']),
owner=dict(default=None),
min_disk=dict(type='int', default=0),
min_ram=dict(type='int', default=0),
is_public=dict(type='bool', default=False),
filename=dict(default=None),
ramdisk=dict(default=None),
kernel=dict(default=None),
properties=dict(type='dict', default={}),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
try:
cloud = shade.openstack_cloud(**module.params)
changed = False
image = cloud.get_image(name_or_id=module.params['name'])
if module.params['state'] == 'present':
if not image:
image = cloud.create_image(
name=module.params['name'],
filename=module.params['filename'],
disk_format=module.params['disk_format'],
container_format=module.params['container_format'],
wait=module.params['wait'],
timeout=module.params['timeout'],
is_public=module.params['is_public'],
min_disk=module.params['min_disk'],
min_ram=module.params['min_ram'])
changed = True
if not module.params['wait']:
module.exit_json(changed=changed, image=image, id=image.id)
cloud.update_image_properties(image=image,
kernel=module.params['kernel'],
ramdisk=module.params['ramdisk'],
**module.params['properties'])
image = cloud.get_image(name_or_id=image.id)
module.exit_json(changed=changed, image=image, id=image.id)
elif module.params['state'] == 'absent':
if not image:
changed = False
else:
cloud.delete_image(name_or_id=module.params['name'],
wait=module.params['wait'],
timeout=module.params['timeout'])
changed = True
module.exit_json(changed=changed)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
def main():
argument_spec = openstack_full_argument_spec(
name=dict(required=True),
image=dict(default=None),
image_exclude=dict(default='(deprecated)'),
flavor=dict(default=None),
flavor_ram=dict(default=None, type='int'),
flavor_include=dict(default=None),
key_name=dict(default=None),
security_groups=dict(default=['default'], type='list'),
network=dict(default=None),
nics=dict(default=[], type='list'),
meta=dict(default=None),
userdata=dict(default=None, aliases=['user_data']),
config_drive=dict(default=False, type='bool'),
auto_ip=dict(default=True,
type='bool',
aliases=['auto_floating_ip', 'public_ip']),
floating_ips=dict(default=None),
floating_ip_pools=dict(default=None),
volume_size=dict(default=False, type='int'),
boot_from_volume=dict(default=False, type='bool'),
boot_volume=dict(default=None, aliases=['root_volume']),
terminate_volume=dict(default=False, type='bool'),
volumes=dict(default=[], type='list'),
state=dict(default='present', choices=['absent', 'present']),
)
module_kwargs = openstack_module_kwargs(
mutually_exclusive=[
['auto_ip', 'floating_ips'],
['auto_ip', 'floating_ip_pools'],
['floating_ips', 'floating_ip_pools'],
['flavor', 'flavor_ram'],
['image', 'boot_volume'],
['boot_from_volume', 'boot_volume'],
['nics', 'network'],
],
required_if=[
('boot_from_volume', True, ['volume_size', 'image']),
],
)
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
state = module.params['state']
image = module.params['image']
boot_volume = module.params['boot_volume']
flavor = module.params['flavor']
flavor_ram = module.params['flavor_ram']
if state == 'present':
if not (image or boot_volume):
module.fail_json(
msg="Parameter 'image' or 'boot_volume' is required "
"if state == 'present'")
if not flavor and not flavor_ram:
module.fail_json(
msg="Parameter 'flavor' or 'flavor_ram' is required "
"if state == 'present'")
try:
cloud_params = dict(module.params)
cloud_params.pop('userdata', None)
cloud = shade.openstack_cloud(**cloud_params)
if state == 'present':
_get_server_state(module, cloud)
_create_server(module, cloud)
elif state == 'absent':
_get_server_state(module, cloud)
_delete_server(module, cloud)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
def main():
argument_spec = openstack_full_argument_spec(
server=dict(required=True),
state=dict(default='present', choices=['absent', 'present']),
network=dict(required=False, default=None),
floating_ip_address=dict(required=False, default=None),
reuse=dict(required=False, type='bool', default=False),
fixed_address=dict(required=False, default=None),
nat_destination=dict(required=False, default=None,
aliases=['fixed_network', 'internal_network']),
wait=dict(required=False, type='bool', default=False),
timeout=dict(required=False, type='int', default=60),
purge=dict(required=False, type='bool', default=False),
)
module_kwargs = openstack_module_kwargs()
module = AnsibleModule(argument_spec, **module_kwargs)
if not HAS_SHADE:
module.fail_json(msg='shade is required for this module')
if (module.params['nat_destination'] and
StrictVersion(shade.__version__) < StrictVersion('1.8.0')):
module.fail_json(msg="To utilize nat_destination, the installed version of"
"the shade library MUST be >= 1.8.0")
server_name_or_id = module.params['server']
state = module.params['state']
network = module.params['network']
floating_ip_address = module.params['floating_ip_address']
reuse = module.params['reuse']
fixed_address = module.params['fixed_address']
nat_destination = module.params['nat_destination']
wait = module.params['wait']
timeout = module.params['timeout']
purge = module.params['purge']
cloud = shade.openstack_cloud(**module.params)
try:
server = cloud.get_server(server_name_or_id)
if server is None:
module.fail_json(
msg="server {0} not found".format(server_name_or_id))
if state == 'present':
# If f_ip already assigned to server, check that it matches
# requirements.
public_ip = cloud.get_server_public_ip(server)
f_ip = _get_floating_ip(cloud, public_ip) if public_ip else public_ip
if f_ip:
if network:
network_id = cloud.get_network(name_or_id=network)["id"]
else:
network_id = None
if all([(fixed_address and f_ip.fixed_ip_address == fixed_address) or
(nat_destination and f_ip.internal_network == fixed_address),
network, f_ip.network != network_id]):
# Current state definitely conflicts with requirements
module.fail_json(msg="server {server} already has a "
"floating-ip on requested "
"interface but it doesn't match "
"requested network {network: {fip}"
.format(server=server_name_or_id,
network=network,
fip=remove_values(f_ip,
module.no_log_values)))
if not network or f_ip.network == network_id:
# Requirements are met
module.exit_json(changed=False, floating_ip=f_ip)
# Requirements are vague enough to ignore existing f_ip and try
# to create a new f_ip to the server.
server = cloud.add_ips_to_server(
server=server, ips=floating_ip_address, ip_pool=network,
reuse=reuse, fixed_address=fixed_address, wait=wait,
timeout=timeout, nat_destination=nat_destination)
fip_address = cloud.get_server_public_ip(server)
# Update the floating IP status
f_ip = _get_floating_ip(cloud, fip_address)
module.exit_json(changed=True, floating_ip=f_ip)
elif state == 'absent':
if floating_ip_address is None:
if not server_name_or_id:
module.fail_json(msg="either server or floating_ip_address are required")
server = cloud.get_server(server_name_or_id)
floating_ip_address = cloud.get_server_public_ip(server)
f_ip = _get_floating_ip(cloud, floating_ip_address)
if not f_ip:
# Nothing to detach
module.exit_json(changed=False)
changed = False
if f_ip["fixed_ip_address"]:
cloud.detach_ip_from_server(
server_id=server['id'], floating_ip_id=f_ip['id'])
# Update the floating IP status
f_ip = cloud.get_floating_ip(id=f_ip['id'])
changed = True
if purge:
cloud.delete_floating_ip(f_ip['id'])
module.exit_json(changed=True)
module.exit_json(changed=changed, floating_ip=f_ip)
except shade.OpenStackCloudException as e:
module.fail_json(msg=str(e), extra_data=e.extra_data)
