def __init__(self,module):
self.module = module
try:
self.masters = config.get('Services','masters').split(",")
except configparser.NoOptionError:
self.masters = ['']
logger.warning("The 'masters' directory was missing in config")
try:
self.slaves = config.get('Services','slaves').split(",")
except configparser.NoOptionError:
self.slaves = ['']
logger.warning("The 'slaves' directory was missing in config")
def startFromConfig(self, config):
uartnum = config.get('Intercom', 'uartnum')
mockUart = get_config(config, 'Intercom', 'use_mock_uart', default='false') == 'true'
sysprefix = get_config(config, 'Intercom', 'sys_prefix', default='/dev/ttyO')
baudrate = get_config(config, 'Intercom', 'baudrate', default=9600)
self.start(uartnum=uartnum, mockUart=mockUart, sysprefix=sysprefix, baudrate=baudrate )
def __init__(self, name, context=None):
super(Lpc, self).__init__(name=name, context=context)
port = config.get('LPC', 'port')
if get_config(config,'LPC', 'use_mock_reader', default='false') == 'true':
self.nfcReader = nfc.MockNfcReader(port=port,nfcListener=self.onNfcMessage)
else:
self.nfcReader = nfc.NfcReader(port=port,nfcListener=self.onNfcMessage)
self.nfcReader.start()
def createActiveServicesFromConfig(self):
servicesToCreate = config.get('Services','Services').split(",")
servicesToCreate += self.slaves
servicesToCreate += self.masters
logger.info("Creating the following services: " + str(servicesToCreate))
serviceList = dict()
for service in servicesToCreate:
if service == '' or service == None:
continue
logger.info("Creating service: " + service)
serviceList[service] = self.createService(service)
return serviceList
def testConfigNoRecursion(self):
initConfig("red/tests/config/recursion_meta.conf",None,0)
self.assertEqual(config.get('Test','rec'),'1')
def testConfigRecursion(self):
initConfig("red/tests/config/recursion_meta.conf")
self.assertEqual(config.get('Test','rec'),'2')
def createService(self, serviceName ):
""" Returns a meta object """
meta = ServiceMeta()
meta.socketName = config.get('Sockets', serviceName)
meta.serviceName = serviceName
meta.socket = self.module.context.socket(zmq.PAIR)
ServiceName = serviceName.capitalize()
""" Determine if this is a slave service """
meta.isSlaveService = meta.serviceName in self.slaves
meta.isMasterService = meta.serviceName in self.masters
""" It cannot be both slave and master """
assert not (meta.isSlaveService and meta.isMasterService)
if meta.isMasterService:
""" You must connect to the master """
logger.info("Connecting on socket: " + meta.socketName)
meta.socket.connect(meta.socketName)
else:
""" We bind to normal and slave services """
logger.info("Binding on socket: " + (meta.socketName))
meta.socket.bind(meta.socketName)
logger.info("Bound on socket: " + meta.socketName)
if not (meta.isSlaveService or meta.isMasterService):
""" Slaves and masters should never be started by us """
logger.info("Starting service: " + str(serviceName))
module = None
moduleName = "services." + serviceName
logger.info("Importing " + moduleName)
try:
module = importlib.import_module(moduleName)
except Exception as e:
try:
moduleName = "red.services." + serviceName
logger.info("Importing " + moduleName)
module = importlib.import_module(moduleName)
except Exception as e:
logger.critical("The service '%s' did not exist as a service. Exception: %s" % (serviceName, str(e)))
if module != None:
serviceClass = getattr(module, ServiceName)
meta.service = serviceClass(name=meta.socketName, context=self.module.context)
meta.service.onCreate()
meta.service.deamon = True
meta.service.start();
self.module.poller.register(meta.socket, zmq.POLLIN)
if not (meta.isSlaveService):
"""
We have really no idea whether the slave is active or not.
The slave will tell os when it connects.
To connect the slave, someone must actually turn on a device
Physically turn on a device.
"""
meta.socket.send_json({"head":"system_message", "data":"echo"})
return meta
def __init__(self, name, context=None):
super(Synchronize, self).__init__(name=name, context=context)
self.serverurl = config.get('Scorekeeper', 'server_url')
self.location = config.get('Scorekeeper', 'location')
#models.py
# I have collected all models into this file/module because it is easier for SQLAlchemy
# Feel free to split it up into more files if you can (dare)
from sqlalchemy import create_engine, Column, Integer, String, Sequence, Table, Text, ForeignKey, DateTime, func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship, backref
from datetime import datetime
from red.config import config
from red.utils.run_once import run_once
import traceback
Base = declarative_base()
engine = create_engine(config.get("Database","connectionstring"),echo=False)
#################################################################################################################
################################## Table used to connect players and to teams ###################################
#################################################################################################################
player_team = Table('player_team',Base.metadata,
Column('player_id',Integer,ForeignKey('players.id')),
Column('team_id',Integer,ForeignKey('teams.id'))
)
#################################################################################################################
class Player(Base):
__tablename__ = 'players'
id = Column(Integer,Sequence('player_id_seq'),primary_key=True)
rfid = Column(String,unique=True)
name = Column(String)
created_at = Column(DateTime, default=func.now())
