def start(self,
command,
arguments,
on_started=None,
on_exit=None,
env=None):
if self.is_running():
raise RuntimeError('Process is already running.')
args = [command]
args.extend(arguments)
if env is None:
env = clean_environment()
def run_process():
with open(self.stdout_path, 'w') as stdout_fd:
with open(self.stderr_path, 'w') as stderr_fd:
self.process = subprocess.Popen(args,
stdout=stdout_fd,
stderr=stderr_fd,
env=env)
if on_started:
on_started(self)
self.process.wait()
if on_exit:
on_exit(self)
start_thread(target=run_process)
def shoot(self, guider_id, exposure, initial_pause):
if exposure < 30:
raise BadRequestError('Exposure should be at least 30 seconds')
guider = [
g for g in controller.indi_server.guiders() if g.id == guider_id
]
if not guider:
raise BadRequestError('Guider not found: {} (guiders: {})'.format(
guider_id,
', '.join([g.id for g in controller.indi_server.guiders()])))
start_thread(self.__darv, guider[0], exposure, initial_pause)
return {'started': 'ok'}
def __start_slew_solver(self, options):
if not 'cameraOptions' in options:
raise BadRequestError(
'You need to capture from camera when using Slew mode')
if not 'target' in options:
raise BadRequestError('You need a target when using Slew mode')
if not 'telescope' in options:
raise BadRequestError('You need a telescope when using Slew mode')
self.solver_thread = start_thread(self.__slew_solver_thread, options)
return self.to_map()
def __init__(self):
self.settings = settings
settings.add_update_listener(self.__on_settings_update)
self.indi_profiles = SavedList(INDIProfile)
self.sequences_runner = SequencesRunner(logger, self)
self.sequences = None
self.ping_thread = start_thread(self.__ping_clients)
self.__create_indi_service()
self.__create_indi_server()
self.sequences = SavedList(Sequence)
self.astrometry_downloader = AstrometryIndexDownloader(event_listener)
self.platesolving = PlateSolving(self.indi_server, event_listener)
def __init__(self, on_saved, on_error):
self.files_queue = mp_queue(SaveAsyncFITS.MAX_QUEUE_SIZE)
self.notify_queue = mp_queue()
self.process_files = mp_start_process(self.__process_sequence_files,
self.files_queue,
self.notify_queue)
self.notify_thread = start_thread(self.__notify_sequence_finished,
self.notify_queue)
self.on_saved = on_saved
self.on_error = on_error
def __init__(self):
self.sse = SSE(app.logger)
self.settings = settings
settings.on_update = self.__on_settings_update
self.indi_profiles = SavedList(INDIProfile)
self.event_listener = EventListener(self.sse)
self.sequences_runner = SequencesRunner(app.logger, self)
self.sequences = None
self.ping_thread = start_thread(self.__ping_clients)
self.__create_indi_service()
self.__create_indi_server()
self.sequences = SavedList(Sequence)
self.astrometry_downloader = AstrometryIndexDownloader(
self.event_listener)
def __start_solver(self, options):
temp_path = os.path.join(StaticSettings.ASTROMETRY_TEMP_PATH,
'solve_field_{}'.format(time.time()))
os.makedirs(temp_path, exist_ok=True)
fits_file_path = None
logger.debug('Solve field options: %s',
self.__platesolving_options_log(options))
if 'fileBuffer' in options:
data = base64.b64decode(
options['fileBuffer']
[options['fileBuffer'].find(PlateSolving.DATAURL_SEPARATOR) +
len(PlateSolving.DATAURL_SEPARATOR):])
fits_file_path = self.__data_to_fits(data, temp_path)
elif 'filePath' in options and os.path.isfile(options['filePath']):
fits_file_path = options['filePath']
elif 'cameraOptions' in options:
from system import controller
cameraOptions = options['cameraOptions']
camera = controller.indi_server.get_camera(
cameraOptions['camera']['id'])
logger.debug('Shooting on camera {} with options {}'.format(
camera, cameraOptions))
result = camera.shoot_image(cameraOptions)
logger.debug('Shoot successfull: {}'.format(result))
fits_file_path = result['filename']
else:
raise BadRequestError(
'You must pass either a fileBuffer object (data-uri formatted) or a filePath argument'
)
resolution = None
with fits.open(fits_file_path) as fits_file:
resolution = fits_file[0].data.shape
if options.get('sync', False):
return self.__wait_for_solution(options, resolution,
fits_file_path, temp_path)
else:
self.solver_thread = start_thread(self.__async_wait_for_solution,
options, resolution,
fits_file_path, temp_path)
return self.to_map()
def connect(self, hostname='localhost', port=4400):
self.__connect = True
self.__thread = start_thread(self.__socket_loop, hostname, port)
return self.__get_result().get('connected', False)
def __init__(self, sequence, controller, logger, on_finished=None):
self.sequence = sequence
self.controller = controller
self.logger = logger
self.thread = start_thread(self.__run)
self.on_finished = on_finished
def broadcast_service():
start_thread(__broadcast_loop)
def on_start(self):
logger.debug('PHD2 Service started')
self.__change_state(True, key='running', publish=False)
self.__events_thread = start_thread(self.__check_events)
def publish(self, data, type):
start_thread(self.__publish_to_clients, data, type)
def start(self):
self.last_connection_check = time.time()
start_thread(self.__loop)