Example #1
0
 def __init__(self, options, **kargs):
     Service.__init__(self)
     self.options = options
     self.depth = options['depth']
     self.enabled = options['enabled']
     self.fifos = dict()
     setLogLevel(namespace=NAMESPACE, levelStr=options['log_level'])
Example #2
0
    def __init__(self, options, **kargs):

        self.options = options
        self.topics = []
        self.regAllowed = False
        self.validate = options['validation']
        setLogLevel(namespace=NAMESPACE, levelStr=options['log_level'])
        setLogLevel(namespace=PROTOCOL_NAMESPACE,
                    levelStr=options['protocol_log_level'])

        self.tess_heads = [
            t.split('/')[0] for t in self.options['tess_topics']
        ]
        self.tess_tails = [
            t.split('/')[2] for t in self.options['tess_topics']
        ]
        self.factory = MQTTFactory(profile=MQTTFactory.SUBSCRIBER)
        self.endpoint = clientFromString(reactor, self.options['broker'])
        if self.options['username'] == "":
            self.options['username'] = None
            self.options['password'] = None
        self.resetCounters()
        ClientService.__init__(self,
                               self.endpoint,
                               self.factory,
                               retryPolicy=backoffPolicy(
                                   initialDelay=INITIAL_DELAY,
                                   factor=FACTOR,
                                   maxDelay=MAX_DELAY))
Example #3
0
 def reloadService(self, new_options):
     setLogLevel(namespace=NAMESPACE, levelStr=new_options['log_level'])
     log.info("new log level is {lvl}", lvl=new_options['log_level'])
     log.info("new filtering status is {flag}", flag=new_options['enabled'])
     if self.enabled == True and new_options['enabled'] == False:
         self.flush()
     self.options = new_options
     self.enabled = self.options['enabled']
     return defer.succeed(None)
Example #4
0
 def __init__(self, config_opts, cfgFilePath):
     MultiService.__init__(self)
     self.cfgFilePath = cfgFilePath
     self.queue = {
         'tess_register': deque(),
         'tess_readings': DeferredQueue(),
         'tess_filtered_readings': deque(),
     }
     self.statsTask = task.LoopingCall(self.logCounters)
     setLogLevel(namespace='tessdb', levelStr=config_opts['log_level'])
     setLogTags(logTags=config_opts['log_selected'])
Example #5
0
 def __init__(self, options, **kargs):
     Service.__init__(self)
     self.options  = options
     self.paused   = False
     self.onBoot   = True
     self.timeStatList  = []
     self.nrowsStatList = []
     self.sunriseTask  = task.LoopingCall(self.sunrise)
     setLogLevel(namespace='dbase', levelStr=options['log_level'])
     setLogLevel(namespace='register', levelStr=options['register_log_level'])
     if self.options['secs_resolution'] not in self.SECS_RESOLUTION:
         raise DiscreteValueError(self.options['secs_resolution'], self.SECS_RESOLUTION)
Example #6
0
 def reloadService(self, new_options):
     self.validate = new_options['validation']
     setLogLevel(namespace=NAMESPACE, levelStr=new_options['log_level'])
     setLogLevel(namespace=PROTOCOL_NAMESPACE,
                 levelStr=new_options['protocol_log_level'])
     log.info("new log level is {lvl}", lvl=new_options['log_level'])
     yield self.subscribe(new_options)
     self.options = new_options
     self.tess_heads = [
         t.split('/')[0] for t in self.options['tess_topics']
     ]
     self.tess_tails = [
         t.split('/')[2] for t in self.options['tess_topics']
     ]
Example #7
0
 def reloadService(self, new_options):
     '''
     Reload configuration.
     Returns a Deferred
     '''
     setLogLevel(namespace='dbase', levelStr=new_options['log_level'])
     setLogLevel(namespace='register',
                 levelStr=new_options['register_log_level'])
     log.info("new log level is {lvl}", lvl=new_options['log_level'])
     self.tess_readings.setOptions(auth_filter=new_options['auth_filter'])
     self.options = new_options
     # self.tess.invalidCache()
     # self.tess_locations.invalidCache()
     return defer.succeed(None)
Example #8
0
 def reloadService(self, new_options):
     '''
     Reload configuration.
     Returns a Deferred
     '''
     setLogLevel(namespace='dbase', levelStr=new_options['log_level'])
     setLogLevel(namespace='register', levelStr=new_options['register_log_level'])
     log.info("new log level is {lvl}", lvl=new_options['log_level'])
     
     self.tess_readings.setOptions(location_filter=new_options['location_filter'], 
         location_horizon=new_options['location_horizon'])
     yield self.date.populate(json_dir=new_options['json_dir'])
     yield self.time.populate(json_dir=new_options['json_dir'])
     yield self.tess_locations.populate(json_dir=new_options['json_dir'])
     yield self.tess_units.populate(json_dir=new_options['json_dir'])
     yield self.tess.populate(json_dir=new_options['json_dir'])
Example #9
0
 def reloadService(self, options):
     '''
     Reload service parameters
     '''
     log.warn("{tessdb} config being reloaded", tessdb=VERSION_STRING)
     try:
         config_opts = yield deferToThread(loadCfgFile, self.cfgFilePath)
     except Exception as e:
         log.error("Error trying to reload: {excp!s}", excp=e)
     else:
         level = config_opts['tessdb']['log_level']
         setLogLevel(namespace='tessdb', levelStr=level)
         log.info("new log level is {lvl}", lvl=level)
         setLogTags(logTags=config_opts['tessdb']['log_selected'])
         yield self.mqttService.reloadService(config_opts['mqtt'])
         yield self.filterService.reloadService(config_opts['filter'])
         yield self.dbaseService.reloadService(config_opts['dbase'])
