def disconnect(self): ''' Override this method. ''' global CALLBACKS #tell threads to stop self.running = 0 #give them a few seconds to stop executing sleep(2) #first destroy all consumers self.getLogger().logInfo("Disconnecting all administrative consumers...") for key in self.channels.keys(): self.channels[key][CONSUMER].disconnect() #next notify all callbacks that we're shutting down self.getLogger().logInfo("Disconnecting all registered callbacks...") for cb in CALLBACKS: try: cb.done("The ACSEventAdmin is shutting down.", Completion(long(0), long(0), long(0), []), CBDescOut(long(0), long(0))) except: self.getLogger().logWarning("Failed to invoke done method on a callback!") print_exc() #now delete member data self.channels = {} CALLBACKS = [] PySimpleClient.disconnect(self) return
class TestStorageMethods(unittest.TestCase): def test_full(self): self.client = PySimpleClient() self.storage = self.client.getComponent("STORAGE") self.storage.clearAllData() targets = [] images = [] for i in range(10): targets.append(TYPES.Target(i, TYPES.Position(10.0, 45.0), 2)) image = bytearray() for j in range(1000000): image.append(j % 256) images.append(bytes(image)) proposal = TYPES.Proposal(0, targets, 0) self.storage.storeObservation(proposal, images) id = self.storage.getNextValidId() print "ID", id self.assertEqual(1, id, "Checking ID") result = self.storage.getObservation(0) self.assertEqual(10, len(result), "Number of observations") self.storage.clearAllData() self.client.releaseComponent(self.storage._get_name())
def set_array_frec(): client = PySimpleClient() master = client.getComponent("CONTROL/MASTER") arrayList = master.getAutomaticArrayComponents() + master.getManualArrayComponents() for array in arrayList: master.destroyArray(array.ComponentName) arrayList = [] antennas = master.getAvailableAntennas() master.createManualArray(antennas) arrayList = master.getAutomaticArrayComponents() + master.getManualArrayComponents() if ( arrayList != 1 ): if( len(arrayList) == 0): print "Could not create an array!!" client.releaseComponent("CONTROL/MASTER") sys.exit(0) else: print "Could not destroy previosly arrays and create a new fresh array!" client.releaseComponent("CONTROL/MASTER") sys.exist(0) currentArray = client.getComponent(arrayList[0].ComponentName) client.releaseComponent("CONTROL/MASTER") setArrayName(currentArray.getArrayName()) array = getArray() tp = array.getTotalPowerObservingMode() return tp
def subsystemsOffline(self, subsystem): from Acspy.Clients.SimpleClient import PySimpleClient client = PySimpleClient() mcI = client._ContainerServices__importComponentStubs(comp_type="IDL:alma/ACS/MasterComponent:1.0") subsystem = client.getComponent(subsystem) subsystem.doTransition(mcI.SUBSYSEVENT_SHUTDOWNPASS1) (state, flag) = self.__waitForSubsystemState(subsystem._get_currentStateHierarchy(), "AVAILABLE.OFFLINE.PRESHUTDOWN", 300) if flag is False: return (state, flag) subsystem.doTransition(mcI.SUBSYSEVENT_SHUTDOWNPASS2) (state, flag) = self.__waitForSubsystemState(subsystem._get_currentStateHierarchy(), "AVAILABLE.OFFLINE.SHUTDOWN", 300) if flag is False: return (state, flag) return (state, flag)
def __init__(self): try: #This stuff is only for get the antennas of a manual array from Acspy.Clients.SimpleClient import PySimpleClient c = PySimpleClient() master = c.getComponent('CONTROL/MASTER') arrayname = master.getManualArrays() array = c.getComponent('CONTROL/'+arrayname[0]) self.antennalist = array.getAntennas() self.logger = getLogger() del master del array c.disconnect() except Exception, e: print e
def setUp(self): """ Test case fixture. """ self.client = PySimpleClient("ServerRepresentationTest") self.simulator = self.client.getComponent("SIMULATION_SERVER") self.lamp = self.client.getComponent("LAMP_ACCESS")
def checkOnline(self): masters_states = [] from Acspy.Clients.SimpleClient import PySimpleClient masters_comps = self.parser.get_masters_from_execconfig() for master in masters_comps: client = PySimpleClient() subsystem = client.getComponent(master) currentStateHierarchy = subsystem._get_currentStateHierarchy() state = currentStateHierarchy.get_sync() #if (state[0][1] is 'OPERATIONAL'): masters_states.append([master,state[0][1]]) for state in masters_states: if(state[1] == 'OPERATIONAL'): print state pass else: return state return "OK"
class EventSubscriberImplTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceEventSubscriberImpl" self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect()
def __init__(self, compname, comp_type): BaseRepresentation.__init__(self, compname) self.comp_type = comp_type self.simulator = None self.client = PySimpleClient() self.simulator = None try: self.simulator = self.client.getDefaultComponent("IDL:alma/ACSSim/Simulator:1.0") except NoDefaultComponentEx, ex: # fine, no Simulator Server component defined in the CDB pass
def run(self): self.simpleClient = PySimpleClient.getInstance() self.ccinstance = self.simpleClient.getDefaultComponent("IDL:alma/CSATCONTROL_MODULE/CSATControl:1.0") self.csinstance = self.simpleClient.getDefaultComponent("IDL:alma/CSATSTATUS_MODULE/CSATStatus:1.0") self.cupd = coorUpdater(self.ra,self.dec,self.csinstance) self.iupd = imgUpdater(self.img,self.ccinstance) self.csinstance.on() self.cupd.start() if(self.video): self.iupd.start() gtk.main()
def __init__(self, name="ACS Event Admin Client"): ''' Just call superclass constructors here. ''' PySimpleClient.__init__(self, name) #dictionary which consists of all active channels #the keys here are the channelNames in string format self.channels = {} #so long as this evaluates to true, the thread continues executing self.running = 1 #start a new thread to continuously look for new channels in the naming #service self.getLogger().logInfo("Creating a thread to poll the CORBA Naming Service for new channels...") #Get the Naming Service helper class self.nt = NameTree.nameTree(getORB()) start_new_thread(self.pollNamingService, ()) return
def get_mgr_instance(self,antenna): ''' Get dinamic component instance ''' from Acspy.Clients.SimpleClient import PySimpleClient mgr = None sys.stdout = open("/dev/null", "w") client = PySimpleClient("CAN STATUS") sys.stdout = sys.__stdout__ deployed_mgrs = client.availableComponents(type_wildcard='IDL:alma/Control/AmbManager:1.0') for deployed_mgr in deployed_mgrs: if deployed_mgr.name.__contains__(antenna) : print "Trying to get ambManager from %s" % antenna try: mgr= client.getDynamicComponent(deployed_mgr.name, deployed_mgr.type, deployed_mgr.code, deployed_mgr.container_name) except maciErrType.CannotGetComponentEx, e: print e[0].shortDescription sys.exit(-1) except Exception, e: print e sys.exit(-1) break
def mostRecentAsdm(date=None) : if date == None : date='%4.2d-%2.2d-%2.2d'%(time.gmtime()[0], time.gmtime()[1], time.gmtime()[2]) client = PySimpleClient() archConn = client.getComponent('ARCHIVE_CONNECTION') archOp = archConn.getOperational('XMLQueryTest') uids = archOp.queryRecent('ASDM',date+'T00:00:00.000') asdm_name=[] for uid in uids: result = archOp.retrieveDirty(uid) dataSet = ArchivedAsdm(result.xmlString) dateOfCreation = dataSet.getDateOfCreation() if dataSet.isAsdm() & (dateOfCreation==date): asdm_name.append("%s \t%s" % (dateOfCreation,uid)) asdm_name.sort() client.releaseComponent('ARCHIVE_CONNECTION') client.disconnect() if len(asdm_name) == 0 : print 'there are no asdms for %s' % date return None else : return asdm_name[-1].split('\t')[1]
def mostRecentAsdm(date = None): ''' Get the most recent Asdm, given a date. If the date is None, it takes the actual hour. return asdm or None ''' from Acspy.Clients.SimpleClient import PySimpleClient from ArchivedAsdm import ArchivedAsdm if date == None : date_T = '%4.2d-%2.2d-%2.2dT00:00:00.000' % (gmtime()[0] , gmtime()[1] , gmtime()[2]) date = '%4.2d-%2.2d-%2.2d'% (gmtime()[0] , gmtime()[1] , gmtime()[2]) else: date_T = '%4.2d-%2.2d-%2.2dT%2.2d:00:00.00' % (date[0] , date[1] , date[2] , date[3]) date = '%4.2d-%2.2d-%2.2d'% (date[0] , date[1] , date[2]) client = PySimpleClient() archConn = client.getComponent('ARCHIVE_CONNECTION') archOp = archConn.getOperational('XMLQueryTest') uids = archOp.queryRecent('ASDM' , date_T) print "Connection entablish with archive ..." asdm_name = [] for uid in uids: print "Checking date of " +str(uid), result = archOp.retrieveDirty(uid) dataSet = ArchivedAsdm(result.xmlString) dateOfCreation = dataSet.getDateOfCreation() print " created: "+str(dataSet.getDateTimeOfCreation()), if dataSet.isAsdm() & (dateOfCreation==date): asdm_name.append("%s \t%s" % (dataSet.getDateTimeOfCreation() , uid)) print " --> is an asdm!", print "" asdm_name.sort() client.releaseComponent('ARCHIVE_CONNECTION') client.disconnect() if len(asdm_name) == 0 : print 'There are no asdms for %s' % date return None else : return asdm_name[-1].split('\t')[1]
def _setup_acs_client(self): self._my_acs_client = PySimpleClient() self._logger = self._my_acs_client.getLogger() self._logger.setLevel(self._verbosity)
self.logger.logInfo(self.name + " started") assert (self.map.isProcessing(self.compName)) if self.activate: self.map.aboutToActivate(self.compName) else: self.map.aboutToDeactivate(self.compName) assert (self.map.isProcessing(self.compName)) self.logger.logInfo(self.name + " processing " + self.compName) if self.activate: self.map.activated(self.compName) else: self.map.deactivated(self.compName) self.logger.logInfo(self.name + " processed " + self.compName) simpleClient = PySimpleClient("acspyTestContainerActivationMap") map = ContainerActivationMap(simpleClient.getLogger()) # Simulate the starting of the activation of multiple components simpleClient.getLogger().logInfo( "Testing activation of components from the main thread...") for i in range(1000): name = "TestComponent_" + str(i) map.aboutToActivate(name) if not map.isProcessing(name): simpleClient.getLogger().logError("The map does not contain " + name) assert (map.numOfProcessingItems() == i + 1) # And then their termination of their activation for i in range(1000): name = "TestComponent_" + str(i)
- Accessing (remote) components. - Converting (ACS Error System) CORBA exceptions into their related Python exception helper classes. - Logging (ACS Error System) CORBA exceptions. LINKS - <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a> ''' import ACSErrTypeCommon import ACSErrTypeCommonImpl # Import the acspy.PySimpleClient class from Acspy.Clients.SimpleClient import PySimpleClient # Make an instance of the PySimpleClient simpleClient = PySimpleClient() try: # Get the standard HelloWorld device hw = simpleClient.getComponent("HELLOWORLD1") simpleClient.getLogger().logInfo("Trying to invoke bad method") hw.badMethod() except ACSErrTypeCommon.UnknownEx, e: simpleClient.getLogger().logCritical( "Caught an ACSException...don't worry because this SHOULD happen.") helperException = ACSErrTypeCommonImpl.UnknownExImpl(exception=e) helperException.Print() helperException.log(simpleClient.getLogger()) # Release it simpleClient.releaseComponent("HELLOWORLD1")
class ComponentUtilTest(unittest.TestCase): """ This test requires ACS running with the testacsproperties CDB and the myC cpp container up """ def setUp(self): self._my_acs_client = PySimpleClient() logger = self._my_acs_client.getLogger() logger.setLevel(logging.WARNING) # disable annoying output from the tests def tearDown(self): self._my_acs_client.disconnect() def test_get_enum_prop_dict(self): my_component = self._my_acs_client.getComponent( "TEST_PROPERTIES_COMPONENT", True) enum_prop = my_component._get_EnumTestROProp() decoded = component_util.get_enum_prop_dict(enum_prop) expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'} self.assertEqual(expected_value, decoded) enum_prop = my_component._get_EnumTestRWProp() decoded = component_util.get_enum_prop_dict(enum_prop) expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'} self.assertEqual(expected_value, decoded) self._my_acs_client.releaseComponent("TEST_PROPERTIES_COMPONENT") def test_get_property_type(self): my_component = self._my_acs_client.getComponent( "TEST_PROPERTIES_COMPONENT", True) self.assertEqual( component_util.get_property_type( my_component._get_EnumTestROProp()._NP_RepositoryId), PropertyType.OBJECT) self.assertEqual( component_util.get_property_type( my_component._get_EnumTestRWProp()._NP_RepositoryId), PropertyType.OBJECT) PropertyType.OBJECT self.assertEqual( component_util.get_property_type( my_component._get_doubleROProp()._NP_RepositoryId), PropertyType.DOUBLE) self.assertEqual( component_util.get_property_type( my_component._get_floatSeqRWProp()._NP_RepositoryId), PropertyType.FLOAT_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_longSeqRWProp()._NP_RepositoryId), PropertyType.LONG_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_uLongLongRWProp()._NP_RepositoryId), PropertyType.LONG_LONG) self.assertEqual( component_util.get_property_type( my_component._get_uLongLongRWProp()._NP_RepositoryId), PropertyType.LONG_LONG) self.assertEqual( component_util.get_property_type( my_component._get_doubleRWProp()._NP_RepositoryId), PropertyType.DOUBLE) self.assertEqual( component_util.get_property_type( my_component._get_uLongROProp()._NP_RepositoryId), PropertyType.LONG) self.assertEqual( component_util.get_property_type( my_component._get_booleanROProp()._NP_RepositoryId), PropertyType.BOOL) self.assertEqual( component_util.get_property_type( my_component._get_doubleSeqROProp()._NP_RepositoryId), PropertyType.DOUBLE_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_longLongROProp()._NP_RepositoryId), PropertyType.LONG_LONG) self.assertEqual( component_util.get_property_type( my_component._get_patternROProp()._NP_RepositoryId), PropertyType.BIT_FIELD) self.assertEqual( component_util.get_property_type( my_component._get_uLongRWProp()._NP_RepositoryId), PropertyType.LONG) self.assertEqual( component_util.get_property_type( my_component._get_booleanRWProp()._NP_RepositoryId), PropertyType.BOOL) self.assertEqual( component_util.get_property_type( my_component._get_doubleSeqRWProp()._NP_RepositoryId), PropertyType.DOUBLE_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_longLongRWProp()._NP_RepositoryId), PropertyType.LONG_LONG) self.assertEqual( component_util.get_property_type( my_component._get_patternRWProp()._NP_RepositoryId), PropertyType.BIT_FIELD) self.assertEqual( component_util.get_property_type( my_component._get_uLongSeqROProp()._NP_RepositoryId), PropertyType.LONG_SEQ) self.assertRaises( UnsupporterPropertyTypeError, component_util.get_property_type, my_component._get_booleanSeqROProp()._NP_RepositoryId) self.assertEqual( component_util.get_property_type( my_component._get_floatROProp()._NP_RepositoryId), PropertyType.FLOAT) self.assertEqual( component_util.get_property_type( my_component._get_longROProp()._NP_RepositoryId), PropertyType.LONG) self.assertEqual( component_util.get_property_type( my_component._get_stringROProp()._NP_RepositoryId), PropertyType.STRING) self.assertEqual( component_util.get_property_type( my_component._get_uLongSeqRWProp()._NP_RepositoryId), PropertyType.LONG_SEQ) self.assertRaises( UnsupporterPropertyTypeError, component_util.get_property_type, my_component._get_booleanSeqRWProp()._NP_RepositoryId) self.assertEqual( component_util.get_property_type( my_component._get_floatRWProp()._NP_RepositoryId), PropertyType.FLOAT) self.assertEqual( component_util.get_property_type( my_component._get_longRWProp()._NP_RepositoryId), PropertyType.LONG) self.assertEqual( component_util.get_property_type( my_component._get_stringRWProp()._NP_RepositoryId), PropertyType.STRING) self.assertEqual( component_util.get_property_type( my_component._get_floatSeqROProp()._NP_RepositoryId), PropertyType.FLOAT_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_longSeqROProp()._NP_RepositoryId), PropertyType.LONG_SEQ) self.assertEqual( component_util.get_property_type( my_component._get_uLongLongROProp()._NP_RepositoryId), PropertyType.LONG_LONG) def test_is_archive_delta_enabled(self): # First test the cases when it should be false self.assertFalse(component_util.is_archive_delta_enabled(None)) self.assertFalse(component_util.is_archive_delta_enabled(False)) self.assertFalse(component_util.is_archive_delta_enabled("0")) self.assertFalse(component_util.is_archive_delta_enabled("0.0")) self.assertFalse(component_util.is_archive_delta_enabled(0)) self.assertFalse(component_util.is_archive_delta_enabled(0.0))
class FrontEndTest(unittest.TestCase): """ This test requires ACS running with the testacsproperties CDB and the myC cpp container up """ def setUp(self): self._my_acs_client = PySimpleClient() self._my_acs_client.getLogger().setLevel(logging.CRITICAL) self._front_end = FrontEnd(RecorderConfig(), self._my_acs_client) self.__my_component_id = "TEST_PROPERTIES_COMPONENT" def test_is_acs_client_ok(self): self.assertTrue(self._front_end.is_acs_client_ok) def test_update_acs_client(self): other_client = PySimpleClient() other_client.getLogger().setLevel(logging.CRITICAL) self._front_end.update_acs_client(other_client) self.assertTrue(self._front_end.is_acs_client_ok) self._front_end.start_recording() yet_other_client = PySimpleClient() yet_other_client.getLogger().setLevel(logging.CRITICAL) self._front_end.update_acs_client(yet_other_client) self._front_end.stop_recording() def test_start_recording(self): self._front_end.start_recording() self.assertTrue(self._front_end.is_recording) self._front_end.stop_recording() self._my_acs_client.getComponent(self.__my_component_id, True) self._front_end.start_recording() self.assertTrue(self._front_end.is_recording) self._front_end.stop_recording() self._my_acs_client.releaseComponent(self.__my_component_id) def test_process_component(self): self._my_acs_client.getComponent(self.__my_component_id, True) self._front_end.process_component(self.__my_component_id) self._my_acs_client.releaseComponent(self.__my_component_id) self.assertRaises(CannotAddComponentException, self._front_end.process_component, "I_DO_NOT_EXIST") def test_remove_wrong_components(self): self._my_acs_client.getComponent(self.__my_component_id, True) self._front_end.start_recording() time.sleep(3) self._my_acs_client.releaseComponent(self.__my_component_id) time.sleep(10) self._front_end.stop_recording() def tearDown(self): self._front_end.cancel() self._front_end = None
# MA 02111-1307 USA # from Acspy.Clients.SimpleClient import PySimpleClient from sys import argv from sys import exit from sys import stdout from TMCDB import MonitorCollector from TMCDB import propertySerailNumber from omniORB import any import MonitorErrImpl import MonitorErr import time # Make an instance of the PySimpleClient simpleClient = PySimpleClient() mc = simpleClient.getComponent(argv[1]) try: tc = simpleClient.getComponent('MC_TEST_PROPERTIES_COMPONENT') psns =[propertySerailNumber('doubleROProp', ['1' ]), propertySerailNumber('floatROProp', ['2' ]), propertySerailNumber('longROProp', ['3' ]), propertySerailNumber('uLongROProp', ['4' ]), propertySerailNumber('patternROProp', ['5' ]), propertySerailNumber('stringROProp', ['6' ]), propertySerailNumber('longLongROProp', ['7' ]), propertySerailNumber('uLongLongROProp', ['8' ]), propertySerailNumber('booleanROProp', ['9' ]), propertySerailNumber('doubleSeqROProp', ['10']),
# License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: acspyTestContainer.py,v 1.10 2005/05/26 17:23:26 dfugate Exp $ """ Test component services via a component. In short, this provides complete testing of the container. """ from Acspy.Clients.SimpleClient import PySimpleClient import acspytest from time import sleep simpleClient = PySimpleClient() #test an immortal component first print "Testing TESTCOMPONENT (i.e., immortal components)" test = simpleClient.getComponent("TESTCOMPONENT") test.sayHello() val = test.testServices() if not val: print "TESTCOMPONENT.testServices() FAILED!!!" #test a mortal component next print "Testing TESTCOMPONENT1 (i.e., mortal components)" test1 = simpleClient.getComponent("TESTCOMPONENT1") test1.sayHello() val = test1.testServices() if not val:
class MotorImplTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceMotorImpl" self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect() #__pPp__ ################################################ # test methods ################################################ def testMove(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testMove()...") response = None response = self.component.move() # no return is expected, response should be None assert response is None #__pPp__ def testStandby(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testStandby()...") response = None response = self.component.standby() # no return is expected, response should be None assert response is None #__pPp__ def testOnline(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testOnline()...") response = None response = self.component.online() # no return is expected, response should be None assert response is None #__pPp__ def testOff(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testOff()...") response = None response = self.component.off() # no return is expected, response should be None assert response is None #__pPp__ def testSetup(self): self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testSetup()...") response = None val = 'emptyString' timeout = 0 response = self.component.setup(val, timeout) # no return is expected, response should be None assert response is None
implementation located in ACS/LGPL/CommonSoftware/acsQoS/ws/test. """ from Acspy.Clients.SimpleClient import PySimpleClient import Acspy.Common.QoS as QofS import sys def exitGracefully(client): client.releaseComponent("TEST_QOS_COMPONENT") client.disconnect() sys.exit() # instantiate the simple client mySimpleClient = PySimpleClient() # get the test component used for the method invocations that we invoke to test timeouts testQoSComponent = mySimpleClient.getComponent("TEST_QOS_COMPONENT") # first, call method on the servant with no QoS timeout set try: testQoSComponent.echo(0, 1000) print "Method w/o timeout executed successfully." except Exception, e: print "ERROR 0: timeout exception caught on method invocation when not expected." exitGracefully(mySimpleClient) # test setting/resetting of a (local) timeout and also test invocation of a method # (with a timeout set) that doesn't exceed the time out
#!/usr/bin/env python from Acspy.Clients.SimpleClient import PySimpleClient remoteComponent = "MOUNT2_LOOP" #Make an instance of the PySimpleClient simpleClient = PySimpleClient() #Get the MOUNT1 Mount device mount = simpleClient.getComponent(remoteComponent) #Get the actAz property actAzProperty = mount._get_actAz() #Get the current value of the property (azm, compl) = actAzProperty.get_sync() print "MOUNT actual azimuth: ", azm #Cleanly disconnect simpleClient.releaseComponent(remoteComponent) simpleClient.disconnect()
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: acspyexmplTestPyContainer.py,v 1.8 2006/10/25 14:10:28 bjeram Exp $ """ Test very simple components. """ from Acspy.Clients.SimpleClient import PySimpleClient simpleClient = PySimpleClient() try: #test an immortal cob first print "Testing HELLODEMO1 (i.e., immortal components)" test1 = simpleClient.getComponent("HELLODEMO1") print test1.sayHello() print test1.sayHelloWithParameters("I'm an 'inString'", 3.14) print print "Now test HELLODEMO2 (i.e., non-immortal components)" test2 = simpleClient.getComponent("HELLODEMO2") print test2.sayHello() print test2.sayHelloWithParameters("I'm an 'inString'", 3.14) print
"completionFromCompletion has thrown an UNEXPECTED exception") ex2.log(self.logger) addComplHelperMethods(comp) if comp.isErrorFree() == 1: self.logger.logInfo("Completion Ok, without error trace") else: self.logger.logInfo("Completion with error trace (UNEXPECTED)") comp.log(self.logger) #----------------------------------------------------------------------------- if __name__ == "__main__": client = PySimpleClient("acspyexmplClientErrorComponent") print("starting acspyexmplClientErrorComponent") # Here we instantiate the object used to show examples of error handling. # Each method call demonstrate one aspect of error hanlding. # See the class documentation for details. try: print("Creating ClientErrorComponent") clientErrorComponent = ClientErrorComponent(client, argv[1]) #Call the displayMessage() method existing in the interface for ErrorComponent clientErrorComponent.TestOk() clientErrorComponent.TestReceiveRemoteException() clientErrorComponent.TestReceiveRemoteCompletion() clientErrorComponent.testExceptionFromCompletion() clientErrorComponent.testTypeException()
def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceEventSubscriberImpl" self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.setUp()...")
catch it and call processEvent(...) which will hopefully have been overriden. ''' global count if count < 5: count = count + 1 LOGGER.logInfo('The temperature difference is ' + str(someParam.absoluteDiff)) return #------------------------------------------------------------------------------ if __name__ == "__main__": print 'Making sure there is a fridge available...' #Start publishing events through a C++ Supplier simpleClient = PySimpleClient() aFridge = simpleClient.getComponent("FRIDGE1") aFridge.on() #Create a FridgeConsumer simpleClient.getLogger().logInfo('Creating FridgeConsumer') g = Consumer(FRIDGE.CHANNELNAME_FRIDGE) #Subscribe to temperatureDataBlockEvent events and register this handler to process #those events g.addSubscription(FRIDGE.temperatureDataBlockEvent, fridgeDataHandler) #Let the Notification Service know we are ready to start processing events. g.consumerReady() #After five events have been received, disconnect from the channel
# You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # from Acspy.Clients.SimpleClient import PySimpleClient from sys import argv from sys import exit from TMCDB import MonitorCollector from TMCDB import propertySerailNumber import MonitorErrImpl import MonitorErr # Make an instance of the PySimpleClient simpleClient = PySimpleClient() mc = simpleClient.getComponent(argv[1]) # Test Case 1: Register collocated device with multiple serial non registrable # Test EH(registerCollocatedMonitoredDeviceWithMultipleSerial): RegisteringDeviceProblem" print "Test Case 1: Register collocated device with multiple serial non registrable" print "--------------------------------------------" try: psns =[propertySerailNumber('asds', ['12124']),propertySerailNumber('sdfsfs', ['3432535'])] mc.registerCollocatedMonitoredDeviceWithMultipleSerial('FAKE_DEVICE', psns) print " TEST FAIL: FAKE_DEVICE registered" except MonitorErr.RegisteringDeviceProblemEx, _ex: ex = MonitorErrImpl.RegisteringDeviceProblemExImpl(exception=_ex) ex.Print(); print " TEST SUCCESS: FAKE_DEVICE not registered"
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: acssimGenericTest.py,v 1.3 2006/03/16 00:03:02 dfugate Exp $ #------------------------------------------------------------------------------ ''' Quite possibly the most generic component client throughout ALMA software. ''' from sys import argv import ACS from Acspy.Clients.SimpleClient import PySimpleClient compName = argv[1] compMethod = argv[2] print "Parameters to this generic test script are:", argv[1], argv[2] # Make an instance of the PySimpleClient simpleClient = PySimpleClient() comp = simpleClient.getComponent(compName) try: joe = eval("comp." + argv[2]) print "The evaluated return value is:", joe except Exception, e: print "The exception that occured was:", e simpleClient.releaseComponent(compName) simpleClient.disconnect()
class SCJavaImpTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceSCJavaImp" self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect() #__pPp__ ################################################ # test methods ################################################ def testReset(self): self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testReset()...") response = None response = self.component.reset() # no return is expected, response should be None assert response is None #__pPp__ def testStatus(self): self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testStatus()...") response = None response = self.component.status() # a return is expected, response should be not None assert response is not None #__pPp__ def testGetPosition(self): self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testGetPosition()...") response = None response = self.component.getPosition() # a return is expected, response should be not None assert response is not None #__pPp__ def testSensorType(self): self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testSensorType()...") response = None response = self.component.sensorType() # a return is expected, response should be not None assert response is not None
def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceTRDJavaImp" self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.setUp()...")
def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceSCJavaImp" self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.setUp()...")
magicNumber = int(argv[2]) def myHandler(ts, device, parameter, value): ''' ''' global count if count < magicNumber: count = count + 1 return #create the consumer myConsumer = ArchiveConsumer(myHandler) myConsumer.consumerReady() #activate the component which will publish the events automatically joe = PySimpleClient() ps = joe.getComponent("TEST_PS_1") #give the consumer a chance to receive the events sleep(int(argv[1])) #shutdown everything cleanly myConsumer.disconnect() joe.releaseComponent("TEST_PS_1") joe.disconnect() if count == magicNumber: print "Test passed!" else: print "Test failed:", count
from Acspy.Clients.SimpleClient import PySimpleClient client = PySimpleClient() def test_component_and_interface(): comp = client.getDynamicComponent( 'comp', "IDL:cta/example/ExampleComponent:1.0", None, "aragornContainer") # see if comp has value propoerty comp.value # test if comp has a set() method comp.set(123)
def setUp(self): self._my_acs_client = PySimpleClient() self._my_acs_client.getLogger().setLevel(logging.CRITICAL) self._front_end = FrontEnd(RecorderConfig(), self._my_acs_client) self.__my_component_id = "TEST_PROPERTIES_COMPONENT"
class DCSImplTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceDCSImpl" self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect() #__pPp__ ################################################ # test methods ################################################ def testSendCommand(self): self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.testSendCommand()...") response = None commandName = 'emptyString' parameterList = 'emptyString' cb = CBstring() desc = CBDescIn() response = self.component.sendCommand(commandName, parameterList, cb, desc) # a return is expected, response should be not None assert response is not None
def setUp(self): self._my_acs_client = PySimpleClient() logger = self._my_acs_client.getLogger() logger.setLevel(logging.WARNING)
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # from Acspy.Clients.SimpleClient import PySimpleClient from sys import argv from sys import exit from TMCDB import MonitorCollector from TMCDB import propertySerailNumber from omniORB import any import MonitorErrImpl import MonitorErr import time # Make an instance of the PySimpleClient simpleClient = PySimpleClient() mc = simpleClient.getComponent(argv[1]) try: tc = simpleClient.getComponent('MC_TEST_COMPONENT') psns = [ propertySerailNumber('doubleSeqProp', ['12124']), propertySerailNumber('doubleProp', ['3432535']) ] mc.registerMonitoredDeviceWithMultipleSerial('MC_TEST_COMPONENT', psns) tc.reset() mc.startMonitoring('MC_TEST_COMPONENT') time.sleep(10) #Change archiving interval to 2 seconds instead of 1 mc.set_archiving_interval('MC_TEST_COMPONENT', 'doubleProp', 20000000)
from subprocess import * import ACSErrTypeCommon import ACSErrTypeCommonImpl import sys import time # Import the acspy.PySimpleClient class from Acspy.Clients.SimpleClient import PySimpleClient from Acspy.Nc.Consumer import Consumer from Control import CHANNELNAME_CONTROLSYSTEM from Control import ExecBlockStartedEvent from Control import ExecBlockEndedEvent # Make an instance of the PySimpleClient simpleClient = PySimpleClient() simpleClient.getLogger().logInfo("Simple client instantiated.") global started global ended def handlerStarted(event): global started started += 1 print event.execId print event.sbId print event.sessionId print event.arrayName print event.startTime return
# You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: acsncTestConSup.py,v 1.6 2006/03/08 17:50:44 dfugate Exp $ """ """ from Acspy.Clients.SimpleClient import PySimpleClient from sys import argv from time import sleep # Make an instance of the PySimpleClient simpleClient = PySimpleClient() consumer = simpleClient.getComponent(argv[1]) if len(argv)==3: supplier = simpleClient.getComponent(argv[2]) supplier.sendEvents(10) else: sleep(10) sleep(50) simpleClient.releaseComponent(argv[1]) sleep(2)
class StandaloneRecorder(object): """ A property recorder that works as an stand-alone application """ def __init__(self, recorder_config, verbosity): ''' Ctor @param recorder_config: the configuration of the recorder @type recorder_config: RecorderConfig @param verbosity: the verbosity level (logging.WARNING, logging.DEBUG, etc) of the logger @type verbosity: int ''' self._verbosity = verbosity self._recorder_config = recorder_config self._setup_acs_client() self._setup_front_end() self.__canceled = False self._logger.info('Property recorder up') def _setup_acs_client(self): self._my_acs_client = PySimpleClient() self._logger = self._my_acs_client.getLogger() self._logger.setLevel(self._verbosity) def _setup_front_end(self): self._front_end = FrontEnd(self._recorder_config, self._my_acs_client) def make_new_acs_client(self): ''' Will make a new ACS client and replace the existing one To be used to recover from ACS restarts. @raise CORBAProblemExImpl: if the client cannot be created. ''' self._setup_acs_client() self._front_end.update_acs_client(self._my_acs_client) def start(self): ''' The property recorded will start to record properties @raises RuntimeError: if the recorder is cancelled ''' if self.__canceled: raise RuntimeError("The recorded is cancelled") self._front_end.start_recording() self._logger.info('Recording start') def stop(self): ''' The property recorded will stop to record properties All the monitors are stopped, the components are unregistered @raises RuntimeError: if the recorder is cancelled ''' if self.__canceled: raise RuntimeError("The recorded is cancelled") self._front_end.stop_recording() self._logger.info('Recording stop') def close(self): ''' Closes the property recorder, ready to be destroyed All the resources will be freed and the connection with ACS closed. The recorder will be cancelled from now on, Meaning that the recorder is not anymore usable and is ready to be destroyed ''' if not self.__canceled: self._logger.info('Switching off property recorder') self.stop() self._front_end.cancel() self._front_end = None self._recorder_config = None self._my_acs_client.disconnect() self._my_acs_client = None self.__canceled = True def is_acs_client_ok(self): ''' Checks if the ACS client is OK or not. When not OK, this typically means that ACS is down. This lets the client know when a new client should be created @return: if the client is OK or not @rtype: bool ''' return self._front_end.is_acs_client_ok def print_config(self): ''' Prints into the logger the existing configuration ''' self._logger.debug('Property Recorder Configuration' '\n--------------------------------------\n' + pprint.pformat(vars(self._recorder_config)) + '\n--------------------------------------')
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: javaSupplierComponent.py,v 1.1 2008/05/23 12:53:45 eallaert Exp $ """ """ from Acspy.Clients.SimpleClient import PySimpleClient from time import sleep import sys simpleClient = PySimpleClient() sleep(5) print "Getting the Supplier" sys.stdout.flush() mySupplierComp = simpleClient.getComponent("SUPPLIERCOMP1") print "Sending events" sys.stdout.flush() for i in range(50): mySupplierComp.sendEvents(1) sleep(1) simpleClient.releaseComponent("SUPPLIERCOMP1") print "Finished sending events"
#!/usr/bin/env python from Acspy.Clients.SimpleClient import PySimpleClient simpleClient = PySimpleClient.getInstance() ncBench = simpleClient.getComponent("NC_DDS_SUPPLIER") ncBench.runTest(10,1000) simpleClient.releaseComponent("NC_DDS_SUPPLIER") simpleClient.disconnect()
''' Tests a callback void method. ''' from sys import argv from time import sleep from Acspy.Clients.SimpleClient import PySimpleClient from Acspy.Common.Callbacks import CBvoid from ACS import CBDescIn compName = argv[1] compMethod = argv[2] print "Parameters to this generic test script are:", argv[1:] # Make an instance of the PySimpleClient simpleClient = PySimpleClient() comp = simpleClient.getComponent(compName) myCB = CBvoid() myCorbaCB = simpleClient.activateOffShoot(myCB) myDescIn = CBDescIn(0L, 0L, 0L) joe = eval("comp." + compMethod + "(myCorbaCB, myDescIn)") print "Method executed...now just waiting on CB status" for i in range(0, 50): if myCB.status == 'DONE': print "The callback has finished!" break else: sleep(1)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # # @(#) $Id: javaSupplierComponent.py,v 1.1 2008/05/23 12:53:45 eallaert Exp $ """ """ from Acspy.Clients.SimpleClient import PySimpleClient from time import sleep import sys simpleClient = PySimpleClient() sleep(5) print "Getting the Supplier" sys.stdout.flush() mySupplierComp = simpleClient.getComponent("SUPPLIERCOMP1") print "Sending events" sys.stdout.flush() for i in range(50): mySupplierComp.sendEvents(1) sleep(1) simpleClient.releaseComponent("SUPPLIERCOMP1")
import datetime import numpy as np from Acspy.Clients.SimpleClient import PySimpleClient print "Getting python client ..." c = PySimpleClient() names = [] tmcdb = c.getComponent('TMCDBAccess') for i in range(1,17): names.append('CORR/CDP_NODE/N%s' % str(i).zfill(2)) names.append('CORR/CDP_MASTER') print "Start profiling ..." prof = {} for comp_name in names: print "Getting: %s" % comp_name t0 = datetime.datetime.utcnow() node = c.getComponent(comp_name) t1 = datetime.datetime.utcnow() delta = (t1 - t0)#.total_seconds() prof[comp_name] = (delta.microseconds + 0.0 + (delta.seconds + delta.days * 24 * 3600) * 10 ** 6) / 10 ** 6 print "\nStats in seconds [s]\n" for comp, delta in prof.items(): print "%s => %f" % (comp, delta) values = np.array(prof.values()) print "\nStats [s]\n" print "min: %f" % ((values.min())) print "max: %f" % ((values.max())) print "mean: %f" % ((values.mean()))
#! /usr/bin/env python from sys import argv from time import sleep from Acspy.Clients.SimpleClient import PySimpleClient import ACS import time, os simpleClient = PySimpleClient() cdb_mount = simpleClient.getComponent("COMP99") sleep(10) simpleClient.releaseComponent("COMP99")
"completionFromCompletion has thrown an UNEXPECTED exception") ex2.log(self.logger) addComplHelperMethods(comp) if comp.isErrorFree() == 1: self.logger.logInfo("Completion Ok, without error trace") else: self.logger.logInfo("Completion with error trace (UNEXPECTED)") comp.log(self.logger) #----------------------------------------------------------------------------- if __name__ == "__main__": client = PySimpleClient() print("starting acspyexmplClientErrorComponent") # Here we instantiate the object used to show examples of error handling. # Each method call demonstrate one aspect of error hanlding. # See the class documentation for details. try: print("Creating ClientErrorComponent") clientErrorComponent = ClientErrorComponent(client, argv[1]) #Call the displayMessage() method existing in the interface for ErrorComponent clientErrorComponent.TestOk() clientErrorComponent.TestReceiveRemoteException() clientErrorComponent.TestReceiveRemoteCompletion() clientErrorComponent.testExceptionFromCompletion() clientErrorComponent.testTypeException()
class TRDJavaImpTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceTRDJavaImp" self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect() #__pPp__ ################################################ # test methods ################################################ def testGetRAB(self): self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetRAB()...") response = None type = 0 response = self.component.getRAB(type) # a return is expected, response should be not None assert response is not None #__pPp__ def testCreateReport(self): self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testCreateReport()...") response = None rep = report() response = self.component.createReport(rep) # a return is expected, response should be not None assert response is not None #__pPp__ def testGetReportsList(self): self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReportsList()...") response = None response = self.component.getReportsList() # a return is expected, response should be not None assert response is not None #__pPp__ def testGetReport(self): self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReport()...") response = None id = 0 response = self.component.getReport(id) # a return is expected, response should be not None assert response is not None
# You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # from Acspy.Clients.SimpleClient import PySimpleClient from sys import argv from sys import exit from TMCDB import MonitorCollector from TMCDB import propertySerailNumber import MonitorErrImpl import MonitorErr # Make an instance of the PySimpleClient simpleClient = PySimpleClient() mc = simpleClient.getComponent(argv[1]) print "Test EH(registerMonitoredDeviceWithMultipleSerial): RegisteringDeviceProblem - not activated" try: psns = [ propertySerailNumber('asds', ['12124']), propertySerailNumber('sdfsfs', ['3432535']) ] mc.registerMonitoredDeviceWithMultipleSerial('FAKE_DEVICE', psns) except MonitorErr.RegisteringDeviceProblemEx, _ex: ex = MonitorErrImpl.RegisteringDeviceProblemExImpl(exception=_ex) ex.Print()
import sys import time from Acspy.Clients.SimpleClient import PySimpleClient remoteComponentName = "TESTMAXMSGSIZE" # Loop and call the sendSequence method on the component # making the size of the sequence sent larger w/ each iteration # at some point, the ORB should fail because omniorb's max # msg size will have been exceeded. # Make an instance of the PySimpleClient simpleClient = PySimpleClient() while 1: try: characters = "1" # Get the test component by name remoteComponent = simpleClient.getComponent(remoteComponentName) for i in range(0, 22): print "Length being sent: ", len(characters) remoteComponent.sendSequence(characters) characters = characters + characters simpleClient.releaseComponent(remoteComponentName) except: print "FAILED to send: ", len(characters) time.sleep(1)
class MoreComponentUtilTest(unittest.TestCase): """ Test the integration of the component utilities """ def setUp(self): self._my_acs_client = PySimpleClient() logger = self._my_acs_client.getLogger() logger.setLevel(logging.WARNING) def tearDown(self): self._my_acs_client.disconnect() def test_is_characteristic_component(self): my_component = self._my_acs_client.getComponent( "TEST_PROPERTIES_COMPONENT", True) self.assertTrue( component_util.is_characteristic_component(my_component)) # Now check a component that is not characteristic my_component2 = self._my_acs_client.getComponent("TIMER1", True) self.assertFalse( component_util.is_characteristic_component(my_component2)) def test_is_python_char_component(self): my_component = self._my_acs_client.getComponent( "TEST_PROPERTIES_PYTHON", True) self.assertTrue(component_util.is_python_char_component(my_component)) # Now check a component that is not characteristic my_component2 = self._my_acs_client.getComponent("TIMER1", True) self.assertRaises(AttributeError, component_util.is_python_char_component, my_component2) my_component3 = self._my_acs_client.getComponent( "TEST_PROPERTIES_COMPONENT", True) self.assertFalse( component_util.is_python_char_component(my_component3)) def test_is_a_property_recorder_component(self): my_component = self._my_acs_client.getComponent( "propertyRecorder1", True) self.assertTrue( component_util.is_a_property_recorder_component(my_component)) # Now check a component that is not characteristic my_component2 = self._my_acs_client.getComponent("TIMER1", True) self.assertFalse( component_util.is_a_property_recorder_component(my_component2)) def test_is_component_state_ok(self): my_component = self._my_acs_client.getComponent( "TEST_PROPERTIES_COMPONENT", True) self.assertTrue(component_util.is_component_state_ok(my_component))
parser.add_option("--levelMax", dest="levelMax", type=float, default=5.0, help="White level in dBm for when not using fullscale option [default 5.0] (note optimal levels for TDM and FDM observations are 3.8 and 2.4 dBm respectively, so if you go below these expect to white-out a lot!)") parser.add_option("--levelMin", dest="levelMin", type=float, default=-2.0, help="Black level in dBm for when not using fullscale option [default -2.0]") (options, args) = parser.parse_args() print 'finding configured antennas' # get_configured_antennas: if options.antennaList == 'All': from Acspy.Clients.SimpleClient import PySimpleClient client = PySimpleClient("ping_abm") ant_info = client.availableComponents(type_wildcard='IDL:alma/Control/Antenna:1.0', activated=1) availableAnts = [] notAvailableAntennas = [] if len(ant_info) > 0: for antenna_info in ant_info: try: name = antenna_info.name antenna = client.getComponentNonSticky(antenna_info.name) name.split('/') antName = name.split('/')[1] sys.stdout.write(antName+'\r') # sys.stdout.flush() print antName if str(antenna.getState())=="Shutdown": notAvailableAntennas.append(antenna[1])
- Accessing (remote) components. - Using PySimpleClient to create and reference dynamic components. - Manipulating default parameters of ContainerServices methods. LINKS - <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a> ''' # Import command-line arguments from sys import argv # Import the SimpleClient class from Acspy.Clients.SimpleClient import PySimpleClient # Make an instance of the PySimpleClient simpleClient = PySimpleClient() # Obtain a reference to a dynamic component using the ContainerServices # getComponent method. hwRef = simpleClient.getDynamicComponent( None, "IDL:alma/acsexmplHelloWorld/HelloWorld:1.0", "acsexmplHelloWorldImpl", str(argv[1])) if hwRef != None: simpleClient.getLogger().logInfo("Retrieved valid reference from manager.") #Do something useful with the reference. hwRef.displayMessage() simpleClient.getLogger().logInfo( "Method of dynamic component successfully invoked. Have a nice day!") else: simpleClient.getLogger().logAlert("Bad reference retrieved from manager")
from Acspy.Util import ACSCorba import CDB import xml.dom.minidom import datetime import numpy as np from Acspy.Clients.SimpleClient import PySimpleClient client = PySimpleClient() all_comp = client.availableComponents() # # DAL # dal = ACSCorba.cdb() # # WDAL # cdb_obj = ACSCorba.getClient().getService('CDB') dal_ = cdb_obj._narrow(CDB.WDAL) prof = {} prof_wdal = {} for comp in all_comp: print comp.name curl = "MACI/Components/"+comp.name # # DAO # t0 = datetime.datetime.utcnow() xmlstring = dal.get_DAO(curl) t1 = datetime.datetime.utcnow() delta = (t1 - t0)#.total_seconds()
def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceNexstarImpl" self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.setUp()...")
from optparse import OptionParser parser = OptionParser() parser.add_option("-f", "--frequency", dest="skyFreq", metavar='SkyFreq', help="The desired sky frequency for the beacon") (options, args) = parser.parse_args() if options.skyFreq == None: print "You must specify a sky frequency use the \"-f\" option" sys.exit(-1) options.skyFreq = float(options.skyFreq) # Check with the Control Master to see what arrays are in existence client = PySimpleClient() master = client.getComponent("CONTROL/MASTER") arrayList = master.getAutomaticArrayComponents() + \ master.getManualArrayComponents() client.releaseComponent("CONTROL/MASTER") if len(arrayList) != 1: if len(arrayList) == 0: print "Error: No Arrays in existence, unable to set frequency" else: print "Error: Multiple arrays detected...are you sure your at the ATF" sys.exit array = client.getComponent(arrayList[0].ComponentName)
class NexstarImplTestPy(unittest.TestCase): ################################################ # lifecycle ################################################ def setUp(self): self.simpleClient = PySimpleClient() self.componentName = "testInstanceNexstarImpl" self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.setUp()...") self.simpleClient.getLogger().logInfo("Get component " + self.componentName) self.component = self.simpleClient.getComponent(self.componentName) #__pPp__ def tearDown(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.tearDown()...") self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName) self.simpleClient.releaseComponent(self.componentName) self.simpleClient.disconnect() #__pPp__ ################################################ # test methods ################################################ def testImage(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testImage()...") response = None exposure = double() response = self.component.image(exposure) # a return is expected, response should be not None assert response is not None #__pPp__ def testLock(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testLock()...") response = None response = self.component.lock() # no return is expected, response should be None assert response is None #__pPp__ def testUnlock(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testUnlock()...") response = None response = self.component.unlock() # no return is expected, response should be None assert response is None #__pPp__ def testOn(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOn()...") response = None response = self.component.on() # no return is expected, response should be None assert response is None #__pPp__ def testOff(self): self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOff()...") response = None response = self.component.off() # no return is expected, response should be None assert response is None