def Get(self):
if (not IsDevServer() and not fnmatch(
urlparse(self._request.host).netloc, '*.appspot.com')):
# Only allow patches on appspot URLs; it doesn't matter if appspot.com is
# XSS'ed, but it matters for chrome.com.
redirect_host = 'https://chrome-apps-doc.appspot.com'
logging.info('Redirecting from XSS-able host %s to %s' %
(self._request.host, redirect_host))
return Response.Redirect('%s/_patch/%s' %
(redirect_host, self._request.path))
path_with_issue = self._request.path.lstrip('/')
if '/' in path_with_issue:
issue, path_without_issue = path_with_issue.split('/', 1)
else:
return Response.NotFound(
'Malformed URL. It should look like ' +
'https://developer.chrome.com/_patch/12345/extensions/...')
try:
response = RenderServlet(
Request(path_without_issue, self._request.host,
self._request.headers),
_PatchServletDelegate(issue, self._delegate)).Get()
# Disable cache for patched content.
response.headers.pop('cache-control', None)
except RietveldPatcherError as e:
response = Response.NotFound(e.message,
{'Content-Type': 'text/plain'})
redirect_url, permanent = response.GetRedirect()
if redirect_url is not None:
response = Response.Redirect(
'/_patch/%s%s' % (issue, redirect_url), permanent)
return response
def get(self):
path, request, response = (self.request.path.lstrip('/'), self.request,
self.response)
if path in ['favicon.ico', 'robots.txt']:
response.set_status(404)
return
if self._RedirectSpecialCases(path):
return
if self._RedirectFromCodeDotGoogleDotCom(path):
return
if path.startswith('_'):
servlet_path = path[1:]
if servlet_path.find('/') == -1:
servlet_path += '/'
servlet_name, servlet_path = servlet_path.split('/', 1)
servlet = _SERVLETS.get(servlet_name)
if servlet is None:
response.out.write('"%s" servlet not found' % servlet_path)
response.set_status(404)
return
else:
servlet_path = path
servlet = RenderServlet
servlet_response = servlet(Request(servlet_path,
request.headers)).Get()
response.out.write(servlet_response.content.ToString())
response.headers.update(servlet_response.headers)
response.status = servlet_response.status
def Get(self):
path = self._request.path
if path.startswith('_'):
servlet_path = path[1:]
if not '/' in servlet_path:
servlet_path += '/'
servlet_name, servlet_path = servlet_path.split('/', 1)
if servlet_name == _FORCE_CRON_TARGET:
queue = taskqueue.Queue()
queue.purge()
time.sleep(2)
queue.add(taskqueue.Task(url='/_cron'))
return Response.Ok('Cron job started.')
if servlet_name == 'enqueue':
queue = taskqueue.Queue()
queue.add(taskqueue.Task(url='/%s' % servlet_path))
return Response.Ok('Task enqueued.')
servlet = _SERVLETS.get(servlet_name)
if servlet is None:
return Response.NotFound('"%s" servlet not found' %
servlet_path)
else:
servlet_path = path
servlet = _DEFAULT_SERVLET
return servlet(
Request(servlet_path, self._request.host, self._request.headers,
self._request.arguments)).Get()
def _HandleRequest(self):
profile_mode = self.request.get('profile')
if profile_mode:
import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
try:
response = None
arguments = {}
for argument in self.request.arguments():
arguments[argument] = self.request.get(argument)
request = Request(self.request.path,
self.request.url[:-len(self.request.path)],
self.request.headers,
arguments)
response = Handler(request).Get()
except Exception as e:
logging.exception(e)
finally:
if profile_mode:
pr.disable()
s = StringIO.StringIO()
pstats.Stats(pr, stream=s).sort_stats(profile_mode).print_stats()
self.response.out.write(s.getvalue())
self.response.headers['Content-Type'] = 'text/plain'
self.response.status = 200
elif response:
self.response.out.write(response.content.ToString())
self.response.headers.update(response.headers)
self.response.status = response.status
else:
self.response.out.write('Internal server error')
self.response.status = 500
def Get(self):
path = self._request.path
redirect = self._RedirectSpecialCases()
if redirect is None:
redirect = self._RedirectFromCodeDotGoogleDotCom()
if redirect is not None:
return redirect
if path.startswith('_'):
servlet_path = path[1:]
if servlet_path.find('/') == -1:
servlet_path += '/'
servlet_name, servlet_path = servlet_path.split('/', 1)
servlet = _SERVLETS.get(servlet_name)
if servlet is None:
return Response.NotFound('"%s" servlet not found' %
servlet_path)
else:
servlet_path = path
servlet = _DEFAULT_SERVLET
return servlet(
Request(servlet_path, self._request.host,
self._request.headers)).Get()
def testCodeGoogleRedirect(self):
response = Handler(
Request('chrome/extensions/storage.html', 'http://code.google.com',
{})).Get()
self.assertEqual(302, response.status)
self.assertEqual('http://developer.chrome.com/extensions/storage.html',
response.headers.get('Location'))
def get(self):
profile_mode = self.request.get('profile')
if profile_mode:
import cProfile, pstats, StringIO
pr = cProfile.Profile()
pr.enable()
try:
request = Request(self.request.path,
self.request.url[:-len(self.request.path)],
self.request.headers)
response = Handler(request).Get()
finally:
if profile_mode:
pr.disable()
s = StringIO.StringIO()
pstats.Stats(pr,
stream=s).sort_stats(profile_mode).print_stats()
self.response.out.write(s.getvalue())
self.response.headers['Content-Type'] = 'text/plain'
self.response.status = 200
else:
self.response.out.write(response.content.ToString())
self.response.headers.update(response.headers)
self.response.status = response.status
def Render(self, path, headers=None, servlet=RenderServlet):
'''Renders |path|, returning a tuple of (status, contents, headers).
'''
headers = headers or {}
# TODO(kalman): do this via a LocalFileSystem not this fake AppEngine stuff.
ConfigureFakeFetchers(os.path.join(self._base_dir, 'docs'))
url_path = urlparse.urlparse(path.replace(os.sep, '/')).path
return servlet(Request(url_path, headers)).Get()
def get(self):
request = Request(self.request.path,
self.request.url[:-len(self.request.path)],
self.request.headers)
response = Handler(request).Get()
self.response.out.write(response.content.ToString())
self.response.headers.update(response.headers)
self.response.status = response.status
def Get(self):
path = self._request.path
if path.startswith('_'):
servlet_path = path[1:]
if not '/' in servlet_path:
servlet_path += '/'
servlet_name, servlet_path = servlet_path.split('/', 1)
servlet = _SERVLETS.get(servlet_name)
if servlet is None:
return Response.NotFound('"%s" servlet not found' % servlet_path)
else:
servlet_path = path
servlet = _DEFAULT_SERVLET
return servlet(
Request(servlet_path, self._request.host, self._request.headers)).Get()
def run_cron_for_dir(d, path_prefix=''):
success = True
start_time = time.time()
files = [
f for f in server_instance.content_cache.GetFromFileListing(d)
if not f.endswith('/')
]
logging.info('cron/%s: rendering %s files from %s...' %
(channel, len(files), d))
try:
for i, f in enumerate(files):
error = None
path = '%s%s' % (path_prefix, f)
try:
response = RenderServlet(
Request(path, self._request.headers)).Get(
server_instance=server_instance)
if response.status != 200:
error = 'Got %s response' % response.status
except DeadlineExceededError:
logging.error(
'cron/%s: deadline exceeded rendering %s (%s of %s): %s'
% (channel, path, i + 1, len(files),
traceback.format_exc()))
raise
except error:
pass
if error:
logging.error('cron/%s: error rendering %s: %s' %
(channel, path, error))
success = False
finally:
logging.info(
'cron/%s: rendering %s files from %s took %s seconds' %
(channel, len(files), d, time.time() - start_time))
return success
def get_via_render_servlet(path):
request = Request(path, self._request.host, self._request.headers)
delegate = _SingletonRenderServletDelegate(server_instance)
return RenderServlet(request, delegate).Get()
def testTestServlet(self):
request = Request('not_a_real_test_url', 'localhost', {})
test_servlet = TestServlet(request, _TestDelegate())
response = test_servlet.Get()
self.assertEqual(404, response.status)
def renderer(path):
return constructor(Request(path, '', self._request.headers)).Get()
def create_from_factory(factory):
path = 'extensions/foo'
return factory.Create(Request(path, {}), path)
def render_path(path):
return RenderServlet(Request(path, 'http://localhost', {}),
_LocalRenderServletDelegate(),
default_channel='trunk').Get()
def testFilterSamples(self):
sds = SamplesDataSource({}, {}, 'fake_path', Request('/', {}))
sds.get = self._FakeGet
self.assertEquals(json.loads(self._ReadLocalFile('expected.json')),
sds.FilterSamples('samples.json', 'bobaloo'))