def _AddTransactionalBulkTask(self, request, response): """ Add a transactional task. Args: request: A taskqueue_service_pb.TaskQueueAddRequest. response: A taskqueue_service_pb.TaskQueueAddResponse. Returns: The taskqueue response. """ for add_request in request.add_request_list(): task_result = response.add_taskresult() task_name = None if add_request.has_task_name(): task_name = add_request.task_name() if not task_name: task_name = self._ChooseTaskName() namespaced_name = '_'.join( ['task', self.__app_id, add_request.queue_name(), task_name]) add_request.set_task_name(task_name) task_result.set_chosen_task_name(namespaced_name) for add_request, task_result in zip(request.add_request_list(), response.taskresult_list()): task_result.set_result( taskqueue_service_pb.TaskQueueServiceError.OK) # All task should have been validated and assigned a unique name by this point. try: apiproxy_stub_map.MakeSyncCall('datastore_v3', 'AddActions', request, api_base_pb.VoidProto()) except apiproxy_errors.ApplicationError, e: raise apiproxy_errors.ApplicationError( e.application_error + taskqueue_service_pb.TaskQueueServiceError.DATASTORE_ERROR, e.error_detail)
def __insert_v3_entity(self, v3_entity, v3_txn): """Inserts a v3 entity. Args: v3_entity: an entity_pb.EntityProto v3_txn: a datastore_pb.Transaction or None Returns: a tuple (the number of index writes that occurred, the entity key) Raises: ApplicationError: if the entity already exists """ if not v3_txn: v3_txn = datastore_pb.Transaction() v3_begin_txn_req = datastore_pb.BeginTransactionRequest() v3_begin_txn_req.set_app(v3_entity.key().app()) self.__make_v3_call('BeginTransaction', v3_begin_txn_req, v3_txn) _, key = self.__insert_v3_entity(v3_entity, v3_txn) v3_resp = datastore_pb.CommitResponse() self.__make_v3_call('Commit', v3_txn, v3_resp) return (v3_resp.cost().index_writes(), key) if datastore_pbs.is_complete_v3_key(v3_entity.key()): v3_get_req = datastore_pb.GetRequest() v3_get_req.mutable_transaction().CopyFrom(v3_txn) v3_get_req.key_list().append(v3_entity.key()) v3_get_resp = datastore_pb.GetResponse() self.__make_v3_call('Get', v3_get_req, v3_get_resp) if v3_get_resp.entity(0).has_entity(): raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Entity already exists.') v3_put_req = datastore_pb.PutRequest() v3_put_req.mutable_transaction().CopyFrom(v3_txn) v3_put_req.entity_list().append(v3_entity) v3_put_resp = datastore_pb.PutResponse() self.__make_v3_call('Put', v3_put_req, v3_put_resp) return (v3_put_resp.cost().index_writes(), v3_put_resp.key(0))
def _RemoteSend(self, request, response, method): """ Sends a request remotely to the search server. Args: request: A request object. response: A response object to be filled in. method: A str, the dynamic function doing the call. """ if not self.__search_location: raise search.InternalError("Search service not configured.") api_request = remote_api_pb.Request() api_request.set_method(method) api_request.set_service_name("search") api_request.set_request(request.Encode()) api_response = remote_api_pb.Response() api_response = api_request.sendCommand(self.__search_location, "", api_response, 1, False, KEY_LOCATION, CERT_LOCATION) if api_response.has_application_error(): error_pb = api_response.application_error() logging.error(error_pb.detail()) raise apiproxy_errors.ApplicationError(error_pb.code(), error_pb.detail()) if api_response.has_exception(): raise api_response.exception() if not api_response or not api_response.has_response(): raise search.InternalError( 'No response from search server on %s requests.' % method) response.ParseFromString(api_response.response())
def _Dynamic_AddActions(self, request, _): """Associates the creation of one or more tasks with a transaction. Args: request: A taskqueue_service_pb.TaskQueueBulkAddRequest containing the tasks that should be created when the transaction is comitted. """ if ((len(self.__tx_actions) + request.add_request_size()) > _MAX_ACTIONS_PER_TXN): raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Too many messages, maximum allowed %s' % _MAX_ACTIONS_PER_TXN) new_actions = [] for add_request in request.add_request_list(): self.__ValidateTransaction(add_request.transaction()) clone = taskqueue_service_pb.TaskQueueAddRequest() clone.CopyFrom(add_request) clone.clear_transaction() new_actions.append(clone) self.__tx_actions.extend(new_actions)
def __get_task_function(self, request): """ Returns a function pointer to a celery task. Load the module for the app/queue. Args: request: A taskqueue_service_pb.TaskQueueAddRequest. Returns: A function pointer to a celery task. Raises: taskqueue_service_pb.TaskQueueServiceError """ try: task_module = __import__(TaskQueueConfig.\ get_celery_worker_module_name(request.app_id())) task_func = getattr( task_module, TaskQueueConfig.get_queue_function_name(request.queue_name())) return task_func except AttributeError, attribute_error: logging.exception(attribute_error) raise apiproxy_errors.ApplicationError( taskqueue_service_pb.TaskQueueServiceError.UNKNOWN_QUEUE)
def _Rotate(self, image, transform): """Use PIL to rotate the given image with the given transform. Args: image: PIL.Image.Image object to rotate. transform: images_service_pb.Transform to use when rotating. Returns: PIL.Image.Image with transforms performed on it. Raises: BadRequestError if the rotate data given is bad. """ degrees = transform.rotate() if degrees < 0 or degrees % 90 != 0: raise apiproxy_errors.ApplicationError( images_service_pb.ImagesServiceError.BAD_TRANSFORM_DATA) degrees %= 360 degrees = 360 - degrees return image.rotate(degrees)
def _MakeRealSyncCall(self, service, call, request, response): request_pb = remote_api_pb.Request() request_pb.set_service_name(service) request_pb.set_method(call) request_pb.set_request(request.Encode()) response_pb = remote_api_pb.Response() encoded_request = request_pb.Encode() encoded_response = self._server.Send(self._path, encoded_request) response_pb.ParseFromString(encoded_response) if response_pb.has_application_error(): error_pb = response_pb.application_error() raise apiproxy_errors.ApplicationError(error_pb.code(), error_pb.detail()) elif response_pb.has_exception(): raise pickle.loads(response_pb.exception()) elif response_pb.has_java_exception(): raise UnknownJavaServerError("An unknown error has occured in the " "Java remote_api handler for this call.") else: response.ParseFromString(response_pb.response())
def TranslateSystemErrors(method): """Decorator to catch and translate socket.error to ApplicationError. Args: method: An unbound method of APIProxyStub or a subclass. Returns: The method, altered such it catches socket.error, socket.timeout and socket.gaierror and re-raises the required apiproxy_errors.ApplicationError. """ def WrappedMethod(self, *args, **kwargs): try: return method(self, *args, **kwargs) except socket.gaierror, e: raise apiproxy_errors.ApplicationError( RemoteSocketServiceError.GAI_ERROR, 'system_error:%u error_detail:"%s"' % (e.errno, e.strerror)) except socket.timeout, e: raise apiproxy_errors.ApplicationError( RemoteSocketServiceError.SYSTEM_ERROR, 'system_error:%u error_detail:"%s"' % (errno.EAGAIN, os.strerror(errno.EAGAIN)))
def _MakeRemoteSyncCall(self, service, call, request, response): """Send an RPC to a remote_api endpoint.""" request_pb = remote_api_pb.Request() request_pb.set_service_name(service) request_pb.set_method(call) request_pb.set_request(request.Encode()) response_pb = remote_api_pb.Response() encoded_request = request_pb.Encode() try: urlfetch_response = urlfetch.fetch(self.remote_url, encoded_request, urlfetch.POST, self.extra_headers, follow_redirects=False, deadline=10) except Exception as e: logging.exception('Fetch failed to %s', self.remote_url) raise FetchFailed(e) if urlfetch_response.status_code != 200: logging.error('Fetch failed to %s; Status %s; body %s', self.remote_url, urlfetch_response.status_code, urlfetch_response.content) raise FetchFailed(urlfetch_response.status_code) response_pb.ParseFromString(urlfetch_response.content) if response_pb.has_application_error(): error_pb = response_pb.application_error() raise apiproxy_errors.ApplicationError(error_pb.code(), error_pb.detail()) elif response_pb.has_exception(): raise pickle.loads(response_pb.exception()) elif response_pb.has_java_exception(): raise UnknownJavaServerError( 'An unknown error has occured in the ' 'Java remote_api handler for this call.') else: response.ParseFromString(response_pb.response())
def Add(self, request): """Inserts a new task into the store. Args: request: A taskqueue_service_pb.TaskQueueAddRequest. Raises: apiproxy_errors.ApplicationError: If a task with the same name is already in the store. """ pos = bisect.bisect_left(self._sorted_by_name, (request.task_name(), )) if (pos < len(self._sorted_by_name) and self._sorted_by_name[pos][0] == request.task_name()): raise apiproxy_errors.ApplicationError( taskqueue_service_pb.TaskQueueServiceError.TASK_ALREADY_EXISTS) now = datetime.datetime.utcnow() now_sec = time.mktime(now.timetuple()) task = taskqueue_service_pb.TaskQueueQueryTasksResponse_Task() task.set_task_name(request.task_name()) task.set_eta_usec(request.eta_usec()) task.set_creation_time_usec(now_sec * 1e6) task.set_url(request.url()) task.set_method(request.method()) for keyvalue in task.header_list(): header = task.add_header() header.set_key(keyvalue.key()) header.set_value(keyvalue.value()) if request.has_description(): task.set_description(request.description()) if request.has_body(): task.set_body(request.body()) if request.has_crontimetable(): task.mutable_crontimetable().set_schedule( request.crontimetable().schedule()) task.mutable_crontimetable().set_timezone( request.crontimetable().timezone()) self._InsertTask(task)
def _Dynamic_Next(self, next_request, query_result): assert next_request.offset() == 0 cursor_id = next_request.cursor().cursor() if cursor_id not in self.__queries: raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Cursor %d not found' % cursor_id) query = self.__queries[cursor_id] if query is None: query_result.set_more_results(False) return else: if next_request.has_count(): query.set_count(next_request.count()) else: query.clear_count() self._Dynamic_RunQuery(query, query_result, cursor_id) query_result.set_skipped_results(0)
def __update_v3_entity(self, v3_entity, v3_txn): """Updates a v3 entity. Args: v3_entity: a datastore_v4_pb.Entity v3_txn: a datastore_pb.Transaction or None Returns: the number of index writes that occurred Raises: ApplicationError: if the entity does not exist """ if not v3_txn: v3_txn = datastore_pb.Transaction() v3_begin_txn_req = datastore_pb.BeginTransactionRequest() v3_begin_txn_req.set_app(v3_entity.key().app()) self.__make_v3_call('BeginTransaction', v3_begin_txn_req, v3_txn) self.__update_v3_entity(v3_entity, v3_txn) v3_resp = datastore_pb.CommitResponse() self.__make_v3_call('Commit', v3_txn, v3_resp) return v3_resp.cost().index_writes() v3_get_req = datastore_pb.GetRequest() v3_get_req.mutable_transaction().CopyFrom(v3_txn) v3_get_req.key_list().append(v3_entity.key()) v3_get_resp = datastore_pb.GetResponse() self.__make_v3_call('Get', v3_get_req, v3_get_resp) if not v3_get_resp.entity(0).has_entity(): raise apiproxy_errors.ApplicationError( datastore_v4_pb.Error.BAD_REQUEST, 'Entity does not exist.') v3_put_req = datastore_pb.PutRequest() v3_put_req.mutable_transaction().CopyFrom(v3_txn) v3_put_req.entity_list().append(v3_entity) v3_put_resp = datastore_pb.PutResponse() self.__make_v3_call('Put', v3_put_req, v3_put_resp) return v3_put_resp.cost().index_writes()
def _Dynamic_Histogram(self, request, response): """Trivial implementation of an API. Based off documentation of the PIL library at http://www.pythonware.com/library/pil/handbook/index.htm Args: request: ImagesHistogramRequest - Contains the image. response: ImagesHistogramResponse - Contains histogram of the image. Raises: ApplicationError: Image was of an unsupported format. """ image = self._OpenImageData(request.image()) img_format = image.format if img_format not in FORMAT_LIST: raise apiproxy_errors.ApplicationError( images_service_pb.ImagesServiceError.NOT_IMAGE) image = image.convert(RGBA) red = [0] * 256 green = [0] * 256 blue = [0] * 256 for pixel in image.getdata(): red[int((pixel[0] * pixel[3]) / 255)] += 1 green[int((pixel[1] * pixel[3]) / 255)] += 1 blue[int((pixel[2] * pixel[3]) / 255)] += 1 histogram = response.mutable_histogram() for value in red: histogram.add_red(value) for value in green: histogram.add_green(value) for value in blue: histogram.add_blue(value)
def _Dynamic_SendChannelMessage(self, request, response): """Implementation of channel.send_message. Queues a message to be retrieved by the client when it polls. Args: request: A SendMessageRequest. response: A VoidProto. """ application_key = request.application_key() if not request.message(): raise apiproxy_errors.ApplicationError( channel_service_pb.ChannelServiceError.BAD_MESSAGE) conn = httplib.HTTPConnection(self._address) headers = { 'Content-Type': 'text/plain', 'Last-Modified': rfc1123_date() } conn.request("POST", "/_ah/publish?id=%s" % application_key, request.message(), headers) conn.close()
def _Dynamic_GetSocketOptions(self, request, response): state = self._LookupSocket(request.socket_descriptor()) for opt in request.options_list(): if (opt.level() == remote_socket_service_pb.SocketOption.SOCKET_SOL_SOCKET and opt.option() == remote_socket_service_pb.SocketOption.SOCKET_SO_ERROR): ret = response.add_options() ret.set_level(opt.level()) ret.set_option(opt.option()) ret.set_value( state.sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR, 1024)) else: value = self._mock_options.GetMockValue(opt.level(), opt.option()) if value is None: raise apiproxy_errors.ApplicationError( RemoteSocketServiceError.PERMISSION_DENIED, 'Attempt to get blocked socket option.') ret = response.add_options() ret.set_level(opt.level()) ret.set_option(opt.option()) ret.set_value(value)
def __filter_binding(self, key, value, operation, prototype): if key in prototype: key += self.__filter_suffix(prototype[key]) if key == "__key__": key = "_id" value = self.__id_for_key(value._ToPb()) else: value = self.__create_mongo_value_for_value(value) if operation == "<": return (key, {'$lt': value}) elif operation == '<=': return (key, {'$lte': value}) elif operation == '>': return (key, {'$gt': value}) elif operation == '>=': return (key, {'$gte': value}) elif operation == '==': return (key, value) raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, "Can't handle operation %r." % operation)
def _Dynamic_Commit(self, transaction, transaction_response): if not self.__transactions.has_key(transaction.handle()): raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Transaction handle %d not found' % transaction.handle()) self.__tx_snapshot = {} try: self.__WriteDatastore() for action in self.__tx_actions: try: apiproxy_stub_map.MakeSyncCall('taskqueue', 'Add', action, api_base_pb.VoidProto()) except apiproxy_errors.ApplicationError, e: logging.warning( 'Transactional task %s has been dropped, %s', action, e) pass finally: self.__tx_actions = [] self.__tx_lock.release()
def _Dynamic_AllocateIds(self, req, resp): v3_stub = apiproxy_stub_map.apiproxy.GetStub(V3_SERVICE_NAME) try: self.__service_validator.validate_allocate_ids_req(req) if req.allocate_list(): v3_refs = self.__entity_converter.v4_to_v3_references( req.allocate_list()) v3_full_refs = v3_stub._AllocateIds(v3_refs) resp.allocated_list().extend( self.__entity_converter.v3_to_v4_keys(v3_full_refs)) elif req.reserve_list(): v3_refs = self.__entity_converter.v4_to_v3_references( req.reserve_list()) v3_stub._AllocateIds(v3_refs) except datastore_pbs.InvalidConversionError, e: raise apiproxy_errors.ApplicationError( datastore_v4_pb.Error.BAD_REQUEST, str(e))
def __ReadPickled(self, filename): """Reads a pickled object from the given file and returns it. """ self.__file_lock.acquire() try: try: if filename and filename != '/dev/null' and os.path.isfile(filename): return pickle.load(open(filename, 'rb')) else: logging.warning('Could not read datastore data from %s', filename) except (AttributeError, LookupError, ImportError, NameError, TypeError, ValueError, struct.error, pickle.PickleError), e: raise apiproxy_errors.ApplicationError( datastore_pb.Error.INTERNAL_ERROR, 'Could not read data from %s. Try running with the ' '--clear_datastore flag. Cause:\n%r' % (filename, e)) finally: self.__file_lock.release() return []
def _Dynamic_Next(self, next_request, query_result): cursor = next_request.cursor().cursor() query_result.set_more_results(False) if cursor == 0: # we exited early from the query w/ no results... return try: cursor = self.__queries[cursor] except KeyError: raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Cursor %d not found' % cursor) count = next_request.count() if count == 0: count = 1 for _ in range(count): try: query_result.result_list().append( self.__entity_for_mongo_document(cursor.next())) except StopIteration: return query_result.set_more_results(True)
def _Rotate(self, image, transform): """Use PIL to rotate the given image with the given transform. Args: image: PIL.Image.Image object to rotate. transform: images_service_pb.Transform to use when rotating. Returns: PIL.Image.Image with transforms performed on it. Raises: BadRequestError if the rotate data given is bad. """ degrees = transform.rotate() if degrees < 0 or degrees % 90 != 0: raise apiproxy_errors.ApplicationError( images_service_pb.ImagesServiceError.BAD_TRANSFORM_DATA) degrees %= 360 degrees = 360 - degrees # AppScale: An update to the pillow library makes the expand parameter # necessary to behave the same way as GAE does. return image.rotate(degrees, expand=True)
def _Dynamic_Commit(self, req, resp): try: self.__service_validator.validate_commit_req(req) if req.has_transaction(): resp.mutable_deprecated_mutation_result() resp.mutable_deprecated_mutation_result().CopyFrom( self.__apply_v4_deprecated_mutation( req.deprecated_mutation(), req.transaction())) v3_req = self.__service_converter.v4_commit_req_to_v3_txn(req) v3_resp = datastore_pb.CommitResponse() self.__make_v3_call('Commit', v3_req, v3_resp) total_index_updates = ( resp.mutable_deprecated_mutation_result().index_updates() + v3_resp.cost().index_writes()) resp.mutable_deprecated_mutation_result().set_index_updates( total_index_updates) else: resp.mutable_deprecated_mutation_result().CopyFrom( self.__apply_v4_deprecated_mutation( req.deprecated_mutation(), None)) except datastore_pbs.InvalidConversionError, e: raise apiproxy_errors.ApplicationError( datastore_v4_pb.Error.BAD_REQUEST, str(e))
def _RemoteSend(self, request, response, method): """Sends a request remotely to the datstore server. """ tag = self.__app_id self._maybeSetDefaultAuthDomain() user = users.GetCurrentUser() if user != None: tag += ":" + user.email() tag += ":" + user.nickname() tag += ":" + user.auth_domain() api_request = remote_api_pb.Request() api_request.set_method(method) api_request.set_service_name("datastore_v3") api_request.set_request(request.Encode()) api_response = remote_api_pb.Response() api_response = api_request.sendCommand(self.__datastore_location, tag, api_response, 1, self.__is_encrypted, KEY_LOCATION, CERT_LOCATION) if not api_response or not api_response.has_response(): raise datastore_errors.InternalError( 'No response from db server on %s requests.' % method) if api_response.has_application_error(): error_pb = api_response.application_error() logging.error(error_pb.detail()) raise apiproxy_errors.ApplicationError(error_pb.code(), error_pb.detail()) if api_response.has_exception(): raise api_response.exception() response.ParseFromString(api_response.response())
def _MakeCallDone(self): self._state = RPC.FINISHING self.cpu_usage_mcycles = self._result_dict['cpu_usage_mcycles'] if self._result_dict['error'] == APPLICATION_ERROR: appl_err = self._result_dict['application_error'] if appl_err == MEMCACHE_UNAVAILABLE and self.package == 'memcache': self._exception = apiproxy_errors.CapabilityDisabledError( 'The memcache service is temporarily unavailable. %s' % self._result_dict['error_detail']) else: self._exception = apiproxy_errors.ApplicationError( appl_err, self._result_dict['error_detail']) elif self._result_dict['error'] == CAPABILITY_DISABLED: if self._result_dict['error_detail']: self._exception = apiproxy_errors.CapabilityDisabledError( self._result_dict['error_detail']) else: self._exception = apiproxy_errors.CapabilityDisabledError( "The API call %s.%s() is temporarily unavailable." % (self.package, self.call)) elif self._result_dict['error'] == FEATURE_DISABLED: self._exception = apiproxy_errors.FeatureNotEnabledError( self._result_dict['error_detail']) elif self._result_dict['error'] in _ExceptionsMap: exception_entry = _ExceptionsMap[self._result_dict['error']] self._exception = exception_entry[0](exception_entry[1] % (self.package, self.call)) else: try: self.response.ParseFromString( self._result_dict['result_string']) except Exception as e: self._exception = e self._Callback()
def _Dynamic_RunQuery(self, query, query_result, request_id=None): """Send a query request to the datastore server. """ if query.has_transaction(): if not query.has_ancestor(): raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Only ancestor queries are allowed inside transactions.') (filters, orders) = datastore_index.Normalize(query.filter_list(), query.order_list(), []) old_datastore_stub_util.FillUsersInQuery(filters) if not query.has_app(): query.set_app(self.project_id) self.__ValidateAppId(query.app()) self._RemoteSend(query, query_result, "RunQuery", request_id) results = query_result.result_list() for result in results: old_datastore_stub_util.PrepareSpecialPropertiesForLoad(result) last_cursor = None if query_result.has_compiled_cursor(): last_cursor = query_result.compiled_cursor() if query_result.more_results(): new_cursor = InternalCursor(query, last_cursor, len(results)) cursor_id = self.__getCursorID() cursor = query_result.mutable_cursor() cursor.set_app(self.project_id) cursor.set_cursor(cursor_id) self.__queries[cursor_id] = new_cursor if query.compile(): compiled_query = query_result.mutable_compiled_query() compiled_query.set_keys_only(query.keys_only()) compiled_query.mutable_primaryscan().set_index_name(query.Encode())
def _FindIndexToUse(query, indexes): """ Matches the query with one of the composite indexes. Args: query: A datastore_pb.Query. indexes: A list of entity_pb.CompsiteIndex. Returns: The composite index of the list for which the composite index matches the query. Returns None if there is no match. """ if not query.has_kind(): return None index_list = __IndexListForQuery(query) if index_list == []: return None index_match = index_list[0] for index in indexes: if index_match.Equals(index.definition()): return index raise apiproxy_errors.ApplicationError(datastore_pb.Error.NEED_INDEX, 'Query requires an index')
def _Dynamic_AllocateIds(self, allocate_ids_request, allocate_ids_response): model_key = allocate_ids_request.model_key() self.__ValidateAppId(model_key.app()) if allocate_ids_request.has_size() and allocate_ids_request.has_max(): raise apiproxy_errors.ApplicationError( datastore_pb.Error.BAD_REQUEST, 'Both size and max cannot be set.') try: self.__id_lock.acquire() start = self.__next_id if allocate_ids_request.has_size(): self.__next_id += allocate_ids_request.size() elif allocate_ids_request.has_max(): self.__next_id = max(self.__next_id, allocate_ids_request.max() + 1) end = self.__next_id - 1 finally: self.__id_lock.release() allocate_ids_response.set_start(start) allocate_ids_response.set_end(end)
def StoreBlob(self, blob_key, blob_stream): """Store blob stream to disk. Args: blob_key: Blob key of blob to store. blob_stream: Stream or stream-like object that will generate blob content. """ blob_key = self._BlobKey(blob_key) block_count = 0 try: while True: block = blob_stream.read(blobstore.MAX_BLOB_FETCH_SIZE) if not block: break entity = datastore.Entity(_BLOB_CHUNK_KIND_, name=str(blob_key) + "__" + str(block_count), namespace='') entity.update({'block': datastore_types.Blob(block)}) datastore.Put(entity) block_count += 1 except datastore_errors.EntityNotFoundError, err: raise apiproxy_errors.ApplicationError( blobstore_service_pb.BlobstoreServiceError.BLOB_NOT_FOUND)
class CloudDatastoreV1Stub(apiproxy_stub.APIProxyStub): """Implementation of the Cloud Datastore V1 API. This proxies requests to the v3 service.""" THREADSAFE = False def __init__(self, app_id): assert _CLOUD_DATASTORE_ENABLED, ( 'Cannot initialize the Cloud Datastore' ' stub without installing the Cloud' ' Datastore client libraries.') apiproxy_stub.APIProxyStub.__init__(self, SERVICE_NAME) self.__app_id = app_id self._id_resolver = _StubIdResolver([app_id]) self.__entity_converter = datastore_pbs.get_entity_converter( self._id_resolver) self.__service_converter = datastore_stub_util.get_service_converter( self._id_resolver) self.__service_validator = cloud_datastore_validator.get_service_validator( self._id_resolver) def _Dynamic_BeginTransaction(self, req, resp): try: self.__service_validator.validate_begin_transaction_req(req) v3_req = self.__service_converter.v1_to_v3_begin_transaction_req( self.__app_id, req) except datastore_pbs.InvalidConversionError, e: raise apiproxy_errors.ApplicationError(datastore_pb.Error.BAD_REQUEST, str(e)) except cloud_datastore_validator.ValidationError, e: raise apiproxy_errors.ApplicationError(datastore_pb.Error.BAD_REQUEST, str(e))
def _Dynamic_RunQuery(self, req, resp): try: self.__normalize_v4_run_query_request(req) self.__service_validator.validate_run_query_req(req) v3_stub = apiproxy_stub_map.apiproxy.GetStub(V3_SERVICE_NAME) new_req, filter_predicate = self._SplitGeospatialFilters(req) if (issubclass(v3_stub.__class__, datastore_stub_util.BaseDatastore) and filter_predicate is not None): v3_req = self.__service_converter.v4_run_query_req_to_v3_query(new_req) v3_resp = datastore_pb.QueryResult() v3_stub._Dynamic_RunQuery(v3_req, v3_resp, filter_predicate) else: v3_req = self.__service_converter.v4_run_query_req_to_v3_query(req) v3_resp = datastore_pb.QueryResult() self.__make_v3_call('RunQuery', v3_req, v3_resp) except datastore_pbs.InvalidConversionError, e: raise apiproxy_errors.ApplicationError( datastore_v4_pb.Error.BAD_REQUEST, str(e))