#!/usr/bin/env python # # Copyright 2007 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # """Serves the stub App Engine APIs (e.g. memcache, datastore) over HTTP. The Remote API protocol is used for communication. """ from __future__ import with_statement import BaseHTTPServer import httplib import logging import os.path import pickle import socket import SocketServer import subprocess import sys import tempfile import threading import time import traceback import urllib2 import urlparse import wsgiref.headers import google import yaml from google.appengine.api import mail_stub from google.appengine.api import request_info from google.appengine.api import urlfetch_stub from google.appengine.api import user_service_stub from google.appengine.api.app_identity import app_identity_stub from google.appengine.api.blobstore import blobstore_stub from google.appengine.api.blobstore import file_blob_storage from google.appengine.api.capabilities import capability_stub from google.appengine.api.channel import channel_service_stub from google.appengine.api.files import file_service_stub from google.appengine.api.logservice import logservice_stub from google.appengine.api.search import simple_search_stub from google.appengine.api.taskqueue import taskqueue_stub from google.appengine.api.prospective_search import prospective_search_stub from google.appengine.api.memcache import memcache_stub from google.appengine.api.system import system_stub from google.appengine.api.xmpp import xmpp_service_stub from google.appengine.api import datastore_file_stub from google.appengine.datastore import datastore_sqlite_stub from google.appengine.datastore import datastore_stub_util from google.appengine.datastore import datastore_v4_stub from google.appengine.api import apiproxy_stub_map from google.appengine.ext.remote_api import remote_api_pb from google.appengine.ext.remote_api import remote_api_services from google.appengine.runtime import apiproxy_errors QUIT_PATH = '/quit' GLOBAL_API_LOCK = threading.RLock() class Error(Exception): pass def _ClearDatastoreStorage(datastore_path): """Delete the datastore storage file at the given path.""" if os.path.lexists(datastore_path): try: os.remove(datastore_path) except OSError, e: logging.warning('Failed to remove datastore file %r: %s', datastore_path, e) def _ClearProspectiveSearchStorage(prospective_search_path): """Delete the perspective search storage file at the given path.""" if os.path.lexists(prospective_search_path): try: os.remove(prospective_search_path) except OSError, e: logging.warning('Failed to remove prospective search file %r: %s', prospective_search_path, e) THREAD_SAFE_SERVICES = frozenset(( 'app_identity_service', 'capability_service', 'channel', 'logservice', 'mail', 'memcache', 'remote_socket', 'urlfetch', 'user', 'xmpp', )) def _ExecuteRequest(request): """Executes an API method call and returns the response object. Args: request: A remote_api.Request object representing the API call e.g. a call to memcache.Get. Returns: A ProtocolBuffer.ProtocolMessage representing the API response e.g. a memcache_service_pb.MemcacheGetResponse. Raises: apiproxy_errors.CallNotFoundError: if the requested method doesn't exist. apiproxy_errors.ApplicationError: if the API method calls fails. """ service = request.service_name() method = request.method() service_methods = remote_api_services.SERVICE_PB_MAP.get(service, {}) request_class, response_class = service_methods.get(method, (None, None)) if not request_class: raise apiproxy_errors.CallNotFoundError('%s.%s does not exist' % (service, method)) request_data = request_class() request_data.ParseFromString(request.request()) response_data = response_class() def MakeRequest(): apiproxy_stub_map.MakeSyncCall(service, method, request_data, response_data) if service in THREAD_SAFE_SERVICES: MakeRequest() else: with GLOBAL_API_LOCK: MakeRequest() return response_data class APIRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): """Handler for all API server HTTP requests.""" def log_message(self, format, *args): logging.debug(format, *args) def do_GET(self): if self.path == QUIT_PATH: self._HandleShutdown() else: params = urlparse.parse_qs(urlparse.urlparse(self.path).query) rtok = params.get('rtok', ['0'])[0] self.send_response(httplib.OK) self.send_header('Content-Type', 'text/plain') self.end_headers() self.wfile.write(yaml.dump({ 'app_id': self.server.app_id, 'rtok': rtok, })) def _HandleShutdown(self): """Handles a request for the API Server to exit.""" self.send_response(httplib.OK) self.send_header('Content-Type', 'text/plain') self.end_headers() self.wfile.write('API Server Quitting') self.server.shutdown() def do_POST(self): """Handles a single API request e.g. memcache.Get().""" self.send_response(httplib.OK) self.send_header('Content-Type', 'application/octet-stream') self.end_headers() response = remote_api_pb.Response() try: request = remote_api_pb.Request() request.ParseFromString( self.rfile.read(int(self.headers['content-length']))) api_response = _ExecuteRequest(request).Encode() response.set_response(api_response) except Exception, e: logging.debug('Exception while handling %s\n%s', request, traceback.format_exc()) response.set_exception(pickle.dumps(e)) if isinstance(e, apiproxy_errors.ApplicationError): application_error = response.mutable_application_error() application_error.set_code(e.application_error) application_error.set_detail(e.error_detail) self.wfile.write(response.Encode()) class APIServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer): """Serves API calls over HTTP.""" def __init__(self, server_address, app_id): BaseHTTPServer.HTTPServer.__init__(self, server_address, APIRequestHandler) self.app_id = app_id def _SetupStubs( app_id, application_root, appidentity_email_address, appidentity_private_key_path, trusted, blobstore_path, use_sqlite, auto_id_policy, high_replication, datastore_path, datastore_require_indexes, images_host_prefix, logs_path, mail_smtp_host, mail_smtp_port, mail_smtp_user, mail_smtp_password, mail_enable_sendmail, mail_show_mail_body, mail_allow_tls, matcher_prospective_search_path, taskqueue_auto_run_tasks, taskqueue_task_retry_seconds, taskqueue_default_http_server, user_login_url, user_logout_url, default_gcs_bucket_name): """Configures the APIs hosted by this server. Args: app_id: The str application id e.g. "guestbook". application_root: The path to the directory containing the user's application e.g. "/home/bquinlan/myapp". trusted: A bool indicating if privileged APIs should be made available. blobstore_path: The path to the file that should be used for blobstore storage. use_sqlite: A bool indicating whether DatastoreSqliteStub or DatastoreFileStub should be used. auto_id_policy: One of datastore_stub_util.SEQUENTIAL or .SCATTERED, indicating whether the Datastore stub should assign IDs sequentially or scattered. high_replication: A bool indicating whether to use the high replication consistency model. datastore_path: The path to the file that should be used for datastore storage. datastore_require_indexes: A bool indicating if the same production datastore indexes requirements should be enforced i.e. if True then a google.appengine.ext.db.NeedIndexError will be be raised if a query is executed without the required indexes. images_host_prefix: The URL prefix (protocol://host:port) to preprend to image urls on calls to images.GetUrlBase. logs_path: Path to the file to store the logs data in. mail_smtp_host: The SMTP hostname that should be used when sending e-mails. If None then the mail_enable_sendmail argument is considered. mail_smtp_port: The SMTP port number that should be used when sending e-mails. If this value is None then mail_smtp_host must also be None. mail_smtp_user: The username to use when authenticating with the SMTP server. This value may be None if mail_smtp_host is also None or if the SMTP server does not require authentication. mail_smtp_password: The password to use when authenticating with the SMTP server. This value may be None if mail_smtp_host or mail_smtp_user is also None. mail_enable_sendmail: A bool indicating if sendmail should be used when sending e-mails. This argument is ignored if mail_smtp_host is not None. mail_show_mail_body: A bool indicating whether the body of sent e-mails should be written to the logs. mail_allow_tls: A bool indicating whether to allow TLS support. matcher_prospective_search_path: The path to the file that should be used to save prospective search subscriptions. taskqueue_auto_run_tasks: A bool indicating whether taskqueue tasks should be run automatically or it the must be manually triggered. taskqueue_task_retry_seconds: An int representing the number of seconds to wait before a retrying a failed taskqueue task. taskqueue_default_http_server: A str containing the address of the http server that should be used to execute tasks. user_login_url: A str containing the url that should be used for user login. user_logout_url: A str containing the url that should be used for user logout. default_gcs_bucket_name: A str overriding the usual default bucket name. """ os.environ['APPLICATION_ID'] = app_id tmp_app_identity_stub = app_identity_stub.AppIdentityServiceStub.Create( email_address=appidentity_email_address, private_key_path=appidentity_private_key_path) if default_gcs_bucket_name is not None: tmp_app_identity_stub.SetDefaultGcsBucketName(default_gcs_bucket_name) apiproxy_stub_map.apiproxy.RegisterStub( 'app_identity_service', tmp_app_identity_stub) blob_storage = file_blob_storage.FileBlobStorage(blobstore_path, app_id) apiproxy_stub_map.apiproxy.RegisterStub( 'blobstore', blobstore_stub.BlobstoreServiceStub(blob_storage)) apiproxy_stub_map.apiproxy.RegisterStub( 'capability_service', capability_stub.CapabilityServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub( 'channel', channel_service_stub.ChannelServiceStub()) if use_sqlite: datastore = datastore_sqlite_stub.DatastoreSqliteStub( app_id, datastore_path, datastore_require_indexes, trusted, root_path=application_root, auto_id_policy=auto_id_policy) else: datastore = datastore_file_stub.DatastoreFileStub( app_id, datastore_path, datastore_require_indexes, trusted, root_path=application_root, auto_id_policy=auto_id_policy) if high_replication: datastore.SetConsistencyPolicy( datastore_stub_util.TimeBasedHRConsistencyPolicy()) apiproxy_stub_map.apiproxy.RegisterStub( 'datastore_v3', datastore) apiproxy_stub_map.apiproxy.RegisterStub( 'datastore_v4', datastore_v4_stub.DatastoreV4Stub(app_id)) apiproxy_stub_map.apiproxy.RegisterStub( 'file', file_service_stub.FileServiceStub(blob_storage)) try: from google.appengine.api.images import images_stub except ImportError: from google.appengine.api.images import images_not_implemented_stub apiproxy_stub_map.apiproxy.RegisterStub( 'images', images_not_implemented_stub.ImagesNotImplementedServiceStub()) else: apiproxy_stub_map.apiproxy.RegisterStub( 'images', images_stub.ImagesServiceStub(host_prefix=images_host_prefix)) apiproxy_stub_map.apiproxy.RegisterStub( 'logservice', logservice_stub.LogServiceStub(logs_path=logs_path)) apiproxy_stub_map.apiproxy.RegisterStub( 'mail', mail_stub.MailServiceStub(mail_smtp_host, mail_smtp_port, mail_smtp_user, mail_smtp_password, enable_sendmail=mail_enable_sendmail, show_mail_body=mail_show_mail_body, allow_tls=mail_allow_tls)) apiproxy_stub_map.apiproxy.RegisterStub( 'memcache', memcache_stub.MemcacheServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub( 'search', simple_search_stub.SearchServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub('system', system_stub.SystemServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub( 'taskqueue', taskqueue_stub.TaskQueueServiceStub( root_path=application_root, auto_task_running=taskqueue_auto_run_tasks, task_retry_seconds=taskqueue_task_retry_seconds, default_http_server=taskqueue_default_http_server)) apiproxy_stub_map.apiproxy.GetStub('taskqueue').StartBackgroundExecution() apiproxy_stub_map.apiproxy.RegisterStub( 'urlfetch', urlfetch_stub.URLFetchServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub( 'user', user_service_stub.UserServiceStub(login_url=user_login_url, logout_url=user_logout_url)) apiproxy_stub_map.apiproxy.RegisterStub( 'xmpp', xmpp_service_stub.XmppServiceStub()) apiproxy_stub_map.apiproxy.RegisterStub( 'matcher', prospective_search_stub.ProspectiveSearchStub( matcher_prospective_search_path, apiproxy_stub_map.apiproxy.GetStub('taskqueue'))) def _TearDownStubs(): """Clean up any stubs that need cleanup.""" logging.info('Applying all pending transactions and saving the datastore') datastore_stub = apiproxy_stub_map.apiproxy.GetStub('datastore_v3') datastore_stub.Write() def ParseCommandArguments(args): """Parses and the application's command line arguments. Args: args: A list of command line arguments *not* including the executable or script e.g. ['-A' 'myapp', '--api_port=8000']. Returns: An object containing the values passed in the commandline as attributes. Raises: SystemExit: if the argument parsing fails. """ import argparse from google.appengine.tools import boolean_action parser = argparse.ArgumentParser() parser.add_argument('-A', '--application', required=True) parser.add_argument('--api_host', default='') parser.add_argument('--api_port', default=8000, type=int) parser.add_argument('--trusted', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--appidentity_email_address', default=None) parser.add_argument('--appidentity_private_key_path', default=None) parser.add_argument('--application_root', default=None) parser.add_argument('--application_host', default='localhost') parser.add_argument('--application_port', default=None) parser.add_argument('--blobstore_path', default=None) parser.add_argument('--datastore_path', default=None) parser.add_argument('--auto_id_policy', default='scattered', type=lambda s: s.lower(), choices=(datastore_stub_util.SEQUENTIAL, datastore_stub_util.SCATTERED)) parser.add_argument('--use_sqlite', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--high_replication', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--require_indexes', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--clear_datastore', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--logs_path', default=None) parser.add_argument('--enable_sendmail', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--smtp_host', default='') parser.add_argument('--smtp_port', default=25, type=int) parser.add_argument('--smtp_user', default='') parser.add_argument('--smtp_password', default='') parser.add_argument('--show_mail_body', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--smtp_allow_tls', action=boolean_action.BooleanAction, const=True, default=True) parser.add_argument('--prospective_search_path', default=None) parser.add_argument('--clear_prospective_search', action=boolean_action.BooleanAction, const=True, default=False) parser.add_argument('--enable_task_running', action=boolean_action.BooleanAction, const=True, default=True) parser.add_argument('--task_retry_seconds', default=30, type=int) parser.add_argument('--user_login_url', default=None) parser.add_argument('--user_logout_url', default=None) return parser.parse_args(args) class APIServerProcess(object): """Manages an API Server running as a seperate process.""" def __init__(self, executable, host, port, app_id, script=None, appidentity_email_address=None, appidentity_private_key_path=None, application_host=None, application_port=None, application_root=None, auto_id_policy=None, blobstore_path=None, clear_datastore=None, clear_prospective_search=None, datastore_path=None, enable_sendmail=None, enable_task_running=None, high_replication=None, logs_path=None, prospective_search_path=None, require_indexes=None, show_mail_body=None, smtp_host=None, smtp_password=None, smtp_port=None, smtp_user=None, smtp_allow_tls=None, task_retry_seconds=None, trusted=None, use_sqlite=None, default_gcs_bucket_name=None): """Configures the APIs hosted by this server. Args: executable: The path of the executable to use when running the API Server e.g. "/usr/bin/python". host: The host name that should be used by the API Server e.g. "localhost". port: The port number that should be used by the API Server e.g. 8080. app_id: The str application id e.g. "guestbook". script: The name of the script that should be used, along with the executable argument, to run the API Server e.g. "api_server.py". If None then the executable is run without a script argument. appidentity_email_address: Email address for service account substitute. appidentity_private_key_path: Private key for service account substitute. application_host: The name of the host where the development application server is running e.g. "localhost". application_port: The port where the application server is running e.g. 8000. application_root: The path to the directory containing the user's application e.g. "/home/bquinlan/myapp". auto_id_policy: One of "sequential" or "scattered", indicating whether the Datastore stub should assign IDs sequentially or scattered. blobstore_path: The path to the file that should be used for blobstore storage. clear_datastore: Clears the file at datastore_path, emptying the datastore from previous runs. clear_prospective_search: Clears the file at prospective_search_path, emptying the perspective search state from previous runs. datastore_path: The path to the file that should be used for datastore storage. enable_sendmail: A bool indicating if sendmail should be used when sending e-mails. This argument is ignored if mail_smtp_host is not None. enable_task_running: A bool indicating whether taskqueue tasks should be run automatically or it the must be manually triggered. high_replication: A bool indicating whether to use the high replication consistency model. logs_path: Path to the file to store the logs data in. prospective_search_path: The path to the file that should be used to save prospective search subscriptions. require_indexes: A bool indicating if the same production datastore indexes requirements should be enforced i.e. if True then a google.appengine.ext.db.NeedIndexError will be be raised if a query is executed without the required indexes. show_mail_body: A bool indicating whether the body of sent e-mails should be written to the logs. smtp_host: The SMTP hostname that should be used when sending e-mails. If None then the enable_sendmail argument is considered. smtp_password: The password to use when authenticating with the SMTP server. This value may be None if smtp_host or smtp_user is also None. smtp_port: The SMTP port number that should be used when sending e-mails. If this value is None then smtp_host must also be None. smtp_user: The username to use when authenticating with the SMTP server. This value may be None if smtp_host is also None or if the SMTP server does not require authentication. smtp_allow_tls: A bool indicating whether to enable TLS. task_retry_seconds: An int representing the number of seconds to wait before a retrying a failed taskqueue task. trusted: A bool indicating if privileged APIs should be made available. use_sqlite: A bool indicating whether DatastoreSqliteStub or DatastoreFileStub should be used. default_gcs_bucket_name: A str overriding the normal default bucket name. """ self._process = None self._host = host self._port = port if script: self._args = [executable, script] else: self._args = [executable] self._BindArgument('--api_host', host) self._BindArgument('--api_port', port) self._BindArgument('--appidentity_email_address', appidentity_email_address) self._BindArgument('--appidentity_private_key_path', appidentity_private_key_path) self._BindArgument('--application_host', application_host) self._BindArgument('--application_port', application_port) self._BindArgument('--application_root', application_root) self._BindArgument('--application', app_id) self._BindArgument('--auto_id_policy', auto_id_policy) self._BindArgument('--blobstore_path', blobstore_path) self._BindArgument('--clear_datastore', clear_datastore) self._BindArgument('--clear_prospective_search', clear_prospective_search) self._BindArgument('--datastore_path', datastore_path) self._BindArgument('--enable_sendmail', enable_sendmail) self._BindArgument('--enable_task_running', enable_task_running) self._BindArgument('--high_replication', high_replication) self._BindArgument('--logs_path', logs_path) self._BindArgument('--prospective_search_path', prospective_search_path) self._BindArgument('--require_indexes', require_indexes) self._BindArgument('--show_mail_body', show_mail_body) self._BindArgument('--smtp_host', smtp_host) self._BindArgument('--smtp_password', smtp_password) self._BindArgument('--smtp_port', smtp_port) self._BindArgument('--smtp_user', smtp_user) self._BindArgument('--smtp_allow_tls', smtp_allow_tls) self._BindArgument('--task_retry_seconds', task_retry_seconds) self._BindArgument('--trusted', trusted) self._BindArgument('--use_sqlite', use_sqlite) self._BindArgument('--default_gcs_bucket_name', default_gcs_bucket_name) @property def url(self): """Returns the URL that should be used to communicate with the server.""" return 'http://%s:%d' % (self._host, self._port) def __repr__(self): return '' % ' '.join(self._args) def Start(self): """Starts the API Server process.""" assert not self._process, 'Start() can only be called once' self._process = subprocess.Popen(self._args) def _CanConnect(self): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect((self._host, self._port)) except socket.error: connected = False else: connected = True s.close() return connected def WaitUntilServing(self, timeout=30.0): """Waits until the API Server is ready to handle requests. Args: timeout: The maximum number of seconds to wait for the server to be ready. Raises: Error: if the server process exits or is not ready in "timeout" seconds. """ assert self._process, 'server was not started' finish_time = time.time() + timeout while time.time() < finish_time: if self._process.poll() is not None: raise Error('server has already exited with return: %r', self._process.returncode) if self._CanConnect(): return time.sleep(0.2) raise Error('server did not start after %f seconds', timeout) def _BindArgument(self, argument, value): if value is not None: self._args.append('%s=%s' % (argument, value)) def Quit(self, timeout=5.0): """Causes the API Server process to exit. Args: timeout: The maximum number of seconds to wait for an orderly shutdown before forceably killing the process. """ assert self._process, 'server was not started' if self._process.poll() is None: try: urllib2.urlopen(self.url + QUIT_PATH) except urllib2.URLError: pass finish_time = time.time() + timeout while time.time() < finish_time and self._process.poll() is None: time.sleep(0.2) if self._process.returncode is None: logging.warning('api_server did not quit cleanly, killing') self._process.kill() class ApiServerDispatcher(request_info._LocalFakeDispatcher): """An api_server Dispatcher implementation.""" def add_request(self, method, relative_url, headers, body, source_ip, server_name=None, version=None, instance_id=None): """Process an HTTP request. Args: method: A str containing the HTTP method of the request. relative_url: A str containing path and query string of the request. headers: A list of (key, value) tuples where key and value are both str. body: A str containing the request body. source_ip: The source ip address for the request. server_name: An optional str containing the server name to service this request. If unset, the request will be dispatched to the default server. version: An optional str containing the version to service this request. If unset, the request will be dispatched to the default version. instance_id: An optional str containing the instance_id of the instance to service this request. If unset, the request will be dispatched to according to the load-balancing for the server and version. Returns: A request_info.ResponseTuple containing the response information for the HTTP request. """ try: header_dict = wsgiref.headers.Headers(headers) connection_host = header_dict.get('host') connection = httplib.HTTPConnection(connection_host) connection.putrequest( method, relative_url, skip_host='host' in header_dict, skip_accept_encoding='accept-encoding' in header_dict) for header_key, header_value in headers: connection.putheader(header_key, header_value) connection.endheaders() connection.send(body) response = connection.getresponse() response.read() response.close() return request_info.ResponseTuple( '%d %s' % (response.status, response.reason), [], '') except (httplib.HTTPException, socket.error): logging.exception( 'An error occured while sending a %s request to "%s%s"', method, connection_host, relative_url) return request_info.ResponseTuple('0', [], '') def main(): logging.basicConfig( level=logging.INFO, format='[API Server] [%(filename)s:%(lineno)d] %(levelname)s %(message)s') args = ParseCommandArguments(sys.argv[1:]) if args.clear_datastore: _ClearDatastoreStorage(args.datastore_path) if args.clear_prospective_search: _ClearProspectiveSearchStorage(args.prospective_search_path) if args.blobstore_path is None: _, blobstore_temp_filename = tempfile.mkstemp(prefix='ae-blobstore') args.blobstore_path = blobstore_temp_filename if args.datastore_path is None: _, datastore_temp_filename = tempfile.mkstemp(prefix='ae-datastore') args.datastore_path = datastore_temp_filename if args.prospective_search_path is None: _, prospective_search_temp_filename = tempfile.mkstemp( prefix='ae-prospective_search') args.prospective_search_path = prospective_search_temp_filename if args.application_host: application_address = args.application_host if args.application_port and args.application_port != 80: application_address += ':' + str(args.application_port) else: application_address = None if not hasattr(args, 'default_gcs_bucket_name'): args.default_gcs_bucket_name = None request_info._local_dispatcher = ApiServerDispatcher() _SetupStubs(app_id=args.application, application_root=args.application_root, appidentity_email_address=args.appidentity_email_address, appidentity_private_key_path=args.appidentity_private_key_path, trusted=args.trusted, blobstore_path=args.blobstore_path, datastore_path=args.datastore_path, use_sqlite=args.use_sqlite, auto_id_policy=args.auto_id_policy, high_replication=args.high_replication, datastore_require_indexes=args.require_indexes, images_host_prefix=application_address, logs_path=args.logs_path, mail_smtp_host=args.smtp_host, mail_smtp_port=args.smtp_port, mail_smtp_user=args.smtp_user, mail_smtp_password=args.smtp_password, mail_enable_sendmail=args.enable_sendmail, mail_show_mail_body=args.show_mail_body, mail_allow_tls=args.smtp_allow_tls, matcher_prospective_search_path=args.prospective_search_path, taskqueue_auto_run_tasks=args.enable_task_running, taskqueue_task_retry_seconds=args.task_retry_seconds, taskqueue_default_http_server=application_address, user_login_url=args.user_login_url, user_logout_url=args.user_logout_url, default_gcs_bucket_name=args.default_gcs_bucket_name) server = APIServer((args.api_host, args.api_port), args.application) try: server.serve_forever() finally: _TearDownStubs() if __name__ == '__main__': try: main() except KeyboardInterrupt: pass