Python device.ExecutableDevice类代码示例

        def initialize(self):
            ExecutableDevice.initialize(self)
            
            # Instantiate the default implementations for all ports on this component
            self.port_dev_resource_in = PortCFResourceIn_i(self, "dev_resource_in")

            self.port_dev_resource_out = PortCFResourceOut_i(self, "dev_resource_out")

 def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams):
     ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams)
     self.threadControlLock = threading.RLock()
     self.process_thread = None
     # self.auto_start is deprecated and is only kept for API compatability
     # with 1.7.X and 1.8.0 components.  This variable may be removed
     # in future releases
     self.auto_start = False

 def initialize(self):
   ExecutableDevice.initialize(self)
   self._props["memCapacity"] = 100000000
   self._props["BogoMipsCapacity"] = 100000000
   self._props["nicCapacity"] = 100.0
   self._props["fakeCapacity"] = 3
   #self._props["execparams"] = " ".join(["%s %s" % x for x in execparams.items()])
   self._usageState = CF.Device.BUSY

 def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams):
   ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES)
   AggregateDevice.__init__(self)
   self._props["memCapacity"] = 100000000
   self._props["BogoMipsCapacity"] = 100000000
   self._props["nicCapacity"] = 100.0
   self._props["fakeCapacity"] = 3
   self._props["execparams"] = " ".join(["%s %s" % x for x in execparams.items()])

 def start(self):
     self.threadControlLock.acquire()
     try:
         ExecutableDevice.start(self)
         if self.process_thread == None:
             self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE)
             self.process_thread.start()
     finally:
         self.threadControlLock.release()

 def releaseObject(self):
     try:
         self.stop()
     except Exception:
         self._log.exception("Error stopping")
     self.threadControlLock.acquire()
     try:
         ExecutableDevice.releaseObject(self)
     finally:
         self.threadControlLock.release()

    def stop(self):
        # Technically not thread-safe but close enough for now
        process_thread = self.process_thread
        self.process_thread = None

        if process_thread != None:
            process_thread.stop()
            process_thread.join(self.TIMEOUT)
            if process_thread.isAlive():
                raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die")
        ExecutableDevice.stop(self)

 def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams):
   self.exit_lock = threading.Lock()
   self.exit_lock.acquire()
   self.process_thread = threading.Thread(target=self.TerminationThread)
   ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES)
   AggregateDevice.__init__(self)
   self._props["memCapacity"] = 100000000
   self._props["BogoMipsCapacity"] = 100000000
   self._props["nicCapacity"] = 100.0
   self._props["fakeCapacity"] = 3
   self._props["execparams"] = " ".join(["%s %s" % x for x in execparams.items()])

    def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams):
        # NB: For now, the ports must be created before calling ExecutableDevice.__init__(),
        #     which registers with the DomainManager, otherwise a race condition may exist.
        #     The DomainManager attempts to make the connections from the DCD, and it is
        #     possible that getPort() will be called before __init__() completes.
        self.ports = {}
        self.ports['event_supplier'] = supplierOut_i(self, 'event_supplier')
        self.ports['event_consumer'] = consumerOut_i(self, 'event_consumer')

        ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES)
        self._props["memCapacity"] = 100000000
        self._props["BogoMipsCapacity"] = 100000000

    def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams):
        ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES)
        AggregateDevice.__init__(self)

        self.__MAX_MEMORY   = 2048
        self.__MAX_BOGOMIPS = 1024
        self.allocated_mem  = 0
        self.allocated_bog  = 0
        self.__mem_name     = 'memCapacity'
        self.__bog_name     = 'BogoMipsCapacity'
        self.__mem_id       = 'DCE:7aeaace8-350e-48da-8d77-f97c2e722e06'
        self.__bog_id       = 'DCE:bbdf708f-ce05-469f-8aed-f5c93e353e14'

        def stop(self):
            self.threadControlLock.acquire()
            try:
                process_thread = self.process_thread
                self.process_thread = None

                if process_thread != None:
                    process_thread.stop()
                    process_thread.join(self.TIMEOUT)
                    if process_thread.isAlive():
                        raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die")
                ExecutableDevice.stop(self)
            finally:
                self.threadControlLock.release()

 def execute(self, name, options, parameters):
   retval = ExecutableDevice.execute(self, name, options, parameters)
   for option in options:
       if option.id == 'STACK_SIZE':
           self._props['check_STACK_SIZE'] = option.value._v
       elif option.id == 'PRIORITY':
           self._props['check_PRIORITY'] = option.value._v
   return retval

 def __getattribute__ (self, attrname):
   """
   Intercept lookup of attributes to allow any method to throw an
   error via the 'exceptionPoint' and 'exceptionType' properties.
   """
   # Use the base class __getattribute__ to avoid recursion.
   getattribute = lambda x: ExecutableDevice.__getattribute__(self, x)
   attribute = getattribute(attrname)
   if callable(attribute) and attrname == getattribute('exceptionPoint'):
     if getattribute('exceptionType') == 'CF.InvalidFileName':
       exception = CF.InvalidFileName(CF.CF_EINVAL, "Test exception")
     elif self.exceptionType == 'CF.Device.InvalidCapacity':
       exception = CF.Device.InvalidCapacity("Test exception", [])
     else:
       exception = Exception()
     return ExceptionFunc(exception)
   return attribute

 def initialize(self):
     ExecutableDevice.initialize(self)

 def configure(self, properties):
   ExecutableDevice.configure(self, properties)
   self.process_thread.start()