def start_server(self, svcname=None, host=None, port=None,
ping_interval=default_ns_ping_interval,
strict_registration=False,
threaded_server=default_threaded_server,
authDict=None, default_auth=use_default_auth,
secure=default_secure, cert_file=default_cert,
ns=None,
usethread=True, wait=True, timeout=None):
if not svcname:
svcname = self.name
# make our RO server for remote interface
self.server = ro.remoteObjectServer(svcname=svcname, obj=self,
logger=self.logger,
ev_quit=self.ev_quit,
port=port, usethread=usethread,
threadPool=self.threadPool,
threaded_server=threaded_server,
authDict=authDict, default_auth=default_auth,
secure=secure, cert_file=cert_file)
self.logger.info("Starting remote subscriptions update loop...")
t = Task.FuncTask(self.update_remote_subscriptions_loop, [], {})
t.init_and_start(self)
self.logger.info("Starting server...")
if not usethread:
self.server.ro_start(wait=wait, timeout=timeout)
else:
# Use one of our threadPool to run the server
t = Task.FuncTask(self.server.ro_start, [], {})
t.init_and_start(self)
if wait:
self.server.ro_wait_start(timeout=timeout)
def setUp(self):
self.env = environment.MockEnvironment()
self.myhost = ro.get_myhost()
self.rohosts = []
self.ns = remoteObjectNameSvc.remoteObjectNameService(
self.rohosts,
name='remoteObjectNameServer',
host=self.myhost,
port=ro.nameServicePort)
self.ns.ro_start()
waitForService(self.ns, 'names')
#print "Hosts for",'names',self.ns.getHosts('names')
ro.init()
self.initval = 'init'
self.server = FakeServer(self.initval)
self.servicename = 'TestServiceName2'
self.ROserver = ro.remoteObjectServer(obj=self.server,
name=self.servicename,
svcname=self.servicename,
usethread=True)
self.ROserver.ro_start()
waitForService(self.ns, self.servicename)
#print "Hosts for",self.servicename,self.ns.getHosts(self.servicename)
self.ROclient = ro.remoteObjectProxy(self.servicename)
def server(logger, options, args):
ev_quit = threading.Event()
daq_obj = DAQdoor(logger,
ev_quit,
interval=options.interval,
fifopath=options.fifopath,
fitsdir=options.fitsdir)
svc = ro.remoteObjectServer(svcname=options.svcname,
obj=daq_obj,
logger=logger,
port=options.port,
ev_quit=ev_quit,
usethread=True)
# Start it
try:
logger.info("Starting DAQ door interface service...")
try:
svc.ro_start(wait=True)
daq_obj.service_loop()
except KeyboardInterrupt:
logger.error("Caught keyboard interrupt!")
finally:
logger.info("DAQ door service shutting down...")
svc.ro_stop()
logger.debug("Exiting program.")
sys.exit(0)
def main(options, args):
ro_hosts = options.gen2host.split(',')
ro.init(ro_hosts)
svcname = options.svcname
monname = svcname + '.mon'
# create a real logger if you want logging
logger = ssdlog.make_logger(svcname, options)
ev_quit = threading.Event()
# Create a local subscribe object
myhost = ro.get_myhost(short=True)
mymon = Monitor.Monitor(monname, logger)
channels = options.channels.split(',')
relay = StatusRelay(logger, options.statsvc, options.monitor,
mymon, channels)
# Startup monitor
mymon.start(wait=True)
monport = options.monport
if not monport:
monport = options.port + 1
mymon.start_server(wait=True, port=monport)
threadPool = mymon.get_threadPool()
svc = ro.remoteObjectServer(svcname=options.svcname,
obj=relay, logger=logger,
port=options.port,
default_auth=None,
ev_quit=ev_quit,
usethread=False,
threadPool=threadPool)
try:
relay.update_statusProxy()
relay.update_monitorFeed()
try:
print "Press ^C to terminate the server."
svc.ro_start(wait=True)
svr_started = True
except KeyboardInterrupt:
logger.error("Caught keyboard interrupt!")
ev_quit.set()
finally:
logger.info("Shutting down...")
mymon.unsubscribe_remote('monitor', channels, {})
mymon.stop_server()
mymon.stop()
logger=logger,
queue=queue,
channels=channels,
ev_quit=ev_quit)
else:
mobj = SoundSource(monitor=minimon,
logger=logger,
queue=queue,
channels=channels,
ev_quit=ev_quit,
compress=options.compress)
svc = ro.remoteObjectServer(svcname=basename,
obj=mobj,
logger=logger,
port=options.port,
ev_quit=ev_quit,
usethread=True,
threadPool=threadPool)
mon_server_started = False
ro_server_started = False
try:
# Startup monitor threadpool
minimon.start(wait=True)
minimon.start_server(wait=True, port=options.monport)
mon_server_started = True
# Configure logger for logging via our monitor
# if options.logmon:
# minimon.logmon(logger, options.logmon, ['logs'])
def run():
logger.info("Starting status service...")
# Create object in which to store status tables. This is a passive
# object; i.e. there are no active threads therein
statusObj = st.storeStatusObj()
threadPool = Task.ThreadPool(logger=logger,
ev_quit=ev_quit,
numthreads=options.numthreads)
# Create the status interface object
statint = StatusReceiver(logger, statusObj, threadPool,
ev_quit=ev_quit,
myhost=options.myhost,
monchannels=monchannels,
loghome=options.loghome)
# Create mini monitor to reflect to main monitor
mymonname = ('%s.mon' % svcname)
minimon = Monitor.Monitor(mymonname, logger, ev_quit=ev_quit,
threadPool=threadPool)
statint.set_monitor(minimon)
logger.info("Starting thread pool...")
threadPool.startall(wait=True)
thrd_started = True
logger.info("Starting monitor...")
minimon.start()
# Configure logger for logging via our monitor
if options.logmon:
minimon.logmon(logger, options.logmon, ['logs'])
minimon.start_server(usethread=True)
mon_started = True
if options.monitor:
# Publish our updates to the main monitor
minimon.publish_to(options.monitor, monchannels, {})
if options.ut1utcfile:
ut1utc_path = options.ut1utcfile
else:
if os.environ.has_key('GEN2COMMON'):
dir = os.environ['GEN2COMMON'] + '/db'
else:
dir = os.path.split(sys.modules[__name__].__file__)[0]
ut1utc_path = ('%s/UT1_UTC.table' % dir)
# Create status object
status = StatusServer(statusObj, logger, minimon, threadPool,
monchannels=monchannels,
checkptfile=options.checkptfile,
ut1utcfile=ut1utc_path,
ev_quit=ev_quit)
# Initialize it
status.initialize()
# Connect status interface to server for notifications of new
# table availability
statint.set_server(status)
# Start status interface RPCs
logger.info("Starting status RPC interfaces...")
statint.start(wait=True)
# Create RO server to handle fetch and store requests
status_svr = ro.remoteObjectServer(svcname=svcname,
obj=status, logger=logger,
port=options.port,
ev_quit=ev_quit,
usethread=False,
threadPool=threadPool)
try:
print "Press ^C to terminate the server."
status_svr.ro_start(wait=True)
svr_started = True
except KeyboardInterrupt:
logger.error("Caught keyboard interrupt!")
def main(options, args):
global statusFromGen2, lock
# Create top level logger.
logger = ssdlog.make_logger('alarm_test', options)
statusFromGen2 = {}
logger.debug("Initializing remote objects")
if options.rohosts:
ro.init(options.rohosts.split(','))
else:
ro.init()
# Connect to the status service via a proxy object and fetch
# initial status items that we need
statusProxy = ro.remoteObjectProxy('status')
logger.info("Fetching initial status values")
statusFromGen2 = statusProxy.fetch(statusFromGen2)
logger.info('initial status %s' % statusFromGen2)
# make a name for our monitor
if options.monname:
myMonName = options.monname
else:
myMonName = 'alarm_test.mon'
# Create a local monitor
mymon = Monitor.Monitor(myMonName, logger, numthreads=options.numthreads)
# Subscribe our local callback function
fn = lambda payload, name, channels: status_cb(payload, logger, statusProxy
)
mymon.subscribe_cb(fn, sub_channels)
# Startup monitor
mymon.start(wait=True)
mymon.start_server(wait=True, port=options.monport)
# subscribe our monitor to the publication feed
mymon.subscribe_remote(options.monitor, sub_channels, {})
ev_quit = threading.Event()
testMethods = [
'changeFocus', 'doMethod', 'doAllMethods', 'listClasses',
'listAllTests', 'listTests', 'testEnviro'
]
alarmTestService = AlarmTestService(statusProxy, ev_quit)
alarm_test_svc = ro.remoteObjectServer(
svcname='alarm_test',
obj=alarmTestService,
logger=logger,
method_list=testMethods,
port=options.alarm_test_port,
ev_quit=ev_quit,
#auth=None,
usethread=True)
alarm_test_svc.ro_start(wait=True)
logger.info('Starting up main program...')
try:
try:
print "Type ^C to exit the server"
while True:
sys.stdin.readline()
except KeyboardInterrupt:
logger.info('Received keyboard interrupt--"shutting down...')
finally:
logger.info("shutting down...")
mymon.stop_server(wait=True)
alarm_test_svc.ro_stop(wait=True)
mymon.stop(wait=True)
class g2Disp(object):
def __init__(self, **kwdargs):
self.__dict__.update(kwdargs)
self.lock = threading.RLock()
self.procs = {}
# Needed for starting our own tasks
self.tag = 'g2disp'
self.shares = ['logger', 'threadPool']
def ro_echo(self, arg):
return arg
def start_server(self, rohosts, options):
# Initialize remoteObjects subsystem
try:
ro.init(rohosts)
except ro.remoteObjectError, e:
self.logger.error("Error initializing remote objects subsystem: %s" % \
str(e))
return
# channels we are interested in
channels = ['sound']
self.ev_quit = threading.Event()
self.server_exited = threading.Event()
# Create a local pub sub instance
# mymon = PubSub.PubSub('%s.mon' % self.basename, self.logger,
# numthreads=30)
monname = '%s.mon' % self.basename
mymon = Monitor.Monitor(monname, self.logger, numthreads=30)
self.monitor = mymon
self.soundsink = SoundSink.SoundSink(monitor=mymon,
logger=self.logger,
ev_quit=self.ev_quit)
self.soundsource = SoundSink.SoundSource(monitor=mymon,
logger=self.logger,
channels=['sound'])
# Subscribe our callback functions to the local monitor
mymon.subscribe_cb(self.soundsink.anon_arr, channels)
self.mon_server_started = False
self.ro_server_started = False
# Startup monitor threadpool
mymon.start(wait=True)
mymon.start_server(wait=True, port=options.monport)
self.mon_server_started = True
self.threadPool = self.monitor.get_threadPool()
# subscribe our monitor to the central monitor hub
mymon.subscribe_remote(options.monitor, channels, ())
# publish to central monitor hub
#mymon.subscribe(options.monitor, channels, ())
mymon.publish_to(options.monitor, ['sound'], {})
self.svc = ro.remoteObjectServer(
svcname=self.basename,
obj=self,
logger=self.logger,
port=options.port,
ev_quit=self.ev_quit,
threadPool=self.threadPool,
#auth=None,
usethread=True)
self.svc.ro_start(wait=True)
self.ro_server_started = True
if options.monitor:
# subscribe our monitor to the central monitor hub
mymon.subscribe_remote(options.monitor, channels, {})
# publishing for remote command executions
mymon.publish_to(options.monitor, ['sound'], {})
# Register local status info subscription callback
mymon.subscribe_cb(model.arr_status, ['status'])
# Create our remote service object
ctrlsvc = ro.remoteObjectServer(
svcname=options.svcname,
obj=statmon,
method_list=['close_plugin', 'close_all_plugins'],
logger=logger,
ev_quit=ev_quit,
port=options.port,
usethread=True,
threadPool=threadPool)
logger.info("Starting statmon service.")
ctrlsvc.ro_start()
try:
# Main loop to handle GUI events
statmon.mainloop(timeout=0.001)
except KeyboardInterrupt:
logger.error("Received keyboard interrupt!")
myhost,
purge_delta=options.purge_delta)
# Hack to use our local object as the name server for our local monitor
ro.default_ns = nsobj
threadPool = mymon.get_threadPool()
# Create remote object server for this object.
# svcname to None temporarily because we get into infinite loop
# try to register ourselves.
nssvc = ro.remoteObjectServer(name='names',
obj=nsobj,
svcname=None,
port=options.port,
logger=logger,
usethread=True,
threadPool=threadPool,
authDict=authDict,
secure=options.secure,
cert_file=options.cert)
# Subscribe our callback functions to the local monitor
#mymon.subscribe_cb(nsobj.ps_update, ['names'])
server_started = False
try:
try:
logger.info("Starting monitor...")
# Startup monitor threadpool
mymon.start(wait=True)
# Configure logger for logging via our monitor
if options.logmon:
minimon.logmon(logger, options.logmon, ['logs'])
# Set up authorization credentials?
# e.g. --auth='joe:pw1,bob:pw2,...
authDict = None
if options.auth:
authDict = dict(map(lambda s: s.split(':'),
options.auth.split(',')))
# Start remoteObjects server in the taskmgr
tm_svr = ro.remoteObjectServer(svcname=svcname,
obj=taskmgr, logger=logger,
ev_quit=ev_quit,
port=options.port,
authDict=authDict,
usethread=False,
threadPool=threadPool)
# Set allocations if specified
if options.allocs:
taskmgr.setAllocs(options.allocs.split(','))
# Load modules/tasks if specified
if options.load:
res = taskmgr.loadModules(options.load.split(','))
nocomplain = True
# Initialize load of PARA files if specified
if options.para:
starcat = StarCatalog(dbhost=options.dbhost,
logger=logger,
threadpool=threadpool)
# sh_keys={'ra':10.1, 'dec':10.0, 'fov':0.076, 'limitmag':13.0}
# ag_keys={'ra':10.0, 'dec':20.0, 'fov':0.076, 'probe_ra':10.0, 'probe_dec':20.0, 'focus':'CS', 'ins':'MOIRCS', 'probe_r':0.0, 'probe_theta':0.0, 'probe_x':0.0, 'probe_y':0.0, 'pa':0.0, 'limitmag':15.0, 'goodmag':10.0, 'fov_pattern':'STANDARD'}
# starcat.select_sh_stars(sh_keys)
#starcat.select_ag_stars(ag_keys)
# svr_started = False
svc = ro.remoteObjectServer(
svcname=options.svcname,
obj=starcat,
logger=logger,
port=options.port,
default_auth=None,
ev_quit=ev_quit,
usethread=False,
)
svc.ro_start(wait=True)
# svr_started = True
except KeyboardInterrupt:
print 'keyboard interrupting...'
quit()
except Exception as e:
logger.error('error: starting svc. %s' % str(e))
status = StatusServer(cso,
logger,
minimon,
monchannels=monchannels,
checkptfile=options.checkptfile)
# Initialize it
status.initialize()
# Register status callbacks to monitor channels
minimon.subscribe_local(status, ['statint'])
# Create RO server to handle fetch and store requests
status_svr = ro.remoteObjectServer(svcname=svcname,
obj=status,
logger=logger,
port=options.port,
ev_quit=ev_quit,
usethread=False)
try:
print "Press ^C to terminate the server."
status_svr.ro_start(wait=True)
svr_started = True
except KeyboardInterrupt:
logger.error("Caught keyboard interrupt!")
finally:
quit()
if __name__ == '__main__':
# 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)
fm = frameSvc(svcname, logger,
monitor=minimon, monchannels=monchannels)
threadPool = minimon.get_threadPool()
# Superclass constructor
svc = ro.remoteObjectServer(svcname=svcname,
obj=fm, logger=logger,
port=options.port,
usethread=True,
threadPool=threadPool)
# Create sun-rpc frame interface
svr = OSSS_FRAMEServer(logger=logger, frame_func=fm.getFrames)
logger.info("Starting frame service.")
try:
svc.ro_start(wait=True)
svc_started = True
svr.start(wait=True)
svr_started = True
while True:
if options.session:
try:
controller.config_from_session(options.session)
except Exception, e:
logger.error("Failed to initialize from session '%s': %s" %
(options.session, str(e)))
# Start up a remote object server for certain services provided by
# integgui2
svc = ro.remoteObjectServer(svcname=options.svcname,
obj=controller,
logger=logger,
method_list=[
'get_ope_paths', 'obs_play_sound_file',
'obs_timer', 'obs_confirmation',
'obs_userinput', 'obs_combobox',
'load_page'
],
port=options.port,
ev_quit=ev_quit,
usethread=True,
threadPool=threadPool)
# Load any files specified on the command line
for opefile in args:
gui.load_ope(opefile)
server_started = False
ro_server_started = False
try:
# Startup monitor threadpool
mymon.subscribe_remote(options.monitor, sub_channels, {})
ev_quit = threading.Event()
# Create an AlarmHandlerService object and connect it to a remote
# object server so that we can control the playing of the audio
alarmHandlerService = AlarmHandlerService(soundsink, svConfig,
statusValHistory,
options.persistDataFile, ev_quit)
alh_svc = ro.remoteObjectServer(
svcname='alarm_handler',
obj=alarmHandlerService,
logger=logger,
method_list=[
'masterMuteOff', 'masterMuteOn', 'playFile', 'muteOff', 'muteOn',
'startIgnoreAlarm', 'stopIgnoreAlarm', 'dumpSvConfigItem',
'loadSvConfig', 'reportHistory', 'purgeHistory',
'purgeHistoryLength', 'saveHistory', 'saveConfig'
],
port=options.alh_port,
ev_quit=ev_quit,
#auth=None,
usethread=True)
alh_svc.ro_start(wait=True)
purgeTask = Task.FuncTask2(alarmHandlerService.periodicPurge,
options.purgeMaxAgeDays, options.purgeMaxLength,
options.purgeInterval)
purgeTask.initialize(mymon)
mymon.get_threadPool().addTask(purgeTask)
## persistDataSaveTask = Task.FuncTask2(alarmHandlerService.periodicSave, options.persistDataSaveInterval)
