golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils

File/Folder	Size	Actions
__init__.py	237 B
__pycache__	-
aggregation.py	5.17 KB
ansible.py	1.48 KB
args.py	18.33 KB
asynchronous.py	4.06 KB
atomicfile.py	5.33 KB
aws.py	20.37 KB
azurearm.py	11.42 KB
beacons.py	517 B
boto3mod.py	8.36 KB
boto_elb_tag.py	3.02 KB
botomod.py	7.98 KB
cache.py	11.49 KB
channel.py	489 B
cloud.py	116.3 KB
color.py	2.72 KB
compat.py	1.89 KB
configcomparer.py	3.88 KB
configparser.py	10.82 KB
context.py	6.8 KB
crypt.py	5 KB
ctx.py	1.42 KB
data.py	53.03 KB
dateutils.py	2.3 KB
debug.py	4.19 KB
decorators	-
dictdiffer.py	16.48 KB
dicttrim.py	3.9 KB
dictupdate.py	11.33 KB
dns.py	35.21 KB
doc.py	2.25 KB
dockermod	-
entrypoints.py	1.83 KB
environment.py	2.2 KB
error.py	1.18 KB
etcd_util.py	33.25 KB
event.py	52.45 KB
extend.py	8.87 KB
extmods.py	6.04 KB
filebuffer.py	3.15 KB
files.py	27.94 KB
find.py	22.08 KB
fsutils.py	3.29 KB
functools.py	6.02 KB
gitfs.py	130.41 KB
github.py	1.52 KB
gzip_util.py	2.86 KB
hashutils.py	5.91 KB
http.py	33.9 KB
iam.py	1.22 KB
icinga2.py	754 B
idem.py	1.22 KB
immutabletypes.py	2.46 KB
itertools.py	2.36 KB
jid.py	3 KB
jinja.py	33.92 KB
job.py	6.89 KB
json.py	3.78 KB
kickstart.py	41.04 KB
kinds.py	493 B
lazy.py	3.06 KB
listdiffer.py	10.9 KB
locales.py	2.06 KB
mac_utils.py	14.01 KB
mako.py	3.97 KB
master.py	29.7 KB
mattermost.py	1.77 KB
memcached.py	3.56 KB
migrations.py	1.46 KB
mine.py	3.68 KB
minion.py	4.13 KB
minions.py	43.38 KB
mount.py	1.15 KB
msazure.py	5.36 KB
msgpack.py	4.69 KB
nacl.py	13.65 KB
namecheap.py	4.32 KB
napalm.py	23.22 KB
nb_popen.py	7.24 KB
network.py	73.86 KB
nxos.py	12.94 KB
nxos_api.py	4 KB
odict.py	13.21 KB
openstack	-
oset.py	6.41 KB
pagerduty.py	3.03 KB
parsers.py	122.69 KB
path.py	11.24 KB
pbm.py	9.81 KB
pkg	-
platform.py	5.84 KB
powershell.py	4.15 KB
preseed.py	2.64 KB
process.py	40.76 KB
profile.py	3.21 KB
proxy.py	331 B
psutil_compat.py	3.63 KB
pushover.py	4.51 KB
pycrypto.py	5.41 KB
pydsl.py	13.74 KB
pyobjects.py	10.75 KB
reactor.py	18.99 KB
reclass.py	752 B
roster_matcher.py	3.55 KB
rsax931.py	8.42 KB
s3.py	8.78 KB
saltclass.py	14.27 KB
sanitizers.py	2.51 KB
schedule.py	71.81 KB
schema.py	54.26 KB
sdb.py	4.04 KB
slack.py	3.58 KB
smb.py	11.16 KB
smtp.py	3.27 KB
ssdp.py	14.75 KB
ssh.py	769 B
state.py	8.43 KB
stringio.py	355 B
stringutils.py	16.95 KB
systemd.py	5.51 KB
templates.py	24.03 KB
textformat.py	5.03 KB
thin.py	31.91 KB
timed_subprocess.py	4.06 KB
timeout.py	1.53 KB
timeutil.py	2.4 KB
url.py	5 KB
user.py	11.86 KB
validate	-
value.py	247 B
vault.py	21.74 KB
verify.py	25.34 KB
versions.py	17.17 KB
virt.py	3.24 KB
virtualbox.py	22.43 KB
vmware.py	129.74 KB
vsan.py	17.18 KB
vt.py	31.47 KB
vt_helper.py	4.4 KB
win_chcp.py	3.7 KB
win_dacl.py	95.49 KB
win_dotnet.py	4.74 KB
win_functions.py	12.69 KB
win_lgpo_auditpol.py	8.48 KB
win_lgpo_netsh.py	17.87 KB
win_lgpo_reg.py	16.98 KB
win_network.py	16.35 KB
win_osinfo.py	2.83 KB
win_pdh.py	13.85 KB
win_reg.py	30.82 KB
win_runas.py	10.53 KB
win_service.py	5.2 KB
win_system.py	14.47 KB
win_update.py	40.36 KB
winapi.py	818 B
x509.py	73.19 KB
xdg.py	316 B
xmlutil.py	13.91 KB
yaml.py	349 B
yamldumper.py	3.37 KB
yamlencoding.py	1.55 KB
yamllint.py	1.61 KB
yamlloader.py	6.04 KB
yamlloader_old.py	8.15 KB
yast.py	619 B
zeromq.py	1.74 KB
zfs.py	19.15 KB

