def UpdateStatsCache(cls, category, browsers): """Update the memcache of stats for all the tests for each browser. This is also where the summary stats get updated. Args: category: a category string like 'network' browsers: a list of browsers like ['Firefox 3.6', 'IE 8.0'] Returns: a list of browsers that were not processed due to a timeout. """ test_set = all_test_sets.GetTestSet(category) test_keys = [t.key for t in test_set.VisibleTests()] ua_stats = {} unhandled_browsers = [] is_timed_out = False for browser in browsers: try: medians, num_scores = test_set.GetMediansAndNumScores(browser) except db.Timeout: is_timed_out = True if is_timed_out: logging.info('Timed out \'%s\' in UpdateStatsCache doing ' 'GetMediansAndNumScores for %s', category, browser) unhandled_browsers.append(browser) else: stats = test_set.GetStats(test_keys, medians, num_scores) ua_stats[browser] = stats memcache.set_multi(ua_stats, **cls.MemcacheParams(category)) if not is_timed_out: SummaryStatsManager.UpdateStats(category, ua_stats) return unhandled_browsers
def UpdateCategory(request): category = request.REQUEST.get('category') user_agent_key = request.REQUEST.get('user_agent_key') if not category: logging.info('cron.UserAgentGroup: No category') return http.HttpResponse('No category') test_set = all_test_sets.GetTestSet(category) if not test_set: logging.info('cron.UserAgentGroup: Bad category: %s', category) return http.HttpResponse('Bad category: %s' % category) if not user_agent_key: logging.info('cron.UserAgentGroup: No key') return http.HttpResponse('No key') try: user_agent = UserAgent.get(db.Key(user_agent_key)) except db.BadKeyError: logging.info('cron.UserAgentGroup: Invalid UserAgent key: %s', user_agent_key) return http.HttpResponse('Invalid UserAgent key: %s' % user_agent_key) if user_agent: logging.info('cron.UserAgentGroup: UpdateCategory(%s, %s)', category, user_agent_key) try: result_stats.UpdateCategory(category, user_agent) return http.HttpResponse('Done with UserAgent key=%s' % user_agent_key) except: return http.HttpResponse('Got a BadValueError. eff this one.') else: return http.HttpResponse('No user_agent with this key.')
def About(request): """About page.""" params = { 'page_title': 'What are the Selectors API Tests?', 'tests': all_test_sets.GetTestSet(CATEGORY).tests, } return util.Render(request, 'templates/about.html', params, CATEGORY)
def TestSelectors(request): page_title = 'Reflow CSS Selector Tests' test_key = request.GET.get('t') test_set = all_test_sets.GetTestSet(CATEGORY) try: test = test_set.GetTest(test_key) page_title += ' %s' % test.name except KeyError: test = None default_params = test_set_params.Params( 'nested_anchors', 'num_elements=400', 'num_nest=4', 'css_selector=#g-content *', 'num_css_rules=1000', 'css_text=border: 1px solid #0C0; padding: 8px;') params = { 'page_title': page_title, 'params': default_params, 'test': test, 'server': util.GetServer(request), 'autorun': request.GET.get('autorun'), 'continue': request.GET.get('continue'), 'csrf_token': request.session.get('csrf_token') } return util.Render(request, 'templates/test.html', params, CATEGORY)
def About(request): """About page.""" params = { 'page_title': 'What is the Ringmark test?', 'tests': all_test_sets.GetTestSet(CATEGORY).tests, } return util.Render(request, 'templates/about.html', params, CATEGORY)
def About(request): """About page.""" params = { 'page_title': 'V8 Benchmark Suite Tests - About', 'tests': all_test_sets.GetTestSet(CATEGORY).tests, } return Render(request, 'templates/about.html', params)
def BuildRankers(db, category): cursor = db.cursor() cursor.execute( ''' SELECT test, family, v1, v2, v3, score FROM scores WHERE category=%s AND test IS NOT NULL AND family IS NOT NULL ORDER by test, family, v1, v2, v3 ;''', category) test_set = all_test_sets.GetTestSet(category) last_test_key = None last_parts = None rankers = {} for test_key, family, v1, v2, v3, score in cursor.fetchall(): if test_key != last_test_key: last_test_key = test_key test = test_set.GetTest(test_key) if test is None: continue parts = family, v1, v2, v3 if parts != last_parts: browsers = UserAgent.parts_to_string_list(family, v1, v2, v3) for browser in browsers: browser_rankers = rankers.setdefault(browser, {}) if test_key not in browser_rankers: ranker = browser_rankers[test_key] = CreateRanker( test, browser) else: ranker = browser_rankers[test_key] ranker.Add(score) return rankers
def About(request): """About page.""" params = { 'page_title': 'What are the Reflow Tests?', 'server': util.GetServer(request), 'tests': all_test_sets.GetTestSet(CATEGORY).tests, } return util.Render(request, 'templates/about.html', params, CATEGORY)
def GetOrCreateRankers(self): parent = self.parent() test_set = all_test_sets.GetTestSet(parent.category) test = test_set.GetTest(self.test) #logging.info('GetOrCreateRankers %s' % test.get_memcache_keyname()) if test: params_str = parent.params_str or None return test.GetOrCreateRankers(parent.GetBrowsers(), params_str) else: logging.warn('Test key not found in test_set: %s', self.test) return []
def GetBrowsers(cls, category, version_level, browser_offset=0, browser_limit=BROWSER_LIMIT): """Get all the browsers for a version level. Args: category: a category string like 'network' or 'reflow'. version_level: 'top', 0 (family), 1 (major), 2 (minor), 3 (3rd) browser_limit: # of browsers to return, max (for version_level=3). browser_offset: Offset for where to start in browser list (for version_level=3). Returns: ['Firefox 3.1', 'Safari 4.0', 'Safari 4.5', ...] """ test_set = None if version_level == 'top': browsers = list(TOP_BROWSERS) elif version_level == 'top-d': browsers = list(TOP_DESKTOP_BROWSERS) elif version_level == 'top-m': browsers = list(TOP_MOBILE_BROWSERS) elif version_level == 'top-d-e': browsers = list(TOP_DESKTOP_EDGE_BROWSERS) else: # If this is an aliased UserTest (like HTML5), use its key instead. test_set = all_test_sets.GetTestSet(category) if test_set is not None and test_set.user_test_category is not None: category = test_set.user_test_category key_name = cls.KeyName(category, version_level) browsers = memcache.get(key_name, namespace=cls.MEMCACHE_NAMESPACE) if browsers is None: manager = cls.get_by_key_name(key_name) browsers = manager and manager.browsers or [] memcache.set(key_name, browsers, namespace=cls.MEMCACHE_NAMESPACE) # We only apply offset and limit when v=1,2,3 and this is a usertest. browser_list = None if ('usertest' in category and test_set and test_set.user_test_category is None and version_level in ['1', '2', '3']): end_index = browser_offset + browser_limit logging.info('OFFSET INDEXES: %s:%s' % (browser_offset,end_index)) browser_list = browsers[browser_offset:end_index] else: browser_list = browsers logging.info('Browser list length: %s' % len(browser_list)) return browser_list
def UploadRankers(request): """Rebuild rankers.""" time_limit = int(request.REQUEST.get('time_limit', 8)) category = request.REQUEST.get('category') params_str = request.REQUEST.get('params_str') test_key_browsers_json = request.REQUEST.get('test_key_browsers_json') ranker_values_json = request.REQUEST.get('ranker_values_json') if not category: return http.HttpResponseServerError('Must send "category".') if not test_key_browsers_json: return http.HttpResponseServerError( 'Must send "test_key_browsers_json".') if not ranker_values_json: return http.HttpResponseServerError('Must send "ranker_values_json".') test_key_browsers = simplejson.loads(test_key_browsers_json) ranker_values = simplejson.loads(ranker_values_json) start_time = time.clock() message = None test_set = all_test_sets.GetTestSet(category) test_browsers = [(test_set.GetTest(test_key), browser) for test_key, browser in test_key_browsers] rankers = result_ranker.GetOrCreateRankers(test_browsers, params_str) for ranker, (median, num_scores, values_str) in zip(rankers, ranker_values): if time.clock() - start_time > time_limit: message = 'Over time limit' break if ranker.GetMedianAndNumScores() == (median, num_scores): logging.info('Skipping ranker with unchanged values: %s', ranker.key().name()) continue values = map(int, values_str.split('|')) try: ranker.SetValues(values, num_scores) except db.Timeout: message = 'db.Timeout' break response_params = {} if message: logging.info('message: %s', message) response_params['message'] = message return http.HttpResponse(simplejson.dumps(response_params))
def UpdateAllStatsCache(request, batch_size=UPDATE_ALL_BATCH_SIZE, is_uncached_update=False): categories_str = request.REQUEST.get('categories') if categories_str: categories = categories_str.split(',') else: categories = [s.category for s in all_test_sets.GetVisibleTestSets()] if not categories: return http.HttpResponseServerError('No categories given.') elif len(categories) > 1: for category in categories: attempt = 0 while attempt < 3: try: task = taskqueue.Task(url=request.path, params={'categories': category}) task.add(queue_name='update-stats-cache') break except: attempt += 1 return http.HttpResponse('Queued stats cache update for categories: %s' % categories) category = categories[0] test_set = all_test_sets.GetTestSet(category) browsers = result_stats.CategoryBrowserManager.GetAllBrowsers(category) logging.info('Update all stats cache: %s', category) for i in range(0, len(browsers), batch_size): params={ 'category': category, 'browsers': ','.join(browsers[i:i+batch_size]), } if is_uncached_update: params['is_uncached_update'] = 1 attempt = 0 while attempt < 3: try: taskqueue.Task(params=params).add(queue_name='update-stats-cache') break except: attempt += 1 logging.info('Added task for browsers %s to %s.', i, i+batch_size) return http.HttpResponse('Done creating update tasks.')
def TestAcid1(request): page_title = 'Reflow Tests' test_key = request.GET.get('t') test_set = all_test_sets.GetTestSet(CATEGORY) try: test = test_set.GetTest(test_key) except KeyError: test = None params = { 'page_title': page_title, 'params': test_set_params.Params('acid1', 'num_elements=300'), 'test': test, 'server': util.GetServer(request), 'autorun': request.GET.get('autorun'), 'continue': request.GET.get('continue'), 'csrf_token': request.session.get('csrf_token') } return util.Render(request, 'templates/acid1.html', params, CATEGORY)
def CheckTests(db): cursor = db.cursor() cursor.execute(''' SELECT category, test, count(*) FROM scores WHERE category IS NOT NULL GROUP BY category, test ORDER BY category, test ;''') for category, test_key, num_scores in cursor.fetchall(): test_set = all_test_sets.GetTestSet(category) if not test_set: logging.warn('No test_set for category: %s (num_scores=%s)', category, num_scores) continue test = test_set.GetTest(test_key) if not test: logging.warn('No test: %s, %s (num_scores=%s)', category, test_key, num_scores)
def UpdateRecentTests(request): max_recent_tests = 10 visible_categories = all_test_sets.GetVisibleTestSets() #logging.info('visible_categories %s' % visible_categories) prev_recent_tests = memcache.get(util.RECENT_TESTS_MEMCACHE_KEY) prev_result_parent_key = None if prev_recent_tests: prev_result_parent_key = prev_recent_tests[0]['result_parent_key'] recent_tests = [] recent_query = db.Query(ResultParent).order('-created').filter('category IN', [vis.category for vis in visible_categories]) for result_parent in recent_query.fetch(max_recent_tests): if str(result_parent.key()) == prev_result_parent_key: num_needed = max_recent_tests - len(recent_tests) if num_needed == max_recent_tests: return http.HttpResponse('No update needed.') else: recent_tests.extend(prev_recent_tests[:num_needed]) break recent_scores = result_parent.GetResults() test_set = all_test_sets.GetTestSet(result_parent.category) visible_test_keys = [t.key for t in test_set.VisibleTests()] recent_stats = test_set.GetStats(visible_test_keys, recent_scores) recent_tests.append({ 'result_parent_key': str(result_parent.key()), 'category': result_parent.category, 'created': result_parent.created, 'user_agent_pretty': result_parent.user_agent.pretty(), 'score': recent_stats['summary_score'], 'display': recent_stats['summary_display'], }) #logging.info('Setting recent tests: %s' % recent_tests) memcache.set(util.RECENT_TESTS_MEMCACHE_KEY, recent_tests, time=settings.STATS_MEMCACHE_TIMEOUT) #logging.info('Read recent tests: %s' % # memcache.get(key=util.RECENT_TESTS_MEMCACHE_KEY)) return http.HttpResponse('Done')
def Json(request): def html(s): return re.sub(r'<', '<', re.sub('>', '>', re.sub(r'&', '&', s))) def help_page(msg): return ( '<title>%(msg)s</title>' '<h1>%(msg)s</h1>' 'Serve JSON mapping code snippets to results.\n' '<p>The JSON is the intersection of the (key, value) pairs accross all' ' user agents requested, so if Firefox 3 was requested then only' ' key/value pairs that are present in both Firefox 3.0, 3.1, etc.' ' will be present.\n' '<p>The extra <code>userAgent</code> key maps to the user agents' ' requested so that the output is self-describing.\n' '\n' '<p>CGI params<dl>\n' ' <dt><code>ot</code></dt>\n' ' <dd>The output mime-type</dd>\n' ' <dt><code>ua</code></dt>\n' ' <dd>The user agents requested</dd>\n' '</dl>\n' 'E.g.,\n' ' <li><code>ua=Firefox+3.5</code>\n' ' <li><code>ua=MSIE+6.0</code>\n' ' <li><code>ot=application%%2Fjson</code>\n' ' <li><code>ot=text%%2Fplain</code>\n' '</ul>' ) % { 'msg': html(msg) } if request.method != 'GET' and request.method != 'HEAD': return http.HttpResponseBadRequest( help_page('Bad method "%s"' % request.method), mimetype='text/html') user_agent_string = None out_type = 'text/plain' for key, value in request.GET.iteritems(): if key == u'ua': user_agent_string = value elif key == u'ot' and value in ('text/plain', 'application/json'): out_type = value else: return http.HttpResponseBadRequest( help_page('Unknown CGI param "%s"' % key), mimetype='text/html') raise Exception() if user_agent_string is None: return http.HttpResponseBadRequest( help_page('Please specify useragent'), mimetype='text/html') user_agent_strings = user_agent_string.split(',') test_set = all_test_sets.GetTestSet(CATEGORY) test_keys = [t.key for t in test_set.tests] stats_data = result_stats.CategoryStatsManager.GetStats( test_set=test_set, browsers=user_agent_strings, test_keys=test_keys) del stats_data['total_runs'] # Keep only those items that are common across all the user agents requested. combined = None for browser_stats in stats_data.values(): stats = browser_stats['results'] if combined is None: combined = dict([(k, v.get('display')) for (k, v) in stats.iteritems() if k in ecmascript_snippets.SNIPPET_NAMES]) else: old_combined = combined combined = dict([(k, v.get('display')) for (k, v) in stats.iteritems() if (k in old_combined and old_combined.get(k) == v.get('display'))]) if combined is None: combined = {} result = [(ecmascript_snippets.with_name(k)[ecmascript_snippets.CODE], v) for (k, v) in combined.iteritems() if v is not None] result.append(('*userAgent*', json.to_json(stats_data.keys()))) def check_json_value(v): if v == 'throw': return '{ "throw": true }' return v response = http.HttpResponse(mimetype=out_type) response.write('{%s}' % ',\n'.join( [('%s:%s' % (json.to_json(k), check_json_value(v))) for (k, v) in result])) return response
def _FindAndUpdateStats(cls, category, browsers): test_set = all_test_sets.GetTestSet(category) ua_stats = CategoryStatsManager.GetStats( test_set, browsers, [t.key for t in test_set.VisibleTests()]) return cls.UpdateStats(category, ua_stats)