| Dir : /proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/cloud/clouds/ |
| Server: Linux ngx353.inmotionhosting.com 4.18.0-553.22.1.lve.1.el8.x86_64 #1 SMP Tue Oct 8 15:52:54 UTC 2024 x86_64 IP: 209.182.202.254 |
| Dir : //proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/cloud/clouds/vagrant.py |
"""
Vagrant Cloud Driver
====================
The Vagrant cloud is designed to "vagrant up" a virtual machine as a
Salt minion.
Use of this module requires some configuration in cloud profile and provider
files as described in the
:ref:`Getting Started with Vagrant <getting-started-with-vagrant>` documentation.
.. versionadded:: 2018.3.0
"""
import logging
import os
import tempfile
import salt.client
import salt.config as config
import salt.utils.cloud
from salt._compat import ipaddress
from salt.exceptions import SaltCloudException, SaltCloudSystemExit, SaltInvocationError
log = logging.getLogger(__name__)
def __virtual__():
"""
Needs no special configuration
"""
return True
def _get_active_provider_name():
try:
return __active_provider_name__.value()
except AttributeError:
return __active_provider_name__
def avail_locations(call=None):
r"""
This function returns a list of locations available.
CLI Example:
.. code-block:: bash
salt-cloud --list-locations my-cloud-provider
# \[ vagrant will always returns an empty dictionary \]
"""
return {}
def avail_images(call=None):
"""This function returns a list of images available for this cloud provider.
vagrant will return a list of profiles.
salt-cloud --list-images my-cloud-provider
"""
vm_ = get_configured_provider()
return {"Profiles": [profile for profile in vm_["profiles"]]}
def avail_sizes(call=None):
r"""
This function returns a list of sizes available for this cloud provider.
CLI Example:
.. code-block:: bash
salt-cloud --list-sizes my-cloud-provider
# \[ vagrant always returns an empty dictionary \]
"""
return {}
def list_nodes(call=None):
"""
List the nodes which have salt-cloud:driver:vagrant grains.
CLI Example:
.. code-block:: bash
salt-cloud -Q
"""
nodes = _list_nodes(call)
return _build_required_items(nodes)
def _build_required_items(nodes):
ret = {}
for name, grains in nodes.items():
if grains:
private_ips = []
public_ips = []
ips = grains["ipv4"] + grains["ipv6"]
for adrs in ips:
ip_ = ipaddress.ip_address(adrs)
if not ip_.is_loopback:
if ip_.is_private:
private_ips.append(adrs)
else:
public_ips.append(adrs)
ret[name] = {
"id": grains["id"],
"image": grains["salt-cloud"]["profile"],
"private_ips": private_ips,
"public_ips": public_ips,
"size": "",
"state": "running",
}
return ret
def list_nodes_full(call=None):
"""
List the nodes, ask all 'vagrant' minions, return dict of grains (enhanced).
CLI Example:
.. code-block:: bash
salt-call -F
"""
ret = _list_nodes(call)
for (
key,
grains,
) in ret.items(): # clean up some hyperverbose grains -- everything is too much
try:
del (
grains["cpu_flags"],
grains["disks"],
grains["pythonpath"],
grains["dns"],
grains["gpus"],
)
except KeyError:
pass # ignore absence of things we are eliminating
except TypeError:
del ret[key] # eliminate all reference to unexpected (None) values.
reqs = _build_required_items(ret)
for name in ret:
ret[name].update(reqs[name])
return ret
def _list_nodes(call=None):
"""
List the nodes, ask all 'vagrant' minions, return dict of grains.
"""
with salt.client.LocalClient() as local:
return local.cmd(
"salt-cloud:driver:vagrant", "grains.items", "", tgt_type="grain"
)
def list_nodes_select(call=None):
"""
Return a list of the minions that have salt-cloud grains, with
select fields.
"""
return salt.utils.cloud.list_nodes_select(
list_nodes_full("function"),
__opts__["query.selection"],
call,
)
def show_instance(name, call=None):
"""
List the a single node, return dict of grains.
"""
with salt.client.LocalClient() as local:
ret = local.cmd(name, "grains.items", "")
reqs = _build_required_items(ret)
ret[name].update(reqs[name])
return ret
def _get_my_info(name):
with salt.client.LocalClient() as local:
return local.cmd(name, "grains.get", ["salt-cloud"])
def create(vm_):
"""
Provision a single machine
CLI Example:
.. code-block:: bash
salt-cloud -p my_profile new_node_1
"""
name = vm_["name"]
machine = config.get_cloud_config_value("machine", vm_, __opts__, default="")
vm_["machine"] = machine
host = config.get_cloud_config_value("host", vm_, __opts__, default=NotImplemented)
vm_["cwd"] = config.get_cloud_config_value("cwd", vm_, __opts__, default="/")
vm_["runas"] = config.get_cloud_config_value(
"vagrant_runas", vm_, __opts__, default=os.getenv("SUDO_USER")
)
vm_["timeout"] = config.get_cloud_config_value(
"vagrant_up_timeout", vm_, __opts__, default=300
)
vm_["vagrant_provider"] = config.get_cloud_config_value(
"vagrant_provider", vm_, __opts__, default=""
)
vm_["grains"] = {"salt-cloud:vagrant": {"host": host, "machine": machine}}
log.info("sending 'vagrant.init %s machine=%s' command to %s", name, machine, host)
with salt.client.LocalClient() as local:
ret = local.cmd(host, "vagrant.init", [name], kwarg={"vm": vm_, "start": True})
log.info("response ==> %s", ret[host])
network_mask = config.get_cloud_config_value(
"network_mask", vm_, __opts__, default=""
)
if "ssh_host" not in vm_:
ret = local.cmd(
host,
"vagrant.get_ssh_config",
[name],
kwarg={"network_mask": network_mask, "get_private_key": True},
)[host]
with tempfile.NamedTemporaryFile() as pks:
if "private_key" not in vm_ and ret and ret.get("private_key", False):
pks.write(ret["private_key"])
pks.flush()
log.debug("wrote private key to %s", pks.name)
vm_["key_filename"] = pks.name
if "ssh_host" not in vm_:
try:
vm_.setdefault("ssh_username", ret["ssh_username"])
if ret.get("ip_address"):
vm_["ssh_host"] = ret["ip_address"]
else: # if probe failed or not used, use Vagrant's reported ssh info
vm_["ssh_host"] = ret["ssh_host"]
vm_.setdefault("ssh_port", ret["ssh_port"])
except (KeyError, TypeError):
raise SaltInvocationError(
f"Insufficient SSH addressing information for {name}"
)
log.info(
"Provisioning machine %s as node %s using ssh %s",
machine,
name,
vm_["ssh_host"],
)
ret = __utils__["cloud.bootstrap"](vm_, __opts__)
return ret
def get_configured_provider():
"""
Return the first configured instance.
"""
ret = config.is_provider_configured(
__opts__, _get_active_provider_name() or "vagrant", ""
)
return ret
# noinspection PyTypeChecker
def destroy(name, call=None):
"""
Destroy a node.
CLI Example:
.. code-block:: bash
salt-cloud --destroy mymachine
"""
if call == "function":
raise SaltCloudSystemExit(
"The destroy action must be called with -d, --destroy, -a, or --action."
)
opts = __opts__
__utils__["cloud.fire_event"](
"event",
"destroying instance",
f"salt/cloud/{name}/destroying",
args={"name": name},
sock_dir=opts["sock_dir"],
transport=opts["transport"],
)
my_info = _get_my_info(name)
if my_info:
profile_name = my_info[name]["profile"]
profile = opts["profiles"][profile_name]
host = profile["host"]
with salt.client.LocalClient() as local:
ret = local.cmd(host, "vagrant.destroy", [name])
if ret[host]:
__utils__["cloud.fire_event"](
"event",
"destroyed instance",
f"salt/cloud/{name}/destroyed",
args={"name": name},
sock_dir=opts["sock_dir"],
transport=opts["transport"],
)
if opts.get("update_cachedir", False) is True:
__utils__["cloud.delete_minion_cachedir"](
name, _get_active_provider_name().split(":")[0], opts
)
return {"Destroyed": f"{name} was destroyed."}
else:
return {"Error": f"Error destroying {name}"}
else:
return {"Error": f"No response from {name}. Cannot destroy."}
# noinspection PyTypeChecker
def reboot(name, call=None):
"""
Reboot a vagrant minion.
name
The name of the VM to reboot.
CLI Example:
.. code-block:: bash
salt-cloud -a reboot vm_name
"""
if call != "action":
raise SaltCloudException(
"The reboot action must be called with -a or --action."
)
my_info = _get_my_info(name)
profile_name = my_info[name]["profile"]
profile = __opts__["profiles"][profile_name]
host = profile["host"]
with salt.client.LocalClient() as local:
return local.cmd(host, "vagrant.reboot", [name])