Edit: virtualbox.py

"""
Utilities to help make requests to virtualbox

The virtualbox SDK reference can be found at http://download.virtualbox.org/virtualbox/SDKRef.pdf

This code assumes vboxapi.py from VirtualBox distribution
being in PYTHONPATH, or installed system-wide
"""

import logging
import re
import time

import salt.utils.compat
import salt.utils.data
from salt.utils.timeout import wait_for

log = logging.getLogger(__name__)

HAS_LIBS = False
try:
    import vboxapi

HAS_LIBS = True

except ImportError:
    VirtualBoxManager = None
    log.trace("Couldn't import VirtualBox API")

_virtualboxManager = None

"""
Attributes we expect to have when converting an XPCOM object to a dict
"""
XPCOM_ATTRIBUTES = {
    "IMachine": [
        "id",
        "name",
        "accessible",
        "description",
        "groups",
        "memorySize",
        "OSTypeId",
        "state",
    ],
    "INetworkAdapter": [
        "adapterType",
        "slot",
        "enabled",
        "MACAddress",
        "bridgedInterface",
        "hostOnlyInterface",
        "internalNetwork",
        "NATNetwork",
        "genericDriver",
        "cableConnected",
        "lineSpeed",
        "lineSpeed",
    ],
}

UNKNOWN_MACHINE_STATE = ("Unknown", "This state is unknown to us. Might be new?")
MACHINE_STATE_LIST = [
    ("Null", "Null value (never used by the API)"),
    (
        "PoweredOff",
        "The machine is not running and has no saved execution state; "
        "it has either never been started or been shut down successfully.",
    ),
    (
        "Saved",
        "The machine is not currently running, but the execution state of the machine"
        " has been saved to an external file when it was running, from where it can be"
        " resumed.",
    ),
    (
        "Teleported",
        "The machine was teleported to a different host (or process) and then powered"
        " off. Take care when powering it on again may corrupt resources it shares with"
        " the teleportation target (e.g. disk and network).",
    ),
    (
        "Aborted",
        "The process running the machine has terminated abnormally. This may indicate a"
        " crash of the VM process in host execution context, or the VM process has been"
        " terminated externally.",
    ),
    ("Running", "The machine is currently being executed."),
    ("Paused", "Execution of the machine has been paused."),
    (
        "Stuck",
        "Execution of the machine has reached the 'Guru Meditation' condition. This"
        " indicates a severe error in the hypervisor itself.",
    ),
    (
        "Teleporting",
        "The machine is about to be teleported to a different host or process. It is"
        " possible to pause a machine in this state, but it will go to the"
        " TeleportingPausedVM state and it will not be possible to resume it again"
        " unless the teleportation fails.",
    ),
    (
        "LiveSnapshotting",
        "A live snapshot is being taken. The machine is running normally, but some of"
        " the runtime configuration options are inaccessible. Also, if paused while in"
        " this state it will transition to OnlineSnapshotting and it will not be resume"
        " the execution until the snapshot operation has completed.",
    ),
    (
        "Starting",
        "Machine is being started after powering it on from a zero execution state.",
    ),
    (
        "Stopping",
        "Machine is being normally stopped powering it off, or after the guest OS has"
        " initiated a shutdown sequence.",
    ),
    ("Saving", "Machine is saving its execution state to a file."),
    (
        "Restoring",
        "Execution state of the machine is being restored from a file after powering it"
        " on from the saved execution state.",
    ),
    (
        "TeleportingPausedVM",
        "The machine is being teleported to another host or process, but it is not "
        "running. This is the paused variant of the Teleporting state.",
    ),
    ("TeleportingIn", "Teleporting the machine state in from another host or process."),
    (
        "FaultTolerantSyncing",
        "The machine is being synced with a fault tolerant VM running else-where.",
    ),
    (
        "DeletingSnapshotOnline",
        "Like DeletingSnapshot , but the merging of media is ongoing in the "
        "background while the machine is running.",
    ),
    (
        "DeletingSnapshotPaused",
        "Like DeletingSnapshotOnline , but the machine was paused when "
        "the merging of differencing media was started.",
    ),
    (
        "OnlineSnapshotting",
        "Like LiveSnapshotting , but the machine was paused when the merging "
        "of differencing media was started.",
    ),
    (
        "RestoringSnapshot",
        "A machine snapshot is being restored; this typically does not take long.",
    ),
    (
        "DeletingSnapshot",
        "A machine snapshot is being deleted; this can take a long time since this may"
        " require merging differencing media. This value indicates that the machine is"
        " not running while the snapshot is being deleted.",
    ),
    ("SettingUp", "Lengthy setup operation is in progress."),
    ("Snapshotting", "Taking an (offline) snapshot."),
    (
        "FirstOnline",
        "Pseudo-state: first online state (for use in relational expressions).",
    ),
    (
        "LastOnline",
        "Pseudo-state: last online state (for use in relational expressions).",
    ),
    (
        "FirstTransient",
        "Pseudo-state: first transient state (for use in relational expressions).",
    ),
    (
        "LastTransient",
        "Pseudo-state: last transient state (for use in relational expressions).",
    ),
]
MACHINE_STATES = dict(MACHINE_STATE_LIST)

