Python imp.acquire_lock方法代码示例

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def declare_namespace(packageName):
    """Declare that package 'packageName' is a namespace package"""

    _imp.acquire_lock()
    try:
        if packageName in _namespace_packages:
            return

        path, parent = sys.path, None
        if '.' in packageName:
            parent = '.'.join(packageName.split('.')[:-1])
            declare_namespace(parent)
            if parent not in _namespace_packages:
                __import__(parent)
            try:
                path = sys.modules[parent].__path__
            except AttributeError:
                raise TypeError("Not a package:", parent)

        # Track what packages are namespaces, so when new path items are added,
        # they can be updated
        _namespace_packages.setdefault(parent, []).append(packageName)
        _namespace_packages.setdefault(packageName, [])

        for path_item in path:
            # Ensure all the parent's path items are reflected in the child,
            # if they apply
            _handle_ns(packageName, path_item)

    finally:
        _imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def fixup_namespace_packages(path_item, parent=None):
    """Ensure that previously-declared namespace packages include path_item"""
    _imp.acquire_lock()
    try:
        for package in _namespace_packages.get(parent, ()):
            subpath = _handle_ns(package, path_item)
            if subpath:
                fixup_namespace_packages(subpath, package)
    finally:
        _imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def declare_namespace(packageName):
    """Declare that package 'packageName' is a namespace package"""

    _imp.acquire_lock()
    try:
        if packageName in _namespace_packages:
            return

        path, parent = sys.path, None
        if '.' in packageName:
            parent = '.'.join(packageName.split('.')[:-1])
            declare_namespace(parent)
            if parent not in _namespace_packages:
                __import__(parent)
            try:
                path = sys.modules[parent].__path__
            except AttributeError:
                raise TypeError("Not a package:", parent)

        # Track what packages are namespaces, so when new path items are added,
        # they can be updated
        _namespace_packages.setdefault(parent,[]).append(packageName)
        _namespace_packages.setdefault(packageName,[])

        for path_item in path:
            # Ensure all the parent's path items are reflected in the child,
            # if they apply
            _handle_ns(packageName, path_item)

    finally:
        _imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def fixup_namespace_packages(path_item, parent=None):
    """Ensure that previously-declared namespace packages include path_item"""
    _imp.acquire_lock()
    try:
        for package in _namespace_packages.get(parent,()):
            subpath = _handle_ns(package, path_item)
            if subpath:
                fixup_namespace_packages(subpath, package)
    finally:
        _imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def collectPlugins(self):
        """
        This method locates and loads plugins

        Also, it attaches the Panoptes Context, Key/Value Store class and any data to the
        PanoptesPluginInfo object so that these are available to the plugin when it is being executed

        Returns:
            None
        """
        logger = self._panoptes_context.logger
        self.locatePlugins()

        # Set the name of the configuration file so that we can find the mtime for that file while deciding if the
        # the plugin should be executed
        for candidate_infofile, candidate_filepath, plugin_info in self._candidates:
            plugin_info.config_filename = candidate_infofile

        imp.acquire_lock()
        plugins = self.loadPlugins()
        imp.release_lock()
        logger.debug(u'Found %d plugins' % len(plugins))
        for plugin in plugins:
            logger.debug(
                u'Loaded plugin "%s", version "%s" of type "%s", category "%s"' % (
                    plugin.name, plugin.version, self._plugin_type, plugin.category))
            plugin.panoptes_context = self._panoptes_context
            plugin.kv_store_class = self._kv_store_class
            plugin.data = self._data 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def unload_modules(self):
        logger = self._panoptes_context.logger
        for plugin in self.getAllPlugins():
            plugin_module = plugin.plugin_object.__module__
            logger.debug(u'Deleting module: %s' % plugin_module)
            imp.acquire_lock()
            try:
                del sys.modules[plugin_module]
            except KeyError:
                logger.error('Error trying to delete module "%s" for plugin "%s" with config "%s"' % (
                    plugin_module, plugin.normalized_name, plugin.config))
            finally:
                imp.release_lock()
            del plugin.plugin_object 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def declare_namespace(packageName):
    """Declare that package 'packageName' is a namespace package"""

    imp.acquire_lock()
    try:
        if packageName in _namespace_packages:
            return

        path, parent = sys.path, None
        if '.' in packageName:
            parent = '.'.join(packageName.split('.')[:-1])
            declare_namespace(parent)
            if parent not in _namespace_packages:
                __import__(parent)
            try:
                path = sys.modules[parent].__path__
            except AttributeError:
                raise TypeError("Not a package:", parent)

        # Track what packages are namespaces, so when new path items are added,
        # they can be updated
        _namespace_packages.setdefault(parent,[]).append(packageName)
        _namespace_packages.setdefault(packageName,[])

        for path_item in path:
            # Ensure all the parent's path items are reflected in the child,
            # if they apply
            _handle_ns(packageName, path_item)

    finally:
        imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def fixup_namespace_packages(path_item, parent=None):
    """Ensure that previously-declared namespace packages include path_item"""
    imp.acquire_lock()
    try:
        for package in _namespace_packages.get(parent,()):
            subpath = _handle_ns(package, path_item)
            if subpath: fixup_namespace_packages(subpath, package)
    finally:
        imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def declare_namespace(packageName):
    """Declare that package 'packageName' is a namespace package"""

    _imp.acquire_lock()
    try:
        if packageName in _namespace_packages:
            return

        path = sys.path
        parent, _, _ = packageName.rpartition('.')

        if parent:
            declare_namespace(parent)
            if parent not in _namespace_packages:
                __import__(parent)
            try:
                path = sys.modules[parent].__path__
            except AttributeError:
                raise TypeError("Not a package:", parent)

        # Track what packages are namespaces, so when new path items are added,
        # they can be updated
        _namespace_packages.setdefault(parent or None, []).append(packageName)
        _namespace_packages.setdefault(packageName, [])

        for path_item in path:
            # Ensure all the parent's path items are reflected in the child,
            # if they apply
            _handle_ns(packageName, path_item)

    finally:
        _imp.release_lock() 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def testLock(self):
        LOOPS = 50

        # The import lock may already be held, e.g. if the test suite is run
        # via "import test.autotest".
        lock_held_at_start = imp.lock_held()
        self.verify_lock_state(lock_held_at_start)

        for i in range(LOOPS):
            imp.acquire_lock()
            self.verify_lock_state(True)

        for i in range(LOOPS):
            imp.release_lock()

        # The original state should be restored now.
        self.verify_lock_state(lock_held_at_start)

        if not lock_held_at_start:
            try:
                imp.release_lock()
            except RuntimeError:
                pass
            else:
                self.fail("release_lock() without lock should raise "
                            "RuntimeError") 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def test_import_lock_fork(self):
        import_started = threading.Event()
        fake_module_name = "fake test module"
        partial_module = "partial"
        complete_module = "complete"
        def importer():
            imp.acquire_lock()
            sys.modules[fake_module_name] = partial_module
            import_started.set()
            time.sleep(0.01) # Give the other thread time to try and acquire.
            sys.modules[fake_module_name] = complete_module
            imp.release_lock()
        t = threading.Thread(target=importer)
        t.start()
        import_started.wait()
        pid = os.fork()
        try:
            if not pid:
                m = __import__(fake_module_name)
                if m == complete_module:
                    os._exit(0)
                else:
                    os._exit(1)
            else:
                t.join()
                # Exitcode 1 means the child got a partial module (bad.) No
                # exitcode (but a hang, which manifests as 'got pid 0')
                # means the child deadlocked (also bad.)
                self.wait_impl(pid)
        finally:
            try:
                os.kill(pid, signal.SIGKILL)
            except OSError:
                pass 

# 需要导入模块: import imp [as 别名]
# 或者: from imp import acquire_lock [as 别名]
def test_lock(self):
        i=0
        while i<5:
            i+=1
            if not imp.lock_held():
                self.assertRaises(RuntimeError,imp.release_lock)
                imp.acquire_lock()
            else:
                imp.release_lock()