def main():
    template = """
        <!doctype html>
            <html>
                <head></head>
                <body>
                    <div> Etag: 
                        {% if etag %} 
                            {{ etag }} 
                        {% else %}
                            None?
                        {% endif %}
                    </div>
                </body>
            </html>"""

    # etag = request.if_none_match
    etag = request.headers.get('If-None-Match')
    # request.headers.get('If-Modified-Since')
    if etag:
        resp = Response(render_template_string(template, etag=etag))
        resp.status_code = 304
        resp.set_etag(etag)
        # resp.cache_control.public = True
        # resp.cache_control.max_age = 31536000 # 365 days
        resp.expires = time.strptime('Tue, 15 Nov 2020 12:45:26',
                                     "%a, %d %b %Y %H:%M:%S")
        resp.last_modified = time.strptime('Tue, 15 Nov 1994 12:45:26',
                                           "%a, %d %b %Y %H:%M:%S")

        for k, v in data.iteritems():
            if k == etag:
                browser = Browser(request, etag)
                data[etag] = browser.__dict__

    else:
        etag = hashlib.sha1(request.remote_addr).hexdigest()
        resp = Response(render_template_string(template, etag=etag))
        resp.status_code = 200
        resp.set_etag(etag)
        # resp.cache_control.public = True
        # resp.cache_control.max_age = 63072000
        resp.expires = time.strptime('Tue, 15 Nov 2020 12:45:26',
                                     "%a, %d %b %Y %H:%M:%S")
        resp.last_modified = time.strptime('Tue, 15 Nov 1994 12:45:26',
                                           "%a, %d %b %Y %H:%M:%S")

        browser = Browser(request)
        data[etag] = browser.__dict__

    with open('browsers.json', 'w') as browsers:
        json.dump(data, browsers, indent=4)
        browsers.close()

    return resp
示例#2
0
    def badge(title, value, ext='svg'):
        """Generate a badge response."""
        if ext == 'svg':
            generator = generate_badge_svg
            mimetype = 'image/svg+xml'
        elif ext == 'png':
            generator = generate_badge_png
            mimetype = 'image/png'

        badge_title_mapping = \
            current_app.config['FORMATTER_BADGES_TITLE_MAPPING'].get(
                title, title)
        response = Response(generator(badge_title_mapping, value),
                            mimetype=mimetype)
        # Generate Etag from badge title and value.
        hashable_badge = "{0}.{1}".format(badge_title_mapping,
                                          value).encode('utf-8')
        response.set_etag(hashlib.sha1(hashable_badge).hexdigest())
        # Add headers to prevent caching.
        response.headers["Pragma"] = "no-cache"
        response.cache_control.no_cache = True
        response.cache_control.max_age = \
            current_app.config['FORMATTER_BADGES_MAX_CACHE_AGE']
        response.last_modified = dt.utcnow()
        extra = timedelta(
            seconds=current_app.config['FORMATTER_BADGES_MAX_CACHE_AGE'])
        response.expires = response.last_modified + extra
        return response.make_conditional(request)
def prepare_response(resp: Response):
    last_modified = datetime.now()
    # (
    #     g.timestamp[:PYTHON_TIMESTAMP_LEN] + "Z",
    #     "%Y-%m-%dT%H:%M:%S.%fZ"
    # )

    resp.last_modified = last_modified
    resp.expires = datetime.now() + timedelta(minutes=1, seconds=30)
    resp.cache_control.max_age = 30
    resp.cache_control.public = True
    resp.cache_control.s_maxage = 90
    resp.cache_control.must_revalidate = True
    resp.headers['PHE-Server-Loc'] = SERVER_LOCATION

    try:
        minified = [
            minifier.get_minified(item.decode(), 'html')
            for item in resp.response
        ]
        data = str.join("", minified).encode()
        resp.set_data(data)
    except UnicodeDecodeError as e:
        app.logger.warning(e)

    # g.log_handler.flush()

    return resp
示例#4
0
    def __call__(self,
                 body=None,
                 header=None,
                 last_modified=None,
                 valid_seconds=15,
                 etag=None):
        rsp = None
        if body is None:
            rsp = Response(json.dumps(self.m),
                           self.c,
                           header,
                           mimetype="application/json")
        else:
            rsp = Response(json.dumps(body),
                           self.c,
                           header,
                           mimetype="application/json")

        if last_modified is not None:
            then = datetime.utcnow() + timedelta(seconds=valid_seconds)
            rsp.expires = then
            rsp.last_modified = last_modified

        if etag is not None:
            rsp.set_etag(etag, False)

        return rsp
示例#5
0
def response_font_zip_from_cache(request_font_path):
    if not request.args.get('hash'):
        raise ValueError()

    if request.if_modified_since:
        if_modified_since = \
            request.if_modified_since.replace(tzinfo=timezone.utc).timestamp()

    if (request.if_modified_since and
            int(app.config['server_updated_date']) <= int(if_modified_since)):
        response = Response()
        response.status_code = 304
    else:
        font_file_path = \
            japont.search_font_path(request_font_path, app.config['font_list'])
        hash_key = '{}_{}'.format(font_file_path,
                                  request.args.get('hash').lower())
        if not cache.has(hash_key):
            raise IOError()

        response = send_file(BytesIO(cache.get(hash_key)),
                             mimetype='application/zip',
                             as_attachment=True,
                             attachment_filename='font.zip')

    response.cache_control.must_revalidate = True
    response.cache_control.no_cache = True
    response.cache_control.max_age = 0
    response.expires = time()
    response.last_modified = app.config['server_updated_date']

    return response