"""
Dict of states {
    <number>: ( <name>, <description> )
}
"""
MACHINE_STATES_ENUM = dict(enumerate(MACHINE_STATE_LIST))

def vb_get_manager():
    """
    Creates a 'singleton' manager to communicate with a local virtualbox hypervisor.
    @return:
    @rtype: VirtualBoxManager
    """
    global _virtualboxManager
    if _virtualboxManager is None and HAS_LIBS:
        salt.utils.compat.reload(vboxapi)
        _virtualboxManager = vboxapi.VirtualBoxManager(None, None)

return _virtualboxManager

def vb_get_box():
    """
    Needed for certain operations in the SDK e.g creating sessions
    @return:
    @rtype: IVirtualBox
    """
    vb_get_manager()

try:
        # This works in older versions of the SDK, but does not seem to work anymore.
        vbox = _virtualboxManager.vbox
    except AttributeError:
        vbox = _virtualboxManager.getVirtualBox()

return vbox

def vb_get_max_network_slots():
    """
    Max number of slots any machine can have
    @return:
    @rtype: number
    """
    sysprops = vb_get_box().systemProperties
    totals = [
        sysprops.getMaxNetworkAdapters(adapter_type)
        for adapter_type in [
            1,  # PIIX3 A PIIX3 (PCI IDE ISA Xcelerator) chipset.
            2,  # ICH9 A ICH9 (I/O Controller Hub) chipset
        ]
    ]
    return sum(totals)

