Python port_agent_process.PortAgentProcess类代码示例

    def test_missing_config(self):
        """
        Test if a required config parameter is missing
        """
        config = {'device_addr': 'localhost'}

        with self.assertRaises(PortAgentMissingConfig):
            process = PortAgentProcess.get_process(config, timeout = TEST_TIMEOUT, test_mode=True)

        config = {'device_port': '921'}

        with self.assertRaises(PortAgentMissingConfig):
            process = PortAgentProcess.get_process(config, timeout = TEST_TIMEOUT, test_mode=True)

    def start_pagent(self):
        """
        Construct and start the port agent.
        @retval port Port that was used for connection to agent
        """
        # Create port agent object.
        comm_config = self.comm_config

        config = {
            'device_addr' : comm_config.device_addr,
            'device_port' : comm_config.device_port,

            'command_port': comm_config.command_port,
            'data_port': comm_config.data_port,

            'process_type': PortAgentProcessType.UNIX,
            'log_level': 5,
        }

        self._pagent = PortAgentProcess.launch_process(config, timeout = 60, test_mode = True)
        pid = self._pagent.get_pid()
        port = self._pagent.get_data_port()

        log.info('Started port agent pid %d listening at port %d', pid, port)

        # Configure driver to use port agent port number.
        DVR_CONFIG['comms_config'] = {
            'addr' : 'localhost',
            'port' : port
        }

        return port

    def test_driver_process(self):
        """
        Test port agent process launch with default values and a good host and port
        """
        process = PortAgentProcess.get_process(self._port_config, test_mode=True)
        self.assertTrue(process)
        self.assertTrue(isinstance(process, PythonPortAgentProcess))

        # Verify config
        self.assertEqual(process._device_addr, self._port_config.get("device_addr"))
        self.assertEqual(process._device_port, self._port_config.get("device_port"))
        self.assertEqual(process._working_dir, '/tmp/')
        self.assertEqual(process._delimiter, ['<<','>>'])

        # Try start
        process.launch()

        # Check that it launched properly
        self.assertTrue(process.get_pid() > 0)
        self.assertTrue(process.get_data_port())
        # Python logger has no command port
        self.assertEqual(process.get_command_port(), None)

        process.stop()
        self.assertFalse(process.get_pid())

    def test_nolaunch_process(self):
        """
        Test the port agent doesn't launch when the port agent address is not localhost
        """
        self._port_config['port_agent_addr'] = 'somewhere.else'

        process = PortAgentProcess.get_process(self._port_config, test_mode=True)
        self.assertTrue(process)
        self.assertTrue(isinstance(process, UnixPortAgentProcess))

        # Verify config
        self.assertEqual(process._device_addr, self._port_config.get("device_addr"))
        self.assertEqual(process._device_port, self._port_config.get("device_port"))
        self.assertEqual(process._binary_path, self._port_config.get("binary_path"))
        self.assertEqual(process._command_port, self._port_config.get("command_port"))
        self.assertEqual(process._data_port, self._port_config.get("data_port"))
        self.assertEqual(process._log_level, self._port_config.get("log_level"))
        self.assertEqual(process._pa_addr, self._port_config.get("port_agent_addr"))

        process.stop()
        
        # Try start
        process.launch()

        # Check that it launched properly
        self.assertFalse(process.get_pid())
        self.assertTrue(process.get_data_port(), PORT_AGENT_DATA_PORT)
        self.assertEqual(process.get_command_port(), PORT_AGENT_COMMAND_PORT)

        process.stop()

    def test_launch_process(self):
        """
        Test port agent process launch with default values and a good host and port
        """
        process = PortAgentProcess.get_process(self._port_config, test_mode=True)
        self.assertTrue(process)
        self.assertTrue(isinstance(process, UnixPortAgentProcess))

        # Verify config
        self.assertEqual(process._device_addr, self._port_config.get("device_addr"))
        self.assertEqual(process._device_port, self._port_config.get("device_port"))
        self.assertEqual(process._binary_path, self._port_config.get("binary_path"))
        self.assertEqual(process._command_port, self._port_config.get("command_port"))
        self.assertEqual(process._data_port, self._port_config.get("data_port"))
        self.assertEqual(process._log_level, self._port_config.get("log_level"))

        process.stop()

        # Try start
        process.launch()

        # Check that it launched properly
        self.assertTrue(process.get_pid() > 0)
        self.assertTrue(process.get_data_port(), PORT_AGENT_DATA_PORT)
        self.assertEqual(process.get_command_port(), PORT_AGENT_COMMAND_PORT)

        process.stop()

    def test_bad_host(self):
        """
        Test the port agent startup with a bad hostname.  This should eventually timeout and raise an
        exception.
        """
        host = '127.0.0.0'
        config = self._port_config
        config['device_addr'] = host

        process = PortAgentProcess.get_process(self._port_config, timeout = TEST_TIMEOUT, test_mode=True)
        self.assertTrue(process)
        self.assertTrue(isinstance(process, PythonPortAgentProcess))

        # Verify config
        self.assertEqual(process._device_addr, host)
        self.assertEqual(process._device_port, self._port_config.get("device_port"))
        self.assertEqual(process._working_dir, '/tmp/')
        self.assertEqual(process._delimiter, ['<<','>>'])

        # Try start
        with self.assertRaises(PortAgentTimeout):
            process.launch()

        # Verify we don't have a process lingering
        self.assertFalse(process.poll())

    def init_port_agent(cls):
        """
        @brief Launch the driver process and driver client.  This is used in the
        integration and qualification tests.  The port agent abstracts the physical
        interface with the instrument.
        @retval return the pid to the logger process
        """
        log.info("Startup Port Agent")

        comm_config = cls.get_comm_config()

        config = {
            'device_addr' : comm_config.device_addr,
            'device_port' : comm_config.device_port
        }

        port_agent = PortAgentProcess.launch_process(config, timeout = 60,
            test_mode = True)

        port = port_agent.get_data_port()
        pid  = port_agent.get_pid()

        log.info('Started port agent pid %s listening at port %s' % (pid, port))

        cls.test_config.port_agent = port_agent
        return port

    def _start_port_agent(self, instrument_agent_instance_obj=None):
        """
        Construct and start the port agent, ONLY NEEDED FOR INSTRUMENT AGENTS.
        """

        _port_agent_config = instrument_agent_instance_obj.port_agent_config

        # It blocks until the port agent starts up or a timeout
        _pagent = PortAgentProcess.launch_process(_port_agent_config,  test_mode = True)
        pid = _pagent.get_pid()
        port = _pagent.get_data_port()
        cmd_port = _pagent.get_command_port()
        log.info("IMS:_start_pagent returned from PortAgentProcess.launch_process pid: %s ", pid)

        # Hack to get ready for DEMO.  Further though needs to be put int
        # how we pass this config info around.
        host = 'localhost'

        driver_config = instrument_agent_instance_obj.driver_config
        comms_config = driver_config.get('comms_config')
        if comms_config:
            host = comms_config.get('addr')
        else:
            log.warn("No comms_config specified, using '%s'" % host)

        # Configure driver to use port agent port number.
        instrument_agent_instance_obj.driver_config['comms_config'] = {
            'addr' : host,
            'cmd_port' : cmd_port,
            'port' : port
        }
        instrument_agent_instance_obj.driver_config['pagent_pid'] = pid
        self.imsclient.update_instrument_agent_instance(instrument_agent_instance_obj)
        return self.imsclient.read_instrument_agent_instance(instrument_agent_instance_obj._id)

    def init_port_agent(self):
        """
        @brief Launch the driver process and driver client.  This is used in the
        integration and qualification tests.  The port agent abstracts the physical
        interface with the instrument.
        @retval return the pid to the logger process
        """
        if (self.port_agent):
            log.error("Port agent already initialized")
            return

        log.debug("Startup Port Agent")

        #comm_config = self.get_comm_config()

        config = self.port_agent_config()
        log.debug("port agent config: %s" % config)

        port_agent = PortAgentProcess.launch_process(config, timeout = 60, test_mode = True)

        port = port_agent.get_data_port()
        pid  = port_agent.get_pid()

        log.info('Started port agent pid %s listening at port %s' % (pid, port))

        self.addCleanup(self.stop_port_agent)
        self.port_agent = port_agent
        return port

    def init_port_agent(self):
        """
        @brief Launch the driver process and driver client.  This is used in the
        integration and qualification tests.  The port agent abstracts the physical
        interface with the instrument.
        @retval return the pid to the logger process
        """
        log.info("Startup Port Agent")

        config = {
            'device_addr' : self.comm_config.device_addr,
            'device_port' : self.comm_config.device_port,

            'command_port': self.comm_config.command_port,
            'data_port': self.comm_config.data_port,

            'process_type': PortAgentProcessType.UNIX,
            'log_level': 5,
        }

        self.port_agent = PortAgentProcess.launch_process(config, timeout = 60,
            test_mode = True)

        port = self.port_agent.get_data_port()
        pid  = self.port_agent.get_pid()

        log.info('Started port agent pid %s listening at port %s' % (pid, port))

        if self.launch_monitor:
            self.logfile = self.port_agent.port_agent.logfname
            log.info('Started port agent pid %s listening at port %s' % (pid, port))
            log.info("data log: %s" % self.logfile)
            self.monitor_process = launch_data_monitor(self.logfile)

    def start_pagent(self):
        """
        Construct and start the port agent.
        @retval port Port that was used for connection to agent
        """
        # Create port agent object.
        config = { 'device_addr' : self.device_addr,
                   'device_port' : self.device_port,

                   'command_port': self.command_port,
                   'data_port': self.data_port,

                   'process_type': PortAgentProcessType.UNIX,
                   'log_level': 5,
                  }

        self._pagent = PortAgentProcess.launch_process(config, timeout = 60, test_mode = True)
        pid = self._pagent.get_pid()
        port = self._pagent.get_data_port()

        if(pid and port):
            mi_logger.info('Started port agent pid %d listening at port %d', pid, port)
        else:
            raise PortAgentLaunchException();
            
        return port

 def test_invalid_type(self):
     """
     Test with a bogus port agent type. Should raise an exception
     """
     process = None
     config = self._port_config
     config['type'] = 'foo'
     with self.assertRaises(PortAgentLaunchException) as exp:
         process = PortAgentProcess.get_process(config, timeout = TEST_TIMEOUT, test_mode=True)
     self.assertRegexpMatches(str(exp.exception), 'unknown port agent type:')

    def test_driver_launch(self):
        """
        Test the alternate method for launching a port agent
        """
        process = PortAgentProcess.launch_process(self._port_config, test_mode=True)

        # Check that it launched properly
        self.assertTrue(process.get_pid() > 0)
        self.assertTrue(process.get_data_port())
        # Python logger has no command port
        self.assertEqual(process.get_command_port(), None)

        process.stop()
        self.assertFalse(process.get_pid())

 def test_invalid_process_type(self):
     """
     Test with a bogus process type. Should raise an exception
     """
     process = None
     config = self._port_config
     config["process_type"] = "foo"
     with self.assertRaises(PortAgentLaunchException) as exp:
         process = PortAgentProcess.get_process(config, timeout=TEST_TIMEOUT, test_mode=True)
     self.assertRegexpMatches(
         str(exp.exception),
         ".*unknown port agent process type:.*",
         msg="exception message was " + str(exp.exception),
     )

    def start_pagent(self):
        """
        Construct and start the port agent.
        @retval port Port that was used for connection to agent
        """
        # Create port agent object.
        config = {
            "device_addr": self.device_addr,
            "device_port": self.device_port,
            "working_dir": self.work_dir,
            "delimiter": self.delim,
        }
        self._pagent = PortAgentProcess.launch_process(config, timeout=60, test_mode=True)
        pid = self._pagent.get_pid()
        port = self._pagent.get_data_port()

        mi_logger.info("Started port agent pid %d listening at port %d", pid, port)
        return port