def setUp(self):
        self.env = environment.MockEnvironment()
        self.myhost = ro.get_myhost()
        self.rohosts = []
        self.ns = remoteObjectNameSvc.remoteObjectNameService(
            self.rohosts,
            name='remoteObjectNameServer',
            host=self.myhost,
            port=ro.nameServicePort)
        self.ns.ro_start()
        waitForService(self.ns, 'names')

        #print "Hosts for",'names',self.ns.getHosts('names')
        ro.init()

        self.initval = 'init'
        self.server = FakeServer(self.initval)

        self.servicename = 'TestServiceName2'
        self.ROserver = ro.remoteObjectServer(obj=self.server,
                                              name=self.servicename,
                                              svcname=self.servicename,
                                              usethread=True)
        self.ROserver.ro_start()
        waitForService(self.ns, self.servicename)
        #print "Hosts for",self.servicename,self.ns.getHosts(self.servicename)
        self.ROclient = ro.remoteObjectProxy(self.servicename)
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()

        self.myhost = ro.get_myhost()
        self.rohosts = []
        self.ns = remoteObjectNameSvc.remoteObjectNameService(
            self.rohosts,
            name='remoteObjectNameServer',
            host=self.myhost,
            port=ro.nameServicePort)
        self.ns.ro_start()
        waitForService(self.ns, 'names')
        #print "Status",self.ns.init0_up1_down2

        #print "Hosts for",'names',self.ns.getHosts('names')
        ro.init()
        #time.sleep(1)

        self.servicename = 'TestServiceName'
        self.ROserver = FakeROServer(self.servicename, usethread=True)
        self.ROserver.ro_start()
        waitForService(self.ns, self.servicename)
        #print "Hosts for",self.servicename,self.ns.getHosts(self.servicename)
        self.ROclient = ro.remoteObjectProxy(self.servicename)
        self.val1 = '1'
        self.val2 = self.val1 + "22"

        self.rofilename = self.env.INST_PATH + "/ROfilename"
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()
        mysqlarchiver._deleteMySQLArchiveDb()  # just in case
        (self.env.con,self.env.cur) = mysqlarchiver.initMySQLArchiveDb()
        self.framedb = archiver.SimFrameDBint(self.env)
        #import test_archiver
        #self.framedb = test_archiver.SimTestFrameDBint(self.env)
        self.iaq = 'SUKA'
        self.archmon = archiver.ArchiveMonitor(self.framedb,self.env)
        self.archivemgr = archiver.ArchiveMgr(self.framedb,self.archmon, self.env)
        self.framesrcSUKA = self.archivemgr.createFrameSourceA("SUK")
        self.basic = ['SIMPLE','BITPIX','NAXIS','EXTEND','PROP-ID',
                      'FRAMEID','RANDOM','OBCPMODE']
        self.basic.sort()
        self.archivemgr.registerKeywords(self.iaq,self.basic)
        import random
        #randokm.seed(0)  # force a random but repeatable sequence
        self.random = str(random.randrange(1000,1010))
        self.mode = "mode_"+str(random.randrange(0,10))

        self.obcpnum = 9
        self.ev_quit = threading.Event()
        # Timeout value for this task
        self.timeout = 20.0

        # Create monitor and other allocations
        self.monitor_name = 'monitor'
        self.monitor = Monitor.Minimon(self.monitor_name, logger=logger)
        
        myhost = SOSSrpc.get_myhost(short=True)
        statusDict = {}
        
        # Create and start the instrument interface
        self.insint = INSint.ocsInsInt(self.obcpnum, myhost, self.env.ARCH_PROP,
                                       statusDict, db=self.monitor,
                                       logger=logger, ev_quit=self.ev_quit)
        self.insint.start()

        # This is our set of allocations
        self.alloc = Bunch.Bunch(monitor=self.monitor,
                                 INSint9=self.insint,
                                 archmgr=self.archivemgr,
                                 status=None)

        # Create and start SIMCAM
        ocsint = DAQtk.ocsInt(self.obcpnum, logger=logger, ev_quit=self.ev_quit)
        simcam = SIMCAM.SIMCAM(logger, self.env, ev_quit=self.ev_quit)
        self.simcam = SIMCAM.OCSInterface(logger, ev_quit=self.ev_quit,
                                          ocsint=ocsint, instrument=simcam)
        self.simcam.start()

        # Create and start our task manager
        self.tm = TaskManager.TaskManager(logger=logger, internal_allocs=self.alloc)
        self.tm.setAllocs(['monitor', 'INSint9', 'archmgr'])
        self.tm.start()
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()
        self.obcpnum = 9
        self.ev_quit = threading.Event()

        # Create monitor and other allocations
        self.monitor_name = 'monitor'
        self.monitor = Monitor.Minimon(self.monitor_name, logger)
        
        myhost = SOSSrpc.get_myhost(short=True)

        # Create and start STARS simulator
        self.stars = STARSint.STARSsimulator(logger=logger, ev_quit=self.ev_quit)
        # Tell STARS how to contact us to copy files
        STARSint.add_transferParams('*',
                                    transfermethod='ssh',
                                    raidpath=self.env.ARCH_PATH,
                                    #username=os.getlogin(),
                                    username=os.environ['LOGNAME'],
                                    password='******')
        
        self.stars.start()

        # Create and start the STARS interface
        self.starsint = STARSint.STARSinterface(starshost=myhost,
                                                db=self.monitor, logger=logger,
                                                ev_quit=self.ev_quit)
        self.starsint.start()

        # This is our set of allocations
        self.alloc = Bunch.Bunch(monitor=self.monitor,
                                 STARSint=self.starsint,
                                 status=None)

        # Create and start our task manager
        self.tm = TaskManager.TaskManager(logger=logger, ev_quit=self.ev_quit,
                                          internal_allocs=self.alloc)
        self.tm.setAllocs(['monitor', 'STARSint'])
        self.tm.start()
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()
        self.obcpnum = 9
        self.fmtstr = 'EXEC SIMCAM FITS_FILE MOTOR=%(motor)s FRAME_NO=%(frame_no)s DELAY=%(delay)f'
        self.ev_quit = threading.Event()

        # Create monitor and other allocations
        self.monitor_name = 'monitor'
        self.monitor = Monitor.Minimon(self.monitor_name, logger)
        
        myhost = SOSSrpc.get_myhost(short=True)
        statusDict = {}
        
        # Create and start the instrument interface
        self.insint = INSint.ocsInsInt(self.obcpnum, myhost, self.env.ARCH_PROP,
                                       statusDict, db=self.monitor,
                                       logger=logger, ev_quit=self.ev_quit)
        self.insint.start()

        # This is our set of allocations
        self.alloc = Bunch.Bunch(monitor=self.monitor,
                                 INSint9=self.insint,
                                 status=None)

        # Create and start SIMCAM
        ocsint = DAQtk.ocsInt(self.obcpnum, logger=logger, ev_quit=self.ev_quit)
        self.simcam = SIMCAM.Instrument(logger, ev_quit=self.ev_quit,
                                        ocsint=ocsint, allowNoPara=True,
                                        env=self.env)
        self.simcam.loadPersonality('SIMCAM')
        #self.simcam.loadParaBuf(fits_file_para)
        self.simcam.start()

        # Create and start our task manager
        self.tm = TaskManager.TaskManager(logger=logger, ev_quit=self.ev_quit,
                                          internal_allocs=self.alloc)
        self.tm.setAllocs(['monitor', 'INSint9'])
        self.tm.start()
