def setUp(self):
     self.rt = Configuration(logger=logger)
     self.fileName = './rts2saf-bootes-2.cfg'
     self.success = self.rt.readConfiguration(fileName=self.fileName)
     self.proxy = JSONProxy(url=self.rt.cfg['URL'],
                            username=self.rt.cfg['RTS2_HTTPD_USERNAME'],
                            password=self.rt.cfg['PASSWORD'])
     self.rts2safFoc = CheckDevices(debug=False,
                                    proxy=self.proxy,
                                    blind=None,
                                    verbose=None,
                                    ccd=None,
                                    ftws=None,
                                    foc=None,
                                    logger=logger)
#!/usr/bin/python

from rts2saf.log import Logger
from rts2saf.rts2exec import Rts2Exec
from rts2.json import JSONProxy


class Args(object):
    def __init__(self):
        pass


args = Args()
args.toPath = '/var/log'
args.logfile = 'rts2-debug'
args.level = 'DEBUG'

debug = False
logger = Logger(debug=debug, args=args).logger

proxy = JSONProxy()
ex = Rts2Exec(debug=debug, proxy=proxy, logger=logger)
ex.reeanableEXEC()
logger.info('rts2saf_reenable_exec.py:  reenabled EXEC')
Beispiel #3
0
    if not args.blind and args.focRange:
        logger.error(
            'rts2saf_focus: --focrange has no effect without --blind'.format(
                args.focRange))
        sys.exit(1)

    if args.focRange:
        if (args.focRange[0] >= args.focRange[1]) or args.focRange[2] <= 0:
            logger.error('rts2saf_focus: bad range values: {}, exiting'.format(
                args.focRange))
            sys.exit(1)

    # establish a connection
    proxy = JSONProxy(url=rt.cfg['URL'],
                      username=rt.cfg['USERNAME'],
                      password=rt.cfg['PASSWORD'])
    try:
        proxy.refresh()
    except Exception, e:
        logger.error(
            'rts2saf_focus: no JSON connection for: {0}, {1}, {2}'.format(
                rt.cfg['URL'], rt.cfg['USERNAME'], rt.cfg['PASSWORD']))
        sys.exit(1)

    # create all devices
    # attention: .create() at the end
    # filters are not yet devices
    # check always True, we need to set limits either from device or from configuration
    foc = CreateFocuser(debug=args.debug,
                        proxy=proxy,
Beispiel #4
0
    def setupDevices(self, blind=False):
        # setup rts2saf
        # fake arguments
        self.args = Args()
        self.args.sxDebug = False
        self.args.blind = blind
        self.args.verbose = False
        self.args.check = True
        self.args.fetchOffsets = True
        self.args.exposure = 1.887
        self.args.catalogAnalysis = False
        self.args.Ds9Display = False
        self.args.FitDisplay = False
        self.args.flux = True
        self.args.dryFitsFiles = '../samples_bootes2'
        # JSON
        self.proxy = JSONProxy(url=self.rt.cfg['URL'],
                               username=self.rt.cfg['USERNAME'],
                               password=self.rt.cfg['PASSWORD'])
        # create Focuser
        self.foc = CreateFocuser(debug=False,
                                 proxy=self.proxy,
                                 check=self.args.check,
                                 rt=self.rt,
                                 logger=logger).create()
        # create filters
        fts = CreateFilters(debug=False,
                            proxy=self.proxy,
                            check=self.args.check,
                            rt=self.rt,
                            logger=logger).create()
        # create filter wheels
        ftwc = CreateFilterWheels(debug=False,
                                  proxy=self.proxy,
                                  check=self.args.check,
                                  rt=self.rt,
                                  logger=logger,
                                  filters=fts,
                                  foc=self.foc)
        ftws = ftwc.create()
        if not ftwc.checkBounds():
            logger.error(
                'setupDevice: filter focus ranges out of bounds, exiting')
            sys.exit(1)

        # create ccd
        ccd = CreateCCD(debug=False,
                        proxy=self.proxy,
                        check=self.args.check,
                        rt=self.rt,
                        logger=logger,
                        ftws=ftws,
                        fetchOffsets=self.args.fetchOffsets).create()

        cdv = CheckDevices(debug=False,
                           proxy=self.proxy,
                           blind=self.args.blind,
                           verbose=self.args.verbose,
                           ccd=ccd,
                           ftws=ftws,
                           foc=self.foc,
                           logger=logger)
        cdv.summaryDevices()
        cdv.printProperties()
        cdv.deviceWriteAccess()
        dryFitsFiles = None
        if self.args.dryFitsFiles:
            dryFitsFiles = glob.glob('{0}/{1}'.format(
                self.args.dryFitsFiles, self.rt.cfg['FILE_GLOB']))
            if len(dryFitsFiles) == 0:
                logger.error('setupDevice: no FITS files found in:{}'.format(
                    self.args.dryFitsFiles))
                logger.info(
                    'setupDevice: download a sample from wget http://azug.minpet.unibas.ch/~wildi/rts2saf-test-focus-2013-09-14.tgz'
                )
                sys.exit(1)

        # ok evrything is there
        self.rts2safFoc = Focus(debug=False,
                                proxy=self.proxy,
                                args=self.args,
                                dryFitsFiles=dryFitsFiles,
                                ccd=ccd,
                                foc=self.foc,
                                ftws=ftws,
                                rt=self.rt,
                                ev=self.ev,
                                logger=logger)
Beispiel #5
0
        rt.cfg['WITH_MATHPLOTLIB'] = True

    # get the environment
    ev=Environment(debug=args.debug, rt=rt,logger=logger)

    if not args.blind and args.focRange:
        logger.error('rts2saf_focus: --focrange has no effect without --blind'.format(args.focRange))
        sys.exit(1)

    if args.focRange:
        if (args.focRange[0] >= args.focRange[1]) or args.focRange[2] <= 0: 
            logger.error('rts2saf_focus: bad range values: {}, exiting'.format(args.focRange))
            sys.exit(1)

    # establish a connection
    proxy=JSONProxy(url=rt.cfg['URL'],username=rt.cfg['RTS2_HTTPD_USERNAME'],password=rt.cfg['PASSWORD'])
    try:
        proxy.refresh()
    except Exception, e:
        logger.error('rts2saf_focus: no JSON connection for: {0}, {1}, {2}'.format(rt.cfg['URL'],rt.cfg['RTS2_HTTPD_USERNAME'],rt.cfg['PASSWORD']))
        sys.exit(1)

    # create all devices
    # attention: .create() at the end
    # filters are not yet devices
    # check always True, we need to set limits either from device or from configuration
    foc= CreateFocuser(debug=args.debug, proxy=proxy, check=True, rangeFocToff=args.focRange, blind=args.blind, verbose=args.verbose, rt=rt, logger=logger).create()
    if foc==None or not isinstance(foc, Focuser):
        logger.error('rts2saf_focus: could not create object for focuser: {}, exiting'.format(rt.cfg['FOCUSER_NAME']))
        sys.exit(1)
Beispiel #6
0
        q = None
        rts2.createProxy(url=rt.cfg['URL'], username=rt.cfg['RTS2_HTTPD_USERNAME'], password=rt.cfg['PASSWORD'])
        try:
            q = rts2.Queue(rts2.json.getProxy(), args.queue)
        except Exception, e:
            logger.error('rts2af_fwhm: no queue named: {0}, doing nothing'.format(args.queue))

        if q is not None:
            q.load()
            for x in q.entries:
                if x.get_target().name and 'OnTargetFocus' in x.get_target().name:
                    q.clear()
                    logger.info('rts2af_fwhm: cleared queue: {}'.format(args.queue))
                    break
    else:
        proxy=JSONProxy(url=rt.cfg['URL'],username=rt.cfg['RTS2_HTTPD_USERNAME'],password=rt.cfg['PASSWORD'])
        try:
            proxy.refresh()
        except Exception, e:
            logger.warn('rts2af_fwhm: JSON proxy connection failed: {}, exiting'.format(e))
            sys.exit(1)

        tarType = proxy.getSingleValue('EXEC','current_type')
        tarName = proxy.getSingleValue('EXEC','current_name')
        if 'GLORIA teleoperation' in tarName: # reserved observing time
            logger.info('rts2af_fwhm: there is a ongoing GLORIA teleoperation, no focus run queued')
        elif 'G' in tarType: # it is a GRB
            logger.info('rts2af_fwhm: there is now a GRB target selected, no focus run queued')

        else:
            q = None
Beispiel #7
0
            logger.error(
                'rts2af_fwhm: no queue named: {0}, doing nothing'.format(
                    args.queue))

        if q is not None:
            q.load()
            for x in q.entries:
                if x.get_target().name and 'OnTargetFocus' in x.get_target(
                ).name:
                    q.clear()
                    logger.info('rts2af_fwhm: cleared queue: {}'.format(
                        args.queue))
                    break
    else:
        proxy = JSONProxy(url=rt.cfg['URL'],
                          username=rt.cfg['USERNAME'],
                          password=rt.cfg['PASSWORD'])
        try:
            proxy.refresh()
        except Exception, e:
            logger.warn(
                'rts2af_fwhm: JSON proxy connection failed: {}, exiting'.
                format(e))
            sys.exit(1)

        tarType = proxy.getSingleValue('EXEC', 'current_type')
        tarName = proxy.getSingleValue('EXEC', 'current_name')
        if 'GLORIA teleoperation' in tarName:  # reserved observing time
            logger.info(
                'rts2af_fwhm: there is a ongoing GLORIA teleoperation, no focus run queued'
            )