def __init__(self, *args, **kwds): unittest.TestCase.__init__(self, *args, **kwds) self._cookie_jar = CookieJar() app = self.get_app() validator(app) self._port = random.randint(50000, 60000) self._httpd = make_server('', self._port, app) self._serve_thread = threading.Thread(target=self._httpd.serve_forever) self._serve_thread.setDaemon(True) self._opener = build_opener(NoRedirectionProcessor, HTTPCookieProcessor(self._cookie_jar))
def main(): """Run the show""" #Arguments parser parser = argparse.ArgumentParser(description="Stream live TV over HTTP to multiple viewers, using Sundtek as capture card") parser.add_argument("-p","--port",type=int,default=2000,help="server port") parser.add_argument("-c", "--channel",type=str,default=0,help="set channel") parser.add_argument("-D", "--dtvmode",type=str,choices=["DVBT", "DVBC", "ATSC","ISDBT"],default="ISDBT",help="set digital TV mode for device") args=parser.parse_args() #Setting dtv mode using mediaclient if dtvmode(args.dtvmode): server = Server() #Select channel channel = select_channel(server.channels,int(args.channel)) print("Channel selected:"+channel) server.set_channel(channel) feed_thread = threading.Thread(target=server.feeder) feed_thread.daemon = True feed_thread.start() validator_app = validator(server.simple_app) httpd = make_server('', args.port, validator_app,server_class=ThreadedWSGIServer) try: print("URL: http://%s:%s/stream" % (LOCAL_IP,args.port)) httpd.serve_forever() finally: server.cur_chan = None feed_thread.join() else: print("Error setting the dtv mode")
def test_cookie_parse(self): STR = 'some_string' class RequestHeader(ComplexModel): some_field = String class SomeService(ServiceBase): __in_header__ = RequestHeader @rpc(String) def some_call(ctx, s): assert ctx.in_header.some_field == STR def start_response(code, headers): assert code == HTTP_200 c = SimpleCookie() c['some_field'] = STR ''.join(validator(WsgiApplication(Application([SomeService], 'tns', in_protocol=HttpRpc(parse_cookie=True), out_protocol=HttpRpc())))({ 'SCRIPT_NAME': '', 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'localhost', 'SERVER_PORT': "9999", 'HTTP_COOKIE': str(c), 'wsgi.url_scheme': 'http', 'wsgi.version': (1,0), 'wsgi.input': StringIO(), 'wsgi.errors': StringIO(), 'wsgi.multithread': False, 'wsgi.multiprocess': False, 'wsgi.run_once': True, }, start_response))
def start_standalone_server(address="localhost", port=8000, app=wsgi_application): """Start standalone http server for processing requests""" validator_app = validator(app) httpd = make_server(address, port, app) LOG.info("Serving on {0}:{1}...".format(address, port)) httpd.serve_forever()
def testGetWsdl(self): """Simple test for serving of WSDL by spyne through pyramid route""" application = PyramidApplication( Application([self.HelloWorldService], tns='spyne.examples.hello', in_protocol=Soap11(validator='lxml'), out_protocol=Soap11())) config = Configurator(settings={'debug_all': True}) config.add_route('home', '/') config.add_view(application, route_name='home') wsgi_app = validator(config.make_wsgi_app()) env = { 'SCRIPT_NAME': '', 'REQUEST_METHOD': 'GET', 'PATH_INFO': '/', 'QUERY_STRING': 'wsdl', } setup_testing_defaults(env) request = Request(env) resp = request.get_response(wsgi_app) self.assert_(resp.status.startswith("200 ")) node = etree.XML(resp.body) # will throw exception if non well formed
def test(): from wsgiref.validate import validator app = Cling(getcwd()) try: print "Serving " + getcwd() + " to http://localhost:8888" print "Serving " + getcwd() + " to http://localhost:8889" start_server = lambda port : make_server('0.0.0.0', port, validator(app)).serve_forever() #start_server(8888) import threading server_1 = threading.Thread(target=start_server, name="The 8888 server",args=[8888]) server_2 = threading.Thread(target=start_server, name="The 8889 server",args=[8889]) server_1.start() server_2.start() print "" print "Point your browser at http://localhost:8888/index.html" server_1.join() server_2.join() except KeyboardInterrupt, ki: print "" print "Ciao, baby!" sys.exit(0)
def get_app(self, app=None): """Obtain a new (decorated) WSGI app to hook into the origin server.""" if app is None: app = cherrypy.tree if self.conquer: try: import wsgiconq except ImportError: warnings.warn( "Error importing wsgiconq. pyconquer will not run.") else: app = wsgiconq.WSGILogger(app, c_calls=True) if self.validate: try: from wsgiref import validate except ImportError: warnings.warn( "Error importing wsgiref. The validator will not run.") else: # wraps the app in the validator app = validate.validator(app) return app
def main(): from wsgiref import simple_server, validate logging.basicConfig(level=logging.INFO) parser = optparse.OptionParser(usage=USAGE) parser.add_option('-p', '--port', dest='port', type='int', default=8000, help='Port to listen on') options, args = parser.parse_args() if len(args) == 0: path = os.getcwd() elif len(args) == 1: path = args[0] else: parser.print_help() return repo_path = mercurial.dispatch._findrepo(path) if not repo_path: print 'No Mercurial repository found for', path print parser.print_help() return logging.info('Mercurial repository %s', repo_path) app = validate.validator(downy_app(repo_path)) httpd = simple_server.make_server('', options.port, app) logging.info('Serving on port %d', options.port) httpd.serve_forever()
def sync_apps(profile=False, validate=False, conquer=False): app = cherrypy.tree if profile: app = profiler.make_app(app, aggregate=False) if conquer: try: import wsgiconq except ImportError: warnings.warn("Error importing wsgiconq. pyconquer will not run.") else: app = wsgiconq.WSGILogger(app) if validate: try: from wsgiref import validate except ImportError: warnings.warn("Error importing wsgiref. The validator will not run.") else: app = validate.validator(app) h = cherrypy.server.httpserver if hasattr(h, 'wsgi_app'): # CherryPy's wsgiserver h.wsgi_app = app elif hasattr(h, 'fcgiserver'): # flup's WSGIServer h.fcgiserver.application = app elif hasattr(h, 'scgiserver'): # flup's WSGIServer h.scgiserver.application = app
def __init__(self, app): self.app = app self.server = simple_server.WSGIServer( ('', 8080), simple_server.WSGIRequestHandler, ) self.server.set_app(validate.validator(self.app))
def sync_apps(profile=False, validate=False, conquer=False): apps = [] for base, app in cherrypy.tree.apps.iteritems(): if base == "/": base = "" if profile: app = profiler.make_app(app, aggregate=False) if conquer: try: import wsgiconq except ImportError: warnings.warn("Error importing wsgiconq. pyconquer will not run.") else: app = wsgiconq.WSGILogger(app) if validate: try: from wsgiref import validate except ImportError: warnings.warn("Error importing wsgiref. The validator will not run.") else: app = validate.validator(app) apps.append((base, app)) apps.sort() apps.reverse() for s in cherrypy.server.httpservers: s.mount_points = apps
def StartWebServer(self, port, application=None): """Start web server. Args: port: Port to start application on. application: Optional WSGI function. If none provided will use tests CreateWsgiApplication method. Returns: A tuple (server, application): server: An instance of ServerThread. application: Application that web server responds with. """ if not application: application = self.CreateWsgiApplication() validated_application = validate.validator(application) try: server = simple_server.make_server( 'localhost', port, validated_application) except socket.error: # Try IPv6 server = simple_server.make_server( 'localhost', port, validated_application, server_class=WSGIServerIPv6) server = ServerThread(server) server.start() return server, application
def handle_connection(conn, port): request = conn.recv(1) if not request: print 'Error, remote client closed connection without sending anything' return count = 0 env = {} while request[-4:] != '\r\n\r\n': request += conn.recv(1) request, data = request.split('\r\n',1) headers = {} for line in data.split('\r\n')[:-2]: k, v = line.split(': ', 1) headers[k.lower()] = v path = urlparse(request.split(' ', 3)[1]) env['REQUEST_METHOD'] = 'GET' env['PATH_INFO'] = path[2] env['QUERY_STRING'] = path[4] env['CONTENT_TYPE'] = 'text/html' env['CONTENT_LENGTH'] = str(0) env['SCRIPT_NAME'] = '' env['SERVER_NAME'] = socket.getfqdn() env['SERVER_PORT'] = str(port) env['wsgi.version'] = (1, 0) env['wsgi.errors'] = stderr env['wsgi.multithread'] = False env['wsgi.multiprocess'] = False env['wsgi.run_once'] = False env['wsgi.url_scheme'] = 'http' env['HTTP_COOKIE'] = headers['cookie'] if 'cookie' in headers.keys() else '' body = '' if request.startswith('POST '): env['REQUEST_METHOD'] = 'POST' env['CONTENT_LENGTH'] = headers['content-length'] env['CONTENT_TYPE'] = headers['content-type'] while len(body) < int(headers['content-length']): body += conn.recv(1) def start_response(status, response_headers): conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') for pair in response_headers: key, header = pair conn.send(key + ': ' + header + '\r\n') conn.send('\r\n') env['wsgi.input'] = StringIO(body) my_app = make_app() validator_app = validator(my_app) result = my_app(env, start_response) for data in result: conn.send(data) conn.close()
def setUpClass(cls): cls._httpd = wsgi_boost.WsgiBoostHttp(threads=1) app = App() cls._httpd.set_app(validator(app)) cls._server_thread = threading.Thread(target=cls._httpd.start) cls._server_thread.daemon = True cls._server_thread.start() time.sleep(0.5)
def test(): from wsgiref.validate import validator magics = StringMagic(title="String Test"), KidMagic(title="Kid Test") app = Shock('testdata/pub', magics=magics) try: make_server('localhost', 9999, validator(app)).serve_forever() except KeyboardInterrupt, ki: print "Ciao, baby!"
def main(): opts, args = parse_options() bind = parse_bind(opts.bind) if opts.validate: application = (Application() + Root()) app = validator(application) httpd = make_server(bind[0], bind[1], app) httpd.serve_forever() raise SystemExit(0) manager = Manager() opts.debug and Debugger().register(manager) Poller = select_poller(opts.poller.lower()) Poller().register(manager) if opts.server.lower() == "base": BaseServer(bind).register(manager) HelloWorld().register(manager) else: Server(bind).register(manager) Root().register(manager) docroot = os.getcwd() if not args else args[0] Static(docroot=docroot, dirlisting=True).register(manager) opts.passwd and Authentication(passwd=opts.passwd).register(manager) opts.logging and Logger().register(manager) if opts.profile and hotshot: profiler = hotshot.Profile(".profile") profiler.start() if opts.debug: print(graph(manager, name="circuits.web")) print() print(inspect(manager)) for i in range(opts.jobs): manager.start(process=True) manager.run() if opts.profile and hotshot: profiler.stop() profiler.close() stats = hotshot.stats.load(".profile") stats.strip_dirs() stats.sort_stats("time", "calls") stats.print_stats(20)
def StartServer(self, app): self.validated = validate.validator(app) self.port = test_util.pick_unused_port() self.server = simple_server.make_server('localhost', self.port, self.validated) self.server_thread = webapp_test_util.ServerThread(self.server) self.server_thread.start() self.server_thread.wait_until_running()
def StartWebServer(self, port): """Start web server.""" application = webapp.WSGIApplication(self.DEFAULT_MAPPING, True) validated_application = validate.validator(application) server = simple_server.make_server('localhost', port, validated_application) server = ServerThread(server) server.start() server.wait_until_running() return server, application
def StartWebServer(self, port): """Start web server.""" application = self.CreateWsgiApplication() validated_application = validate.validator(application) server = simple_server.make_server('localhost', port, validated_application) server = ServerThread(server) server.start() server.wait_until_running() return server, application
def __init__(self): """ Initialization of the WSGI OCCI application for synnefo """ global ENABLE_VOMS, VOMS_DB ENABLE_VOMS = VOMS_CONFIG['enable_voms'] super(MyAPP,self).__init__(registry=snfRegistry()) self._register_backends() VALIDATOR_APP = validator(self)
def test(): from wsgiref.validate import validator app = Cling(getcwd()) try: print "Serving " + getcwd() + " to http://localhost:9999" make_server('localhost', 9999, validator(app)).serve_forever() except KeyboardInterrupt, ki: print "" print "Ciao, baby!"
def test_wsgi_input(self): def bad_app(e, s): e["wsgi.input"].read() s("200 OK", [("Content-Type", "text/plain; charset=utf-8")]) return [b"data"] out, err = run_amock(validator(bad_app)) self.assertTrue(out.endswith(b"A server error occurred. Please contact the administrator.")) self.assertEqual(err.splitlines()[-2], "AssertionError")
def wsgi_get(app, url): environ = {'PATH_INFO': url, 'QUERY_STRING': '', 'SCRIPT_NAME': ''} wsgiref.util.setup_testing_defaults(environ) response = dict() def start_response(status, headers): response.update({'status': status, 'headers': headers}) ret = validator(app)(environ, start_response) response['body'] = ''.join(ret) ret.close() return response
def test_list_children(self): k1 = model.Note({'-name-': 'kidone'}) k2 = model.Note({'-name-': 'kidtwo'}) note = model.Note(children=[k1, k2]) req = test_request({'PATH_INFO': '/children'}) res = req.get_response(validator(note.get_delegate().wsgi)) data = check_json_response(res) self.assertEqual(data, {'children': ['http://example.com/c:kidone', 'http://example.com/c:kidtwo']})
def wsgi_test(app, path='/', query_string=''): env = {'PATH_INFO': path, 'SCRIPT_NAME': '', 'QUERY_STRING': query_string} setup_testing_defaults(env) output = {} def start_response(status, headers, exc_info=None): output.update(status=status, headers=headers, exc_info=exc_info) body = validator(app)(env, start_response) output['body'] = ''.join(body) body.close() return output
def test_simple_validation_error(self): def bad_app(environ, start_response): start_response("200 OK", ("Content-Type", "text/plain")) return ["Hello, world!"] out, err = run_amock(validator(bad_app)) self.assertTrue(out.endswith("A server error occurred. Please contact the administrator.")) self.assertEqual( err.splitlines()[-2], "AssertionError: Headers (('Content-Type', 'text/plain')) must" " be of type list: <type 'tuple'>", )
def get_app(self): class HelloHandler(RequestHandler): def get(self): self.write("Hello world!") # It would be better to run the wsgiref server implementation in # another thread instead of using our own WSGIContainer, but this # fits better in our async testing framework and the wsgiref # validator should keep us honest return WSGIContainer(validator(WSGIApplication([ ("/", HelloHandler)])))
def before_scenario(context, scenario): context.beer_json = context.app.config['BEER_JSON'] if 'beerdesc' in scenario.tags: context.app.config['BEER_JSON'] = 'tests_json/test_beer_shortage.json' if 'encode' in scenario.tags: context.app.config['BEER_JSON'] = 'tests_json/test_beer_encode.json' # run app in subprocess # context.wsgi = make_server("", 8000, beer.app) context.wsgi = make_server("", 8000, validator(context.app)) context.server = Process(target=context.wsgi.serve_forever) context.server.start()
def main(): application = WSGISimpleRouter() from wsgiref.validate import validator application.map('/form', validator(show_form)) application.map('/upload', upload_form) application.map('/process', process_form) server = WSGIServer(application) server.serve(('localhost', 8080))
def main(): options, args = parser.parse_args() if not args or len(args) > 1: parser.error('You must give one PROXY_URL') proxy_url = args[0] app = JumbleMiddleware( LinkRewriterMiddleware(Proxy(proxy_url), proxy_url)) if getattr(options, 'debug', False): app = EvalException(app) app = validator(app) from paste.httpserver import serve serve(app, host=options.host, port=int(options.port))
def test_simple_validation_error(self): def bad_app(environ, start_response): start_response("200 OK", ('Content-Type', 'text/plain')) return ["Hello, world!"] out, err = run_amock(validator(bad_app)) self.assertTrue( out.endswith( b"A server error occurred. Please contact the administrator.") ) self.assertEqual( err.splitlines()[-2], "AssertionError: Headers (('Content-Type', 'text/plain')) must" " be of type list: <class 'tuple'>")
def test_http_headers(self): DATE = datetime(year=2013, month=1, day=1) STR = 'hey' class ResponseHeader(ComplexModel): _type_info = { 'Set-Cookie': String(max_occurs='unbounded'), 'Expires': DateTime } class SomeService(ServiceBase): __out_header__ = ResponseHeader @rpc(String) def some_call(ctx, s): assert s is not None ctx.out_header = ResponseHeader(**{ 'Set-Cookie': STR, 'Expires': DATE }) def start_response(code, headers): assert dict(headers)['Set-Cookie'] == STR assert dict(headers)['Expires'] == 'Tue, 01 Jan 2013 00:00:00 GMT' ret = ''.join( validator( WsgiApplication( Application( [SomeService], 'tns', in_protocol=HttpRpc(), out_protocol=HttpRpc())))({ 'SCRIPT_NAME': '', 'QUERY_STRING': '&s=' + STR, 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'localhost', 'SERVER_PORT': "9999", 'wsgi.url_scheme': 'http', 'wsgi.version': (1, 0), 'wsgi.input': StringIO(), 'wsgi.errors': StringIO(), 'wsgi.multithread': False, 'wsgi.multiprocess': False, 'wsgi.run_once': True, }, start_response)) assert ret == ''
def roulette_server(count=1): """ This application validates the interface used by the roulette application; it decorates the various APIs with assert statements to provide some diagnostic information. """ wheel = American() roulette = Roulette(wheel) debug = validator(roulette) httpd = make_server('', 8080, debug) if count is None: httpd.serve_forever() else: for c in range(count): httpd.handle_request()
def StartWebServer(self, port): """Start web server.""" protocols = wsgi_util.Protocols() protocols.add_protocol(protojson, 'json', 'application/json') application = wsgi_service.service_app(webapp_test_util.TestService, protocols=protocols) validated_application = validate.validator(application) other_application = wsgi_service.service_app( webapp_test_util.TestService.new_factory('initialized'), protocols=protocols) other_validated_application = validate.validator(other_application) applications = app_mapping([ ('/my/service', validated_application), ('/my/other_service', other_validated_application), ]) server = simple_server.make_server('localhost', port, applications) server = webapp_test_util.ServerThread(server) server.start() server.wait_until_running() return server, application
def main(): try: from wsgiref.simple_server import make_server from wsgiref.validate import validator if port[0] == 0: port[0] = get_open_port() wsgi_application = WsgiApplication(soap11_application) server = make_server(host, port[0], validator(wsgi_application)) logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', port[0])) logger.info('WSDL is at: /?wsdl') server.serve_forever() except ImportError: print("Error: example server code requires Python >= 2.5")
def get_app(self, app=None): """Obtain a new (decorated) WSGI app to hook into the origin server.""" if app is None: app = cherrypy.tree if self.validate: try: from wsgiref import validate except ImportError: warnings.warn( 'Error importing wsgiref. The validator will not run.') else: # wraps the app in the validator app = validate.validator(app) return app
def run(filepath, wsgiapp, host, port, reload, interval, static, static_root, static_dirs, lineprof, lineprof_file, validate): """ Runs a development server for WSGI Application. Usage: $ wsgicli run hello.py app -h 0.0.0.0 -p 5000 $ wsgicli run hello.py app --reload $ wsgicli run hello.py app --static --static-root /static/ --static-dirs ./static/ $ wsgicli run hello.py app --lineprof """ module = SourceFileLoader('module', filepath).load_module() app = getattr(module, wsgiapp) if static: from wsgi_static_middleware import StaticMiddleware app = StaticMiddleware(app, static_root=static_root, static_dirs=static_dirs) if validate: from wsgiref.validate import validator app = validator(app) if lineprof: # Caution: wsgi-lineprof is still pre-alpha. Except breaking API Changes. from wsgi_lineprof.middleware import LineProfilerMiddleware from wsgi_lineprof.filters import FilenameFilter, TotalTimeSorter if lineprof_file: # Now wsgi-lineprof is now supported only 1 file checking. lineprof_file = lineprof_file[0] else: lineprof_file = filepath.split( '/')[-1] if '/' in filepath else filepath filters = [FilenameFilter(lineprof_file), TotalTimeSorter()] app = LineProfilerMiddleware(app, filters=filters) if reload: run_live_reloading_server(interval, app=app, host=host, port=port) else: run_server(app=app, host=host, port=port)
def get_fps(self, device_id, package_name): """ :param device_id: :param package_name: :return: 60 """ _adb = "adb -s %s shell dumpsys gfxinfo %s" % (device_id, package_name) results = os.popen(_adb).read().strip() frames = [x for x in results.split('\n') if validator(x)] frame_count = len(frames) jank_count = 0 vsync_overtime = 0 render_time = 0 for frame in frames: time_block = re.split(r'\s+', frame.strip()) if len(time_block) == 3: try: render_time = float(time_block[0]) + float( time_block[1]) + float(time_block[2]) except Exception as e: render_time = 0 ''' 当渲染时间大于16.67,按照垂直同步机制,该帧就已经渲染超时 那么,如果它正好是16.67的整数倍,比如66.68,则它花费了4个垂直同步脉冲,减去本身需要一个,则超时3个 如果它不是16.67的整数倍,比如67,那么它花费的垂直同步脉冲应向上取整,即5个,减去本身需要一个,即超时4个,可直接算向下取整 最后的计算方法思路: 执行一次命令,总共收集到了m帧(理想情况下m=128),但是这m帧里面有些帧渲染超过了16.67毫秒,算一次jank,一旦jank, 需要用掉额外的垂直同步脉冲。其他的就算没有超过16.67,也按一个脉冲时间来算(理想情况下,一个脉冲就可以渲染完一帧) 所以FPS的算法可以变为: m / (m + 额外的垂直同步脉冲) * 60 ''' if render_time > 16.67: jank_count += 1 if render_time % 16.67 == 0: vsync_overtime += int(render_time / 16.67) - 1 else: vsync_overtime += int(render_time / 16.67) _fps = int(frame_count * 60 / (frame_count + vsync_overtime)) # writeInfo(_fps, PATH("../info/" + devices + "_fps.pickle")) # return (frame_count, jank_count, fps) return _fps
def get_app(self): class HelloHandler(RequestHandler): def get(self): self.write("Hello world!") class PathQuotingHandler(RequestHandler): def get(self, path): self.write(path) # It would be better to run the wsgiref server implementation in # another thread instead of using our own WSGIContainer, but this # fits better in our async testing framework and the wsgiref # validator should keep us honest return WSGIContainer(validator(WSGIApplication([ ("/", HelloHandler), ("/path/(.*)", PathQuotingHandler), ])))
def test_bytes_validation(self): def app(e, s): s("200 OK", [ ("Content-Type", "text/plain; charset=utf-8"), ("Date", "Wed, 24 Dec 2008 13:29:32 GMT"), ]) return [b"data"] out, err = run_amock(validator(app)) self.assertTrue(err.endswith('"GET / HTTP/1.0" 200 4\n')) ver = sys.version.split()[0].encode('ascii') self.assertEqual( b"HTTP/1.0 200 OK\r\n" b"Server: WSGIServer/0.2 Python/" + ver + b"\r\n" b"Content-Type: text/plain; charset=utf-8\r\n" b"Date: Wed, 24 Dec 2008 13:29:32 GMT\r\n" b"\r\n" b"data", out)
def get_fps(pkg_name, devices): _adb = "adb -s " + devices + " shell dumpsys gfxinfo %s" % pkg_name print(_adb) results = os.popen(_adb).read().strip() frames = [x for x in results.split('\n') if validator(x)] frame_count = len(frames) jank_count = 0 vsync_overtime = 0 render_time = 0 for frame in frames: time_block = re.split(r'\s+', frame.strip()) if len(time_block) == 3: try: render_time = float(time_block[0]) + float( time_block[1]) + float(time_block[2]) except Exception as e: render_time = 0 ''' 当渲染时间大于16.67,按照垂直同步机制,该帧就已经渲染超时 那么,如果它正好是16.67的整数倍,比如66.68,则它花费了4个垂直同步脉冲,减去本身需要一个,则超时3个 如果它不是16.67的整数倍,比如67,那么它花费的垂直同步脉冲应向上取整,即5个,减去本身需要一个,即超时4个,可直接算向下取整 最后的计算方法思路: 执行一次命令,总共收集到了m帧(理想情况下m=128),但是这m帧里面有些帧渲染超过了16.67毫秒,算一次jank,一旦jank, 需要用掉额外的垂直同步脉冲。其他的就算没有超过16.67,也按一个脉冲时间来算(理想情况下,一个脉冲就可以渲染完一帧) 所以FPS的算法可以变为: m / (m + 额外的垂直同步脉冲) * 60 ''' if render_time > 16.67: jank_count += 1 if render_time % 16.67 == 0: vsync_overtime += int(render_time / 16.67) - 1 else: vsync_overtime += int(render_time / 16.67) _fps = int(frame_count * 60 / (frame_count + vsync_overtime)) # if ':'in devices: # devices=devices.replace(':',' ') # return (frame_count, jank_count, fps) print("-----fps------") print(_fps) return _fps
def run_server(application, *, validate=True, **kwargs): with debug_loop() as loop: # Add a WSGI validator. if validate: application = validator(application) # Configure the server. server_config = { "host": "127.0.0.1", "port": 0, "loop": loop, } server_config.update(**kwargs) # Create the server. server, app = configure_server(application, **server_config) server_port = server.sockets[0].getsockname()[1] try: yield TestClient(server, app, server_port, loop=loop) finally: close_server(server, app, loop=loop)
def test_cp1252_url(self): def app(e, s): s("200 OK", [ ("Content-Type", "text/plain"), ("Date", "Wed, 24 Dec 2008 13:29:32 GMT"), ]) # PEP3333 says environ variables are decoded as latin1. # Encode as latin1 to get original bytes return [e["PATH_INFO"].encode("latin1")] out, err = run_amock(validator(app), data=b"GET /\x80%80 HTTP/1.0") self.assertEqual([ b"HTTP/1.0 200 OK", mock.ANY, b"Content-Type: text/plain", b"Date: Wed, 24 Dec 2008 13:29:32 GMT", b"", b"/\x80\x80", ], out.splitlines())
def test_cookie_parse(self): STR = 'some_string' class RequestHeader(ComplexModel): some_field = String class SomeService(ServiceBase): __in_header__ = RequestHeader @rpc(String) def some_call(ctx, s): assert ctx.in_header.some_field == STR def start_response(code, headers): assert code == HTTP_200 c = SimpleCookie() c['some_field'] = STR ''.join( validator( WsgiApplication( Application( [SomeService], 'tns', in_protocol=HttpRpc(parse_cookie=True), out_protocol=HttpRpc())))({ 'SCRIPT_NAME': '', 'QUERY_STRING': '', 'PATH_INFO': '/some_call', 'REQUEST_METHOD': 'GET', 'SERVER_NAME': 'localhost', 'SERVER_PORT': "9999", 'HTTP_COOKIE': str(c), 'wsgi.url_scheme': 'http', 'wsgi.version': (1, 0), 'wsgi.input': StringIO(), 'wsgi.errors': StringIO(), 'wsgi.multithread': False, 'wsgi.multiprocess': False, 'wsgi.run_once': True, }, start_response))
def setUp(self): io = StringIO.StringIO() sys.stdout = io self.application = validate.validator(server_config.server_normal) # 準備データの投稿. app = webtest.TestApp(self.application) self.condition = [ {'id': '', 'title': 'ready_post1', 'content': 'ready_post1'}, {'id': '', 'title': 'ready_post2', 'content': 'ready_post2'}] for dic in self.condition: response = app.post('/', params='a=post&p=3&delkey=0000&name=WebTest&title={0}&content={1}'.format(dic['title'], dic['content'])) self.assertEqual('301 Moved Permanently', response.status) redirect_response = response.follow() self.assertEqual('200 OK', redirect_response.status) pattern = r'<a href="/\?id=([0-9a-zA-Z]+)">{0}</a>'.format(dic['title']) dic['id'] = re.search(pattern, redirect_response.body).group(1) self.assertTrue(len(dic['id']) == 24)
def get_fps(dev_obj, pkg_name): results = dev_obj.shell(f"dumpsys gfxinfo {pkg_name}") # print(results) frames = [x for x in results.split('\n') if validator(x)] frame_count = len(frames) jank_count = 0 vsync_overtime = 0 render_time = 0 for frame in frames: time_block = re.split(r'\s+', frame.strip()) if len(time_block) == 3: try: render_time = float(time_block[0]) + float(time_block[1]) + float(time_block[2]) except Exception as e: render_time = 0 ''' 当渲染时间大于16.67,按照垂直同步机制,该帧就已经渲染超时 那么,如果它正好是16.67的整数倍,比如66.68,则它花费了4个垂直同步脉冲,减去本身需要一个,则超时3个 如果它不是16.67的整数倍,比如67,那么它花费的垂直同步脉冲应向上取整,即5个,减去本身需要一个,即超时4个,可直接算向下取整 最后的计算方法思路: 执行一次命令,总共收集到了m帧(理想情况下m=128),但是这m帧里面有些帧渲染超过了16.67毫秒,算一次jank,一旦jank, 需要用掉额外的垂直同步脉冲。其他的就算没有超过16.67,也按一个脉冲时间来算(理想情况下,一个脉冲就可以渲染完一帧) 所以FPS的算法可以变为: m / (m + 额外的垂直同步脉冲) * 60 ''' if render_time > 16.67: jank_count += 1 if render_time % 16.67 == 0: vsync_overtime += int(render_time / 16.67) - 1 else: vsync_overtime += int(render_time / 16.67) _fps = int(frame_count * 60 / (frame_count + vsync_overtime)) writeInfo(_fps, PATH(f"../info/{dev_obj.uuid}_fps.pickle")) # return (frame_count, jank_count, fps) print("-----fps------") print(_fps)
def test_functional(self): app = validator(CleaverWebUI(SampleBackend())) environ = {} setup_testing_defaults(environ) environ['PATH_INFO'] = '/' environ['REQUEST_METHOD'] = 'GET' environ['QUERY_STRING'] = '' result = {} def start_response(status, headers): result['status'] = status resp = app(environ, start_response) assert result['status'] == '200 OK' if hasattr(resp, 'close'): resp.close() del resp
def _StartWebServer(self, port, application=None): """Start web server. Args: port: Port to start application on. application: Optional WSGI function. If none provided will use tests CreateWsgiApplication method. Returns: A tuple (server, application): server: An instance of ServerThread. application: Application that web server responds with. """ if not application: application = self.CreateWsgiApplication() validated_application = validate.validator(application) server = simple_server.make_server('localhost', port, validated_application) server = ServerThread(server) server.start() return server, application
def get_app(self): """Obtain a new (decorated) WSGI app to hook into the origin server.""" import cherrypy app = cherrypy.tree if self.profile: app = profiler.make_app(app, aggregate=False) if self.conquer: try: import wsgiconq except ImportError: warnings.warn("Error importing wsgiconq. pyconquer will not run.") else: app = wsgiconq.WSGILogger(app, c_calls=True) if self.validate: try: from wsgiref import validate except ImportError: warnings.warn("Error importing wsgiref. The validator will not run.") else: app = validate.validator(app) return app
def main(): """Run the show""" global cur_chan channels.update(set( l.split(':')[0] for l in open(CHAN_PATH, 'r') )) cur_chan = list(channels)[0] feed_thread = threading.Thread(target=feeder) feed_thread.daemon = True feed_thread.start() validator_app = validator(simple_app) httpd = make_server( '', 80, validator_app, server_class=ThreadedWSGIServer ) try: httpd.serve_forever() finally: cur_chan = None feed_thread.join()
def get_app(self, app=None): if app is None: app = cherrypy.tree if self.conquer: try: import wsgiconq except ImportError: warnings.warn( 'Error importing wsgiconq. pyconquer will not run.') else: app = wsgiconq.WSGILogger(app, c_calls=True) if self.validate: try: from wsgiref import validate except ImportError: warnings.warn( 'Error importing wsgiref. The validator will not run.') else: app = validate.validator(app) return app
def getfps(self,activity): ''' 计算fps,写入文件 :return: ''' global fps try: cmd = "adb -s %s shell dumpsys gfxinfo %s" % (self.dev,self.db.packagename) logger.log_debug(cmd) result = os.popen(cmd).read().strip() frames = [x for x in result.split('\n') if validator(x)] frame_count = len(frames) jank_count = 0 vsync_overtime = 0 render_time = 0 for frame in frames: time_block = re.split(r'\s+', frame.strip()) if len(time_block) == 3: try: render_time = float(time_block[0]) + float(time_block[1]) + float(time_block[2]) except Exception as e: render_time = 0 if render_time > 16.67: jank_count += 1 if render_time % 16.67 == 0: vsync_overtime += int(render_time / 16.67) - 1 else: vsync_overtime += int(render_time / 16.67) fps = int(frame_count * 60 / (frame_count + vsync_overtime)) except Exception, e: logger.log_error("获取fps失败:" + str(e)) fps = 0
def get_app(self, app=None): """Obtain a new (decorated) WSGI app to hook into the origin server.""" if app is None: app = cherrypy.tree if self.conquer: try: import wsgiconq except ImportError: warnings.warn( 'Error importing wsgiconq. pyconquer will not run.') else: app = wsgiconq.WSGILogger(app, c_calls=True) if self.validate: try: from wsgiref import validate except ImportError: warnings.warn( 'Error importing wsgiref. The validator will not run.') else: app = validate.validator(app) return app
def request(self, method, path, environ=None, **kw): """Send a request to the application under test. The environment will be populated with some default keys. Additional keyword arguments will be interpreted as request headers. For example, passing x_foo=1 will add a request header "X-Foo: 1". """ if environ is None: environ = {} # setup_testing_defaults() uses '127.0.0.1', but localhost is easier # to type when testing. environ.setdefault('SERVER_NAME', 'localhost') environ.setdefault('QUERY_STRING', '') # silence validator warning setup_testing_defaults(environ) environ['REQUEST_METHOD'] = method environ['PATH_INFO'] = path for k, v in kw.items(): key = k.upper() if key not in ('CONTENT_TYPE', 'CONTENT_LENGTH'): key = 'HTTP_' + key environ[key] = str(v) start_response_rv = [] def start_response(status, headers, exc_info=None): # TODO handle exc_info != None start_response_rv.extend([status, headers]) wsgi_app = validator(self.app) app_iter = wsgi_app(environ, start_response) try: body = ''.join(app_iter) finally: if hasattr(app_iter, 'close'): app_iter.close() statusline, headerlist = start_response_rv return wsgi_response(statusline, Headers(headerlist), body)
def test_app(environ, start_response): """Probably not the most efficient example.""" import cgi start_response('200 OK', [('Content-Type', 'text/html')]) yield '<html><head><title>Hello World!</title></head>\n' \ '<body>\n' \ '<p>Hello World!</p>\n' \ '<table border="1">' names = environ.keys() names.sort() for name in names: yield '<tr><td>%s</td><td>%s</td></tr>\n' % ( name, cgi.escape( ` environ[name] `)) form = cgi.FieldStorage(fp=environ['wsgi.input'], environ=environ, keep_blank_values=1) if form.list: yield '<tr><th colspan="2">Form data</th></tr>' for field in form.list: yield '<tr><td>%s</td><td>%s</td></tr>\n' % (field.name, field.value) yield '</table>\n' \ '</body></html>\n' from wsgiref import validate test_app = validate.validator(test_app) WSGIServer(test_app, loggingLevel=logging.DEBUG).run()
def _makeOne(self, app, *arg, **kw): from wsgiref.validate import validator rhs = validator(app) retry = self._getTargetClass()(rhs, *arg, **kw) lhs = validator(retry) return lhs
def test_validated_hello(self): out, err = run_amock(validator(hello_app)) # the middleware doesn't support len(), so content-length isn't there self.check_hello(out, has_length=False)
def test_app(environ, start_response): if environ.get('CONTENT_LENGTH', None) in (-1, '-1'): del environ['CONTENT_LENGTH'] return validator(hello_app)(environ, start_response)
from wsgiref.simple_server import make_server from wsgiref.validate import validator # Our callable object which is intentionally not compliant to the # standard, so the validator is going to break def simple_app(environ, start_response): status = '200 OK' # HTTP Status headers = [('Content-type', 'text/plain')] # HTTP Headers start_response(status, headers) # This is going to break because we need to return a list, and # the validator is going to inform us return b"Hello World" # This is the application wrapped in a validator validator_app = validator(simple_app) with make_server('', 8020, validator_app) as httpd: print("Listening on port 8000....") httpd.serve_forever()
def get_app(self): self.app = WSGIApplication(self.get_handlers(), **self.get_app_kwargs()) return WSGIContainer(validator(self.app))