def get(self):
post = db.get(db.Key(self.request.query_string))
if (post.IsModeratable()):
post.delete()
#delete the memcached html for the parent thread
memcache.delete('threadhtml' + str(post.ParentThread.key()))
self.redirect('/messageboard/thread?' + str(post.ParentThread.key()))
def post(self):
code = self.request.get('code',None)
img = self.request.get('img',"")
# simple antispam
if sum(x in code.lower() for x in ('href=', 'url=', 'link=')) > 2:
self.redirect("/error")
return
if code.strip():
hash = base64.b64encode(hashlib.sha1(code.strip()).digest()[:6], "-_")
if not LogoProgram.all().filter('hash =', hash).get():
program = LogoProgram()
program.code = code
program.hash = hash
if img:
img = base64.b64decode(img)
img = images.Image(img)
img.resize(125, 125)
program.img = img.execute_transforms()
else:
self.redirect("/error")
return
program.put()
memcache.set("program: %s" % hash, program)
memcache.delete("recent_progs")
else:
hash = ""
self.redirect("/%s" % hash)
def get(self):
category_key = self.request.get('id')
category = db.get(category_key)
category.reverse = True
db.put(category)
memcache.delete(category.getReviewPairsKey())
self.redirect('category?id=' + category_key)
def post(self, login_user=None, template_values={}):
memcache.set('import_status', "Queued import task", time=30)
# import or upload?
action = self.request.get('action')
assert action, "Import or upload? No action specified."
upload_files = self.get_uploads('osmdata')
try:
blob_info = upload_files[0]
except IndexError:
memcache.set('%s_status' % action, "%s failed. Nothing found in blobstore." % action.title(), time=30)
logging.warning("Could not find uploaded data in blobstore.")
self.redirect('/update')
# delete memory for confirmation walkthrough (see balsa_update)
memcache.delete('update')
memcache.delete('new')
# start background process
taskqueue.add(url='/%s/store' % action, queue_name='import',
params={'compressed': self.request.get('compressed', ""),
'action': action,
'osmdata': blob_info.key()})
# redirect to update page which will show the current state of the data storage
self.redirect('/update')
def render_to_response(self, template, context=None, use_cache=False):
"""Renders the template and writes the result to the response."""
if use_cache:
# Use the request's path to store the contents.
# WARNING: This could cause scary problems if you render
# user-specific pages.
# DO NOT use current_profile in a template rendered with use_cache=True.
cache_key = self.request.path
contents = memcache.get(cache_key)
if not contents or 'flushcache' in self.request.arguments():
contents = self.render_template(template, context)
# If add() returns False, it means another request is already trying
# to cache the page. No need to do anything here.
if memcache.add('lock.%s' % cache_key, True):
memcache.set(cache_key, contents)
memcache.delete('lock.%s' % cache_key)
else:
contents = self.render_template(template, context)
self.response.write(contents)
def post(self):
self.response.headers['Content-Type'] = 'application/json'
action = self.request.get("action")
if action == "login":
username = self.request.get('username')
password = self.request.get('password')
self._handle_login(username=username, password=password)
elif action == "logout":
student_token = self.request.get('token')
memcache.delete(student_token, namespace="teachers")
self.response.write(json.dumps({'api':'ok'}))
elif action == "register":
self._handle_register()
elif action == "debug":
try:
student_token = self.request.get('token')
self.response.out.write("token " + student_token)
student = memcache.get(student_token, "teachers")
self.response.out.write(json.dumps(student))
self.response.out.write("end")
except:
self.response.out.write("not logged in")
pass
else:
raise RuntimeError("invalid request error.")
def delete_all_sessions(cls):
"""
Deletes all sessions and session data from the data store and memcache:
NOTE: This is not fully developed. It also will not delete any cookie
data as this does not work for each incoming request. Keep this in mind
if you are using the cookie writer.
"""
all_sessions_deleted = False
all_data_deleted = False
while not all_sessions_deleted:
query = _AppEngineUtilities_Session.all()
results = query.fetch(75)
if len(results) is 0:
all_sessions_deleted = True
else:
for result in results:
memcache.delete("sid-" + str(result.key()))
result.delete()
while not all_data_deleted:
query = _AppEngineUtilities_SessionData.all()
results = query.fetch(75)
if len(results) is 0:
all_data_deleted = True
else:
for result in results:
result.delete()
def post(self, id):
if not users.get_current_user():
self.response.set_status(401, "")
return
if len(id) > 0:
entry = Package.get(id)
if not entry:
self.error(404)
return
entry.name = self.request.get('name'),
entry.version = self.request.get("version"),
entry.description = self.request.get("description"),
entry.url = self.request.get("url"),
entry.extractor = self.request.get("extractor"),
entry.author = self.request.get("author"),
entry.packer = users.get_current_user(),
entry.requires = self.request.get("requires"),
entry.installer = self.request.get("installer"),
entry.installer_script = self.request.get("installer_script"),
else:
entry = Package(
name=self.request.get('name'),
version=self.request.get("version"),
description=self.request.get("description"),
url=self.request.get("url"),
extractor=self.request.get("extractor"),
author=self.request.get("author"),
packer=users.get_current_user(),
requires=self.request.get("requires"),
installer=self.request.get("installer"),
installer_script=self.request.get("installer_script"),
)
entry.put()
memcache.delete("packages")
self.redirect("/edit/%s" % (entry.key()))
def get_doc(id):
if googleUser.is_current_user_admin():
memcache.delete(id)
entry = memcache.get(id)
if not entry:
client = gdata.docs.client.DocsClient(source='yourCo-yourAppName-v1')
client.ssl = True # Force all API requests through HTTPS
client.http_client.debug = True # Set to True for debugging HTTP requests
client.ClientLogin(settings.DOCS_EMAIL, settings.DOCS_PASS, client.source)
entry = client.GetFileContent(
'/feeds/download/documents/Export?id=%s&format=html' % id)
memcache.add(id, entry)
html = BeautifulStoneSoup(entry, convertEntities=BeautifulStoneSoup.HTML_ENTITIES)
body = html.body.renderContents()
style = html.style.prettify()
return {
'entry': entry,
'title': html.head.title.text,
'html': html,
'body': body.replace('http:///', '/'),
'style': style,
'id': id,
}
def MemcacheWrappedDelete(cls, key_name=None, entity=None):
"""Delete an entity by key name and clear Memcache.
Note: This only clears the entity cache. If MemcacheWrappedGet()
with a prop_name kwarg has been used, a separate cache will exist
for that property. This function will not delete that memcache.
TODO(user): If this function were actually used anywhere
we should have prop_name=[] here so that users can delete prop_name
caches too.
Args:
key_name: str, key name of entity to fetch
entity: db.Model entity
Raises:
ValueError: when neither entity nor key_name are supplied
"""
if entity:
key_name = entity.key().name()
elif key_name:
entity = cls.get_by_key_name(key_name)
else:
raise ValueError
if entity:
entity.delete()
memcache_key = 'mwg_%s_%s' % (cls.kind(), key_name)
memcache.delete(memcache_key)
def POST(self):
import opml
x = web.input(importfile={})
memcache.set(MEMC_ADV_ID, self.__url__, 86400)
if 'importfile' in x:
user = self.getcurrentuser()
try:
rsslist = opml.from_string(x.importfile.file.read())
except Exception as e:
return self.GET(str(e))
for o in self.walkOutline(rsslist):
title, url, isfulltext = o.text, urllib.unquote_plus(o.xmlUrl), o.isFulltext #isFulltext为非标准属性
isfulltext = bool(isfulltext.lower() in ('true', '1'))
if title and url:
rss = Feed.all().filter('book = ', user.ownfeeds).filter("url = ", url).get() #查询是否有重复的
if rss:
rss.title = title
rss.isfulltext = isfulltext
rss.put()
else:
Feed(title=title,url=url,book=user.ownfeeds,isfulltext=isfulltext,
time=datetime.datetime.utcnow()).put()
memcache.delete('%d.feedscount'%user.ownfeeds.key().id())
raise web.seeother('/my')
else:
raise web.seeother('')
def post(self):
raw_img = self.request.get("img")
if len(raw_img) == 0:
logging.info('Image payload is empty')
self.redirect('/problem/ERR_PAYLOAD_EMPTY')
return
if len(raw_img) > 1000000:
logging.error('Image is too large')
self.redirect('/problem/ERR_IMG_TOO_LARGE')
return
xi = ImageObject()
xi.views = 0
if users.get_current_user():
xi.author = users.get_current_user()
content = self.request.get("content")
xi.content = validate_content(content)
xi.full_text = strip_camel_case(content)
try:
xi.payload = db.Blob(raw_img)
xi.thumbnail = create_thumbnail(xi)
xi.put()
except:
payload = images.resize(raw_img, 640, 480)
xi.payload = db.Blob(raw_img)
xi.thumbnail = create_thumbnail(xi)
xi.put()
username = get_user()
content_all_key = "%s_the_contents_all" % username
content_key = "%s_the_contents" % username
logging.info('Invalidating the memcache contents of %s %s', content_all_key, content_key)
memcache.delete(content_all_key)
memcache.delete(content_key)
self.redirect('/user')
def end_recording(status, firepython_set_extension_data=None):
"""Stop recording RPC traces and save all traces to memcache.
This resets the global 'recorder' variable to None.
Args:
status: HTTP Status, a 3-digit integer.
firepython_set_extension_data: Optional function to be called
to pass the recorded data to FirePython.
"""
global recorder
rec = recorder
recorder = None
if config.DEBUG:
logging.debug('Cleared recorder')
if rec is not None:
try:
rec.record_http_status(status)
rec.save()
if (firepython_set_extension_data and
(os.getenv('SERVER_SOFTWARE', '').startswith('Dev') or
users.is_current_user_admin())):
logging.info('Passing data to firepython')
firepython_set_extension_data('appengine_appstats', rec.json())
finally:
memcache.delete(lock_key(), namespace=config.KEY_NAMESPACE)
def sync_add_image(request, uid):
logging.info("Add image for gift with key: %s" % uid)
mem_key = 'sync/add_image/%s' % uid
img_url = memcache.get(mem_key)
if img_url:
memcache.delete(mem_key)
img = urlfetch.fetch(img_url)
if img.status_code == 200:
thumb = img.content
gift = Gift.get_by_id(uid)
if gift:
title = gift.name.replace('"', '"')
thumb_img = ThumbImage()
content_type = 'image/jpeg'
thumb_img.add_new_thumb(blob_img=thumb, thumb_size=(700, 700,),
title=title, content_type=content_type)
thumb_img.add_new_thumb(blob_img=thumb, thumb_size=(400, 400, ),
title=title, content_type=content_type)
thumb_img.add_new_thumb(blob_img=thumb, thumb_size=(200, 200, ),
title=title, content_type=content_type)
thumb_img.add_new_thumb(blob_img=thumb, thumb_size=(100, 100, ),
title=title, content_type=content_type)
if not gift.thumbs.count():
thumb_img.main_gift = gift
thumb_img.gift = gift
thumb_img.put()
return render_json_response({'api_msg': 'Ok', 'api_success': True})
def end_recording(status, firepython_set_extension_data=None):
"""Stop recording RPC traces and save all traces to memcache.
This clears the recorder set for this request in 'recorder_proxy'.
Args:
status: HTTP Status, a 3-digit integer.
firepython_set_extension_data: Optional function to be called
to pass the recorded data to FirePython.
"""
rec = recorder_proxy.get_for_current_request()
recorder_proxy.clear_for_current_request()
if config.DEBUG:
logging.debug("Cleared recorder")
if rec is not None:
try:
rec.record_http_status(status)
rec.save()
if firepython_set_extension_data and (
os.getenv("SERVER_SOFTWARE", "").startswith("Dev") or users.is_current_user_admin()
):
logging.info("Passing data to firepython")
firepython_set_extension_data("appengine_appstats", rec.json())
finally:
memcache.delete(lock_key(), namespace=config.KEY_NAMESPACE)
def post(self):
E_username = str(self.request.get('username'))
E_password = self.request.get('password')
username = valid_username(E_username)
if not username:
name_error = "That's not a valid username,"
else:
name_error = ''
password = valid_pass(E_password)
if not password:
pass_error = "That wasn't a valid password."
else:
pass_error = ''
if not (username and password):
self.write_form(name_error, pass_error, '', E_username)
else:
entry = db.GqlQuery("select * from Users where username=:1 limit 1", E_username).get()
if entry:
name = logged_in(self)
if name and '*' in name: # delete guest user if current
c = db.GqlQuery("select * from Users where username=:1", name).get()
c.delete()
memcache.delete(name + '_loginhash')
stored_hash = str(entry.password)
if valid_hash(E_username, E_password, stored_hash):
make_session(self, E_username, E_password)
self.redirect("/welcome")
else:
self.write_form('', 'Incorrect password', '', E_username)
else:
self.write_form('', '', "Don't know you, %s. Have you signed up?" % E_username, E_username)
def get(self):
exp = datetime.date.today() + datetime.timedelta(days = -1)
name = logged_in(self)
if name:
memcache.delete(name + '_loginhash')
self.response.headers.add_header('Set-Cookie', "user_id=; expires='%s';path=/" % exp.strftime("%a, %d-%b-%Y 23:59:59 GMT"))
self.redirect("/")
def get(self, one_num):
if 'Referer' in self.request.headers:
go = self.request.headers['Referer']
else:
go = '/'
member = CheckAuth(self)
t = self.request.get('t')
if member:
if str(member.created_ts) == str(t):
one = GetKindByNum('Member', int(one_num))
if one is not False:
if one.num != member.num:
q = db.GqlQuery("SELECT * FROM MemberBookmark WHERE one = :1 AND member_num = :2", one, member.num)
if q.count() > 0:
bookmark = q[0]
bookmark.delete()
member = db.get(member.key())
member.favorited_members = member.favorited_members - 1
member.put()
memcache.set('Member_' + str(member.num), member, 86400)
n = 'r/m' + str(one.num) + '/m' + str(member.num)
memcache.delete(n)
one = db.get(one.key())
one.followers_count = one.followers_count - 1
one.put()
memcache.set('Member_' + str(one.num), one, 86400)
memcache.set('Member::' + str(one.username_lower), one, 86400)
self.redirect(go)
def post(self):
"""Adds a new builder status message."""
# Check if this is a delete builder request.
delete_builder = self.request.get('delete')
if delete_builder:
BuilderStatus.delete_builder(delete_builder)
else:
message = self.request.get('message')
builder_name = self.request.get('builder_name')
# If an entry with the builder_name already exists then delete it first.
BuilderStatus.delete_builder(builder_name)
# Add a new BuilderStatus entry.
BuilderStatus(username=self.user.email(),
builder_name=builder_name,
message=message).put()
# Flush the cache.
memcache.flush_all()
memcache.delete('builder_statuses')
# Wait for a second before accessing the memcache again (in case there is a
# propagation delay).
time.sleep(1)
# Set template values and load the template.
self._handle()
def get(self):
if not self.is_login:
self.redirect(users.create_login_url(self.request.uri))
action=self.param('action')
if action=='stop':
memcache.delete("imt")
#OptionSet.remove('wpimport_data')
self.write('"ok"')
return
imt=memcache.get('imt')
#imt=OptionSet.getValue('wpimport_data')
if imt and imt.cur_do:
process=100-math.ceil(imt.count()*100/imt.total)
if imt.cur_do[0]=='cat':
msg="importing category '%s'"%imt.cur_do[1]['name']
elif imt.cur_do[0]=='entry':
msg="importing entry '%s'"%imt.cur_do[1]['title']
else:
msg="start importing..."
self.write(simplejson.dumps((process,msg,not process==100)))
else:
self.write(simplejson.dumps((-1,"Have no data to import!",False)))
def stop(self):
self.active = False
game_slugs = get_game_slugs()
if self.slug in game_slugs:
game_slugs.remove(self.slug)
memcache.set('game_slugs', game_slugs)
serialized_status = memcache.get_multi(self.status_ids,
key_prefix='status')
# Just copying my status_ids list to make some changes localy
missing_status_ids = list(self.status_ids)
for status_id, status in serialized_status.iteritems():
deserialized_status = deserialize(status)
deserialized_status.player.leave_game(self)
missing_status_ids.remove(status_id)
# Taking the missing status in database
if missing_status_ids:
missing_status = Status.get(missing_status_ids)
for status in missing_status:
status.player.leave_game(self)
memcache.delete('game'+self.slug)
self.status_ids = []
self.put()
def clear(cls):
charCache = memcache.get(cls._charCacheName)
if not charCache: return
for char in charCache:
cls.deleteCache(char)
memcache.delete(cls._charCacheName)
def test_get_and_put_cached(self):
storage = appengine.StorageByKeyName(
appengine.CredentialsModel, 'foo', 'credentials', cache=memcache)
self.assertEqual(None, storage.get())
self.credentials.set_store(storage)
http = http_mock.HttpMock(data=BASIC_RESP)
self.credentials._refresh(http)
credmodel = appengine.CredentialsModel.get_by_key_name('foo')
self.assertEqual(BASIC_TOKEN, credmodel.credentials.access_token)
# Now remove the item from the cache.
memcache.delete('foo')
# Check that getting refreshes the cache.
credentials = storage.get()
self.assertEqual(BASIC_TOKEN, credentials.access_token)
self.assertNotEqual(None, memcache.get('foo'))
# Deleting should clear the cache.
storage.delete()
credentials = storage.get()
self.assertEqual(None, credentials)
self.assertEqual(None, memcache.get('foo'))
# Verify mock.
self._verify_basic_refresh(http)
def post(self):
user = check_privileged(self)
if not user:
return
# basic template values
template_values = {
'action': self.request.uri,
'pages': page.DbPage.all(),
'displays': display.Display.all()
}
p = self._get_page()
if p:
template_values['page'] = p
form = PageForm(instance=p, data=self.request.POST.mixed())
else:
form = PageForm(data=self.request.POST.mixed())
if form.is_valid():
form.save()
# force udpate of serials
# TODO only do this if the page has/had a serial display
memcache.delete('serials')
template_values['form'] = form
self.response.out.write(template.render('static/admin_pages.html', template_values))
def _respond(self, path, obj={}, xml=False, search={}):
""" draw the html and add it to the response then decide to add to or flush the cashe if admin"""
opt = {
"appname": self._conf.APP_NAME,
"blog_name": self._conf.BLOG,
"fb_app_id": self._conf.FB_APP_ID,
"can_edit": self._req.sesh().can_edit(),
"authed": self._req.sesh().authorised(),
"authfor": self._req.sesh().user_name(),
"url": self._req.spath(query=False),
"search": search
}
if self._req.ext() == 'xml' or xml:
path = "rss"
self._req.set_header('Content-Type', 'application/rss+xml')
html = self._req.draw(path=path, obj=obj, opt=opt)
# if an admin hits the page then clear this out of the cache
if self._conf.CACHE:
# if an admin hits the page then clear this out of the cache
if self._req.sesh().can_edit():
memcache.delete(self._req.get_cache_key())
else:
if not memcache.add(self._req.get_cache_key(), html, 3600): #3600 = 1 hour
logging.error("MEMCACHE MISTAKE")
def flush(model, filter): """Removes the data for the current user from the memcache. """ memcache_key = key(model, filter) # pylint: disable=E1101 memcache.delete(memcache_key)
def post(self):
try:
self.store_poll()
memcache.delete('INDEX_HTML')
self.redirect('/')
except:
self.response.out.write('Error: ' + str(sys.exc_info()))
def create_event(title, summary, information, start_date, end_date, start_time, end_time, attendance, location, email):
event = event_info()
event.populate(
title=title,
summary=summary,
information=information,
start_date=start_date,
end_date=end_date,
start_time=start_time,
end_time=end_time,
attendance=attendance,
location=location,
featured=False,
votes=0,
user=email,
)
# event_number = event_number,)
##event.key = ndb.Key(event_info, event_number)
event.put()
memcache.delete("events")
memcache.set(event.key.urlsafe(), event, namespace="event")
return event.key.urlsafe()
def flush_cache(): """Flushes the memcache key used by this datamodel.""" memcache.flush_all() memcache.delete(IS_STOPPED_MEMCACHE_KEY) # Wait for a second before accessing the memcache again (in case there is a # propagation delay). time.sleep(1)
def delete(cls, key, namespace=None):
"""Deletes an item from memcache if memcache is enabled."""
if CAN_USE_MEMCACHE.value:
CACHE_DELETE.inc()
if not namespace:
namespace = appengine_config.DEFAULT_NAMESPACE_NAME
memcache.delete(key, namespace=namespace)
def put(self):
Setting.cached_exercises_date(str(datetime.datetime.now()))
memcache.delete(Exercise._EXERCISES_COUNT_KEY, namespace=App.version)
db.Model.put(self)
def delete(self, *args, **kwargs):
"""Ensure tags memcache entries are purged when one is delete."""
# TODO(user): extend BaseModel so such memcache cleanup is reusable.
memcache.delete(self.ALL_TAGS_MEMCACHE_KEY)
return super(Tag, self).delete(*args, **kwargs)
def put(self, *args, **kwargs):
"""Ensure tags memcache entries are purged when a new one is created."""
memcache.delete(self.ALL_TAGS_MEMCACHE_KEY)
return super(Tag, self).put(*args, **kwargs)
'MemcacheWrappedGet: failure to memcache.set(%s, ...): %s',
memcache_key, str(e))
else:
if prop_name:
output = cached
else:
try:
output = db.model_from_protobuf(cached)
except Exception, e: # pylint: disable=broad-except
# NOTE(user): I copied this exception trap style from
# google.appengine.datastore.datatstore_query. The notes indicate
# that trapping this exception by the class itself is problematic
# due to differences between the Python and SWIG'd exception
# classes.
output = None
memcache.delete(memcache_key)
if e.__class__.__name__ == 'ProtocolBufferDecodeError':
logging.warning('Invalid protobuf at key %s', key_name)
elif retry:
logging.exception(
'Unexpected exception in MemcacheWrappedGet')
if not retry:
return cls.MemcacheWrappedGet(
key_name,
prop_name=prop_name,
memcache_secs=memcache_secs,
retry=True)
else:
return cls.get_by_key_name(key_name)
return output
def delete_memcached_api_key_list(): key_name = "MASTERDATA_API_KEYS" memcache.delete(key_name)
def clearMemcacheKeyMasterData(master_code): memcache.delete(getMemcacheKeyMasterData(master_code))
def clear_memcache(self):
memcache.delete(UserExercise.get_key_for_user(self.user))
def delete_token(unique_key):
# Clear from memcache.
memcache.delete(unique_key)
# Clear from the datastore.
Token(key_name=unique_key).delete()
def removecache(self):
memcache.delete('/')
memcache.delete('/' + self.link)
memcache.delete('/sitemap')
memcache.delete('blog.postcount')
g_blog.tigger_action("clean_post_cache", self)
def get(self): """Render the main page.""" # Get the flash message and delete it. message = memcache.get(key=self.userid) memcache.delete(key=self.userid) self._render_template(message)
def invalidate_user_fb_id(user_fb_id):
memcache.delete(user_fb_id, namespace=USER_FB_ID_NAMESPACE)
def delete(self, raw_token):
s = datamodel.UserToken.get_by_key_name(raw_token)
if s:
memcache.delete('token_request:%s' % s.value)
s.delete()
def post(self):
if not self.current_user:
args = dict(user=self.current_user, logout_url=LOGOUT_URL)
self.response.out.write(
template.render('templates/index.html', args))
return
try:
query = db.Query(Crush)
query.filter('id =', self.current_user.id)
query.order('created')
results = query.fetch(11)
orig_crushes = [x.crush for x in results]
names = self.request.POST.getall('c')
orig = self.request.POST.getall('o')
# First handle deletion
for crush in orig_crushes:
if crush not in names:
crushkey = self.current_user.id + ':' + crush
c = Crush.get_by_key_name(crushkey)
if c:
logging.info('deleting crush %s from cache and store' %
(crushkey))
c.delete()
mc.delete(crushkey, namespace='crushes')
# Now add anything new
d = DNDRemoteLookup()
# TODO not necessary to lookup names that were already in there (even though we memcache lookups)
dndnames = d.lookup(names, CLASS_YEAR)
new_crushes = []
comments = []
i = 0
for name in names:
if name == '':
i += 1
continue
# Check if it's already there
crushkeyname = self.current_user.id + ':' + name
c = mc.get(crushkeyname, namespace='crushes')
if c != None or Crush.get_by_key_name(crushkeyname):
# We also checked that it's in db in case it got evicted from cache
if c:
logging.info('Found preexisting crush in cache')
else:
logging.info('Found preexisting crush in store')
# Was already validated, so no need to check in dndnames
comments.append('')
new_crushes.append(name)
else:
# Crush doesn't already exist
if len(dndnames[name]) == 0:
# No good
comments.append(
'DND couldn\'t find anyone named "%s" in your year'
% (cgi.escape(name)))
new_crushes.append('')
elif len(dndnames[name]) == 1:
# New crush
resolved_name = dndnames[name][0]
crushkeyname = self.current_user.id + ':' + resolved_name
c = Crush(key_name=crushkeyname,
id=self.current_user.id,
crush=resolved_name)
c.put()
mc.set(crushkeyname, True, namespace='crushes')
comments.append('Saved')
new_crushes.append(resolved_name)
else:
# Unspecific - let them choose
links = ['<a href="#" onClick="document.getElementById(\'c%d\').value=\'%s\';return false;">%s</a>' \
% (i,x,x) for x in dndnames[name]]
comments.append('Did you mean: ' + ', '.join(links))
new_crushes.append('')
i += 1
self.render_main(crushes=new_crushes, comments=comments)
except DeadlineExceededError:
self.response.clear()
self.response.set_status(500)
self.response.out.write(
'The operation could not be completed in time. Try again or contact technical assistance.'
)
def invalidate_cache():
if not memcache.delete("frontpage"):
logging.error("Memcache delete failed on frontpage")
taskqueue.add(url='/', method="GET")
def post(self):
(forum, siteroot,
tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.redirect("/forum/")
if self.request.get('Cancel'):
return self.redirect(siteroot)
ip = get_remote_ip()
if ip in BANNED_IPS:
return self.redirect(siteroot)
self.send_cookie()
vals = [
'TopicId', 'num1', 'num2', 'Captcha', 'Subject', 'Message',
'Remember', 'Email', 'Name', 'Url'
]
(topic_id, num1, num2, captcha, subject, message, remember_me, email,
name, homepage) = req_get_vals(self.request, vals)
message = to_unicode(message)
remember_me = True
if remember_me == "": remember_me = False
rememberChecked = ""
if remember_me: rememberChecked = "checked"
validCaptcha = True
try:
captcha = int(captcha)
num1 = int(num1)
num2 = int(num2)
except ValueError:
validCaptcha = False
homepage = sanitize_homepage(homepage)
tvals = {
'siteroot': siteroot,
'forum': forum,
'num1': num1,
'num2': num2,
'num3': int(num1) + int(num2),
"prevCaptcha": captcha,
"prevSubject": subject,
"prevMessage": message,
"rememberChecked": rememberChecked,
"prevEmail": email,
"prevUrl": homepage,
"prevName": name,
"prevTopicId": topic_id,
"log_in_out": get_log_in_out(siteroot + "post")
}
# validate captcha and other values
errclass = None
if not validCaptcha or (captcha != (num1 + num2)):
errclass = 'captcha_class'
if not message: errclass = "message_class"
if not name: errclass = "name_class"
if not valid_email(email): errclass = "email_class"
# first post must have subject
if not topic_id and not subject: errclass = "subject_class"
# sha.new() doesn't accept Unicode strings, so convert to utf8 first
message_utf8 = message.encode('UTF-8')
s = sha.new(message_utf8)
sha1_digest = s.hexdigest()
duppost = Post.gql("WHERE sha1_digest = :1", sha1_digest).get()
if duppost: errclass = "message_class"
if errclass:
tvals[errclass] = "error"
tmpl = os.path.join(tmpldir, "post.html")
return self.template_out(tmpl, tvals)
# get user either by google user id or cookie. Create user objects if don't
# already exist
existing_user = False
user_id = users.get_current_user()
if user_id:
user = FofouUser.gql("WHERE user = :1", user_id).get()
if not user:
#logging.info("Creating new user for '%s'" % str(user_id))
user = FofouUser(user=user_id,
remember_me=remember_me,
email=email,
name=name,
homepage=homepage)
user.put()
else:
existing_user = True
#logging.info("Found existing user for '%s'" % str(user_id))
else:
cookie = self.get_cookie_val()
user = FofouUser.gql("WHERE cookie = :1", cookie).get()
if not user:
#logging.info("Creating new user for cookie '%s'" % cookie)
user = FofouUser(cookie=cookie,
remember_me=remember_me,
email=email,
name=name,
homepage=homepage)
user.put()
else:
existing_user = True
#logging.info("Found existing user for cookie '%s'" % cookie)
if existing_user:
need_update = False
if user.remember_me != remember_me:
user.remember_me = remember_me
need_update = True
if user.email != email:
user.email = email
need_update = True
if user.name != name:
user.name = name
need_update = True
if user.homepage != homepage:
user.homepage = homepage
need_update = True
if need_update:
#logging.info("User needed an update")
user.put()
if not topic_id:
topic = Topic(forum=forum, subject=subject, created_by=name)
topic.put()
else:
topic = db.get(db.Key.from_path('Topic', int(topic_id)))
#assert forum.key() == topic.forum.key()
topic.ncomments += 1
topic.put()
user_ip_str = get_remote_ip()
p = Post(topic=topic,
forum=forum,
user=user,
user_ip=0,
user_ip_str=user_ip_str,
message=message,
sha1_digest=sha1_digest,
user_name=name,
user_email=email,
user_homepage=homepage)
p.put()
memcache.delete(rss_memcache_key(forum))
clear_topics_memcache(forum)
if topic_id:
self.redirect(siteroot + "topic?id=" + str(topic_id))
else:
self.redirect(siteroot)
def invalidate(key):
memcache.delete(key)
def clear_forums_memcache():
memcache.delete(FORUMS_MEMCACHE_KEY)
def post(self):
if not auth(self.request):
self.response.set_status(403)
return
builder = self.request.get('builder')
log = self.request.get('log').encode('utf-8')
loghash = ''
if len(log) > 0:
loghash = hashlib.sha256(log).hexdigest()
l = CompressedLog(key_name=loghash)
l.log = bz2.compress(log)
l.put()
date = parseDate(self.request.get('date'))
user = self.request.get('user').encode('utf8')
desc = self.request.get('desc').encode('utf8')
node = self.request.get('node')
parenthash = self.request.get('parent')
if not validNode(node) or not validNode(parenthash) or date is None:
logging.error("Not valid node ('%s') or bad date (%s %s)", node,
date, self.request.get('date'))
self.response.set_status(500)
return
q = Commit.all()
q.filter('node =', parenthash)
parent = q.get()
if parent is None:
logging.error('Cannot find parent %s of node %s' %
(parenthash, node))
self.response.set_status(404)
return
parentnum, _ = parent.key().name().split('-', 1)
nodenum = int(parentnum, 16) + 1
key_name = '%08x-%s' % (nodenum, node)
def add_build():
n = Commit.get_by_key_name(key_name)
if n is None:
n = Commit(key_name=key_name)
n.num = nodenum
n.node = node
n.parentnode = parenthash
n.user = user
n.date = date
n.desc = desc
s = '%s`%s' % (builder, loghash)
for i, b in enumerate(n.builds):
if b.split('`', 1)[0] == builder:
n.builds[i] = s
break
else:
n.builds.append(s)
n.put()
db.run_in_transaction(add_build)
key = 'hw-%s' % builder
hw = Highwater.get_by_key_name(key)
if hw is None:
hw = Highwater(key_name=key)
hw.commit = node
hw.put()
memcache.delete(key)
memcache.delete('hw')
def mark_sent():
n = Commit.get_by_key_name(key_name)
n.fail_notification_sent = True
n.put()
n = Commit.get_by_key_name(key_name)
if loghash and not failed(parent,
builder) and not n.fail_notification_sent:
subject = const.mail_fail_subject % (builder, desc.split("\n")[0])
path = os.path.join(os.path.dirname(__file__), 'fail-notify.txt')
body = template.render(
path, {
"builder": builder,
"node": node[:12],
"user": user,
"desc": desc,
"loghash": loghash
})
mail.send_mail(sender=const.mail_from,
reply_to=const.mail_fail_reply_to,
to=const.mail_fail_to,
subject=subject,
body=body)
db.run_in_transaction(mark_sent)
self.response.set_status(200)
def release(self):
memcache.delete(self.name, namespace="whooshlocks")
def clear_topics_memcache(forum):
memcache.delete(topics_memcache_key(forum))
def post(self):
memcache.delete(self.request.get('mac'))
self.redirect('/%s' % base64.b64encode(','.join(
[self.request.get('mac'),
self.request.get('redirect')])))
def get(self):
path = self.request.path
# Remove string after "_" if redirected from basic-authed link
path_parts = path.split("_")
path = path_parts[0]
if len(path_parts) >= 2:
key_auth = path_parts[1]
else:
key_auth = None
if not path or len(path) < 1 or path[0] != "/":
self.response.set_status(404)
return
key_name = path[1:]
entry = models.ApkEntry.get_by_key_name(key_name)
if not entry:
self.response.set_status(404)
return
# if the path was postfixed w/ "_" + key_auth random string
if key_auth != None:
user_ip = memcache.get(key_auth)
if user_ip == self.request.remote_addr:
memcache.delete(key_auth)
self.respond_apk(entry)
return
else:
self.response.set_status(404)
return
if not entry.ipaddrs and not entry.accounts and not entry.basic_id:
# public available if both empty
self.respond_apk(entry)
return
if entry.ipaddrs:
if self.is_ip_allowed(entry):
self.respond_apk(entry)
return
if entry.accounts:
cur_user = users.get_current_user()
if cur_user:
if self.is_user_allowed(entry, cur_user):
self.respond_apk(entry)
return
self.redirect(users.create_login_url(self.request.path))
return
if entry.basic_id:
if self.is_basicAuthorized(entry):
# A file cannot be downloaded from Android device if
# it is protected by Basic authentication directly.
# So, after authenticated, redirect to a different address
# that allows only the IP address cached here.
# self.respond_apk(entry) is what is not working here.
auth_key = self.gen_key(32)
user_ip = self.request.remote_addr
# Set expiration time a little long to 60 sec, because
# user must start downloadeing before it expires.
memcache.set(auth_key, user_ip, 60)
self.redirect(self.request.url + "_" + auth_key)
return
else:
self.response.set_status(401)
self.response.headers[
'WWW-Authenticate'] = 'Basic realm="BasicTest"'
return
self.response.set_status(404)
def delete_memcache(self):
memcache.delete(self.get_memcache_keyname())
def delete_file(self, name):
memcache.delete(name, namespace="DatastoreFile")
return DatastoreFile.get_by_key_name(name).delete()
def flushBlogPagesCache():
memcache.delete("blog_pages_key")
def _expire_conversation(self):
memcache.delete(self._convo_mckey())
def flushTagList():
memcache.delete("blog_tagList_key")
def add_memcache(self, test):
memcache_keyname = self.get_memcache_keyname(test)
memcache.delete(memcache_keyname)
memcache.add(memcache_keyname, self, settings.STATS_USERTEST_TIMEOUT)
def flushCPedialog():
memcache.delete("blog_cpedialog_key")
def flushRecentReactions():
memcache.delete("blog_recentReactions_key")