def post(self, task_id=None):
request = self.parse_body()
bot_id = request.get('id')
task_id = request.get('task_id', '')
message = request.get('message', 'unknown')
bot_management.bot_event(
event_type='task_error', bot_id=bot_id,
external_ip=self.request.remote_addr, dimensions=None, state=None,
version=None, quarantined=None, task_id=task_id, task_name=None,
message=message)
line = (
'Bot: https://%s/restricted/bot/%s\n'
'Task failed: https://%s/user/task/%s\n'
'%s') % (
app_identity.get_default_version_hostname(), bot_id,
app_identity.get_default_version_hostname(), task_id,
message)
ereporter2.log_request(self.request, source='bot', message=line)
msg = log_unexpected_keys(
self.EXPECTED_KEYS, request, self.request, 'bot', 'keys')
if msg:
self.abort_with_error(400, error=msg)
msg = task_scheduler.bot_kill_task(
task_pack.unpack_run_result_key(task_id), bot_id)
if msg:
logging.error(msg)
self.abort_with_error(400, error=msg)
self.send_response({})
def __init__(self):
host = get_default_version_hostname()
if 'micro' in host:
self.admin_url = 'http://admin.byucoaching.com'
self.home_url = 'http://www.byucoaching.com'
else:
self.home_url = '{}{}'.format(self.protocol, host)
self.admin_url = '{}admin.{}'.format(self.protocol, get_default_version_hostname())
def api_ticket_details(self, e_key=None):
evt = self.util.decode_key(e_key).get()
if evt.seat_map_url is None or evt.seat_map_url == "":
evt.seat_map_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=evt.seat_map)
evt.put()
if evt.photo_url is None or evt.photo_url == "":
evt.photo_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=evt.photo)
evt.put()
evt_details = Event.find_event(evt)
self.context['data'] = evt_details
def static_url(relative_url):
host = os.environ["HTTP_HOST"].lower()
if not get_default_version_hostname() or not host.endswith(".iktel.nl"):
return relative_url
else:
# when using a wildcard url to serve a nondefault version, ensure
# static urls point at the correct nondefault version
match = re.match(r"([\w-]+)\.wild\.khanacademie\.nl", host)
if match:
version = match.group(1)
return "http://%s.%s%s" % (version, get_default_version_hostname(), relative_url)
else:
return "http://%s.%s" % (get_default_version_hostname(), relative_url)
def get(self):
userinfo = {}
user = users.get_current_user()
if user:
userinfo['id'] = user.user_id()
userinfo['email'] = user.email()
userinfo['nickname'] = user.nickname()
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
template_values = {
'hostname': app_identity.get_default_version_hostname(),
'userinfo': userinfo,
'url': url,
'url_linktext': url_linktext,
}
path = os.path.join(os.path.dirname(__file__), '../templates/home.html')
self.response.out.write(template.render(path, template_values))
def _PerformBuildbucketBisect(bisect_job):
config_dict = bisect_job.GetConfigDict()
if 'recipe_tester_name' not in config_dict:
logging.error('"recipe_tester_name" required in bisect jobs '
'that use buildbucket. Config: %s', config_dict)
return {'error': 'No "recipe_tester_name" given.'}
try:
bisect_job.buildbucket_job_id = buildbucket_service.PutJob(
_MakeBuildbucketBisectJob(bisect_job))
bisect_job.SetStarted()
hostname = app_identity.get_default_version_hostname()
job_id = bisect_job.buildbucket_job_id
issue_url = 'https://%s/buildbucket_job_status/%s' % (hostname, job_id)
bug_comment = ('Bisect started; track progress at '
'<a href="%s">%s</a>' % (issue_url, issue_url))
LogBisectResult(bisect_job.bug_id, bug_comment)
return {
'issue_id': job_id,
'issue_url': issue_url,
}
except httplib2.HttpLib2Error as e:
return {
'error': ('Could not start job because of the following exception: ' +
e.message),
}
def get_deployment(self):
"""Shows server environment and deployment information page."""
template_values = {}
template_values['page_title'] = self.format_title('Deployment')
template_values['page_description'] = messages.DEPLOYMENT_DESCRIPTION
# Yaml file content.
yaml_content = safe_dom.NodeList()
yaml_content.append(
safe_dom.Element('h3').add_text('Contents of ').add_child(
safe_dom.Element('code').add_text('app.yaml')))
ol = safe_dom.Element('ol')
yaml_content.append(ol)
yaml_lines = open(os.path.join(os.path.dirname(
__file__), '../../app.yaml'), 'r').readlines()
for line in yaml_lines:
ol.add_child(safe_dom.Element('li').add_text(line))
# Application identity.
app_id = app.get_application_id()
app_dict = {}
app_dict['application_id'] = escape(app_id)
app_dict['default_ver_hostname'] = escape(
app.get_default_version_hostname())
template_values['main_content'] = safe_dom.NodeList().append(
self.render_dict(app_dict, 'About the Application')
).append(
yaml_content
).append(
self.render_dict(os.environ, 'Server Environment Variables'))
self.render_page(template_values)
def _QueueChangeTestPatternsAndEmail(
self, entity, new_patterns, old_patterns):
deferred.defer(
_QueueChangeTestPatternsTasks, old_patterns, new_patterns)
user_email = users.get_current_user().email()
subject = 'Added or updated %s: %s by %s' % (
self._model_class.__name__, entity.key.string_id(), user_email)
email_key = entity.key.string_id()
email_body = _NOTIFICATION_EMAIL_BODY % {
'key': email_key,
'new_test_path_patterns': json.dumps(
list(new_patterns), indent=2, sort_keys=True,
separators=(',', ': ')),
'old_test_path_patterns': json.dumps(
list(old_patterns), indent=2, sort_keys=True,
separators=(',', ': ')),
'hostname': app_identity.get_default_version_hostname(),
'user': user_email,
}
mail.send_mail(
sender=_SENDER_ADDRESS,
to=_NOTIFICATION_ADDRESS,
subject=subject,
body=email_body)
def __init__(self):
self._configs = {
"heading": "Heading",
"subheading": "subheading",
"host": app_identity.get_default_version_hostname(),
"abstract": False,
"postnumperpage": 10,
"commentnumperpage": 10,
"feednum": 10,
"recentcommentnum": 10,
"recentpostnum": 10,
"blobEnable": False,
"picasaalbumname": "",
"gauid": "",
"baidusiteid": "",
}
for key in self._configs:
configure = Configure.get_by_id(key)
if configure:
setdict(self._configs, key, configure.value)
else:
configure = Configure(id=key)
configure.value = str(self._configs[key])
configure.put()
def api(name, version, description=None, hostname=None, audiences=None,
scopes=None, allowed_client_ids=None):
"""Decorate a ProtoRPC Service class for use by the framework above.
This decorator can be used to specify an API name, version, description, and
hostname for your API.
Sample usage (python 2.7):
@api_config.api(name='guestbook', version='v0.2',
description='Guestbook API')
class PostService(remote.Service):
pass
Sample usage (python 2.5):
class PostService(remote.Service):
pass
api_config.api(PostService, name='guestbook', version='v0.2',
description='Guestbook API')(PostService)
Args:
name: string, Name of the API.
version: string, Version of the API.
description: string, Short description of the API (Default: None)
hostname: string, Hostname of the API (Default: app engine default host)
audiences: list of strings, Acceptable audiences for authentication.
scopes: list of strings, Acceptable scopes for authentication.
allowed_client_ids: list of strings, Acceptable client IDs for auth.
Returns:
Class decorated with api_info attribute, an instance of ApiInfo.
"""
def apiserving_api_decorator(api_class):
"""Decorator for ProtoRPC class that configures Google's API server.
Args:
api_class: remote.Service class, ProtoRPC service class being wrapped.
Returns:
Same class with attributes assigned corresponding name, version, kwargs.
"""
api_class.api_info = _ApiInfo(
name, version, description=description, hostname=hostname,
audiences=audiences, scopes=scopes,
allowed_client_ids=allowed_client_ids)
return api_class
_CheckListType(scopes, basestring, 'scopes')
_CheckListType(audiences, basestring, 'audiences')
_CheckListType(allowed_client_ids, basestring, 'allowed_client_ids')
if hostname is None:
hostname = app_identity.get_default_version_hostname()
if audiences is None and hostname is not None:
audiences = [hostname]
if scopes is None:
scopes = [EMAIL_SCOPE]
if allowed_client_ids is None:
allowed_client_ids = [API_EXPLORER_CLIENT_ID]
return apiserving_api_decorator
def sentry_setup(data):
project_id = long(data['project_id'])
project = Project.get_by_id(project_id)
if project is None:
raise RecordNotFoundError('Project', project_id)
slug = sentry.create_project(project.name)
dsn = sentry.create_key(slug)
if 'Development' in os.environ['SERVER_SOFTWARE']:
app_url = 'http://'
else:
app_url = 'https://'
app_url += app_identity.get_default_version_hostname()
headers = {'Content-type': 'application/json'}
payload = urllib.urlencode({'kind': 'sentry', 'data': {'slug': slug, 'dsn': dsn}})
url = '{0}/projects/{1}/integrations'.format(app_url, project_id)
urlfetch.fetch(
url=url,
payload=payload,
method=urlfetch.POST,
headers=headers
)
def get_deployment(self):
"""Shows server environment and deployment information page."""
template_values = {}
template_values["page_title"] = self.format_title("Deployment")
template_values["page_description"] = messages.DEPLOYMENT_DESCRIPTION
# Yaml file content.
yaml_content = []
yaml_content.append("<h3>Contents of <code>app.yaml</code></h3>")
yaml_content.append("<ol>")
yaml_lines = open(os.path.join(os.path.dirname(__file__), "../../app.yaml"), "r").readlines()
for line in yaml_lines:
yaml_content.append("<li>%s</li>" % escape(line))
yaml_content.append("</ol>")
yaml_content = "".join(yaml_content)
# Application identity.
app_id = app.get_application_id()
app_dict = {}
app_dict["application_id"] = escape(app_id)
app_dict["default_ver_hostname"] = escape(app.get_default_version_hostname())
template_values["main_content"] = (
self.render_dict(app_dict, "About the Application")
+ yaml_content
+ self.render_dict(os.environ, "Server Environment Variables")
)
self.render_page(template_values)
def application_url():
"""
Get the application's current serving hostname by using the app_identity
service. Uses https:// by default for all appspot urls.
URLs can be manually over-ridden by setting a URL_MAP value in settings.py
URL_MAP = {'someapp.appspot.com': 'https://www.somedomain.com'}
"""
# check if running on the dev server
on_dev = os.environ['SERVER_SOFTWARE'].startswith('Development')
# get URL_MAP value from settings.py
URL_MAP = getattr(settings, 'URL_MAP', {})
# use the app_identity service to get the app's default hostname
hostname = app_identity.get_default_version_hostname()
# check if the url has been mapped in settings
if hostname in URL_MAP:
app_url = URL_MAP[hostname]
# use the appspot url over https://
elif on_dev:
app_url = 'http://' + hostname
else:
app_url = 'https://' + hostname
# return this application's current url
return app_url
def setup():
# app.yaml should already have ensured that the user is logged in as admin.
if not users.is_current_user_admin():
abort(401, "Sorry, only administrators can access this page.")
is_dev = os.environ.get('SERVER_SOFTWARE', '').startswith('Development')
setup_scheme = 'http' if is_dev else 'https'
setup_url = '%s://%s/setup' % (setup_scheme,
app_identity.get_default_version_hostname())
if request.url != setup_url:
redirect(setup_url)
result = ""
settings = GcmSettings.singleton()
if (request.forms.sender_id and request.forms.api_key and
request.forms.endpoint):
# Basic CSRF protection (will block some valid requests, like
# https://1-dot-johnme-gcm.appspot.com/setup but ohwell).
if request.get_header('Referer') != setup_url:
abort(403, "Invalid Referer.")
settings.endpoint = request.forms.endpoint
settings.sender_id = request.forms.sender_id
settings.api_key = request.forms.api_key
settings.put()
result = 'Updated successfully'
return template('setup', result=result,
endpoint=settings.endpoint,
sender_id=settings.sender_id,
api_key=settings.api_key)
def _GraphLink(test_key, rev):
"""Returns an HTML link to view the graph for an alert."""
test_path = utils.TestPath(test_key)
master, bot, test = test_path.split('/', 2)
query = '?masters=%s&bots=%s&tests=%s&rev=%s' % (master, bot, test, rev)
return '<a href="https://%s/report%s">%s/%s@%s</a>' % (
app_identity.get_default_version_hostname(), query, bot, test, rev)
def send_wo_created_email(self, wo_id, fix_by):
server_url = app_identity.get_default_version_hostname()
estimation_link = 'http://'+server_url+"/work_order/provide_estimate?work_order="+str(wo_id)
template_content = [
{'name':'work_order_id','content':self.display_id},
{'name':'store_name','content':self.appliance_obj.store.name},
{'name':'provider_address','content':self.provider_obj.address},
{'name':'store_address','content':self.store.address},
{'name':'store_name','content':self.store.name},
{'name':'store_manager_name','content':self.manager_user.name},
{'name':'store_manager_phone','content':self.manager_user.phone},
{'name':'store_billing_address','content':self.store.billing_address},
{'name':'appliance_name','content':self.appliance_obj.name},
{'name':'manufacturer','content':self.appliance_obj.manufacturer},
{'name':'model','content':self.appliance_obj.model},
{'name':'serial_num','content':self.appliance_obj.serial_num},
{'name':'warranty','content':self.appliance_obj.warranty},
{'name':'appliance_status','content':self.problem_description},
{'name':'service_type','content':self.priority},
{'name':'provider_name','content':self.provider_obj.name},
{'name':'accept_link','content':'<a class="mcnButton " title="ACCEPT" href="' + estimation_link + '&action=accept' + '" target="_blank" style="font-weight: bold;letter-spacing: normal;line-height: 100%;text-align: center;text-decoration: none;color: #FFFFFF;">ACCEPT</a>'},
{'name':'reject_link','content':'<a class="mcnButton " title="REJECT" href="' + estimation_link + '&action=reject' + '" target="_blank" style="font-weight: bold;letter-spacing: normal;line-height: 100%;text-align: center;text-decoration: none;color: #FFFFFF;">REJECT</a>'},
{'name':'fix_by','content':fix_by},
]
to = [{'email': self.provider_user.key().name(),'name':self.provider_user.name,'type':'to'}]
merge_vars = [{"rcpt": self.provider_user.key().name(),"vars": [{"name":"ROLE", "content":"provider"}]},
{"rcpt": self.owner_user.key().name(),"vars": [{"name":"ROLE", "content":"owner"}]},
{"rcpt": self.manager_user.key().name(),"vars": [{"name":"ROLE", "content":"manager"}]}]
send_mandrill_email('work-order-created-3', template_content, to, "Service Order created", merge_vars)
def send_wo_approval_email(self, estimate, service_date, technician):
server_url = app_identity.get_default_version_hostname()
link = 'http://'+server_url+'/work_order/list?work_order='+str(self.key().id())
template_content = [
{'name':'work_order_id','content':self.display_id},
{'name':'store_name','content':self.appliance_obj.store.name},
{'name':'fix_by','content':service_date},
{'name':'provider_name','content':self.provider_obj.name},
{'name':'provider_address','content':self.provider_obj.address},
{'name':'owner_name','content':self.owner_user.name},
{'name':'estimate','content':estimate},
{'name':'store_name','content':self.store.name},
{'name':'store_manager_name','content':self.manager_user.name},
{'name':'store_manager_phone','content':self.manager_user.phone},
{'name':'store_address','content':self.store.address},
{'name':'store_billing_address','content':self.store.billing_address},
{'name':'appliance_name','content':self.appliance_obj.name},
{'name':'manufacturer','content':self.appliance_obj.manufacturer},
{'name':'model','content':self.appliance_obj.model},
{'name':'serial_num','content':self.appliance_obj.serial_num},
{'name':'warranty','content':self.appliance_obj.warranty},
{'name':'application_status','content':self.problem_description},
{'name':'technician','content':technician},
{'name':'action_link','content':'<a class="mcnButton " title="TAKE ACTION" href="'+ link + '" target="_blank" style="font-weight: bold;letter-spacing: normal;line-height: 100%;text-align: center;text-decoration: none;color: #FFFFFF;">TAKE ACTION</a>'},
]
to = [{'email':self.owner_user.key().name(),'name':self.owner_user.name,'type':'to'}]
merge_vars = [{"rcpt": self.owner_user.key().name(),"vars": [{"name":"ROLE", "content":"owner"}]},
{"rcpt": self.manager_user.key().name(),"vars": [{"name":"ROLE", "content":"manager"}]}]
send_mandrill_email('approve-work-order-3', template_content, to, "Service Order - Request for approval", merge_vars)
def secure_url(url):
""" Given a Khan Academy URL (i.e. not to an external site), returns an
absolute https version of the URL, if possible.
Abstracts away limitations of https, such as non-support in vanity domains
and dev servers.
"""
if url.startswith("https://"):
return url
if App.is_dev_server:
# Dev servers can't handle https.
return url
_, netloc, path, query, fragment = _get_url_parts(url)
if netloc.lower().endswith(".khanacademie.nl"):
# Vanity domains can't handle https - but all the ones we own
# are simple CNAMEs to the default app engine instance.
# http://code.google.com/p/googleappengine/issues/detail?id=792
netloc = "%s.appspot.com" % get_default_version_hostname()
return urlparse.urlunsplit(("https", netloc, path, query, fragment))
def api_list(self):
evt = Event.list_all()
# logging.info("===EVT== 2:: %s" % evt)
list_e = []
for event in evt:
if event.seat_map_url is None or event.seat_map_url == "":
event.seat_map_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=event.seat_map)
event.put()
if event.photo_url is None or event.photo_url == "":
event.photo_url = "http://" + app_identity.get_default_version_hostname() + self.uri("download", blob=event.photo)
event.put()
list_e.append(event)
evt_messages = Event.to_message(list_e)
self.context['data'] = evt_messages
def get_hostname():
hostname = app_identity.get_default_version_hostname()
if 'testbed' not in os.environ.get('SERVER_SOFTWARE', 'testbed'):
current_version = modules.modules.get_current_version_name()
if current_version and modules.modules.get_default_version() != current_version:
hostname = '%s-dot-%s' % (current_version, hostname)
return hostname
def post(self):
(request, bot_id, version, state, dimensions, quarantined_msg) = self._process()
event = request.get("event")
if event not in ("bot_error", "bot_rebooting", "bot_shutdown"):
self.abort_with_error(400, error="Unsupported event type")
message = request.get("message")
bot_management.bot_event(
event_type=event,
bot_id=bot_id,
external_ip=self.request.remote_addr,
dimensions=dimensions,
state=state,
version=version,
quarantined=bool(quarantined_msg),
task_id=None,
task_name=None,
message=message,
)
if event == "bot_error":
line = ("Bot: https://%s/restricted/bot/%s\n" "Bot error:\n" "%s") % (
app_identity.get_default_version_hostname(),
bot_id,
message,
)
ereporter2.log_request(self.request, source="bot", message=line)
self.send_response({})
def bootstrap_templates():
TEMPLATES_DIR = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'templates')
template.bootstrap(
{'templates': TEMPLATES_DIR},
global_env={
'hostname': app_identity.get_default_version_hostname()
})
def post(self):
entries = simplejson.loads(zlib.decompress(self.request.body))
messages = Messages().messages_from_entries(entries)
if clients.update_clients(TOPIC_URL, messages) == 0:
hostname = app_identity.get_default_version_hostname()
pshb_client.unsubscribe(TOPIC_URL, 'http://' + hostname + '/subcb',
'http://www.pubsubhubbub.com',
'tokentokentoken')
def start_purchase(self, item):
account = self.util.decode_key(item.scalper_name).get()
params = {
'item': item.key,
'owner': account.email,
'purchaser': users.get_current_user(),
'status': 'NEW',
'secret': utils.random_alnum(16)
}
purchase = Purchase.create(params)
if settings.get('paypal').get('use_ipn'):
ipn_url = "%s/ipn/%s/%s/" % (self.request.host_url, purchase.key(), purchase.secret)
else:
ipn_url = None
if settings.get('paypal').get('use_chain'):
seller_paypal_email = utils.paypal_email(account.email)
else:
seller_paypal_email = None
pay = paypal.Pay(
item.quantity,
item.price,
"%s" % ("http://" + app_identity.get_default_version_hostname()),
# "%sreturn/%s/%s/" % (self.request.uri, purchase.key, purchase.secret),
"%s" % ("http://" + app_identity.get_default_version_hostname()),
# "%scancel/%s/" % (self.request.uri, purchase.key),
self.request.remote_addr,
seller_paypal_email,
ipn_url,
shipping=settings.get('paypal').get('shipping'))
purchase.debug_request = pay.raw_request
purchase.debug_response = pay.raw_response
purchase.paykey = pay.paykey()
purchase.put()
if pay.status() == 'CREATED':
purchase.status = 'CREATED'
purchase.put()
item.sold = True
item.put()
return (True, pay)
else:
purchase.status = 'ERROR'
purchase.put()
return (False, pay)
def get(self):
swarming_server = 'https://%s' % app_identity.get_default_version_hostname()
for machine_type_key in lease_management.MachineType.query().fetch(
keys_only=True):
lease_requests = lease_management.generate_lease_requests(
machine_type_key, swarming_server)
if lease_requests:
responses = machine_provider.lease_machines(lease_requests)
lease_management.update_leases(machine_type_key, responses)
def pipeline_status_url(self): # pragma: no cover
"""Returns a URL to look up the status of the pipeline."""
scheme = 'https'
if os.environ['APPLICATION_ID'].startswith('dev'):
scheme = 'http'
return '%s://%s/_ah/pipeline/status?root=%s&auto=false' % (
scheme,
app_identity.get_default_version_hostname(),
self.root_pipeline_id)
def get_config():
"""Fetches AuthOpenIDConfig from datastore or returns default instance."""
conf = AuthOpenIDConfig.get_by_id(id='default')
if not conf:
uri = '%s://%s/auth/openid/callback' % (
'http' if utils.is_local_dev_server() else 'https',
app_identity.get_default_version_hostname())
conf = AuthOpenIDConfig(id='default', redirect_uri=uri)
return conf
def get(self):
self.response.headers['Content-Type'] = 'text/xml'
logout_url = users.create_logout_url(self.request.uri)
server_url = app_identity.get_default_version_hostname()
posts = db.GqlQuery("SELECT * FROM Post ORDER BY adddate DESC LIMIT 10")
posts_dic = {"posts" : posts, "logout_url": logout_url, "server_url": server_url}
self.response.out.write(render_str('rss.xml', **posts_dic))
def _StartInstance(self, instance_name):
"""Creates Compute Engine instance with the given name."""
logging.info('Starting instance: ' + instance_name)
startup_script_template = jinja_environment.get_template(
os.path.join('worker', 'checkload.py'))
startup_script = startup_script_template.render({
'hostname': app_identity.get_default_version_hostname()
})
param = {
'kind': 'compute#instance',
'name': instance_name,
'zone': self._ApiUrl(paths=['zones', self.DEFAULT_ZONE]),
'image': self._ApiUrl(self.DEFAULT_IMAGE_PROJECT,
paths=['images', self.DEFAULT_IMAGE],
is_global=True),
'machineType': self._ApiUrl(
paths=['zones', self.DEFAULT_ZONE,
'machineTypes', self.DEFAULT_MACHINE_TYPE]),
'networkInterfaces': [
{
'kind': 'compute#networkInterface',
'network': self._ApiUrl(paths=['networks', 'default'],
is_global=True),
'accessConfigs': [
{
'type': 'ONE_TO_ONE_NAT',
'name': 'External NAT'
}
],
}
],
'serviceAccounts': [
{
'kind': 'compute#serviceAccount',
'email': 'default',
'scopes': [
'https://www.googleapis.com/auth/devstorage.read_only'
]
}
],
'metadata': {
'items': [
{
'key': 'startup-script',
'value': startup_script,
},
],
}
}
logging.info('Create instance with parameter: %s', str(param))
operation = self.compute_api.instances().insert(
project=self.PROJECT_ID, zone=self.DEFAULT_ZONE, body=param).execute()
logging.info('Create instance operation: %s', str(operation))
def get_urlfetch_service_id():
"""Returns a value for X-URLFetch-Service-Id header for GAE <-> GAE calls.
Usually it can be omitted. It is required in certain environments.
"""
if is_local_dev_server():
return 'LOCAL'
hostname = app_identity.get_default_version_hostname().split('.')
return hostname[-2].upper() if len(hostname) >= 3 else 'APPSPOT'
def GetDefaultVersionHostname(): # pragma: no cover.
"""Returns the default version hostname of this service."""
return app_identity.get_default_version_hostname()
def enqueue_task_async(url,
queue_name,
params=None,
payload=None,
name=None,
countdown=None,
use_dedicated_module=True,
version=None,
transactional=False):
"""Adds a task to a task queue.
If |use_dedicated_module| is True (default) the task will be executed by
a separate backend module instance that runs same version as currently
executing instance. If |version| is specified, the task will be executed by a
separate backend module instance of specified version. Otherwise it will run
on a current version of default module.
Returns True if the task was successfully added or a task with such name
existed before (i.e. on TombstonedTaskError exception): deduplicated task is
not a error.
Logs an error and returns False if task queue is acting up.
"""
assert not use_dedicated_module or version is None, (
'use_dedicated_module(%s) and version(%s) are both specified' %
(use_dedicated_module, version))
try:
headers = None
if use_dedicated_module:
headers = {'Host': get_task_queue_host()}
elif version is not None:
headers = {
'Host':
'%s-dot-%s-dot-%s' %
(version, _task_queue_module,
app_identity.get_default_version_hostname())
}
# Note that just using 'target=module' here would redirect task request to
# a default version of a module, not the curently executing one.
task = taskqueue.Task(url=url,
params=params,
payload=payload,
name=name,
countdown=countdown,
headers=headers)
yield task.add_async(queue_name=queue_name,
transactional=transactional)
raise ndb.Return(True)
except (taskqueue.TombstonedTaskError, taskqueue.TaskAlreadyExistsError):
logging.info('Task %r deduplicated (already exists in queue %r)', name,
queue_name)
raise ndb.Return(True)
except (taskqueue.Error, runtime.DeadlineExceededError,
runtime.apiproxy_errors.CancelledError,
runtime.apiproxy_errors.DeadlineExceededError,
runtime.apiproxy_errors.OverQuotaError) as e:
logging.warning('Problem adding task %r to task queue %r (%s): %s',
url, queue_name, e.__class__.__name__, e)
raise ndb.Return(False)
import webapp2
import jinja2
import os
import datetime
import update_schema
from google.appengine.api import users, app_identity
from google.appengine.ext import ndb
from google.appengine.ext import deferred
from webapp2_extras import json
from models import Snippet
jinja_environment = jinja2.Environment(loader=jinja2.FileSystemLoader(
os.path.join(os.path.dirname(__file__), "template")))
server_url = app_identity.get_default_version_hostname()
DEFAULT_COLLECTION_NAME = "snippets"
PAGE_SIZE = 25
def snippet_key(snippet_collection_name=DEFAULT_COLLECTION_NAME):
return ndb.Key('Snippets', snippet_collection_name)
class SnippetBase(webapp2.RequestHandler):
def list(self):
cursor = None
bookmark = self.request.get('bookmark')
def get(self):
user = users.get_current_user()
session_key = str(self.request.get('session_key'))
session = None
# testing flag
testing = 'testing' in self.request.arguments()
logging.info('testing: ' + str(testing))
if not user:
# generate random user when testing
if testing:
user = users.User(
str(time.mktime(datetime.datetime.now().timetuple())) +
'@test.com')
else:
self.redirect(users.create_login_url(self.request.uri))
return
if not session_key:
# No session specified, create a new one, make this the host
# If this user is already hosting, connect them to the existing session
q = Session.all().filter("host =", user)
session = q.get()
logging.info('session: ' + str(session))
if not session:
session_key = session_key_gen()
curTime = datetime.datetime.now()
session = Session(
key_name=session_key, # Key for the db.Model.
host=user,
curSongIdx=0,
play=False,
endFlag=False,
timestamp=curTime)
session.put()
else:
session_key = session.key().name()
else:
# Session exists
session = Session.get_by_key_name(session_key)
if not session:
self.response.out.write('Invalid session ' + session_key)
return
logging.info('existing session: ' + str(user) + ', ' +
str(session.host))
if user != session.host and (user not in session.listeners):
logging.info('add user ' + str(user.email()) + ' to listeners')
# User not in listener list
session.listeners.append(user)
session.put()
SessionUpdater(session).send_update(
SessionUpdater(session).get_session_message())
# Perform cleanup where we remove any sessions for which we are the host
q = Session.all().filter('host =', user)
for ses in q.run(read_policy=db.STRONG_CONSISTENCY):
SessionUpdater(ses).remove_session()
# handle test users
user_id = user.user_id()
if not user_id:
user_id = user.email()
ACL = findACL(user_id)
# if user has no ACL, create one with no listeners and no potential sessions
if (ACL == None):
ACL = ACLEntry(key_name=str(user_id),
host=user,
sessionkey=session_key,
plisteners=[],
psessions=[])
ACL.put()
# TODO: remove when user logs out
# ADD USER TO LIST OF LOGGED IN USERS
# (so other users can add to listner list)
addlog = LoggedInUsers(key_name=user.email(), userid=user_id)
addlog.put()
# Deployed version:
session_link = 'http://3.' + app_identity.get_default_version_hostname(
) + '/?session_key=' + session_key
#session_link = 'http://localhost:8080/?session_key=' + session_key
logout_link = users.create_logout_url(self.request.uri)
if session:
# check for free channels and channels this user is already using
userCh = ChannelEntry.all().filter('user ='******'free =', True).get()
if userCh:
chEntry = userCh
elif freeCh:
chEntry = freeCh
else:
chEntry = None
if chEntry:
chEntry.user = user
chEntry.free = False
chEntry.session_key = session_key
channel_token = chEntry.token # use old token
chEntry.put()
else:
channel_key = session_key_gen()
channel_token = channel.create_channel(
channel_key,
duration_minutes=1440) # For max token reuse....
exp_time = datetime.datetime.now() + datetime.timedelta(
minutes=1440) # 24 hr expiration
# create a new entry
chEntry = ChannelEntry(key_name=channel_key,
token=channel_token,
user=user,
session_key=session_key,
free=False,
expire=exp_time)
chEntry.put()
template_values = {
'token': channel_token,
'me': user_id,
'me_email': user.email(),
'session_key': session_key,
'session_link': session_link,
'logout_link': logout_link,
}
# combine these so that they can be used on the client side
#template_values.update(SessionUpdater(session).get_session_details())
# send update out when someone joins session
#SessionUpdater(session).send_update(SessionUpdater(session).get_session_message())
template = jinja_environment.get_template('index.html')
self.response.out.write(template.render(template_values))
else:
self.response.out.write('No existing session')
APPENGINE_DIR = os.path.abspath(os.path.dirname(SRC_DIR))
ROOT_DIR = os.path.abspath(os.path.dirname(os.path.dirname(APPENGINE_DIR)))
INTERNAL_IPS = (
'127.0.0.1',
'localhost',
'::1'
)
DEBUG = not APPENGINE_PRODUCTION
TESTING = False
try:
APP_ID = app_identity.get_application_id()
HOME_LINK = app_identity.get_default_version_hostname()
GCS_BUCKET = app_identity.get_default_gcs_bucket_name()
CURRENT_VERSION = modules.get_current_version_name()
CURRENT_MODULE = modules.get_current_module_name()
except AttributeError:
APP_ID = 'greenday-project-v02-local'
HOME_LINK = 'http://localhost:8080/'
GCS_BUCKET = 'greenday-project-v02-local.appspot.com'
CURRENT_VERSION = 'local'
CURRENT_MODULE = ''
ALLOWED_HOSTS = [ # Django 1.5 requirement when DEBUG = False
"localhost",
"montage.storyful.com",
"montage.meedan.com",
app_identity.get_default_version_hostname(),
def home_url():
if None == app_identity.get_default_version_hostname():
return ""
else:
return app_identity.get_default_version_hostname()
def _GetServerURL(): return 'https://' + app_identity.get_default_version_hostname()
def become_replica(ticket, initiated_by):
"""Converts current service to a replica of a primary specified in a ticket.
Args:
ticket: replication_pb2.ServiceLinkTicket passed from a primary.
initiated_by: Identity of a user that accepted linking request, for logging.
Raises:
ProtocolError in case the request to primary fails.
"""
assert model.is_standalone()
# On dev appserver emulate X-Appengine-Inbound-Appid header.
headers = {'Content-Type': 'application/octet-stream'}
protocol = 'https'
if utils.is_local_dev_server():
headers['X-Appengine-Inbound-Appid'] = app_identity.get_application_id(
)
protocol = 'http'
headers['X-URLFetch-Service-Id'] = utils.get_urlfetch_service_id()
# Pass back the ticket for primary to verify it, tell the primary to use
# default version hostname to talk to us.
link_request = replication_pb2.ServiceLinkRequest()
link_request.ticket = ticket.ticket
link_request.replica_url = (
'%s://%s' % (protocol, app_identity.get_default_version_hostname()))
link_request.initiated_by = initiated_by.to_bytes()
# Primary will look at X-Appengine-Inbound-Appid and compare it to what's in
# the ticket.
try:
result = urlfetch.fetch(
url='%s/auth_service/api/v1/internal/link_replica' %
ticket.primary_url,
payload=link_request.SerializeToString(),
method='POST',
headers=headers,
follow_redirects=False,
deadline=30,
validate_certificate=True)
except urlfetch.Error as exc:
raise ProtocolError(
replication_pb2.ServiceLinkResponse.TRANSPORT_ERROR,
'URLFetch error (%s): %s' % (exc.__class__.__name__, exc))
# Protobuf based protocol is not using HTTP codes (handler always replies with
# HTTP 200, providing error details if needed in protobuf serialized body).
# So any other status code here means there was a transport level error.
if result.status_code != 200:
raise ProtocolError(
replication_pb2.ServiceLinkResponse.TRANSPORT_ERROR,
'Request to the primary failed with HTTP %d.' % result.status_code)
link_response = replication_pb2.ServiceLinkResponse.FromString(
result.content)
if link_response.status != replication_pb2.ServiceLinkResponse.SUCCESS:
message = LINKING_ERRORS.get(
link_response.status,
'Request to the primary failed with status %d.' %
link_response.status)
raise ProtocolError(link_response.status, message)
# Become replica. Auth DB will be overwritten on a first push from Primary.
state = model.AuthReplicationState(key=model.replication_state_key(),
primary_id=ticket.primary_id,
primary_url=ticket.primary_url)
state.put()
def get_deployment(self):
"""Shows server environment and deployment information page."""
template_values = {}
template_values['page_title'] = self.format_title('Deployment')
template_values['page_description'] = messages.DEPLOYMENT_DESCRIPTION
# modules
module_content = safe_dom.NodeList()
module_content.append(
safe_dom.Element('h3').add_text('Custom Modules'))
ol = safe_dom.Element('ol')
module_content.append(ol)
for name in sorted(custom_modules.Registry.registered_modules.keys()):
enabled_text = ''
if name not in custom_modules.Registry.enabled_module_names:
enabled_text = ' (disabled)'
li = safe_dom.Element('li').add_text('%s%s' % (name, enabled_text))
ol.add_child(li)
amodule = custom_modules.Registry.registered_modules.get(name)
self._make_routes_dom(li, amodule.global_routes, 'Global Routes')
self._make_routes_dom(li, amodule.namespaced_routes,
'Namespaced Routes')
# Custom tags.
tag_content = safe_dom.NodeList()
tag_content.append(safe_dom.Element('h3').add_text('Custom Tags'))
ol = safe_dom.Element('ol')
tag_content.append(ol)
tag_bindings = tags.get_tag_bindings()
for name in sorted(tag_bindings.keys()):
clazz = tag_bindings.get(name)
tag = clazz()
vendor = tag.vendor()
ol.add_child(
safe_dom.Element('li').add_text(
'%s: %s: %s' % (name, tag.__class__.__name__, vendor)))
# Yaml file content.
yaml_content = safe_dom.NodeList()
yaml_content.append(
safe_dom.Element('h3').add_text('Contents of ').add_child(
safe_dom.Element('code').add_text('app.yaml')))
ol = safe_dom.Element('ol')
yaml_content.append(ol)
yaml_lines = open(
os.path.join(os.path.dirname(__file__), '../../app.yaml'),
'r').readlines()
for line in yaml_lines:
ol.add_child(safe_dom.Element('li').add_text(line))
# Application identity.
app_id = app.get_application_id()
app_dict = {}
app_dict['application_id'] = escape(app_id)
app_dict['default_ver_hostname'] = escape(
app.get_default_version_hostname())
template_values['main_content'] = safe_dom.NodeList().append(
self.render_dict(
app_dict,
'About the Application')).append(module_content).append(
tag_content).append(yaml_content).append(
self.render_dict(os.environ,
'Server Environment Variables'))
self.render_page(template_values)
def get_friendly_hostname():
host = app_identity.get_default_version_hostname()
# For a typical host 'xyz-cq-status.appspot.com', return 'Xyz'.
return host.split('-')[0].capitalize() if host else '(Development)'
def get_default_version_hostname():
return app_identity.get_default_version_hostname()
def _IssueURL(job):
"""Returns a URL for information about a bisect try job."""
hostname = app_identity.get_default_version_hostname()
job_id = job.buildbucket_job_id
return 'https://%s/buildbucket_job_status/%s' % (hostname, job_id)
def get_base_url():
"""Returns the base URL for this application."""
base = get_default_version_hostname()
if "appspot.com" in base:
return "https://%s" % base
return "http://%s" % base
from google.appengine.api import users
from google.appengine.api import app_identity
import logging
FORMAT = "[%(levelname)s %(asctime)s %(filename)s:%(lineno)s] %(funcName)20s() %(message)s"
logging.basicConfig(level=logging.DEBUG, format=FORMAT)
logger = logging.getLogger(__name__)
import urlparse
import urllib
import short_url
DEFAULT_SCHEME = 'http'
DEFAULT_NETLOC = app_identity.get_default_version_hostname() # '4RT.mp'
if app_identity.get_default_version_hostname().startswith('localhost'):
DEFAULT_NETLOC = app_identity.get_default_version_hostname()
class View(ndb.Model):
url_key = ndb.KeyProperty(kind='URL')
create_date = ndb.DateTimeProperty(auto_now_add=True)
class Link(ndb.Model):
target_url = ndb.TextProperty(required=True, default='oops')
sequence_index = ndb.ComputedProperty(lambda self: self.index)
create_date = ndb.DateTimeProperty(auto_now_add=True)
created_by = ndb.UserProperty(
validator=lambda p, v: users.get_current_user())
import json
import logging
import webapp2
from webapp2_extras import security
from google.appengine.api import app_identity
import github_auth
import view_base
import view_build
import view_logs
import view_pr
hostname = app_identity.get_default_version_hostname()
def get_secret(key):
data = json.load(open('secrets.json'))
return data[hostname][key]
def get_session_secret():
try:
return str(get_secret('session'))
except (IOError, KeyError):
if hostname: # no scary error messages when testing
logging.error(
'unable to load secret key! sessions WILL NOT persist!')
# This fallback is enough for testing, but in production
def api_uploads(self):
evt = Event.query().get()
uri = "http://" + app_identity.get_default_version_hostname(
) + self.uri("download", blob=evt.photo)
return uri
def _RecoveredBugComment(cls, bug_id):
server_url = app_identity.get_default_version_hostname()
graphs_url = 'https://%s/group_report?bug_id=%s' % (server_url, bug_id)
return 'Automatic message: All alerts recovered.\nGraphs: %s' % graphs_url
projectName = "Lurr CS-253 Project"
adr = {
'hello': '/hello',
'rot13': '/rot13',
'signup' : '/blog/signup',
'signin' : '/blog/login',
'signout' : '/blog/logout',
'welcome' : '/blog/welcome',
'blog' : '/blog',
'blogpost' : '/blog/newpost',
'timer' : '/timer',
}
homeLinkString ='<div><a href="http://%s">home</a></div>'%app_identity.get_default_version_hostname()
page = """
<!DOCTYPE html>
<html>
<head>
<title>{{title|e}}</title>
<link rel="stylesheet" type="text/css" href="/css/main.css">
</head>
<body>
<div class="main">
{{content}}
{{homeLink}}
</div>
</body>
</html>
def _GetBisectResults(job):
"""Gets bisect results for a bisect job.
Args:
job: TryJob entity.
Returns:
A dictionary containing status, results, buildbot_log_url, and
issue_url for this bisect job. The issue_url may be a link to a Rietveld
issue or to Buildbucket job info.
"""
results = {}
# Fetch bisect bot results from Rietveld server.
if job.use_buildbucket:
try_job_info = _ValidateAndConvertBuildbucketResponse(
buildbucket_service.GetJobStatus(job.buildbucket_job_id))
hostname = app_identity.get_default_version_hostname()
job_id = job.buildbucket_job_id
issue_url = 'https://%s/buildbucket_job_status/%s' % (hostname, job_id)
else:
response = _FetchURL(_RietveldIssueJSONURL(job))
issue_url = _RietveldIssueURL(job)
try_job_info = _ValidateRietveldResponse(response)
results['buildbot_log_url'] = str(try_job_info['url'])
results['issue_url'] = str(issue_url)
# Check whether the bisect job is finished or not and fetch the output.
result = int(try_job_info['result'])
if result not in OK + FAIL:
return None
results_url = '%s/steps/Results/logs/stdio/text' % try_job_info['url']
response = _FetchURL(results_url, skip_status_code=True)
results['bisect_bot'] = try_job_info['builder']
# We don't see content for "Result" step. Bot probably did not get there.
if not response or response.status_code != 200:
results['status'] = 'Failure'
results['results'] = ''
build_data = _FetchBuildData(try_job_info['url'])
if build_data:
_CheckBisectBotForInfraFailure(job.bug_id, build_data,
try_job_info['url'])
results['results'] = _GetBotFailureInfo(build_data)
partial_result = _GetPartialBisectResult(build_data, try_job_info['url'])
if partial_result:
results['status'] = 'Failure with partial results'
results['results'] += partial_result
return results
# Clean result.
# If the bisect_results string contains any non-ASCII characters,
# converting to string should prevent an error from being raised.
bisect_result = _BeautifyContent(str(response.content))
# Bisect is considered success if result is provided.
# "BISECTION ABORTED" is added when a job is ealy aborted because the
# associated issue was closed.
# TODO(robertocn): Make sure we are outputting this string
if ('BISECT JOB RESULTS' in bisect_result or
'BISECTION ABORTED' in bisect_result):
results['status'] = 'Completed'
else:
results['status'] = 'Failure'
results['results'] = bisect_result
return results
import jinja2
import os
import xsrf
ROOT = os.path.dirname(__file__)
JINJA_ENVIRONMENT = jinja2.Environment(
loader=jinja2.FileSystemLoader(ROOT),
extensions=['jinja2.ext.autoescape',
'jinja2.ext.i18n'],
autoescape=True)
JINJA_ENVIRONMENT.globals['xsrf_token'] = xsrf.XSRFToken()
HOST = str(app_identity.get_default_version_hostname())
JINJA_ENVIRONMENT.globals['BASE_URL'] = ('https://' + HOST)
JINJA_ENVIRONMENT.globals['EMAIL_VALIDATION_PATTERN'] = r'[^@]+@[^@]+.[^@]+'
email_validation_error = 'Please supply a valid email address.'
JINJA_ENVIRONMENT.globals['EMAIL_VALIDATION_ERROR'] = email_validation_error
# Key lookup for users and group allows email or unique id.
key_lookup_pattern = r'([^@]+@[^@]+.[^@]+|[a-zA-Z0-9]+)'
key_lookup_error = 'Please supply a valid email address or unique id.'
JINJA_ENVIRONMENT.globals['KEY_LOOKUP_VALIDATION_PATTERN'] = key_lookup_pattern
JINJA_ENVIRONMENT.globals['KEY_LOOKUP_VALIDATION_ERROR'] = key_lookup_error
for key, value in PATHS.iteritems():
JINJA_ENVIRONMENT.globals[key] = value
# Add any libraries installed in the "lib" folder.
vendor.add('lib')
