예제 #1
0
def version():
    def impl():
        return "LibVirt-" + libvirt.getVersion()

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #2
0
class CommandExecuter(object):

    logger = logging.getLogger(support.discoverCaller())

    def __init__(self, cmdId, parameters):
        #parameters is a dict
        self._cmdId = cmdId
        self._parameters = parameters

    def executeCommand(self):
        """ 
    Executes (or tries to) cmd.

    Runs cmd, returning a tuple (stdout, stderr) with the
    contents of the execution
    """
        res = None
        cmd = self._parameters.pop('cmd')
        fileForStdin = self._parameters.pop('fileForStdin')
        try:
            if fileForStdin:
                fileForStdin = file(fileForStdin, 'r')
        except Exception, e:
            res = defer.fail(('', str(e), -1))  #mimic process output
            self._execResUsage = resource.getrusage(resource.RUSAGE_CHILDREN)
        else:
예제 #3
0
def version():
    def impl():
        return ctx['vb'].version

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def takeSnapshot(vm, name, desc):
    def impl():
        logger.debug("Taking snapshot of VM: '%s' and description: %s" % (name, desc) )
        return cmdExistingVm(vm, 'takeSnapshot', (name, desc))
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
예제 #5
0
def listRunningVMs():
    def impl():
        pass

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def saveState(vm):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.save("Current")
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
예제 #7
0
def powerOff(vm):
    def impl():
        return cmdExistingVm(vm, 'powerdown', None)

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #8
0
def start(vm, guiMode):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.create()

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    return d
예제 #9
0
class _VBoxHeadlessProcessProtocol(protocol.ProcessProtocol):
    logger = logging.getLogger(support.discoverCaller())

    def connectionMade(self):
        self.transport.closeStdin()
        self.logger.debug("VBoxHeadless process started!")

    def outReceived(self, data):
        self.logger.debug("VBoxHeadless stdout: %s" % data)

    def errReceived(self, data):
        self.logger.debug("VBoxHeadless stderr: %s" % data)

    def inConnectionLost(self):
        pass  #we don't care about stdin. We do in fact close it ourselves

    def outConnectionLost(self):
        self.logger.info("VBoxHeadless closed its stdout")

    def errConnectionLost(self):
        self.logger.info("VBoxHeadless closed its stderr")

    def processExited(self, reason):
        #This is called when the child process has been reaped
        pass

    def processEnded(self, reason):
        #This is called when all the file descriptors associated with the child
        #process have been closed and the process has been reaped
        self.logger.warn("Process ended (code: %s) " % reason.value.exitCode)
def resume(vm):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.resume()
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
예제 #11
0
def discardState(vm):
    def impl():
        return cmdExistingVm(vm, 'discardState', None)

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #12
0
def deleteSnapshot(vm, name):
    def impl():
        pass

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #13
0
def listVMs():
    def impl():
        return conn.listDefinedDomains()

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #14
0
def listVMsWithState():
    def impl():
        pass  # ? over list of domains, use dom.isActive()?

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #15
0
def discardState(vm):
    def impl():
        pass

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #16
0
def states():
    def impl():
        return ctx['const']._Values['MachineState']

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #17
0
def createVM(xmlFile):
    def impl():
        pass

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #18
0
def pause(vm):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.suspend()

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #19
0
def reset(vm):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.reboot(True)

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def getStats(vm, key):
    def impl():
        if not ctx['perf']:
            return
        return ctx['perf'].query([key], [machById(vm)])
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
예제 #21
0
def saveState(vm):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.save("Current")

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def getState( vm): 
    def impl():
        m = machById(vm)
        mstate = m.state
        stateName = getNameForMachineStateCode(mstate)
        return stateName
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl) 
    return d
예제 #23
0
def getStats(vm, key):
    def impl():
        if not ctx['perf']:
            return
        return ctx['perf'].query([key], [machById(vm)])

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def listVMs():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        msNames = [ str(m.name) for m in ms ]
        return msNames
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
예제 #25
0
def takeSnapshot(vm, name, desc):
    def impl():
        logger.debug("Taking snapshot of VM: '%s' and description: %s" %
                     (name, desc))
        return cmdExistingVm(vm, 'takeSnapshot', (name, desc))

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def createVM(vboxFile):
    vb = ctx['vb']
    def impl():
        mach = vb.openMachine(vboxFile)
        vb.registerMachine( mach )
        logger.debug("Created VM '%s' with UUID %s" % (mach.name, mach.id))
        return (True, mach.name)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
