def list_volume_snapshots(volume_id, profile, **libcloud_kwargs):
'''
Return a list of storage volumes snapshots for this cloud
:param volume_id: The volume identifier
:type volume_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_volume_snapshots method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.list_volume_snapshots vol1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
volume = _get_by_id(conn.list_volumes(), volume_id)
snapshots = conn.list_volume_snapshots(volume, **libcloud_kwargs)
ret = []
for snapshot in snapshots:
ret.append(_simple_volume_snapshot(snapshot))
return ret
def attach_volume(node_id, volume_id, profile, device=None, **libcloud_kwargs):
'''
Attaches volume to node.
:param node_id: Node ID to target
:type node_id: ``str``
:param volume_id: Volume ID from which to attach
:type volume_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param device: Where the device is exposed, e.g. '/dev/sdb'
:type device: ``str``
:param libcloud_kwargs: Extra arguments for the driver's attach_volume method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.detach_volume vol1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
volume = _get_by_id(conn.list_volumes(), volume_id)
node = _get_by_id(conn.list_nodes(), node_id)
return conn.attach_volume(node, volume, device=device, **libcloud_kwargs)
def create_volume_snapshot(volume_id, profile, name=None, **libcloud_kwargs):
'''
Create a storage volume snapshot
:param volume_id: Volume ID from which to create the new
snapshot.
:type volume_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param name: Name of the snapshot to be created (optional)
:type name: ``str``
:param libcloud_kwargs: Extra arguments for the driver's create_volume_snapshot method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.create_volume_snapshot vol1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
volume = _get_by_id(conn.list_volumes(), volume_id)
snapshot = conn.create_volume_snapshot(volume,
name=name,
**libcloud_kwargs)
return _simple_volume_snapshot(snapshot)
def destroy_volume_snapshot(volume_id, snapshot_id, profile,
**libcloud_kwargs):
'''
Destroy a volume snapshot.
:param volume_id: Volume ID from which the snapshot belongs
:type volume_id: ``str``
:param snapshot_id: Volume Snapshot ID from which to destroy
:type snapshot_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's destroy_volume_snapshot method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.destroy_volume_snapshot snap1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
volume = _get_by_id(conn.list_volumes(), volume_id)
snapshot = _get_by_id(conn.list_volume_snapshots(volume), snapshot_id)
return conn.destroy_volume_snapshot(snapshot, **libcloud_kwargs)
def balancer_attach_member(balancer_id, ip, port, profile, extra=None, **libcloud_kwargs):
'''
Add a new member to the load balancer
:param balancer_id: id of a load balancer you want to fetch
:type balancer_id: ``str``
:param ip: IP address for the new member
:type ip: ``str``
:param port: Port for the new member
:type port: ``int``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's balancer_attach_member method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.balancer_attach_member balancer123 1.2.3.4 80 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
member = Member(id=None, ip=ip, port=port, balancer=None, extra=extra)
balancer = conn.get_balancer(balancer_id)
member_saved = conn.balancer_attach_member(balancer, member, **libcloud_kwargs)
return _simple_member(member_saved)
def get_balancer_by_name(name, profile, **libcloud_kwargs):
'''
Get the details for a load balancer by name
:param name: Name of a load balancer you want to fetch
:type name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_balancers method
:type libcloud_kwargs: ``dict``
:return: the load balancer details
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.get_balancer_by_name my_balancer profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
balancers = conn.list_balancers(**libcloud_kwargs)
match = [b for b in balancers if b.name == name]
if len(match) == 1:
return _simple_balancer(match[0])
elif len(match) > 1:
raise ValueError("Ambiguous argument, found mulitple records")
else:
raise ValueError("Bad argument, found no records")
def get_balancer(balancer_id, profile, **libcloud_kwargs):
'''
Get the details for a load balancer by ID
:param balancer_id: id of a load balancer you want to fetch
:type balancer_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's get_balancer method
:type libcloud_kwargs: ``dict``
:return: the load balancer details
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.get_balancer balancer123 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
balancer = conn.get_balancer(balancer_id, **libcloud_kwargs)
return _simple_balancer(balancer)
def list_images(profile, location_id=None, **libcloud_kwargs):
'''
Return a list of images for this cloud
:param profile: The profile key
:type profile: ``str``
:param location_id: The location key, from list_locations
:type location_id: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_images method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.list_images profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
if location_id is not None:
location = _get_by_id(conn.list_locations(), location_id)
else:
location = None
images = conn.list_images(location=location, **libcloud_kwargs)
ret = []
for image in images:
ret.append(_simple_image(image))
return ret
def destroy_balancer(balancer_id, profile, **libcloud_kwargs):
'''
Destroy a load balancer
:param balancer_id: LoadBalancer ID which should be used
:type balancer_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's destroy_balancer method
:type libcloud_kwargs: ``dict``
:return: ``True`` if the destroy was successful, otherwise ``False``.
:rtype: ``bool``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.destroy_balancer balancer_1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
balancer = conn.get_balancer(balancer_id)
return conn.destroy_balancer(balancer, **libcloud_kwargs)
def delete_container(container_name, profile, **libcloud_kwargs):
'''
Delete an object container in the cloud
:param container_name: Container name
:type container_name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's delete_container method
:type libcloud_kwargs: ``dict``
:return: True if an object container has been successfully deleted, False
otherwise.
:rtype: ``bool``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.delete_container MyFolder profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
container = conn.get_container(container_name)
return conn.delete_container(container, **libcloud_kwargs)
def create_image(node_id, name, profile, description=None, **libcloud_kwargs):
'''
Create an image from a node
:param node_id: Node to run the task on.
:type node_id: ``str``
:param name: name for new image.
:type name: ``str``
:param profile: The profile key
:type profile: ``str``
:param description: description for new image.
:type description: ``description``
:param libcloud_kwargs: Extra arguments for the driver's create_image method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.create_image server1 my_image profile1
salt myminion libcloud_compute.create_image server1 my_image profile1 description='test image'
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
node = _get_by_id(conn.list_nodes(), node_id)
return _simple_image(
conn.create_image(node,
name,
description=description,
**libcloud_kwargs))
def import_key_pair(name, key, profile, key_type=None, **libcloud_kwargs):
'''
Import a new public key from string or a file path
:param name: Key pair name.
:type name: ``str``
:param key: Public key material, the string or a path to a file
:type key: ``str`` or path ``str``
:param profile: The profile key
:type profile: ``str``
:param key_type: The key pair type, either `FILE` or `STRING`. Will detect if not provided
and assume that if the string is a path to an existing path it is a FILE, else STRING.
:type key_type: ``str``
:param libcloud_kwargs: Extra arguments for the driver's import_key_pair_from_xxx method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.import_key_pair pair1 key_value_data123 profile1
salt myminion libcloud_compute.import_key_pair pair1 /path/to/key profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
if os.path.exists(key) or key_type == 'FILE':
return _simple_key_pair(
conn.import_key_pair_from_file(name, key, **libcloud_kwargs))
else:
return _simple_key_pair(
conn.import_key_pair_from_string(name, key, **libcloud_kwargs))
def get_container_object(container_name, object_name, profile,
**libcloud_kwargs):
'''
Get the details for a container object (file or object in the cloud)
:param container_name: Container name
:type container_name: ``str``
:param object_name: Object name
:type object_name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's get_container_object method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.get_container_object MyFolder MyFile.xyz profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
obj = conn.get_container_object(container_name, object_name,
**libcloud_kwargs)
return {
'name': obj.name,
'size': obj.size,
'hash': obj.hash,
'container': obj.container.name,
'extra': obj.extra,
'meta_data': obj.meta_data
}
def list_container_objects(container_name, profile, **libcloud_kwargs):
'''
List container objects (e.g. files) for the given container_id on the given profile
:param container_name: Container name
:type container_name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_container_objects method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.list_container_objects MyFolder profile1
'''
conn = _get_driver(profile=profile)
container = conn.get_container(container_name)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
objects = conn.list_container_objects(container, **libcloud_kwargs)
ret = []
for obj in objects:
ret.append({
'name': obj.name,
'size': obj.size,
'hash': obj.hash,
'container': obj.container.name,
'extra': obj.extra,
'meta_data': obj.meta_data
})
return ret
def all_removed(name, **kwargs):
'''
Removes all containers from the host. Note this also applies to containers that are not on any map.
name
State name - has no effect.
kwargs
Keyword arguments forwarded to ``container_map.remove_all_containers``.
'''
res = __salt__['container_map.remove_all_containers'](**clean_kwargs(**kwargs))
res['name'] = '__all__'
return res
def upload_object(file_path,
container_name,
object_name,
profile,
extra=None,
verify_hash=True,
headers=None,
**libcloud_kwargs):
'''
Upload an object currently located on a disk.
:param file_path: Path to the object on disk.
:type file_path: ``str``
:param container_name: Destination container.
:type container_name: ``str``
:param object_name: Object name.
:type object_name: ``str``
:param profile: The profile key
:type profile: ``str``
:param verify_hash: Verify hash
:type verify_hash: ``bool``
:param extra: Extra attributes (driver specific). (optional)
:type extra: ``dict``
:param headers: (optional) Additional request headers,
such as CORS headers. For example:
headers = {'Access-Control-Allow-Origin': 'http://mozilla.com'}
:type headers: ``dict``
:param libcloud_kwargs: Extra arguments for the driver's upload_object method
:type libcloud_kwargs: ``dict``
:return: The object name in the cloud
:rtype: ``str``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.upload_object /file/to/me.jpg MyFolder me.jpg profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
container = conn.get_container(container_name)
obj = conn.upload_object(file_path, container, object_name, extra,
verify_hash, headers, **libcloud_kwargs)
return obj.name
def all_removed(name, **kwargs):
'''
Removes all containers from the host. Note this also applies to containers that are not on any map.
name
State name - has no effect.
kwargs
Keyword arguments forwarded to ``container_map.remove_all_containers``.
'''
res = __salt__['container_map.remove_all_containers'](**clean_kwargs(
**kwargs))
res['name'] = '__all__'
return res
def download_object(container_name,
object_name,
destination_path,
profile,
overwrite_existing=False,
delete_on_failure=True,
**libcloud_kwargs):
'''
Download an object to the specified destination path.
:param container_name: Container name
:type container_name: ``str``
:param object_name: Object name
:type object_name: ``str``
:param destination_path: Full path to a file or a directory where the
incoming file will be saved.
:type destination_path: ``str``
:param profile: The profile key
:type profile: ``str``
:param overwrite_existing: True to overwrite an existing file,
defaults to False.
:type overwrite_existing: ``bool``
:param delete_on_failure: True to delete a partially downloaded file if
the download was not successful (hash
mismatch / file size).
:type delete_on_failure: ``bool``
:param libcloud_kwargs: Extra arguments for the driver's download_object method
:type libcloud_kwargs: ``dict``
:return: True if an object has been successfully downloaded, False
otherwise.
:rtype: ``bool``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.download_object MyFolder me.jpg /tmp/me.jpg profile1
'''
conn = _get_driver(profile=profile)
obj = conn.get_object(container_name, object_name)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
return conn.download_object(obj, destination_path, overwrite_existing,
delete_on_failure, **libcloud_kwargs)
def create_balancer(name, port, protocol, profile, algorithm=None, members=None, **libcloud_kwargs):
'''
Create a new load balancer instance
:param name: Name of the new load balancer (required)
:type name: ``str``
:param port: Port the load balancer should listen on, defaults to 80
:type port: ``str``
:param protocol: Loadbalancer protocol, defaults to http.
:type protocol: ``str``
:param algorithm: Load balancing algorithm, defaults to ROUND_ROBIN. See Algorithm type
in Libcloud documentation for a full listing.
:type algorithm: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's create_balancer method
:type libcloud_kwargs: ``dict``
:return: The details of the new balancer
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.create_balancer my_balancer 80 http profile1
'''
if algorithm is None:
algorithm = Algorithm.ROUND_ROBIN
else:
if isinstance(algorithm, six.string_types):
algorithm = _algorithm_maps()[algorithm]
starting_members = []
if members is not None:
if isinstance(members, list):
for m in members:
starting_members.append(Member(id=None, ip=m['ip'], port=m['port']))
else:
raise ValueError("members must be of type list")
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
conn = _get_driver(profile=profile)
balancer = conn.create_balancer(name, port, protocol, algorithm, starting_members, **libcloud_kwargs)
return _simple_balancer(balancer)
def _get_endpoint(endpoint, id=None, **kwargs):
username, password = _get_auth(kwargs.pop('username', None),
kwargs.pop('password', None))
kwargs = clean_kwargs(**kwargs)
url = _build_url(endpoint, id=id)
ret = {'comment': '', 'result': True, 'out': None}
res = salt.utils.http.query(url,
method='GET',
decode=True,
username=username,
password=password,
params=kwargs)
if 'error' in res:
ret.update({'result': False, 'comment': res['error']})
return ret
ret['out'] = res['dict']['data']
return ret
def hmset(key, **fieldsvals):
'''
Sets multiple hash fields to multiple values.
.. versionadded:: 2017.7.0
CLI Example:
.. code-block:: bash
salt '*' redis.hmset foo_hash bar_field1=bar_value1 bar_field2=bar_value2
'''
host = fieldsvals.pop('host', None)
port = fieldsvals.pop('port', None)
database = fieldsvals.pop('db', None)
password = fieldsvals.pop('password', None)
server = _connect(host, port, database, password)
return server.hmset(key, clean_kwargs(**fieldsvals))
def copy_image(source_region,
image_id,
name,
profile,
description=None,
**libcloud_kwargs):
'''
Copies an image from a source region to the current region.
:param source_region: Region to copy the node from.
:type source_region: ``str``
:param image_id: Image to copy.
:type image_id: ``str``
:param name: name for new image.
:type name: ``str``
:param profile: The profile key
:type profile: ``str``
:param description: description for new image.
:type name: ``str``
:param libcloud_kwargs: Extra arguments for the driver's copy_image method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.copy_image us-east1 image1 'new image' profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
image = conn.get_image(image_id, **libcloud_kwargs)
new_image = conn.copy_image(source_region,
image,
name,
description=description,
**libcloud_kwargs)
return _simple_image(new_image)
def create_volume(size, name, profile, location_id=None, **libcloud_kwargs):
'''
Create a storage volume
:param size: Size of volume in gigabytes (required)
:type size: ``int``
:param name: Name of the volume to be created
:type name: ``str``
:param location_id: Which data center to create a volume in. If
empty, undefined behavior will be selected.
(optional)
:type location_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_volumes method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.create_volume 1000 vol1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
if location_id is not None:
location = _get_by_id(conn.list_locations(), location_id)
else:
location = None
# TODO : Support creating from volume snapshot
volume = conn.create_volume(size,
name,
location,
snapshot=None,
**libcloud_kwargs)
return _simple_volume(volume)
def list_supported_algorithms(profile, **libcloud_kwargs):
'''
Get the supported algorithms for a profile
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_supported_algorithms method
:type libcloud_kwargs: ``dict``
:return: The supported algorithms
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.list_supported_algorithms profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
return conn.list_supported_algorithms(**libcloud_kwargs)
def list_protocols(profile, **libcloud_kwargs):
'''
Return a list of supported protocols.
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_protocols method
:type libcloud_kwargs: ``dict``
:return: a list of supported protocols
:rtype: ``list`` of ``str``
CLI Example:
.. code-block:: bash
salt myminion libcloud_storage.list_protocols profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
return conn.list_protocols(**libcloud_kwargs)
def create_key_pair(name, profile, **libcloud_kwargs):
'''
Create a single key pair by name
:param name: Name of the key pair to create.
:type name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's create_key_pair method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.create_key_pair pair1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
return _simple_key_pair(conn.create_key_pair(name, **libcloud_kwargs))
def get_image(image_id, profile, **libcloud_kwargs):
'''
Get an image of a node
:param image_id: Image to fetch
:type image_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's delete_image method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.get_image image1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
image = conn.get_image(image_id, **libcloud_kwargs)
return _simple_image(image)
def delete_image(image_id, profile, **libcloud_kwargs):
'''
Delete an image of a node
:param image_id: Image to delete
:type image_id: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's delete_image method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.delete_image image1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
image = _get_by_id(conn.list_images(), image_id)
return conn.delete_image(image, **libcloud_kwargs)
def list_nodes(profile, **libcloud_kwargs):
'''
Return a list of nodes
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's list_nodes method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.list_nodes profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
nodes = conn.list_nodes(**libcloud_kwargs)
ret = []
for node in nodes:
ret.append(_simple_node(node))
return ret
def extra(method, profile, **libcloud_kwargs):
'''
Call an extended method on the driver
:param method: Driver's method name
:type method: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.extra ex_get_permissions google container_name=my_container object_name=me.jpg --out=yaml
'''
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
conn = _get_driver(profile=profile)
connection_method = getattr(conn, method)
return connection_method(**libcloud_kwargs)
def delete_key_pair(name, profile, **libcloud_kwargs):
'''
Delete a key pair
:param name: Key pair name.
:type name: ``str``
:param profile: The profile key
:type profile: ``str``
:param libcloud_kwargs: Extra arguments for the driver's import_key_pair_from_xxx method
:type libcloud_kwargs: ``dict``
CLI Example:
.. code-block:: bash
salt myminion libcloud_compute.delete_key_pair pair1 profile1
'''
conn = _get_driver(profile=profile)
libcloud_kwargs = clean_kwargs(**libcloud_kwargs)
key = conn.get_key_pair(name)
return conn.delete_key_pair(key, **libcloud_kwargs)
def run(*args, **kwargs):
'''
Execute a puppet run and return a dict with the stderr, stdout,
return code, etc. The first positional argument given is checked as a
subcommand. Following positional arguments should be ordered with arguments
required by the subcommand first, followed by non-keyvalue pair options.
Tags are specified by a tag keyword and comma separated list of values. --
http://projects.puppetlabs.com/projects/1/wiki/Using_Tags
CLI Examples::
salt '*' puppet.run
salt '*' puppet.run tags=basefiles::edit,apache::server
salt '*' puppet.run debug
salt '*' puppet.run apply /a/b/manifest.pp modulepath=/a/b/modules tags=basefiles::edit,apache::server
'''
_check_puppet()
puppet = _Puppet()
if args:
# based on puppet documentation action must come first. making the same
# assertion. need to ensure the list of supported cmds here matches those
# defined in _Puppet.arguments()
if args[0] in ['agent', 'apply']:
puppet.subcmd = args[0]
puppet.arguments(args[1:])
else:
# args will exist as an empty list even if none have been provided
puppet.arguments(args)
puppet.kwargs.update(utils.clean_kwargs(**kwargs))
return __salt__['cmd.run_all'](repr(puppet))
def _get_endpoint(endpoint, id=None, **kwargs):
username, password = _get_auth(kwargs.pop('username', None),
kwargs.pop('password', None))
kwargs = clean_kwargs(**kwargs)
url = _build_url(endpoint, id=id)
ret = {
'comment': '',
'result': True,
'out': None
}
res = salt.utils.http.query(url,
method='GET',
decode=True,
username=username,
password=password,
params=kwargs)
if 'error' in res:
ret.update({
'result': False,
'comment': res['error']
})
return ret
ret['out'] = res['dict']['data']
return ret
def test_clean_kwargs(self):
self.assertDictEqual(utils.clean_kwargs(foo="bar"), {"foo": "bar"})
self.assertDictEqual(utils.clean_kwargs(__pub_foo="bar"), {})
self.assertDictEqual(utils.clean_kwargs(__foo_bar="gwar"), {"__foo_bar": "gwar"})
def test_clean_kwargs(self):
self.assertDictEqual(utils.clean_kwargs(foo='bar'), {'foo': 'bar'})
self.assertDictEqual(utils.clean_kwargs(__pub_foo='bar'), {})
self.assertDictEqual(utils.clean_kwargs(__foo_bar='gwar'), {'__foo_bar': 'gwar'})
