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)