Sorted include files.

Checks for missing config.json and discovery.json.
Fixed string constants.

NOTRY=true

Review URL: https://codereview.chromium.org/293833003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271521 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 235 insertions, 220 deletions

diff --git a/components/cloud_devices/tools/prototype/prototype.py b/components/cloud_devices/tools/prototype/prototype.py
index 851b54d..2e2d923 100755
--- a/components/cloud_devices/tools/prototype/prototype.py
+++ b/components/cloud_devices/tools/prototype/prototype.py
@@ -6,74 +6,75 @@
 # This prototype has tons of flaws, not the least of which being that it
 # occasionally will block while waiting for commands to finish. However, this is
 # a quick sketch.
+# Script requires following components:
+#   sudo apt-get install python-tornado
+#   sudo apt-get install python-pip
+#   sudo pip install google-api-python-client
 
-import subprocess
-import json
-import tornado.httpserver
-import tornado.ioloop
-import time
 import atexit
-import apiclient.errors
-from apiclient.discovery import build_from_document
-from oauth2client.client import OAuth2WebServerFlow
-from oauth2client.file import Storage
-import oauth2client.client
+import base64
 import datetime
 import httplib2
+import json
 import os
+import subprocess
+import time
 import traceback
-import urlparse
-import base64
+
+from apiclient.discovery import build_from_document
+from apiclient.errors import HttpError
+from oauth2client.client import AccessTokenRefreshError
+from oauth2client.client import OAuth2WebServerFlow
+from oauth2client.file import Storage
+from tornado.httpserver import HTTPServer
+from tornado.ioloop import IOLoop
 
 _OAUTH_SCOPE = 'https://www.googleapis.com/auth/clouddevices'
 