def listVMsWithState():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        msNamesAndStates = [ (str(m.name), getNameForMachineStateCode(m.state)) \
            for m in ms ]
        return dict(msNamesAndStates)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
예제 #28
0
def getState(vm):
    def impl():
        m = machById(vm)
        mstate = m.state
        stateName = getNameForMachineStateCode(mstate)
        return stateName

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #29
0
def listVMs():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        msNames = [str(m.name) for m in ms]
        return msNames

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #30
0
class HostStompEngine(BaseStompEngine):

    logger = logging.getLogger(support.discoverCaller())

    def __init__(self):
        super(HostStompEngine, self).__init__()

    def connected(self, msg):
        #once connected, subscribe
        return (stomper.subscribe(destinations.CONN_DESTINATION),
                stomper.subscribe(destinations.CMD_RES_DESTINATION))
예제 #31
0
def listVMsWithState():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        msNamesAndStates = [ (str(m.name), getNameForMachineStateCode(m.state)) \
            for m in ms ]
        return dict(msNamesAndStates)

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def listRunningVMs():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        isRunning = lambda m: m.state ==  ctx['const'].MachineState_Running
        res = filter( isRunning, ms )
        res = [ str(m.name) for m in res ]
        return res
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
def deleteSnapshot(vm, name):
    def impl():
        mach = machById(vm)
        if name == "":
            return False
        snapshot = mach.findSnapshot(name)
        logger.debug("Deleting snapshot named '%s' and id: %s" % (name, snapshot.id) )
        return cmdExistingVm(vm, 'deleteSnapshot', (snapshot.id,))
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
예제 #34
0
def listRunningVMs():
    def impl():
        vb = ctx['vb']
        ms = getMachines()
        isRunning = lambda m: m.state == ctx['const'].MachineState_Running
        res = filter(isRunning, ms)
        res = [str(m.name) for m in res]
        return res

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #35
0
def createVM(vboxFile):
    vb = ctx['vb']

    def impl():
        mach = vb.openMachine(vboxFile)
        vb.registerMachine(mach)
        logger.debug("Created VM '%s' with UUID %s" % (mach.name, mach.id))
        return (True, mach.name)

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
예제 #36
0
def deleteSnapshot(vm, name):
    def impl():
        mach = machById(vm)
        if name == "":
            return False
        snapshot = mach.findSnapshot(name)
        logger.debug("Deleting snapshot named '%s' and id: %s" %
                     (name, snapshot.id))
        return cmdExistingVm(vm, 'deleteSnapshot', (snapshot.id, ))

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def listSnapshots(vm):
    def impl():
        sl = []
        if machById(vm).snapshotCount > 0:
            root = machById(vm).findSnapshot('')
            def recurseTree(snapList, node):
                snapList.append(node.name)
                for child in node.getChildren():
                    recurseTree(snapList, child)
            recurseTree(sl, root)
        return sl
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
예제 #38
0
class CommandRegistry(object):
    """ 
    For all command-execution related. 

    Keeps track of requests made, served and retired
    """
    logger = logging.getLogger(support.discoverCaller())

    words = inject.attr('words')
    vmRegistry = inject.attr('vmRegistry', VMRegistry)

    def __init__(self):
        self._cmdReqsSent = {
        }  #cmdId: dict with keys (timestamp, to, cmd, args, env, path)
        self._cmdReqsRetired = {}  #finished cmdReqsSent
        self._cmdReqsRcvd = {}

    def addCmdRequest(self, cmdId, requestInfoDict):
        self._cmdReqsSent[cmdId] = requestInfoDict

    def processCmdResult(self, resultsMsg):
        serializedResults = resultsMsg['body'].split(None, 1)[1]
        #serializeded data: dict with keys (cmd-id, out, err, finished?, code/signal, resources)
        results = support.deserialize(serializedResults)
        self.logger.debug("Deserialized results: %s" % results)
        cmdId = results.pop('cmd-id')
        #this comes from a word.CMD_RESULT.listenAndAct
        #note down for which cmd we are getting the result back
        assert cmdId in self._cmdReqsSent
        self._cmdReqsRcvd[cmdId] = results
        self._cmdReqsRetired[cmdId] = self._cmdReqsSent.pop(cmdId)
        self.logger.info("Received command results for cmd-id '%s'", cmdId)

    def popCmdResults(self, cmdId):
        # for invalid cmdIds, returning None could
        # result in problems with xml-rpc. Thus we
        # resource to an empty string, which likewise
        # fails a boolean test
        return self._cmdReqsRcvd.pop(cmdId, "")

    def listFinishedCmds(self):
        return self._cmdReqsRcvd.keys()

    def getCmdDetails(self, cmdId):
        details = self._cmdReqsSent.get(cmdId)
        if not details:
            details = self._cmdReqsRetired.get(cmdId)
        return support.serialize(details)
