Python producers.simple_producer函数代码示例

 def status(self):
     # Thanks to [email protected] (Mike Meyer)
     r = [
         producers.simple_producer(
             "<li>Authorization Extension : " "<b>Unauthorized requests:</b> %s<ul>" % self.fail_count
         )
     ]
     if hasattr(self.handler, "status"):
         r.append(self.handler.status())
     r.append(producers.simple_producer("</ul>"))
     return producers.composite_producer(r)

    def status (self):
        from supervisor.medusa.status_handler import english_bytes
        def nice_bytes (n):
            return ''.join(english_bytes (n))

        handler_stats = [_f for _f in map (maybe_status, self.handlers) if _f]

        if self.total_clients:
            ratio = self.total_requests.as_long() / float(self.total_clients.as_long())
        else:
            ratio = 0.0

        return producers.composite_producer (
                [producers.lines_producer (
                        ['<h2>%s</h2>'                                                  % self.SERVER_IDENT,
                        '<br>Listening on: <b>Host:</b> %s'             % self.server_name,
                        '<b>Port:</b> %d'                                               % self.port,
                         '<p><ul>'
                         '<li>Total <b>Clients:</b> %s'                 % self.total_clients,
                         '<b>Requests:</b> %s'                                  % self.total_requests,
                         '<b>Requests/Client:</b> %.1f'                 % ratio,
                         '<li>Total <b>Bytes In:</b> %s'        % (nice_bytes (self.bytes_in.as_long())),
                         '<b>Bytes Out:</b> %s'                         % (nice_bytes (self.bytes_out.as_long())),
                         '<li>Total <b>Exceptions:</b> %s'              % self.exceptions,
                         '</ul><p>'
                         '<b>Extension List</b><ul>',
                         ])] + handler_stats + [producers.simple_producer('</ul>')]
                )

 def status (self):
     import supervisor.medusa.producers as producers
     return producers.simple_producer (
             '<li> Redirecting Handler %s => %s <b>Hits</b>: %s' % (
                     self.pattern, self.redirect, self.hits
                     )
             )

    def getresponse(self, body):
        self.request["Content-Type"] = "text/xml"
        self.request["Content-Length"] = len(body)
        self.request.push(body)
        connection = get_header(self.CONNECTION, self.request.header)

        close_it = 0
        wrap_in_chunking = 0

        if self.request.version == "1.0":
            if connection == "keep-alive":
                if not self.request.has_key("Content-Length"):
                    close_it = 1
                else:
                    self.request["Connection"] = "Keep-Alive"
            else:
                close_it = 1
        elif self.request.version == "1.1":
            if connection == "close":
                close_it = 1
            elif not self.request.has_key("Content-Length"):
                if self.request.has_key("Transfer-Encoding"):
                    if not self.request["Transfer-Encoding"] == "chunked":
                        close_it = 1
                elif self.request.use_chunked:
                    self.request["Transfer-Encoding"] = "chunked"
                    wrap_in_chunking = 1
                else:
                    close_it = 1
        elif self.request.version is None:
            close_it = 1

        outgoing_header = producers.simple_producer(self.request.build_reply_header())

        if close_it:
            self.request["Connection"] = "close"

        if wrap_in_chunking:
            outgoing_producer = producers.chunked_producer(producers.composite_producer(self.request.outgoing))
            # prepend the header
            outgoing_producer = producers.composite_producer([outgoing_header, outgoing_producer])
        else:
            # prepend the header
            self.request.outgoing.insert(0, outgoing_header)
            outgoing_producer = producers.composite_producer(self.request.outgoing)

        # apply a few final transformations to the output
        self.request.channel.push_with_producer(
            # globbing gives us large packets
            producers.globbing_producer(
                # hooking lets us log the number of bytes sent
                producers.hooked_producer(outgoing_producer, self.request.log)
            )
        )

        self.request.channel.current_request = None

        if close_it:
            self.request.channel.close_when_done()

 def push (self, thing):
     # Sometimes, text gets pushed by XMLRPC logic for later
     # processing.
     if isinstance(thing, str):
         thing = as_bytes(thing)
     if isinstance(thing, bytes):
         thing = producers.simple_producer(thing, buffer_size=len(thing))
     self.outgoing.append(thing)

 def status (self):
     return producers.simple_producer (
             '<h2>%s</h2>'                                           % self.SERVER_IDENT
             + '<br><b>Total Sessions:</b> %s'               % self.total_sessions
             + '<br><b>Current Sessions:</b> %d'     % (
                     self.total_sessions.as_long()-self.closed_sessions.as_long()
                     )
             )

 def status (self):
     return producers.simple_producer (
             '<li>Server-Side Script Handler'
             + '<ul>'
             + '  <li><b>Hits:</b> %s' % self.hits
             + '  <li><b>Exceptions:</b> %s' % self.exceptions
             + '</ul>'
             )

 def status (self):
     return producers.simple_producer (
             '<li>%s' % status_handler.html_repr (self)
             + '<ul>'
             + '  <li><b>Total Hits:</b> %s'                 % self.hit_counter
             + '  <li><b>Files Delivered:</b> %s'    % self.file_counter
             + '  <li><b>Cache Hits:</b> %s'                 % self.cache_counter
             + '</ul>'
             )

 def status (self):
     import supervisor.medusa.producers as producers
     return producers.simple_producer (
             '<h2>%s</h2>'                                   % self.SERVER_IDENT
             + '<br>Server: %s'                              % self.server
             + '<br>Cache Entries: %d'               % len(self.cache)
             + '<br>Outstanding Requests: %d' % len(self.request_map)
             + '<br>Forward Requests: %s'    % self.forward_requests
             + '<br>Reverse Requests: %s'    % self.reverse_requests
             + '<br>Cache Hits: %s'                  % self.cache_hits
             )

    def check_chunked (self):
        p1 = producers.simple_producer('the quick brown fox', buffer_size = 5)
        p = producers.chunked_producer(p1, footers=['FOOTER'])
        self._check_all(p, """5\r
the q\r
5\r
uick \r
5\r
brown\r
4\r
 fox\r
0\r
FOOTER\r
\r\n""")

    def getresponse(self, body):
        self.request['Content-Type'] = 'text/xml'
        self.request['Content-Length'] = len(body)
        self.request.push(body)
        connection = get_header(self.CONNECTION, self.request.header)

        close_it = 0

        if self.request.version == '1.0':
            if connection == 'keep-alive':
                self.request['Connection'] = 'Keep-Alive'
            else:
                close_it = 1
        elif self.request.version == '1.1':
            if connection == 'close':
                close_it = 1
        elif self.request.version is None:
            close_it = 1

        outgoing_header = producers.simple_producer (
            self.request.build_reply_header())

        if close_it:
            self.request['Connection'] = 'close'

        # prepend the header
        self.request.outgoing.insert(0, outgoing_header)
        outgoing_producer = producers.composite_producer(self.request.outgoing)

        # apply a few final transformations to the output
        self.request.channel.push_with_producer (
                # globbing gives us large packets
                producers.globbing_producer (
                        # hooking lets us log the number of bytes sent
                        producers.hooked_producer (
                                outgoing_producer,
                                self.request.log
                                )
                        )
                )

        self.request.channel.current_request = None

        if close_it:
            self.request.channel.close_when_done()

 def check_hooked (self):
     def f (num_bytes):
         self.test_val('num_bytes', len(test_string))
     p1 = producers.simple_producer(test_string, buffer_size = 5)
     p = producers.hooked_producer(p1, f)
     self._check_all(p, test_string)

 def check_glob (self):
     p1 = producers.simple_producer(test_string, buffer_size = 5)
     p = producers.globbing_producer(p1, buffer_size = 1024)
     self.test_true('1024 <= len(p.more())')

 def check_composite (self):
     p1 = producers.simple_producer('a'*66, buffer_size = 5)
     p2 = producers.lines_producer(['b']*65)
     p = producers.composite_producer([p1, p2])
     self._check_all(p, 'a'*66 + 'b\r\n'*65)

    def done (self):
        """finalize this transaction - send output to the http channel"""

        # ----------------------------------------
        # persistent connection management
        # ----------------------------------------

        #  --- BUCKLE UP! ----

        connection = get_header(CONNECTION, self.header).lower()

        close_it = 0
        wrap_in_chunking = 0

        if self.version == '1.0':
            if connection == 'keep-alive':
                if 'Content-Length' not in self:
                    close_it = 1
                else:
                    self['Connection'] = 'Keep-Alive'
            else:
                close_it = 1
        elif self.version == '1.1':
            if connection == 'close':
                close_it = 1
            elif 'Content-Length' not in self:
                if 'Transfer-Encoding' in self:
                    if not self['Transfer-Encoding'] == 'chunked':
                        close_it = 1
                elif self.use_chunked:
                    self['Transfer-Encoding'] = 'chunked'
                    wrap_in_chunking = 1
                else:
                    close_it = 1
        elif self.version is None:
            # Although we don't *really* support http/0.9 (because we'd have to
            # use \r\n as a terminator, and it would just yuck up a lot of stuff)
            # it's very common for developers to not want to type a version number
            # when using telnet to debug a server.
            close_it = 1

        outgoing_header = producers.simple_producer(self.get_reply_header_text())

        if close_it:
            self['Connection'] = 'close'

        if wrap_in_chunking:
            outgoing_producer = producers.chunked_producer (
                    producers.composite_producer (self.outgoing)
                    )
            # prepend the header
            outgoing_producer = producers.composite_producer(
                [outgoing_header, outgoing_producer]
                )
        else:
            # prepend the header
            self.outgoing.insert(0, outgoing_header)
            outgoing_producer = producers.composite_producer (self.outgoing)

        # apply a few final transformations to the output
        self.channel.push_with_producer (
                # globbing gives us large packets
                producers.globbing_producer (
                        # hooking lets us log the number of bytes sent
                        producers.hooked_producer (
                                outgoing_producer,
                                self.log
                                )
                        )
                )

        self.channel.current_request = None

        if close_it:
            self.channel.close_when_done()