+_API_CLIENT_FILE = 'config.json'
+_API_DISCOVERY_FILE = 'discovery.json'
+
 DEVICE_DRAFT = {
-    "systemName": "LEDFlasher",
-    "deviceKind": "vendor",
-    "displayName": "LED Flasher",
-    "channel":
-    {
-      "supportedType": "xmpp"
-    },
-    "commands":
-    {
-      "base":
-      {
-        "vendorCommands":
-        [
-          {
-            "name": "flashLED",
-            "parameter" : [{
-                "name": "times",
-                "type": "string"
-            }]
-          }
-        ]
-      }
+  'systemName': 'LEDFlasher',
+  'deviceKind': 'vendor',
+  'displayName': 'LED Flasher',
+  'channel': {
+    'supportedType': 'xmpp'
+  },
+  'commands': {
+    'base': {
+      'vendorCommands': [{
+        'name': 'flashLED',
+        'parameter' : [{
+          'name': 'times',
+          'type': 'string'
+        }]
+      }]
     }
   }
-
-wpa_supplicant_cmd = "wpa_supplicant -Dwext -iwlan0 -cwpa_supplicant.conf"
-ifconfig_cmd = "ifconfig wlan0 192.168.0.3"
-hostapd_cmd = "hostapd hostapd-min.conf"
-dhclient_release = "dhclient -r wlan0"
-dhclient_renew = "dhclient wlan0"
-dhcpd_cmd = "udhcpd -f /etc/udhcpd.conf"
-
-
-wpa_supplicant_conf = "wpa_supplicant.conf"
-
-wpa_supplicant_template = """network={
-       ssid="%s"
-       scan_ssid=1
-       proto=WPA RSN
-       key_mgmt=WPA-PSK
-       pairwise=CCMP TKIP
-       group=CCMP TKIP
-       psk="%s"
+}
+
+wpa_supplicant_cmd = 'wpa_supplicant -Dwext -iwlan0 -cwpa_supplicant.conf'
+ifconfig_cmd = 'ifconfig wlan0 192.168.0.3'
+hostapd_cmd = 'hostapd hostapd-min.conf'
+dhclient_release = 'dhclient -r wlan0'
+dhclient_renew = 'dhclient wlan0'
+dhcpd_cmd = 'udhcpd -f /etc/udhcpd.conf'
+
+wpa_supplicant_conf = 'wpa_supplicant.conf'
+
+wpa_supplicant_template = """
+network={
+   ssid="%s"
+   scan_ssid=1
+   proto=WPA RSN
+   key_mgmt=WPA-PSK
+   pairwise=CCMP TKIP
+   group=CCMP TKIP
+   psk="%s"
 }"""
 
-led_path = "/sys/class/leds/ath9k_htc-phy0/"
+led_path = '/sys/class/leds/ath9k_htc-phy0/'
 
 class DeviceUnregisteredError(Exception):
     pass
@@ -83,7 +84,7 @@ def ignore_errors(func):
         try:
             func(*args, **kwargs)
         except:
-            print "Got error in unsafe function:"
+            print 'Got error in unsafe function:'
             traceback.print_exc()
     return inner
 
@@ -107,31 +108,31 @@ class CommandWrapperFake(object):
     def __init__(self, cmd):
         self.cmd = cmd
     def start(self):
-        print "Start: ", self.cmd
+        print 'Start: ', self.cmd
     def wait(self):
-        print "Wait: ", self.cmd
+        print 'Wait: ', self.cmd
     def end(self):
-        print "End: ", self.cmd
+        print 'End: ', self.cmd
 
 class CloudCommandHandlerFake(object):
     def __init__(self, ioloop):
         pass
     def handle_command(self, command_name, args):
-        if command_name == "flashLED":
+        if command_name == 'flashLED':
             times = 1
-            if "times" in args:
-                times = int(args["times"])
-            print "Flashing LED %d times" % times
+            if 'times' in args:
+                times = int(args['times'])
+            print 'Flashing LED %d times' % times
 
 class CloudCommandHandlerReal(object):
     def __init__(self, ioloop):
         self.ioloop = ioloop
     def handle_command(self, command_name, args):
-        if command_name == "flashLED":
+        if command_name == 'flashLED':
             times = 1
-            if "times" in args:
-                times = int(args["times"])
-            print "Really flashing LED %d times" % times
+            if 'times' in args:
+                times = int(args['times'])
+            print 'Really flashing LED %d times' % times
             self.flash_led(times)
     @ignore_errors
     def flash_led(self, times):
@@ -140,12 +141,12 @@ class CloudCommandHandlerReal(object):
         if not times:
             return
 
-        file_trigger = open(os.path.join(led_path, "brightness"), "w")
+        file_trigger = open(os.path.join(led_path, 'brightness'), 'w')
 
         if value:
-            file_trigger.write("1")
+            file_trigger.write('1')
         else:
-            file_trigger.write("0")
+            file_trigger.write('0')
 
         file_trigger.close()
 
@@ -156,16 +157,16 @@ class WifiHandler(object):
     class Delegate:
         # Token is optional, and all delegates should support it being None
         def on_wifi_connected(self, token):
-            raise Exception("Unhandled condition: WiFi connected")
+            raise Exception('Unhandled condition: WiFi connected')
 
     def __init__(self, ioloop, state, delegate):
         self.ioloop = ioloop
         self.state = state
         self.delegate = delegate
     def start(self):
-        raise Exception("Start not implemented!")
+        raise Exception('Start not implemented!')
     def get_ssid(self):
-        raise Exception("Get SSID not implemented!")
+        raise Exception('Get SSID not implemented!')
 
 # Note that by using CommandWrapperFake, you can run WifiHandlerReal on fake
 # devices for testing the wifi-specific logic
@@ -190,7 +191,7 @@ class WifiHandlerReal(WifiHandler):
         self.dhcpd.start()
     def switch_to_wifi(self, ssid, passwd, token):
         try:
-            wpa_config = open(wpa_supplicant_conf, "w")
+            wpa_config = open(wpa_supplicant_conf, 'w')
             wpa_config.write(wpa_supplicant_template % (ssid, passwd))
             wpa_config.close()
             self.hostapd.end()
@@ -219,20 +220,20 @@ class WifiHandlerPassthrough(WifiHandler):
     def start(self):
         self.delegate.on_wifi_connected(None)
     def switch_to_wifi(self, ssid, passwd, token):
-        raise Exception("Should not be reached")
+        raise Exception('Should not be reached')
     def get_ssid(self):
-        return "dummy"
+        return 'dummy'
 
 
 def setup_fake():
-    print "Called setup"
+    print 'Called setup'
 
 def setup_real():
-    file_trigger = open(os.path.join(led_path, "trigger"), "w")
-    file_trigger.write("none")
+    file_trigger = open(os.path.join(led_path, 'trigger'), 'w')
+    file_trigger.write('none')
     file_trigger.close()
 
-if os.path.exists("on_real_device"):
+if os.path.exists('on_real_device'):
     CommandWrapper = CommandWrapperReal
     CommandWrapperMDns = CommandWrapperReal
     CloudCommandHandler = CloudCommandHandlerReal
@@ -253,36 +254,36 @@ class State:
         self.credentials_ = None
         self.has_credentials_ = False
         self.has_wifi_ = False
-        self.ssid_ = ""
-        self.password_ = ""
-        self.device_id_ = ""
+        self.ssid_ = ''
+        self.password_ = ''
+        self.device_id_ = ''
     def reset(self):
         self.clear()
         self.dump()
     def dump(self):
         json_obj = {
-            "has_credentials": self.has_credentials_,
-            "has_wifi": self.has_wifi_,
-            "ssid": self.ssid_,
-            "password": self.password_,
-            "device_id": self.device_id_ }
-        statefile = open("device_state.json", "w")
+            'has_credentials': self.has_credentials_,
+            'has_wifi': self.has_wifi_,
+            'ssid': self.ssid_,
+            'password': self.password_,
+            'device_id': self.device_id_ }
+        statefile = open('device_state.json', 'w')
         json.dump(json_obj, statefile)
         statefile.close()
 
         if self.has_credentials_:
             self.oauth_storage_.put(self.credentials_)
     def load(self):
-        if os.path.exists("device_state.json"):
-            statefile = open("device_state.json", "r")
+        if os.path.exists('device_state.json'):
+            statefile = open('device_state.json', 'r')
             json_obj = json.load(statefile)
             statefile.close()
 
-            self.has_credentials_ = json_obj["has_credentials"]
-            self.has_wifi_ = json_obj["has_wifi"]
-            self.ssid_ = json_obj["ssid"]
-            self.password_ = json_obj["password"]
-            self.device_id_ = json_obj["device_id"]
+            self.has_credentials_ = json_obj['has_credentials']
+            self.has_wifi_ = json_obj['has_wifi']
+            self.ssid_ = json_obj['ssid']
+            self.password_ = json_obj['password']
+            self.device_id_ = json_obj['device_id']
 
             if self.has_credentials_:
                 self.credentials_ = self.oauth_storage_.get()
@@ -318,17 +319,17 @@ class MDnsWrapper:
     def __init__(self):
         self.avahi_wrapper =  None
         self.setup_name = None
-        self.device_id = ""
+        self.device_id = ''
         self.started = False
     def start(self):
         self.started = True
         self.run_command()
     def get_command(self):
-        cmd = ["avahi-publish", "-s", "Raspberry Pi" , "_privet._tcp", "8080",
-                "txtvers=2", "type=wifi", "ty=Raspberry Pi",
-               "id=" + self.device_id]
+        cmd = ['avahi-publish', '-s', 'Raspberry Pi' , '_privet._tcp', '8080',
+                'txtvers=2', 'type=wifi', 'ty=Raspberry Pi',
+               'id=' + self.device_id]
         if self.setup_name:
-            cmd.append("setup=" + self.setup_name)
+            cmd.append('setup=' + self.setup_name)
         return cmd
     def run_command(self):
         if self.avahi_wrapper:
@@ -349,22 +350,36 @@ class MDnsWrapper:
 class CloudDevice:
     class Delegate:
         def on_device_started(self):
-            raise Exception("Not implemented: Device started")
+            raise Exception('Not implemented: Device started')
         def on_device_stopped(self):
-            raise Exception("Not implemented: Device stopped")
+            raise Exception('Not implemented: Device stopped')
     def __init__(self, ioloop, state, delegate):
         self.state = state
         self.http = httplib2.Http()
+        if not os.path.isfile(_API_CLIENT_FILE):
+          credentials = {
+              'oauth_client_id' : '',
+              'oauth_secret' : '',
+              'api_key' : ''
+          }
+          credentials_f = open(_API_CLIENT_FILE + '.samlpe', 'w')
+          credentials_f.write(json.dumps(credentials));
+          credentials_f.close()
+          raise Exception('Missing ' + _API_CLIENT_FILE);
 
-        credentials_f = open("api_client.json")
+        credentials_f = open(_API_CLIENT_FILE)
         credentials = json.load(credentials_f)
         credentials_f.close()
 
-        self.oauth_client_id = credentials["oauth_client_id"]
-        self.oauth_secret = credentials["oauth_secret"]
-        self.api_key = credentials["api_key"]
+        self.oauth_client_id = credentials['oauth_client_id']
+        self.oauth_secret = credentials['oauth_secret']
+        self.api_key = credentials['api_key']
+
+        if not os.path.isfile(_API_DISCOVERY_FILE):
+          raise Exception('Download https://developers.google.com/'
+                          'cloud-devices/v1/discovery.json');
 
-        f = open("clouddevices.json")
+        f = open('discovery.json')
         discovery = f.read()
         f.close()
         self.gcd = build_from_document(
@@ -384,8 +399,8 @@ class CloudDevice:
         elif token:
             self.register(token)
         else:
-            print "Device not registered and has no credentials."
-            print "Waiting for registration."
+            print 'Device not registered and has no credentials.'
+            print 'Waiting for registration.'
     def register(self, token):
         resource = {
             'deviceDraft': DEVICE_DRAFT,
@@ -405,7 +420,7 @@ class CloudDevice:
         self.credentials = flow.step2_exchange(authorization_code)
         self.device_id = finalTicket['deviceDraft']['id']
         self.state.set_credentials(self.credentials, self.device_id)
-        print "Registered with device_id ", self.device_id
+        print 'Registered with device_id ', self.device_id
 
         self.run_device()
     def run_device(self):
@@ -413,11 +428,11 @@ class CloudDevice:
 
         try:
             dev=self.gcd.devices().get(deviceId=self.device_id).execute()
-        except apiclient.errors.HttpError, e:
+        except HttpError, e:
             # Pretty good indication the device was deleted
             if e.resp.status == 404:
                 raise DeviceUnregisteredError()
-        except oauth2client.client.AccessTokenRefreshError:
+        except AccessTokenRefreshError:
             raise DeviceUnregisteredError()
 
         self.check_commands()
@@ -426,29 +441,29 @@ class CloudDevice:
         if not self.active:
             return
 
-        print "Checking commands..."
+        print 'Checking commands...'
 
         commands = self.gcd.commands().list(deviceId=self.device_id,
-                                            state="queued").execute()
+                                            state='queued').execute()
 
-        if "commands" in commands:
-            print "Found ", len(commands["commands"]), " commands"
+        if 'commands' in commands:
+            print 'Found ', len(commands['commands']), ' commands'
             args = {}
             vendorCommandName = None
 
-            for command in commands["commands"]:
+            for command in commands['commands']:
                 try:
-                    if command["name"].startswith("base._"):
-                        vendorCommandName = command["name"][
-                            len("base._"):]
-                        if "parameters" in command:
-                            parameters = command["parameters"]
+                    if command['name'].startswith('base._'):
+                        vendorCommandName = command['name'][
+                            len('base._'):]
+                        if 'parameters' in command:
+                            parameters = command['parameters']
                         else:
                             parameters = {}
                     else:
                         vendorCommandName = None
                 except KeyError:
-                    print "Could not parse vendor command ",
+                    print 'Could not parse vendor command ',
                     print repr(command)
                     vendorCommandName = None
 
@@ -457,10 +472,10 @@ class CloudDevice:
                         vendorCommandName,
                         parameters)
 
-                self.gcd.commands().patch(commandId = command["id"],
-                                          body={"state": "done"}).execute()
+                self.gcd.commands().patch(commandId = command['id'],
+                                          body={'state': 'done'}).execute()
         else:
-            print "Found no commands"
+            print 'Found no commands'
 
         self.ioloop.add_timeout(datetime.timedelta(milliseconds=1000),
                                 self.check_commands)
@@ -471,14 +486,14 @@ class CloudDevice:
 
 def get_only(f):
     def inner(self, request, response_func, *args):
-        if request.method != "GET":
+        if request.method != 'GET':
             return False
         return f(self, request, response_func, *args)
     return inner
 
 def post_only(f):
     def inner(self, request, response_func, *args):
-        if request.method != "POST":
+        if request.method != 'POST':
             return False
         return f(self, request, response_func, *args)
     return inner
@@ -500,15 +515,15 @@ def post_provisioning(f):
 def extract_encryption_params(f):
     def inner(self, request, response_func, *args):
         try:
-            client_id = request.headers["X-Privet-Client-ID"]
-            if "X-Privet-Encrypted" in request.headers:
-                encrypted = (request.headers["X-Privet-Encrypted"].lower()
-                             == "true")
+            client_id = request.headers['X-Privet-Client-ID']
+            if 'X-Privet-Encrypted' in request.headers:
+                encrypted = (request.headers['X-Privet-Encrypted'].lower()
+                             == 'true')
             else:
                 encrypted = False
         except (KeyError, TypeError):
-            print "Missing client parameters in headers"
-            response_func(400, { "error": "missing_client_parameters" })
+            print 'Missing client parameters in headers'
+            response_func(400, { 'error': 'missing_client_parameters' })
             return True
 
         return f(self, request, response_func, client_id, encrypted, *args)
@@ -560,7 +575,7 @@ class DummySession:
     def get_client_id(self):
         return client_id
     def get_stype(self):
-        return "dummy"
+        return 'dummy'
 
 class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
     def __init__(self, ioloop, state):
@@ -572,15 +587,15 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
         self.in_session = False
         self.ioloop = ioloop
         self.handlers = {
-            "/internal/ping": self.do_ping,
-            "/privet/info": self.do_info,
-            "/deprecated/wifi/switch": self.do_wifi_switch,
-            "/privet/v2/session/handshake": self.do_session_handshake,
-            "/privet/v2/session/cancel": self.do_session_cancel,
-            "/privet/v2/session/api": self.do_session_api,
-            "/privet/v2/setup/start": self.get_insecure_api_handler(
+            '/internal/ping': self.do_ping,
+            '/privet/info': self.do_info,
+            '/deprecated/wifi/switch': self.do_wifi_switch,
+            '/privet/v2/session/handshake': self.do_session_handshake,
+            '/privet/v2/session/cancel': self.do_session_cancel,
+            '/privet/v2/session/api': self.do_session_api,
+            '/privet/v2/setup/start': self.get_insecure_api_handler(
                 self.do_secure_setup),
-            "/privet/v2/setup/status": self.get_insecure_api_handler(
+            '/privet/v2/setup/status': self.get_insecure_api_handler(
                 self.do_secure_status),
 
         }
@@ -588,27 +603,27 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
         self.current_session = None
         self.session_cancel_callback = None
         self.session_handlers = {
-            "dummy" : DummySession
+            'dummy' : DummySession
         }
 
         self.secure_handlers = {
-            "/privet/v2/setup/start" : self.do_secure_setup,
-            "/privet/v2/setup/status" : self.do_secure_status
+            '/privet/v2/setup/start' : self.do_secure_setup,
+            '/privet/v2/setup/status' : self.do_secure_status
         }
     def start(self):
         self.wifi_handler.start()
-        self.mdns_wrapper.set_setup_name("RaspberryPi.camera.privet")
+        self.mdns_wrapper.set_setup_name('RaspberryPi.camera.privet')
         self.mdns_wrapper.start()
     @get_only
     def do_ping(self, request, response_func):
-        response_func(200, "{ \"pong\": true }")
+        response_func(200, '{ "pong": true }')
         return True
     @get_only
     def do_public_info(self, request, response_func):
         info = merge_dictionary(
             self.get_common_info(),
             {
-                "stype" : self.session_handlers.keys()
+                'stype' : self.session_handlers.keys()
             })
 
         self.real_send_response(
@@ -617,7 +632,7 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
     @get_only
     def do_info(self, request, response_func):
         specific_info = {
-            "x-privet-token": "sample",
+            'x-privet-token': 'sample',
         }
 
         info = merge_dictionary(
@@ -632,16 +647,16 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
     def do_wifi_switch(self, request, response_func):
         data = json.loads(request.body)
         try:
-            ssid = data["ssid"]
-            passw = data["passw"]
+            ssid = data['ssid']
+            passw = data['passw']
         except KeyError:
-            print "Malformed content: " + repr(data)
+            print 'Malformed content: ' + repr(data)
             self.real_send_response(
-                request, 400, { "error": "invalid_params" })
+                request, 400, { 'error': 'invalid_params' })
             traceback.print_exc()
             return True
 
-        response_func(200, { "ssid": ssid } )
+        response_func(200, { 'ssid': ssid } )
         self.wifi_handler.switch_to_wifi(ssid, passw, None)
         # TODO: Return to normal wifi after timeout (cancelable)
         return True
@@ -652,29 +667,29 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
                              encrypted):
         data = json.loads(request.body)
         try:
-            stype = data["stype"]
-            step = data["step"]
-            package = base64.b64decode(data["package"])
+            stype = data['stype']
+            step = data['step']
+            package = base64.b64decode(data['package'])
         except (KeyError, TypeError):
             traceback.print_exc()
-            print "Malformed content: " + repr(data)
+            print 'Malformed content: ' + repr(data)
             self.real_send_response(
-                request, 400, { "error": "invalid_params" })
+                request, 400, { 'error': 'invalid_params' })
             return True
 
         if self.current_session:
             if client_id != self.current_session.get_client_id():
                 self.real_send_response(
-                    request, 500, { "error": "in_session" })
+                    request, 500, { 'error': 'in_session' })
                 return True
             if stype != self.current_session.get_stype():
                 self.real_send_response(
-                    request, 500, { "error": "invalid_stype" })
+                    request, 500, { 'error': 'invalid_stype' })
                 return True
         else:
             if stype not in self.session_handlers:
                 self.real_send_response(
-                    request, 500, { "error": "invalid_stype" })
+                    request, 500, { 'error': 'invalid_stype' })
                 return True
             self.current_session = self.session_handlers[stype](client_id)
 
@@ -682,17 +697,17 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
             output_package = self.current_session.do_step(step, package)
         except InvalidStepError:
             self.real_send_response(
-                    request, 500, { "error": "invalid_step" })
+                    request, 500, { 'error': 'invalid_step' })
             return True
         except InvalidPackageError:
             self.real_send_response(
-                    request, 500, { "error": "invalid_step" })
+                    request, 500, { 'error': 'invalid_step' })
             return True
 
         return_obj = {
-            "stype" : stype,
-            "step" : step,
-            "package": base64.b64encode(output_package)}
+            'stype' : stype,
+            'step' : step,
+            'package': base64.b64encode(output_package)}
 
         self.real_send_response(
                     request, 200, json.dumps(return_obj))
@@ -710,48 +725,48 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
                 self.session_cancel_callback.cancel()
         else:
             self.real_send_response(
-                request, 400, { "error": "invalid_client_id" })
+                request, 400, { 'error': 'invalid_client_id' })
         return True
     @extract_encryption_params
     @post_only
     @wifi_provisioning
     def do_session_api(self, request, response_func, client_id, encrypted):
         if not encrypted:
-            response_func(400, { "error": "encryption_required" })
+            response_func(400, { 'error': 'encryption_required' })
             return True
 
         if (not self.current_session or
             client_id != self.current_session.client_id):
-            response_func(405, { "error": "invalid_client_id" })
+            response_func(405, { 'error': 'invalid_client_id' })
             return True
 
         try:
             decrypted = self.current_session.decrypt(request.body)
         except EncryptionError:
-            response_func(415, { "error": "decryption_failed" })
+            response_func(415, { 'error': 'decryption_failed' })
             return True
 
         def encrypted_response_func(code, data):
-            if "error" in data:
+            if 'error' in data:
                 self.encrypted_send_response(request, code, data)
             else:
                 self.encrypted_send_response(request, code, {
-                    "api": decrypted["api"],
-                    "response": data})
+                    'api': decrypted['api'],
+                    'response': data})
 
-        if ("api" not in decrypted or "request" not in decrypted
-            or type(decrypted["request"]) != dict):
-            print "Invalid params in API stage"
-            encrypted_response_func(400, { "error": "invalid_params" })
+        if ('api' not in decrypted or 'request' not in decrypted
+            or type(decrypted['request']) != dict):
+            print 'Invalid params in API stage'
+            encrypted_response_func(400, { 'error': 'invalid_params' })
             return True
 
 
-        if decrypted["api"] in self.secure_handlers:
-            self.secure_handlers[decrypted["api"]](request,
+        if decrypted['api'] in self.secure_handlers:
+            self.secure_handlers[decrypted['api']](request,
                                                    encrypted_response_func,
-                                                   decrypted["request"])
+                                                   decrypted['request'])
         else:
-           encrypted_response_func(400, { "error": "unknown_api" })
+           encrypted_response_func(400, { 'error': 'unknown_api' })
 
         self.post_session_cancel()
         return True
@@ -765,63 +780,63 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
         return True
     def do_secure_setup(self, request, response_func, params):
         setup_handlers = {
-            "start": self.do_setup_start,
-            "cancel": self.do_setup_cancel }
+            'start': self.do_setup_start,
+            'cancel': self.do_setup_cancel }
 
-        if not "action" in params:
-            response_func(400, { "error": "invalid_params" })
+        if not 'action' in params:
+            response_func(400, { 'error': 'invalid_params' })
             return
 
-        if params["action"] not in setup:
-            response_func(400, { "error": "invalid_action" })
+        if params['action'] not in setup:
+            response_func(400, { 'error': 'invalid_action' })
             return
 
-        setup[params["action"]](request, response_func, params)
+        setup[params['action']](request, response_func, params)
     def do_secure_status(self, request, response_func, params):
         setup = {
-            "registration" : {
-                "required" : True
+            'registration' : {
+                'required' : True
             },
-            "wifi" : {
-                "required" : True
+            'wifi' : {
+                'required' : True
             }
         }
         if self.on_wifi:
-            setup["wifi"]["status"] = "complete"
-            setup["wifi"]["ssid"] = ""  # TODO(noamsml): Add SSID to status
+            setup['wifi']['status'] = 'complete'
+            setup['wifi']['ssid'] = ''  # TODO(noamsml): Add SSID to status
         else:
-            setup["wifi"]["status"] = "available"
+            setup['wifi']['status'] = 'available'
 
         if self.cloud_device.get_device_id():
-            setup["registration"]["status"] = "complete"
-            setup["registration"]["id"] = self.cloud_device.get_device_id()
+            setup['registration']['status'] = 'complete'
+            setup['registration']['id'] = self.cloud_device.get_device_id()
         else:
-            specific_info["setup"]["registration"] = "available"
+            specific_info['setup']['registration'] = 'available'
 
     def do_setup_start(self, request, response_func, params):
         has_wifi = False
         token = None
 
         try:
-            if "wifi" in params:
+            if 'wifi' in params:
                 has_wifi = True
-                ssid = params["wifi"]["ssid"]
-                passw = params["wifi"]["passphrase"]
+                ssid = params['wifi']['ssid']
+                passw = params['wifi']['passphrase']
 
-            if "registration" in params:
-                token = params["registration"]["ticketID"]
+            if 'registration' in params:
+                token = params['registration']['ticketID']
         except KeyError:
-            print "Invalid params in bootstrap stage"
-            response_func(400, { "error": "invalid_params" })
+            print 'Invalid params in bootstrap stage'
+            response_func(400, { 'error': 'invalid_params' })
             return
 
-        response_func(200, { "ssid" : ssid })
+        response_func(200, { 'ssid' : ssid })
         if has_wifi:
             self.wifi_handler.switch_to_wifi(ssid, passw, token)
         elif token:
             self.cloud_device.register(token)
         else:
-            response_func(400, { "error": "invalid_params" })
+            response_func(400, { 'error': 'invalid_params' })
     def do_setup_cancel(self, request, response_func, params):
         pass
     def handle_request(self, request):
@@ -834,24 +849,24 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
 
         if not handled:
             self.real_send_response(request, 404,
-                                    { "error": "Not found" })
+                                    { 'error': 'Not found' })
     def encrypted_send_response(self, request, code, json):
         self.real_send_response(request, code,
                                 self.current_session.encrypt(json))
     def real_send_response(self, request, code, data):
-        request.write("HTTP/1.1 %d Maybe OK\n" % code)
-        request.write("Content-Type: application/json\n")
-        request.write("Content-Length: %d\n" % len(data))
-        write_data = "\n%s" % data
+        request.write('HTTP/1.1 %d Maybe OK\n' % code)
+        request.write('Content-Type: application/json\n')
+        request.write('Content-Length: %d\n' % len(data))
+        write_data = '\n%s' % data
         request.write(str(write_data));
 
         request.finish()
     def device_state(self):
-        return "idle"
+        return 'idle'
     def  get_common_info(self):
-        return { "version" : "2.0",
-                 "name" : "Sample Device",
-                 "device_state" : self.device_state() }
+        return { 'version' : '2.0',
+                 'name' : 'Sample Device',
+                 'device_state' : self.device_state() }
     def post_session_cancel(self):
         if self.session_cancel_callback:
             self.session_cancel_callback.cancel()
@@ -876,7 +891,7 @@ class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
 state = State()
 state.load()
 
-ioloop = tornado.ioloop.IOLoop.instance()
+ioloop = IOLoop.instance()
 
 
 handler = WebRequestHandler(ioloop, state)
@@ -887,6 +902,6 @@ def logic_stop():
 
 atexit.register(logic_stop)
 
-server = tornado.httpserver.HTTPServer(handler.handle_request)
+server = HTTPServer(handler.handle_request)
 server.listen(8080)
 ioloop.start()