File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/local.py.tar
Back
usr/lib/python3/dist-packages/sos/collector/transports/local.py 0000644 00000002660 15030017634 0020726 0 ustar 00 # Copyright Red Hat 2021, Jake Hunsaker <jhunsake@redhat.com> # This file is part of the sos project: https://github.com/sosreport/sos # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # version 2 of the GNU General Public License. # # See the LICENSE file in the source distribution for further information. import os import shutil from sos.collector.transports import RemoteTransport class LocalTransport(RemoteTransport): """ A 'transport' to represent a local node. No remote connection is actually made, and all commands set to be run by this transport are executed locally without any wrappers. """ name = 'local_node' def _connect(self, password): return True def _disconnect(self): return True @property def connected(self): return True def _retrieve_file(self, fname, dest): self.log_debug(f"Moving {fname} to {dest}") shutil.copy(fname, dest) return True def _format_cmd_for_exec(self, cmd): return cmd def _copy_file_to_remote(self, fname, dest): return True def _read_file(self, fname): if os.path.exists(fname): with open(fname, 'r', encoding='utf-8') as rfile: return rfile.read() self.log_debug(f"No such file: {fname}") return '' # vim: set et ts=4 sw=4 : usr/local/CyberCP/lib/python3.10/site-packages/asgiref/local.py 0000644 00000011310 15030036427 0020127 0 ustar 00 import asyncio import contextlib import contextvars import threading from typing import Any, Dict, Union class _CVar: """Storage utility for Local.""" def __init__(self) -> None: self._data: "contextvars.ContextVar[Dict[str, Any]]" = contextvars.ContextVar( "asgiref.local" ) def __getattr__(self, key): storage_object = self._data.get({}) try: return storage_object[key] except KeyError: raise AttributeError(f"{self!r} object has no attribute {key!r}") def __setattr__(self, key: str, value: Any) -> None: if key == "_data": return super().__setattr__(key, value) storage_object = self._data.get({}) storage_object[key] = value self._data.set(storage_object) def __delattr__(self, key: str) -> None: storage_object = self._data.get({}) if key in storage_object: del storage_object[key] self._data.set(storage_object) else: raise AttributeError(f"{self!r} object has no attribute {key!r}") class Local: """Local storage for async tasks. This is a namespace object (similar to `threading.local`) where data is also local to the current async task (if there is one). In async threads, local means in the same sense as the `contextvars` module - i.e. a value set in an async frame will be visible: - to other async code `await`-ed from this frame. - to tasks spawned using `asyncio` utilities (`create_task`, `wait_for`, `gather` and probably others). - to code scheduled in a sync thread using `sync_to_async` In "sync" threads (a thread with no async event loop running), the data is thread-local, but additionally shared with async code executed via the `async_to_sync` utility, which schedules async code in a new thread and copies context across to that thread. If `thread_critical` is True, then the local will only be visible per-thread, behaving exactly like `threading.local` if the thread is sync, and as `contextvars` if the thread is async. This allows genuinely thread-sensitive code (such as DB handles) to be kept stricly to their initial thread and disable the sharing across `sync_to_async` and `async_to_sync` wrapped calls. Unlike plain `contextvars` objects, this utility is threadsafe. """ def __init__(self, thread_critical: bool = False) -> None: self._thread_critical = thread_critical self._thread_lock = threading.RLock() self._storage: "Union[threading.local, _CVar]" if thread_critical: # Thread-local storage self._storage = threading.local() else: # Contextvar storage self._storage = _CVar() @contextlib.contextmanager def _lock_storage(self): # Thread safe access to storage if self._thread_critical: try: # this is a test for are we in a async or sync # thread - will raise RuntimeError if there is # no current loop asyncio.get_running_loop() except RuntimeError: # We are in a sync thread, the storage is # just the plain thread local (i.e, "global within # this thread" - it doesn't matter where you are # in a call stack you see the same storage) yield self._storage else: # We are in an async thread - storage is still # local to this thread, but additionally should # behave like a context var (is only visible with # the same async call stack) # Ensure context exists in the current thread if not hasattr(self._storage, "cvar"): self._storage.cvar = _CVar() # self._storage is a thread local, so the members # can't be accessed in another thread (we don't # need any locks) yield self._storage.cvar else: # Lock for thread_critical=False as other threads # can access the exact same storage object with self._thread_lock: yield self._storage def __getattr__(self, key): with self._lock_storage() as storage: return getattr(storage, key) def __setattr__(self, key, value): if key in ("_local", "_storage", "_thread_critical", "_thread_lock"): return super().__setattr__(key, value) with self._lock_storage() as storage: setattr(storage, key, value) def __delattr__(self, key): with self._lock_storage() as storage: delattr(storage, key)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings