qemuguest

#!/usr/bin/python
import sys
import time
import base64
import subprocess
import json
from subprocess import check_output, CalledProcessError
from subprocess import PIPE
import getopt

def getOSVersion(vm_name):
    osInfoCMD = {
            "execute":"guest-get-osinfo"
            }

    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(osInfoCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error getting guest agent OS Info: %s' % e)
        return "no OS information available"
    return json.loads(cmd_result)['return']



def guestExec(vm_name, cmd, args):
    execCMD = {
            "execute":"guest-exec",
            "arguments":{  
                "path": cmd,
                "arg": args,
                "capture-output":True
                }
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, 'error executing command')

    pid = json.loads(cmd_result)['return']['pid']
    print('Command execution returned PID=%s' % pid)

    time.sleep(2)
    resultCMD = {  
            "execute":"guest-exec-status",
            "arguments":{  
                "pid":pid
                }
            }
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(resultCMD)]
        cmd_result = subprocess.check_output(cmd_list)
        #print('command output: %s' % cmd_result)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, '')
    ret = json.loads(cmd_result)['return']['exitcode']
    print('Command execution returned RC=%s' % ret)

    try:
        output = json.loads(cmd_result)['return']['out-data']
    except KeyError:
        output = ''
    #print("Command output: [%s]" % output)

    decoded_output = base64.b64decode(output).decode("utf-8")
    #print("Decoded output: [%s]" % (decoded_output))
    return (ret, decoded_output)
    

def guestSetPassword(vm_name, username, password):
    execCMD = {
            "execute":"guest-set-user-password",
            "arguments":{  
                "username": username,
                "password": base64.encodestring(password.encode('ascii')).decode('ascii'),
                "crypted":False
                }
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return False

    output = json.loads(cmd_result)
    #print('Command execution returned [%s]' % output)

    if output['return'] == {}:
        return True
    else:
        print('error changing password: [%s]' % output)
        return False

def readFileFromVM(vm_name, filename):
    file_handle = -1
    fileOpenCMD = {
            "execute":"guest-file-open",
            "arguments":{
                "path":"%s" % filename
                }
            }

    # get the file handle first
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileOpenCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        # print('Error while opening file from VM: %s' % e)
        return ""

    file_handle = json.loads(cmd_result)['return']
    #print("file handle: %s" % file_handle)

    if file_handle <= 0:
        print('Invalid handle while opening file from VM')
        return ""

    # command structures with the file handle
    fileReadCMD = {
            "execute":"guest-file-read",
            "arguments":{
                "handle": file_handle, 
                "count":65535
                }
            }
    
    fileCloseCMD = {
            "execute":"guest-file-close", 
            "arguments":{
                "handle":file_handle
                }
            }
    # we have a valid file handle, let's get the contents
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileReadCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error while getting file contents from VM')
        return ""
    
    file_contents = json.loads(cmd_result)['return']['buf-b64']
    file_size = json.loads(cmd_result)['return']['count']
    print("Received file %s (%d bytes)" % (filename, file_size))

    decoded_file = base64.b64decode(file_contents)
    #print("Decoded content: [%s]" % (decoded_file))

    # now we need to close the file handle
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileCloseCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
        #print("Close file handle %s: %s" % (file_handle, json.loads(cmd_result)['return']))
    except CalledProcessError as e:
        print('Error while closing file handle: %s' % e)

    return decoded_file


def writeFileToVM(vm_name, local_file, remote_file):
    file_handle = -1
    fileOpenCMD = {
            "execute":"guest-file-open",
            "arguments":{
                "path":"%s" % remote_file,
                "mode":"w"
                }
            }

    # read local file contents
    try:
        with open(local_file, 'rb') as f:
            file_contents = base64.b64encode(f.read())
    except Exception as e:
        print('Error [%s] opening local file: %s ' % (str(e), local_file))
        return -1

    print("Sending file %s to %s" % (local_file, remote_file))

    # get the file handle first
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileOpenCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error while opening file from VM: %s' % e)
        return -1

    file_handle = json.loads(cmd_result)['return']
    #print("file handle: %s" % file_handle)

    if file_handle <= 0:
        print('Invalid handle while opening file from VM')
        return ""


    # command structures with the file handle
    fileWriteCMD = {
            "execute":"guest-file-write",
            "arguments":{
                "handle": file_handle, 
                "buf-b64":file_contents
                }
            }
    
    fileCloseCMD = {
            "execute":"guest-file-close", 
            "arguments":{
                "handle":file_handle
                }
            }
    # we have a valid file handle, let's write the contents
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileWriteCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error while writing file to VM: ' + str(e))
        return ""
    
    #print("Return: [%s]" % (cmd_result))
    bytes_written =  json.loads(cmd_result)['return']['count']

    # now we need to close the file handle
    cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(fileCloseCMD)]
    try:
        cmd_result = subprocess.check_output(cmd_list)
        #print("Close file handle %s: %s" % (file_handle, json.loads(cmd_result)['return']))
    except CalledProcessError as e:
        print('Error while closing file handle: %s' % e)

    return bytes_written

    