示例#6
0
def api_badge():
    CHARWIDTH = 7

    try:
        room_jid = request.args["address"]
    except KeyError:
        return abort(400, "missing address argument")

    room_info = db.session.query(
        model.MUC,
        model.PubliclyListedMUC,
    ).join(model.PubliclyListedMUC, ).filter(
        model.MUC.address == room_jid, ).one_or_none()

    if room_info is None or room_info[1] is None:
        return abort(404, "no such room")

    muc, public_info = room_info

    # check if the room may have changed since the last request
    last_update = None
    if muc.last_seen is not None:
        last_update = muc.last_seen
    if muc.moving_average_last_update is not None:
        if last_update is None:
            last_update = muc.moving_average_last_update
        else:
            last_update = min(muc.moving_average_last_update, last_update)

    # round up to the next second; this is not perfect, but good enough.
    last_update = last_update.replace(microsecond=0) + timedelta(seconds=1)

    if (request.if_modified_since is not None
            and last_update <= request.if_modified_since):
        return "", 304

    label = " {} ".format(public_info.name or muc.address)
    nusers = " {:.0f} ".format(muc.nusers_moving_average)

    labelwidth = len(label) * CHARWIDTH
    countwidth = len(nusers) * CHARWIDTH
    width = labelwidth + countwidth

    rendered = render_template(
        "badge.svg",
        width=width,
        label=label,
        labelwidth=labelwidth,
        number=nusers,
        countwidth=countwidth,
    )

    response = Response(rendered, mimetype="image/svg+xml")
    response.last_modified = last_update
    if last_update is not None:
        response.expires = last_update + CACHE_BADGE_TTL
    response.headers["Content-Security-Policy"] = \
        "frame-ancestors 'none'; default-src 'none'; style-src 'unsafe-inline'"
    return response
示例#7
0
def get_badge():
    projects, job_names = get_args(request.args)
    if (not projects and not job_names) or not projects:
        return Response("Invaild Request")
    url = genarate_zuul_url(projects, job_names)
    success = check_the_result(url, projects, job_names)
    response = Response(RESP_TYPE[success], mimetype='image/svg+xml')
    response.cache_control.no_cache = True
    response.cache_control.no_store = True
    response.cache_control.private = True
    response.cache_control.max_age = 0
    response.expires = datetime.datetime(1984, 1, 1)
    response.headers['X-Content-Type-Options'] = 'nosniff'
    response.add_etag()
    return response
示例#8
0
def __send_file(musicFile, cachetimout, stream=True):
    headers = Headers()
    headers.add('Content-Disposition',
                'attachment',
                filename=musicFile.filename)
    headers.add('Content-Transfer-Encoding', 'binary')

    status = 200
    size = getsize(musicFile.path)
    begin = 0
    end = size - 1

    if request.headers.has_key("Range") and rangerequest:
        status = 206
        headers.add('Accept-Ranges', 'bytes')
        ranges = findall(r"\d+", request.headers["Range"])
        begin = int(ranges[0])
        if len(ranges) > 1:
            end = int(ranges[1])
        headers.add(
            'Content-Range',
            'bytes %s-%s/%s' % (str(begin), str(end), str(end - begin)))

    headers.add('Content-Length', str((end - begin) + 1))

    #Add mimetype
    mimetypes = {u"mp3": "audio/mpeg", u"ogg": "audio/ogg"}
    if stream == True:
        mimetype = mimetypes[musicFile.filetype]
    else:
        mimetype = "application/octet-stream"

    response = Response(file(musicFile.path),
                        status=status,
                        mimetype=mimetype,
                        headers=headers,
                        direct_passthrough=True)

    #enable browser file caching with etags
    response.cache_control.public = True
    response.cache_control.max_age = int(cachetimout)
    response.last_modified = int(musicFile.changetime)
    response.expires = int(time() + int(cachetimout))
    response.set_etag('%s%s' % (musicFile.id, musicFile.changetime))
    response.make_conditional(request)

    return response