def vb_get_network_adapters(machine_name=None, machine=None):
    """
    A valid machine_name or a machine is needed to make this work!

@param machine_name:
    @type machine_name: str
    @param machine:
    @type machine: IMachine
    @return: INetorkAdapter's converted to dicts
    @rtype: [dict]
    """

if machine_name:
        machine = vb_get_box().findMachine(machine_name)
    network_adapters = []

for i in range(vb_get_max_network_slots()):
        try:
            inetwork_adapter = machine.getNetworkAdapter(i)
            network_adapter = vb_xpcom_to_attribute_dict(
                inetwork_adapter, "INetworkAdapter"
            )
            network_adapter["properties"] = inetwork_adapter.getProperties("")
            network_adapters.append(network_adapter)
        except Exception:  # pylint: disable=broad-except
            pass

return network_adapters

def vb_wait_for_network_address(
    timeout, step=None, machine_name=None, machine=None, wait_for_pattern=None
):
    """
    Wait until a machine has a network address to return or quit after the timeout

@param timeout: in seconds
    @type timeout: float
    @param step: How regularly we want to check for ips (in seconds)
    @type step: float
    @param machine_name:
    @type machine_name: str
    @param machine:
    @type machine: IMachine
    @type wait_for_pattern: str
    @param wait_for_pattern:
    @type machine: str
    @return:
    @rtype: list
    """
    kwargs = {
        "machine_name": machine_name,
        "machine": machine,
        "wait_for_pattern": wait_for_pattern,
    }
    return wait_for(
        vb_get_network_addresses,
        timeout=timeout,
        step=step,
        default=[],
        func_kwargs=kwargs,
    )

def _check_session_state(xp_session, expected_state="Unlocked"):
    """
    @param xp_session:
    @type xp_session: ISession from the Virtualbox API
    @param expected_state: The constant descriptor according to the docs
    @type expected_state: str
    @return:
    @rtype: bool
    """
    state_value = getattr(
        _virtualboxManager.constants, "SessionState_" + expected_state
    )
    return xp_session.state == state_value

def vb_wait_for_session_state(xp_session, state="Unlocked", timeout=10, step=None):
    """
    Waits until a session state has been reached, checking at regular intervals.

@param xp_session:
    @type xp_session: ISession from the Virtualbox API
    @param state: The constant descriptor according to the docs
    @type state: str
    @param timeout: in seconds
    @type timeout: int | float
    @param step: Intervals at which the value is checked
    @type step: int | float
    @return: Did we reach the state?
    @rtype: bool
    """
    args = (xp_session, state)
    wait_for(
        _check_session_state, timeout=timeout, step=step, default=False, func_args=args
    )

def vb_get_network_addresses(machine_name=None, machine=None, wait_for_pattern=None):
    """
    TODO distinguish between private and public addresses

A valid machine_name or a machine is needed to make this work!

!!!
    Guest prerequisite: GuestAddition
    !!!

Thanks to Shrikant Havale for the StackOverflow answer http://stackoverflow.com/a/29335390

More information on guest properties: https://www.virtualbox.org/manual/ch04.html#guestadd-guestprops

@param machine_name:
    @type machine_name: str
    @param machine:
    @type machine: IMachine
    @return: All the IPv4 addresses we could get
    @rtype: str[]
    """
    if machine_name:
        machine = vb_get_box().findMachine(machine_name)

