Beispiel #1
0
    def testExport(self):
        jls = Jails()

        expected = []
        self.assertEqual(jls.export(), expected, "The exported data does not match the expected value (empty list).")

        j = getJail()
        jls.add(jls.create(j))
        expected = [j]
        self.assertEqual(jls.export(), expected, "The exported data does not match the expected value (one jail).")

        h = getJail()
        jls.add(jls.create(h))
        expected = [j, h]
        self.assertEqual(len(jls.export()), 2, "The exported data does not match the expected value (one jail).")
Beispiel #2
0
Datei: vm.py Projekt: masom/Puck
class VM(object):
    '''
    Virtual Machine
    '''

    def __init__(self, registration):
        self.id = registration['id']
        self.jails = Jails()
        self.keys = {}
        self.name = registration['name']
        self.status = 'new'
        self.environment = None
        self.interface = None
        self.firewall = None

        self.interfaces = NetInterfaces.getInterfaces()
        self.configured = False

        self._persist_file = cherrypy.config.get('vm.persistence')
        self._load()

    def update(self, **kwargs):
        '''Update the VM object with provided values.'''

        valid = ['keys', 'interface', 'name', 'firewall']

        for key in kwargs:
            if not key in valid:
                continue
            setattr(self, key, kwargs[key])

        if 'environment' in kwargs:
            old_env = self.environment
            self.environment = kwargs['environment']

            if old_env != self.environment:
                self.jails.clear()

        if 'jails' in kwargs:
            self._set_jails(kwargs['jails'])

        self.configurationValid()

    def _set_jails(self, jails):
        '''Sets the jails to the provided list.'''

        self.jails.clear()

        for data in jails:
            if self.jails.contain(data['id']):
                continue
            jail = self.jails.create(data)
            self.jails.add(jail)

    def _load(self):
        '''Load the vm off the persistent storage.'''

        if not os.path.exists(self._persist_file):
            return

        keys = [
            'id', 'keys', 'status', 'environment', 'configured', 'interface',
            'firewall'
        ]
        data = {}

        try:
            with open(self._persist_file, 'r') as f:
                data = json.load(f)
        except ValueError as e:
            return

        for key in keys:
            if not key in data:
                #discard loaded data.
                raise KeyError("Key: `%s` is missing." % key)

        if not 'jails' in data:
            raise KeyError("Key: `jails` is missing.")

        for key in keys:
            setattr(self, key, data[key])

        self.jails.load(data['jails'])

    def persist(self):
        '''Saves the VM to the persistent storage.'''

        data = self.getConfiguration()
        with open(self._persist_file, 'w') as f:
            f.write(json.dumps(data, sort_keys=True, indent=4))

    def getConfiguration(self):
        '''Returns a dictionary filled with the VM configuration data.'''

        data = {}
        data['id'] = self.id
        data['jails'] = self.jails.export()
        data['keys'] = self.keys
        data['status'] = self.status
        data['environment'] = self.environment
        data['configured'] = self.configured
        data['interface'] = self.interface
        data['firewall'] = self.firewall
        return data

    def configurationValid(self):
        '''Verifies if the configuration is valid and upate the jail status accordingly'''

        listItems = [self.jails.get(), self.keys]
        boolItems = [self.environment, self.interface]

        for item in listItems:
            if len(item) == 0:
                return self.isConfigured(False)

        for item in boolItems:
            if not item:
                return self.isConfigured(False)

        return self.isConfigured(True)

    def isConfigured(self, state = None):
        '''Switch the configuration state or returns it.'''

        if state:
            self.configured = state
            self.status = 'configured'
        elif state == False:
            self.configured = state
            self.status = 'new'

        return self.configured