Example #10
0
 def reloadService(self, options):
     '''
     Reload service parameters
     '''
     log.warn("{tessdb} config being reloaded", tessdb=VERSION_STRING)
     try:
         config_opts  = yield deferToThread(loadCfgFile, self.cfgFilePath)
     except Exception as e:
         log.error("Error trying to reload: {excp!s}", excp=e)
     else:
         yield self.mqttService.reloadService(config_opts['mqtt'])
         yield self.dbaseService.reloadService(config_opts['dbase'])
         level = config_opts['tessdb']['log_level']
         setLogLevel(namespace='tessdb', levelStr=level)
         log.info("new log level is {lvl}", lvl=level)
         # It is very convenient to recompute all sunrise/sunset data after a reload
         # After having assigned an instrument to a location
         # Otherwise, I have to restart tssdb and loose some samples
         yield self.dbaseService.sunrise() # This is asynchronous !
Example #11
0
    def __init__(self, options, **kargs):
        Service.__init__(self)
        self.options = options
        self.paused = False
        self.onBoot = True
        self.timeStatList = []
        self.nrowsStatList = []

        setLogLevel(namespace='dbase', levelStr=options['log_level'])
        setLogLevel(namespace='registry',
                    levelStr=options['register_log_level'])
        if self.options['secs_resolution'] not in self.SECS_RESOLUTION:
            raise DiscreteValueError(self.options['secs_resolution'],
                                     self.SECS_RESOLUTION)

        # Import appropiate DAO module
        if self.options['type'] == "sqlite3":
            import sqlite3
            from .sqlite3 import getPool, Date, TimeOfDay, TESSUnits, Location, TESS, TESSReadings
            if not os.path.exists(options['connection_string']):
                raise IOError(
                    "No SQLite3 Database file found in {0}. Exiting ...".
                    format(options['connection_string']))
            # synchronous database initialization uses standard API, not adbapi
            connection = sqlite3.connect(options['connection_string'])
            self.getPoolFunc = getPool
        else:
            msg = "No database driver found for '{0}'".format(
                self.options['type'])
            raise ImportError(msg)

        # Create DAO objects
        self.pool = None
        self.connection = connection
        self.tess = TESS(connection)
        self.tess_units = TESSUnits(connection)
        self.tess_readings = TESSReadings(connection, self)
        self.tess_locations = Location(connection)
        self.date = Date(connection)
        self.time = TimeOfDay(connection, self.options['secs_resolution'])
Example #12
0
        '''
        self.seq += 1
        self.freq = round(self.freq + random.uniform(-1, 1), 3)
        self.mag = round(self.mag + random.uniform(-0.5, 0.5), 2)
        self.tamb = round(self.tamb + random.uniform(-2, 2), 1)
        self.tsky = self.tamb - 30
        self.tstamp = datetime.datetime.utcnow().strftime(TSTAMP_FORMAT)
        #self.tstamp = (datetime.datetime.utcnow() + datetime.timedelta(minutes=1)).strftime(TSTAMP_FORMAT)
        return {
            'seq': self.seq,
            'name': NAME,
            'freq': self.freq,
            'mag': self.mag,
            'tamb': self.tamb,
            'tsky': self.tsky,
            'rev': PROTOCOL_REVISION,
            'tstamp': self.tstamp,
        }


log = Logger()
startLogging()
setLogLevel(namespace=None, levelStr='debug')

factory = MQTTFactory(profile=MQTTFactory.PUBLISHER)
point = TCP4ClientEndpoint(reactor, "test.mosquitto.org", 1883)
tess = TESS()

point.connect(factory).addCallback(tess.gotProtocol)
reactor.run()
Example #13
0
 def __init__(self, config_opts, cfgFilePath):
     MultiService.__init__(self)
     self.cfgFilePath = cfgFilePath
     self.queue  = { 'tess_register':  deque() , 'tess_readings':   deque() }
     self.statsTask    = task.LoopingCall(self.logCounters)
     setLogLevel(namespace='tessdb', levelStr=config_opts['log_level'])
        self.seq += 1
        self.freq = round(self.freq + random.uniform(-1,1), 3)
        self.mag  = round(self.mag  + random.uniform(-0.5,0.5), 2)
        self.tamb = round(self.tamb + random.uniform(-2,2), 1)
        self.tsky = self.tamb - 30
        self.tstamp = datetime.datetime.utcnow().strftime(TSTAMP_FORMAT)
        #self.tstamp = (datetime.datetime.utcnow() + datetime.timedelta(minutes=1)).strftime(TSTAMP_FORMAT)
        return {  
                'seq': self.seq,
                'name' : NAME,
                'freq' : self.freq,
                'mag'  : self.mag,
                'tamb' : self.tamb,
                'tsky' : self.tsky,
                'rev'  : PROTOCOL_REVISION,
                'tstamp': self.tstamp,
                }
        


log = Logger()
startLogging()
setLogLevel(namespace=None, levelStr='debug')

factory = MQTTFactory(profile=MQTTFactory.PUBLISHER)
point   = TCP4ClientEndpoint(reactor, "test.mosquitto.org", 1883)
tess    = TESS()

point.connect(factory).addCallback(tess.gotProtocol)
reactor.run()