ip_addresses = []
    log.debug("checking for power on:")
    if machine.state == _virtualboxManager.constants.MachineState_Running:

log.debug("got power on:")

# wait on an arbitrary named property
        # for instance use a dhcp client script to set a property via VBoxControl guestproperty set dhcp_done 1
        if wait_for_pattern and not machine.getGuestPropertyValue(wait_for_pattern):
            log.debug("waiting for pattern:%s:", wait_for_pattern)
            return None

_total_slots = machine.getGuestPropertyValue("/VirtualBox/GuestInfo/Net/Count")

# upon dhcp the net count drops to 0 and it takes some seconds for it to be set again
        if not _total_slots:
            log.debug("waiting for net count:%s:", wait_for_pattern)
            return None

try:
            total_slots = int(_total_slots)
            for i in range(total_slots):
                try:
                    address = machine.getGuestPropertyValue(
                        "/VirtualBox/GuestInfo/Net/{}/V4/IP".format(i)
                    )
                    if address:
                        ip_addresses.append(address)
                except Exception as e:  # pylint: disable=broad-except
                    log.debug(e.message)
        except ValueError as e:
            log.debug(e.message)
            return None

log.debug("returning ip_addresses:%s:", ip_addresses)
    return ip_addresses

def vb_list_machines(**kwargs):
    """
    Which machines does the hypervisor have
    @param kwargs: Passed to vb_xpcom_to_attribute_dict to filter the attributes
    @type kwargs: dict
    @return: Untreated dicts of the machines known to the hypervisor
    @rtype: [{}]
    """
    manager = vb_get_manager()
    machines = manager.getArray(vb_get_box(), "machines")
    return [
        vb_xpcom_to_attribute_dict(machine, "IMachine", **kwargs)
        for machine in machines
    ]

def vb_create_machine(name=None):
    """
    Creates a machine on the virtualbox hypervisor

TODO pass more params to customize machine creation
    @param name:
    @type name: str
    @return: Representation of the created machine
    @rtype: dict
    """
    vbox = vb_get_box()
    log.info("Create virtualbox machine %s ", name)
    groups = None
    os_type_id = "Other"
    new_machine = vbox.createMachine(
        None, name, groups, os_type_id, None  # Settings file  # flags
    )
    vbox.registerMachine(new_machine)
    log.info("Finished creating %s", name)
    return vb_xpcom_to_attribute_dict(new_machine, "IMachine")

def vb_clone_vm(name=None, clone_from=None, clone_mode=0, timeout=10000, **kwargs):
    """
    Tells virtualbox to create a VM by cloning from an existing one

@param name: Name for the new VM
    @type name: str
    @param clone_from:
    @type clone_from: str
    @param timeout: maximum time in milliseconds to wait or -1 to wait indefinitely
    @type timeout: int
    @return dict of resulting VM
    """
    vbox = vb_get_box()
    log.info("Clone virtualbox machine %s from %s", name, clone_from)

source_machine = vbox.findMachine(clone_from)

groups = None
    os_type_id = "Other"
    new_machine = vbox.createMachine(
        None, name, groups, os_type_id, None  # Settings file  # flags
    )

progress = source_machine.cloneTo(
        new_machine, clone_mode, None  # CloneMode  # CloneOptions : None = Full?
    )

progress.waitForCompletion(timeout)
    log.info("Finished cloning %s from %s", name, clone_from)

vbox.registerMachine(new_machine)

return vb_xpcom_to_attribute_dict(new_machine, "IMachine")

def _start_machine(machine, session):
    """
    Helper to try and start machines

@param machine:
    @type machine: IMachine
    @param session:
    @type session: ISession
    @return:
    @rtype: IProgress or None
    """
    try:
        return machine.launchVMProcess(session, "", "")
    except Exception as e:  # pylint: disable=broad-except
        log.debug(e.message, exc_info=True)
        return None

