Skip to content

GitLab

T
tangled
Commit 7b6f5dd4 authored by vitalybuka@chromium.org's avatar vitalybuka@chromium.org
Browse files
Options

Fixed gpylint warnings. 

TBR=noamsml
NOTRY=true

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271596 0039d316-1c4b-4281-b951-d872f2087c98
parent 938f37f7
Hide whitespace changes
Inline Side-by-side
Showing with 866 additions and 778 deletions
components/cloud_devices/tools/prototype/prototype.py
View file @ 7b6f5dd4
......@@ -3,18 +3,20 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# 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
"""Prototype of cloud device with support of local API.
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 atexit
import base64
import datetime
import httplib2
import json
import os
import subprocess
......@@ -23,6 +25,7 @@ import traceback
from apiclient.discovery import build_from_document
from apiclient.errors import HttpError
import httplib2
from oauth2client.client import AccessTokenRefreshError
from oauth2client.client import OAuth2WebServerFlow
from oauth2client.file import Storage
......@@ -33,25 +36,26 @@ _OAUTH_SCOPE = 'https://www.googleapis.com/auth/clouddevices'
_API_CLIENT_FILE = 'config.json'
_API_DISCOVERY_FILE = 'discovery.json'
_DEVICE_STATE_FILE = 'device_state.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'
......@@ -65,843 +69,927 @@ 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"
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/'
class DeviceUnregisteredError(Exception):
pass
pass
def ignore_errors(func):
def inner(*args, **kwargs):
try:
func(*args, **kwargs)
except:
print 'Got error in unsafe function:'
traceback.print_exc()
return inner
def inner(*args, **kwargs):
try:
func(*args, **kwargs)
except Exception: # pylint: disable=broad-except
print 'Got error in unsafe function:'
traceback.print_exc()
return inner
class CommandWrapperReal(object):
def __init__(self, cmd):
if type(cmd) == str:
cmd = cmd.split()
self.cmd = cmd
self.process = None
def start(self):
if self.process:
end()
self.process = subprocess.Popen(self.cmd)
def wait(self):
self.process.wait()
def end(self):
if self.process:
self.process.terminate()
"""Command wrapper that executs shell commands."""
def __init__(self, cmd):
if type(cmd) == str:
cmd = cmd.split()
self.cmd = cmd
self.process = None
def start(self):
if self.process:
self.end()
self.process = subprocess.Popen(self.cmd)
def wait(self):
self.process.wait()
def end(self):
if self.process:
self.process.terminate()
class CommandWrapperFake(object):
def __init__(self, cmd):
self.cmd = cmd
def start(self):
print 'Start: ', self.cmd
def wait(self):
print 'Wait: ', self.cmd
def end(self):
print 'End: ', self.cmd
"""Command wrapper that just prints shell commands."""
def __init__(self, cmd):
self.cmd = cmd
def start(self):
print 'Start: ', self.cmd
def wait(self):
print 'Wait: ', self.cmd
def end(self):
print 'End: ', self.cmd
class CloudCommandHandlerFake(object):
def __init__(self, ioloop):
pass
def handle_command(self, command_name, args):
if command_name == 'flashLED':
times = 1
if 'times' in args:
times = int(args['times'])
print 'Flashing LED %d times' % times
"""Prints devices commands without execution."""
def __init__(self, ioloop):
pass
def handle_command(self, command_name, args):
if command_name == 'flashLED':
times = 1
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':
times = 1
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):
self.set_led(times*2, True)
def set_led(self, times, value):
if not times:
return
file_trigger = open(os.path.join(led_path, 'brightness'), 'w')
if value:
file_trigger.write('1')
else:
file_trigger.write('0')
file_trigger.close()
self.ioloop.add_timeout(datetime.timedelta(milliseconds = 500),
lambda: self.set_led(times - 1, not value))
"""Executes device commands."""
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')
def __init__(self, ioloop, state, delegate):
self.ioloop = ioloop
self.state = state
self.delegate = delegate
def start(self):
raise Exception('Start not implemented!')
def get_ssid(self):
raise Exception('Get SSID not implemented!')
# Note that by using CommandWrapperFake, you can run WifiHandlerReal on fake
# devices for testing the wifi-specific logic
class WifiHandlerReal(WifiHandler):
def __init__(self, ioloop, state, delegate):
super(WifiHandlerReal, self).__init__(ioloop, state, delegate)
self.hostapd = CommandWrapper(hostapd_cmd)
self.wpa_supplicant = CommandWrapper(wpa_supplicant_cmd)
self.dhcpd = CommandWrapper(dhcpd_cmd)
def start(self):
if self.state.has_wifi():
self.switch_to_wifi(self.state.ssid(),
self.state.password(),
None)
else:
self.start_hostapd()
def start_hostapd(self):
self.hostapd.start()
time.sleep(3)
run_command(ifconfig_cmd)
self.dhcpd.start()
def switch_to_wifi(self, ssid, passwd, token):
try:
wpa_config = open(wpa_supplicant_conf, 'w')
wpa_config.write(wpa_supplicant_template % (ssid, passwd))
wpa_config.close()
self.hostapd.end()
self.dhcpd.end()
self.wpa_supplicant.start()
run_command(dhclient_release)
run_command(dhclient_renew)
self.state.set_wifi(ssid,passwd)
self.delegate.on_wifi_connected(token)
except DeviceUnregisteredError:
self.state.reset()
self.wpa_supplicant.end()
self.start_hostapd()
def stop(self):
self.hostapd.end()
self.wpa_supplicant.end()
self.dhcpd.end()
def get_ssid(self):
return self.state.get_ssid()
def __init__(self, ioloop):
self.ioloop = ioloop
def handle_command(self, command_name, args):
if command_name == 'flashLED':
times = 1
if 'times' in args:
times = int(args['times'])
print 'Really flashing LED %d times' % times
self.flash_led(times)
class WifiHandlerPassthrough(WifiHandler):
def __init__(self, ioloop, state, delegate):
super(WifiHandlerPassthrough, self).__init__(ioloop, state, delegate)
def start(self):
self.delegate.on_wifi_connected(None)
def switch_to_wifi(self, ssid, passwd, token):
raise Exception('Should not be reached')
def get_ssid(self):
return 'dummy'
@ignore_errors
def flash_led(self, times):
self.set_led(times*2, True)
def set_led(self, times, value):
"""Set led value."""
if not times:
return
def setup_fake():
print 'Called setup'
file_trigger = open(os.path.join(led_path, 'brightness'), 'w')
if value:
file_trigger.write('1')
else:
file_trigger.write('0')
def setup_real():
file_trigger = open(os.path.join(led_path, 'trigger'), 'w')
file_trigger.write('none')
file_trigger.close()
if os.path.exists('on_real_device'):
CommandWrapper = CommandWrapperReal
CommandWrapperMDns = CommandWrapperReal
CloudCommandHandler = CloudCommandHandlerReal
WifiHandler = WifiHandlerReal
setup_real()
else:
CommandWrapper = CommandWrapperFake
CommandWrapperMDns = CommandWrapperReal
CloudCommandHandler = CloudCommandHandlerFake
WifiHandler = WifiHandlerPassthrough
setup_fake()
class State:
def __init__(self):
self.oauth_storage_ = Storage('oauth_creds')
self.clear()
def clear(self):
self.credentials_ = None
self.has_credentials_ = False
self.has_wifi_ = False
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')
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')
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']
if self.has_credentials_:
self.credentials_ = self.oauth_storage_.get()
def set_credentials(self, credentials, device_id):
self.device_id_ = device_id
self.credentials_ = credentials
self.has_credentials_ = True
self.dump()
def set_wifi(self, ssid, password):
self.ssid_ = ssid
self.password_ = password
self.has_wifi_ = True
self.dump()
def has_wifi(self):
return self.has_wifi_
def has_credentials(self):
return self.has_credentials_
def credentials(self):
return self.credentials_
def ssid(self):
return self.ssid_
def password(self):
return self.password_
def device_id(self):
return self.device_id_
def run_command(cmd):
wrapper = CommandWrapper(cmd)
self.ioloop.add_timeout(datetime.timedelta(milliseconds=500),
lambda: self.set_led(times - 1, not value))
class WifiHandler(object):
"""Base class for wifi handlers."""
class Delegate(object):
def on_wifi_connected(self, unused_token):
"""Token is optional, and all delegates should support it being None."""
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!')
def get_ssid(self):
raise Exception('Get SSID not implemented!')
class WifiHandlerReal(WifiHandler):
"""Real wifi handler.
Note that by using CommandWrapperFake, you can run WifiHandlerReal on fake
devices for testing the wifi-specific logic.
"""
def __init__(self, ioloop, state, delegate):
super(WifiHandlerReal, self).__init__(ioloop, state, delegate)
self.command_wrapper = CommandWrapperReal
self.hostapd = self.CommandWrapper(hostapd_cmd)
self.wpa_supplicant = self.CommandWrapper(wpa_supplicant_cmd)
self.dhcpd = self.CommandWrapper(dhcpd_cmd)
def start(self):
if self.state.has_wifi():
self.switch_to_wifi(self.state.ssid(), self.state.password(), None)
else:
self.start_hostapd()
def start_hostapd(self):
self.hostapd.start()
time.sleep(3)
self.run_command(ifconfig_cmd)
self.dhcpd.start()
def switch_to_wifi(self, ssid, passwd, token):
try:
wpa_config = open(wpa_supplicant_conf, 'w')
wpa_config.write(wpa_supplicant_template % (ssid, passwd))
wpa_config.close()
self.hostapd.end()
self.dhcpd.end()
self.wpa_supplicant.start()
self.run_command(dhclient_release)
self.run_command(dhclient_renew)
self.state.set_wifi(ssid, passwd)
self.delegate.on_wifi_connected(token)
except DeviceUnregisteredError:
self.state.reset()
self.wpa_supplicant.end()
self.start_hostapd()
def stop(self):
self.hostapd.end()
self.wpa_supplicant.end()
self.dhcpd.end()
def get_ssid(self):
return self.state.get_ssid()
def run_command(self, cmd):
wrapper = self.command_wrapper(cmd)
wrapper.start()
wrapper.wait()
class MDnsWrapper:
def __init__(self):
self.avahi_wrapper = None
self.setup_name = None
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]
if self.setup_name:
cmd.append('setup=' + self.setup_name)
return cmd
def run_command(self):
if self.avahi_wrapper:
self.avahi_wrapper.end()
self.avahi_wrapper.wait()
self.avahi_wrapper = CommandWrapperMDns(self.get_command())
self.avahi_wrapper.start()
def set_id(self, device_id):
self.device_id = device_id
if self.started:
self.run_command()
def set_setup_name(self, setup_name):
self.setup_name = setup_name
if self.started:
self.run_command()
class CloudDevice:
class Delegate:
def on_device_started(self):
raise Exception('Not implemented: Device started')
def on_device_stopped(self):
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_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']
if not os.path.isfile(_API_DISCOVERY_FILE):
raise Exception('Download https://developers.google.com/'
'cloud-devices/v1/discovery.json');
f = open('discovery.json')
discovery = f.read()
f.close()
self.gcd = build_from_document(
discovery, developerKey=self.api_key, http=self.http)
self.ioloop = ioloop
self.active = True
self.device_id = None
self.credentials = None
self.delegate = delegate
self.command_handler = CloudCommandHandler(ioloop)
def try_start(self, token): # Token may be null
if self.state.has_credentials():
self.credentials = self.state.credentials()
self.device_id = self.state.device_id()
self.run_device()
elif token:
self.register(token)
else:
print 'Device not registered and has no credentials.'
print 'Waiting for registration.'
def register(self, token):
resource = {
'deviceDraft': DEVICE_DRAFT,
'oauthClientId': self.oauth_client_id
}
self.gcd.registrationTickets().patch(registrationTicketId=token,
body=resource).execute()
class WifiHandlerPassthrough(WifiHandler):
"""Passthrough wifi handler."""
def __init__(self, ioloop, state, delegate):
super(WifiHandlerPassthrough, self).__init__(ioloop, state, delegate)
def start(self):
self.delegate.on_wifi_connected(None)
def switch_to_wifi(self, unused_ssid, unused_passwd, unused_token):
raise Exception('Should not be reached')
def get_ssid(self):
return 'dummy'
class State(object):
"""Device state."""
def __init__(self):
self.oauth_storage_ = Storage('oauth_creds')
self.clear()
def clear(self):
self.credentials_ = None
self.has_credentials_ = False
self.has_wifi_ = False
self.ssid_ = ''
self.password_ = ''
self.device_id_ = ''
def reset(self):
self.clear()
self.dump()
def dump(self):
"""Saves device state to file."""
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_FILE, '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_FILE):
statefile = open(_DEVICE_STATE_FILE, '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']
if self.has_credentials_:
self.credentials_ = self.oauth_storage_.get()
def set_credentials(self, credentials, device_id):
self.device_id_ = device_id
self.credentials_ = credentials
self.has_credentials_ = True
self.dump()
def set_wifi(self, ssid, password):
self.ssid_ = ssid
self.password_ = password
self.has_wifi_ = True
self.dump()
def has_wifi(self):
return self.has_wifi_
def has_credentials(self):
return self.has_credentials_
def credentials(self):
return self.credentials_
def ssid(self):
return self.ssid_
def password(self):
return self.password_
def device_id(self):
return self.device_id_
class MDnsWrapper(object):
"""Handles mDNS requests to device."""
def __init__(self, command_wrapper):
self.command_wrapper = command_wrapper
self.avahi_wrapper = None
self.setup_name = None
self.device_id = ''
self.started = False
def start(self):
self.started = True
self.run_command()
finalTicket = self.gcd.registrationTickets().finalize(
registrationTicketId=token).execute()
def get_command(self):
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)
return cmd
authorization_code = finalTicket['robotAccountAuthorizationCode']
flow = OAuth2WebServerFlow(
self.oauth_client_id, self.oauth_secret, _OAUTH_SCOPE,
redirect_uri='oob')
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
def run_command(self):
if self.avahi_wrapper:
self.avahi_wrapper.end()
self.avahi_wrapper.wait()
self.run_device()
def run_device(self):
self.credentials.authorize(self.http)
self.avahi_wrapper = self.command_wrapper(self.get_command())
self.avahi_wrapper.start()
def set_id(self, device_id):
self.device_id = device_id
if self.started:
self.run_command()
def set_setup_name(self, setup_name):
self.setup_name = setup_name
if self.started:
self.run_command()
class CloudDevice(object):
"""Handles device registration and commands."""
class Delegate(object):
def on_device_started(self):
raise Exception('Not implemented: Device started')
def on_device_stopped(self):
raise Exception('Not implemented: Device stopped')
def __init__(self, ioloop, state, command_wrapper, 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_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']
if not os.path.isfile(_API_DISCOVERY_FILE):
raise Exception('Download https://developers.google.com/'
'cloud-devices/v1/discovery.json')
f = open(_API_DISCOVERY_FILE)
discovery = f.read()
f.close()
self.gcd = build_from_document(discovery, developerKey=self.api_key,
http=self.http)
self.ioloop = ioloop
self.active = True
self.device_id = None
self.credentials = None
self.delegate = delegate
self.command_handler = command_wrapper(ioloop)
def try_start(self, token):
"""Tries start or register device."""
if self.state.has_credentials():
self.credentials = self.state.credentials()
self.device_id = self.state.device_id()
self.run_device()
elif token:
self.register(token)
else:
print 'Device not registered and has no credentials.'
print 'Waiting for registration.'
def register(self, token):
"""Register device."""
resource = {
'deviceDraft': DEVICE_DRAFT,
'oauthClientId': self.oauth_client_id
}
self.gcd.registrationTickets().patch(registration_ticke_id=token,
body=resource).execute()
final_ticket = self.gcd.registrationTickets().finalize(
registration_ticke_id=token).execute()
authorization_code = final_ticket['robotAccountAuthorizationCode']
flow = OAuth2WebServerFlow(self.oauth_client_id, self.oauth_secret,
_OAUTH_SCOPE, redirect_uri='oob')
self.credentials = flow.step2_exchange(authorization_code)
self.device_id = final_ticket['deviceDraft']['id']
self.state.set_credentials(self.credentials, self.device_id)
print 'Registered with device_id ', self.device_id
self.run_device()
def run_device(self):
"""Runs device."""
self.credentials.authorize(self.http)
try:
self.gcd.devices().get(deviceId=self.device_id).execute()
except HttpError, e:
# Pretty good indication the device was deleted
if e.resp.status == 404:
raise DeviceUnregisteredError()
except AccessTokenRefreshError:
raise DeviceUnregisteredError()
self.check_commands()
self.delegate.on_device_started()
def check_commands(self):
"""Checks device commands."""
if not self.active:
return
print 'Checking commands...'
commands = self.gcd.commands().list(deviceId=self.device_id,
state='queued').execute()
if 'commands' in commands:
print 'Found ', len(commands['commands']), ' commands'
vendor_command_name = None
for command in commands['commands']:
try:
dev=self.gcd.devices().get(deviceId=self.device_id).execute()
except HttpError, e:
# Pretty good indication the device was deleted
if e.resp.status == 404:
raise DeviceUnregisteredError()
except AccessTokenRefreshError:
raise DeviceUnregisteredError()
self.check_commands()
self.delegate.on_device_started()
def check_commands(self):
if not self.active:
return
print 'Checking commands...'
commands = self.gcd.commands().list(deviceId=self.device_id,
state='queued').execute()
if 'commands' in commands:
print 'Found ', len(commands['commands']), ' commands'
args = {}
vendorCommandName = None
for command in commands['commands']:
try:
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 repr(command)
vendorCommandName = None
if vendorCommandName:
self.command_handler.handle_command(
vendorCommandName,
parameters)
self.gcd.commands().patch(commandId = command['id'],
body={'state': 'done'}).execute()
else:
print 'Found no commands'
self.ioloop.add_timeout(datetime.timedelta(milliseconds=1000),
self.check_commands)
def stop(self):
self.active = False
def get_device_id(self):
return self.device_id
if command['name'].startswith('base._'):
vendor_command_name = command['name'][len('base._'):]
if 'parameters' in command:
parameters = command['parameters']
else:
parameters = {}
else:
vendor_command_name = None
except KeyError:
print 'Could not parse vendor command ',
print repr(command)
vendor_command_name = None
if vendor_command_name:
self.command_handler.handle_command(vendor_command_name, parameters)
self.gcd.commands().patch(commandId=command['id'],
body={'state': 'done'}).execute()
else:
print 'Found no commands'
self.ioloop.add_timeout(datetime.timedelta(milliseconds=1000),
self.check_commands)
def stop(self):
self.active = False
def get_device_id(self):
return self.device_id
def get_only(f):
def inner(self, request, response_func, *args):
if request.method != 'GET':
return False
return f(self, request, response_func, *args)
return inner
def inner(self, request, response_func, *args):
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':
return False
return f(self, request, response_func, *args)
return inner
def inner(self, request, response_func, *args):
# if request.method != 'POST':
# return False
return f(self, request, response_func, *args)
return inner
def wifi_provisioning(f):
def inner(self, request, response_func, *args):
if self.on_wifi:
return False
return f(self, request, response_func, *args)
return inner
def inner(self, request, response_func, *args):
if self.on_wifi:
return False
return f(self, request, response_func, *args)
return inner
def post_provisioning(f):
def inner(self, request, response_func, *args):
if not self.on_wifi:
return False
return f(self, request, response_func, *args)
return inner
def inner(self, request, response_func, *args):
if not self.on_wifi:
return False
return f(self, request, response_func, *args)
return inner
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')
else:
encrypted = False
except (KeyError, TypeError):
print 'Missing client parameters in headers'
response_func(400, { 'error': 'missing_client_parameters' })
return True
"""Extracts privet encription header and pass as parameter into function."""
def inner(self, request, response_func, *args):
"""Extracts privet encription header."""
try:
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'})
return True
return f(self, request, response_func, client_id, encrypted, *args)
return inner
return f(self, request, response_func, client_id, encrypted, *args)
return inner
def merge_dictionary(a, b):
result = {}
for k in a:
result[k] = a[k]
for k in b:
result[k] = b[k]
return result
class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
"""Handles HTTP requests."""
class InvalidStepError(Exception):
class InvalidStepError(Exception):
pass
class InvalidPackageError(Exception):
class InvalidPackageError(Exception):
pass
class EncryptionError(Exception):
class EncryptionError(Exception):
pass
class CancelableClosure:
class CancelableClosure(object):
"""Allows to cancel callbacks."""
def __init__(self, function):
self.function = function
self.function = function
def __call__(self):
if self.function:
return self.function
return None
if self.function:
return self.function
return None
def cancel(self):
self.function = None
self.function = None
class DummySession(object):
"""Handles sessions."""
class DummySession:
def __init__(self, client_id):
self.client_id = client_id
self.key = None
def do_step(self, step, package):
if step != 0:
raise InvalidStepError()
self.client_id = client_id
self.key = None
def do_step(self, step, package):
if step != 0:
raise self.InvalidStepError()
self.key = package
return self.key
self.key = package
return self.key
def decrypt(self, cyphertext):
return json.loads(cyphertext[len(self.key):])
return json.loads(cyphertext[len(self.key):])
def encrypt(self, plain_data):
return self.key + json.dumps(plain_data)
return self.key + json.dumps(plain_data)
def get_client_id(self):
return client_id
return self.client_id
def get_stype(self):
return 'dummy'
return 'dummy'
def __init__(self, ioloop, state):
if os.path.exists('on_real_device'):
mdns_wrappers = CommandWrapperReal
cloud_wrapper = CloudCommandHandlerReal
wifi_handler = WifiHandlerReal
self.setup_real()
else:
mdns_wrappers = CommandWrapperReal
cloud_wrapper = CloudCommandHandlerFake
wifi_handler = WifiHandlerPassthrough
self.setup_fake()
self.cloud_device = CloudDevice(ioloop, state, cloud_wrapper, self)
self.wifi_handler = wifi_handler(ioloop, state, self)
self.mdns_wrapper = MDnsWrapper(mdns_wrappers)
self.on_wifi = False
self.registered = False
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(self.do_secure_setup_start),
'/privet/v2/setup/cancel':
self.get_insecure_api_handler(self.do_secure_setup_cancel),
'/privet/v2/setup/status':
self.get_insecure_api_handler(self.do_secure_status),
}
class WebRequestHandler(WifiHandler.Delegate, CloudDevice.Delegate):
def __init__(self, ioloop, state):
self.cloud_device = CloudDevice(ioloop, state, self)
self.wifi_handler = WifiHandler(ioloop, state, self)
self.mdns_wrapper = MDnsWrapper()
self.on_wifi = False
self.registered = False
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(
self.do_secure_setup),
'/privet/v2/setup/status': self.get_insecure_api_handler(
self.do_secure_status),
self.current_session = None
self.session_cancel_callback = None
self.session_handlers = {
'dummy': self.DummySession
}
}
self.secure_handlers = {
'/privet/v2/setup/start': self.do_secure_setup_start,
'/privet/v2/setup/cancel': self.do_secure_setup_cancel,
'/privet/v2/setup/status': self.do_secure_status
}
self.current_session = None
self.session_cancel_callback = None
self.session_handlers = {
'dummy' : DummySession
}
@staticmethod
def setup_fake():
print 'Called setup'
self.secure_handlers = {
'/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.start()
@get_only
def do_ping(self, request, response_func):
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()
})
self.real_send_response(
request, 200, json.dumps(info))
@post_provisioning
@get_only
def do_info(self, request, response_func):
specific_info = {
'x-privet-token': 'sample',
}
@staticmethod
def setup_real():
file_trigger = open(os.path.join(led_path, 'trigger'), 'w')
file_trigger.write('none')
file_trigger.close()
info = merge_dictionary(
self.get_common_info(),
specific_info
)
self.real_send_response(
request, 200, json.dumps(info))
@post_only
@wifi_provisioning
def do_wifi_switch(self, request, response_func):
data = json.loads(request.body)
try:
ssid = data['ssid']
passw = data['passw']
except KeyError:
print 'Malformed content: ' + repr(data)
self.real_send_response(
request, 400, { 'error': 'invalid_params' })
traceback.print_exc()
return True
response_func(200, { 'ssid': ssid } )
self.wifi_handler.switch_to_wifi(ssid, passw, None)
# TODO: Return to normal wifi after timeout (cancelable)
def start(self):
self.wifi_handler.start()
self.mdns_wrapper.set_setup_name('RaspberryPi.camera.privet')
self.mdns_wrapper.start()
@get_only
def do_ping(self, unused_request, response_func):
response_func(200, '{ "pong": true }')
return True
@get_only
def do_public_info(self, request, unused_response_func):
info = self.get_common_info().items() + {
'stype': self.session_handlers.keys()}.items()
self.real_send_response(request, 200, json.dumps(info))
@post_provisioning
@get_only
def do_info(self, request, unused_response_func):
specific_info = {'x-privet-token': 'sample'}
info = self.get_common_info().items() + specific_info.items()
self.real_send_response(request, 200, json.dumps(info))
@post_only
@wifi_provisioning
def do_wifi_switch(self, request, response_func):
"""Handles /deprecated/wifi/switch requests."""
data = json.loads(request.body)
try:
ssid = data['ssid']
passw = data['passw']
except KeyError:
print 'Malformed content: ' + repr(data)
self.real_send_response(request, 400, {'error': 'invalid_params'})
traceback.print_exc()
return True
response_func(200, {'ssid': ssid})
self.wifi_handler.switch_to_wifi(ssid, passw, None)
# TODO(noamsml): Return to normal wifi after timeout (cancelable)
return True
@extract_encryption_params
@post_only
@wifi_provisioning
def do_session_handshake(self, request, unused_response_func, client_id,
unused_encrypted):
"""Handles /privet/v2/session/handshake requests."""
data = json.loads(request.body)
try:
stype = data['stype']
step = data['step']
package = base64.b64decode(data['package'])
except (KeyError, TypeError):
traceback.print_exc()
print 'Malformed content: ' + repr(data)
self.real_send_response(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'})
return True
@extract_encryption_params
@post_only
@wifi_provisioning
def do_session_handshake(self, request, response_func, client_id,
encrypted):
data = json.loads(request.body)
try:
stype = data['stype']
step = data['step']
package = base64.b64decode(data['package'])
except (KeyError, TypeError):
traceback.print_exc()
print 'Malformed content: ' + repr(data)
self.real_send_response(
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' })
return True
if stype != self.current_session.get_stype():
self.real_send_response(
request, 500, { 'error': 'invalid_stype' })
return True
else:
if stype not in self.session_handlers:
self.real_send_response(
request, 500, { 'error': 'invalid_stype' })
return True
self.current_session = self.session_handlers[stype](client_id)
try:
output_package = self.current_session.do_step(step, package)
except InvalidStepError:
self.real_send_response(
request, 500, { 'error': 'invalid_step' })
return True
except InvalidPackageError:
self.real_send_response(
request, 500, { 'error': 'invalid_step' })
return True
return_obj = {
'stype' : stype,
'step' : step,
'package': base64.b64encode(output_package)}
self.real_send_response(
request, 200, json.dumps(return_obj))
self.post_session_cancel()
if stype != self.current_session.get_stype():
self.real_send_response(request, 500, {'error': 'invalid_stype'})
return True
@extract_encryption_params
@post_only
@wifi_provisioning
def do_session_cancel(self, request, response_func, client_id,
encrypted):
if client_id == self.current_session.client_id:
self.current_session = None
if self.session_cancel_callback:
self.session_cancel_callback.cancel()
else:
self.real_send_response(
request, 400, { 'error': 'invalid_client_id' })
else:
if stype not in self.session_handlers:
self.real_send_response(request, 500, {'error': 'invalid_stype'})
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' })
return True
if (not self.current_session or
client_id != self.current_session.client_id):
response_func(405, { 'error': 'invalid_client_id' })
return True
self.current_session = self.session_handlers[stype](client_id)
try:
output_package = self.current_session.do_step(step, package)
except self.InvalidStepError:
self.real_send_response(request, 500, {'error': 'invalid_step'})
return True
except self.InvalidPackageError:
self.real_send_response(request, 500, {'error': 'invalid_step'})
return True
return_obj = {
'stype': stype,
'step': step,
'package': base64.b64encode(output_package)
}
self.real_send_response(request, 200, json.dumps(return_obj))
self.post_session_cancel()
return True
@extract_encryption_params
@post_only
@wifi_provisioning
def do_session_cancel(self, request, unused_response_func, client_id,
unused_encrypted):
if client_id == self.current_session.client_id:
self.current_session = None
if self.session_cancel_callback:
self.session_cancel_callback.cancel()
else:
self.real_send_response(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):
"""Handles /privet/v2/session/api requests."""
if not encrypted:
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'})
return True
try:
decrypted = self.current_session.decrypt(request.body)
except self.EncryptionError:
response_func(415, {'error': 'decryption_failed'})
return True
def encrypted_response_func(code, data):
if 'error' in data:
self.encrypted_send_response(request, code, data)
else:
self.encrypted_send_response(request, code, {
'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'})
return True
if decrypted['api'] in self.secure_handlers:
self.secure_handlers[decrypted['api']](request,
encrypted_response_func,
decrypted['request'])
else:
encrypted_response_func(400, {'error': 'unknown_api'})
self.post_session_cancel()
return True
def get_insecure_api_handler(self, handler):
def inner(request, func):
return self.insecure_api_handler(request, func, handler)
return inner
try:
decrypted = self.current_session.decrypt(request.body)
except EncryptionError:
response_func(415, { 'error': 'decryption_failed' })
return True
def encrypted_response_func(code, data):
if 'error' in data:
self.encrypted_send_response(request, code, data)
else:
self.encrypted_send_response(request, code, {
'api': decrypted['api'],
'response': data})
@post_only
def insecure_api_handler(self, request, response_func, handler):
real_params = json.loads(request.body) if request.body else {}
handler(request, response_func, real_params)
return True
def do_secure_status(self, unused_request, response_func, unused_params):
"""Handles /privet/v2/setup/status requests."""
setup = {
'registration': {
'required': True
},
'wifi': {
'required': True
}
}
if self.on_wifi:
setup['wifi']['status'] = 'complete'
setup['wifi']['ssid'] = '' # TODO(noamsml): Add SSID to status
else:
setup['wifi']['status'] = 'available'
if self.cloud_device.get_device_id():
setup['registration']['status'] = 'complete'
setup['registration']['id'] = self.cloud_device.get_device_id()
else:
setup['registration']['status'] = 'available'
response_func(200, setup)
def do_secure_setup_start(self, unused_request, response_func, params):
"""Handles /privet/v2/setup/start requests."""
has_wifi = False
token = None
try:
if 'wifi' in params:
has_wifi = True
ssid = params['wifi']['ssid']
passw = params['wifi']['passphrase']
if 'registration' in params:
token = params['registration']['ticketID']
except KeyError:
print 'Invalid params in bootstrap stage'
response_func(400, {'error': 'invalid_params'})
return
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'})
return
self.do_secure_status(unused_request, response_func, params)
def do_secure_setup_cancel(self, request, response_func, params):
pass
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
def handle_request(self, request):
def response_func(code, data):
self.real_send_response(request, code, json.dumps(data))
handled = False
if request.path in self.handlers:
handled = self.handlers[request.path](request, response_func)
if not handled:
self.real_send_response(request, 404, {'error': 'Not found'})
def encrypted_send_response(self, request, code, data):
self.real_send_response(request, code,
self.current_session.encrypt(data))
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(str(write_data))
request.finish()
def device_state(self):
return 'idle'
def get_common_info(self):
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()
self.session_cancel_callback = self.CancelableClosure(self.session_cancel)
self.ioloop.add_timeout(datetime.timedelta(minutes=2),
self.session_cancel_callback)
if decrypted['api'] in self.secure_handlers:
self.secure_handlers[decrypted['api']](request,
encrypted_response_func,
decrypted['request'])
else:
encrypted_response_func(400, { 'error': 'unknown_api' })
def session_cancel(self):
self.current_session = None
self.post_session_cancel()
return True
def get_insecure_api_handler(self, handler):
return lambda request, response_func: self.insecure_api_handler(
request, response_func, handler)
@post_only
def insecure_api_handler(self, request, response_func, handler):
real_params = json.loads(request.body)
handler(request, response_func, real_params)
return True
def do_secure_setup(self, request, response_func, params):
setup_handlers = {
'start': self.do_setup_start,
'cancel': self.do_setup_cancel }
if not 'action' in params:
response_func(400, { 'error': 'invalid_params' })
return
if params['action'] not in setup:
response_func(400, { 'error': 'invalid_action' })
return
setup[params['action']](request, response_func, params)
def do_secure_status(self, request, response_func, params):
setup = {
'registration' : {
'required' : True
},
'wifi' : {
'required' : True
}
}
if self.on_wifi:
setup['wifi']['status'] = 'complete'
setup['wifi']['ssid'] = '' # TODO(noamsml): Add SSID to status
else:
setup['wifi']['status'] = 'available'
if 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'
def do_setup_start(self, request, response_func, params):
has_wifi = False
token = None
# WifiHandler.Delegate implementation
def on_wifi_connected(self, token):
self.mdns_wrapper.set_setup_name(None)
self.cloud_device.try_start(token)
self.on_wifi = True
try:
if 'wifi' in params:
has_wifi = True
ssid = params['wifi']['ssid']
passw = params['wifi']['passphrase']
def on_device_started(self):
self.mdns_wrapper.set_id(self.cloud_device.get_device_id())
if 'registration' in params:
token = params['registration']['ticketID']
except KeyError:
print 'Invalid params in bootstrap stage'
response_func(400, { 'error': 'invalid_params' })
return
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' })
def do_setup_cancel(self, request, response_func, params):
pass
def handle_request(self, request):
def response_func(code, data):
self.real_send_response(request, code, json.dumps(data))
handled = False
if request.path in self.handlers:
handled = self.handlers[request.path](request, response_func)
if not handled:
self.real_send_response(request, 404,
{ '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(str(write_data));
request.finish()
def device_state(self):
return 'idle'
def get_common_info(self):
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()
self.session_cancel_callback = CancelableClosure(self.session_cancel)
self.ioloop.add_timeout(datetime.timedelta(minutes=2),
self.session_cancel_callback)
def session_cancel(self):
self.current_session = None
# WifiHandler.Delegate implementation
def on_wifi_connected(self, token):
self.mdns_wrapper.set_setup_name(None)
self.cloud_device.try_start(token)
self.on_wifi = True
def on_device_started(self):
self.mdns_wrapper.set_id(self.cloud_device.get_device_id())
def on_device_stopped(self):
pass
def stop(self):
self.wifi_handler.stop()
self.cloud_device.stop()
def on_device_stopped(self):
pass
state = State()
state.load()
def stop(self):
self.wifi_handler.stop()
self.cloud_device.stop()
ioloop = IOLoop.instance()
def main():
state = State()
state.load()
handler = WebRequestHandler(ioloop, state)
handler.start()
ioloop = IOLoop.instance()
def logic_stop():
handler = WebRequestHandler(ioloop, state)
handler.start()
def logic_stop():
handler.stop()
atexit.register(logic_stop)
server = HTTPServer(handler.handle_request)
server.listen(8080)
atexit.register(logic_stop)
ioloop.start()
server = HTTPServer(handler.handle_request)
server.listen(8080)
ioloop.start()
if __name__ == '__main__':
main()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment