def __init__(self, keys): self._keys = list(keys) self._data_valid = False self.__data = None self._cache = memcache.Client() self._cache_rpc = memcache.create_rpc() self._cache_prefix = self.__class__.__name__ self._cache.get_multi_async(self._keys, key_prefix=self._cache_prefix, rpc=self._cache_rpc)
def __init__(self, keys): self._keys = list(keys) self._data_valid = False self.__data = None self._cache = memcache.Client() self._cache_rpc = memcache.create_rpc() self._cache_prefix = self.__class__.__name__ self._cache.get_multi_async(self._keys, key_prefix=self._cache_prefix, rpc=self._cache_rpc)
def POST(self, world): cur_world = world_exists(world) self.redirect_if_not_create(cur_world) i = web.input(long=[], lat=[], prop_name=[], prop_val=[]) coord = [] new = [] access = cur_world.get_access_string(self.page_user) form = self.text_form() if not form.validates(): world_menu = self.get_or_put_menu(cur_world, access) return self.reset_text_page(cur_world, form, access, world_menu) else: if cur_world.is_mod(self.page_user): visible = True """ Flush menus for everyone so they get reset""" mrpc = memcache.create_rpc() m = flush_caches("", cur_world, mrpc) try: m.get_result() except AssertionError: # There were no caches to flush - is this even the problem? pass else: visible = False new_text = Room(world = cur_world.key, name=form.d.name, short_desc=form.d.short_desc, long_desc=form.d.long_desc, added_by=self.page_user.key, latitudes=i.lat, longitudes=i.long, visible=visible, rejected=False ) new_text.put() for index, name in enumerate(i.prop_name): p = Property.get_by_id(int(name)) new.append(PropertyValue()) new[index].value = i.prop_val[index] new[index].of_property = p.key new[index].room = new_text.key new[index].added_by = self.page_user.key new[index].visible = visible valftrs = ndb.put_multi_async(new) self.set_menu(cur_world, access) for ftr in valftrs: ftr.get_result() return web.seeother('/%s/text/%s' % (cur_world.key.id(), new_text.key.id()))
def POST(self, world): cur_world = world_exists(world) self.redirect_if_not_create(cur_world) i = web.input(long=[], lat=[], prop_name=[], prop_val=[]) coord = [] new = [] access = cur_world.get_access_string(self.page_user) form = self.text_form() if not form.validates(): world_menu = self.get_or_put_menu(cur_world, access) return self.reset_text_page(cur_world, form, access, world_menu) else: if cur_world.is_mod(self.page_user): visible = True """ Flush menus for everyone so they get reset""" mrpc = memcache.create_rpc() m = flush_caches("", cur_world, mrpc) try: m.get_result() except AssertionError: # There were no caches to flush - is this even the problem? pass else: visible = False new_text = Room(world=cur_world.key, name=form.d.name, short_desc=form.d.short_desc, long_desc=form.d.long_desc, added_by=self.page_user.key, latitudes=i.lat, longitudes=i.long, visible=visible, rejected=False) new_text.put() for index, name in enumerate(i.prop_name): p = Property.get_by_id(int(name)) new.append(PropertyValue()) new[index].value = i.prop_val[index] new[index].of_property = p.key new[index].room = new_text.key new[index].added_by = self.page_user.key new[index].visible = visible valftrs = ndb.put_multi_async(new) self.set_menu(cur_world, access) for ftr in valftrs: ftr.get_result() return web.seeother('/%s/text/%s' % (cur_world.key.id(), new_text.key.id()))
def _memcache_off_tasklet(self, todo, options): if not todo: raise RuntimeError('Nothing to do.') initial_value, namespace, deadline = options mapping = {} for unused_fut, (key, delta) in todo: mapping[key] = delta rpc = memcache.create_rpc(deadline=deadline) results = yield self._memcache.offset_multi_async( mapping, initial_value=initial_value, namespace=namespace, rpc=rpc) for fut, (key, unused_delta) in todo: fut.set_result(results.get(key))
def _memcache_get_tasklet(self, todo, options): if not todo: raise RuntimeError('Nothing to do.') for_cas, namespace, deadline = options keys = set() for unused_fut, key in todo: keys.add(key) rpc = memcache.create_rpc(deadline=deadline) results = yield self._memcache.get_multi_async(keys, for_cas=for_cas, namespace=namespace, rpc=rpc) for fut, key in todo: fut.set_result(results.get(key))
def memcache_util_get_multi_async_with_deadline( keys, key_prefix='', namespace=None, deadline=DEFAULT_MEMCACHE_GET_DEADLINE): """Like get_multi_async(), but fails if it takes longer than deadline. Asynchronously looks up multiple keys from memcache in one operation. Deadline is in seconds and is defaulted to a reasonable value unless set explicitly. See memcache.Client().get_multi_async documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) return memcache.Client().get_multi_async(keys, key_prefix=key_prefix, namespace=namespace, rpc=rpc)
def memcache_util_add_multi_async_with_deadline( mapping, time=0, key_prefix='', min_compress_len=0, namespace=None, deadline=DEFAULT_MEMCACHE_SET_DEADLINE): """Like add_multi_async(), but fails if it takes longer than deadline. Asynchronously adds multiple keys' values at once. Deadline is in seconds and is defaulted to a reasonable value unless set explicitly. See memcache.Client().add_multi_async documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) return memcache.Client().add_multi_async(mapping, time=time, key_prefix=key_prefix, min_compress_len=min_compress_len, namespace=namespace, rpc=rpc)
def memcache_util_get_multi_async_with_deadline( keys, key_prefix='', namespace=None, deadline=DEFAULT_MEMCACHE_GET_DEADLINE): """Like get_multi_async(), but fails if it takes longer than deadline. Asynchronously looks up multiple keys from memcache in one operation. Deadline is in seconds and is defaulted to a reasonable value unless set explicitly. See memcache.Client().get_multi_async documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) return memcache.Client().get_multi_async(keys, key_prefix=key_prefix, namespace=namespace, rpc=rpc)
def get(self): count = int(self.request.get('count')) if count < 1: self.response.write('Count must be at least 1\n') return rpcs = [] c = memcache.Client() for x in xrange(count): rpc = memcache.create_rpc(deadline=30) c.get_multi_async(["roger"], rpc=rpc) rpcs.append(rpc) for rpc in rpcs: rpc.wait() self.response.write('OK\n')
def memcache_util_delete_with_deadline( key, seconds=0, namespace=None, deadline=DEFAULT_MEMCACHE_SET_DEADLINE): """Like delete(), but fails if it takes longer than deadline seconds. Deletes a key. Deadline is in seconds and is defaulted to a reasonable value unless delete explicitly. If the deadline is reached before memcache responds, False is returned. See memcache.delete documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) async_response = memcache.Client().delete_multi_async( [key], seconds=seconds, key_prefix='', namespace=namespace, rpc=rpc) results = async_response.get_result() if not results: return memcache.DELETE_NETWORK_FAILURE return results[0]
def _memcache_del_tasklet(self, todo, options): if not todo: raise RuntimeError('Nothing to do.') seconds, namespace, deadline = options keys = set() for unused_fut, key in todo: keys.add(key) rpc = memcache.create_rpc(deadline=deadline) statuses = yield self._memcache.delete_multi_async(keys, seconds=seconds, namespace=namespace, rpc=rpc) status_key_mapping = {} if statuses: for key, status in zip(keys, statuses): status_key_mapping[key] = status for fut, key in todo: status = status_key_mapping.get(key, memcache.DELETE_NETWORK_FAILURE) fut.set_result(status)
def _memcache_set_tasklet(self, todo, options): if not todo: raise RuntimeError('Nothing to do.') opname, time, namespace, deadline = options methodname = opname + '_multi_async' method = getattr(self._memcache, methodname) mapping = {} for unused_fut, (key, value) in todo: mapping[key] = value rpc = memcache.create_rpc(deadline=deadline) results = yield method(mapping, time=time, namespace=namespace, rpc=rpc) for fut, (key, unused_value) in todo: if results is None: status = memcache.MemcacheSetResponse.ERROR else: status = results.get(key) fut.set_result(status == memcache.MemcacheSetResponse.STORED)
def memcache_util_add_multi_async_with_deadline( mapping, time=0, key_prefix='', min_compress_len=0, namespace=None, deadline=DEFAULT_MEMCACHE_SET_DEADLINE): """Like add_multi_async(), but fails if it takes longer than deadline. Asynchronously adds multiple keys' values at once. Deadline is in seconds and is defaulted to a reasonable value unless set explicitly. See memcache.Client().add_multi_async documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) return memcache.Client().add_multi_async(mapping, time=time, key_prefix=key_prefix, min_compress_len=min_compress_len, namespace=namespace, rpc=rpc)
def memcache_util_delete_with_deadline(key, seconds=0, namespace=None, deadline=DEFAULT_MEMCACHE_SET_DEADLINE): """Like delete(), but fails if it takes longer than deadline seconds. Deletes a key. Deadline is in seconds and is defaulted to a reasonable value unless delete explicitly. If the deadline is reached before memcache responds, False is returned. See memcache.delete documentation for details. """ rpc = memcache.create_rpc(deadline=deadline) async_response = memcache.Client().delete_multi_async([key], seconds=seconds, key_prefix='', namespace=namespace, rpc=rpc) results = async_response.get_result() if not results: return memcache.DELETE_NETWORK_FAILURE return results[0]
def test_raise_rpc_error(self): rpc = memcache.create_rpc() with self.assertRaises(Exception): memcachetag.get_multi_async_with_tags(['test'], rpc=rpc)
def POST(self, world, text): cur_world = world_exists(world) cur_text = text_exists(text) self.redirect_if_not_edit(cur_world, cur_text) a = cur_world.get_access_string(self.page_user) post = web.input() if hasattr(post, 'delete'): PropertyValue.delete_all_for_text(cur_text) cur_text.key.delete() """ Flush menus for everyone so they get reset""" # TODO: Fix cache flushing for everyone else self.replace_or_put_menu(cur_world, a) if a == "admin": memcache.delete("%s-closed" % cur_world.key.id()) elif a == "closed": memcache.delete("%s-admin" % cur_world.key.id()) raise web.seeother("/%s/text" % cur_world.key.id()) else: i = web.input(long=[], lat=[], prop_name=[], prop_val=[], del_property=[], action_val=[], mod_id=[]) coord = [] new = [] form = self.text_form() if not form.validates(): world_menu = self.get_or_put_menu(cur_world, a) return self.reset_text_page(cur_world, form, a, world_menu, cur_text) else: cur_text.world = cur_world.key cur_text.name = form.d.name cur_text.short_desc = form.d.short_desc cur_text.long_desc = form.d.long_desc cur_text.last_modified_by = self.page_user.key cur_text.latitudes = i.lat cur_text.longitudes = i.long text_ftr = cur_text.put_async() if cur_world.is_mod(self.page_user): visible = True """ Flush menus for everyone so they get reset""" mrpc = memcache.create_rpc() m = flush_caches("", cur_world, mrpc) try: m.get_result() except AssertionError: # There were no caches to flush - this doesn't work pass else: visible = False for index, name in enumerate(i.prop_name): p = ndb.Key('Property', int(name)) new.append(PropertyValue()) new[index].value = i.prop_val[index] new[index].of_property = p new[index].room = cur_text.key new[index].added_by = self.page_user.key new[index].visible = visible new_values_ftrs = ndb.put_multi_async(new) value_keys = [] for index, p_id in enumerate(i.del_property): value_keys.append(ndb.Key('PropertyValue', int(p_id))) ndb.delete_multi(value_keys) for ftr in new_values_ftrs: ftr.get_result() text_ftr.get_result() self.set_menu(cur_world, a) return web.seeother("/%s/text/%s" % (cur_world.key.id(), cur_text.key.id()))