示例#9
0
def avatar_v1(address):
    try:
        address = aioxmpp.JID.fromstr(address)
    except (ValueError, TypeError):
        return abort(400, "bad address")

    metadata = db.session.query(
        model.Avatar.hash_,
        model.Avatar.last_updated,
        model.Avatar.mime_type,
    ).filter(model.Avatar.address == address, ).one_or_none()

    if metadata is None:
        return abort(404, "no avatar stored")

    hash_, last_updated, mime_type = metadata

    response = Response(mimetype=mime_type)
    response.status_code = 500
    response.add_etag(hash_)
    response.last_modified = last_updated
    response.expires = datetime.utcnow() + CACHE_AVATAR_TTL
    response.headers["Content-Security-Policy"] = \
        "frame-ancestors 'none'; default-src 'none'; style-src 'unsafe-inline'"

    if (request.if_none_match.contains(hash_)
            or (request.if_modified_since is not None
                and last_updated <= request.if_modified_since)):
        response.status_code = 304
        return response

    if request.method == "HEAD":
        # do not fetch the data, only its size
        length, = db.session.query(sqlalchemy.func.length(
            model.Avatar.data), ).filter(
                model.Avatar.address == address).one()
        response.status_code = 200
        response.content_length = length
        return response

    data, = db.session.query(
        model.Avatar.data, ).filter(model.Avatar.address == address).one()

    response.data = data
    response.status_code = 200
    return response
示例#10
0
文件: views.py 项目: Answeror/aip
    def js():
        names = [
            'head.js',
            'ut.js',
            'notice.js',
            'redo.js',
            'stream.js',
            'super_resolution.js',
            'load_image.js',
            'plus.js',
            'detail.js',
            'tag.js',
            'thumbnail.js',
            'fade.js',
            'base.js',
        ]

        def gen():
            for name in names:
                yield datetime.fromtimestamp(os.path.getmtime(os.path.join(
                    current_app.root_path,
                    current_app.template_folder,
                    name
                )))
        mtime = max(gen())

        if has_timestamp() and not expired_request(mtime):
            return Response(status=304)

        content = '\n'.join(render_template(name) for name in names)
        resp = Response(
            content,
            mimetype='text/javascript',
        )
        resp.content_md5 = calcmd5(content.encode('utf-8'))
        resp.last_modified = mtime

        if has_timestamp():
            if cache_timeout() is not None:
                resp.cache_control.max_age = cache_timeout()
                resp.expires = int(time() + cache_timeout())

        return resp
示例#11
0
def __send_file( musicFile , cachetimout, stream=True):
    headers = Headers()
    headers.add('Content-Disposition', 
'attachment',filename=musicFile.filename)
    headers.add('Content-Transfer-Encoding','binary')

    status = 200
    size = getsize(musicFile.path)
    begin=0;
    end=size-1;

    if request.headers.has_key("Range") and rangerequest:
        status = 206
        headers.add('Accept-Ranges','bytes')
        ranges=findall(r"\d+", request.headers["Range"])
        begin = int( ranges[0] )
        if len(ranges)>1:
            end=int( ranges[1] )
        headers.add('Content-Range','bytes %s-%s/%s' % 
(str(begin),str(end),str(end-begin)) )
    
    headers.add('Content-Length',str((end-begin)+1))
    
    #Add mimetype    
    mimetypes = {u"mp3":"audio/mpeg",u"ogg":"audio/ogg"}
    if stream==True:
        mimetype = mimetypes[musicFile.filetype]
    else:
        mimetype = "application/octet-stream"
    
    response = Response( file(musicFile.path), status=status, 
mimetype=mimetype, headers=headers, direct_passthrough=True)
    
    #enable browser file caching with etags
    response.cache_control.public = True
    response.cache_control.max_age = int(cachetimout)
    response.last_modified = int(musicFile.changetime)
    response.expires=int( time() + int(cachetimout) )
    response.set_etag('%s%s' % ( musicFile.id,musicFile.changetime ))
    response.make_conditional(request)
    
    return response
示例#12
0
文件: views.py 项目: Answeror/aip
    def style():
        root = os.path.join(app.static_folder, 'scss')
        sources = scss_sources(root)

        def gen():
            for filename, _ in sources:
                yield datetime.fromtimestamp(os.path.getmtime(os.path.join(
                    root,
                    filename
                )))
        mtime = max(gen())

        if has_timestamp() and not expired_request(mtime):
            return Response(status=304)

        c = scss.Scss(
            scss_vars={},
            scss_opts={
                'compress': True,
                'debug_info': True,
                'load_paths': [root]
            }
        )
        c._scss_files = OrderedDict(sources)
        content = c.compile()
        resp = Response(
            content,
            mimetype='text/css',
        )
        resp.content_md5 = calcmd5(content.encode('utf-8'))
        resp.last_modified = mtime

        if has_timestamp():
            if cache_timeout() is not None:
                resp.cache_control.max_age = cache_timeout()
                resp.expires = int(time() + cache_timeout())

        return resp
示例#13
0
文件: views.py 项目: Answeror/aip
    def thumbnail(md5):
        try:
            if (
                has_timestamp() and
                not expired_request(core.thumbnail_mtime_bi_md5(md5))
            ):
                return Response(status=304)
        except:
            pass

        width = int(request.args['width'])
        content = core.thumbnail_bi_md5(md5, width)
        resp = Response(content, mimetype='image/' + img.kind(data=content))
        resp.content_md5 = calcmd5(content)
        resp.last_modified = core.thumbnail_mtime_bi_md5(md5)

        if has_timestamp():
            cache_timeout = core.thumbnail_cache_timeout_bi_md5(md5)
            if cache_timeout is not None:
                resp.cache_control.max_age = cache_timeout
                resp.expires = int(time() + cache_timeout)

        return resp