def receive_data_chunk(self, raw_data, start): ''' Receives a "chunk" of data from the file upload. ``raw_data is`` a byte string containing the uploaded data. ``start`` is the position in the file where this raw_data chunk begins. The data you return will get fed into the subsequent upload handlers' receive_data_chunk methods. In this way, one handler can be a "filter" for other handlers. Return None from receive_data_chunk to sort-circuit remaining upload handlers from getting this chunk.. This is useful if you're storing the uploaded data yourself and don't want future handlers to store a copy of the data. If you raise a StopUpload or a SkipFile exception, the upload will abort or the file will be completely skipped. ''' self.progress += self.chunk_size if self.cach_key: try: percent = min(100, int(100 * self.progress / self.length)) cache.incr(self.cach_key, percent) if settings.DEBUG: logging.debug('uploaded proceeded for %s and filename %s @ %s' % (self.cach_key, self.name, ctime.ctime())) except ValueError, e: logging.error('Tried to increment a non-existing cache-key;\ %s %s' % (self.cach_key, e))
def handle_raw_input(self, input_data, META, content_length, boundary, encoding): ''' Allows the handler to completely override the parsing of the raw HTTP input. ``input_data`` is a file-like object that supports read()-ing. ``META`` is the same object as request.META. ``content_length`` is the length of the data in input_data. ``boundary`` is the MIME boundary for this request. ``encoding`` is the encoding of the request. ''' if 'X-Progress-Id' in self.request.GET and content_length > 0: self.progress_id = self.request.GET['X-Progress-Id'] self.length = content_length if settings.DEBUG: logging.debug('X-Progress-Id was %s and content_length %s @ %s' % (self.progress_id, self.length, ctime.ctime())) elif settings.DEBUG: logging.debug('Upload not containing progress_id') return None
def new_file (self, field_name, file_name, content_type, content_length, charset): ''' Callback signaling that a new file upload is starting. This is called before any data has been fed to any upload handlers. ``field_name`` is a string name of the file <input> field. ``file_name`` is the unicode filename that was provided by the browser. ``content_type`` is the MIME type provided by the browser -- E.g. 'image/jpeg'. ``content_length`` is the length of the image given by the browser. Sometimes this won't be provided and will be None., None otherwise. ``charset`` is the character set (i.e. utf8) given by the browser. Like content_length, this sometimes wonn't be provided. ''' if self.progress_id: self.cach_key = '%s_%s_%s' % (self.request.META['REMOTE_ADDR'], self.progress_id, file_name) cache.set(self.cach_key, 0, 360) self.name = file_name if settings.DEBUG: logging.debug('Upload started key %s and filename %s @ %s' % (self.cach_key, self.name, ctime.ctime()))
def upload_complete(self): ''' Callback signaling that the entire upload (all files) has completed. ''' if settings.DEBUG: logging.debug('Upload for %s and %s was completed @ %s' % (self.name, self.cach_key, ctime.ctime()))