def handle(self, params, *args): serverid = params['serverid'] new_game_state = params['game_state'] game_name = new_game_state['name'] _match_maker.update_player_names(serverid, game_name, new_game_state) return {'success': True, 'backend': backends.get_backend()}
def overlayGenerateExport(request, key, type): if request.method == 'GET': return (HttpResponse('<form action="." method="post">' + '<input type="submit" name="submit"' + ' value="Create Export Archive"/>' + '</form>')) elif request.method == 'POST': if settings.USING_APP_ENGINE: onFrontEndInstance = (backends.get_backend() == None) if onFrontEndInstance: # on app engine, quadTree generation may take too long # for a frontend instance, so we pass it to a backend taskqueue.add(url='/backend' + request.path, target='processing') return HttpResponse('{"result": "ok"}', content_type='application/json') overlay = get_object_or_404(Overlay, key=key) if type == 'html': overlay.generateHtmlExport() elif type == 'kml': overlay.generateKmlExport() elif type == 'geotiff': overlay.generateGeotiffExport() else: return HttpResponse('{"result": "error! Export type invalid."}', content_type='application/json') return HttpResponse('{"result": "ok"}', content_type='application/json') else: return HttpResponseNotAllowed(['GET', 'POST'])
def schedule_check(self, service_slug, delay=0, tries_count=0, last_status_slug="", backend=None): taskqueue.add( url="/services-check/check", queue_name="services-active-checks", countdown=delay, target=(backends.get_backend() if not backend else backend), params={"service-slug": service_slug, "tries-count": tries_count, "last-status": last_status_slug}, )
def handle(self, params, *args): if _PAIRING_KEY != params['pairing_key']: return {'success': False, 'exception': 'bad pairing key'} controller_port = params['controller_port'] ip = self.request.remote_addr controller_host = '%s:%d' % (ip, controller_port) params['controller_host'] = controller_host _match_maker.update_server_info(params) return {'success': True, 'backend': backends.get_backend(), 'controller_host': controller_host}
def shutdown(self): server_name = backends.get_backend() servers = memcache.get('servers') if servers is None: servers = dict() servers[server_name] = 0 else: if server_name not in servers: servers[server_name] = 0 else: servers[server_name] = servers[server_name] - 1 memcache.set('servers', servers)
def process(self): logging.info('Backend running') server_name = backends.get_backend() logging.info(server_name) servers = memcache.get('servers') if servers is None: servers = dict() servers[server_name] = 1 else: if server_name not in servers: servers[server_name] = 1 else: servers[server_name] = servers[server_name] + 1 memcache.set('servers', servers) logservice.flush() runtime.set_shutdown_hook(self.shutdown) self.response.set_status(200) return
def overlayGenerateExport(request, key): if request.method == 'GET': return (HttpResponse ('<form action="." method="post">' + '<input type="submit" name="submit"' + ' value="Create Export Archive"/>' + '</form>')) elif request.method == 'POST': if settings.USING_APP_ENGINE: onFrontEndInstance = (backends.get_backend() == None) if onFrontEndInstance: # on app engine, quadTree generation may take too long # for a frontend instance, so we pass it to a backend taskqueue.add(url='/backend' + request.path, target='processing') return HttpResponse('{"result": "ok"}', content_type='application/json') overlay = get_object_or_404(Overlay, key=key) overlay.generateExport() return HttpResponse('{"result": "ok"}', content_type='application/json') else: return HttpResponseNotAllowed(['GET', 'POST'])
def api_unified(self): logging.info(backends.get_backend()) self.components.cache('public') query = self.request.params.get('q') users = get_all_users_local_cached() groups = google_directory.get_groups_list_cached() if query: query = query.lower() users = filter( lambda x: query in x['name']['fullName'].lower() or query in x['primaryEmail'].lower(), users) groups = filter( lambda x: query in x['name'].lower() or query in x['email'].lower(), groups) users.extend(groups) if not 'nolimit' in self.request.params: users = users[:DEFAULT_LIMIT] self.context['data'] = users
def api_unified(self): logging.info(backends.get_backend()) self.components.cache('public') query = self.request.params.get('q') users = get_all_users_local_cached() groups = google_directory.get_groups_list_cached() if query: query = query.lower() users = filter( lambda x: query in x['name']['fullName'].lower() or query in x[ 'primaryEmail'].lower(), users) groups = filter( lambda x: query in x['name'].lower() or query in x['email']. lower(), groups) users.extend(groups) if not 'nolimit' in self.request.params: users = users[:DEFAULT_LIMIT] self.context['data'] = users
def __get__(self, request, obj_type=None): if not hasattr(request, '_cached_user'): if request.path.startswith('/public'): # treat requests on /public URLs as unauthenticated so # we can avoid hitting the user table user = None else: user = users.get_current_user() if user: try: request._cached_user = User.objects.get(email=user.email()) except ObjectDoesNotExist: if users.is_current_user_admin(): # bootstrap -- treat any app engine admin user as a django superuser u = User.objects.create_superuser(user.nickname(), user.email(), None) request._cached_user = u else: # user logged in through app engine but not somebody we know request._cached_user = AnonymousUser() else: onBackEndInstance = (backends.get_backend() != None) if onBackEndInstance: # if the request was forwarded to a backend # instance, it will not have any credentials # attached, but should be treated as an admin # request. bit of a hack. request._cached_user = User(username='******', email='*****@*****.**', is_superuser=True, is_staff=True, is_active=True) else: request._cached_user = AnonymousUser() return request._cached_user
def handle(self, params, *args): _match_maker.del_game(params['serverid'], params['name']) return {'success': True, 'backend': backends.get_backend()}
def inner(self, *args, **kwargs): if USE_BACKENDS and backends.get_backend() != BACKEND_NAME: return self.redirect( backends.get_url(BACKEND_NAME) + self.request.path_qs) return f(self, *args, **kwargs)
def _get_taskqueue_target(): return '%d.%s' % (backends.get_instance(), backends.get_backend())
def post(self): logging.info(str(backends.get_backend()) + "I'm a backend..") return ".. I'm working"
import random import sys import traceback import urllib import webapp2 # constants _DEBUG = True _JSON_ENCODER = json.JSONEncoder() if _DEBUG: _JSON_ENCODER.indent = 4 _JSON_ENCODER.sort_keys = True if backends.get_backend() == 'matcher': _match_maker = matcher.MatchMaker() _EMAIL_SCOPE = "https://www.googleapis.com/auth/userinfo.email" _IS_DEVELOPMENT = os.environ['SERVER_SOFTWARE'].startswith('Development/') ####################################################################### # common functions ####################################################################### def tojson(python_object): """Helper function to output and optionally pretty print JSON.""" return _JSON_ENCODER.encode(python_object) def fromjson(msg):
import stats_backend #needed for backends from google.appengine.api import urlfetch #needed for backends import os; import webapp2 #needed for backends import cgi import datetime import urllib import json import logging import wsgiref.handlers from types import * _BACKEND_NAME='statgather' #needed for backends if backends.get_backend() == _BACKEND_NAME: _stats = stats_backend.StatsGather() def tojson(python_object): """Helper function to output and optionally pretty print JSON.""" return json.JSONEncoder().encode(python_object) def fromjson(msg): """Helper function to ingest JSON.""" try: return json.loads(msg) except Exception, e: raise Exception('Unable to parse as JSON: %s' % msg) #-----------------------------------------------------
def inner(self, *args, **kwargs): if USE_BACKENDS and backends.get_backend() != BACKEND_NAME: return self.redirect(backends.get_url(BACKEND_NAME) + self.request.path_qs) return f(self, *args, **kwargs)
def ThisIsPlaygroundApp(): """Determines whether this is the playground app id.""" if common.IsDevMode(): return not backends.get_backend() return app_identity.get_application_id() == appids.PLAYGROUND_APP_ID
class RunTask(webapp.RequestHandler): def post(self): if backends.get_backend() != "queue-issue" and settings.GOOGLE_APP_ENGINE_LIVE: logging.warn("Only the queue-issue backend can call /run_task/") return return self.response.out.write("OK") # }}} # init application {{{ application = webapp.WSGIApplication([ ('/run_task/', RunTask), # login: admin ('/enqueue_tasks/', EnqueueTasks), # login: admin ], debug=True) def main(): run_wsgi_app(application) # }}} # init the events-logger backend {{{ if backends.get_backend() == "queue-issue": tools.debug("%s-backend" % backends.get_backend(), "%s-backend-initiated" % backends.get_backend(), \ {"instance_id": backends.get_instance(), "backend_instance_url": backends.get_url(instance=backends.get_instance()), "backend_load_balancer_url": backends.get_url() }) # }}} if __name__ == '__main__': main()
def post(self): if backends.get_backend() != "queue-issue" and settings.GOOGLE_APP_ENGINE_LIVE: logging.warn("Only the queue-issue backend can call /run_task/") return return self.response.out.write("OK")
from google.appengine.api import users, app_identity, backends, memcache from google.appengine.ext import ndb from webapp2_extras import jinja2 from webapp2_extras import sessions import jsonrpc # Initialize constants & stuff for static files VERSION_ID = os.environ.get('CURRENT_VERSION_ID', '1.1').split('.') VERSION = VERSION_ID[0] APP_VERSION = int(VERSION_ID[1]) APP_ID = app_identity.get_application_id() IS_DEV = os.environ.get('SERVER_SOFTWARE', 'Development/%s' % VERSION_ID).startswith('Dev') IS_BACKEND = backends.get_backend() is not None # Bot user agents BOT_USER_AGENTS = [ 'Googlebot', 'Yahoo! Slurp', 'YahooSeeker', 'bingbot', 'iaskspider' ] def user_required(handler): """ Decorator for checking if there's a user associated with the current session.
import stats_backend #needed for backends from google.appengine.api import urlfetch #needed for backends import os import webapp2 #needed for backends import cgi import datetime import urllib import json import logging import wsgiref.handlers from types import * _BACKEND_NAME = 'statgather' #needed for backends if backends.get_backend() == _BACKEND_NAME: _stats = stats_backend.StatsGather() def tojson(python_object): """Helper function to output and optionally pretty print JSON.""" return json.JSONEncoder().encode(python_object) def fromjson(msg): """Helper function to ingest JSON.""" try: return json.loads(msg) except Exception, e: raise Exception('Unable to parse as JSON: %s' % msg)
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.''' from google.appengine.api import apiproxy_stub_map from google.appengine.api import backends from google.appengine.api import runtime import datetime import logging _NAME = '{}.{} {} ({})'.format(backends.get_backend(), backends.get_instance(), backends.get_url(), datetime.datetime.now()) def my_shutdown_hook(): logging.warning('{} SHUTDOWN HOOK CALLED'.format(_NAME)) apiproxy_stub_map.apiproxy.CancelApiCalls() # save_state() # May want to raise an exception # register our shutdown hook, which is not guaranteed to be called logging.info('{} REGISTERING SHUTDOWN HOOK'.format(_NAME)) runtime.set_shutdown_hook(my_shutdown_hook)
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.''' from google.appengine.api import apiproxy_stub_map from google.appengine.api import backends from google.appengine.api import runtime import datetime import logging _NAME = '{}.{} {} ({})'.format(backends.get_backend(), backends.get_instance(), backends.get_url(), datetime.datetime.now()) def my_shutdown_hook(): logging.warning('{} SHUTDOWN HOOK CALLED'.format(_NAME)) apiproxy_stub_map.apiproxy.CancelApiCalls() # save_state() # May want to raise an exception # register our shutdown hook, which is not guaranteed to be called logging.info('{} REGISTERING SHUTDOWN HOOK'.format(_NAME)) runtime.set_shutdown_hook(my_shutdown_hook)
from google.appengine.api import backends from google.appengine.api import runtime from google.appengine.api import users from google.appengine.ext import webapp from google.appengine.ext.webapp import template import cgi import datetime import logging import os import urllib my_name = '%s.%s (%s)' % (backends.get_backend(), backends.get_instance(), backends.get_url()) logging.info(my_name + ' is registering shutdown hook') def my_shutdown_hook(): logging.warning('shutdown hook called') apiproxy_stub_map.apiproxy.CancelApiCalls() # save_state() # May want to raise an exception # register our shutdown hook, which is not guaranteed to be called runtime.set_shutdown_hook(my_shutdown_hook)