def get(self, context_name, class_name, instance_id): optional_params = INSTANCE_PARAMS with safe_params(optional_params): self.query_params = ParamDict(self, context_name=context_name, class_name=class_name, instance_id=instance_id, **optional_params) response = memoize(self.query_params, get_instance, key=build_instance_key(self.query_params), function_arguments=self.query_params) if response is None: error_message = u"Instance ({0}) of class ({1}) in graph ({2}) was not found.".format( self.query_params['instance_uri'], self.query_params['class_uri'], self.query_params['graph_uri']) raise HTTPError(404, log_message=error_message) response_meta = response['meta'] response = response['body'] if self.query_params["expand_uri"] == "0": response = normalize_all_uris_recursively(response, mode=SHORTEN) self.add_cache_headers(response_meta) self.finalize(response)
def get(self, context_name, class_name, instance_id): optional_params = INSTANCE_PARAMS with safe_params(optional_params): self.query_params = ParamDict(self, context_name=context_name, class_name=class_name, instance_id=instance_id, **optional_params) response = memoize(self.query_params, get_instance, key=build_instance_key(self.query_params), function_arguments=self.query_params) if response is None: error_message = u"Instance ({0}) of class ({1}) in graph ({2}) was not found.".format( self.query_params['instance_uri'], self.query_params['class_uri'], self.query_params['graph_uri']) raise HTTPError(404, log_message=error_message) response_meta = response['meta'] response = response['body'] if self.query_params["expand_uri"] == "0": response = normalize_all_uris_recursively(response, mode=SHORTEN) self.add_cache_headers(response_meta) self.finalize(response)
def test_memoize_cache_enabled_and_hit(self, settings): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) self.assertEqual(answer['status'], "Dishes cleaned up") self.assertEqual(answer['meta']['cache'], "HIT")
def test_memoize_cache_enabled_and_hit_with_different_key(self, settings): def ressurect(): return {"status": "Ressurected"} params = {'request': MockRequest(uri="/home")} answer = memoize(params, ressurect, key="/grave") self.assertEqual(answer["status"], "Sleeping") self.assertEqual(answer['meta']['cache'], "HIT")
def test_memoize_cache_enabled_and_hit(self, strict_redis, redis_get, redis_set, settings): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) self.assertEqual(answer['status'], "Dishes cleaned up") self.assertEqual(redis_get.call_count, 1)
def test_memoize_cache_enabled_and_hit_with_different_key(self, settings): def ressurect(): return {"status": "Ressurected"} params = {'request': MockRequest(uri="/home")} answer = memoize(params, ressurect, key="/grave") self.assertEqual(answer["status"], "Sleeping") self.assertEqual(answer['meta']['cache'], "HIT")
def test_memoize_cache_enabled_and_hit(self, settings): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) self.assertEqual(answer['status'], "Dishes cleaned up") self.assertEqual(answer['meta']['cache'], "HIT")
def test_memoize_cache_enabled_and_hit(self, strict_redis, redis_get, redis_set, settings): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) self.assertEqual(answer['status'], "Dishes cleaned up") self.assertEqual(redis_get.call_count, 1)
def patch(self, context_name, class_name, instance_id): valid_params = INSTANCE_PARAMS with safe_params(valid_params): self.query_params = ParamDict(self, context_name=context_name, class_name=class_name, instance_id=instance_id, **valid_params) del context_name del class_name del instance_id patch_list = get_json_request_as_dict(self.request.body) # Retrieve original data instance_data = memoize(self.query_params, get_instance, key=build_instance_key(self.query_params), function_arguments=self.query_params) if instance_data is not None: # Editing an instance instance_data = instance_data['body'] instance_data.pop( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', None) # compute patch changed_data = apply_patch(instance_data, patch_list) # Try to put edit_instance(self.query_params, changed_data) status = 200 # Clear cache cache.purge_an_instance(self.query_params['instance_uri']) self.finalize(status) else: # Creating a new instance from patch list instance_data = get_instance_data_from_patch_list(patch_list) instance_data = normalize_all_uris_recursively(instance_data) rdf_type_error = is_rdf_type_invalid(self.query_params, instance_data) if rdf_type_error: raise HTTPError(400, log_message=rdf_type_error) instance_uri, instance_id = create_instance( self.query_params, instance_data, self.query_params["instance_uri"]) resource_url = self.request.full_url() status = 201 self.set_header("location", resource_url) self.set_header("X-Brainiak-Resource-URI", instance_uri) self.finalize(status)
def get_cached_schema(query_params, include_meta=False): schema_key = build_key_for_class(query_params) class_object = memoize(query_params, get_schema, query_params, key=schema_key) if class_object is None or not class_object["body"]: msg = _(u"The class definition for {0} was not found in graph {1}") raise SchemaNotFound(msg.format(query_params['class_uri'], query_params['graph_uri'])) if include_meta: return class_object else: return class_object['body']
def test_memoize_cache_disabled(self, strict_redis, redis_get, redis_set, settings): def clean_up(): return {"status": "Laundry done"} params = {'request': MockRequest(uri="/home")} answer = memoize(params, clean_up) self.assertEqual(answer["body"], {"status": "Laundry done"}) self.assertTrue(answer["meta"]) self.assertEqual(redis_get.call_count, 0) self.assertEqual(redis_set.call_count, 0)
def test_memoize_cache_disabled(self, strict_redis, redis_get, redis_set, settings): def clean_up(): return {"status": "Laundry done"} params = {'request': MockRequest(uri="/home")} answer = memoize(params, clean_up) self.assertEqual(answer["body"], {"status": "Laundry done"}) self.assertTrue(answer["meta"]) self.assertEqual(redis_get.call_count, 0) self.assertEqual(redis_set.call_count, 0)
def get(self): valid_params = PAGING_PARAMS with safe_params(valid_params): self.query_params = ParamDict(self, **valid_params) response = memoize(self.query_params, list_all_contexts, function_arguments=self.query_params, key=cache.build_key_for_root(self.query_params)) if response is None: raise HTTPError(404, log_message=_("Failed to retrieve list of graphs")) self.add_cache_headers(response['meta']) self.finalize(response['body'])
def test_memoize_cache_disabled_delegatee_receive_params(self, strict_redis, redis_get, redis_set, settings): def clean_up(param_value): return {"status": param_value} params = {'request': MockRequest(uri="/home")} param_to_clean_up = 'It was received by the wrapped function' answer = memoize(params, clean_up, function_arguments=param_to_clean_up) self.assertEqual(answer["body"], {"status": param_to_clean_up}) self.assertTrue(answer["meta"]) self.assertEqual(redis_get.call_count, 0) self.assertEqual(redis_set.call_count, 0)
def test_memoize_cache_disabled_delegatee_receive_params(self, strict_redis, redis_get, redis_set, settings): def clean_up(param_value): return {"status": param_value} params = {'request': MockRequest(uri="/home")} param_to_clean_up = 'It was received by the wrapped function' answer = memoize(params, clean_up, function_arguments=param_to_clean_up) self.assertEqual(answer["body"], {"status": param_to_clean_up}) self.assertTrue(answer["meta"]) self.assertEqual(redis_get.call_count, 0) self.assertEqual(redis_set.call_count, 0)
def get(self): valid_params = PAGING_PARAMS with safe_params(valid_params): self.query_params = ParamDict(self, **valid_params) response = memoize(self.query_params, list_all_contexts, function_arguments=self.query_params, key=cache.build_key_for_root(self.query_params)) if response is None: raise HTTPError(404, log_message=_("Failed to retrieve list of graphs")) self.add_cache_headers(response['meta']) self.finalize(response['body'])
def get(self): with safe_params(): self.query_params = ParamDict(self) response = memoize(self.query_params, root_schema, key=self.get_cache_path()) if response is None: raise HTTPError(404, log_message=_("Failed to retrieve json-schema")) self.add_cache_headers(response['meta']) self.finalize(response['body'])
def get(self): with safe_params(): self.query_params = ParamDict(self) response = memoize( self.query_params, root_schema, key=self.get_cache_path() ) if response is None: raise HTTPError(404, log_message=_("Failed to retrieve json-schema")) self.add_cache_headers(response['meta']) self.finalize(response['body'])
def get_cached_schema(query_params, include_meta=False): schema_key = build_key_for_class(query_params) class_object = memoize(query_params, get_schema, query_params, key=schema_key) if class_object is None or not class_object["body"]: msg = _(u"The class definition for {0} was not found in graph {1}") raise SchemaNotFound( msg.format(query_params['class_uri'], query_params['graph_uri'])) if include_meta: return class_object else: return class_object['body']
def get(self): with safe_params(): self.query_params = ParamDict(self) response = memoize(self.query_params, root_schema, key=self.get_cache_path()) if response is None: raise HTTPError(404, log_message=_("Failed to retrieve json-schema")) self.add_cache_headers(response['meta']) # FIXME: handle cache policy uniformly self.set_header("Cache-control", "private") self.set_header("max-age", "0") self.finalize(response['body'])
def test_memoize_cache_enabled_but_without_cache(self, strict_redis, redis_get, redis_set, settings, isoformat): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) expected = { 'body': {"status": "Laundry done"}, 'meta': { 'cache': 'MISS', 'last_modified': 'Fri, 11 May 1984 20:00:00 -0300' } } self.assertEqual(answer, expected) self.assertEqual(redis_get.call_count, 1) self.assertEqual(redis_set.call_count, 1)
def test_memoize_cache_enabled_but_without_cache(self, strict_redis, redis_get, redis_set, settings, isoformat): def clean_up(): return {"status": "Laundry done"} params = Mock(request=MockRequest(uri="/home")) answer = memoize(params, clean_up) expected = { 'body': {"status": "Laundry done"}, 'meta': { 'cache': 'MISS', 'last_modified': 'Fri, 11 May 1984 20:00:00 -0300' } } self.assertEqual(answer, expected) self.assertEqual(redis_get.call_count, 1) self.assertEqual(redis_set.call_count, 1)
def patch(self, context_name, class_name, instance_id): valid_params = INSTANCE_PARAMS with safe_params(valid_params): self.query_params = ParamDict(self, context_name=context_name, class_name=class_name, instance_id=instance_id, **valid_params) del context_name del class_name del instance_id try: patch_list = json.loads(self.request.body) except ValueError: raise HTTPError(400, log_message=_("No JSON object could be decoded")) # Retrieve original data instance_data = memoize(self.query_params, get_instance, key=build_instance_key(self.query_params), function_arguments=self.query_params) try: instance_data = instance_data['body'] except TypeError: raise HTTPError(404, log_message=_("Inexistent instance")) instance_data.pop('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', None) # compute patch changed_data = apply_patch(instance_data, patch_list) # Try to put edit_instance(self.query_params, changed_data) status = 200 # Clear cache cache.purge_an_instance(self.query_params['instance_uri']) self.finalize(status)
def patch(self, context_name, class_name, instance_id): valid_params = INSTANCE_PARAMS with safe_params(valid_params): self.query_params = ParamDict(self, context_name=context_name, class_name=class_name, instance_id=instance_id, **valid_params) del context_name del class_name del instance_id try: patch_list = json.loads(self.request.body) except ValueError: raise HTTPError(400, log_message=_("No JSON object could be decoded")) # Retrieve original data instance_data = memoize(self.query_params, get_instance, key=build_instance_key(self.query_params), function_arguments=self.query_params) try: instance_data = instance_data['body'] except TypeError: raise HTTPError(404, log_message=_("Inexistent instance")) instance_data.pop('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', None) # compute patch changed_data = apply_patch(instance_data, patch_list) # Try to put edit_instance(self.query_params, changed_data) status = 200 # Clear cache cache.purge_an_instance(self.query_params['instance_uri']) self.finalize(status)