tools/android/loading Add link to dashboard and a way to cancel tasks.

tools/android/loading/cloud/frontend/clovis_frontend.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import logging
 import datetime
 import math
 import os
 import sys
 import time
@@ skipping 20 matching lines @@
 clovis_logger = logging.getLogger('clovis_frontend')
 clovis_logger.setLevel(logging.DEBUG)
 project_name = app_identity.get_application_id()
 instance_helper = common.google_instance_helper.GoogleInstanceHelper(
     credentials=GoogleCredentials.get_application_default(),
     project=project_name,
     logger=clovis_logger)
 app = flask.Flask(__name__)
 
 
-def Render(message, memory_logs=None):
+def RenderJobCreationPage(message, memory_logs=None):
   """Renders the log.html template.
 
   Args:
     message (str): Main content of the page.
     memory_logs (MemoryLogs): Optional logs.
   """
   log = None
   if memory_logs:
     log = memory_logs.Flush().split('\n')
-  return flask.render_template('log.html', body=message, log=log)
+  return flask.render_template('log.html', body=message, log=log,
+                               title='Job Creation Status')
 
 
 def PollWorkers(tag, start_time, timeout_hours, email_address, task_url):
   """Checks if there are workers associated with tag, by polling the instance
   group. When all workers are finished, the instance group and the instance
   template are destroyed.
   After some timeout delay, the instance group is destroyed even if there are
   still workers associated to it, which has the effect of killing all these
   workers.
 
@@ skipping 254 matching lines @@
 def StartFromJsonString(http_body_str):
   """Main function handling a JSON task posted by the user."""
   # Set up logging.
   memory_logs = MemoryLogs(clovis_logger)
   memory_logs.Start()
 
   # Load the task from JSON.
   task = ClovisTask.FromJsonString(http_body_str)
   if not task:
     clovis_logger.error('Invalid JSON task.')
-    return Render('Invalid JSON task:\n' + http_body_str, memory_logs)
+    return RenderJobCreationPage(
+        'Invalid JSON task:\n' + http_body_str, memory_logs)
 
   task_tag = task.BackendParams()['tag']
   clovis_logger.info('Start processing %s task with tag %s.' % (task.Action(),
                                                                 task_tag))
   user_email = email_helper.GetUserEmail()
 
   # Write the job to the datastore.
   frontend_job = FrontendJob.CreateForTag(task_tag)
   frontend_job.email = user_email
   frontend_job.status = 'not_started'
   frontend_job.clovis_task = task.ToJsonString()
   frontend_job.put()
 
   # Process the job on the queue, to avoid timeout issues.
   deferred.defer(SpawnTasksOnBackgroundQueue, task_tag)
 
-  return Render(
+  return RenderJobCreationPage(
       flask.Markup(
           '<a href="%s">See progress.</a>' % FrontendJob.GetJobURL(task_tag)),
       memory_logs)
 
 
 def SpawnTasksOnBackgroundQueue(task_tag):
   """Spawns Clovis tasks associated with task_tag from the backgound queue.
 
   This function is mostly a wrapper around SpawnTasks() that catches exceptions.
   It is assumed that a FrontendJob for task_tag exists.
@@ skipping 75 matching lines @@
         sequential_duration_s / target_parallel_duration_s)
 
   # Check the instance quotas.
   clovis_logger.info(
       'Requesting %i instances.' % task.BackendParams()['instance_count'])
   frontend_job.status = 'checking_instance_quotas'
   max_instances = instance_helper.GetAvailableInstanceCount()
   if max_instances == -1:
     frontend_job.status = 'instance_count_error'
     return
-  elif task.BackendParams()['instance_count'] == 0:
+  elif max_instances == 0 and task.BackendParams()['instance_count'] > 0:
     frontend_job.status = 'no_instance_available_error'
     return
   elif max_instances < task.BackendParams()['instance_count']:
     clovis_logger.warning(
         'Instance count limited by quota: %i available / %i requested.' % (
             max_instances, task.BackendParams()['instance_count']))
     task.BackendParams()['instance_count'] = max_instances
 
   # Compute the timeout if there is none specified.
   expected_duration_s = sequential_duration_s / (
@@ skipping 64 matching lines @@
 def Root():
   """Home page: show the new task form."""
   return flask.render_template('form.html')
 
 
 @app.route('/form_sent', methods=['POST'])
 def StartFromForm():
   """HTML form endpoint."""
   data_stream = flask.request.files.get('json_task')
   if not data_stream:
-    return Render('Failed, no content.')
+    return RenderJobCreationPage('Failed, no content.')
   http_body_str = data_stream.read()
   return StartFromJsonString(http_body_str)
 
 
+@app.route('/kill_job')
+def KillJob():
+  tag = flask.request.args.get('tag')
+  page_title = 'Kill Job'
+  if not tag:
+    return flask.render_template('log.html', body='Failed: Invalid tag.',
+                                 title=page_title)
+
+  frontend_job = FrontendJob.GetFromTag(tag)
+
+  if not frontend_job:
+    return flask.render_template('log.html', body='Job not found.',
+                                 title=page_title)
+  Finalize(tag, frontend_job.email, 'CANCELED', frontend_job.task_url)
+
+  body = 'Killed job %s.' % tag
+  return flask.render_template('log.html', body=body, title=page_title)
+
+
 @app.route('/list_jobs')
-def ShowTaskList():
+def ShowJobList():
   """Shows a list of all active jobs."""
   tags = FrontendJob.ListJobs()
+  page_title = 'Active Jobs'
 
   if not tags:
-    Render('No active jobs.')
+    return flask.render_template('log.html', body='No active job.',
+                                 title=page_title)
 
-  html = flask.Markup('Active tasks:<ul>')
+  html = ''
   for tag in tags:
     html += flask.Markup(
         '<li><a href="%s">%s</a></li>') % (FrontendJob.GetJobURL(tag), tag)
   html += flask.Markup('</ul>')
-  return Render(html)
+  return flask.render_template('log.html', body=html, title=page_title)
 
 
 @app.route(FrontendJob.SHOW_JOB_URL)
-def ShowTask():
+def ShowJob():
   """Shows basic information abour a job."""
   tag = flask.request.args.get('tag')
+  page_title = 'Job Information'
   if not tag:
-    return Render('Invalid task tag.')
+    return flask.render_template('log.html', body='Invalid tag.',
+                                 title=page_title)
 
   frontend_job = FrontendJob.GetFromTag(tag)
 
   if not frontend_job:
-    return Render('Task not found.')
-
-  message = flask.Markup('Task details:' + frontend_job.RenderAsHtml())
+    return flask.render_template('log.html', body='Job not found.',
+                                 title=page_title)
 
   log = None
   if frontend_job.log:
     log = frontend_job.log.split('\n')
 
-  return flask.render_template('log.html', body=message, log=log)
+  body = flask.Markup(frontend_job.RenderAsHtml())
+  body += flask.Markup('<a href="/kill_job?tag=%s">Kill</a>' % tag)
+  return flask.render_template('log.html', log=log, title=page_title,
+                               body=body)
 
 
 @app.errorhandler(404)
 def PageNotFound(e):  # pylint: disable=unused-argument
   """Return a custom 404 error."""
   return 'Sorry, Nothing at this URL.', 404
 
 
 @app.errorhandler(500)
 def ApplicationError(e):
   """Return a custom 500 error."""
   return 'Sorry, unexpected error: {}'.format(e), 499