golden hour
/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/__pycache__
⬆️ Go Up
Upload
File/Folder
Size
Actions
__init__.cpython-310.pyc
378 B
Del
OK
_locale_data.cpython-310.pyc
3.23 KB
Del
OK
auth.cpython-310.pyc
39.18 KB
Del
OK
autoreload.cpython-310.pyc
7.02 KB
Del
OK
concurrent.cpython-310.pyc
17.24 KB
Del
OK
curl_httpclient.cpython-310.pyc
12.8 KB
Del
OK
escape.cpython-310.pyc
9.89 KB
Del
OK
gen.cpython-310.pyc
38.39 KB
Del
OK
http1connection.cpython-310.pyc
19.47 KB
Del
OK
httpclient.cpython-310.pyc
25.19 KB
Del
OK
httpserver.cpython-310.pyc
11.45 KB
Del
OK
httputil.cpython-310.pyc
29.84 KB
Del
OK
ioloop.cpython-310.pyc
33.19 KB
Del
OK
iostream.cpython-310.pyc
42.97 KB
Del
OK
locale.cpython-310.pyc
15.22 KB
Del
OK
locks.cpython-310.pyc
16.61 KB
Del
OK
log.cpython-310.pyc
8.07 KB
Del
OK
netutil.cpython-310.pyc
14.32 KB
Del
OK
options.cpython-310.pyc
19.63 KB
Del
OK
process.cpython-310.pyc
10.27 KB
Del
OK
queues.cpython-310.pyc
11.29 KB
Del
OK
routing.cpython-310.pyc
21.08 KB
Del
OK
simple_httpclient.cpython-310.pyc
16.08 KB
Del
OK
stack_context.cpython-310.pyc
10.65 KB
Del
OK
tcpclient.cpython-310.pyc
6.49 KB
Del
OK
tcpserver.cpython-310.pyc
10.06 KB
Del
OK
template.cpython-310.pyc
30.52 KB
Del
OK
testing.cpython-310.pyc
24.61 KB
Del
OK
util.cpython-310.pyc
13.72 KB
Del
OK
web.cpython-310.pyc
105.22 KB
Del
OK
websocket.cpython-310.pyc
39.08 KB
Del
OK
wsgi.cpython-310.pyc
11.5 KB
Del
OK
Edit: routing.cpython-310.pyc
o �xe(U � @ sn d Z ddlmZmZmZ ddlZddlmZ ddlm Z ddl m Z ddl m Z mZmZ ddlmZ dd lmZmZmZmZ zddlZW n eyM Y nw G d d � d e j�ZG d d � d e�ZG dd� de j �Z G dd� de�Z G dd� dee �Z G dd� de �Z!G dd� de �Z"G dd� de"�Z#G dd� de"�Z$G d d � d e"�Z%G d d � d e"�Z&G d d!� d!e!�Z'd"d#� Z(dS )$aq Flexible routing implementation. Tornado routes HTTP requests to appropriate handlers using `Router` class implementations. The `tornado.web.Application` class is a `Router` implementation and may be used directly, or the classes in this module may be used for additional flexibility. The `RuleRouter` class can match on more criteria than `.Application`, or the `Router` interface can be subclassed for maximum customization. `Router` interface extends `~.httputil.HTTPServerConnectionDelegate` to provide additional routing capabilities. This also means that any `Router` implementation can be used directly as a ``request_callback`` for `~.httpserver.HTTPServer` constructor. `Router` subclass must implement a ``find_handler`` method to provide a suitable `~.httputil.HTTPMessageDelegate` instance to handle the request: .. code-block:: python class CustomRouter(Router): def find_handler(self, request, **kwargs): # some routing logic providing a suitable HTTPMessageDelegate instance return MessageDelegate(request.connection) class MessageDelegate(HTTPMessageDelegate): def __init__(self, connection): self.connection = connection def finish(self): self.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": "2"}), b"OK") self.connection.finish() router = CustomRouter() server = HTTPServer(router) The main responsibility of `Router` implementation is to provide a mapping from a request to `~.httputil.HTTPMessageDelegate` instance that will handle this request. In the example above we can see that routing is possible even without instantiating an `~.web.Application`. For routing to `~.web.RequestHandler` implementations we need an `~.web.Application` instance. `~.web.Application.get_handler_delegate` provides a convenient way to create `~.httputil.HTTPMessageDelegate` for a given request and `~.web.RequestHandler`. Here is a simple example of how we can we route to `~.web.RequestHandler` subclasses by HTTP method: .. code-block:: python resources = {} class GetResource(RequestHandler): def get(self, path): if path not in resources: raise HTTPError(404) self.finish(resources[path]) class PostResource(RequestHandler): def post(self, path): resources[path] = self.request.body class HTTPMethodRouter(Router): def __init__(self, app): self.app = app def find_handler(self, request, **kwargs): handler = GetResource if request.method == "GET" else PostResource return self.app.get_handler_delegate(request, handler, path_args=[request.path]) router = HTTPMethodRouter(Application()) server = HTTPServer(router) `ReversibleRouter` interface adds the ability to distinguish between the routes and reverse them to the original urls using route's name and additional arguments. `~.web.Application` is itself an implementation of `ReversibleRouter` class. `RuleRouter` and `ReversibleRuleRouter` are implementations of `Router` and `ReversibleRouter` interfaces and can be used for creating rule-based routing configurations. Rules are instances of `Rule` class. They contain a `Matcher`, which provides the logic for determining whether the rule is a match for a particular request and a target, which can be one of the following. 1) An instance of `~.httputil.HTTPServerConnectionDelegate`: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/handler"), ConnectionDelegate()), # ... more rules ]) class ConnectionDelegate(HTTPServerConnectionDelegate): def start_request(self, server_conn, request_conn): return MessageDelegate(request_conn) 2) A callable accepting a single argument of `~.httputil.HTTPServerRequest` type: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/callable"), request_callable) ]) def request_callable(request): request.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK") request.finish() 3) Another `Router` instance: .. code-block:: python router = RuleRouter([ Rule(PathMatches("/router.*"), CustomRouter()) ]) Of course a nested `RuleRouter` or a `~.web.Application` is allowed: .. code-block:: python router = RuleRouter([ Rule(HostMatches("example.com"), RuleRouter([ Rule(PathMatches("/app1/.*"), Application([(r"/app1/handler", Handler)]))), ])) ]) server = HTTPServer(router) In the example below `RuleRouter` is used to route between applications: .. code-block:: python app1 = Application([ (r"/app1/handler", Handler1), # other handlers ... ]) app2 = Application([ (r"/app2/handler", Handler2), # other handlers ... ]) router = RuleRouter([ Rule(PathMatches("/app1.*"), app1), Rule(PathMatches("/app2.*"), app2) ]) server = HTTPServer(router) For more information on application-level routing see docs for `~.web.Application`. .. versionadded:: 4.5 � )�absolute_import�division�print_functionN)�partial)�httputil)�_CallableAdapter)� url_escape� url_unescape�utf8)�app_log)�basestring_type� import_object� re_unescape� unicode_typec @ � e Zd ZdZdd� Zdd� ZdS )�RouterzAbstract router interface.c K � t � �)a� Must be implemented to return an appropriate instance of `~.httputil.HTTPMessageDelegate` that can serve the request. Routing implementations may pass additional kwargs to extend the routing logic. :arg httputil.HTTPServerRequest request: current HTTP request. :arg kwargs: additional keyword arguments passed by routing implementation. :returns: an instance of `~.httputil.HTTPMessageDelegate` that will be used to process the request. ��NotImplementedError)�self�request�kwargs� r �L/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/routing.py� find_handler� s zRouter.find_handlerc C s t | ||�S �N)�_RoutingDelegate)r � server_conn� request_connr r r � start_request� � zRouter.start_requestN)�__name__� __module__� __qualname__�__doc__r r r r r r r � s r c @ � e Zd ZdZdd� ZdS )�ReversibleRouterzxAbstract router interface for routers that can handle named routes and support reversing them to original urls. c G r )a Returns url string for a given route name and arguments or ``None`` if no match is found. :arg str name: route name. :arg args: url parameters. :returns: parametrized url string for a given route name (or ``None``). r )r �name�argsr r r � reverse_url� s z ReversibleRouter.reverse_urlN)r! r" r# r$ r) r r r r r& � s r& c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) r c C s || _ || _d | _|| _d S r )r r �delegate�router)r r+ r r r r r �__init__� s z_RoutingDelegate.__init__c C s2 t j| j| j||d�}| j�|�| _| j�||�S )N)� connection�server_connection� start_line�headers)r ZHTTPServerRequestr r r+ r r* �headers_received)r r/ r0 r r r r r1 � s �z!_RoutingDelegate.headers_receivedc C s | j �|�S r )r* � data_received)r �chunkr r r r2 � r z _RoutingDelegate.data_receivedc C � | j �� d S r )r* �finish�r r r r r5 � � z_RoutingDelegate.finishc C r4 r )r* �on_connection_closer6 r r r r8 � r7 z$_RoutingDelegate.on_connection_closeN)r! r" r# r, r1 r2 r5 r8 r r r r r � s r c @ s: e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd d � ZdS )� RuleRouterz!Rule-based router implementation.Nc C s g | _ |r | �|� dS dS )aA Constructs a router from an ordered list of rules:: RuleRouter([ Rule(PathMatches("/handler"), Target), # ... more rules ]) You can also omit explicit `Rule` constructor and use tuples of arguments:: RuleRouter([ (PathMatches("/handler"), Target), ]) `PathMatches` is a default matcher, so the example above can be simplified:: RuleRouter([ ("/handler", Target), ]) In the examples above, ``Target`` can be a nested `Router` instance, an instance of `~.httputil.HTTPServerConnectionDelegate` or an old-style callable, accepting a request argument. :arg rules: a list of `Rule` instances or tuples of `Rule` constructor arguments. N)�rules� add_rules�r r: r r r r, s �zRuleRouter.__init__c C sv |D ]6}t |ttf�r/t|�dv sJ �t |d t�r+tt|d �g|dd� �R � }nt|� }| j�| � |�� qdS )z�Appends new rules to the router. :arg rules: a list of Rule instances (or tuples of arguments, which are passed to Rule constructor). )� � � r � N) � isinstance�tuple�list�lenr �Rule� PathMatchesr: �append� process_rule)r r: �ruler r r r; # s "�zRuleRouter.add_rulesc C s |S )z�Override this method for additional preprocessing of each rule. :arg Rule rule: a rule to be processed. :returns: the same or modified Rule instance. r �r rI r r r rH 3 s zRuleRouter.process_rulec K sZ | j D ]'}|j�|�}|d ur*|jr|j|d< | j|j|fi |��}|d ur*| S qd S )N� target_kwargs)r: �matcher�matchrK �get_target_delegate�target)r r r rI � target_paramsr* r r r r ; s ���zRuleRouter.find_handlerc K s\ t |t�r|j|fi |��S t |tj�r |�|j|j�S t|�r,t t |fi |��|j�S dS )a� Returns an instance of `~.httputil.HTTPMessageDelegate` for a Rule's target. This method is called by `~.find_handler` and can be extended to provide additional target types. :arg target: a Rule's target. :arg httputil.HTTPServerRequest request: current request. :arg target_params: additional parameters that can be useful for `~.httputil.HTTPMessageDelegate` creation. N) rA r r r � HTTPServerConnectionDelegater r. r- �callabler r )r rO r rP r r r rN J s �z RuleRouter.get_target_delegater ) r! r" r# r$ r, r; rH r rN r r r r r9 s r9 c s6 e Zd ZdZd � fdd� Z� fdd�Zdd� Z� ZS ) �ReversibleRuleRoutera A rule-based router that implements ``reverse_url`` method. Each rule added to this router may have a ``name`` attribute that can be used to reconstruct an original uri. The actual reconstruction takes place in a rule's matcher (see `Matcher.reverse`). Nc s i | _ tt| ��|� d S r )� named_rules�superrS r, r< �� __class__r r r, j s z ReversibleRuleRouter.__init__c s@ t t| ��|�}|jr |j| jv rt�d|j� || j|j< |S )Nz4Multiple handlers named %s; replacing previous value)rU rS rH r' rT r �warningrJ rV r r rH n s � z!ReversibleRuleRouter.process_rulec G s\ || j v r| j | jj|� S | jD ]}t|jt�r+|jj|g|�R � }|d ur+| S qd S r )rT rL �reverser: rA rO r& r) )r r' r( rI Z reversed_urlr r r r) z s �z ReversibleRuleRouter.reverse_urlr )r! r" r# r$ r, rH r) � __classcell__r r rV r rS b s rS c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) rE zA routing rule.Nc C s6 t |t�r t|�}|| _|| _|r|ni | _|| _dS )ad Constructs a Rule instance. :arg Matcher matcher: a `Matcher` instance used for determining whether the rule should be considered a match for a specific request. :arg target: a Rule's target (typically a ``RequestHandler`` or `~.httputil.HTTPServerConnectionDelegate` subclass or even a nested `Router`, depending on routing implementation). :arg dict target_kwargs: a dict of parameters that can be useful at the moment of target instantiation (for example, ``status_code`` for a ``RequestHandler`` subclass). They end up in ``target_params['target_kwargs']`` of `RuleRouter.get_target_delegate` method. :arg str name: the name of the rule that can be used to find it in `ReversibleRouter.reverse_url` implementation. N)rA �strr rL rO rK r' )r rL rO rK r' r r r r, � s z Rule.__init__c G s | j j|� S r )rL rY �r r( r r r rY � r z Rule.reversec C s d| j j| j| j| j| jf S �Nz %s(%r, %s, kwargs=%r, name=%r))rW r! rL rO rK r' r6 r r r �__repr__� s ��z Rule.__repr__�NN)r! r" r# r$ r, rY r^ r r r r rE � s rE c @ r )�Matcherz*Represents a matcher for request features.c C r )a1 Matches current instance against the request. :arg httputil.HTTPServerRequest request: current HTTP request :returns: a dict of parameters to be passed to the target handler (for example, ``handler_kwargs``, ``path_args``, ``path_kwargs`` can be passed for proper `~.web.RequestHandler` instantiation). An empty dict is a valid (and common) return value to indicate a match when the argument-passing features are not used. ``None`` must be returned to indicate that there is no match.r �r r r r r rM � s z Matcher.matchc G s dS )zEReconstructs full url from matcher instance and additional arguments.Nr r\ r r r rY � s zMatcher.reverseN)r! r" r# r$ rM rY r r r r r` � s r` c @ r% )� AnyMatcheszMatches any request.c C s i S r r ra r r r rM � s zAnyMatches.matchN)r! r" r# r$ rM r r r r rb � s rb c @ r )� HostMatchesz@Matches requests from hosts specified by ``host_pattern`` regex.c C s6 t |t�r|�d�s|d7 }t�|�| _d S || _d S )N�$)rA r �endswith�re�compile� host_pattern)r rh r r r r, � s zHostMatches.__init__c C s | j �|j�r i S d S r )rh rM Z host_namera r r r rM � s zHostMatches.matchN�r! r" r# r$ r, rM r r r r rc � s rc c @ r )�DefaultHostMatchesz�Matches requests from host that is equal to application's default_host. Always returns no match if ``X-Real-Ip`` header is present. c C s || _ || _d S r )� applicationrh )r rk rh r r r r, � s zDefaultHostMatches.__init__c C s" d|j vr| j�| jj�ri S d S )Nz X-Real-Ip)r0 rh rM rk Z default_hostra r r r rM � s zDefaultHostMatches.matchNri r r r r rj � s rj c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) rF z@Matches requests with paths specified by ``path_pattern`` regex.c C sl t |t�r|�d�s|d7 }t�|�| _n|| _t| jj�d| jjfv s,J d| jj ��| � � \| _ | _ d S )Nrd r zDgroups in url regexes must either be all named or all positional: %r) rA r re rf rg �regexrD � groupindex�groups�pattern� _find_groups�_path� _group_count)r � path_patternr r r r, � s ��zPathMatches.__init__c C sr | j �|j�}|d u r d S | j jsi S g i }}| j jr*tdd� |�� �� D ��}n dd� |�� D �}t||d�S )Nc s s$ � | ] \}}t |�t|�fV qd S r )r[ �_unquote_or_none)�.0�k�vr r r � <genexpr> s � � �z$PathMatches.match.<locals>.<genexpr>c S s g | ]}t |��qS r )rt )ru �sr r r � <listcomp> s z%PathMatches.match.<locals>.<listcomp>)� path_args� path_kwargs)rl rM �pathrn rm �dict� groupdict�items)r r rM r{ r| r r r rM � s � zPathMatches.matchc G s� | j d u r td| jj ��t|�| jksJ d��t|�s | j S g }|D ]}t|ttf�s0t |�}|� t t |�dd�� q#| j t |� S )NzCannot reverse url regex z&required number of arguments not foundF)�plus)rq � ValueErrorrl ro rD rr rA r �bytesr[ rG r r rB )r r( Zconverted_args�ar r r rY s zPathMatches.reversec C s� | j j}|�d�r|dd� }|�d�r|dd� }| j j|�d�kr%dS g }|�d�D ]=}d|v rI|�d�}|d krH|�d ||d d� � q,zt |�}W n t yc } zW Y d}~ dS d}~ww |�|� q,d � |�| j jfS ) z�Returns a tuple (reverse string, group count) for a url. For example: Given the url pattern /([0-9]{4})/([a-z-]+)/, this method would return ('/%s/%s/', 2). �^r@ Nrd ����(r_ �)r z%s� ) rl ro � startswithre rn �count�split�indexrG r r� �join)r ro �pieces�fragmentZ paren_locZunescaped_fragment�excr r r rp ! s, � �� zPathMatches._find_groupsN)r! r" r# r$ r, rM rY rp r r r r rF � s rF c s* e Zd ZdZd� fdd� Zdd� Z� ZS )�URLSpecz�Specifies mappings between URLs and handlers. .. versionchanged: 4.5 `URLSpec` is now a subclass of a `Rule` with `PathMatches` matcher and is preserved for backwards compatibility. Nc s6 t t| ��t|�|||� | jj| _| j| _|| _dS )a� Parameters: * ``pattern``: Regular expression to be matched. Any capturing groups in the regex will be passed in to the handler's get/post/etc methods as arguments (by keyword if named, by position if unnamed. Named and unnamed capturing groups may may not be mixed in the same rule). * ``handler``: `~.web.RequestHandler` subclass to be invoked. * ``kwargs`` (optional): A dictionary of additional arguments to be passed to the handler's constructor. * ``name`` (optional): A name for this handler. Used by `~.web.Application.reverse_url`. N) rU r� r, rF rL rl rO � handler_classr )r ro �handlerr r' rV r r r, K s zURLSpec.__init__c C s d| j j| jj| j| j| jf S r] )rW r! rl ro r� r r' r6 r r r r^ c s ��zURLSpec.__repr__r_ )r! r" r# r$ r, r^ rZ r r rV r r� D s r� c C s | du r| S t | ddd�S )z�None-safe wrapper around url_unescape to handle unmatched optional groups correctly. Note that args are passed as bytes so the handler can decide what encoding to use. NF)�encodingr� )r )ry r r r rt i s rt ))r$ Z __future__r r r rf � functoolsr Zsalt.ext.tornador Zsalt.ext.tornado.httpserverr Zsalt.ext.tornado.escaper r r Zsalt.ext.tornado.logr Zsalt.ext.tornado.utilr r r r �typing� ImportErrorrQ r r& ZHTTPMessageDelegater r9 rS �objectrE r` rb rc rj rF r� rt r r r r �<module> s8 % �`%'X %
Save