def _dump_file(self, file, submission_gus, file_gus):

        result = {}
        result['file_gus'] = file_gus
        result['name'] = file['filename']
        result['type'] = file['content_type']
        result['size'] = len(file['body'])

        # XXX verify this token what's is it
        result['token'] = submission_gus

        if not os.path.isdir(config.advanced.submissions_dir):
            print "%s does not exist. Creating it." % config.advanced.submissions_dir
            os.mkdir(config.advanced.submissions_dir)

        the_submission_dir = config.advanced.submissions_dir

        # this happen only at the first execution
        if not os.path.isdir(the_submission_dir):
            os.mkdir(the_submission_dir)

        filelocation = os.path.join(the_submission_dir, file_gus)

        print "Saving file \"%s\" of %d byte [%s] type, to %s" % \
              (result['name'], result['size'], result['type'], filelocation )

        with open(filelocation, 'w+') as fd:
            fdesc.setNonBlocking(fd.fileno())
            fdesc.writeToFD(fd.fileno(), file['body'])

        return result

 def updateReport(self, report_filename, data):
     try:
         with open(report_filename, 'a+') as fd:
             fdesc.setNonBlocking(fd.fileno())
             fdesc.writeToFD(fd.fileno(), data)
     except IOError as e:
         e.OONIBError(404, "Report not found")

    def contentReceived(self, chunk):
        #log.msg('Content %s bytes received:', len(chunk))
        fdesc.writeToFD(self.file, chunk)
        
        if self.beginning == 2:
            log.msg('File should be closed here')

        return self.headerReceived, HEADER_LENGTH

    def process_image(self, payload, **kwargs):
        """ Writes images to the cache """

        filecache_loc = settings.CACHE_LOCATION
        webcache_loc = settings.WEB_CACHE_LOCATION
        cache_filename_parts = payload['image_path'].split('.')
        filefront = cache_filename_parts[0]
        fileend = cache_filename_parts[1]
        cache_filename = ''

        original_filename = '%s.%s' % (
            filefront,
            fileend,
        )
        cache_filename = '%s_%sx%s_%s.%s' % (
            filefront,
            payload['width'],
            payload['height'],
            payload['mode'],
            fileend,
        )

        file_cache = os.path.join(filecache_loc, cache_filename)
        web_cache = os.path.join(webcache_loc, cache_filename)

        # Files are normally binned in subdir, create them in cache
        dirs = os.path.dirname(file_cache)
        try:
            os.makedirs(dirs)
        except os.error:
            pass

        if 'skip_resize' in payload.keys():
            # Just save/servwe original image as there is no resized image
            file_cache = os.path.join(filecache_loc, original_filename)
            web_cache = os.path.join(webcache_loc, original_filename)

        # Save image to be served
        fd = open(file_cache, 'w')
        fdesc.setNonBlocking(fd.fileno())
        yield fdesc.writeToFD(fd.fileno(), payload['image'])
        fd.close()

        if 'skip_resize' not in payload.keys():
            # If image to be served has beenr esized, also cache full size image
            file_cache = os.path.join(filecache_loc, original_filename)
            fd = open(file_cache, 'w')
            fdesc.setNonBlocking(fd.fileno())
            yield fdesc.writeToFD(fd.fileno(), payload['original_image'])
            fd.close()

        if settings.DEBUG:
            log.msg(
                "[%s] Cached image location: %s" % (datetime.now().isoformat(), file_cache),
                logLevel=logging.DEBUG
            )

        defer.returnValue(web_cache)

 def writeSomeData(self, data):
     self._write_buf += data
     while True:
         length = self.get_frame(self._write_buf)
         if length == -1:
             break
         frame = self._write_buf[:length]
         self._write_buf = self._write_buf[length:]
         fdesc.writeToFD(self.tunfd, frame)

    def do_verbose_log(self, content):
        """
        Record in the verbose log the content as defined by Cyclone wrappers.
        """
        content = sanitize_str(content)

        try:
            with open(GLSetting.httplogfile, "a+") as fd:
                fdesc.writeToFD(fd.fileno(), content + "\n")
        except Exception as excep:
            log.err("Unable to open %s: %s" % (GLSetting.httplogfile, excep))

    def do_verbose_log(self, content):
        """
        Record in the verbose log the content as defined by Cyclone wrappers.
        """
        content = log_remove_escapes(content)
        content = log_encode_html(content)

        try:
            with open(GLSetting.httplogfile, 'a+') as fd:
                fdesc.writeToFD(fd.fileno(), content + "\n")
        except Exception as excep:
            log.err("Unable to open %s: %s" % (GLSetting.httplogfile, excep))

    def receiveContent(self, chunk):

        start = time.time()
        log.msg('Content %s bytes received:', len(chunk))
        fdesc.writeToFD(self.file, chunk)

        if self.beginning == 2:
            log.msg('Last chunk go to processing')
            for websock in self.factory.browsers:
                websock.write(self.path.split('/')[-1].encode('utf-8')) 
            self.startProcessing()
        stop = time.time()
        return self.receiveHeader, HEADER_LENGTH

    def do_verbose_log(self, content):
        """
        Record in the verbose log the content as defined by Cyclone wrappers.

        This option is only available in devel mode and intentionally does not filter
        any input/output; It should be used only for debug purposes.
        """

        try:
            with open(GLSettings.httplogfile, "a+") as fd:
                fdesc.writeToFD(fd.fileno(), content + "\n")
        except Exception as excep:
            log.err("Unable to open %s: %s" % (GLSettings.httplogfile, excep))

    def updateReport(self, report_id, parsed_request):

        log.debug("Got this request %s" % parsed_request)
        report_filename = os.path.join(config.main.report_dir,
                report_id)
        
        config.reports[report_id].refresh()

        try:
            with open(report_filename, 'a+') as fd:
                fdesc.setNonBlocking(fd.fileno())
                fdesc.writeToFD(fd.fileno(), parsed_request['content'])
        except IOError as exc:
            e.OONIBError(404, "Report not found")
        self.write({})

 def writeSomeData(self, data):
     """
     Write some data to the open process.
     """
     rv = fdesc.writeToFD(self.fd, data)
     if rv == len(data) and self.enableReadHack:
         self.startReading()
     return rv

 def writeSomeData(self, data):
     """
     Write data to the FIFO. Should not be used by protocols -
     use L{write<twisted.internet.abstract.FileDescriptor.write>} instead.
     """
     return writeToFD(self.fileno(), data)

 def writeToReport(self, report_filename, data):
     with open(report_filename, 'w+') as fd:
         fdesc.setNonBlocking(fd.fileno())
         fdesc.writeToFD(fd.fileno(), data)

 def writeToFile(self, data):
     if self.outputFile is not None:
         # Write to nonblocking output file descriptor
         fdesc.writeToFD(self.outputFile.fileno(), data)

 def writeSomeData(self, data):
     """
     Write some data to the serial device.
     """
     return fdesc.writeToFD(self.fileno(), data)

 def writeSomeData(self, data):
     rw = fdesc.writeToFD(self.fileno(), data)
     if rw == len(data) and self.backToReading:
         self.backToReading = False
         self.startReading()
     return rw

 def write(self, data):
     fdesc.writeToFD(self._port.fileno(), data)

 def writeSomeData(self, data):
     return fdesc.writeToFD(self.fp.fileno(), data)

 def writeData(self,data):
     """docstring for writeData"""
     fdesc.writeToFD(self.outfile,data)

 def write(self, d):
     """
     Write data to the pipe.
     """
     return fdesc.writeToFD(self.w, d)