def receive_response(self, fields):
cmd = fields["cmd"]
print("cmd respone:{}".format(cmd))
if cmd == Commands.REGISTER_IMAGEVIEWER:
#1. TODO handle it in new way (below)
print("response:REGISTER_IMAGEVIEWER")
# data = fields["data"] # save controllerID to use
# # will send setSize inside
# # self.controllerID = data
# self.image_viewer.set_controllerID(data)
# ImageController.parseReigsterViewResp(self.m_client, data)
self.sync_connected_queue.put(connect_response)
# elif cmd == command_REQUEST_FILE_LIST:
# print("response:REQUEST_FILE_LIST:")
# data = fields["data"]
# files = data["dir"]
# rootDir= data["name"]
# self.remote_current_folder = rootDir
# # print("files:{};dir:{}".format(files, rootDir))
# self.print_file_list(rootDir, files)
# dprint("response:REQUEST_FILE_LIST end")
# self.sync_connected_queue.put("get file list resp")
# elif cmd == command_SELECT_FILE_TO_OPEN:
# print("response:SELECT_FILE_TO_OPEN")
# else:
ApiService.instance().consume_response(fields)
def sendRegiserView(self):
dprint("sendRegiserView")
# cmd = '/CartaObjects/ViewManager:registerView'
# const cmd = Commands.REGISTER_IMAGEVIEWER; // '/CartaObjects/ViewManager:registerView';
params = 'pluginId:ImageViewer,index:0'
# // this.BASE_PATH = this.SEP + this.CARTA + this.SEP;
# // return `${this.BASE_PATH + this.VIEW_MANAGER + this.SEP_COMMAND}registerView`;
ApiService.instance().send_command(Commands.REGISTER_IMAGEVIEWER,
params, self.registerview_callback)
def registerview_callback(self, result):
# if error:
# dprint(error)
# return
dprint("in registerview_callback")
dprint(result)
data = result["data"] # save controllerID to use
# will send setSize inside
# self.controllerID = data
self.controllerID = data
view_name = data + "/view"
width = 637 #// TODO same as the experimental setting in ImageViewer, change later
height = 677
# client.call(setSizeCmd, [viewName, width, height], self.setSizeCallback)
ApiService.instance().setup_size(view_name, width, height)
def __init__(self, user, password):
self.url = 'ws://127.0.0.1:3000/websocket'
self.m_client = None
self.m_client = None
self.use_other_session = False
# SessionManager.instance() = SessionManager()
self.user = user
self.password = password
# self.remote_current_folder = None
# if session != None:
# SessionManager.instance().use_other_session(session)
# self.use_other_session = True
# dprint("test:{}".format(testtest))
# self.sefSessionID = None
# self.controllerID = None
# https://stackoverflow.com/questions/43471696/sending-data-to-a-thread-in-python
self.sync_connected_queue = queue.Queue()
# self.numberOfImages = 0
self.debug_image_queue = None
# self.testimage = 0
# if isnotebook():
# dprint("is notebook")
# import matplotlib
# matplotlib.use('TkAgg')
# sys.exit()
self.m_client = MeteorClient(self.url)
# self.controllerID = None
self.file_manager = FileManager()
self.image_viewer = ImageViewer()
ApiService.instance().set_client(self.m_client)
if run_from_interactive():
dprint("is ipython, setup matplotlib")
plt.ion()
plt.figure()
plt.show()
else:
dprint("not ipython")
def selectFileToOpen(self, file, folder):
# time.sleep(10) # 10 for testing sharing session between python and browser
home = expanduser("~")
# print(home)
# path = home + "/CARTA/Images/" + file
path = folder + "/" + file
# controllerID = state.imageController.controllerID;
parameter = "id:" + self.controllerID + ",data:" + path
print("query file list parameter:", parameter)
# console.log('inject file parameter, become:', parameter);
#
# Meteor.call('sendCommand', Commands.SELECT_FILE_TO_OPEN, parameter, SessionManager.get_suitable_session(), (error, result) => {
# console.log('get select file result:', result);
# });
# self.image_viewer.controllerID, file, self.files().remote_current_folder
# client.call(sendCmd, [Commands.SELECT_FILE_TO_OPEN, parameter, session], selectFile_callback)
ApiService.instance().send_command(Commands.SELECT_FILE_TO_OPEN,
parameter, self.selectFile_callback)
def request_file_list(self, user_callback=None):
# TODO do not pass session or client directly to this class, later.
# use the way newMeteorCARTA uses, apiService
# self.queryServerFileList(self.session_manager.get(), self.client)
dprint("queryServerFileList")
params = 'path:'
data = ApiService.instance().send_command(
Commands.REQUEST_FILE_LIST, params, self.query_file_list_callback,
user_callback)
print('after send request file list, return data')
return data
def serviceLoop(self, settings, logger):
"""Monitor service managers.
Starts up the managers and then actively monitor their status.
Arguments:
settings (json) : global settings
"""
activeServices = []
watcherWaitCycle = int(settings['statusReportingInterval'])
serviceWaitCycle = int(
settings['waitSecondsBeforeStartingNextService'])
exitWaitCycle = int(settings['waitSecondsBeforeExiting'])
shutdownEvent = multiprocessing.Event()
## Construct each Service
transportService = TransportService(shutdownEvent, settings)
apiService = ApiService(shutdownEvent, settings)
contentGatheringService = ContentGatheringService(
shutdownEvent, settings)
resultProcessingService = ResultProcessingService(
shutdownEvent, settings)
queryService = QueryService(shutdownEvent, settings)
universalJobService = UniversalJobService(shutdownEvent, settings)
logCollectionService = LogCollectionService(shutdownEvent, settings)
## Add to the list of services
activeServices.append(transportService)
activeServices.append(apiService)
activeServices.append(contentGatheringService)
activeServices.append(resultProcessingService)
activeServices.append(queryService)
activeServices.append(universalJobService)
activeServices.append(logCollectionService)
## Conditionally start/add the local service (ServerSideService)
if settings['startServerSideService']:
serverSideService = ServerSideService(shutdownEvent, settings)
activeServices.append(serverSideService)
## Start the services as separate processes
for thisService in activeServices:
thisService.start()
logger.info('Started {} with PID {}'.format(
thisService.name, thisService.pid))
## Default 2 second sleep between service starts
time.sleep(serviceWaitCycle)
logger.info('Status of services:')
for thisService in activeServices:
if not thisService.is_alive():
logger.error(' {}: stopped with exit code [{}]'.format(
thisService.name, thisService.exitcode))
else:
logger.info(' {}: running'.format(thisService.name))
## Wait loop
logger.info('Starting main loop - {}'.format(time.strftime('%X %x')))
while True:
try:
if self.stopFlag:
raise KeyboardInterrupt()
## Message on any failing services
for thisService in activeServices:
if not thisService.is_alive():
logger.error(
' {}: stopped with exit code [{}]'.format(
thisService.name, thisService.exitcode))
## Avoiding join() with the processes (from the multiprocessing
## internals), since we're not waiting for them to finish. They
## will always be running, so this loop is just for monitoring
## and messaging. Any interrupt signals will be sent to the sub-
## processes, and intentional shutdown requests are handled here.
win32event.WaitForSingleObject(self.eventFlag, 10000)
except (KeyboardInterrupt, SystemExit):
print('Interrrupt received; notifying services to stop...')
logger.debug(
'Interrrupt received; notifying services to stop...')
shutdownEvent.set()
## Wait for threads to finish graceful shutdown
time.sleep(exitWaitCycle)
break
except:
stacktrace = traceback.format_exception(
sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
logger.debug(
'Exception in watcher loop: {}'.format(stacktrace))
logger.debug('Notifying services to stop...')
shutdownEvent.set()
time.sleep(exitWaitCycle)
break
## end serviceLoop
return