| # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Handle gdata spreadsheet authentication.""" |
| |
| import BaseHTTPServer |
| import httplib |
| import os |
| import Queue |
| import threading |
| import socket |
| import time |
| |
| import gdata.gauth |
| import gdata.spreadsheets.client |
| |
| # Local port of http daemon for receiving the refresh token from the redirected |
| # url returned by authentication server. |
| START_PORT = 12345 |
| ACCESS_CODE_Q = Queue.Queue() |
| |
| # Token storage |
| TOKEN_STORAGE_NAME = '%s/.spreadsheets.oauth2.dat' % os.getenv('HOME') |
| |
| # Application's CLIENT_ID and SECRET for OAuthToken which is created from |
| # google's api console's API access - https://code.google.com/apis/console |
| CLIENT_ID = '657833351030.apps.googleusercontent.com' |
| CLIENT_SECRET = 'h72FzPdzfbN3I4U3M3l1DSiT' |
| |
| USER_AGENT = 'Pressure Calibration Data Collector' |
| SCOPES = 'https://spreadsheets.google.com/feeds/ https://docs.google.com/feeds/' |
| RETRY = 10 |
| |
| |
| class AuthenticationHandler(BaseHTTPServer.BaseHTTPRequestHandler): |
| """Authentication handler class.""" |
| |
| def do_QUIT(self): |
| """Do QUIT reuqest.""" |
| self.send_response(200) |
| self.end_headers() |
| self.server.stop = True |
| |
| def do_GET(self): # pylint: disable=g-bad-name |
| """Do GET request.""" |
| self.send_response(200) |
| self.send_header('Content-type', 'text/html') |
| self.end_headers() |
| self.port = START_PORT |
| query_str = self.path[2:] |
| if query_str.startswith('code='): |
| self.wfile.write('Spreadsheet authentication complete, ' |
| 'please back to command prompt.') |
| ACCESS_CODE_Q.put(query_str[5:]) |
| return |
| if query_str.startswith('error='): |
| print "Ouch, error: '%s'." % query_str[6:] |
| raise Exception("Exception during approval process: '%s'." % |
| query_str[6:]) |
| |
| def log_message(self, format, *args): # pylint: disable=redefined-builtin |
| pass |
| |
| |
| class AuthenticationHTTPD(BaseHTTPServer.HTTPServer): |
| """ Handle redirected response from authentication server.""" |
| def serve_forever(self, poll_interval=0.5): |
| poll_interval = poll_interval |
| self.stop = False |
| while not self.stop: |
| self.handle_request() |
| |
| |
| class AuthenticationServer(threading.Thread): |
| """Authentication http server thread.""" |
| |
| def __init__(self): |
| self.authserver = None |
| self.started = False |
| threading.Thread.__init__(self) |
| |
| def run(self): |
| for ports in range(START_PORT, START_PORT + RETRY): |
| self.port = ports |
| try: |
| self.authserver = AuthenticationHTTPD(('', self.port), |
| AuthenticationHandler) |
| self.started = True |
| self.authserver.serve_forever() |
| return |
| |
| except socket.error, se: |
| # port is busy, there must be another instance running... |
| if self.port == START_PORT + RETRY - 1: |
| raise se |
| else: |
| continue # keep trying new ports |
| |
| except KeyboardInterrupt: |
| print '^C received, shutting down authentication server.' |
| self.stop = True |
| return # out of retry loop |
| |
| except Exception: |
| self.stop = True |
| return # out of retry loop |
| |
| def get_port(self): |
| """Get the running port number.""" |
| for retry in xrange(RETRY): |
| if self.started and self.authserver: |
| return self.port |
| else: |
| time.sleep(retry * 2) |
| continue |
| |
| |
| class SpreadsheetAuthorizer: |
| """ Handle gdata api authentication for spreadsheet client.""" |
| def __init__(self): |
| self.lock = threading.Lock() |
| self.refresh_token = None |
| self.redirect_url = None |
| self.httpd_auth = None |
| self.port = None |
| |
| def _start_server(self): |
| """Start http daemon for handling refresh token.""" |
| if not self.httpd_auth or not self.httpd_auth.isAlive(): |
| ### Starting webserver if necessary |
| self.httpd_auth = AuthenticationServer() |
| self.httpd_auth.start() |
| self.port = self.httpd_auth.get_port() |
| |
| def _stop_server(self): |
| """Stop http daemon.""" |
| if self.httpd_auth: |
| try: |
| conn = httplib.HTTPConnection('localhost:%s' % self.port) |
| conn.request('QUIT', '/') |
| conn.getresponse() |
| time.sleep(1) |
| del self.httpd_auth |
| self.httpd_auth = None |
| except Exception, e: |
| print "Failed to quit local auth server...'%s'." % e |
| return |
| |
| def authorize(self, ss_client): |
| """Authorize the spreadsheet client. |
| |
| @param ss_client: spreadsheet client |
| """ |
| self._read_refresh_token() |
| token = gdata.gauth.OAuth2Token(CLIENT_ID, |
| CLIENT_SECRET, |
| SCOPES, |
| USER_AGENT, |
| refresh_token = self.refresh_token) |
| try: |
| if not self.refresh_token: |
| self._start_server() |
| token = gdata.gauth.OAuth2Token(CLIENT_ID, |
| CLIENT_SECRET, |
| SCOPES, |
| USER_AGENT) |
| redirect_url = 'http://localhost:' + str(self.port) |
| url = token.generate_authorize_url(redirect_url) |
| print ('\nPlease open the following URL and use @chromium.org' |
| 'account for authentication and authorization of the' |
| 'spreadsheet access:\n' + url) |
| print 'Waiting for you to authenticate...' |
| while ACCESS_CODE_Q.empty(): |
| time.sleep(.25) |
| access_code = ACCESS_CODE_Q.get() |
| print 'ACCESS CODE is ' + access_code |
| token.get_access_token(access_code) |
| self.refresh_token = token.refresh_token |
| print 'REFRESH TOKEN is ' + self.refresh_token |
| self._write_refresh_token() |
| self._stop_server() |
| token.authorize(ss_client) |
| return True |
| except IOError: |
| print "ERROR!!!!!!!!!!!!!!!!" |
| return False |
| |
| def _read_refresh_token(self): |
| """Read refresh token from storage.""" |
| try: |
| self.lock.acquire() |
| token_file = open(TOKEN_STORAGE_NAME, 'r') |
| self.refresh_token = token_file.readline().strip() |
| token_file.close() |
| self.lock.release() |
| return self.refresh_token |
| except IOError: |
| self.lock.release() |
| return None |
| |
| def _write_refresh_token(self): |
| """Write refresh token into storage.""" |
| try: |
| self.lock.acquire() |
| token_descriptor = os.open(TOKEN_STORAGE_NAME, |
| os.O_CREAT | os.O_WRONLY | os.O_TRUNC, |
| 0600) |
| token_file = os.fdopen(token_descriptor, 'w') |
| token_file.write(self.refresh_token + '\n') |
| token_file.close() |
| self.lock.release() |
| except (IOError, OSError): |
| self.lock.release() |
| print 'Error, can not write refresh token\n' |
