def __init__(self,
logger,
monitor,
debug,
dummyval,
usethread,
ev_quit=None):
self.logger = logger
self.debug = debug # do dubug or not
self.monitor = monitor # do monitoring
self.dummyval = dummyval # use dummy fits values
self.usethread = usethread # use thread
self.timeout = 0.2 # Q timeout
self.cmd_end = "END"
self.aliasVal = guiderfitsheader.getAlias() # status alias values
self.keyVal = guiderfitsheader.getKeyVal()
# fits header template
self.guiderFitsHeader = guiderfitsheader.guider_fits_header
# set thread event
if not ev_quit: self.ev_quit = threading.Event()
else: self.ev_quit = ev_quit
# monitor instance
if self.monitor:
self.db = Monitor.Minimon('GuiderInt.mon', self.logger)
self.db.subscribe(self.monitor, ['GuiderInt'], None)
if not self.dummyval:
self.svc = ro.remoteObjectProxy('status')
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
mysqlarchiver._deleteMySQLArchiveDb() # just in case
(self.env.con,self.env.cur) = mysqlarchiver.initMySQLArchiveDb()
self.framedb = archiver.SimFrameDBint(self.env)
#import test_archiver
#self.framedb = test_archiver.SimTestFrameDBint(self.env)
self.iaq = 'SUKA'
self.archmon = archiver.ArchiveMonitor(self.framedb,self.env)
self.archivemgr = archiver.ArchiveMgr(self.framedb,self.archmon, self.env)
self.framesrcSUKA = self.archivemgr.createFrameSourceA("SUK")
self.basic = ['SIMPLE','BITPIX','NAXIS','EXTEND','PROP-ID',
'FRAMEID','RANDOM','OBCPMODE']
self.basic.sort()
self.archivemgr.registerKeywords(self.iaq,self.basic)
import random
#randokm.seed(0) # force a random but repeatable sequence
self.random = str(random.randrange(1000,1010))
self.mode = "mode_"+str(random.randrange(0,10))
self.obcpnum = 9
self.ev_quit = threading.Event()
# Timeout value for this task
self.timeout = 20.0
# Create monitor and other allocations
self.monitor_name = 'monitor'
self.monitor = Monitor.Minimon(self.monitor_name, logger=logger)
myhost = SOSSrpc.get_myhost(short=True)
statusDict = {}
# Create and start the instrument interface
self.insint = INSint.ocsInsInt(self.obcpnum, myhost, self.env.ARCH_PROP,
statusDict, db=self.monitor,
logger=logger, ev_quit=self.ev_quit)
self.insint.start()
# This is our set of allocations
self.alloc = Bunch.Bunch(monitor=self.monitor,
INSint9=self.insint,
archmgr=self.archivemgr,
status=None)
# Create and start SIMCAM
ocsint = DAQtk.ocsInt(self.obcpnum, logger=logger, ev_quit=self.ev_quit)
simcam = SIMCAM.SIMCAM(logger, self.env, ev_quit=self.ev_quit)
self.simcam = SIMCAM.OCSInterface(logger, ev_quit=self.ev_quit,
ocsint=ocsint, instrument=simcam)
self.simcam.start()
# Create and start our task manager
self.tm = TaskManager.TaskManager(logger=logger, internal_allocs=self.alloc)
self.tm.setAllocs(['monitor', 'INSint9', 'archmgr'])
self.tm.start()
def setUp(self):
import rpc
self.ev_quit = threading.Event()
# Create monitor and other allocations
self.monitor = Monitor.Minimon(TestTCSCmds.monitorName, logger)
#
# commandManager = CommandManager.CommandManager(None)
# commandSender = CommandManager.CommandSender(commandManager=commandManager,
# timeout=0.1,
# host='localhost',
# prog=0x20000011,
# uid=CommandManager.TCS_UID,
# gid=CommandManager.TCS_GID )
# #humm...
# commandManager.commandQueue = commandSender.commandQueue
# commandReceiver = CommandManager.ReplyReceiver(host="",
# prog=0x20000012,
# vers=1,
# port=0,
# commandManager=commandManager)
commandManager = TCSintTestCase.MockCommandManager()
commandManager.mockResult = True
commandSender = TCSintTestCase.MockTCSClient()
commandReceiver = TCSintTestCase.MockReplyReceiver(rpc.Packer(),
rpc.Unpacker('\x00\x00\x00=CEOBS%TSC%00002006020719514370028000005930020000000COMPLETE%%\x00\x00\x00'),
commandManager)
ddSequenceGenerator = TCSint.FakeSequenceGenerator()
self.tCSint = TCSint.TCSint(self.monitor,
commandManager,
commandSender,
commandReceiver,
ddSequenceGenerator)
self.tCSint.start()
self.alloc = Bunch.Bunch(monitor=self.monitor,
TSC=self.tCSint,
status=None)
# Create and start our task manager
self.tm = TaskManager.TaskManager(logger=logger, ev_quit=self.ev_quit,
internal_allocs=self.alloc)
self.tm.setAllocs([TestTCSCmds.monitorName,
TestTCSCmds.intName])
self.tm.start()
def setup(self):
self.minimon = Monitor.Minimon('mymon',
self.logger,
ev_quit=self.ev_quit)
self.minimon.start(wait=True)
tp = self.minimon.get_threadPool()
self.soss = INSint.ocsInsInt(self.obcpnum,
self.obcphost,
'/tmp',
self.statusObj,
ev_quit=self.ev_quit,
interfaces=('cmd', ),
db=self.minimon,
logger=self.logger,
threadPool=tp)
self.soss.start(wait=True)
def __init__(self, logger, svcname, monitor, debug, port, usethread=False):
# Superclass constructor
#self.guider=GuiderSaveFrame(debug=False, monitor=monitor, svcname=svcname)
ro.remoteObjectServer.__init__(self,
svcname=svcname,
port=port,
logger=logger,
usethread=usethread)
self.logger = logger
self.debug = debug
self.monitor = monitor
if self.monitor:
self.db = Monitor.Minimon(monSvcName, self.logger)
self.db.subscribe(self.monitor, (monChannel), (Monitor.TWO_WAY))
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
self.obcpnum = 9
self.ev_quit = threading.Event()
# Create monitor and other allocations
self.monitor_name = 'monitor'
self.monitor = Monitor.Minimon(self.monitor_name, logger)
myhost = SOSSrpc.get_myhost(short=True)
# Create and start STARS simulator
self.stars = STARSint.STARSsimulator(logger=logger, ev_quit=self.ev_quit)
# Tell STARS how to contact us to copy files
STARSint.add_transferParams('*',
transfermethod='ssh',
raidpath=self.env.ARCH_PATH,
#username=os.getlogin(),
username=os.environ['LOGNAME'],
password='******')
self.stars.start()
# Create and start the STARS interface
self.starsint = STARSint.STARSinterface(starshost=myhost,
db=self.monitor, logger=logger,
ev_quit=self.ev_quit)
self.starsint.start()
# This is our set of allocations
self.alloc = Bunch.Bunch(monitor=self.monitor,
STARSint=self.starsint,
status=None)
# Create and start our task manager
self.tm = TaskManager.TaskManager(logger=logger, ev_quit=self.ev_quit,
internal_allocs=self.alloc)
self.tm.setAllocs(['monitor', 'STARSint'])
self.tm.start()
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
self.obcpnum = 9
self.fmtstr = 'EXEC SIMCAM FITS_FILE MOTOR=%(motor)s FRAME_NO=%(frame_no)s DELAY=%(delay)f'
self.ev_quit = threading.Event()
# Create monitor and other allocations
self.monitor_name = 'monitor'
self.monitor = Monitor.Minimon(self.monitor_name, logger)
myhost = SOSSrpc.get_myhost(short=True)
statusDict = {}
# Create and start the instrument interface
self.insint = INSint.ocsInsInt(self.obcpnum, myhost, self.env.ARCH_PROP,
statusDict, db=self.monitor,
logger=logger, ev_quit=self.ev_quit)
self.insint.start()
# This is our set of allocations
self.alloc = Bunch.Bunch(monitor=self.monitor,
INSint9=self.insint,
status=None)
# Create and start SIMCAM
ocsint = DAQtk.ocsInt(self.obcpnum, logger=logger, ev_quit=self.ev_quit)
self.simcam = SIMCAM.Instrument(logger, ev_quit=self.ev_quit,
ocsint=ocsint, allowNoPara=True,
env=self.env)
self.simcam.loadPersonality('SIMCAM')
#self.simcam.loadParaBuf(fits_file_para)
self.simcam.start()
# Create and start our task manager
self.tm = TaskManager.TaskManager(logger=logger, ev_quit=self.ev_quit,
internal_allocs=self.alloc)
self.tm.setAllocs(['monitor', 'INSint9'])
self.tm.start()
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
self.obcpnum = 9
self.ev_quit = threading.Event()
# Create mini monitor for INSint
self.minimon = Monitor.Minimon('monitor', logger)
myhost = SOSSrpc.get_myhost(short=True)
raidpath = self.env.INST_PATH
statusObj = INSint.FetchStatusWrapper_SOSS({})
# Create and start the instrument interface
self.insint = INSint.ocsInsInt(self.obcpnum,
myhost,
raidpath,
statusObj,
db=self.minimon,
logger=logger,
ev_quit=self.ev_quit)
self.insint.start(wait=True)
# Create and start SIMCAM
ocsint = DAQtk.ocsInt(self.obcpnum,
logger=logger,
ev_quit=self.ev_quit)
self.simcam = SIMCAM.Instrument(logger,
ev_quit=self.ev_quit,
ocsint=ocsint,
allowNoPara=False,
env=self.env)
self.simcam.loadPersonality('SIMCAM')
self.simcam.loadParaBuf(('SIMCAM', 'FITS_FILE'), fits_file_para)
# Wait until SIMCAM is up and running
self.simcam.start(wait=True)
def setUp(self):
self.env = environment.MockEnvironment()
self.env.removeTestDirs() # just in case
self.env.makeDirs()
self.ev_quit = threading.Event()
# Create mini monitor for STARSint
self.minimon = Monitor.Minimon('monitor', logger)
myhost = SOSSrpc.get_myhost(short=True)
# Create and start STARS simulator
self.starssim = STARSint.STARSsimulator(logger=logger,
ev_quit=self.ev_quit)
# Tell STARS how to contact us to copy files
STARSint.add_transferParams(
'*',
transfermethod='ssh',
raidpath=self.env.ARCH_PATH,
#username=os.getlogin(),
username=os.environ['LOGNAME'],
password='******')
self.starssim.start()
# Create and start the STARS interface
self.starsint = STARSint.STARSinterface(starshost=myhost,
db=self.minimon,
logger=logger,
ev_quit=self.ev_quit)
self.starsint.start()
# Wait until STARS simulator is up and running
# TODO: figure out a way to synchronize on the portmapper
time.sleep(0.0)
def __init__(self, logger=None, ev_quit=None, dbpath='taskmgr-db',
threadPool=None, numthreads=50, internal_allocs=None,
identity=serviceName, monitor='monitor'):
self.myname = identity
self.myMonName = ('%s.mon' % self.myname)
self.mainMonName = monitor
# For instrument information
self.insconfig = INSconfig()
# Handles for subsystems. Is set/reset by setAllocs() method.
self.alloc = Bunch.threadSafeBunch()
#self.alloc = {}
# Dictionary-compat object of 'internal' allocations (local objects to
# the TaskManager process)
if internal_allocs:
self.internal_allocs = internal_allocs
else:
self.internal_allocs = {}
self.internal_allocs['taskmgr'] = self
# If no logger is passed in, create a simple one to stderr
if not logger:
logger = logging.getLogger(self.myname)
logger.setLevel(logging.ERROR)
fmt = logging.Formatter(ssdlog.STD_FORMAT)
stderrHdlr = logging.StreamHandler()
stderrHdlr.setFormatter(fmt)
logger.addHandler(stderrHdlr)
self.logger = logger
if not ev_quit:
ev_quit = threading.Event()
self.ev_quit = ev_quit
self.numthreads = numthreads
# 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
# If we were handed a monitor then use it, otherwise create a
# minimon (will be synced to by external monitor)
if self.internal_allocs.has_key('monitor'):
self.monitor = self.internal_allocs['monitor']
self.mymonitor = False
else:
self.monitor = Monitor.Minimon(self.myMonName, self.logger,
useSync=False,
threadPool=self.threadPool)
self.mymonitor = True
self.internal_allocs['monitor'] = self.monitor
# Our list of loaded modules
self.modules = Bunch.threadSafeBunch()
# Our directory mapping subsystems and task class names
self.taskdir = Bunch.threadSafeBunch(caseless=True)
self.taskdir[''] = Bunch.threadSafeBunch(caseless=True)
# Generates tags for tasks
self.tagger = TagGenerator()
# Used for validating subsystem commands
self.validator = ParaValidator.ParaValidator(self.logger)
# For loading skeleton files
self.sk_bank = sk_interp.skBank(obshome)
# TODO: this value should be parameterized
self.channels = [self.myname]
# Default variables we will share with child tasks
self.shares = ['logger', 'threadPool', 'alloc', 'shares', 'tagger',
'monitor', 'validator', 'channels', 'insconfig',]
# Top level tag that all my tasks will appear underneath in the monitor
self.tag = ('mon.tasks.%s' % self.myname)
self.qtask = {}
self.topTags = []
logger = ssdlog.make_logger(svcname, options)
# Initialize remote objects subsystem.
try:
ro.init()
except ro.remoteObjectError, e:
logger.error("Error initializing remote objects subsystem: %s" % str(e))
sys.exit(1)
svc_started = False
svr_started = False
mon_started = False
# Create mini monitor to reflect to main monitor
minimon = Monitor.Minimon('%s.mon' % svcname, logger,
numthreads=options.numthreads)
minimon.start()
mon_started = True
# publish our information to the specified monitor
if options.monitor:
channels = list(monchannels)
minimon.publish_to(options.monitor, channels, {})
# Configure logger for logging via our monitor
if options.logmon:
minimon.logmon(logger, options.logmon, ['logs'])
try:
minimon.start_server(port=options.monport, usethread=True)