def vb_start_vm(name=None, timeout=10000, **kwargs):
    """
    Tells Virtualbox to start up a VM.
    Blocking function!

@param name:
    @type name: str
    @param timeout: Maximum time in milliseconds to wait or -1 to wait indefinitely
    @type timeout: int
    @return untreated dict of started VM
    """
    # Time tracking
    start_time = time.time()
    timeout_in_seconds = timeout / 1000
    max_time = start_time + timeout_in_seconds

vbox = vb_get_box()
    machine = vbox.findMachine(name)
    session = _virtualboxManager.getSessionObject(vbox)

log.info(
        "Starting machine %s in state %s", name, vb_machinestate_to_str(machine.state)
    )
    try:
        # Keep trying to start a machine
        args = (machine, session)
        progress = wait_for(_start_machine, timeout=timeout_in_seconds, func_args=args)
        if not progress:
            progress = machine.launchVMProcess(session, "", "")

# We already waited for stuff, don't push it
        time_left = max_time - time.time()
        progress.waitForCompletion(time_left * 1000)
    finally:
        _virtualboxManager.closeMachineSession(session)

# The session state should best be unlocked otherwise subsequent calls might cause problems
    time_left = max_time - time.time()
    vb_wait_for_session_state(session, timeout=time_left)
    log.info("Started machine %s", name)

return vb_xpcom_to_attribute_dict(machine, "IMachine")

def vb_stop_vm(name=None, timeout=10000, **kwargs):
    """
    Tells Virtualbox to stop a VM.
    This is a blocking function!

@param name:
    @type name: str
    @param timeout: Maximum time in milliseconds to wait or -1 to wait indefinitely
    @type timeout: int
    @return untreated dict of stopped VM
    """
    vbox = vb_get_box()
    machine = vbox.findMachine(name)
    log.info("Stopping machine %s", name)
    session = _virtualboxManager.openMachineSession(machine)
    try:
        console = session.console
        progress = console.powerDown()
        progress.waitForCompletion(timeout)
    finally:
        _virtualboxManager.closeMachineSession(session)
        vb_wait_for_session_state(session)
    log.info(
        "Stopped machine %s is now %s", name, vb_machinestate_to_str(machine.state)
    )
    return vb_xpcom_to_attribute_dict(machine, "IMachine")

def vb_destroy_machine(name=None, timeout=10000):
    """
    Attempts to get rid of a machine and all its files from the hypervisor
    @param name:
    @type name: str
    @param timeout int timeout in milliseconds
    """
    vbox = vb_get_box()
    log.info("Destroying machine %s", name)
    machine = vbox.findMachine(name)
    files = machine.unregister(2)
    progress = machine.deleteConfig(files)
    progress.waitForCompletion(timeout)
    log.info("Finished destroying machine %s", name)

def vb_xpcom_to_attribute_dict(
    xpcom,
    interface_name=None,
    attributes=None,
    excluded_attributes=None,
    extra_attributes=None,
):
    """
    Attempts to build a dict from an XPCOM object.
    Attributes that don't exist in the object return an empty string.

attribute_list = list of str or tuple(str,<a class>)

e.g attributes=[('bad_attribute', list)] --> { 'bad_attribute': [] }

@param xpcom:
    @type xpcom:
    @param interface_name: Which interface we will be converting from.
                           Without this it's best to specify the list of attributes you want
    @type interface_name: str
    @param attributes: Overrides the attributes used from XPCOM_ATTRIBUTES
    @type attributes: attribute_list
    @param excluded_attributes: Which should be excluded in the returned dict.
                                !!These take precedence over extra_attributes!!
    @type excluded_attributes: attribute_list
    @param extra_attributes: Which should be retrieved in addition those already being retrieved
    @type extra_attributes: attribute_list
    @return:
    @rtype: dict
    """
    # Check the interface
    if interface_name:
        m = re.search(r"XPCOM.+implementing {}".format(interface_name), str(xpcom))
        if not m:
            # TODO maybe raise error here?
            log.warning(
                "Interface %s is unknown and cannot be converted to dict",
                interface_name,
            )
            return dict()

