Lines Matching refs:self
123 def __init__(self, cmd):
126 self.cmd = cmd
127 self.cmd_str = ' '.join(cmd)
128 self.process = None
130 def start(self):
131 print 'Start: ', self.cmd_str
132 if self.process:
133 self.end()
134 self.process = subprocess.Popen(self.cmd)
136 def wait(self):
137 print 'Wait: ', self.cmd_str
138 self.process.wait()
140 def end(self):
141 print 'End: ', self.cmd_str
142 if self.process:
143 self.process.terminate()
149 def __init__(self, cmd):
150 self.cmd_str = ' '.join(cmd)
152 def start(self):
153 print 'Fake start: ', self.cmd_str
155 def wait(self):
156 print 'Fake wait: ', self.cmd_str
158 def end(self):
159 print 'Fake end: ', self.cmd_str
165 def __init__(self, ioloop):
168 def handle_command(self, command_name, args):
179 def __init__(self, ioloop, led_path):
180 self.ioloop = ioloop
181 self.led_path = led_path
183 def handle_command(self, command_name, args):
189 self.flash_led(times)
192 def flash_led(self, times):
193 self.set_led(times*2, True)
195 def set_led(self, times, value):
200 file_trigger = open(os.path.join(self.led_path, 'brightness'), 'w')
209 self.ioloop.add_timeout(datetime.timedelta(milliseconds=500),
210 lambda: self.set_led(times - 1, not value))
218 def on_wifi_connected(self, unused_token):
222 def __init__(self, ioloop, state, config, setup_ssid, delegate):
223 self.ioloop = ioloop
224 self.state = state
225 self.delegate = delegate
226 self.setup_ssid = setup_ssid
227 self.interface = config['wireless_interface']
229 def start(self):
232 def get_ssid(self):
243 def __init__(self, ioloop, state, config, setup_ssid, delegate):
244 super(WifiHandlerReal, self).__init__(ioloop, state, config,
248 self.command_wrapper = CommandWrapperFake
250 self.command_wrapper = CommandWrapperReal
251 self.hostapd = self.command_wrapper(hostapd_cmd)
252 self.wpa_supplicant = self.command_wrapper(
253 wpa_supplicant_cmd % self.interface)
254 self.dhcpd = self.command_wrapper(dhcpd_cmd)
256 def start(self):
257 if self.state.has_wifi():
258 self.switch_to_wifi(self.state.ssid(), self.state.password(), None)
260 self.start_hostapd()
262 def start_hostapd(self):
264 hostapd_config.write(hostapd_template % (self.interface, self.setup_ssid))
267 self.hostapd.start()
269 self.run_command(ifconfig_cmd % self.interface)
270 self.dhcpd.start()
272 def switch_to_wifi(self, ssid, passwd, token):
275 udhcpd_config.write(udhcpd_template % self.interface)
282 self.hostapd.end()
283 self.dhcpd.end()
284 self.wpa_supplicant.start()
285 self.run_command(dhclient_release % self.interface)
286 self.run_command(dhclient_renew % self.interface)
288 self.state.set_wifi(ssid, passwd)
289 self.delegate.on_wifi_connected(token)
291 self.state.reset()
292 self.wpa_supplicant.end()
293 self.start_hostapd()
295 def stop(self):
296 self.hostapd.end()
297 self.wpa_supplicant.end()
298 self.dhcpd.end()
300 def get_ssid(self):
301 return self.state.get_ssid()
303 def run_command(self, cmd):
304 wrapper = self.command_wrapper(cmd)
312 def __init__(self, ioloop, state, config, setup_ssid, delegate):
313 super(WifiHandlerPassthrough, self).__init__(ioloop, state, config,
316 def start(self):
317 self.delegate.on_wifi_connected(None)
319 def switch_to_wifi(self, unused_ssid, unused_passwd, unused_token):
322 def stop(self):
325 def get_ssid(self):
332 def __init__(self):
333 self.oauth_storage_ = Storage('oauth_creds')
334 self.clear()
336 def clear(self):
337 self.credentials_ = None
338 self.has_credentials_ = False
339 self.has_wifi_ = False
340 self.ssid_ = ''
341 self.password_ = ''
342 self.device_id_ = ''
344 def reset(self):
345 self.clear()
346 self.dump()
348 def dump(self):
351 'has_credentials': self.has_credentials_,
352 'has_wifi': self.has_wifi_,
353 'ssid': self.ssid_,
354 'password': self.password_,
355 'device_id': self.device_id_
361 if self.has_credentials_:
362 self.oauth_storage_.put(self.credentials_)
364 def load(self):
370 self.has_credentials_ = json_obj['has_credentials']
371 self.has_wifi_ = json_obj['has_wifi']
372 self.ssid_ = json_obj['ssid']
373 self.password_ = json_obj['password']
374 self.device_id_ = json_obj['device_id']
376 if self.has_credentials_:
377 self.credentials_ = self.oauth_storage_.get()
379 def set_credentials(self, credentials, device_id):
380 self.device_id_ = device_id
381 self.credentials_ = credentials
382 self.has_credentials_ = True
383 self.dump()
385 def set_wifi(self, ssid, password):
386 self.ssid_ = ssid
387 self.password_ = password
388 self.has_wifi_ = True
389 self.dump()
391 def has_wifi(self):
392 return self.has_wifi_
394 def has_credentials(self):
395 return self.has_credentials_
397 def credentials(self):
398 return self.credentials_
400 def ssid(self):
401 return self.ssid_
403 def password(self):
404 return self.password_
406 def device_id(self):
407 return self.device_id_
412 def __init__(self):
430 self.config = config
432 def __getitem__(self, item):
433 if item in self.config:
434 return self.config[item]
440 def __init__(self, command_wrapper):
441 self.command_wrapper = command_wrapper
442 self.avahi_wrapper = None
443 self.setup_name = None
444 self.device_id = ''
445 self.started = False
447 def start(self):
448 self.started = True
449 self.run_command()
451 def get_command(self):
460 'id=%s' % self.device_id
462 if self.setup_name:
463 cmd.append('setup_ssid=' + self.setup_name)
466 def run_command(self):
467 if self.avahi_wrapper:
468 self.avahi_wrapper.end()
469 self.avahi_wrapper.wait()
471 self.avahi_wrapper = self.command_wrapper(self.get_command())
472 self.avahi_wrapper.start()
474 def set_id(self, device_id):
475 self.device_id = device_id
476 if self.started:
477 self.run_command()
479 def set_setup_name(self, setup_name):
480 self.setup_name = setup_name
481 if self.started:
482 self.run_command()
490 def on_device_started(self):
493 def on_device_stopped(self):
496 def __init__(self, ioloop, state, config, command_wrapper, delegate):
497 self.state = state
498 self.http = httplib2.Http()
500 self.oauth_client_id = config['oauth_client_id']
501 self.oauth_secret = config['oauth_secret']
502 self.api_key = config['api_key']
511 self.gcd = build_from_document(discovery, developerKey=self.api_key,
512 http=self.http)
514 self.ioloop = ioloop
515 self.active = True
516 self.device_id = None
517 self.credentials = None
518 self.delegate = delegate
519 self.command_handler = command_wrapper
521 def try_start(self, token):
523 if self.state.has_credentials():
524 self.credentials = self.state.credentials()
525 self.device_id = self.state.device_id()
526 self.run_device()
528 self.register(token)
533 def register(self, token):
537 'oauthClientId': self.oauth_client_id
540 self.gcd.registrationTickets().patch(registrationTicketId=token,
543 final_ticket = self.gcd.registrationTickets().finalize(
547 flow = OAuth2WebServerFlow(self.oauth_client_id, self.oauth_secret,
549 self.credentials = flow.step2_exchange(authorization_code)
550 self.device_id = final_ticket['deviceDraft']['id']
551 self.state.set_credentials(self.credentials, self.device_id)
552 print 'Registered with device_id ', self.device_id
554 self.run_device()
556 def run_device(self):
558 self.credentials.authorize(self.http)
561 self.gcd.devices().get(deviceId=self.device_id).execute()
569 self.check_commands()
570 self.delegate.on_device_started()
572 def check_commands(self):
574 if not self.active:
577 commands = self.gcd.commands().list(deviceId=self.device_id,
600 self.command_handler.handle_command(vendor_command_name, parameters)
602 self.gcd.commands().patch(commandId=command['id'],
607 self.ioloop.add_timeout(datetime.timedelta(milliseconds=1000),
608 self.check_commands)
610 def stop(self):
611 self.active = False
613 def get_device_id(self):
614 return self.device_id
618 def inner(self, request, response_func, *args):
621 return f(self, request, response_func, *args)
626 def inner(self, request, response_func, *args):
629 return f(self, request, response_func, *args)
634 def inner(self, request, response_func, *args):
635 if self.on_wifi:
637 return f(self, request, response_func, *args)
642 def inner(self, request, response_func, *args):
643 if not self.on_wifi:
645 return f(self, request, response_func, *args)
664 def __init__(self, function):
665 self.function = function
667 def __call__(self):
668 if self.function:
669 return self.function
672 def cancel(self):
673 self.function = None
678 def __init__(self, session_id):
679 self.session_id = session_id
680 self.key = None
682 def do_step(self, step, package):
684 raise self.InvalidStepError()
685 self.key = package
686 return self.key
688 def decrypt(self, cyphertext):
689 return json.loads(cyphertext[len(self.key):])
691 def encrypt(self, plain_data):
692 return self.key + json.dumps(plain_data)
694 def get_session_id(self):
695 return self.session_id
697 def get_stype(self):
700 def get_status(self):
706 def __init__(self, session_id):
707 self.session_id = session_id
708 self.key = None
710 def do_step(self, step, package):
712 raise self.InvalidStepError()
715 def decrypt(self, cyphertext):
718 def encrypt(self, plain_data):
721 def get_session_id(self):
722 return self.session_id
724 def get_stype(self):
727 def get_status(self):
730 def __init__(self, ioloop, state):
731 self.config = Config()
733 if self.config['on_real_device']:
741 if self.config['led_path']:
743 self.config['led_path'])
744 self.setup_real(self.config['led_path'])
747 self.setup_fake()
749 self.setup_ssid = _DEVICE_SETUP_SSID % random.randint(0,99)
750 self.cloud_device = CloudDevice(ioloop, state, self.config,
751 cloud_wrapper, self)
752 self.wifi_handler = wifi_handler(ioloop, state, self.config,
753 self.setup_ssid, self)
754 self.mdns_wrapper = MDnsWrapper(mdns_wrappers)
755 self.on_wifi = False
756 self.registered = False
757 self.in_session = False
758 self.ioloop = ioloop
760 self.handlers = {
761 '/internal/ping': self.do_ping,
762 '/privet/info': self.do_info,
763 '/deprecated/wifi/switch': self.do_wifi_switch,
764 '/privet/v3/session/handshake': self.do_session_handshake,
765 '/privet/v3/session/cancel': self.do_session_cancel,
766 '/privet/v3/session/request': self.do_session_call,
768 self.get_insecure_api_handler(self.do_secure_setup_start),
770 self.get_insecure_api_handler(self.do_secure_setup_cancel),
772 self.get_insecure_api_handler(self.do_secure_status),
775 self.current_session = None
776 self.session_cancel_callback = None
777 self.session_handlers = {
778 'dummy': self.DummySession,
779 'empty': self.EmptySession
782 self.secure_handlers = {
783 '/privet/v3/setup/start': self.do_secure_setup_start,
784 '/privet/v3/setup/cancel': self.do_secure_setup_cancel,
785 '/privet/v3/setup/status': self.do_secure_status
798 def start(self):
799 self.wifi_handler.start()
800 self.mdns_wrapper.set_setup_name(self.setup_ssid)
801 self.mdns_wrapper.start()
804 def do_ping(self, unused_request, response_func):
809 def do_public_info(self, unused_request, response_func):
810 info = dict(self.get_common_info().items() + {
811 'stype': self.session_handlers.keys()}.items())
815 def do_info(self, unused_request, response_func):
818 'api': sorted(self.handlers.keys())
820 info = dict(self.get_common_info().items() + specific_info.items())
826 def do_wifi_switch(self, request, response_func):
839 self.wifi_handler.switch_to_wifi(ssid, passw, None)
844 def do_session_handshake(self, request, response_func):
862 if self.current_session:
863 if session_id != self.current_session.get_session_id():
866 if stype != self.current_session.get_stype():
870 if stype not in self.session_handlers:
873 self.current_session = self.session_handlers[stype](session_id)
876 output_package = self.current_session.do_step(step, package)
877 except self.InvalidStepError:
880 except self.InvalidPackageError:
885 'status': self.current_session.get_status(),
891 self.post_session_cancel()
895 def do_session_cancel(self, request, response_func):
904 if self.current_session and session_id == self.current_session.session_id:
905 self.current_session = None
906 if self.session_cancel_callback:
907 self.session_cancel_callback.cancel()
914 def do_session_call(self, request, response_func):
922 if (not self.current_session or
923 session_id != self.current_session.session_id):
928 decrypted = self.current_session.decrypt(request.body)
929 except self.EncryptionError:
935 self.encrypted_send_response(request, code, dict(data.items() + {
939 self.encrypted_send_response(request, code, {
950 if decrypted['api'] in self.secure_handlers:
951 self.secure_handlers[decrypted['api']](request,
957 self.post_session_cancel()
960 def get_insecure_api_handler(self, handler):
962 return self.insecure_api_handler(request, func, handler)
966 def insecure_api_handler(self, request, response_func, handler):
971 def do_secure_status(self, unused_request, response_func, unused_params):
981 if self.on_wifi:
987 if self.cloud_device.get_device_id():
989 setup['registration']['id'] = self.cloud_device.get_device_id()
994 def do_secure_setup_start(self, unused_request, response_func, params):
1014 self.wifi_handler.switch_to_wifi(ssid, passw, token)
1016 self.cloud_device.register(token)
1023 self.do_secure_status(unused_request, response_func, params)
1025 def do_secure_setup_cancel(self, request, response_func, params):
1028 def handle_request(self, request):
1030 self.real_send_response(request, code, data)
1034 if request.path in self.handlers:
1035 handled = self.handlers[request.path](request, response_func)
1038 self.real_send_response(request, 404, {'error': 'notFound'})
1040 def encrypted_send_response(self, request, code, data):
1041 self.raw_send_response(request, code,
1042 self.current_session.encrypt(data))
1044 def real_send_response(self, request, code, data):
1047 self.raw_send_response(request, code, data)
1049 def raw_send_response(self, request, code, data):
1056 def device_state(self):
1059 def get_common_info(self):
1063 'device_state': self.device_state()
1066 def post_session_cancel(self):
1067 if self.session_cancel_callback:
1068 self.session_cancel_callback.cancel()
1069 self.session_cancel_callback = self.CancelableClosure(self.session_cancel)
1070 self.ioloop.add_timeout(datetime.timedelta(minutes=2),
1071 self.session_cancel_callback)
1073 def session_cancel(self):
1074 self.current_session = None
1077 def on_wifi_connected(self, token):
1078 self.mdns_wrapper.set_setup_name(None)
1079 self.cloud_device.try_start(token)
1080 self.on_wifi = True
1082 def on_device_started(self):
1083 self.mdns_wrapper.set_id(self.cloud_device.get_device_id())
1085 def on_device_stopped(self):
1088 def stop(self):
1089 self.wifi_handler.stop()
1090 self.cloud_device.stop()