def _create_dispatcher(configuration, options):
from google.appengine.tools.devappserver2 import dispatcher
from google.appengine.tools.devappserver2.devappserver2 import (
DevelopmentServer, _LOG_LEVEL_TO_RUNTIME_CONSTANT)
if hasattr(_create_dispatcher, "singleton"):
return _create_dispatcher.singleton
_create_dispatcher.singleton = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
DevelopmentServer._create_php_config(options),
DevelopmentServer._create_python_config(options),
DevelopmentServer._create_java_config(options),
DevelopmentServer._create_cloud_sql_config(options),
DevelopmentServer._create_vm_config(options),
DevelopmentServer._create_module_to_setting(
options.max_module_instances, configuration,
'--max_module_instances'), options.use_mtime_file_watcher,
options.automatic_restart, options.allow_skipped_files,
DevelopmentServer._create_module_to_setting(
options.threadsafe_override, configuration,
'--threadsafe_override'))
return _create_dispatcher.singleton
def setUp(self):
self.mox = mox.Mox()
api_server.test_setup_stubs()
self.dispatch_config = DispatchConfigurationStub()
app_config = ApplicationConfigurationStub(MODULE_CONFIGURATIONS)
self.dispatcher = dispatcher.Dispatcher(app_config,
'localhost',
1,
'gmail.com',
1,
'php_executable_path',
'enable_php_remote_debugging',
python_config=None,
cloud_sql_config=None,
module_to_max_instances={},
use_mtime_file_watcher=False,
automatic_restart=True,
allow_skipped_files=False)
self.module1 = AutoScalingModuleFacade(app_config.modules[0],
balanced_port=1,
host='localhost')
self.module2 = ManualScalingModuleFacade(app_config.modules[0],
balanced_port=2,
host='localhost')
self.mox.StubOutWithMock(self.dispatcher, '_create_module')
self.dispatcher._create_module(app_config.modules[0], 1).AndReturn(
(self.module1, 2))
self.dispatcher._create_module(app_config.modules[1], 2).AndReturn(
(self.module2, 3))
self.mox.ReplayAll()
self.dispatcher.start(12345, object())
app_config.dispatch = self.dispatch_config
self.mox.VerifyAll()
self.mox.StubOutWithMock(module.Module, 'build_request_environ')
def setUp(self):
self.mox = mox.Mox()
api_server.test_setup_stubs()
self.dispatch_config = DispatchConfigurationStub()
app_config = ApplicationConfigurationStub(SERVER_CONFIGURATIONS)
self.dispatcher = dispatcher.Dispatcher(app_config,
'localhost',
1,
1,
python_config=None,
cloud_sql_config=None,
server_to_max_instances={},
use_mtime_file_watcher=False,
automatic_restart=True)
self.server1 = AutoScalingServerFacade(app_config.servers[0],
balanced_port=1,
host='localhost')
self.server2 = ManualScalingServerFacade(app_config.servers[0],
balanced_port=2,
host='localhost')
self.mox.StubOutWithMock(self.dispatcher, '_create_server')
self.dispatcher._create_server(app_config.servers[0], 1).AndReturn(
(self.server1, 2))
self.dispatcher._create_server(app_config.servers[1], 2).AndReturn(
(self.server2, 3))
self.mox.ReplayAll()
self.dispatcher.start(12345, object())
app_config.dispatch = self.dispatch_config
self.mox.VerifyAll()
self.mox.StubOutWithMock(server.Server, 'build_request_environ')
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
logging.getLogger().setLevel(
_LOG_LEVEL_TO_PYTHON_CONSTANT[options.dev_appserver_log_level])
configuration = application_configuration.ApplicationConfiguration(
options.yaml_files)
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id)
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
self._create_php_config(options),
self._create_python_config(options),
self._create_cloud_sql_config(options),
self._create_module_to_setting(options.max_module_instances,
configuration,
'--max_module_instances'),
options.use_mtime_file_watcher, options.automatic_restart,
options.allow_skipped_files,
self._create_module_to_setting(options.threadsafe_override,
configuration,
'--threadsafe_override'))
request_data = wsgi_request_info.WSGIRequestInfo(self._dispatcher)
storage_path = _get_storage_path(options.storage_path,
configuration.app_id)
apis = self._create_api_server(request_data, storage_path, options,
configuration)
apis.start()
self._running_modules.append(apis)
self._dispatcher.start(options.api_host, apis.port, request_data)
self._running_modules.append(self._dispatcher)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
def _create_dispatcher(configuration, options):
from google.appengine.tools.devappserver2 import dispatcher
from google.appengine.tools.devappserver2.devappserver2 import DevelopmentServer
try:
from google.appengine.tools.devappserver2.devappserver2 import _LOG_LEVEL_TO_RUNTIME_CONSTANT
except ImportError:
from google.appengine.tools.devappserver2.constants import LOG_LEVEL_TO_RUNTIME_CONSTANT
_LOG_LEVEL_TO_RUNTIME_CONSTANT = LOG_LEVEL_TO_RUNTIME_CONSTANT
from google.appengine.tools.sdk_update_checker import GetVersionObject, \
_VersionList
if hasattr(_create_dispatcher, "singleton"):
return _create_dispatcher.singleton
class UnsupportedOption(object):
pass
current_version = _VersionList(GetVersionObject()['release'])
supports_go_config = current_version >= _VersionList('1.9.50')
supports_custom_config = current_version >= _VersionList(
'1.9.22') or current_version == TEMP_1_9_49_VERSION_NO
supports_external_port = current_version >= _VersionList(
'1.9.19') or current_version == TEMP_1_9_49_VERSION_NO
supports_watcher_ignore_re = current_version >= _VersionList('1.9.54')
dispatcher_args = [
configuration, options.host, options.port, options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
DevelopmentServer._create_php_config(options),
DevelopmentServer._create_python_config(options),
DevelopmentServer._create_java_config(options),
DevelopmentServer._create_go_config(options)
if supports_go_config else UnsupportedOption,
None if supports_custom_config else UnsupportedOption,
DevelopmentServer._create_cloud_sql_config(options),
DevelopmentServer._create_vm_config(options),
DevelopmentServer._create_module_to_setting(
options.max_module_instances, configuration,
'--max_module_instances'), options.use_mtime_file_watcher,
None if supports_watcher_ignore_re else UnsupportedOption,
options.automatic_restart, options.allow_skipped_files,
DevelopmentServer._create_module_to_setting(
options.threadsafe_override, configuration,
'--threadsafe_override'),
options.external_port if supports_external_port else UnsupportedOption
]
dispatcher_args = [
x for x in dispatcher_args if not x is UnsupportedOption
]
_create_dispatcher.singleton = dispatcher.Dispatcher(*dispatcher_args)
return _create_dispatcher.singleton
def _make_dispatcher(app_config):
"""Make a new dispatcher with the given ApplicationConfigurationStub."""
return dispatcher.Dispatcher(app_config,
'localhost',
1,
'gmail.com',
1,
php_config=None,
python_config=None,
cloud_sql_config=None,
vm_config=None,
module_to_max_instances={},
use_mtime_file_watcher=False,
automatic_restart=True,
allow_skipped_files=False,
module_to_threadsafe_override={})
def _create_dispatcher(configuration, options):
from google.appengine.tools.devappserver2 import dispatcher
from google.appengine.tools.devappserver2.devappserver2 import (
DevelopmentServer, _LOG_LEVEL_TO_RUNTIME_CONSTANT
)
from google.appengine.tools.sdk_update_checker import GetVersionObject, \
_VersionList
if hasattr(_create_dispatcher, "singleton"):
return _create_dispatcher.singleton
dispatcher_args = [
configuration,
options.host,
options.port,
options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
DevelopmentServer._create_php_config(options),
DevelopmentServer._create_python_config(options),
DevelopmentServer._create_java_config(options),
DevelopmentServer._create_cloud_sql_config(options),
DevelopmentServer._create_vm_config(options),
DevelopmentServer._create_module_to_setting(options.max_module_instances,
configuration, '--max_module_instances'),
options.use_mtime_file_watcher,
options.automatic_restart,
options.allow_skipped_files,
DevelopmentServer._create_module_to_setting(options.threadsafe_override,
configuration, '--threadsafe_override')
]
# External port is a new flag introduced in 1.9.19
current_version = _VersionList(GetVersionObject()['release'])
if current_version >= _VersionList('1.9.19') or \
current_version == TEMP_1_9_49_VERSION_NO:
dispatcher_args.append(options.external_port)
if current_version >= _VersionList('1.9.50'):
dispatcher_args.insert(7, DevelopmentServer._create_go_config(options))
if current_version >= _VersionList('1.9.22') or \
current_version == TEMP_1_9_49_VERSION_NO:
dispatcher_args.insert(8, None) # Custom config setting
_create_dispatcher.singleton = dispatcher.Dispatcher(*dispatcher_args)
return _create_dispatcher.singleton
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
logging.getLogger().setLevel(
_LOG_LEVEL_TO_PYTHON_CONSTANT[options.dev_appserver_log_level])
configuration = application_configuration.ApplicationConfiguration(
options.config_paths, options.app_id)
if options.enable_cloud_datastore:
# This requires the oauth server stub to return that the logged in user
# is in fact an admin.
os.environ['OAUTH_IS_ADMIN'] = '1'
gcd_module = application_configuration.ModuleConfiguration(
gcd_application.generate_gcd_app(
configuration.app_id.split('~')[1]))
configuration.modules.append(gcd_module)
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
# There is no good way to set the default encoding from application code
# (it needs to be done during interpreter initialization in site.py or
# sitecustomize.py) so just warn developers if they have a different
# encoding than production.
if sys.getdefaultencoding() != _PROD_DEFAULT_ENCODING:
logging.warning(
'The default encoding of your local Python interpreter is set to %r '
'while App Engine\'s production environment uses %r; as a result '
'your code may behave differently when deployed.',
sys.getdefaultencoding(), _PROD_DEFAULT_ENCODING)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id)
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
self._create_php_config(options),
self._create_python_config(options),
self._create_java_config(options),
self._create_cloud_sql_config(options),
self._create_vm_config(options),
self._create_module_to_setting(options.max_module_instances,
configuration,
'--max_module_instances'),
options.use_mtime_file_watcher, options.automatic_restart,
options.allow_skipped_files,
self._create_module_to_setting(options.threadsafe_override,
configuration,
'--threadsafe_override'))
request_data = wsgi_request_info.WSGIRequestInfo(self._dispatcher)
storage_path = _get_storage_path(options.storage_path,
configuration.app_id)
apis = self._create_api_server(request_data, storage_path, options,
configuration)
apis.start()
self._running_modules.append(apis)
self._dispatcher.start(options.api_host, apis.port, request_data)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
self._options = options
logging.getLogger().setLevel(constants.LOG_LEVEL_TO_PYTHON_CONSTANT[
options.dev_appserver_log_level])
parsed_env_variables = dict(options.env_variables or [])
configuration = application_configuration.ApplicationConfiguration(
config_paths=options.config_paths,
app_id=options.app_id,
runtime=options.runtime,
env_variables=parsed_env_variables)
if options.google_analytics_client_id:
metrics_logger = metrics.GetMetricsLogger()
metrics_logger.Start(
options.google_analytics_client_id,
options.google_analytics_user_agent,
{module.runtime
for module in configuration.modules},
{module.env or 'standard'
for module in configuration.modules})
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
# There is no good way to set the default encoding from application code
# (it needs to be done during interpreter initialization in site.py or
# sitecustomize.py) so just warn developers if they have a different
# encoding than production.
if sys.getdefaultencoding() != constants.PROD_DEFAULT_ENCODING:
logging.warning(
'The default encoding of your local Python interpreter is set to %r '
'while App Engine\'s production environment uses %r; as a result '
'your code may behave differently when deployed.',
sys.getdefaultencoding(), constants.PROD_DEFAULT_ENCODING)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id)
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
constants.LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
self._create_php_config(options),
self._create_python_config(options),
self._create_java_config(options), self._create_go_config(options),
self._create_custom_config(options),
self._create_cloud_sql_config(options),
self._create_vm_config(options),
self._create_module_to_setting(options.max_module_instances,
configuration,
'--max_module_instances'),
options.use_mtime_file_watcher, options.watcher_ignore_re,
options.automatic_restart, options.allow_skipped_files,
self._create_module_to_setting(options.threadsafe_override,
configuration,
'--threadsafe_override'),
options.external_port)
wsgi_request_info_ = wsgi_request_info.WSGIRequestInfo(
self._dispatcher)
storage_path = api_server.get_storage_path(options.storage_path,
configuration.app_id)
apiserver = api_server.create_api_server(
wsgi_request_info_, storage_path, options, configuration.app_id,
configuration.modules[0].application_root)
apiserver.start()
self._running_modules.append(apiserver)
self._dispatcher.start(options.api_host, apiserver.port,
wsgi_request_info_)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
try:
default = self._dispatcher.get_module_by_name('default')
apiserver.set_balanced_address(default.balanced_address)
except request_info.ModuleDoesNotExistError:
logging.warning('No default module found. Ignoring.')
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
logging.getLogger().setLevel(constants.LOG_LEVEL_TO_PYTHON_CONSTANT[
options.dev_appserver_log_level])
configuration = application_configuration.ApplicationConfiguration(
options.config_paths, options.app_id)
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id,
configuration.modules[0].version_id)
python_config = runtime_config_pb2.PythonConfig()
if options.python_startup_script:
python_config.startup_script = os.path.abspath(
options.python_startup_script)
if options.python_startup_args:
python_config.startup_args = options.python_startup_args
php_executable_path = (options.php_executable_path and os.path.abspath(
options.php_executable_path))
cloud_sql_config = runtime_config_pb2.CloudSQL()
cloud_sql_config.mysql_host = options.mysql_host
cloud_sql_config.mysql_port = options.mysql_port
cloud_sql_config.mysql_user = options.mysql_user
cloud_sql_config.mysql_password = options.mysql_password
if options.mysql_socket:
cloud_sql_config.mysql_socket = options.mysql_socket
if options.max_module_instances is None:
module_to_max_instances = {}
elif isinstance(options.max_module_instances, int):
module_to_max_instances = {
module_configuration.module_name: options.max_module_instances
for module_configuration in configuration.modules
}
else:
module_to_max_instances = options.max_module_instances
if options.threadsafe_override is None:
module_to_threadsafe_override = {}
elif isinstance(options.threadsafe_override, bool):
module_to_threadsafe_override = {
module_configuration.module_name: options.threadsafe_override
for module_configuration in configuration.modules
}
else:
module_to_threadsafe_override = options.threadsafe_override
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
constants.LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
php_executable_path, options.php_remote_debugging, python_config,
cloud_sql_config, module_to_max_instances,
options.use_mtime_file_watcher, options.automatic_restart,
options.allow_skipped_files, module_to_threadsafe_override,
options.external_api_port)
request_data = wsgi_request_info.WSGIRequestInfo(self._dispatcher)
storage_path = api_server.get_storage_path(options.storage_path,
configuration.app_id)
apis = api_server.create_api_server(
request_data, storage_path, options, configuration.app_id,
configuration.modules[0].application_root)
apis.start()
self._running_modules.append(apis)
self._dispatcher.start(apis.port, request_data)
self._running_modules.append(self._dispatcher)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
logging.getLogger().setLevel(
_LOG_LEVEL_TO_PYTHON_CONSTANT[options.dev_appserver_log_level])
configuration = application_configuration.ApplicationConfiguration(
options.yaml_files, options.app_id)
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
if options.port == 0:
logging.warn('DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id, configuration.modules[0].version_id)
python_config = runtime_config_pb2.PythonConfig()
if options.python_startup_script:
python_config.startup_script = os.path.abspath(
options.python_startup_script)
if options.python_startup_args:
python_config.startup_args = options.python_startup_args
cloud_sql_config = runtime_config_pb2.CloudSQL()
cloud_sql_config.mysql_host = options.mysql_host
cloud_sql_config.mysql_port = options.mysql_port
cloud_sql_config.mysql_user = options.mysql_user
cloud_sql_config.mysql_password = options.mysql_password
if options.mysql_socket:
cloud_sql_config.mysql_socket = options.mysql_socket
if options.max_module_instances is None:
module_to_max_instances = {}
elif isinstance(options.max_module_instances, int):
module_to_max_instances = {
module_configuration.module_name: options.max_module_instances
for module_configuration in configuration.modules}
else:
module_to_max_instances = options.max_module_instances
self._dispatcher = dispatcher.Dispatcher(
configuration,
options.host,
options.port,
options.auth_domain,
_LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
options.php_executable_path,
options.php_remote_debugging,
python_config,
cloud_sql_config,
module_to_max_instances,
options.use_mtime_file_watcher,
options.automatic_restart,
options.allow_skipped_files,
options.external_api_port)
request_data = wsgi_request_info.WSGIRequestInfo(self._dispatcher)
storage_path = _get_storage_path(options.storage_path, configuration.app_id)
datastore_path = options.datastore_path or os.path.join(storage_path,
'datastore.db')
logs_path = options.logs_path or os.path.join(storage_path, 'logs.db')
xsrf_path = os.path.join(storage_path, 'xsrf')
search_index_path = options.search_indexes_path or os.path.join(
storage_path, 'search_indexes')
prospective_search_path = options.prospective_search_path or os.path.join(
storage_path, 'prospective-search')
blobstore_path = options.blobstore_path or os.path.join(storage_path,
'blobs')
if options.clear_datastore:
_clear_datastore_storage(datastore_path)
if options.clear_prospective_search:
_clear_prospective_search_storage(prospective_search_path)
if options.clear_search_indexes:
_clear_search_indexes_storage(search_index_path)
if options.auto_id_policy==datastore_stub_util.SEQUENTIAL:
logging.warn("--auto_id_policy='sequential' is deprecated. This option "
"will be removed in a future release.")
application_address = '%s' % options.host
if options.port and options.port != 80:
application_address += ':' + str(options.port)
user_login_url = '/%s?%s=%%s' % (login.LOGIN_URL_RELATIVE,
login.CONTINUE_PARAM)
user_logout_url = '%s&%s=%s' % (user_login_url, login.ACTION_PARAM,
login.LOGOUT_ACTION)
if options.datastore_consistency_policy == 'time':
consistency = datastore_stub_util.TimeBasedHRConsistencyPolicy()
elif options.datastore_consistency_policy == 'random':
consistency = datastore_stub_util.PseudoRandomHRConsistencyPolicy()
elif options.datastore_consistency_policy == 'consistent':
consistency = datastore_stub_util.PseudoRandomHRConsistencyPolicy(1.0)
else:
assert 0, ('unknown consistency policy: %r' %
options.datastore_consistency_policy)
api_server.maybe_convert_datastore_file_stub_data_to_sqlite(
configuration.app_id, datastore_path)
api_server.setup_stubs(
request_data=request_data,
app_id=configuration.app_id,
application_root=configuration.modules[0].application_root,
# The "trusted" flag is only relevant for Google administrative
# applications.
trusted=getattr(options, 'trusted', False),
blobstore_path=blobstore_path,
datastore_path=datastore_path,
datastore_consistency=consistency,
datastore_require_indexes=options.require_indexes,
datastore_auto_id_policy=options.auto_id_policy,
images_host_prefix='http://%s' % application_address,
logs_path=logs_path,
mail_smtp_host=options.smtp_host,
mail_smtp_port=options.smtp_port,
mail_smtp_user=options.smtp_user,
mail_smtp_password=options.smtp_password,
mail_enable_sendmail=options.enable_sendmail,
mail_show_mail_body=options.show_mail_body,
matcher_prospective_search_path=prospective_search_path,
search_index_path=search_index_path,
taskqueue_auto_run_tasks=options.enable_task_running,
taskqueue_default_http_server=application_address,
uaserver_path=options.uaserver_path,
user_login_url=user_login_url,
user_logout_url=user_logout_url,
xmpp_path=options.xmpp_path)
# The APIServer must bind to localhost because that is what the runtime
# instances talk to.
apis = api_server.APIServer('localhost', options.api_port,
configuration.app_id)
apis.start()
self._running_modules.append(apis)
self._running_modules.append(self._dispatcher)
self._dispatcher.start(apis.port, request_data)
admin = admin_server.AdminServer(options.admin_host, options.admin_port,
self._dispatcher, configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
"""
self._options = options
logging.getLogger().setLevel(constants.LOG_LEVEL_TO_PYTHON_CONSTANT[
options.dev_appserver_log_level])
parsed_env_variables = dict(options.env_variables or [])
configuration = application_configuration.ApplicationConfiguration(
config_paths=options.config_paths,
app_id=options.app_id,
runtime=options.runtime,
env_variables=parsed_env_variables)
if options.google_analytics_client_id:
metrics_logger = metrics.GetMetricsLogger()
metrics_logger.Start(
options.google_analytics_client_id,
options.google_analytics_user_agent,
{module.runtime
for module in configuration.modules},
{module.env or 'standard'
for module in configuration.modules})
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
# There is no good way to set the default encoding from application code
# (it needs to be done during interpreter initialization in site.py or
# sitecustomize.py) so just warn developers if they have a different
# encoding than production.
if sys.getdefaultencoding() != constants.PROD_DEFAULT_ENCODING:
logging.warning(
'The default encoding of your local Python interpreter is set to %r '
'while App Engine\'s production environment uses %r; as a result '
'your code may behave differently when deployed.',
sys.getdefaultencoding(), constants.PROD_DEFAULT_ENCODING)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
_setup_environ(configuration.app_id)
# grpc_proxy is only needed for python2 because remote_api_stub.py is
# imported in local python runtime sandbox. For more details, see
# grpc_proxy_util.py.
grpc_proxy_port = portpicker.PickUnusedPort()
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
constants.LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
self._create_php_config(options),
self._create_python_config(options, grpc_proxy_port),
self._create_java_config(options), self._create_go_config(options),
self._create_custom_config(options),
self._create_cloud_sql_config(options),
self._create_vm_config(options),
self._create_module_to_setting(options.max_module_instances,
configuration,
'--max_module_instances'),
options.use_mtime_file_watcher, options.watcher_ignore_re,
options.automatic_restart, options.allow_skipped_files,
self._create_module_to_setting(options.threadsafe_override,
configuration,
'--threadsafe_override'),
options.external_port)
wsgi_request_info_ = wsgi_request_info.WSGIRequestInfo(
self._dispatcher)
storage_path = api_server.get_storage_path(options.storage_path,
configuration.app_id)
datastore_emulator_host = (
parsed_env_variables['DATASTORE_EMULATOR_HOST']
if 'DATASTORE_EMULATOR_HOST' in parsed_env_variables else None)
apiserver = api_server.create_api_server(
wsgi_request_info_, storage_path, options, configuration.app_id,
configuration.modules[0].application_root, datastore_emulator_host)
apiserver.start()
self._running_modules.append(apiserver)
if options.grpc_apis:
grpc_apiserver = api_server.GRPCAPIServer(options.grpc_api_port)
grpc_apiserver.start()
self._running_modules.append(grpc_apiserver)
# We declare grpc_proxy_util as global, otherwise it cannot be accessed
# from outside of this function.
global grpc_proxy_util
# pylint: disable=g-import-not-at-top
# We lazy import here because grpc binaries are not always present.
from google.appengine.tools.devappserver2 import grpc_proxy_util
grpc_proxy = grpc_proxy_util.GrpcProxyServer(grpc_proxy_port)
grpc_proxy.start()
self._running_modules.append(grpc_proxy)
self._dispatcher.start(options.api_host, apiserver.port,
wsgi_request_info_, options.grpc_apis)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path)
admin.start()
self._running_modules.append(admin)
try:
default = self._dispatcher.get_module_by_name('default')
apiserver.set_balanced_address(default.balanced_address)
except request_info.ModuleDoesNotExistError:
logging.warning('No default module found. Ignoring.')
def start(self, options):
"""Start devappserver2 servers based on the provided command line arguments.
Args:
options: An argparse.Namespace containing the command line arguments.
Raises:
PhpPathError: php executable path is not specified for php72.
MissingDatastoreEmulatorError: dev_appserver.py is not invoked from the right
directory.
"""
self._options = options
self._options.datastore_emulator_cmd = self._correct_datastore_emulator_cmd(
self._options.datastore_emulator_cmd)
self._check_datastore_emulator_support()
logging.getLogger().setLevel(constants.LOG_LEVEL_TO_PYTHON_CONSTANT[
options.dev_appserver_log_level])
parsed_env_variables = dict(options.env_variables or [])
configuration = application_configuration.ApplicationConfiguration(
config_paths=options.config_paths,
app_id=options.app_id,
runtime=options.runtime,
env_variables=parsed_env_variables)
all_module_runtimes = {
module.runtime
for module in configuration.modules
}
self._check_platform_support(all_module_runtimes)
storage_path = api_server.get_storage_path(options.storage_path,
configuration.app_id)
datastore_path = api_server.get_datastore_path(storage_path,
options.datastore_path)
datastore_data_type = (
datastore_converter.get_stub_type(datastore_path)
if os.path.isfile(datastore_path) else None)
if options.skip_sdk_update_check:
logging.info('Skipping SDK update check.')
else:
update_checker.check_for_updates(configuration)
# There is no good way to set the default encoding from application code
# (it needs to be done during interpreter initialization in site.py or
# sitecustomize.py) so just warn developers if they have a different
# encoding than production.
if sys.getdefaultencoding() != constants.PROD_DEFAULT_ENCODING:
logging.warning(
'The default encoding of your local Python interpreter is set to %r '
'while App Engine\'s production environment uses %r; as a result '
'your code may behave differently when deployed.',
sys.getdefaultencoding(), constants.PROD_DEFAULT_ENCODING)
if options.port == 0:
logging.warn(
'DEFAULT_VERSION_HOSTNAME will not be set correctly with '
'--port=0')
util.setup_environ(configuration.app_id)
php_version = self._get_php_runtime(configuration)
if not options.php_executable_path and php_version == 'php72':
raise PhpPathError(
'For php72, --php_executable_path must be specified.')
if options.ssl_certificate_path and options.ssl_certificate_key_path:
ssl_certificate_paths = self._create_ssl_certificate_paths_if_valid(
options.ssl_certificate_path, options.ssl_certificate_key_path)
else:
if options.ssl_certificate_path or options.ssl_certificate_key_path:
logging.warn('Must provide both --ssl_certificate_path and '
'--ssl_certificate_key_path to enable SSL. Since '
'only one flag was provided, not using SSL.')
ssl_certificate_paths = None
if options.google_analytics_client_id:
metrics_logger = metrics.GetMetricsLogger()
metrics_logger.Start(
options.google_analytics_client_id,
options.google_analytics_user_agent,
all_module_runtimes,
{module.env or 'standard'
for module in configuration.modules},
options.support_datastore_emulator,
datastore_data_type,
bool(ssl_certificate_paths),
options,
multi_module=len(configuration.modules) > 1,
dispatch_config=configuration.dispatch is not None,
)
self._dispatcher = dispatcher.Dispatcher(
configuration, options.host, options.port, options.auth_domain,
constants.LOG_LEVEL_TO_RUNTIME_CONSTANT[options.log_level],
self._create_php_config(options, php_version),
self._create_python_config(options),
self._create_java_config(options), self._create_go_config(options),
self._create_custom_config(options),
self._create_cloud_sql_config(options),
self._create_vm_config(options),
self._create_module_to_setting(options.max_module_instances,
configuration,
'--max_module_instances'),
options.use_mtime_file_watcher, options.watcher_ignore_re,
options.automatic_restart, options.allow_skipped_files,
self._create_module_to_setting(options.threadsafe_override,
configuration,
'--threadsafe_override'),
options.external_port, options.specified_service_ports,
options.enable_host_checking, ssl_certificate_paths)
wsgi_request_info_ = wsgi_request_info.WSGIRequestInfo(
self._dispatcher)
apiserver = api_server.create_api_server(
wsgi_request_info_, storage_path, options, configuration.app_id,
configuration.modules[0].application_root)
apiserver.start()
self._running_modules.append(apiserver)
self._dispatcher.start(options.api_host, apiserver.port,
wsgi_request_info_)
xsrf_path = os.path.join(storage_path, 'xsrf')
admin = admin_server.AdminServer(options.admin_host,
options.admin_port, self._dispatcher,
configuration, xsrf_path,
options.enable_host_checking,
options.enable_console)
admin.start()
self._running_modules.append(admin)
try:
default = self._dispatcher.get_module_by_name('default')
apiserver.set_balanced_address(default.balanced_address)
except request_info.ModuleDoesNotExistError:
logging.warning('No default module found. Ignoring.')