def getNetworkInterfaces(vm_name):

    execCMD = {
            "execute":"guest-network-get-interfaces",
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, 'error executing command')

    output = json.loads(cmd_result)
    #print("Command output: [%s]" % output)

    return output['return']

def getHostname(vm_name):

    execCMD = {
            "execute":"guest-get-host-name",
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, 'error executing command')

    output = json.loads(cmd_result)
    #print("Command output: [%s]" % output)

    return output['return']['host-name']


def getVCPUs(vm_name):

    execCMD = {
            "execute":"guest-get-vcpus",
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, 'error executing command')

    output = json.loads(cmd_result)
    #print("Command output: [%s]" % output)

    return output['return']


def pingAgent(vm_name):
    execCMD = {
            "execute":"guest-ping",
            }
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        return False

    output = json.loads(cmd_result)
    return True

def getFilesystems(vm_name):

    execCMD = {
            "execute":"guest-get-fsinfo",
            }
    
    try:
        cmd_list = ['virsh', '-c', 'qemu:///system', 'qemu-agent-command', vm_name, json.dumps(execCMD)]
        cmd_result = subprocess.check_output(cmd_list)
    except CalledProcessError as e:
        print('Error executing command')
        return (-1, 'error executing command')

    output = json.loads(cmd_result)
    #print("Command output: [%s]" % output)

    return output['return']

def usage():

    print('qemuguest [-n <VM name>] [-h|--help] [-e|--exec <command to execute>] [-i|--info] [--changepassword|-p <username:password>] [-f|--filesystems] [-u|--upload <local file>:<remote file>] [-d|--download <remote file>]')
    return

def checkPreReqs(vm_name):

    if vm_name == '':
        print('Must provide a VM name.')
        usage()
        sys.exit()

    if pingAgent(vm_name) is False:
        print('Guest Agent not responding on VM: ' + vm_name)
        sys.exit()
    return


def main(argv):
    try:
        opts, args = getopt.getopt(argv,"hn:ie:p:ifd:u:",["help","vm=","info","exec=","changepassword=","filesystems","download=","upload="])
    except getopt.GetoptError:
        usage()
        sys.exit(2)

    if len(argv) == 0:
        usage()
        sys.exit()

    vm_name = ''
    for opt, arg in opts:
        if opt in ("-h", "--help"):
            usage()
            sys.exit()
        elif opt in ("-n", "--vm"):
            vm_name = arg
        elif opt in ("-i", "--info"):
            checkPreReqs(vm_name)
            print('---- System information ----\n')
            print('Host name: ' + str(getHostname(vm_name)))
            for cpu in getVCPUs(vm_name):
                status = "online" if cpu['online'] else "offline"
                print('vCPU ' + str(cpu['logical-id']) + ': ' + status)

            print('\n---- OS information ----\n')
            osinfo = getOSVersion(vm_name)
            for k in osinfo.keys():
                print(k + ': ' + osinfo[k])

            print('\n---- Network Interfaces ----\n')
            for nic in getNetworkInterfaces(vm_name):
                print(nic['name'] + ' (mac: ' + nic['hardware-address'] + ')')
                for ip in nic['ip-addresses']:
                    print('\t' + ip['ip-address'] + '/' + str(ip['prefix']) + ' (' + ip['ip-address-type'] + ')')

        elif opt in ("-f", "--filesystems"):
            checkPreReqs(vm_name)
            print('---- Filesystem information ----\n')
            filesystems =  getFilesystems(vm_name)
            for fs in filesystems:
                print('Device: %s (%s)' % (fs['name'], fs['disk'][0]['serial']))
                print('Mount point: %s' % fs['mountpoint'])
                print('File system: %s' % fs['type'])
                print('Used bytes: %d MiB (Total: %d MiB)' % (fs['used-bytes']/1024/1024, fs['total-bytes']/1024/1024))
                print('\n')

        elif opt in ("-e", "--exec"):
            checkPreReqs(vm_name)
            cmds = arg.split()
            command = cmds[0]
            cmds.remove(cmds[0])
            args = cmds
            ret,output = guestExec(vm_name, command, args)
            print('exec rc = %s, output=[%s]' % (ret, output))
            
        elif opt in ("-p", "--changepass"):
            checkPreReqs(vm_name)
            params = arg.split(':')
            output = guestSetPassword(vm_name, params[0], params[1])
            print('set password = [%s]' % output)

        elif opt in ("-d", "--download"):
            checkPreReqs(vm_name)
            params = arg.split(':')
            if len(params) != 2:
                print('You need to supply a remote filename and a local file name.')
                print('e.g.: <remote file>:<local file>')
                sys.exit()
            file_contents = readFileFromVM(vm_name, params[0])
            if file_contents == '':
                print('returned content is null, will not write file.')
                sys.exit(1)
            
            with open(params[1], 'w') as f:
                f.write(file_contents)
        
        elif opt in ("-u", "--upload"):
            checkPreReqs(vm_name)
            params = arg.split(':')
            if len(params) != 2:
                print('You need to supply a local filename and a remote file name.')
                print('e.g.: <local file>:<remote file>')
                sys.exit()
            print('Total bytes written: %d' % writeFileToVM(vm_name, params[0], params[1]))
            

if __name__ == "__main__":
    main(sys.argv[1:])