Ejemplo n.º 6
0
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()

        self.obcpnum = 9
        self.ev_quit = threading.Event()

        # Create mini monitor for INSint
        self.minimon = Monitor.Minimon('monitor', logger)

        myhost = SOSSrpc.get_myhost(short=True)

        raidpath = self.env.INST_PATH
        statusObj = INSint.FetchStatusWrapper_SOSS({})

        # Create and start the instrument interface
        self.insint = INSint.ocsInsInt(self.obcpnum,
                                       myhost,
                                       raidpath,
                                       statusObj,
                                       db=self.minimon,
                                       logger=logger,
                                       ev_quit=self.ev_quit)
        self.insint.start(wait=True)

        # Create and start SIMCAM
        ocsint = DAQtk.ocsInt(self.obcpnum,
                              logger=logger,
                              ev_quit=self.ev_quit)
        self.simcam = SIMCAM.Instrument(logger,
                                        ev_quit=self.ev_quit,
                                        ocsint=ocsint,
                                        allowNoPara=False,
                                        env=self.env)
        self.simcam.loadPersonality('SIMCAM')
        self.simcam.loadParaBuf(('SIMCAM', 'FITS_FILE'), fits_file_para)
        # Wait until SIMCAM is up and running
        self.simcam.start(wait=True)
Ejemplo n.º 7
0
    def setUp(self):
        self.env = environment.MockEnvironment()
        self.env.removeTestDirs()  # just in case
        self.env.makeDirs()

        self.ev_quit = threading.Event()

        # Create mini monitor for STARSint
        self.minimon = Monitor.Minimon('monitor', logger)

        myhost = SOSSrpc.get_myhost(short=True)

        # Create and start STARS simulator
        self.starssim = STARSint.STARSsimulator(logger=logger,
                                                ev_quit=self.ev_quit)
        # Tell STARS how to contact us to copy files
        STARSint.add_transferParams(
            '*',
            transfermethod='ssh',
            raidpath=self.env.ARCH_PATH,
            #username=os.getlogin(),
            username=os.environ['LOGNAME'],
            password='******')

        self.starssim.start()

        # Create and start the STARS interface
        self.starsint = STARSint.STARSinterface(starshost=myhost,
                                                db=self.minimon,
                                                logger=logger,
                                                ev_quit=self.ev_quit)
        self.starsint.start()

        # Wait until STARS simulator is up and running
        # TODO: figure out a way to synchronize on the portmapper
        time.sleep(0.0)