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 start(self):
self.logger.info("starting ANA plugin for propid: {}".format(
self.propid))
# Startup monitor threadpool
self.monitor.start(wait=True)
# start_server is necessary if we are subscribing, but not if only
# publishing
#self.logger.info("starting monitor on port {}".format(self.monport))
#self.monitor.start_server(wait=True, port=self.monport)
# subscribe our monitor to the central monitor hub
#self.monitor.subscribe_remote(self.monitor_name, self.channels, {})
# publishing for remote command executions
self.monitor.publish_to('monitor', ['g2task'], {})
# Create our remote service object
threadPool = self.fv.get_threadPool()
# methods that can be called from outside via our service
method_list = ['callGlobalPlugin2']
self.viewsvc = ro.remoteObjectServer(svcname=self.svcname,
obj=self,
logger=self.logger,
ev_quit=self.fv.ev_quit,
port=self.port,
usethread=True,
threadPool=threadPool,
method_list=method_list)
self.logger.info("starting ANA service on port {}".format(self.port))
self.viewsvc.ro_start()
if not have_inotify:
self.logger.warning("'inotify' package needs to be installed to "
"monitor for files to be loaded")
else:
self.fv.nongui_do(self.watch_loop, self.fv.ev_quit)
self.logger.info("ANA plugin started.")
def start(self, portbase=None, wait=True):
# Start the instrument(s)
for cam in self.cams.keys():
self.startCam(cam, wait=wait)
# start the command servers
self.ro_svc = {}
i = 0
for cam in self.cams.keys():
port = None
if portbase is not None:
port = portbase + i
self.ro_svc[cam] = ro.remoteObjectServer(
cam,
obj=self,
logger=self.logger,
port=port,
method_list=['executeCmd', 'reload_module'],
usethread=True,
threadPool=self.threadPool)
self.ro_svc[cam].ro_start(wait=True)
i += 1
nsobj = remoteObjectNameService(mymon, logger, 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,
transport=ro.ns_transport,
encoding=ro.ns_encoding,
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)
# start_server is necessary if we are subscribing, but not if only
def start_server(self, rohosts, options):
# Initialize remoteObjects subsystem
try:
ro.init(rohosts)
except ro.remoteObjectError as 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=options.numthreads,
ev_quit=self.ev_quit)
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
def main(options, args):
basename = options.svcname
logger = ssdlog.make_logger(basename, options)
# Initialize remote objects subsystem
args = ['localhost']
if options.rohosts is not None:
args = options.rohosts.split(',')
try:
ro.init(args)
except ro.remoteObjectError as e:
logger.error("Error initializing remote objects subsystem: %s" % \
str(e))
sys.exit(1)
ev_quit = threading.Event()
# Create a local pub sub instance
monname = '%s.mon' % basename
minimon = Monitor.Monitor(monname, logger, numthreads=options.numthreads)
threadPool = minimon.get_threadPool()
queue = Queue.Queue()
channels = options.channels.split(',')
# Make our callback object/remote object
if options.soundsink:
mobj = SoundSink(monitor=minimon, logger=logger, queue=queue,
channels=channels, ev_quit=ev_quit,
dst=options.destination)
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'])
if options.soundsink:
# Subscribe our callback functions to the local monitor
minimon.subscribe_cb(mobj.anon_arr, channels)
minimon.subscribe_remote(options.monitor, channels, {})
else:
# publish our channels to the specified monitor
minimon.publish_to(options.monitor, channels, {})
svc.ro_start(wait=True)
ro_server_started = True
try:
mobj.server_loop()
except KeyboardInterrupt:
logger.error("Received keyboard interrupt!")
finally:
ev_quit.set()
if mon_server_started:
minimon.stop_server(wait=True)
if ro_server_started:
svc.ro_stop(wait=True)
minimon.stop(wait=True)
logger.info("%s exiting..." % basename)
