Example #1
0
    def __init__(self, config):
        """Accepts a configuration object returns a FloodLight object"""
        self.config = config
        self.sequence = _sequence.Sequence(self.config)
        self.client = _opc.Client(self.config['fadecandy']['server'],
                                  self.config['fadecandy']['long_connection'])

        # Check fadecandy connection
        connection = self.client.can_connect()
        if (connection is False):
            message = ('Could not connect to Fadecandy server at %s' %
                       self.config['fadecandy']['server'])
            logger.error(message)
            raise RuntimeError(message)
Example #2
0
 def getSequence(self):
     id = 'acl_sequence'
     exists = id in self.objectIds(['Sequence'])
     portalMaster = self.getPortalMaster()
     if portalMaster is not None:
         startvalue = 0
         if exists:
             ob = getattr(self, id)
             startvalue = ob.value
             self.manage_delObjects(ids=[id])
         ob = portalMaster.getSequence()
         if ob.value < startvalue:
             ob.value = startvalue
     else:
         if not exists:
             sequence = _sequence.Sequence()
             self._setObject(sequence.id, sequence)
         ob = getattr(self, id)
     return ob
Example #3
0
    def test_start(self, mock_get_report_count, mock_send_sequence,
                   mock_can_connect, mock_put_pixels, mock_time_sleep):
        """Test send sequence method"""

        mock_get_report_count.return_value = 2

        # Mock the OPC can_connect function
        mock_can_connect.return_value = True

        # Execute the send sequence method
        try:
            floodlight.FloodLight(config).start()
        except InterruptedError:

            # Construct the expected sequence
            sequence = _sequence.Sequence(config).build(0, 2)

            # Test that put pixels called with expected value
            mock_send_sequence.assert_called_with(sequence)

            # Check that sleep value called as expected
            mock_time_sleep.assert_called_with(60)
Example #4
0
import unittest
import sys
import os

sys.path.insert(
    0, os.path.abspath(os.path.join(os.path.dirname(__file__),
                                    '../floodlight')))

import _config
import _sequence

config = _config.load_config('config.json')
sq = _sequence.Sequence(config)


class TestSequence(unittest.TestCase):
    def test_build(self):
        """Test Sequence builder"""

        self.assertEqual(sq.build(0, 0), sq.online())
        self.assertEqual(sq.build(0, 1), sq.new_report(0, 1))
        self.assertEqual(sq.build(1, 1), sq.report_count(1))
        self.assertEqual(sq.build(-1, -1), sq.error())


if __name__ == '__main__':
    unittest.main()
Example #5
0
    def manage_customizeSystem(self, btn, key, lang, REQUEST, RESPONSE=None):
        """ ConfManager.manage_customizeSystem """

        message = ''
        params = []

        ##### Import ####
        if key == 'Import':
            if btn == 'Import':
                f = REQUEST['file']
                createIfNotExists = 1
                if f:
                    filename = f.filename
                    self.importConfPackage(f, REQUEST, createIfNotExists)
                else:
                    filename = REQUEST['init']
                    self.importConfPackage(filename, REQUEST,
                                           createIfNotExists)
                message = self.getZMILangStr('MSG_IMPORTED') % ('<i>%s</i>' %
                                                                filename)

        ##### History ####
        elif key == 'History':
            old_active = self.getConfProperty('ZMS.Version.active', 0)
            new_active = REQUEST.get('active', 0)
            old_nodes = self.getConfProperty('ZMS.Version.nodes', ['{$}'])
            new_nodes = self.string_list(REQUEST.get('nodes', ''))
            self.setConfProperty('ZMS.Version.active', new_active)
            self.setConfProperty('ZMS.Version.nodes', new_nodes)
            nodes = []
            if old_active == 1 and new_active == 0:
                nodes = old_nodes
            if old_active == 1 and new_active == 1:
                nodes = self.difference_list(
                    old_nodes,
                    self.getConfProperty('ZMS.Version.nodes', ['{$}']))
            for node in nodes:
                ob = self.getLinkObj(node)
                if ob is not None:
                    message += '[%s: %i]' % (node, ob.packHistory())
            message = self.getZMILangStr('MSG_CHANGED') + message

        ##### Clients ####
        elif key == 'Clients':
            if btn == 'Change':
                s = REQUEST.get('portal_master', '').strip()
                if s != self.getHome().id:
                    self.setConfProperty('Portal.Master', s)
                l = []
                for s in REQUEST.get('portal_clients', '').split('\n'):
                    s = s.strip()
                    if s in self.getHome().objectIds(['Folder']):
                        l.append(s)
                self.setConfProperty('Portal.Clients', l)
                message = self.getZMILangStr('MSG_CHANGED')

        ##### MediaDb ####
        elif key == 'MediaDb':
            if btn == 'Create':
                location = REQUEST['mediadb_location'].strip()
                _mediadb.manage_addMediaDb(self, location)
                message = self.getZMILangStr('MSG_CHANGED')
            elif btn == 'Pack':
                message = _mediadb.manage_packMediaDb(self)
            elif btn == 'Remove':
                message = _mediadb.manage_delMediaDb(self)

        ##### Custom ####
        elif key == 'Custom':
            k = REQUEST.get('conf_key', '')
            if btn == 'Change':
                v = REQUEST.get('conf_value', '')
                self.setConfProperty(k, v)
                if REQUEST.get('portal_clients'):
                    for portalClient in self.getPortalClients():
                        portalClient.setConfProperty(k, v)
                params.append('conf_key')
                message = self.getZMILangStr('MSG_CHANGED')
            elif btn == 'Delete':
                self.delConfProperty(k)
                if REQUEST.get('portal_clients'):
                    for portalClient in self.getPortalClients():
                        portalClient.delConfProperty(k)
                message = self.getZMILangStr('MSG_DELETED') % int(1)

        ##### InstalledProducts ####
        elif key == 'InstalledProducts':
            if btn == 'Change':
                self.setConfProperty('InstalledProducts.pil.thumbnail.max',
                                     REQUEST.get('pil_thumbnail_max', 100))
                self.setConfProperty(
                    'InstalledProducts.pil.hires.thumbnail.max',
                    REQUEST.get('pil_hires_thumbnail_max', 600))
                message = self.getZMILangStr('MSG_CHANGED')

        ##### Manager ####
        elif key == 'Manager':
            if btn == 'Add':
                meta_type = REQUEST.get('meta_type', '')
                if meta_type == 'Sequence':
                    obj = _sequence.Sequence()
                    self._setObject(obj.id, obj)
                    message = 'Added ' + meta_type
                elif meta_type == 'ZMSLog':
                    obj = zmslog.ZMSLog()
                    self._setObject(obj.id, obj)
                    message = 'Added ' + meta_type
                elif meta_type in [
                        'ZMSWorkflowProvider', 'ZMSWorkflowProviderAcquired'
                ]:
                    obj = ConfDict.get_constructor(meta_type)()
                    self._setObject(obj.id, obj)
                    message = 'Added ' + meta_type
            elif btn == 'Remove':
                ids = REQUEST.get('ids', [])
                if ids:
                    message = 'Removed ' + ', '.join(ids)
                    self.manage_delObjects(ids=ids)

        # Return with message.
        if RESPONSE:
            d = {'lang': lang, 'manage_tabs_message': message}
            for param in params:
                d[param] = REQUEST.get(param, '')
            return RESPONSE.redirect(
                self.url_append_params('manage_customize', d) + '#%s' % key)

        return message