Python Response.write方法代码示例

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def application(req):
    #doGzip = 0
    #try:
    #    if string.find(os.environ["HTTP_ACCEPT_ENCODING"], "gzip") != -1:
    #        doGzip = 1
    #except:
    #    pass

    treeid = req.params.get("treeid")
    module = req.params.get("module")
    branch = req.params.get("branch")
    mindate = req.params.get("mindate")
    maxdate = req.params.get("maxdate")
    xml_nofiles = req.params.get("xml_nofiles")

    if not treeid or not module or not branch or not mindate or not maxdate:
        raise exc.HTTPBadRequest("ERROR")

    url = bonsai + "?" + "branchtype=match&sortby=Date&date=explicit&cvsroot=%2Fcvsroot&xml=1"
    url += "&treeid=%s&module=%s&branch=%s&mindate=%s&maxdate=%s" % (quote(treeid), quote(module), quote(branch), quote(mindate), quote(maxdate))

    if xml_nofiles:
        url += "&xml_nofiles=1"

    urlstream = urllib.urlopen(url)
    resp = Response(content_type='text/xml')
    for s in urlstream:
        resp.write(s)
    urlstream.close()
    return resp

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def dispatch_wsgi(self, environ, start_response):
        """
        Dispatches a WSGI request.

        :param environ: WSGI request environment.
        :param start_response: WSGI response callback
        :returns: A valid WSGI response content.
        """
        req = Request(environ)
        req.response = Response()

        try:
            resp = self.dispatch_request(req)
        except HTTPException as e:
            resp = e

        if inspect.isgenerator(resp):
            resp = Response(app_iter=resp)
        elif resp is None:
            resp = req.response
        if isinstance(resp, text_type):
            resp = bytes_(resp, req.charset)
        if isinstance(resp, bytes):
            body = resp
            resp = req.response
            resp.write(body)
        if resp is not req.response:
            resp = req.response.merge_cookies(resp)
        return resp(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def skin_response(environ, start_response):
    if environ['PATH_INFO'].endswith('.gif'):        
        response = Response(content_type='image/gif')
    elif environ['PATH_INFO'].endswith('.css'):        
        response = Response(content_type='text/css')
    with open(os.path.join(dir, 'resources', 'jquery.dynatree', 
                           environ['PATH_INFO'].strip('/'))) as item:
        response.write(item.read())
    return response(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def app(environ, start_response):
    req = Request(environ)
    res = Response(charset='utf-8', last_modified=last_modified())

    if req.if_modified_since and req.if_modified_since >= last_modified():
        res.status = 304
        return res(environ, start_response)

    if req.method == 'HEAD':
        return res(environ, start_response)
    tmpl = template()
    res.write(tmpl.render(data=data(), req=req))
    return res(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def POST(self, request, start_response):
        json = simplejson.loads(request.body)
        res = Response()
        urls = []

        if json:
            urls.extend(self.add(json, request))
        else:
            res.status = 400
            return res

        if len(urls) == 1:
            res.headers['Location'] = urls[0]
            res.write(urls.pop())
        else:
            for url in urls:
                res.write(url)
        return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def service_rpc(self, request):
        if not self.with_rpc:
            raise Forbidden()

        response = Response()
        response.status = 200
        response.content_type = "application/x-git-%s-result" % request.rpc

        command = self.git_command("%s --stateless-rpc %s" % (request.rpc, request.dir))

        with Popen(command, stdin=PIPE, stdout=PIPE) as pipe:
            pipe.stdin.write(request.body)
            while True:
                data = pipe.stdout.read(8192)
                if not data:
                    break
                response.write(data)

        return response

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def application(req):
    resp = Response(content_type='text/plain')

    # incoming query string has the following parameters:
    # user=name
    #  (REQUIRED) user that made this annotation
    # tbox=foopy
    #  (REQUIRED) name of the tinderbox to annotate
    # data=string
    #  annotation to record
    # time=seconds
    #  time since the epoch in GMT of this test result; if ommitted, current time at time of script run is used

    tbox = req.params.get("tbox")
    user = req.params.get("user")
    data = req.params.get("data")
    timeval = req.params.get("time")
    if timeval is None:
        timeval = int(time.time())

    if user is None or tbox is None or data is None:
        raise exc.HTTPBadRequest("Bad args")

    if re.match(r"[^A-Za-z0-9]", tbox):
        raise exc.HTTPBadRequest("Bad tbox name")

    db = sqlite.connect("db/" + tbox + ".sqlite")

    try:
        db.execute("CREATE TABLE test_results (test_name STRING, test_time INTEGER, test_value FLOAT, test_data BLOB);")
        db.execute("CREATE TABLE annotations (anno_user STRING, anno_time INTEGER, anno_string STRING);")
        db.execute("CREATE INDEX test_name_idx ON test_results.test_name")
        db.execute("CREATE INDEX test_time_idx ON test_results.test_time")
        db.execute("CREATE INDEX anno_time_idx ON annotations.anno_time")
    except:
        pass

    db.execute("INSERT INTO annotations VALUES (?,?,?)", (user, timeval, data))

    db.commit()

    resp.write("Inserted.")

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
 def exec_input(self, req):
     input = req.params.get("input")
     if not input.strip():
         return ""
     input = input.rstrip() + "\n"
     frame = req.debug_info.frame(int(req.params["tbid"]))
     vars = frame.tb_frame.f_locals
     glob_vars = frame.tb_frame.f_globals
     context = evalcontext.EvalContext(vars, glob_vars)
     registry.restorer.restoration_begin(req.debug_info.counter)
     try:
         output = context.exec_expr(input)
     finally:
         registry.restorer.restoration_end()
     input_html = formatter.str2html(input)
     res = Response(content_type="text/html")
     res.write(
         '<code style="color: #060">&gt;&gt;&gt;</code> '
         "%s<br>\n%s" % (preserve_whitespace(input_html, quote=False), preserve_whitespace(output))
     )
     return res

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
 def internal(self, req):
     if (self.require_devauth
         and not req.environ.get('x-wsgiorg.developer_user')):
         raise exc.HTTPForbidden('You must login')
     if req.method == 'POST':
         if req.params.get('clear'):
             name = self.file.name
             self.file.close()
             self.file = open(name, 'wb')
         else:
             false_req = Request.blank('/')
             false_resp = Response('', status='200 Internal Note')
             false_resp.write(req.params['note'])
             self.write_record(false_req, false_resp)
         raise exc.HTTPFound(req.url)
     if req.params.get('download'):
         if req.params['download'] == 'doctest':
             text = self.doctest(req)
         else:
             text = self.function_unittest(req)
         return Response(text, content_type='text/plain')
     return Response(self._intercept_template.substitute(req=req, s=self))

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def handleRequest(req, databaseConnection, databaseModule=None, outputStream=sys.stdout):
    if not databaseModule:
        databaseModule = sys.modules[databaseConnection.__module__.split('.')[0]]

    resp = Response(content_type='text/plain')

    try:
        if "filename" not in req.POST:
            raise ImproperFormatException("Cannot find input stream")

        inputStream = req.POST["filename"].file
        startLine = inputStream.readline().strip()
        #responseList.append('line 1: "%s"' % startLine)
        if startLine.upper() not in 'START':
            raise ImproperFormatException("input stream did not begin with 'START'")
        dataSetType = inputStream.readline().strip().upper()
        #responseList.append('line 2: "%s"' % dataSetType)
        if dataSetType == 'AMO':
            from pyfomatic.collect_amo import parse_amo_collection, ParseError
            try:
                parse_amo_collection(inputStream)
            except ParseError, e:
                return Response(content_type='text/plain', body=str(e),
                                status='400 Bad Request')
            return Response(content_type='text/plain', body='Return\tsuccess')

        if dataSetType not in ('VALUES', 'AVERAGE'):
            raise ImproperFormatException("data set type was not 'VALUES' or 'AVERAGE'")

        databaseCursor = databaseConnection.cursor()

        metadata = MetaDataFromTalos(databaseCursor, databaseModule, inputStream)
        if dataSetType == 'VALUES':
            average = valuesReader(databaseCursor, databaseModule, inputStream, metadata)
            resp.write("""RETURN\t%s\tgraph.html#type=series&tests=[{"test":%d,"branch":%d,"machine":%d,"testrun":%d}]\n""" % (metadata.test_name, metadata.test_id, metadata.branch_id, metadata.machine_id, metadata.test_run_id))
        else:
            average = averageReader(databaseCursor, databaseModule, inputStream, metadata)
        resp.write("""RETURN\t%s\t%.2f\tgraph.html#tests=[{"test":%d,"branch":%d,"machine":%d}]\n""" % (metadata.test_name, average, metadata.test_id, metadata.branch_id, metadata.machine_id))

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def take_over(self, req):
        """Attached to ``POST /take-over``

        Takes over databases from another server, that presumably has
        gone offline without notice.

        This goes through all of the local databases, and sees if this
        node was either using the bad node as a backup, or is a backup
        for the bad node.  In either case it finds the new node that
        should be either master or handling the bad node, and sends
        the local database to that server.

        Takes a JSON body with keys:

        `other`: a list of all nodes
        `name`: the name of *this* node
        `bad`: the bad node being removed
        `backups`: the number of backups
        """
        self.assert_is_internal(req)
        status = Response(content_type='text/plain')
        data = req.json
        nodes = data['other']
        self_name = data['name']
        bad_node = data['bad']
        assert self_name != bad_node
        backups = data['backups']
        ring = HashRing(nodes)
        for domain, username, bucket in self.storage.all_dbs():
            assert bucket.startswith('/')
            path = '/' + domain + '/' + username + bucket
            iterator = iter(ring.iterate_nodes(path))
            active_nodes = [iterator.next() for i in xrange(backups + 1)]
            replacement_node = iterator.next()
            # Not all the backups should try to restore the database, so instead
            # just the "first" does it
            restore = False
            if active_nodes[0] == bad_node and active_nodes[1:] and active_nodes[1] == self_name:
                status.write('Master node %s for %s removed\n' % (bad_node, path))
                restore = True
            elif bad_node in active_nodes and active_nodes[0] == self_name:
                status.write('Backup node %s for %s removed\n' % (bad_node, path))
                restore = True
            if not restore:
                continue
            db = self.storage.for_user(domain, username, bucket)
            send = Request.blank(replacement_node + urllib.quote(path) + '?paste',
                                 method='POST', body=''.join(db.encode_db()))
            send.environ['cutout.root'] = req.environ.get('cutout.root')
            resp = forward(send)
            assert resp.status_code == 201, str(resp)
            #status.write('  nodes: %r - %r / %r\n' % (active_nodes, bad_node, self_name))
            status.write('  success, added to %s (from %s)\n' % (replacement_node, self_name))
        return status

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def remove_self(self, req):
        """Responds to ``POST /remove-self``

        This is a request for this node to gracefully remove itself.
        It will attempt to back up its data to the other nodes that
        should take over.

        This takes a request with the JSON data:

        `name`: the name of this node
        `other`: a list of all nodes (including this)
        `backups`: the number of backups to make

        It responds with a text description of what it did.
        """
        self.assert_is_internal(req)
        status = Response(content_type='text/plain')
        self.storage.disable()
        data = req.json
        self_name = data['name']
        status.write('Disabling node %s\n' % self_name)
        ring = HashRing(data['other'])
        for domain, username, bucket in self.storage.all_dbs():
            assert bucket.startswith('/')
            path = '/' + domain + '/' + username + bucket
            db = self.storage.for_user(domain, username, bucket)
            if db.is_deprecated:
                db.clear()
                continue
            iterator = iter(ring.iterate_nodes(path))
            active_nodes = [iterator.next() for i in xrange(data['backups'] + 1)]
            new_node = iterator.next()
            assert self_name in active_nodes, '%r not in %r' % (self_name, active_nodes)
            status.write('Sending %s to node %s\n' % (path, new_node))
            url = urlparse.urljoin(req.application_url, '/' + new_node)
            send = Request.blank(url + urllib.quote(path) + '?paste',
                                 method='POST', body=''.join(db.encode_db()))
            send.environ['cutout.root'] = req.environ.get('cutout.root')
            resp = forward(send)
            assert resp.status_code == 201, str(resp)
            status.write('  success, deleting\n')
            db.clear()
        self.storage.clear()
        return status

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def application(environ, start_response):
    request = Request(environ)
    response = Response()
    response.write('<html><body><h1>YAFOWIL Demo</h1>')
    form = factory(u'form', name='helloworld', props={
        'action': url})
    form['hello'] = factory('field:label:error:text', props={
        'label': 'Enter some text',
        'value': '',
        'required': True})
    form['submit'] = factory('field:submit', props={        
        'label': 'store value',
        'action': 'save',
        'handler': store,
        'next': next})
    controller = Controller(form, request)
    response.write(controller.rendered)
    response.write('<hr />%s</html></body>' % '<br />'.join(readall()))
    return response(environ, start_response)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
    def get_info_refs(self, request):

        service_name = self.get_service_type(request)
        if self.has_access(service_name):
            cmd = git_command("%s --stateless-rpc --advertise-refs ." % service_name)
            refs = Popen(cmd, stdout=PIPE, shell=True)
            refs = refs.stdout.read()

            response = Response()
            response.status = 200
            response.content_type = "application/x-git-%s-advertisement" % service_name
            self.hdr_nocache(response)

            response.write(pkt_write("# service=git-#{service_name}\n"))
            response.write(pkt_flush)
            response.write(refs)

            return response
        else:
            return self.dumb_info_refs(request)

# 需要导入模块: from webob import Response [as 别名]
# 或者: from webob.Response import write [as 别名]
def javascript_response2(environ, start_response):
    response = Response(content_type='text/javascript')
    with open(os.path.join(dir, 'resources', 'jquery.dynatree', 
                           'jquery.dynatree.js')) as js:
        response.write(js.read())
    return response(environ, start_response)