ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 3.136.25.242

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / opt / alt / python27 / lib / python2.7 / site-packages / raven / transport /

Home Upload Mass Deface Mass Delete Back Connect Notify

threaded.py

"""
raven.transport.threaded
~~~~~~~~~~~~~~~~~~~~~~~~

:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import

import atexit
import logging
import threading
import os

from time import sleep, time

from raven.transport.base import AsyncTransport
from raven.transport.http import HTTPTransport
from raven.utils.compat import Queue, check_threads

DEFAULT_TIMEOUT = 10

logger = logging.getLogger('sentry.errors')

class AsyncWorker(object):
    _terminator = object()

def __init__(self, shutdown_timeout=DEFAULT_TIMEOUT):
        check_threads()
        self._queue = Queue(-1)
        self._lock = threading.Lock()
        self._thread = None
        self._thread_for_pid = None
        self.options = {
            'shutdown_timeout': shutdown_timeout,
        }
        self.start()

def is_alive(self):
        if self._thread_for_pid != os.getpid():
            return False
        return self._thread and self._thread.is_alive()

def _ensure_thread(self):
        if self.is_alive():
            return
        self.start()

def main_thread_terminated(self):
        self._lock.acquire()
        try:
            if not self.is_alive():
                # thread not started or already stopped - nothing to do
                return

# wake the processing thread up
            self._queue.put_nowait(self._terminator)

timeout = self.options['shutdown_timeout']

# wait briefly, initially
            initial_timeout = min(0.1, timeout)

if not self._timed_queue_join(initial_timeout):
                # if that didn't work, wait a bit longer
                # NB that size is an approximation, because other threads may
                # add or remove items
                size = self._queue.qsize()

print("Sentry is attempting to send %i pending error messages"
                      % size)
                print("Waiting up to %s seconds" % timeout)

if os.name == 'nt':
                    print("Press Ctrl-Break to quit")
                else:
                    print("Press Ctrl-C to quit")

self._timed_queue_join(timeout - initial_timeout)

self._thread = None

finally:
            self._lock.release()

def _timed_queue_join(self, timeout):
        """
        implementation of Queue.join which takes a 'timeout' argument

returns true on success, false on timeout
        """
        deadline = time() + timeout
        queue = self._queue

queue.all_tasks_done.acquire()
        try:
            while queue.unfinished_tasks:
                delay = deadline - time()
                if delay <= 0:
                    # timed out
                    return False

queue.all_tasks_done.wait(timeout=delay)

return True

finally:
            queue.all_tasks_done.release()

def start(self):
        """
        Starts the task thread.
        """
        self._lock.acquire()
        try:
            if not self.is_alive():
                self._thread = threading.Thread(target=self._target, name="raven.AsyncWorker")
                self._thread.setDaemon(True)
                self._thread.start()
                self._thread_for_pid = os.getpid()
        finally:
            self._lock.release()
            atexit.register(self.main_thread_terminated)

def stop(self, timeout=None):
        """
        Stops the task thread. Synchronous!
        """
        self._lock.acquire()
        try:
            if self._thread:
                self._queue.put_nowait(self._terminator)
                self._thread.join(timeout=timeout)
                self._thread = None
                self._thread_for_pid = None
        finally:
            self._lock.release()

def queue(self, callback, *args, **kwargs):
        self._ensure_thread()
        self._queue.put_nowait((callback, args, kwargs))

def _target(self):
        while True:
            record = self._queue.get()
            try:
                if record is self._terminator:
                    break
                callback, args, kwargs = record
                try:
                    callback(*args, **kwargs)
                except Exception:
                    logger.error('Failed processing job', exc_info=True)
            finally:
                self._queue.task_done()

sleep(0)

class ThreadedHTTPTransport(AsyncTransport, HTTPTransport):

scheme = ['http', 'https', 'threaded+http', 'threaded+https']

def get_worker(self):
        if not hasattr(self, '_worker') or not self._worker.is_alive():
            self._worker = AsyncWorker()
        return self._worker

def send_sync(self, url, data, headers, success_cb, failure_cb):
        try:
            super(ThreadedHTTPTransport, self).send(url, data, headers)
        except Exception as e:
            failure_cb(e)
        else:
            success_cb()

def async_send(self, url, data, headers, success_cb, failure_cb):
        self.get_worker().queue(
            self.send_sync, url, data, headers, success_cb, failure_cb)

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2024-03-21 10:46:16
..	dir	-	root/linksafe	drwxr-xr-x	2024-03-21 10:46:16
__init__.py	text/plain	784 B	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
__init__.pyc	application/x-bytecode.python	817 B	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
base.py	text/plain	1.19 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
base.pyc	application/x-bytecode.python	2 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
eventlet.py	text/plain	1.5 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
eventlet.pyc	application/x-bytecode.python	2.21 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
exceptions.py	text/plain	517 B	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
exceptions.pyc	application/x-bytecode.python	1.1 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
gevent.py	text/plain	1.62 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
gevent.pyc	application/x-bytecode.python	2.36 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
http.py	text/plain	1.78 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
http.pyc	application/x-bytecode.python	2.24 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
registry.py	text/plain	2.54 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
registry.pyc	application/x-bytecode.python	3.31 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
requests.py	text/plain	1 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
requests.pyc	application/x-bytecode.python	1.55 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
threaded.py	text/plain	5.11 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
threaded.pyc	application/x-bytecode.python	6.11 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
threaded_requests.py	text/plain	1.07 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
threaded_requests.pyc	application/x-bytecode.python	1.84 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
tornado.py	text/plain	1.79 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
tornado.pyc	application/x-bytecode.python	2.49 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42
twisted.py	text/plain	2.27 KB	root/linksafe	-rw-r--r--	2017-10-29 05:41:19
twisted.pyc	application/x-bytecode.python	3.33 KB	root/linksafe	-rw-r--r--	2019-10-18 01:53:42