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 _get_taskqueue_target():
return '%d.%s' % (backends.get_instance(), 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 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")
def post(self):
logging.info(str(backends.get_backend()) + "I'm a backend..")
return ".. I'm working"
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.
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
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)
