def main(argv): """Runs the development application server.""" args, option_dict = ParseArguments(argv) if len(args) != 1: print >> sys.stderr, 'Invalid arguments' PrintUsageExit(1) root_path = args[0] log_level = option_dict[ARG_LOG_LEVEL] port = option_dict[ARG_PORT] datastore_path = option_dict[ARG_DATASTORE_PATH] login_url = option_dict[ARG_LOGIN_URL] template_dir = option_dict[ARG_TEMPLATE_DIR] serve_address = option_dict[ARG_ADDRESS] require_indexes = option_dict[ARG_REQUIRE_INDEXES] logging.basicConfig( level=log_level, format='%(levelname)-8s %(asctime)s %(filename)s] %(message)s') config = None try: config, matcher = dev_appserver.LoadAppConfig(root_path, {}) except yaml_errors.EventListenerError, e: logging.error('Fatal error when loading application configuration:\n' + str(e)) return 1
def LoadAppengineEnvironment(): """Loads the appengine environment. Returns: This function has no return value, but it sets the following parameters on this package: - appid: The name of the application - have_appserver: Boolean parameter which is True if the code is being run from within the appserver environment. """ global appid, have_appserver # Detect if we are running under an appserver. have_appserver = False stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3") if stub: have_appserver = True # Load the application identifier. if have_appserver: appid = os.environ.get("APPLICATION_ID", "unknown") else: # Running as manage.py script, read from config file. try: from google.appengine.tools import dev_appserver appconfig, unused_matcher = dev_appserver.LoadAppConfig( PARENT_DIR, {}) appid = appconfig.application except ImportError: # Something went wrong. appid = "unknown" logging.debug("Loading application '%s' %s an appserver" % (appid, have_appserver and "with" or "without"))
def LoadAppengineEnvironment(): """Loads the appengine environment. Returns: This function has no return value, but it sets the following parameters on this package: - appid: The name of the application. - have_appserver: Boolean parameter which is True if the code is being run from within the appserver environment. """ global appid, have_appserver from google.appengine.api import yaml_errors from google.appengine.api import apiproxy_stub_map # Detect if we are running under an appserver. have_appserver = False stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3") if stub: have_appserver = True # Load the application identifier. if have_appserver: appid = os.environ.get("APPLICATION_ID", "unknown") else: # Running as manage.py script, read from config file. try: from google.appengine.tools import dev_appserver appconfig, unused_matcher = dev_appserver.LoadAppConfig( PARENT_DIR, {}) appid = appconfig.application except (ImportError, yaml_errors.EventListenerYAMLError), e: logging.warn("Could not read the Application ID from app.yaml. " "This may break things in unusual ways!") # Something went wrong. appid = "unknown"
def LoadAppengineEnvironment(): """Loads the appengine environment. Returns: This function has no return value, but it sets the following parameters on this package: - appid: The name of the application as read from the config file. - appconfig: The appserver configuration dictionary for the application, as read from the config file. - have_appserver: Boolean parameter which is True if the code is being run from within the appserver environment. """ global appid, appconfig, have_appserver # Load the application configuration. try: from google.appengine.tools import dev_appserver appconfig, unused_matcher = dev_appserver.LoadAppConfig(".", {}) appid = appconfig.application except ImportError: # Running under the real appserver. appconfig = {} appid = "unknown" # Detect if we are running under an appserver. have_appserver = False stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3") if stub: have_appserver = True logging.debug("Loading application '%s' %s an appserver" % (appid, have_appserver and "with" or "without"))
def setup_environ(): # lib sys.path.insert(0, os.path.join(ROOT_PATH, 'lib')) # SDK (this will be simpler if SDK is in the codebase) sdk_path = None for path in os.environ.get('PATH').split(os.pathsep): if 'dev_appserver.py' in os.listdir(path): test_path = os.path.join(path, 'dev_appserver.py') sdk_path = os.path.dirname( os.readlink(test_path) if os.path.islink(test_path ) else test_path) break if not sdk_path: logging.critical("Can't find sdk_path") sys.exit(1) sys.path.insert(0, sdk_path) # Use dev_appserver to set up the python path from dev_appserver import fix_sys_path fix_sys_path() from google.appengine.tools import dev_appserver as tools_dev_appserver from google.appengine import dist # Parse `app.yaml` appinfo, url_matcher, from_cache = tools_dev_appserver.LoadAppConfig( ROOT_PATH, {}, default_partition='dev') app_id = appinfo.application # Useful for later scripts os.environ['APPLICATION_ID'] = app_id os.environ['APPLICATION_VERSION'] = appinfo.version # Third party libraries on the path if appinfo.libraries: for library in appinfo.libraries: try: dist.use_library(library.name, library.version) except ValueError, e: if library.name == 'django' and library.version == '1.4': # Work around an SDK issue logging.warn( 'django 1.4 not recognised by dist, fixing python path' ) sys.path.insert( 0, os.path.join(sdk_path, 'lib', 'django-1.4')) else: logging.warn('Unsupported library:\n%s\n' % e) # Extra setup for django if library.name == 'django': try: import settings from django.core.management import setup_environ setup_environ(settings, original_settings_path='settings') except ImportError: logging.error("Could not import django settings")
def main(argv): """Runs the development application server.""" args, option_dict = ParseArguments(argv) if len(args) != 1: print >>sys.stderr, 'Invalid arguments' PrintUsageExit(1) root_path = args[0] if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict: auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN'] dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain if '_ENABLE_LOGGING' in option_dict: enable_logging = option_dict['_ENABLE_LOGGING'] dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging log_level = option_dict[ARG_LOG_LEVEL] option_dict['root_path'] = os.path.realpath(root_path) logging.getLogger().setLevel(log_level) default_partition = option_dict[ARG_DEFAULT_PARTITION] appinfo = None try: appinfo, _, _ = dev_appserver.LoadAppConfig( root_path, {}, default_partition=default_partition) except yaml_errors.EventListenerError, e: logging.error('Fatal error when loading application configuration:\n%s', e) return 1
def main(): p = optparse.OptionParser(usage="%prog [options]") default = "/tmp/dev_appserver.datastore" p.add_option( "--datastore_path", default=default, help= ("Path to datastore file. This must match the value used for " "the same option when running dev_appserver.py if you want to view the data. " "Default: %s" % default)) default = "/tmp/dev_appserver.datastore.history" p.add_option( "--history_path", default=default, help= ("Path to datastore history file. This doesn't need to match the one you use for " "dev_appserver.py. Default: %s" % default)) default = "/usr/local/google_appengine" p.add_option("--google_path", default=default, help=("Path to google module directory. Default: %s" % default)) (options, args) = p.parse_args() if not os.path.exists(options.google_path): p.error( "Could not find google module path at %s. You'll need to specify the path" % options.google_path) groot = options.google_path sys.path.append(groot) sys.path.append(os.path.join(groot, "lib/django")) sys.path.append(os.path.join(groot, "lib/webob")) sys.path.append(os.path.join(groot, "lib/yaml/lib")) from google.appengine.tools import dev_appserver from gblog import models from tests import datasets config, explicit_matcher = dev_appserver.LoadAppConfig( os.path.dirname(__file__), {}) dev_appserver.SetupStubs( config.application, clear_datastore=False, # just removes the files when True datastore_path=options.datastore_path, history_path=options.history_path, login_url=None) datafixture = GoogleDatastoreFixture(env=models, style=NamedDataStyle()) data = datafixture.data(datasets.CommentData, datasets.EntryData) data.setup() print "Data loaded into datastore %s" % (options.datastore_path or "[default]")
def main(argv): """Runs the development application server.""" args, option_dict = ParseArguments(argv) if len(args) != 1: print >> sys.stderr, 'Invalid arguments' PrintUsageExit(1) version_tuple = tuple(sys.version_info[:2]) if ARG_MULTIPROCESS not in option_dict and WARN_ABOUT_PYTHON_VERSION: if version_tuple < PRODUCTION_VERSION: sys.stderr.write( 'Warning: You are using a Python runtime (%d.%d) that ' 'is older than the production runtime environment ' '(%d.%d). Your application may be dependent on Python ' 'behaviors that have changed and may not work correctly ' 'when deployed to production.\n' % (version_tuple[0], version_tuple[1], PRODUCTION_VERSION[0], PRODUCTION_VERSION[1])) if version_tuple > PRODUCTION_VERSION: sys.stderr.write( 'Warning: You are using a Python runtime (%d.%d) that ' 'is more recent than the production runtime environment ' '(%d.%d). Your application may use features that are not ' 'available in the production environment and may not work ' 'correctly when deployed to production.\n' % (version_tuple[0], version_tuple[1], PRODUCTION_VERSION[0], PRODUCTION_VERSION[1])) root_path = args[0] if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict: auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN'] dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain if '_ENABLE_LOGGING' in option_dict: enable_logging = option_dict['_ENABLE_LOGGING'] dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging log_level = option_dict[ARG_LOG_LEVEL] option_dict['root_path'] = os.path.realpath(root_path) logging.getLogger().setLevel(log_level) appinfo = None try: appinfo, matcher = dev_appserver.LoadAppConfig(root_path, {}) except yaml_errors.EventListenerError, e: logging.error( 'Fatal error when loading application configuration:\n%s', e) return 1
def get_appid(): from google.appengine.api import apiproxy_stub_map have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = os.environ.get('APPLICATION_ID') else: try: from google.appengine.tools import dev_appserver from kay import PROJECT_DIR from google.appengine.tools.dev_appserver import GetVersionObject version = GetVersionObject() if version and version.get('timestamp', 0) >= 1318895182: # if GAE 1.6 or high appconfig, unused, cache = dev_appserver.LoadAppConfig( PROJECT_DIR, {}) else: appconfig, unused = dev_appserver.LoadAppConfig( PROJECT_DIR, {}) appid = appconfig.application except ImportError: appid = None return appid
def get_appid(): from google.appengine.api import apiproxy_stub_map have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = os.environ.get('APPLICATION_ID') else: try: from google.appengine.tools import dev_appserver appconfig, unused, unused = dev_appserver.LoadAppConfig( os.path.dirname(os.path.abspath(__file__)), {}) appid = appconfig.application except ImportError: appid = None return appid
def get_versionid(): from google.appengine.api import apiproxy_stub_map have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: versionid = os.environ.get('CURRENT_VERSION_ID') else: try: from google.appengine.tools import dev_appserver from kay import PROJECT_DIR appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {}) versionid = appconfig.version except ImportError: versionid = None return versionid
def main(argv): """Runs the development application server.""" args, option_dict = ParseArguments(argv) if len(args) != 1: print >> sys.stderr, 'Invalid arguments' PrintUsageExit(1) root_path = args[0] for suffix in ('yaml', 'yml'): path = os.path.join(root_path, 'app.%s' % suffix) if os.path.exists(path): api_version = SetPaths(path) break else: logging.error("Application configuration file not found in %s" % root_path) return 1 SetGlobals() dev_appserver.API_VERSION = api_version if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict: auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN'] dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain if '_ENABLE_LOGGING' in option_dict: enable_logging = option_dict['_ENABLE_LOGGING'] dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging log_level = option_dict[ARG_LOG_LEVEL] port = option_dict[ARG_PORT] datastore_path = option_dict[ARG_DATASTORE_PATH] login_url = option_dict[ARG_LOGIN_URL] template_dir = option_dict[ARG_TEMPLATE_DIR] serve_address = option_dict[ARG_ADDRESS] require_indexes = option_dict[ARG_REQUIRE_INDEXES] allow_skipped_files = option_dict[ARG_ALLOW_SKIPPED_FILES] static_caching = option_dict[ARG_STATIC_CACHING] logging.basicConfig( level=log_level, format='%(levelname)-8s %(asctime)s %(filename)s] %(message)s') config = None try: config, matcher = dev_appserver.LoadAppConfig(root_path, {}) except yaml_errors.EventListenerError, e: logging.error('Fatal error when loading application configuration:\n' + str(e)) return 1
def setup_appserver(): """ Set up appserver stubs as in dev_appserver. """ # these require setup_path to have been run from google.appengine.tools import dev_appserver from google.appengine.tools.dev_appserver_main import * option_dict = DEFAULT_ARGS.copy() option_dict[ARG_CLEAR_DATASTORE] = True # path to app: root_path = os.path.join(os.path.dirname(__file__), '..') (config, matcher) = dev_appserver.LoadAppConfig(root_path, {}) # commented out stuff here that checked for SDK updates dev_appserver.SetupStubs(config.application, **option_dict)
def setup(): from google.appengine.tools import dev_appserver from google.appengine.tools.dev_appserver_main import ( ARG_CLEAR_DATASTORE, ARG_LOG_LEVEL, DEFAULT_ARGS, logging, ) option_dict = DEFAULT_ARGS.copy() option_dict[ARG_CLEAR_DATASTORE] = True logging.basicConfig( level=option_dict[ARG_LOG_LEVEL], format="%(levelname)-8s %(asctime)s %(filename)s] %(message)s") config, matcher = dev_appserver.LoadAppConfig(root_path, {}) dev_appserver.SetupStubs(config.application, **option_dict)
def load_appengine_environment(): """ Loads the appengine environment. """ global APP_ID from google.appengine.api import yaml_errors from google.appengine.api import apiproxy_stub_map stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3") # Detect if we are running under an appserver. try: from google.appengine.tools import dev_appserver appconfig, unused_matcher, options = dev_appserver.LoadAppConfig( project_dir, {}) APP_ID = appconfig.application except (ImportError, yaml_errors.EventListenerYAMLError), e: logging.warn("Could not read the Application ID from app.yaml. " "This may break things in unusual ways!") # Something went wrong. APP_ID = "unknown"
def main(argv): """Runs the development application server.""" args, option_dict = ParseArguments(argv) if len(args) != 1: print >>sys.stderr, 'Invalid arguments' PrintUsageExit(1) root_path = args[0] if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict: auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN'] dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain if '_ENABLE_LOGGING' in option_dict: enable_logging = option_dict['_ENABLE_LOGGING'] dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging log_level = option_dict[ARG_LOG_LEVEL] port = option_dict[ARG_PORT] login_url = option_dict[ARG_LOGIN_URL] template_dir = option_dict[ARG_TEMPLATE_DIR] serve_address = option_dict[ARG_ADDRESS] require_indexes = option_dict[ARG_REQUIRE_INDEXES] allow_skipped_files = option_dict[ARG_ALLOW_SKIPPED_FILES] static_caching = option_dict[ARG_STATIC_CACHING] skip_sdk_update_check = option_dict[ARG_SKIP_SDK_UPDATE_CHECK] option_dict['root_path'] = os.path.realpath(root_path) logging.getLogger().setLevel(log_level) config = None try: config, matcher = dev_appserver.LoadAppConfig(root_path, {}) except yaml_errors.EventListenerError, e: logging.error('Fatal error when loading application configuration:\n' + str(e)) return 1
def startup_appengine(gae_path='/usr/local/google_appengine', clear_datastore=False): # set up app engine paths sys.path.append(gae_path) sys.path.append(os.path.join(gae_path, "lib/django")) sys.path.append(os.path.join(gae_path, "lib/webob")) sys.path.append(os.path.join(gae_path, "lib/yaml/lib")) sys.path.append(os.path.join(gae_path, "lib/antlr3")) # set up dev app server from google.appengine.tools import dev_appserver config, explicit_matcher = dev_appserver.LoadAppConfig(chirp_root, {}) from appengine_django.db.base import get_datastore_paths datastore_path, history_path = get_datastore_paths() if clear_datastore: print "clearing datastore" dev_appserver.SetupStubs(config.application, clear_datastore=clear_datastore, datastore_path=datastore_path, history_path=history_path, login_url=None)
def setup_environ(): """ This func will import the required modules and set up enough of an appengine environment to let some of our management commands run inside the SDK sandbox """ # add the lib directory to the sytem path sys.path.insert(0, os.path.join(ROOT_PATH, 'vendor')) # Find the path on which the SDK is installed sdk_path = None for path in os.environ.get('PATH').split(os.pathsep): if not os.path.exists(path): continue if 'dev_appserver.py' in os.listdir(path): test_path = os.path.join(path, 'dev_appserver.py') sdk_path = os.path.dirname(os.readlink(test_path) if os.path.islink(test_path) else test_path) break # crap out if we can't find the SDK if not sdk_path: sys.stderr.write("Fatal: Can't find sdk_path") sys.exit(1) # add the SDK path to the system path sys.path.insert(0, sdk_path) # Use dev_appserver to set up the python path from dev_appserver import fix_sys_path fix_sys_path() from google.appengine.tools import dev_appserver as tools_dev_appserver from google.appengine import dist # Parse `app.yaml` appinfo, url_matcher, from_cache = tools_dev_appserver.LoadAppConfig( ROOT_PATH, {}, default_partition='dev') app_id = appinfo.application # Useful for later scripts os.environ['APPLICATION_ID'] = app_id os.environ['APPLICATION_VERSION'] = appinfo.version # Add third-party libs to the system path if appinfo.libraries: for library in appinfo.libraries: try: dist.use_library(library.name, library.version) except ValueError, e: if library.name == 'django' and library.version == '1.5': # Work around an SDK issue # print 'Warning: django 1.5 not recognised by dist, fixing python path' sys.path.insert(0, os.path.join(sdk_path, 'lib', 'django-1.5')) elif library.name == 'webapp2' and library.version == '2.5.2': sys.path.insert(0, os.path.join(sdk_path, 'lib', 'webapp2-2.5.2')) elif library.name == 'webob' and library.version == '1.2.3': sys.path.insert(0, os.path.join(sdk_path, 'lib', 'webob-1.2.3')) elif library.name == 'PIL': try: from PIL import Image except ImportError: print 'Warning: Make sure you have PIL installed locally' else: print 'Warning: Unsupported library:\n%s\n' % e # Extra setup for django if library.name == 'django': try: from config import settings from django.core.management import setup_environ setup_environ(settings) except ImportError: sys.stderr.write("\nWarning! Could not import django settings")
import os from google.appengine.api.app_identity import get_application_id from google.appengine.api import apiproxy_stub_map server_software = os.environ.get('SERVER_SOFTWARE', '') have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) appid = None if have_appserver: appid = get_application_id() else: try: project_dir = os.path.dirname(os.path.abspath(os.path.dirname(os.path.dirname(__file__)))) from google.appengine.tools import dev_appserver appconfig, matcher, from_cache = dev_appserver.LoadAppConfig(project_dir, {}) appid = appconfig.application except ImportError: appid = None #: ``True`` if running in the dev server, ``False`` otherwise. on_development_server = bool(have_appserver and (not server_software or server_software.lower().startswith('devel'))) #: ``True`` if running on a google server, ``False`` otherwise. on_server = bool(have_appserver and appid and server_software and not on_development_server) #: ``True`` if running on a google server and the application ID ends in ``-int``, ``False`` otherwise. on_integration_server = on_server and appid.lower().endswith('-int') #: ``True`` if running on a google server and the application ID does not end in ``-int``, ``False`` otherwise. on_production_server = on_server and not on_integration_server
import os from google.appengine.api import apiproxy_stub_map from google.appengine.api.app_identity import get_application_id have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = get_application_id() else: try: from google.appengine.tools import dev_appserver from .boot import PROJECT_DIR appconfig = dev_appserver.LoadAppConfig(PROJECT_DIR, {}, default_partition='dev')[0] appid = appconfig.application.split('~', 1)[-1] #appid = 'woyingng' except ImportError, e: raise Exception("Could not get appid. Is your app.yaml file missing? " "Error was: %s" % e) on_production_server = have_appserver and \ not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')
from google.appengine.api import apiproxy_stub_map import os, sys have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = os.environ.get('APPLICATION_ID') else: try: from google.appengine.tools import dev_appserver from aecmd import PROJECT_DIR appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {}) appid = appconfig.application except ImportError: appid = None on_production_server = not (os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel') or sys.argv[0].endswith('manage.py'))
from google.appengine.api import apiproxy_stub_map import os have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = os.environ.get('APPLICATION_ID') else: try: from google.appengine.tools import dev_appserver from .boot import PROJECT_DIR try: appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {}) except ValueError: # https://bitbucket.org/wkornewald/django-nonrel/issue/13/managepy-test-broken-with-gae-sdk-16 appconfig, unused, from_cache = dev_appserver.LoadAppConfig( PROJECT_DIR, {}) appid = appconfig.application except ImportError, e: raise Exception('Could not get appid. Is your app.yaml file missing? ' 'Error was: %s' % e) on_production_server = have_appserver and \ not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')
from google.appengine.api import apiproxy_stub_map from google.appengine.api.app_identity import get_application_id import os have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3')) if have_appserver: appid = get_application_id() else: try: from google.appengine.tools import dev_appserver from .boot import PROJECT_DIR appconfig = dev_appserver.LoadAppConfig(PROJECT_DIR, {})[0] appid = appconfig.application except ImportError, e: raise Exception('Could not get appid. Is your app.yaml file missing? ' 'Error was: %s' % e) on_production_server = have_appserver and \ not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')