Fix managed instances demo web server to correctly start/stop CPU loading (GoogleCloudPlatform#2310)

* Update minfra demo to correctly terminate worker process

* Create CpuBurner object for minfra demo to simulate CPU load

* Fix linting error in minfra demo webserver for CpuBurner

Author: djmailhot

compute/managed-instances/demo/app.py

@@ -19,30 +19,38 @@
 Attached health checks should query the '/health' path.
 """
 
+from ctypes import c_bool
 from flask import Flask, make_response, render_template
+from multiprocessing import Process, Value
 from random import random
 from re import sub
 from requests import get
 from socket import gethostname
-from multiprocessing import Process
+from time import sleep
 
 PORT_NUMBER = 80
 
 app = Flask(__name__)
 _is_healthy = True
-_worker = None
+_cpu_burner = None
+
+
+@app.before_first_request
+def init():
+    global _cpu_burner
+    _cpu_burner = CpuBurner()
 
 
 @app.route('/')
 def index():
     """Returns the demo UI."""
-    global _is_healthy
+    global _cpu_burner, _is_healthy
     return render_template('index.html',
                            hostname=gethostname(),
                            zone=_get_zone(),
                            template=_get_template(),
                            healthy=_is_healthy,
-                           working=_is_working())
+                           working=_cpu_burner.is_running())
 
 
 @app.route('/health')
@@ -60,15 +68,15 @@ def health():
 @app.route('/makeHealthy')
 def make_healthy():
     """Sets the server to simulate a 'healthy' status."""
-    global _is_healthy
+    global _cpu_burner, _is_healthy
     _is_healthy = True
 
     template = render_template('index.html',
                                hostname=gethostname(),
                                zone=_get_zone(),
                                template=_get_template(),
                                healthy=True,
-                               working=_is_working())
+                               working=_cpu_burner.is_running())
     response = make_response(template, 302)
     response.headers['Location'] = '/'
     return response
@@ -77,15 +85,15 @@ def make_healthy():
 @app.route('/makeUnhealthy')
 def make_unhealthy():
     """Sets the server to simulate an 'unhealthy' status."""
-    global _is_healthy
+    global _cpu_burner, _is_healthy
     _is_healthy = False
 
     template = render_template('index.html',
                                hostname=gethostname(),
                                zone=_get_zone(),
                                template=_get_template(),
                                healthy=False,
-                               working=_is_working())
+                               working=_cpu_burner.is_running())
     response = make_response(template, 302)
     response.headers['Location'] = '/'
     return response
@@ -94,10 +102,8 @@ def make_unhealthy():
 @app.route('/startLoad')
 def start_load():
     """Sets the server to simulate high CPU load."""
-    global _worker, _is_healthy
-    if not _is_working():
-        _worker = Process(target=_burn_cpu)
-        _worker.start()
+    global _cpu_burner, _is_healthy
+    _cpu_burner.start()
 
     template = render_template('index.html',
                                hostname=gethostname(),
@@ -113,10 +119,8 @@ def start_load():
 @app.route('/stopLoad')
 def stop_load():
     """Sets the server to stop simulating CPU load."""
-    global _worker, _is_healthy
-    if _is_working():
-        _worker.terminate()
-        _worker = None
+    global _cpu_burner, _is_healthy
+    _cpu_burner.stop()
 
     template = render_template('index.html',
                                hostname=gethostname(),
@@ -162,16 +166,32 @@ def _get_template():
         return ''
 
 
-def _is_working():
-    """Returns TRUE if the server is currently simulating CPU load."""
-    global _worker
-    return _worker is not None and _worker.is_alive()
-
-
-def _burn_cpu():
-    """Burn CPU cycles to simulate high CPU load."""
-    while True:
-        random()*random()
+class CpuBurner:
+    """
+    Object to asynchronously burn CPU cycles to simulate high CPU load.
+    Burns CPU in a separate process and can be toggled on and off.
+    """
+    def __init__(self):
+        self._toggle = Value(c_bool, False, lock=True)
+        self._process = Process(target=self._burn_cpu)
+        self._process.start()
+
+    def start(self):
+        """Start burning CPU."""
+        self._toggle.value = True
+
+    def stop(self):
+        """Stop burning CPU."""
+        self._toggle.value = False
+
+    def is_running(self):
+        """Returns true if currently burning CPU."""
+        return self._toggle.value
+
+    def _burn_cpu(self):
+        """Burn CPU cycles if work is toggled, otherwise sleep."""
+        while True:
+            random()*random() if self._toggle.value else sleep(1)
 
 
 if __name__ == "__main__":

compute/managed-instances/demo/requirements.txt

@@ -1 +1,2 @@
 flask==1.0
+requests