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)
