def _setup_stubs(self): # If this code is being run without an appserver (eg. via a django # commandline flag) then setup a default stub environment. if not have_appserver: from google.appengine.tools import dev_appserver_main args = dev_appserver_main.DEFAULT_ARGS.copy() args['datastore_path'], args['blobstore_path'], args[ 'history_path'] = self._get_paths() from google.appengine.tools import dev_appserver dev_appserver.SetupStubs(appid, **args) # If we're supposed to set up the remote_api, do that now. if self.remote: self.setup_remote()
def setup_local_stubs(self, connection): if self.active_stubs == 'local': return from .base import get_datastore_paths from google.appengine.tools import dev_appserver_main args = dev_appserver_main.DEFAULT_ARGS.copy() args.update(get_datastore_paths(connection.settings_dict)) log_level = logging.getLogger().getEffectiveLevel() logging.getLogger().setLevel(logging.WARNING) from google.appengine.tools import dev_appserver dev_appserver.SetupStubs(appid, **args) logging.getLogger().setLevel(log_level) self.active_stubs = 'local'
def prep_local_shell(): """Prepares a local shell by adjusting the datastore paths according to the settings and setting up the appropriate stubs.""" import settings args = dev_appserver_main.DEFAULT_ARGS.copy() # If a custom datastore directory is requested, modify the args for each # of the datastore paths if hasattr(settings, 'DATASTORE_DIR'): ddir = settings.DATASTORE_DIR for key in ('datastore_path', 'history_path', 'blobstore_path'): args[key] = os.path.join(ddir, os.path.basename(args[key])) # Finally, set up the stubs dev_appserver.SetupStubs(env.gae.app_id, **args)
def start_server(root_path=ROOT_PATH, port=PORT): dev_appserver.SetupStubs(get_appid(), login_url=LOGIN_URL, datastore_path='/dev/null', history_path='/dev/null', blobstore_path='/dev/null', clear_datastore=False) server = dev_appserver.CreateServer(ROOT_PATH, LOGIN_URL, port, '/unused/templates/path') server_thread = threading.Thread(target=server.serve_forever) server_thread.setDaemon(True) server_thread.start() return port
def _setup_environment(): from google.appengine.tools import dev_appserver config = stub_config.copy() config['root_path'] = os.getcwd() config['blobstore_path'] = tempfile.mkdtemp() config['datastore_path'] = tempfile.mktemp() config['high_replication'] = True dev_appserver.SetupStubs('unittest', **config) import logging logging.getLogger().setLevel(logging.DEBUG)
def _setup_stubs(self): # If this code is being run without an appserver (eg. via a django # commandline flag) then setup a default stub environment. if not have_appserver: from google.appengine.tools import dev_appserver_main args = dev_appserver_main.DEFAULT_ARGS.copy() args.update(self._get_paths()) log_level = logging.getLogger().getEffectiveLevel() logging.getLogger().setLevel(logging.WARNING) from google.appengine.tools import dev_appserver dev_appserver.SetupStubs(appid, **args) logging.getLogger().setLevel(log_level) # If we're supposed to set up the remote_api, do that now. if self.remote: self.setup_remote()
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 start_server(root_path=ROOT_PATH, port=PORT, app_id=APP_ID): dev_appserver.ApplicationLoggingHandler.InitializeTemplates( 'HEADER', 'SCRIPT', 'MIDDLE', 'FOOTER') dev_appserver.SetupStubs(app_id, login_url=LOGIN_URL, datastore_path='/dev/null', history_path='/dev/null', clear_datastore=False) server = dev_appserver.CreateServer(ROOT_PATH, LOGIN_URL, port, '/unused/templates/path') server_thread = threading.Thread(target=server.serve_forever) server_thread.setDaemon(True) server_thread.start() return port
def setup(): # Appengine needs this setup. os.environ["SERVER_SOFTWARE"] = "Dev" os.environ["AUTH_DOMAIN"] = "gmail.com" os.environ["USER_EMAIL"] = "*****@*****.**" datastore_path = rel_path("rietveld_datastore") history_path = rel_path("rietveld_datastore_history") options = {"datastore_path": datastore_path, "history_path": history_path, "clear_datastore": False, "login_url": "/_ah/login", } dev_appserver.SetupStubs("codereview", **options) # Rietveld needs its template libraries loaded like this. library_name = "codereview.library" if not libraries.get(library_name, None): add_to_builtins(library_name)
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 setup_local_stubs(self, connection): if self.active_stubs == 'local': return from .base import get_datastore_paths from google.appengine.tools import dev_appserver_main args = dev_appserver_main.DEFAULT_ARGS.copy() args.update(get_datastore_paths(connection.settings_dict)) args.update(connection.settings_dict.get('DEV_APPSERVER_OPTIONS', {})) log_level = logging.getLogger().getEffectiveLevel() logging.getLogger().setLevel(logging.WARNING) try: from google.appengine.tools import dev_appserver except ImportError: from google.appengine.tools import old_dev_appserver as dev_appserver dev_appserver.SetupStubs('dev~' + appid, **args) logging.getLogger().setLevel(log_level) self.active_stubs = 'local'
def setup_for_testing(require_indexes=True, define_queues=[]): """Sets up the stubs for testing. Args: require_indexes: True if indexes should be required for all indexes. define_queues: Additional queues that should be available. """ from google.appengine.api import apiproxy_stub_map from google.appengine.api import memcache from google.appengine.api import queueinfo from google.appengine.tools import dev_appserver from google.appengine.tools import dev_appserver_index before_level = logging.getLogger().getEffectiveLevel() try: logging.getLogger().setLevel(100) root_path = os.path.realpath(os.path.dirname(__file__)) dev_appserver.SetupStubs( TEST_APP_ID, root_path=root_path, login_url='', datastore_path=tempfile.mktemp(suffix='datastore_stub'), history_path=tempfile.mktemp(suffix='datastore_history'), blobstore_path=tempfile.mktemp(suffix='blobstore_stub'), require_indexes=require_indexes, clear_datastore=False) dev_appserver_index.SetupIndexes(TEST_APP_ID, root_path) # Actually need to flush, even though we've reallocated. Maybe because the # memcache stub's cache is at the module level, not the API stub? memcache.flush_all() finally: logging.getLogger().setLevel(before_level) taskqueue_stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue') taskqueue_stub.queue_yaml_parser = ( lambda x: queueinfo.LoadSingleQueue( 'queue:\n- name: default\n rate: 1/s\n' + '\n'.join('- name: %s\n rate: 1/s' % name for name in define_queues)))
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)
#!/usr/bin/python import sys import os APP_ENGINE = '/home/jzegan/google_appengine' sys.path.insert(0, APP_ENGINE) # so that import dev_appserver dev_appserver.fix_sys_path() APP_PATH = os.path.abspath("/home/jzegan/code/udacityplus/uplusprofiles") sys.path.insert(0, APP_PATH) # for the No api proxy found for service "memcache"; # http://blairconrad.wordpress.com/2010/02/20/automated-testing-using-app-engine-service-apis-and-a-memcaching-memoizer/ from google.appengine.tools import dev_appserver as das from google.appengine.tools.dev_appserver_main import ParseArguments args, option_dict = ParseArguments( sys.argv) # Otherwise the option_dict isn't populated. das.SetupStubs('local', **option_dict) import unittest from datastore import user_test suite1 = user_test.suite() suite = unittest.TestSuite() suite.addTest(suite1) unittest.TextTestRunner(verbosity=2).run(suite)
not dev_process.IsSubprocess()): server = MakeRpcServer(option_dict) if skip_sdk_update_check: logging.info('Skipping update check.') else: update_check = appcfg.UpdateCheck(server, appinfo) update_check.CheckSupportedVersion() if update_check.AllowedToCheckForUpdates(): update_check.CheckForUpdates() if dev_process.IsSubprocess(): logging.getLogger().setLevel(logging.WARNING) try: dev_appserver.SetupStubs(appinfo.application, **option_dict) except: exc_type, exc_value, exc_traceback = sys.exc_info() logging.error(str(exc_type) + ': ' + str(exc_value)) logging.debug(''.join(traceback.format_exception( exc_type, exc_value, exc_traceback))) return 1 http_server = dev_appserver.CreateServer( root_path, login_url, port, sdk_dir=SDK_PATH, serve_address=address, allow_skipped_files=allow_skipped_files, static_caching=static_caching,
#!/usr/bin/env python -i """ A shell to play around with the local data, assuming: dev_appserver.py . --use_sqlite --datastore_path=tmp/data """ import os import logging from lib.environ import DATASTORE_PATH, setup_environ setup_environ() # Setup shell stubs from google.appengine.tools import dev_appserver_main from google.appengine.tools import dev_appserver app_id = os.environ['APPLICATION_ID'] kwargs = dev_appserver_main.DEFAULT_ARGS.copy() kwargs.update({ 'use_sqlite': True, 'datastore_path': DATASTORE_PATH # todo: blobstore, prospective search }) dev_appserver.SetupStubs(app_id, **kwargs) logging.info('DataStore Path: %s' % DATASTORE_PATH)
from google.appengine.ext import testbed from google.appengine.datastore import datastore_stub_util ## import sys from dev_appserver import EXTRA_PATHS sys.path = EXTRA_PATHS + sys.path from google.appengine.tools import dev_appserver from google.appengine.tools.dev_appserver_main import ParseArguments args, option_dict = ParseArguments( sys.argv) # Otherwise the option_dict isn't populated. dev_appserver.SetupStubs('local', **option_dict) from google.appengine.api import memcache ## from lib.models.models import User from lib.models.models import Company class ModelsTest(unittest.TestCase): def setUp(self): # First, create an instance of the Testbed class. self.testbed = testbed.Testbed() # Then activate the testbed, which prepares the service stubs for use. self.testbed.setup_env(app_id='evangeler') self.testbed.activate()
except dev_appserver.InvalidAppConfigError, e: logging.error('Application configuration file invalid:\n%s', e) return 1 if option_dict[ARG_ADMIN_CONSOLE_SERVER] != '': server = MakeRpcServer(option_dict) if skip_sdk_update_check: logging.info('Skipping update check.') else: update_check = appcfg.UpdateCheck(server, config) update_check.CheckSupportedVersion() if update_check.AllowedToCheckForUpdates(): update_check.CheckForUpdates() try: dev_appserver.SetupStubs(config.application, **option_dict) except: exc_type, exc_value, exc_traceback = sys.exc_info() logging.error(str(exc_type) + ': ' + str(exc_value)) logging.debug(''.join( traceback.format_exception(exc_type, exc_value, exc_traceback))) return 1 http_server = dev_appserver.CreateServer( root_path, login_url, port, template_dir, sdk_dir=SDK_PATH, serve_address=serve_address, require_indexes=require_indexes,
server = MakeRpcServer(option_dict) if skip_sdk_update_check: logging.info('Skipping update check.') else: update_check = sdk_update_checker.SDKUpdateChecker(server, appinfo) update_check.CheckSupportedVersion() if update_check.AllowedToCheckForUpdates(): update_check.CheckForUpdates() if dev_process.IsSubprocess(): logging.getLogger().setLevel(logging.WARNING) try: dev_appserver.SetupStubs(appinfo.application, _use_atexit_for_datastore_stub=True, **option_dict) except: exc_type, exc_value, exc_traceback = sys.exc_info() logging.error(str(exc_type) + ': ' + str(exc_value)) logging.debug(''.join(traceback.format_exception( exc_type, exc_value, exc_traceback))) return 1 frontend_port=option_dict.get(ARG_MULTIPROCESS_FRONTEND_PORT, None) if frontend_port is not None: frontend_port = int(frontend_port) http_server = dev_appserver.CreateServer( root_path, login_url, port,
def initialize_service_apis(): from google.appengine.tools import dev_appserver from google.appengine.tools.dev_appserver_main import ParseArguments args, option_dict = ParseArguments(sys.argv) # Otherwise the option_dict isn't populated. dev_appserver.SetupStubs('local', **option_dict)