interface_attributes = set(attributes or XPCOM_ATTRIBUTES.get(interface_name, []))
    if extra_attributes:
        interface_attributes = interface_attributes.union(extra_attributes)
    if excluded_attributes:
        interface_attributes = interface_attributes.difference(excluded_attributes)

attribute_tuples = []
    for attribute in interface_attributes:
        if isinstance(attribute, tuple):
            attribute_name = attribute[0]
            attribute_class = attribute[1]
            value = (attribute_name, getattr(xpcom, attribute_name, attribute_class()))
        else:
            value = (attribute, getattr(xpcom, attribute, ""))
        attribute_tuples.append(value)

return dict(attribute_tuples)

def treat_machine_dict(machine):
    """
    Make machine presentable for outside world.

!!!Modifies the input machine!!!

@param machine:
    @type machine: dict
    @return: the modified input machine
    @rtype: dict
    """
    machine.update(
        {
            "id": machine.get("id", ""),
            "image": machine.get("image", ""),
            "size": "{} MB".format(machine.get("memorySize", 0)),
            "state": machine_get_machinestate_str(machine),
            "private_ips": [],
            "public_ips": [],
        }
    )

# Replaced keys
    if "memorySize" in machine:
        del machine["memorySize"]
    return machine

def vb_machinestate_to_str(machinestate):
    """
    Put a name to the state

@param machinestate: from the machine state enum from XPCOM
    @type machinestate: int
    @return:
    @rtype: str
    """

return vb_machinestate_to_tuple(machinestate)[0]

def vb_machinestate_to_description(machinestate):
    """
    Describe the given state

@param machinestate: from the machine state enum from XPCOM
    @type machinestate: int | str
    @return:
    @rtype: str
    """
    return vb_machinestate_to_tuple(machinestate)[1]

def vb_machinestate_to_tuple(machinestate):
    """

@param machinestate:
    @type machinestate: int | str
    @return:
    @rtype: tuple(<name>, <description>)
    """
    if isinstance(machinestate, int):
        ret = MACHINE_STATES_ENUM.get(machinestate, UNKNOWN_MACHINE_STATE)
    elif isinstance(machinestate, str):
        ret = MACHINE_STATES.get(machinestate, UNKNOWN_MACHINE_STATE)
    else:
        ret = UNKNOWN_MACHINE_STATE
    return salt.utils.data.decode(ret, preserve_tuples=True)

def machine_get_machinestate_tuple(machinedict):
    return vb_machinestate_to_tuple(machinedict.get("state"))

def machine_get_machinestate_str(machinedict):
    return vb_machinestate_to_str(machinedict.get("state"))

def vb_machine_exists(name):
    """
    Checks in with the hypervisor to see if the machine with the given name is known
    @param name:
    @type name:
    @return:
    @rtype:
    """
    try:
        vbox = vb_get_box()
        vbox.findMachine(name)
        return True
    except Exception as e:  # pylint: disable=broad-except
        if isinstance(e.message, str):
            message = e.message
        elif hasattr(e, "msg") and isinstance(getattr(e, "msg"), str):
            message = getattr(e, "msg")
        else:
            message = ""
        if 0 > message.find("Could not find a registered machine named"):
            log.error(message)

return False

def vb_get_machine(name, **kwargs):
    """
    Attempts to fetch a machine from Virtualbox and convert it to a dict

@param name: The unique name of the machine
    @type name:
    @param kwargs: To be passed to vb_xpcom_to_attribute_dict
    @type kwargs:
    @return:
    @rtype: dict
    """
    vbox = vb_get_box()
    machine = vbox.findMachine(name)
    return vb_xpcom_to_attribute_dict(machine, "IMachine", **kwargs)