예제 #39
0
def listSnapshots(vm):
    def impl():
        sl = []
        if machById(vm).snapshotCount > 0:
            root = machById(vm).findSnapshot('')

            def recurseTree(snapList, node):
                snapList.append(node.name)
                for child in node.getChildren():
                    recurseTree(snapList, child)

            recurseTree(sl, root)
        return sl

    logger.debug("Controller method %s invoked" % support.discoverCaller())
    d = threads.deferToThread(impl)
    return d
def states():
    def impl():
        return ctx['const']._Values['MachineState']
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl) 
    return d
def deleteSnapshot(vm, name):
    def impl():
        pass
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
def version():
    def impl():
        return "LibVirt-" + libvirt.getVersion()
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
def start(vm, guiMode):
    def impl():
        dom = conn.lookupByName(vm)
        return dom.create()
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    return d
def listVMs():
    def impl():
        return conn.listDefinedDomains()
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
def listVMsWithState():
    def impl():
        pass # ? over list of domains, use dom.isActive()?
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
def powerOff(vm):
    def impl():
        return cmdExistingVm(vm, 'powerdown', None)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
            return True 

        d = threads.deferToThread(impl)
    else:
        m = machById(vm)
        mName = str(m.name)
        processProtocol = VBoxHeadlessProcessProtocol()
        pseudoCWD = os.path.dirname(sys.modules[__name__].__file__)
        vboxBinariesPath = None #TODO: use VBOX_INSTALL_PATH
        cmdWithPath = os.path.join(pseudoCWD, 'scripts', 'vboxstart.bat')
        cmdWithArgs = ("vboxstart.bat", vboxBinariesPath, mName)
        cmdPath = os.path.join(pseudoCWD, 'scripts')
        newProc = lambda: reactor.spawnProcess( processProtocol, cmdWithPath, args=cmdWithArgs, env=None, path=cmdPath )
        reactor.callWhenRunning(newProc)
        d = True #in order to have a unique return 
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    return d

def shutdown(vm):
    def impl():
        return cmdExistingVm(vm, 'shutdown', None)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d

def reset(vm):
    def impl():
        return cmdExistingVm(vm, 'reset', None)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d
