ansible/xoxys.general
1
0
Fork 0
Code Issues Pull Requests Releases 17 Activity
dff4b91525
xoxys.general/plugins/modules/proxmox_kvm.py

1336 lines
49 KiB
Python
Raw Normal View History

add custom modules
2020-08-18 21:44:49 +00:00
# -*- coding: utf-8 -*-
# Copyright (c) 2016, Abdoul Bah (@helldorado) <bahabdoul at gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
"""Module to control Proxmox KVM machines."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import re
import time
import traceback
from ansible.module_utils._text import to_native
from ansible.module_utils.basic import AnsibleModule
__metaclass__ = type
ANSIBLE_METADATA = {"metadata_version": "1.1", "status": ["preview"], "supported_by": "community"}
DOCUMENTATION = """
---
module: proxmox_kvm
short_description: Management of Qemu(KVM) Virtual Machines in Proxmox VE cluster.
description:
- Allows you to create/delete/stop Qemu(KVM) Virtual Machines in Proxmox VE cluster.
version_added: "2.3"
author: "Abdoul Bah (@helldorado) <bahabdoul at gmail.com>, Thijs Cramer <thijs.cramer at gmail.com>"
options:
acpi:
description:
- Specify if ACPI should be enabled/disabled.
type: bool
default: "yes"
agent:
description:
- Specify if the QEMU Guest Agent should be enabled/disabled.
type: bool
args:
description:
- Pass arbitrary arguments to kvm.
- This option is for experts only!
default: "-serial unix:/var/run/qemu-server/VMID.serial,server,nowait"
api_host:
description:
- Specify the target host of the Proxmox VE cluster.
required: true
api_user:
description:
- Specify the user to authenticate with.
required: true
api_password:
description:
- Specify the password to authenticate with.
- You can use C(PROXMOX_PASSWORD) environment variable.
autostart:
description:
- Specify if the VM should be automatically restarted after crash (currently ignored in PVE API).
type: bool
default: "no"
balloon:
description:
- Specify the amount of RAM for the VM in MB.
- Using zero disables the balloon driver.
default: 0
bios:
description:
- Specify the BIOS implementation.
choices: ["seabios", "ovmf"]
boot:
description:
- Specify the boot order -> boot on floppy C(a), hard disk C(c), CD-ROM C(d), or network C(n).
- You can combine to set order.
default: cnd
bootdisk:
description:
- Enable booting from specified disk. C((ide|sata|scsi|virtio)\d+)
ciuser:
version_added: 2.6
description:
- Set username used in Cloud-Init Config.
cipassword:
version_added: 2.6
description:
- Set password used in Cloud-Init Config (NOT RECOMMENDED, use sshkeys instead).
citype:
version_added: 2.6
description:
- Specifies the cloud-init configuration format.
choices: ["nocloud", "configdrive2"]
clone:
description:
- Name of VM to be cloned. If C(vmid) is setted, C(clone) can take arbitrary value but required for intiating the clone.
cores:
description:
- Specify number of cores per socket.
default: 1
cpu:
description:
- Specify emulated CPU type.
default: kvm64
cpulimit:
description:
- Specify if CPU usage will be limited. Value 0 indicates no CPU limit.
- If the computer has 2 CPUs, it has total of "2" CPU time
cpuunits:
description:
- Specify CPU weight for a VM.
- You can disable fair-scheduler configuration by setting this to 0
default: 1000
delete:
description:
- Specify a list of settings you want to delete.
description:
description:
- Specify the description for the VM. Only used on the configuration web interface.
- This is saved as comment inside the configuration file.
digest:
description:
- Specify if to prevent changes if current configuration file has different SHA1 digest.
- This can be used to prevent concurrent modifications.
force:
description:
- Allow to force stop VM.
- Can be used only with states C(stopped), C(restarted).
type: bool
format:
description:
- Target drive"s backing file"s data format.
- Used only with clone
default: qcow2
choices: [ "cloop", "cow", "qcow", "qcow2", "qed", "raw", "vmdk" ]
freeze:
description:
- Specify if PVE should freeze CPU at startup (use "c" monitor command to start execution).
type: bool
full:
description:
- Create a full copy of all disk. This is always done when you clone a normal VM.
- For VM templates, we try to create a linked clone by default.
- Used only with clone
type: bool
default: "yes"
hostpci:
description:
- Specify a hash/dictionary of map host pci devices into guest. C(hostpci="{"key":"value", "key":"value"}").
- Keys allowed are - C(hostpci[n]) where 0 ≤ n ≤ N.
- Values allowed are - C("host="HOSTPCIID[;HOSTPCIID2...]",pcie="1|0",rombar="1|0",x-vga="1|0"").
- The C(host) parameter is Host PCI device pass through. HOSTPCIID syntax is C(bus:dev.func) (hexadecimal numbers).
- C(pcie=boolean) I(default=0) Choose the PCI-express bus (needs the q35 machine model).
- C(rombar=boolean) I(default=1) Specify whether or not the device"s ROM will be visible in the guest"s memory map.
- C(x-vga=boolean) I(default=0) Enable vfio-vga device support.
- /!\ This option allows direct access to host hardware. So it is no longer possible to migrate such machines - use with special care.
hotplug:
description:
- Selectively enable hotplug features.
- This is a comma separated list of hotplug features C("network", "disk", "cpu", "memory" and "usb").
- Value 0 disables hotplug completely and value 1 is an alias for the default C("network,disk,usb").
hugepages:
description:
- Enable/disable hugepages memory.
choices: ["any", "2", "1024"]
ide:
description:
- A hash/dictionary of volume used as IDE hard disk or CD-ROM. C(ide="{"key":"value", "key":"value"}").
- Keys allowed are - C(ide[n]) where 0 ≤ n ≤ 3.
- Values allowed are - C("storage:size,format=value").
- C(storage) is the storage identifier where to create the disk.
- C(size) is the size of the disk in GB.
- C(format) is the drive"s backing file"s data format. C(qcow2|raw|subvol).
ipconfig:
version_added: 2.6
description:
- A hash/dictionary of ip"s used in the Cloud-Init Configuration.
- Keys allowed are - C(ipconfig[n]).
- "Values allowed are - C("gw=IP/CIDR,gw6=IP6/CIDR,ip=IP/CIDR,ip6=IP/CIDR")."
- C(gw) is the IPv4 Default Gateway.
- C(gw6) is the IPv6 Default Gateway.
- C(ip) is the IPv4 IP Address.
- C(ip6) is the IPv6 IP Address.
keyboard:
description:
- Sets the keyboard layout for VNC server.
kvm:
description:
- Enable/disable KVM hardware virtualization.
type: bool
default: "yes"
localtime:
description:
- Sets the real time clock to local time.
- This is enabled by default if ostype indicates a Microsoft OS.
type: bool
lock:
description:
- Lock/unlock the VM.
choices: ["migrate", "backup", "snapshot", "rollback"]
machine:
description:
- Specifies the Qemu machine type.
- type => C((pc|pc(-i440fx)?-\d+\.\d+(\.pxe)?|q35|pc-q35-\d+\.\d+(\.pxe)?))
memory:
description:
- Memory size in MB for instance.
default: 512
migrate_downtime:
description:
- Sets maximum tolerated downtime (in seconds) for migrations.
migrate_speed:
description:
- Sets maximum speed (in MB/s) for migrations.
- A value of 0 is no limit.
name:
description:
- Specifies the VM name. Only used on the configuration web interface.
- Required only for C(state=present).
nameserver:
version_added: 2.6
description:
- Specifies the DNS Nameserver used by Cloud-Init Config.
net:
description:
- A hash/dictionary of network interfaces for the VM. C(net="{"key":"value", "key":"value"}").
- Keys allowed are - C(net[n]) where 0 ≤ n ≤ N.
- Values allowed are - C("model="XX:XX:XX:XX:XX:XX",brigde="value",rate="value",tag="value",firewall="1|0",trunks="vlanid"").
- Model is one of C(e1000 e1000-82540em e1000-82544gc e1000-82545em i82551 i82557b i82559er ne2k_isa ne2k_pci pcnet rtl8139 virtio vmxnet3).
- C(XX:XX:XX:XX:XX:XX) should be an unique MAC address. This is automatically generated if not specified.
- The C(bridge) parameter can be used to automatically add the interface to a bridge device. The Proxmox VE standard bridge is called "vmbr0".
- Option C(rate) is used to limit traffic bandwidth from and to this interface. It is specified as floating point number, unit is "Megabytes per second".
- If you specify no bridge, we create a kvm "user" (NATed) network device, which provides DHCP and DNS services.
newid:
description:
- VMID for the clone. Used only with clone.
- If newid is not set, the next available VM ID will be fetched from ProxmoxAPI.
node:
description:
- Proxmox VE node, where the new VM will be created.
- Only required for C(state=present).
- For other states, it will be autodiscovered.
numa:
description:
- A hash/dictionaries of NUMA topology. C(numa="{"key":"value", "key":"value"}").
- Keys allowed are - C(numa[n]) where 0 ≤ n ≤ N.
- Values allowed are - C("cpu="<id[-id];...>",hostnodes="<id[-id];...>",memory="number",policy="(bind|interleave|preferred)"").
- C(cpus) CPUs accessing this NUMA node.
- C(hostnodes) Host NUMA nodes to use.
- C(memory) Amount of memory this NUMA node provides.
- C(policy) NUMA allocation policy.
onboot:
description:
- Specifies whether a VM will be started during system bootup.
type: bool
default: "yes"
ostype:
description:
- Specifies guest operating system. This is used to enable special optimization/features for specific operating systems.
- The l26 is Linux 2.6/3.X Kernel.
choices: ["other", "wxp", "w2k", "w2k3", "w2k8", "wvista", "win7", "win8", "l24", "l26", "solaris"]
default: l26
parallel:
description:
- A hash/dictionary of map host parallel devices. C(parallel="{"key":"value", "key":"value"}").
- Keys allowed are - (parallel[n]) where 0 ≤ n ≤ 2.
- Values allowed are - C("/dev/parport\d+|/dev/usb/lp\d+").
pool:
description:
- Add the new VM to the specified pool.
protection:
description:
- Enable/disable the protection flag of the VM. This will enable/disable the remove VM and remove disk operations.
type: bool
reboot:
description:
- Allow reboot. If set to C(yes), the VM exit on reboot.
type: bool
revert:
description:
- Revert a pending change.
sata:
description:
- A hash/dictionary of volume used as sata hard disk or CD-ROM. C(sata="{"key":"value", "key":"value"}").
- Keys allowed are - C(sata[n]) where 0 ≤ n ≤ 5.
- Values allowed are - C("storage:size,format=value").
- C(storage) is the storage identifier where to create the disk.
- C(size) is the size of the disk in GB.
- C(format) is the drive"s backing file"s data format. C(qcow2|raw|subvol).
scsi:
description:
- A hash/dictionary of volume used as SCSI hard disk or CD-ROM. C(scsi="{"key":"value", "key":"value"}").
- Keys allowed are - C(sata[n]) where 0 ≤ n ≤ 13.
- Values allowed are - C("storage:size,format=value").
- C(storage) is the storage identifier where to create the disk.
- C(size) is the size of the disk in GB.
- C(format) is the drive"s backing file"s data format. C(qcow2|raw|subvol).
scsihw:
description:
- Specifies the SCSI controller model.
choices: ["lsi", "lsi53c810", "virtio-scsi-pci", "virtio-scsi-single", "megasas", "pvscsi"]
searchdomain:
version_added: 2.6
description:
- The DNS Search Domain used by Cloud-Init Config.
serial:
description:
- A hash/dictionary of serial device to create inside the VM. C("{"key":"value", "key":"value"}").
- Keys allowed are - serial[n](str; required) where 0 ≤ n ≤ 3.
- Values allowed are - C((/dev/.+|socket)).
- /!\ If you pass through a host serial device, it is no longer possible to migrate such machines - use with special care.
shares:
description:
- Rets amount of memory shares for auto-ballooning. (0 - 50000).
- The larger the number is, the more memory this VM gets.
- The number is relative to weights of all other running VMs.
- Using 0 disables auto-ballooning, this means no limit.
skiplock:
description:
- Ignore locks
- Only root is allowed to use this option.
smbios:
description:
- Specifies SMBIOS type 1 fields.
snapname:
description:
- The name of the snapshot. Used only with clone.
sockets:
description:
- Sets the number of CPU sockets. (1 - N).
default: 1
sshkeys:
version_added: 2.6
description:
- The SSH Keys used by Cloud-Init Config (OpenSSH Format).
startdate:
description:
- Sets the initial date of the real time clock.
- Valid format for date are C("now") or C("2016-09-25T16:01:21") or C("2016-09-25").
startup:
description:
- Startup and shutdown behavior. C([[order=]\d+] [,up=\d+] [,down=\d+]).
- Order is a non-negative number defining the general startup order.
- Shutdown in done with reverse ordering.
state:
description:
- Indicates desired state of the instance.
- If C(current), the current state of the VM will be fecthed. You can access it with C(results.status)
choices: ["present", "started", "absent", "stopped", "restarted","current"]
default: present
storage:
description:
- Target storage for full clone.
tablet:
description:
- Enables/disables the USB tablet device.
type: bool
default: "no"
target:
description:
- Target node. Only allowed if the original VM is on shared storage.
- Used only with clone
tdf:
description:
- Enables/disables time drift fix.
type: bool
template:
description:
- Enables/disables the template.
type: bool
default: "no"
timeout:
description:
- Timeout for operations.
default: 30
update:
description:
- If C(yes), the VM will be update with new value.
- Cause of the operations of the API and security reasons, I have disabled the update of the following parameters
- C(net, virtio, ide, sata, scsi). Per example updating C(net) update the MAC address and C(virtio) create always new disk...
type: bool
default: "no"
validate_certs:
description:
- If C(no), SSL certificates will not be validated. This should only be used on personally controlled sites using self-signed certificates.
type: bool
default: "no"
vcpus:
description:
- Sets number of hotplugged vcpus.
vga:
description:
- Select VGA type. If you want to use high resolution modes (>= 1280x1024x16) then you should use option "std" or "vmware".
choices: ["std", "cirrus", "vmware", "qxl", "serial0", "serial1", "serial2", "serial3", "qxl2", "qxl3", "qxl4"]
default: std
virtio:
description:
- A hash/dictionary of volume used as VIRTIO hard disk. C(virtio="{"key":"value", "key":"value"}").
- Keys allowed are - C(virto[n]) where 0 ≤ n ≤ 15.
- Values allowed are - C("storage:size,format=value").
- C(storage) is the storage identifier where to create the disk.
- C(size) is the size of the disk in GB.
- C(format) is the drive"s backing file"s data format. C(qcow2|raw|subvol).
vmid:
description:
- Specifies the VM ID. Instead use I(name) parameter.
- If vmid is not set, the next available VM ID will be fetched from ProxmoxAPI.
watchdog:
description:
- Creates a virtual hardware watchdog device.
requirements: [ "proxmoxer", "requests" ]
""" # noqa
EXAMPLES = """
# Create new VM with minimal options
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
# Create new VM with minimal options and given vmid
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
vmid : 100
# Create new VM with two network interface options.
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
net : "{"net0":"virtio,bridge=vmbr1,rate=200", "net1":"e1000,bridge=vmbr2,"}"
# Create new VM with one network interface, three virto hard disk, 4 cores, and 2 vcpus.
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
net : "{"net0":"virtio,bridge=vmbr1,rate=200"}"
virtio : "{"virtio0":"VMs_LVM:10", "virtio1":"VMs:2,format=qcow2", "virtio2":"VMs:5,format=raw"}"
cores : 4
vcpus : 2
# Clone VM with only source VM name
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
clone : spynal # The VM source
name : zavala # The target VM name
node : sabrewulf
storage : VMs
format : qcow2
timeout : 500 # Note: The task can take a while. Adapt
# Clone VM with source vmid and target newid and raw format
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
clone : arbitrary_name
vmid : 108
newid : 152
name : zavala # The target VM name
node : sabrewulf
storage : LVM_STO
format : raw
timeout : 300 # Note: The task can take a while. Adapt
# Create new VM and lock it for snapashot.
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
lock : snapshot
# Create new VM and set protection to disable the remove VM and remove disk operations
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
protection : yes
# Start VM
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : started
# Stop VM
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : stopped
# Stop VM with force
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : stopped
force : yes
# Restart VM
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : restarted
# Remove VM
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : absent
# Get VM current state
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
state : current
# Update VM configuration
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
cpu : 8
memory : 16384
update : yes
# Delete QEMU parameters
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
delete : "args,template,cpulimit"
# Revert a pending change
- proxmox_kvm:
api_user : root@pam
api_password: secret
api_host : helldorado
name : spynal
node : sabrewulf
revert : "template,cpulimit"
""" # noqa
RETURN = """
devices:
description: The list of devices created or used.
returned: success
type: dict
sample: "
{
"ide0": "VMS_LVM:vm-115-disk-1",
"ide1": "VMs:115/vm-115-disk-3.raw",
"virtio0": "VMS_LVM:vm-115-disk-2",
"virtio1": "VMs:115/vm-115-disk-1.qcow2",
"virtio2": "VMs:115/vm-115-disk-2.raw"
}"
mac:
description: List of mac address created and net[n] attached. Useful when you want to use provision systems like Foreman via PXE.
returned: success
type: dict
sample: "
{
"net0": "3E:6E:97:D2:31:9F",
"net1": "B6:A1:FC:EF:78:A4"
}"
vmid:
description: The VM vmid.
returned: success
type: int
sample: 115
status:
description:
- The current virtual machine status.
- Returned only when C(state=current)
returned: success
type: dict
sample: "{
"changed": false,
"msg": "VM kropta with vmid = 110 is running",
"status": "running"
}"
""" # noqa
try:
from proxmoxer import ProxmoxAPI
HAS_PROXMOXER = True
except ImportError:
HAS_PROXMOXER = False
VZ_TYPE = "qemu"
def get_nextvmid(module, proxmox):
try:
vmid = proxmox.cluster.nextid.get()
return vmid
except Exception as e:
module.fail_json(
msg="Unable to get next vmid. Failed with exception: {}".format(to_native(e)),
exception=traceback.format_exc()
)
def get_vmid(proxmox, name):
return [vm["vmid"] for vm in proxmox.cluster.resources.get(type="vm") if vm["name"] == name]
def get_vm(proxmox, vmid):
return [vm for vm in proxmox.cluster.resources.get(type="vm") if vm["vmid"] == int(vmid)]
def node_check(proxmox, node):
return [True for nd in proxmox.nodes.get() if nd["node"] == node]
def get_vminfo(module, proxmox, node, vmid, **kwargs):
global results # noqa
results = {}
mac = {}
devices = {}
try:
vm = proxmox.nodes(node).qemu(vmid).config.get()
except Exception as e:
module.fail_json(
msg="Getting information for VM with vmid={0} failed with exception: {1}".
format(vmid, e)
)
# Sanitize kwargs. Remove not defined args and ensure True and False converted to int.
kwargs = dict((k, v) for k, v in kwargs.items() if v is not None)
# Convert all dict in kwargs to elements.
# For hostpci[n], ide[n], ipconfig[n], net[n], numa[n],
# parallel[n], sata[n], scsi[n], serial[n], virtio[n] ## noqa
for k in kwargs.keys():
if isinstance(kwargs[k], dict):
kwargs.update(kwargs[k])
del kwargs[k]
# Split information by type
for k, v in kwargs.items():
if re.match(r"net[0-9]", k) is not None:
interface = k
k = vm[k]
k = re.search("=(.*?),", k).group(1)
mac[interface] = k
if (
re.match(r"virtio[0-9]", k) is not None or re.match(r"ide[0-9]", k) is not None
or re.match(r"ipconfig[0-9]", k) is not None or re.match(r"scsi[0-9]", k) is not None
or re.match(r"sata[0-9]", k) is not None
):
device = k
k = vm[k]
k = re.search("(.*?),", k).group(1)
devices[device] = k
results["mac"] = mac
results["devices"] = devices
results["vmid"] = int(vmid)
def settings(module, proxmox, vmid, node, name, timeout, **kwargs):
proxmox_node = proxmox.nodes(node)
# Sanitize kwargs. Remove not defined args and ensure True and False converted to int.
kwargs = dict((k, v) for k, v in kwargs.items() if v is not None)
if getattr(proxmox_node, VZ_TYPE)(vmid).config.set(**kwargs) is None:
return True
else:
return False
def create_vm(
module, proxmox, vmid, newid, node, name, memory, cpu, cores, sockets, timeout, update,
**kwargs
):
# Available only in PVE 4
only_v4 = ["force", "protection", "skiplock"]
# valide clone parameters
valid_clone_params = ["format", "full", "pool", "snapname", "storage", "target"]
clone_params = {}
# Default args for vm. Note: -args option is for experts only.
# It allows you to pass arbitrary arguments to kvm.
vm_args = "-serial unix:/var/run/qemu-server/{}.serial,server,nowait".format(vmid)
proxmox_node = proxmox.nodes(node)
# Sanitize kwargs. Remove not defined args and ensure True and False converted to int.
kwargs = dict((k, v) for k, v in kwargs.items() if v is not None)
kwargs.update(dict([k, int(v)] for k, v in kwargs.items() if isinstance(v, bool)))
# Verify Cloud-Init support
if PVE_FULL_VERSION < 5.2: # noqa
if (
"ciuser" in kwargs or "cipassword" in kwargs or "citype" in kwargs
or "ipconfig" in kwargs or "nameserver" in kwargs or "searchdomain" in kwargs
or "sshkeys" in kwargs
):
module.fail_json(
msg="Cloud-Init is not supported on Proxmox Versions"
" older than 5.2, your version: {}".format(PVE_FULL_VERSION) # noqa
)
# The features work only on PVE 4
if PVE_MAJOR_VERSION < 4: # noqa
for p in only_v4:
if p in kwargs:
del kwargs[p]
# If update, don"t update disk (virtio, ide, sata, scsi) and network interface
if update:
if "virtio" in kwargs:
del kwargs["virtio"]
if "sata" in kwargs:
del kwargs["sata"]
if "scsi" in kwargs:
del kwargs["scsi"]
if "ide" in kwargs:
del kwargs["ide"]
# Convert all dict in kwargs to elements.
# For hostpci[n], ide[n], net[n], numa[n], parallel[n],
# sata[n], scsi[n], serial[n], virtio[n] ## noqa
for k in kwargs.keys():
if isinstance(kwargs[k], dict):
kwargs.update(kwargs[k])
del kwargs[k]
# Rename numa_enabled to numa. According the API documentation
if "numa_enabled" in kwargs:
kwargs["numa"] = kwargs["numa_enabled"]
del kwargs["numa_enabled"]
# -args and skiplock require root@pam user
if module.params["api_user"] == "root@pam" and module.params["args"] is None:
if not update:
kwargs["args"] = vm_args
elif module.params["api_user"] == "root@pam" and module.params["args"] is not None:
kwargs["args"] = module.params["args"]
elif module.params["api_user"] != "root@pam" and module.params["args"] is not None:
module.fail_json(msg="args parameter require root@pam user. ")
if module.params["api_user"] != "root@pam" and module.params["skiplock"] is not None:
module.fail_json(msg="skiplock parameter require root@pam user. ")
if update:
if getattr(proxmox_node, VZ_TYPE)(vmid).config.set(
name=name, memory=memory, cpu=cpu, cores=cores, sockets=sockets, **kwargs
) is None:
return True
else:
return False
elif module.params["clone"] is not None:
for param in valid_clone_params:
if module.params[param] is not None:
clone_params[param] = module.params[param]
clone_params.update(
dict([k, int(v)] for k, v in clone_params.items() if isinstance(v, bool))
)
taskid = proxmox_node.qemu(vmid).clone.post(newid=newid, name=name, **clone_params)
else:
taskid = getattr(proxmox_node, VZ_TYPE).create(
vmid=vmid, name=name, memory=memory, cpu=cpu, cores=cores, sockets=sockets, **kwargs
)
while timeout:
if (
proxmox_node.tasks(taskid).status.get()["status"] == "stopped"
and proxmox_node.tasks(taskid).status.get()["exitstatus"] == "OK"
):
return True
timeout = timeout - 1
if timeout == 0:
module.fail_json(
msg="Reached timeout while waiting for creating VM."
" Last line in task before timeout: {}".
format(proxmox_node.tasks(taskid).log.get()[:1])
)
time.sleep(1)
return False
def start_vm(module, proxmox, vm, vmid, timeout):
taskid = getattr(proxmox.nodes(vm[0]["node"]), VZ_TYPE)(vmid).status.start.post()
while timeout:
if (
proxmox.nodes(vm[0]["node"]).tasks(taskid).status.get()["status"] == "stopped"
and proxmox.nodes(vm[0]["node"]).tasks(taskid).status.get()["exitstatus"] == "OK"
):
return True
timeout -= 1
if timeout == 0:
message = (
"Reached timeout while waiting for starting VM."
" Last line in task before timeout: {}".format(
proxmox.nodes(vm[0]["node"]).tasks(taskid).log.get()[:1]
)
)
module.fail_json(msg=message)
time.sleep(1)
return False
def stop_vm(module, proxmox, vm, vmid, timeout, force):
if force:
taskid = getattr(proxmox.nodes(vm[0]["node"]),
VZ_TYPE)(vmid).status.shutdown.post(forceStop=1)
else:
taskid = getattr(proxmox.nodes(vm[0]["node"]), VZ_TYPE)(vmid).status.shutdown.post()
while timeout:
if (
proxmox.nodes(vm[0]["node"]).tasks(taskid).status.get()["status"] == "stopped"
and proxmox.nodes(vm[0]["node"]).tasks(taskid).status.get()["exitstatus"] == "OK"
):
return True
timeout -= 1
if timeout == 0:
message = (
"Reached timeout while waiting for stopping VM."
" Last line in task before timeout: {}".format(
proxmox.nodes(vm[0]["node"]).tasks(taskid).log.get()[:1]
)
)
module.fail_json(msg=message)
time.sleep(1)
return False
def main():
module = AnsibleModule(
argument_spec=dict(
acpi=dict(type="bool", default="yes"),
agent=dict(type="bool"),
args=dict(type="str", default=None),
api_host=dict(required=True),
api_user=dict(required=True),
api_password=dict(no_log=True),
autostart=dict(type="bool", default="no"),
balloon=dict(type="int", default=0),
bios=dict(choices=["seabios", "ovmf"]),
boot=dict(type="str", default="cnd"),
bootdisk=dict(type="str"),
ciuser=dict(type="str", default="root"),
cipassword=dict(type="str"),
citype=dict(type="str", default=None, choices=["nocloud", "configdrive2"]),
clone=dict(type="str", default=None),
cores=dict(type="int", default=1),
cpu=dict(type="str", default="kvm64"),
cpulimit=dict(type="int"),
cpuunits=dict(type="int", default=1000),
delete=dict(type="str", default=None),
description=dict(type="str"),
digest=dict(type="str"),
force=dict(type="bool", default=None),
format=dict(
type="str",
default="qcow2",
choices=["cloop", "cow", "qcow", "qcow2", "qed", "raw", "vmdk"]
),
freeze=dict(type="bool"),
full=dict(type="bool", default="yes"),
hostpci=dict(type="dict"),
hotplug=dict(type="str"),
hugepages=dict(choices=["any", "2", "1024"]),
ide=dict(type="dict", default=None),
ipconfig=dict(type="dict", default=None),
keyboard=dict(type="str"),
kvm=dict(type="bool", default="yes"),
localtime=dict(type="bool"),
lock=dict(choices=["migrate", "backup", "snapshot", "rollback"]),
machine=dict(type="str"),
memory=dict(type="int", default=512),
migrate_downtime=dict(type="int"),
migrate_speed=dict(type="int"),
name=dict(type="str"),
nameserver=dict(type="str"),
net=dict(type="dict"),
newid=dict(type="int", default=None),
node=dict(),
numa=dict(type="dict"),
numa_enabled=dict(type="bool"),
onboot=dict(type="bool", default="yes"),
ostype=dict(
default="l26",
choices=[
"other", "wxp", "w2k", "w2k3", "w2k8", "wvista", "win7", "win8", "l24", "l26",
"solaris"
]
),
parallel=dict(type="dict"),
pool=dict(type="str"),
protection=dict(type="bool"),
reboot=dict(type="bool"),
revert=dict(type="str", default=None),
sata=dict(type="dict"),
scsi=dict(type="dict"),
scsihw=dict(
choices=[
"lsi", "lsi53c810", "virtio-scsi-pci", "virtio-scsi-single", "megasas",
"pvscsi"
]
),
searchdomain=dict(type="str"),
serial=dict(type="dict"),
shares=dict(type="int"),
skiplock=dict(type="bool"),
smbios=dict(type="str"),
snapname=dict(type="str"),
sockets=dict(type="int", default=1),
sshkeys=dict(type="str"),
startdate=dict(type="str"),
startup=dict(),
state=dict(
default="present",
choices=["present", "absent", "stopped", "started", "restarted", "current"]
),
storage=dict(type="str"),
tablet=dict(type="bool", default="no"),
target=dict(type="str"),
tdf=dict(type="bool"),
template=dict(type="bool", default="no"),
timeout=dict(type="int", default=30),
update=dict(type="bool", default="no"),
validate_certs=dict(type="bool", default="no"),
vcpus=dict(type="int", default=None),
vga=dict(
default="std",
choices=[
"std", "cirrus", "vmware", "qxl", "serial0", "serial1", "serial2", "serial3",
"qxl2", "qxl3", "qxl4"
]
),
virtio=dict(type="dict", default=None),
vmid=dict(type="int", default=None),
watchdog=dict(),
),
mutually_exclusive=[("delete", "revert"), ("delete", "update"), ("revert", "update"),
("clone", "update"), ("clone", "delete"), ("clone", "revert")],
required_one_of=[(
"name",
"vmid",
)],
required_if=[("state", "present", ["node"])]
)
if not HAS_PROXMOXER:
module.fail_json(msg="proxmoxer required for this module")
api_user = module.params["api_user"]
api_host = module.params["api_host"]
api_password = module.params["api_password"]
clone = module.params["clone"]
cpu = module.params["cpu"]
cores = module.params["cores"]
delete = module.params["delete"]
memory = module.params["memory"]
name = module.params["name"]
newid = module.params["newid"]
node = module.params["node"]
revert = module.params["revert"]
sockets = module.params["sockets"]
state = module.params["state"]
timeout = module.params["timeout"]
update = bool(module.params["update"])
vmid = module.params["vmid"]
validate_certs = module.params["validate_certs"]
# If password not set get it from PROXMOX_PASSWORD env
if not api_password:
try:
api_password = os.environ["PROXMOX_PASSWORD"]
except KeyError:
module.fail_json(
msg="You should set api_password param or use "
"PROXMOX_PASSWORD environment variable"
)
try:
proxmox = ProxmoxAPI(
api_host, user=api_user, password=api_password, verify_ssl=validate_certs
)
global VZ_TYPE
global PVE_MAJOR_VERSION # noqa
global PVE_FULL_VERSION # noqa
PVE_MAJOR_VERSION = 3 if float(proxmox.version.get()["version"]) < 4.0 else 4
PVE_FULL_VERSION = float(proxmox.version.get()["version"])
except Exception as e:
module.fail_json(
msg="authorization on proxmox cluster failed with exception: {}".format(e)
)
# If vmid not set get the Next VM id from ProxmoxAPI
# If vm name is set get the VM id from ProxmoxAPI
if not vmid:
if state == "present" and (not update and not clone) and (not delete and not revert):
try:
vmid = get_nextvmid(module, proxmox)
except Exception:
module.fail_json(
msg="Can't get the next vmid for VM{} automatically."
" Ensure your cluster state is good".format(name)
)
else:
try:
if not clone:
vmid = get_vmid(proxmox, name)[0]
else:
vmid = get_vmid(proxmox, clone)[0]
except Exception:
if not clone:
module.fail_json(msg="VM {} does not exist in cluster.".format(name))
else:
module.fail_json(msg="VM {} does not exist in cluster.".format(clone))
if clone is not None:
if get_vmid(proxmox, name):
module.exit_json(changed=False, msg="VM with name <{}> already exists".format(name))
if vmid is not None:
vm = get_vm(proxmox, vmid)
if not vm:
module.fail_json(msg="VM with vmid = {} does not exist in cluster".format(vmid))
if not newid:
try:
newid = get_nextvmid(module, proxmox)
except Exception:
module.fail_json(
msg="Can't get the next vmid for VM {} automatically."
" Ensure your cluster state is good".format(name)
)
else:
vm = get_vm(proxmox, newid)
if vm:
module.exit_json(
changed=False,
msg="vmid {0} with VM name {1} already exists".format(newid, name)
)
if delete is not None:
try:
settings(module, proxmox, vmid, node, name, timeout, delete=delete)
module.exit_json(
changed=True, msg="Settings has deleted on VM {} with vmid {}".format(name, vmid)
)
except Exception as e:
module.fail_json(
msg="Unable to delete settings on VM {} with vmid {}: {}".
format(name, vmid, str(e))
)
elif revert is not None:
try:
settings(module, proxmox, vmid, node, name, timeout, revert=revert)
module.exit_json(
changed=True, msg="Settings has reverted on VM {} with vmid {}".format(name, vmid)
)
except Exception as e:
module.fail_json(
msg="Unable to revert settings on VM {} with vmid {}:"
" Maybe is not a pending task... ".format(name, vmid) + str(e)
)
if state == "present":
try:
if get_vm(proxmox, vmid) and not (update or clone):
module.exit_json(
changed=False, msg="VM with vmid <{}> already exists".format(vmid)
)
elif get_vmid(proxmox, name) and not (update or clone):
module.exit_json(
changed=False, msg="VM with name <{}> already exists".format(name)
)
elif not (node, name):
module.fail_json(msg="node, name is mandatory for creating/updating vm")
elif not node_check(proxmox, node):
module.fail_json(msg="node '{}' does not exist in cluster".format(node))
create_vm(
module,
proxmox,
vmid,
newid,
node,
name,
memory,
cpu,
cores,
sockets,
timeout,
update,
acpi=module.params["acpi"],
agent=module.params["agent"],
autostart=module.params["autostart"],
balloon=module.params["balloon"],
bios=module.params["bios"],
boot=module.params["boot"],
bootdisk=module.params["bootdisk"],
ciuser=module.params["ciuser"],
cipassword=module.params["cipassword"],
citype=module.params["citype"],
cpulimit=module.params["cpulimit"],
cpuunits=module.params["cpuunits"],
description=module.params["description"],
digest=module.params["digest"],
force=module.params["force"],
freeze=module.params["freeze"],
hostpci=module.params["hostpci"],
hotplug=module.params["hotplug"],
hugepages=module.params["hugepages"],
ide=module.params["ide"],
ipconfig=module.params["ipconfig"],
keyboard=module.params["keyboard"],
kvm=module.params["kvm"],
localtime=module.params["localtime"],
lock=module.params["lock"],
machine=module.params["machine"],
migrate_downtime=module.params["migrate_downtime"],
migrate_speed=module.params["migrate_speed"],
nameserver=module.params["nameserver"],
net=module.params["net"],
numa=module.params["numa"],
numa_enabled=module.params["numa_enabled"],
onboot=module.params["onboot"],
ostype=module.params["ostype"],
parallel=module.params["parallel"],
pool=module.params["pool"],
protection=module.params["protection"],
reboot=module.params["reboot"],
sata=module.params["sata"],
scsi=module.params["scsi"],
scsihw=module.params["scsihw"],
searchdomain=module.params["searchdomain"],
serial=module.params["serial"],
shares=module.params["shares"],
skiplock=module.params["skiplock"],
smbios1=module.params["smbios"],
snapname=module.params["snapname"],
sshkeys=module.params["sshkeys"],
startdate=module.params["startdate"],
startup=module.params["startup"],
tablet=module.params["tablet"],
target=module.params["target"],
tdf=module.params["tdf"],
template=module.params["template"],
vcpus=module.params["vcpus"],
vga=module.params["vga"],
virtio=module.params["virtio"],
watchdog=module.params["watchdog"]
)
if not clone:
get_vminfo(
module,
proxmox,
node,
vmid,
ide=module.params["ide"],
net=module.params["net"],
sata=module.params["sata"],
scsi=module.params["scsi"],
virtio=module.params["virtio"]
)
if update:
module.exit_json(
changed=True, msg="VM {0} with vmid {1} updated".format(name, vmid)
)
elif clone is not None:
module.exit_json(
changed=True,
msg="VM {0} with newid {1} cloned from vm with vmid {2}".format(
name, newid, vmid
)
)
else:
module.exit_json(
changed=True,
msg="VM {0} with vmid {1} deployed".format(name, vmid),
**results # noqa
)
except Exception as e:
if update:
module.fail_json(
msg="Unable to update vm {0} with vmid {1}=".format(name, vmid) + str(e)
)
elif clone is not None:
module.fail_json(
msg="Unable to clone vm {0} from vmid {1}=".format(name, vmid) + str(e)
)
else:
message = (
"creation of {0} VM {1} with vmid {2} failed with exception={3}".format(
VZ_TYPE, name, vmid, e
)
)
module.fail_json(msg=message)
elif state == "started":
try:
vm = get_vm(proxmox, vmid)
if not vm:
module.fail_json(msg="VM with vmid <{}> does not exist in cluster".format(vmid))
if getattr(proxmox.nodes(vm[0]["node"]),
VZ_TYPE)(vmid).status.current.get()["status"] == "running":
module.exit_json(changed=False, msg="VM {} is already running".format(vmid))
if start_vm(module, proxmox, vm, vmid, timeout):
module.exit_json(changed=True, msg="VM {} started".format(vmid))
except Exception as e:
module.fail_json(msg="starting of VM {0} failed with exception: {1}".format(vmid, e))
elif state == "stopped":
try:
vm = get_vm(proxmox, vmid)
if not vm:
module.fail_json(msg="VM with vmid={} does not exist in cluster".format(vmid))
if getattr(proxmox.nodes(vm[0]["node"]),
VZ_TYPE)(vmid).status.current.get()["status"] == "stopped":
module.exit_json(changed=False, msg="VM {} is already stopped".format(vmid))
if stop_vm(module, proxmox, vm, vmid, timeout, force=module.params["force"]):
module.exit_json(changed=True, msg="VM {} is shutting down".format(vmid))
except Exception as e:
module.fail_json(msg="stopping of VM {0} failed with exception: {1}".format(vmid, e))
elif state == "restarted":
try:
vm = get_vm(proxmox, vmid)
if not vm:
module.fail_json(msg="VM with vmid={} does not exist in cluster".format(vmid))
if getattr(proxmox.nodes(vm[0]["node"]),
VZ_TYPE)(vmid).status.current.get()["status"] == "stopped":
module.exit_json(changed=False, msg="VM {} is not running".format(vmid))
if (
stop_vm(module, proxmox, vm, vmid, timeout, force=module.params["force"])
and start_vm(module, proxmox, vm, vmid, timeout)
):
module.exit_json(changed=True, msg="VM {} is restarted".format(vmid))
except Exception as e:
module.fail_json(msg="restarting of VM {0} failed with exception: {1}".format(vmid, e))
elif state == "absent":
try:
vm = get_vm(proxmox, vmid)
node = proxmox.nodes(vm[0]["node"])
if not vm:
module.exit_json(changed=False, msg="VM {} does not exist".format(vmid))
if getattr(node, VZ_TYPE)(vmid).status.current.get()["status"] == "running":
module.exit_json(
changed=False, msg="VM {} is running. Stop it before deletion.".format(vmid)
)
taskid = getattr(node, VZ_TYPE).delete(vmid)
while timeout:
if (
node.tasks(taskid).status.get()["status"] == "stopped"
and (node.tasks(taskid).status.get()["exitstatus"] == "OK")
):
module.exit_json(changed=True, msg="VM {} removed".format(vmid))
timeout -= 1
if timeout == 0:
message = (
"Reached timeout while waiting for removing VM."
" Last line in task before timeout: {}".format(
node.tasks(taskid).log.get()[:1]
)
)
module.fail_json(msg=message)
time.sleep(1)
except Exception as e:
module.fail_json(msg="deletion of VM {0} failed with exception: {1}".format(vmid, e))
elif state == "current":
status = {}
try:
vm = get_vm(proxmox, vmid)
if not vm:
module.fail_json(msg="VM with vmid={} does not exist in cluster".format(vmid))
current = getattr(proxmox.nodes(vm[0]["node"]),
VZ_TYPE)(vmid).status.current.get()["status"]
status["status"] = current
if status:
module.exit_json(
changed=False,
msg="VM {0} with vmid={1} is {2}".format(name, vmid, current),
**status
)
except Exception as e:
module.fail_json(
msg="Unable to get vm {} with vmid = {} status: ".format(name, vmid) + str(e)
)
if __name__ == "__main__":
main()
Reference in New Issue Copy Permalink