def __init__(self, logger):
self.logger = logger
self.parser = CommandParser.CommandParser()
self.para_lexer = para_lexer.paraScanner(logger=logger, debug=0)
self.para_parser = paraParser(self.para_lexer, logger=logger,
debug=0)
self.para = Bunch.threadSafeBunch()
self.userRegMap = Bunch.threadSafeBunch()
self.systemRegMap = Bunch.threadSafeBunch()
self.commandRegMap = Bunch.threadSafeBunch()
def __init__(self, logger, env, ev_quit=None):
super(SCEXAO, self).__init__()
self.logger = logger
self.env = env
self.ev_quit = ev_quit
self.insname = 'SCEXAO'
# Holds our link to OCS delegate object
self.ocs = None
# Thread-safe bunch for storing parameters read/written
# by threads executing in this object
self.param = Bunch.threadSafeBunch()
# Interval between status packets (secs)
self.param.status_interval = 60.0
# status we are interested in
self.s_aliases = [
'FITS.SBR.RA',
'FITS.SBR.DEC',
'FITS.SBR.EQUINOX',
'FITS.SBR.HA',
'FITS.SBR.AIRMASS',
'TSCS.AZ',
'TSCS.EL',
# add more here if you like
]
def __init__(self, logger, env, ev_quit=None):
super(SIMCAM, self).__init__()
self.logger = logger
self.env = env
# Convoluted but sure way of getting this module's directory
self.mydir = os.path.split(sys.modules[__name__].__file__)[0]
if not ev_quit:
self.ev_quit = threading.Event()
else:
self.ev_quit = ev_quit
# Holds our link to OCS delegate object
self.ocs = None
# We define our own modes that we report through status
# to the OCS
self.mode = 'default'
# Thread-safe bunch for storing parameters read/written
# by threads executing in this object
self.param = Bunch.threadSafeBunch()
# Interval between status packets (secs)
self.param.status_interval = 10.0
def __init__(self, sk_basedir, logger=None):
if logger:
self.logger = logger
else:
self.logger = logging.getLogger('sk.skbank')
# Base directory of sk files
self.sk_basedir = sk_basedir
self.cache = Bunch.threadSafeBunch()
lexer = sk_lexer.skScanner(logger=self.logger,
debug=0,
lextab='scan1_tab')
self.param_parser = sk_parser.paramParser(lexer, logger=self.logger)
self.param_parser.build(debug=0, tabmodule='param_parser_tab')
self.param_parser.reset()
lexer = sk_lexer.skScanner(logger=self.logger,
debug=0,
lextab='scan2_tab')
self.ope_parser = sk_parser.opeParser(lexer, logger=self.logger)
self.ope_parser.build(debug=0, tabmodule='ope_parser_tab')
self.ope_parser.reset()
lexer = sk_lexer.skScanner(logger=self.logger,
debug=0,
lextab='scan3_tab')
self.sk_parser = sk_parser.skParser(lexer, logger=self.logger)
self.sk_parser.build(debug=0, tabmodule='sk_parser_tab')
self.sk_parser.reset()
def __init__(self, logger, env, ev_quit=None):
super(PFS, self).__init__()
self.logger = logger
self.env = env
# Convoluted but sure way of getting this module's directory
self.mydir = os.path.split(sys.modules[__name__].__file__)[0]
if not ev_quit:
self.ev_quit = threading.Event()
else:
self.ev_quit = ev_quit
# Holds our link to OCS delegate object
self.ocs = None
# We define our own modes that we report through status
# to the OCS
self.mode = 'default'
# Thread-safe bunch for storing parameters read/written
# by threads executing in this object
self.param = Bunch.threadSafeBunch()
# Interval between status packets (secs)
self.param.status_interval = 10.0
self.frameType = 'A'
def __init__(self, name, logger,
ev_quit=None, threadPool=None, numthreads=15,
outlimit=5):
"""
Constructor for the PubSubBase class.
name pubsub name
logger logger to be used for any diagnostic messages
threadPool optional, threadPool for serving PubSub activities
numthreads if a threadPool is NOT furnished, the number of
threads to allocate
"""
super(PubSubBase, self).__init__()
self.logger = logger
self.name = name
self.numthreads = numthreads
self.outlimit = outlimit
# Handles to subscriber remote proxies
self._partner = {}
# Defines aggregate channels
self.aggregates = Bunch.threadSafeBunch()
# Termination event
if not ev_quit:
ev_quit = threading.Event()
self.ev_quit = ev_quit
# If we were passed in a thread pool, then use it. If not,
# make one. Record whether we made our own or not.
if threadPool != None:
self.threadPool = threadPool
self.mythreadpool = False
else:
self.threadPool = Task.ThreadPool(logger=self.logger,
ev_quit=self.ev_quit,
numthreads=self.numthreads)
self.mythreadpool = True
# For task inheritance:
self.tag = 'PubSub'
self.shares = ['logger', 'threadPool']
# For handling subscriber info
self._lock = threading.RLock()
self._sub_info = {}
# number of seconds to wait before unsubscribing a subscriber
# who is unresponsive
self.failure_limit = 60.0
self.cb_subscr_cnt = 0
self.outbound_sem = threading.BoundedSemaphore(self.outlimit)
