Clone VM from template with pyVmomi

clone.py

#!/usr/bin/env python
"""

NOTE: 
This gist has been moved to EZmomi: 

   https://github.com/snobear/ezmomi
  
Give it a star or fork.  Contributions are more than welcome.  I'm hoping it will become an easy cli tool for
common VMware tasks.



(Notes from the original gist start here)
Example usage:
  ./clone.py --hostname test01 --template CentOS65 --ips 172.9.9.11 172.12.120.22 --cpus 2 --mem 4

Pip requirements:
-----------------
ecdsa==0.10
netaddr==0.7.10
pycrypto==2.6.1
pyvmomi==5.5.0
wsgiref==0.1.2
"""


from pyVim.connect import SmartConnect, Disconnect
from pyVmomi import vim, vmodl
import atexit
import os
import sys
from pprint import pprint, pformat
import time
from netaddr import IPNetwork, IPAddress
import argparse
import getpass
from settings import *
from copy import deepcopy

"""
 Send an email
"""
def send_email(deploy_settings, ip_settings, output):
    # Import smtplib for the actual sending function
    import smtplib
    from email.mime.text import MIMEText

    me = os.getenv("SUDO_USER") # who ran sudo
    if me is None:
        me = os.getenv("USER")  # will always be root when this scripts is run as sudo
    
    email_body = "%s" % output
    msg = MIMEText(email_body)
    msg['Subject'] = "%s - VM deploy complete" % deploy_settings["new_vm_name"]
    msg['From'] = deploy_settings["mailfrom"] 
    msg['To'] = me

    s = smtplib.SMTP('localhost')
    s.sendmail(deploy_settings["mailfrom"] , [me], msg.as_string())
    s.quit()

"""
 Waits and provides updates on a vSphere task
"""
def WaitTask(task, actionName='job', hideResult=False):
    #print 'Waiting for %s to complete.' % actionName
    
    while task.info.state == vim.TaskInfo.State.running:
       time.sleep(2)
    
    if task.info.state == vim.TaskInfo.State.success:
       if task.info.result is not None and not hideResult:
          out = '%s completed successfully, result: %s' % (actionName, task.info.result)
       else:
          out = '%s completed successfully.' % actionName
    else:
       out = '%s did not complete successfully: %s' % (actionName, task.info.error)
       print out
       raise task.info.error # should be a Fault... check XXX
    
    # may not always be applicable, but can't hurt.
    return task.info.result

"""
 Get the vsphere object associated with a given text name
"""
def get_obj(content, vimtype, name):
    obj = None
    container = content.viewManager.CreateContainerView(content.rootFolder, vimtype, True)
    for c in container.view:
        if c.name == name:
            obj = c
            break
    return obj


"""
 Connect to vCenter server and deploy a VM from template
"""
def clone(deploy_settings, ip_settings):
    fqdn = "%s.%s" % (deploy_settings["new_vm_name"], ip_settings[0]["domain"])

    # connect to vCenter server
    try:
        si = SmartConnect(host=deploy_settings["vserver"], user=deploy_settings["username"], pwd=deploy_settings["password"], port=int(deploy_settings["port"]))
    except IOError, e:
        sys.exit("Unable to connect to vsphere server. Error message: %s" % e)
        
    # add a clean up routine
    atexit.register(Disconnect, si)
    
    content = si.RetrieveContent()

    # get the vSphere objects associated with the human-friendly labels we supply
    datacenter = get_obj(content, [vim.Datacenter], ip_settings[0]["datacenter_name"])
    # get the folder where VMs are kept for this datacenter
    destfolder = datacenter.vmFolder
    
    cluster = get_obj(content, [vim.ClusterComputeResource], ip_settings[0]["cluster_name"])
    resource_pool = cluster.resourcePool # use same root resource pool that my desired cluster uses
    datastore = get_obj(content, [vim.Datastore], ip_settings[0]["datastore_name"])
    template_vm = get_obj(content, [vim.VirtualMachine], deploy_settings["template_name"])

    # Relocation spec
    relospec = vim.vm.RelocateSpec()
    relospec.datastore = datastore
    relospec.pool = resource_pool

    '''
     Networking config for VM and guest OS
    '''
    devices = [] 
    adaptermaps = []

    # create a Network device for each static IP
    for key, ip in enumerate(ip_settings):
        # VM device
        nic = vim.vm.device.VirtualDeviceSpec()
        nic.operation = vim.vm.device.VirtualDeviceSpec.Operation.add  # or edit if a device exists
        nic.device = vim.vm.device.VirtualVmxnet3()
        nic.device.wakeOnLanEnabled = True
        nic.device.addressType = 'assigned'
        nic.device.key = 4000  # 4000 seems to be the value to use for a vmxnet3 device
        nic.device.deviceInfo = vim.Description()
        nic.device.deviceInfo.label = "Network Adapter %s" % (key + 1 )
        nic.device.deviceInfo.summary = ip_settings[key]["network_name"]
        nic.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
        nic.device.backing.network = get_obj(content, [vim.Network], ip_settings[key]["network_name"])
        nic.device.backing.deviceName = ip_settings[key]["network_name"]
        nic.device.backing.useAutoDetect = False
        nic.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
        nic.device.connectable.startConnected = True
        nic.device.connectable.allowGuestControl = True
        devices.append(nic)

        # guest NIC settings, i.e. "adapter map"
        guest_map = vim.vm.customization.AdapterMapping()
        guest_map.adapter = vim.vm.customization.IPSettings()
        guest_map.adapter.ip = vim.vm.customization.FixedIp()
        guest_map.adapter.ip.ipAddress = str(ip_settings[key]["ip"])
        guest_map.adapter.subnetMask = str(ip_settings[key]["subnet_mask"])
        
        # these may not be set for certain IPs, e.g. storage IPs
        try:
            guest_map.adapter.gateway = ip_settings[key]["gateway"]
        except:
            pass

        try:
            guest_map.adapter.dnsDomain = ip_settings[key]["domain"]
        except:
            pass
            
        adaptermaps.append(guest_map)

    # VM config spec
    vmconf = vim.vm.ConfigSpec()
    vmconf.numCPUs = deploy_settings['cpus']
    vmconf.memoryMB = deploy_settings['mem']
    vmconf.cpuHotAddEnabled = True
    vmconf.memoryHotAddEnabled = True
    vmconf.deviceChange = devices

    # DNS settings
    globalip = vim.vm.customization.GlobalIPSettings()
    globalip.dnsServerList = deploy_settings['dns_servers']
    globalip.dnsSuffixList = ip_settings[0]['domain']
    
    # Hostname settings
    ident = vim.vm.customization.LinuxPrep()
    ident.domain = ip_settings[0]['domain']
    ident.hostName = vim.vm.customization.FixedName()
    ident.hostName.name = deploy_settings["new_vm_name"]
    
    customspec = vim.vm.customization.Specification()
    customspec.nicSettingMap = adaptermaps
    customspec.globalIPSettings = globalip
    customspec.identity = ident

    # Clone spec
    clonespec = vim.vm.CloneSpec()
    clonespec.location = relospec
    clonespec.config = vmconf
    clonespec.customization = customspec
    clonespec.powerOn = True
    clonespec.template = False

    # fire the clone task
    task = template_vm.Clone(folder=destfolder, name=deploy_settings["new_vm_name"].title(), spec=clonespec)
    result = WaitTask(task, 'VM clone task')
    
    # send notification
    send_email(deploy_settings, ip_settings, output)

