File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/servers.tar
Back
__pycache__/__init__.cpython-310.pyc 0000644 00000000254 15030056576 0013224 0 ustar 00 o �h � @ s d S )N� r r r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/servers/__init__.py�<module> s __pycache__/basehttp.cpython-310.pyc 0000644 00000020227 15030056576 0013301 0 ustar 00 o �h�& � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z ddl m Z ddl mZ ddlmZ dd lmZ d Ze�d �Zd d � Zdd� ZG dd� dej�ZG dd� deje�ZG dd� dej�ZG dd� dej �Z dddefdd�Z dS )a0 HTTP server that implements the Python WSGI protocol (PEP 333, rev 1.21). Based on wsgiref.simple_server which is part of the standard library since 2.5. This is a simple server for use in testing or debugging Django apps. It hasn't been reviewed for security issues. DON'T USE IT FOR PRODUCTION USE! � N)�deque)� simple_server)�ImproperlyConfigured)� LimitedStream)�get_wsgi_application)� connections)� import_string)� WSGIServer�WSGIRequestHandlerz django.serverc C sV ddl m} t| d�}|du rt� S zt|�W S ty* } ztd| �|�d}~ww )aK Load and return the WSGI application as configured by the user in ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout, this will be the ``application`` object in ``projectname/wsgi.py``. This function, and the ``WSGI_APPLICATION`` setting itself, are only useful for Django's internal server (runserver); external WSGI servers should just be configured to point to the correct application object directly. If settings.WSGI_APPLICATION is not set (is ``None``), return whatever ``django.core.wsgi.get_wsgi_application`` returns. r )�settings�WSGI_APPLICATIONNzBWSGI application '%s' could not be loaded; Error importing module.)� django.confr �getattrr r � ImportErrorr )r �app_path�err� r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/servers/basehttp.py� get_internal_wsgi_application s �����r c C s t �� \} }}t| tttf�S �N)�sys�exc_info� issubclass�BrokenPipeError�ConnectionAbortedError�ConnectionResetError)�exc_type�_r r r �is_broken_pipe_error8 s ��r c s8 e Zd ZdZdZddd�� fdd� Z� fdd �Z� ZS ) r z7BaseHTTPServer that implements the Python WSGI protocol� FT)�ipv6�allow_reuse_addressc s( |rt j| _|| _t� j|i |�� d S r )�socket�AF_INET6�address_familyr! �super�__init__)�selfr r! �args�kwargs�� __class__r r r& I s zWSGIServer.__init__c s( t � r t�d|� d S t� �||� d S )Nz- Broken pipe from %s)r �logger�infor% � handle_error)r' �request�client_addressr* r r r. O s zWSGIServer.handle_error)�__name__� __module__� __qualname__�__doc__�request_queue_sizer& r. � __classcell__r r r* r r D s r c sJ e Zd ZdZdZdd�� fdd� Z� fdd�Zd d � Z� fd d �Z� Z S ) �ThreadedWSGIServerz$A threaded version of the WSGIServerTN)�connections_overridec s t � j|i |�� || _d S r )r% r& r8 )r' r8 r( r) r* r r r& [ s zThreadedWSGIServer.__init__c s4 | j r| j �� D ]\}}|t|< qt� �||� d S r )r8 �itemsr r% �process_request_thread)r' r/ r0 �alias�connr* r r r: a s z)ThreadedWSGIServer.process_request_threadc C s t �� d S r )r � close_all�r' r r r �_close_connectionsi s z%ThreadedWSGIServer._close_connectionsc s | � � t� �|� d S r )r? r% � close_request)r' r/ r* r r r@ m s z ThreadedWSGIServer.close_request) r1 r2 r3 r4 �daemon_threadsr& r: r? r@ r6 r r r* r r7 V s r7 c sD e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� ZS ) � ServerHandlerz1.1c sR z t |�d��}W n ttfy d}Y nw t� jt||�|||fi |�� dS )a# Use a LimitedStream so that unread request data will be ignored at the end of the request. WSGIRequest uses a LimitedStream but it shouldn't discard the data since the upstream servers usually do this. This fix applies only for testserver/runserver. �CONTENT_LENGTHr N)�int�get� ValueError� TypeErrorr% r& r )r' �stdin�stdout�stderr�environr) �content_lengthr* r r r& u s �� �zServerHandler.__init__c s� t � �� | jd dkrd| jv r| jd= | jd dkr'd| jvr'd| jd< n t| jjtj�s4d| jd< | j� d�dkrBd| j_ d S d S )N�REQUEST_METHOD�HEADzContent-Length�close� ConnectionT) r% �cleanup_headersrK �headers� isinstance�request_handler�server� socketserver�ThreadingMixInrE �close_connectionr> r* r r rQ � s �z ServerHandler.cleanup_headersc s | � � �� t� �� d S r )� get_stdin�readr% rO r> r* r r rO � s zServerHandler.closec s` | j d dkr)z t| jdd� | js | �� W | �� d S W | �� d S | �� w t� �� d S )NrM rN r )�maxlen)rK r �result� headers_sent� send_headersrO r% �finish_responser> r* r r r_ � s �z ServerHandler.finish_response) r1 r2 r3 � http_versionr& rQ rO r_ r6 r r r* r rB r s rB c s@ e Zd ZdZdd� Zdd� Z� fdd�Zdd � Zd d � Z� Z S ) r zHTTP/1.1c C s | j d S )Nr )r0 r> r r r �address_string� s z!WSGIRequestHandler.address_stringc G s� | j | �� d�}|d d dkr$|d �d�r$d|d< tjd|d � d S |d �� rPt|d �d krPt|d �}||d< |dkrDtj}n|d krLtj}ntj }ntj }||g|�R d |i� d S ) N)r/ � server_time� r �4zi� � status_codezNYou're accessing the development server over HTTPS, but it only supports HTTP.)�extra� i� rf ) r/ �log_date_time_string� startswithr, �error�isdigit�lenrD �warningr- )r' �formatr( rf re �levelr r r � log_message� s* �� z WSGIRequestHandler.log_messagec s& | j D ] }d|v r | j |= qt� �� S )Nr )rR r% � get_environ)r' �kr* r r rq � s � z WSGIRequestHandler.get_environc C sP d| _ | �� | j s| �� | j r z | j�tj� W d S ttfy' Y d S w )NT)rX �handle_one_request� connection�shutdownr" �SHUT_WR�AttributeError�OSErrorr> r r r �handle� s ��zWSGIRequestHandler.handlec C s| | j �d�| _t| j�dkr d| _d| _d| _| �d� dS | �� s$dS t | j | j | � � | � � �}| |_ |�| j�� � dS )zDCopy of WSGIRequestHandler.handle() but with different ServerHandleri i � i� N)�rfile�readline�raw_requestlinerl � requestline�request_version�command� send_error� parse_requestrB �wfile� get_stderrrq rT �runrU �get_app)r' �handlerr r r rs � s �z%WSGIRequestHandler.handle_one_request) r1 r2 r3 �protocol_versionra rp rq ry rs r6 r r r* r r � s r Fc C sj | |f}|rt dtj|fi �}n|}||t|d�} |d ur%|t| d|�� |r*d| _| �|� | �� d S )Nr )r � server_portT)�typerV rW r r rA �set_app� serve_forever) �addr�port� wsgi_handlerr � threading�on_bind� server_cls�server_address� httpd_cls�httpdr r r r� � s r� ) r4 �loggingr" rV r � collectionsr �wsgirefr �django.core.exceptionsr �django.core.handlers.wsgir �django.core.wsgir � django.dbr �django.utils.module_loadingr �__all__� getLoggerr, r r r rW r7 rB r r� r r r r �<module> s2 >S� basehttp.py 0000644 00000023320 15030056576 0006737 0 ustar 00 """ HTTP server that implements the Python WSGI protocol (PEP 333, rev 1.21). Based on wsgiref.simple_server which is part of the standard library since 2.5. This is a simple server for use in testing or debugging Django apps. It hasn't been reviewed for security issues. DON'T USE IT FOR PRODUCTION USE! """ import logging import socket import socketserver import sys from collections import deque from wsgiref import simple_server from django.core.exceptions import ImproperlyConfigured from django.core.handlers.wsgi import LimitedStream from django.core.wsgi import get_wsgi_application from django.db import connections from django.utils.module_loading import import_string __all__ = ("WSGIServer", "WSGIRequestHandler") logger = logging.getLogger("django.server") def get_internal_wsgi_application(): """ Load and return the WSGI application as configured by the user in ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout, this will be the ``application`` object in ``projectname/wsgi.py``. This function, and the ``WSGI_APPLICATION`` setting itself, are only useful for Django's internal server (runserver); external WSGI servers should just be configured to point to the correct application object directly. If settings.WSGI_APPLICATION is not set (is ``None``), return whatever ``django.core.wsgi.get_wsgi_application`` returns. """ from django.conf import settings app_path = getattr(settings, "WSGI_APPLICATION") if app_path is None: return get_wsgi_application() try: return import_string(app_path) except ImportError as err: raise ImproperlyConfigured( "WSGI application '%s' could not be loaded; " "Error importing module." % app_path ) from err def is_broken_pipe_error(): exc_type, _, _ = sys.exc_info() return issubclass( exc_type, ( BrokenPipeError, ConnectionAbortedError, ConnectionResetError, ), ) class WSGIServer(simple_server.WSGIServer): """BaseHTTPServer that implements the Python WSGI protocol""" request_queue_size = 10 def __init__(self, *args, ipv6=False, allow_reuse_address=True, **kwargs): if ipv6: self.address_family = socket.AF_INET6 self.allow_reuse_address = allow_reuse_address super().__init__(*args, **kwargs) def handle_error(self, request, client_address): if is_broken_pipe_error(): logger.info("- Broken pipe from %s", client_address) else: super().handle_error(request, client_address) class ThreadedWSGIServer(socketserver.ThreadingMixIn, WSGIServer): """A threaded version of the WSGIServer""" daemon_threads = True def __init__(self, *args, connections_override=None, **kwargs): super().__init__(*args, **kwargs) self.connections_override = connections_override # socketserver.ThreadingMixIn.process_request() passes this method as # the target to a new Thread object. def process_request_thread(self, request, client_address): if self.connections_override: # Override this thread's database connections with the ones # provided by the parent thread. for alias, conn in self.connections_override.items(): connections[alias] = conn super().process_request_thread(request, client_address) def _close_connections(self): # Used for mocking in tests. connections.close_all() def close_request(self, request): self._close_connections() super().close_request(request) class ServerHandler(simple_server.ServerHandler): http_version = "1.1" def __init__(self, stdin, stdout, stderr, environ, **kwargs): """ Use a LimitedStream so that unread request data will be ignored at the end of the request. WSGIRequest uses a LimitedStream but it shouldn't discard the data since the upstream servers usually do this. This fix applies only for testserver/runserver. """ try: content_length = int(environ.get("CONTENT_LENGTH")) except (ValueError, TypeError): content_length = 0 super().__init__( LimitedStream(stdin, content_length), stdout, stderr, environ, **kwargs ) def cleanup_headers(self): super().cleanup_headers() if ( self.environ["REQUEST_METHOD"] == "HEAD" and "Content-Length" in self.headers ): del self.headers["Content-Length"] # HTTP/1.1 requires support for persistent connections. Send 'close' if # the content length is unknown to prevent clients from reusing the # connection. if ( self.environ["REQUEST_METHOD"] != "HEAD" and "Content-Length" not in self.headers ): self.headers["Connection"] = "close" # Persistent connections require threading server. elif not isinstance(self.request_handler.server, socketserver.ThreadingMixIn): self.headers["Connection"] = "close" # Mark the connection for closing if it's set as such above or if the # application sent the header. if self.headers.get("Connection") == "close": self.request_handler.close_connection = True def close(self): self.get_stdin().read() super().close() def finish_response(self): if self.environ["REQUEST_METHOD"] == "HEAD": try: deque(self.result, maxlen=0) # Consume iterator. # Don't call self.finish_content() as, if the headers have not # been sent and Content-Length isn't set, it'll default to "0" # which will prevent omission of the Content-Length header with # HEAD requests as permitted by RFC 9110 Section 9.3.2. # Instead, send the headers, if not sent yet. if not self.headers_sent: self.send_headers() finally: self.close() else: super().finish_response() class WSGIRequestHandler(simple_server.WSGIRequestHandler): protocol_version = "HTTP/1.1" def address_string(self): # Short-circuit parent method to not call socket.getfqdn return self.client_address[0] def log_message(self, format, *args): extra = { "request": self.request, "server_time": self.log_date_time_string(), } if args[1][0] == "4": # 0x16 = Handshake, 0x03 = SSL 3.0 or TLS 1.x if args[0].startswith("\x16\x03"): extra["status_code"] = 500 logger.error( "You're accessing the development server over HTTPS, but " "it only supports HTTP.", extra=extra, ) return if args[1].isdigit() and len(args[1]) == 3: status_code = int(args[1]) extra["status_code"] = status_code if status_code >= 500: level = logger.error elif status_code >= 400: level = logger.warning else: level = logger.info else: level = logger.info level(format, *args, extra=extra) def get_environ(self): # Strip all headers with underscores in the name before constructing # the WSGI environ. This prevents header-spoofing based on ambiguity # between underscores and dashes both normalized to underscores in WSGI # env vars. Nginx and Apache 2.4+ both do this as well. for k in self.headers: if "_" in k: del self.headers[k] return super().get_environ() def handle(self): self.close_connection = True self.handle_one_request() while not self.close_connection: self.handle_one_request() try: self.connection.shutdown(socket.SHUT_WR) except (AttributeError, OSError): pass def handle_one_request(self): """Copy of WSGIRequestHandler.handle() but with different ServerHandler""" self.raw_requestline = self.rfile.readline(65537) if len(self.raw_requestline) > 65536: self.requestline = "" self.request_version = "" self.command = "" self.send_error(414) return if not self.parse_request(): # An error code has been sent, just exit return handler = ServerHandler( self.rfile, self.wfile, self.get_stderr(), self.get_environ() ) handler.request_handler = self # backpointer for logging & connection closing handler.run(self.server.get_app()) def run( addr, port, wsgi_handler, ipv6=False, threading=False, on_bind=None, server_cls=WSGIServer, ): server_address = (addr, port) if threading: httpd_cls = type("WSGIServer", (socketserver.ThreadingMixIn, server_cls), {}) else: httpd_cls = server_cls httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6) if on_bind is not None: on_bind(getattr(httpd, "server_port", port)) if threading: # ThreadingMixIn.daemon_threads indicates how threads will behave on an # abrupt shutdown; like quitting the server by the user or restarting # by the auto-reloader. True means the server will not wait for thread # termination before it quits. This will make auto-reloader faster # and will prevent the need to kill the server manually if a thread # isn't terminating correctly. httpd.daemon_threads = True httpd.set_app(wsgi_handler) httpd.serve_forever() __init__.py 0000644 00000000000 15030056576 0006652 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings