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')