"""

try:
    import logging
    import inject

    from twisted.internet import defer
    from vmcontroller.common import support, exceptions
except ImportError, e:
    print "Import error in %s : %s" % (__name__, e)
    import sys
    sys.exit()

CONTROLLERS_PATH = "hypervisors"  #relative to this file

logger = logging.getLogger(support.discoverCaller())


@inject.param('config')
def _createController(config):
    """
    Creates the appropriate (hypervisor) controller based on the
    given configuration. 

    This is the place where to perform particular initialization tasks for 
    the particular hypervisor controller implementations.

    @param config: an instance of L{ConfigParser}
    """
    hv = config.get('hypervisor', 'name')
    hvMod = None
예제 #49
0
class Host(object):
    logger = logging.getLogger(support.discoverCaller())

    #we use injection so that we can do things lazily
    cmdRegistry = inject.attr('cmdRegistry', CommandRegistry)
    vmRegistry = inject.attr('vmRegistry', VMRegistry)
    fileTxs = inject.attr('fileTxs', FileTxs)

    words = inject.attr('words')
    stompProtocol = inject.attr('stompProtocol')

    def __init__(self):
        self._descriptor = EntityDescriptor('VMController-Host')
        self._vms = {}
        self._pings = {}

    @property
    def descriptor(self):
        return self._descriptor

    def ping(self, vmId, timeout_secs):
        def _timeout(timestamp):
            d = self._pings.pop(timestamp, None)
            if d:
                name = self.vmRegistry.getNameForId(vmId)
                d.errback(RuntimeError('PING timeout (for %s)' % name))

        timestamp = str(time.time())
        d = defer.Deferred()
        self._pings[timestamp] = d
        self.stompProtocol.sendMsg(self.words['PING']().howToSay(vmId))
        reactor.callLater(timeout_secs, _timeout, timestamp)
        return d

    def processPong(self, msg):
        timestamp = msg['headers']['timestamp']
        d = self._pings.pop(timestamp, None)
        assert d
        vmId = msg['headers']['from']
        vmName = self.vmRegistry.getNameForId(vmId)
        d.callback('PONG from %s' % vmName)

    def sendCmdRequest(self,
                       toVmName,
                       cmd,
                       args=(),
                       env={},
                       path=None,
                       fileForStdin=''):
        #get id for name
        toVmId = self.vmRegistry.getIdForName(toVmName)
        cmdId = str(uuid.uuid4())

        toSend = self.words['CMD_RUN']().  \
                 howToSay(toVmId, \
                     cmdId, cmd, args, \
                     env, path, fileForStdin )

        requestKeys = ('timestamp', 'toVmName', 'toVmId', 'cmd', 'args', 'env',
                       'path', 'fileForStdin')
        requestValues = (time.time(), toVmName, toVmId, cmd, args, env, path,
                         fileForStdin)

        self.stompProtocol.sendMsg(toSend)
        self.logger.info(
            "Requested execution of command '%s' with cmd-id '%s'" %
            (cmd, cmdId))

        self.cmdRegistry.addCmdRequest(cmdId,
                                       dict(zip(requestKeys, requestValues)))
        return cmdId

    def processCmdResult(self, resultsMsg):
        self.cmdRegistry.processCmdResult(resultsMsg)

    #XXX: make it possible to be blocking?
    def getCmdResults(self, cmdId):
        return self.cmdRegistry.popCmdResults(cmdId)

    def listFinishedCmds(self):
        return self.cmdRegistry.listFinishedCmds()

    ################################

    def addVM(self, vmDescriptor):
        self.vmRegistry.addVM(vmDescriptor)

    def removeVM():
        self.vmRegistry.removeVM(vmId)

    ################################

    def cpFileToVM(self, vmId, pathToLocalFileName, pathToRemoteFileName=None):
        return self.fileTxs.cpFileToVM(vmId, pathToLocalFileName,
                                       pathToRemoteFileName)

    def cpFileFromVM(self,
                     vmId,
                     pathToRemoteFileName,
                     pathToLocalFileName=None):
        return self.fileTxs.cpFileFromVM(vmId, pathToRemoteFileName,
                                         pathToLocalFileName)
def version():
    def impl():
        return ctx['vb'].version
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl)
    return d
def states():
    def impl():
        pass
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread(impl) 
    return d
"""

try:
    import logging
    import inject

    from twisted.internet import defer
    from vmcontroller.common import support, exceptions
except ImportError, e:
    print "Import error in %s : %s" % (__name__, e)
    import sys
    sys.exit()

CONTROLLERS_PATH = "hypervisors" #relative to this file

logger = logging.getLogger( support.discoverCaller() )

@inject.param('config')
def _createController(config):
    """
    Creates the appropriate (hypervisor) controller based on the
    given configuration. 

    This is the place where to perform particular initialization tasks for 
    the particular hypervisor controller implementations.

    @param config: an instance of L{ConfigParser}
    """
    hv = config.get('hypervisor', 'name')
    hvMod = None
    logger.debug("Hypervisor specified in config: '%s'" % hv)
def discardState(vm):
    def impl():
        return cmdExistingVm(vm, 'discardState', None)
    logger.debug("Controller method %s invoked" % support.discoverCaller() )
    d = threads.deferToThread( impl )
    return d