def main(**kwargs):
    deploy_settings["new_vm_name"] = kwargs['hostname'].lower()
    deploy_settings['cpus'] = kwargs['cpus']
    deploy_settings['mem'] = kwargs['mem'] * 1024

    # initialize a list to hold our network settings
    ip_settings = list()

    '''
    Get settings for each IP given
    '''
    for key, ip_string in enumerate(kwargs['ips']):
        
        # convert ip from string to the "IPAddress" type
        ip = IPAddress(ip_string)
    
        # determine network this IP is in
        for network_address in net:
            if ip in network_address:
                net[network_address]["ip"] = ip               
                ip_settings.append(net[network_address])
        
        # throw an error if we couldn't find a network for this ip
        if not any(d['ip'] == ip for d in ip_settings):
            sys.exit("ERROR: I don't know what network %s is in.  Please add settings for this network." % ip_string)
    
    # our default domain
    if 'domain' not in ip_settings[0]:
        ip_settings[0]['domain'] = 'example.com'
    
    # what VM template to use
    deploy_settings['template_name'] = kwargs['template']

    # clone template to a new VM with our specified settings
    clone(deploy_settings, ip_settings)

"""
 Main program
"""
if __name__ == "__main__":
    if getpass.getuser() != 'root':
        sys.exit("You must be root to run this.  Quitting.")

    # Define command line arguments
    parser = argparse.ArgumentParser(description='Deploy a new VM in vSphere')
    parser.add_argument('--template', type=str, help='VMware template to clone', default='CentOS65')
    parser.add_argument('--hostname', type=str, required=True, help='New host name',)
    parser.add_argument('--ips', type=str, help='Static IPs of new host, separated by a space', nargs='+', required=True)
    parser.add_argument('--cpus', type=int, help='Number of CPUs', default=1)
    parser.add_argument('--mem', type=int, help='Memory in GB', default=3)
    
    # Parse arguments and hand off to main()
    args = parser.parse_args()
    main(**vars(args))

settings.py

"""
Network, VMware, and general settings for deploying a new Linux VM
"""

from netaddr import IPNetwork, IPAddress

"""
General settings
"""
deploy_settings = dict()
deploy_settings["dns_servers"]      = ['8.8.8.8','8.8.4.4']
deploy_settings["vserver"]          = "vcenter.example.com"
deploy_settings["port"]             = 443
deploy_settings["username"]         = "admin"
deploy_settings["password"]         = "password"
deploy_settings["mailfrom"]         = 'root@example.com'

"""
Networks
"""
# define settings for each of our networks
net = dict()

internal_omaha = IPNetwork("172.9.9.0/24")
net[internal_omaha] = dict()
net[internal_omaha]["datacenter_name"] = 'Omaha'
net[internal_omaha]["cluster_name"]    = 'Omaha Server Cluster'
net[internal_omaha]["datastore_name"]  = 'Omaha datastore'
net[internal_omaha]["network_name"]    = 'Omaha Internal 1'
net[internal_omaha]["gateway"]         = '172.9.9.1'
net[internal_omaha]["subnet_mask"]     = str(internal_omaha.netmask)

routable_omaha = IPNetwork("123.456.78.90/25")
net[routable_omaha] = dict()
net[routable_omaha]["datacenter_name"] = 'Omaha'
net[routable_omaha]["cluster_name"]    = 'Omaha Server Cluster'
net[routable_omaha]["datastore_name"]  = 'Omaha datastore'
net[routable_omaha]["network_name"]    = 'Omaha Routable 1'
net[routable_omaha]["gateway"]         = '123.456.78.91'
net[routable_omaha]["subnet_mask"]     = str(routable_omaha.netmask)

'''
Storage networks
'''
internal_storage = IPNetwork("172.12.120.1/24")
net[internal_storage] = dict()
net[internal_storage]["network_name"] = '172.12.120.x storage net'
net[internal_storage]["subnet_mask"]  = str(internal_storage.netmask)