static rc_t SaveToFile( struct KFile * f, const VNamelist * nl, const char * delim )
{
uint32_t count;
rc_t rc = VNameListCount ( nl, &count );
if ( rc == 0 && count > 0 )
{
uint32_t idx;
uint64_t pos = 0;
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const char * s;
rc = VNameListGet ( nl, idx, &s );
if ( rc == 0 && s != NULL )
{
size_t num_writ;
rc = KFileWriteAll ( f, pos, s, string_size ( s ), &num_writ );
if ( rc == 0 )
{
pos += num_writ;
rc = KFileWriteAll ( f, pos, delim, string_size ( delim ), &num_writ );
if ( rc == 0 )
pos += num_writ;
}
}
}
if ( rc == 0 )
rc = KFileSetSize ( f, pos );
}
return rc;
}
static rc_t CC out_redir_callback( void * self, const char * buffer, size_t bufsize, size_t * num_writ )
{
out_redir * redir = ( out_redir * )self;
rc_t rc = KFileWriteAll( redir->kfile, redir->pos, buffer, bufsize, num_writ );
if ( rc == 0 )
redir->pos += *num_writ;
return rc;
}
static rc_t write_to_file( struct rna_splice_log * sl, const uint8_t * src, size_t len )
{
size_t num_writ;
rc_t rc = KFileWriteAll( sl->log_file, sl->log_file_pos, src, len, &num_writ );
if ( rc == 0 )
sl->log_file_pos += num_writ;
return rc;
}
rc_t write_packed_to_lookup_writer( struct lookup_writer * writer,
uint64_t key,
const String * bases_as_packed_4na )
{
size_t num_writ;
/* first write the key ( combination of seq-id and read-id ) */
rc_t rc = KFileWriteAll( writer -> f, writer -> pos, &key, sizeof key, &num_writ );
if ( rc != 0 )
{
ErrMsg( "KFileWriteAll( key ) -> %R", rc );
}
else if ( num_writ != sizeof key )
{
rc = RC( rcVDB, rcNoTarg, rcWriting, rcFormat, rcInvalid );
ErrMsg( "KFileWriteAll( key ) -> %R", rc );
}
else
{
uint64_t start_pos = writer -> pos; /* store the pos to be written later to the index... */
writer -> pos += num_writ;
/* now write the packed 4na ( length + packed data ) */
rc = KFileWriteAll( writer -> f,
writer -> pos,
bases_as_packed_4na -> addr,
bases_as_packed_4na -> size,
&num_writ );
if ( rc != 0 )
ErrMsg( "KFileWriteAll( bases ) -> %R", rc );
else if ( num_writ != bases_as_packed_4na -> size )
{
rc = RC( rcVDB, rcNoTarg, rcWriting, rcFormat, rcInvalid );
ErrMsg( "KFileWriteAll( bases ) -> %R", rc );
}
else
{
if ( writer -> idx != NULL )
rc = write_key( writer -> idx, key, start_pos );
writer->pos += num_writ;
}
}
return rc;
}
/*
* Copy a file from a const KFile * to a KFile * with the paths for the two
* for logging purposes
*
* return rc_t = 0 for success
* return rc_t != 0 for failure
*/
rc_t CopyFile (const KFile * src, KFile * dst, const char * source, const char * dest)
{
rc_t rc;
uint8_t buff [256 * 1024];
size_t num_read;
size_t num_writ;
uint64_t pos;
for (pos = 0; ; pos += num_read)
{
rc = Quitting ();
if (rc)
{
LOGMSG (klogFatal, "Received quit");
break;
}
rc = KFileReadAll (src, pos, buff, sizeof (buff), &num_read);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to read from file $(F) at $(P)",
"F=%s,P=%lu", source, pos));
break;
}
if (num_read == 0)
break;
rc = KFileWriteAll (dst, pos, buff, num_read, &num_writ);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to write to file $(F) at $(P)",
"F=%s,P=%lu", dest, pos));
break;
}
if (num_writ != num_read)
{
rc = RC (rcExe, rcFile, rcWriting, rcFile, rcInsufficient);
PLOGERR (klogErr,
(klogErr, rc,
"Failed to write all to file $(F) at $(P)",
"F=%s,P=%lu", dest, pos));
break;
}
}
return rc;
}
rc_t CC
TCopyFile ( struct KFile * file_dst, struct KFile * file_src )
{
rc_t rc = 0;
uint64_t size_src;
rc = KFileSize ( file_src, &size_src );
if (rc != 0)
{
return rc;
}
if (size_src == 0)
{
// do nothing
return rc;
}
const size_t buffer_size = 32*1024;
uint8_t buffer[buffer_size];
uint64_t num_copied_total = 0;
size_t num_read, num_written;
while (num_copied_total < size_src)
{
size_t to_copy = size_src - num_copied_total;
if (to_copy > buffer_size)
{
to_copy = buffer_size;
}
rc = KFileReadAll ( file_src, num_copied_total, buffer, to_copy, &num_read );
if (rc != 0)
{
break;
}
assert(num_read == to_copy);
rc = KFileWriteAll ( file_dst, num_copied_total, buffer, to_copy, &num_written );
if (rc != 0)
{
break;
}
assert(num_written == to_copy);
num_copied_total += num_written;
}
return rc;
}
rc_t CC
TFillFile ( struct KFile * file, const uint8_t* filler, size_t filler_size, uint64_t content_size )
{
rc_t rc = 0;
if (content_size == 0)
{
// do nothing
return rc;
}
const size_t buffer_size = 32*1024;
uint8_t buffer[buffer_size];
size_t filler_sizes_in_buffer = buffer_size / filler_size;
assert(buffer_size % filler_size == 0);
assert(buffer_size / filler_size > 0);
for (size_t i = 0; i < filler_sizes_in_buffer; ++i)
{
memmove(buffer + i*filler_size, filler, filler_size);
}
uint64_t num_written_total = 0;
size_t num_written;
while (num_written_total < content_size)
{
size_t to_write = content_size - num_written_total;
if (to_write > buffer_size)
{
to_write = buffer_size;
}
rc = KFileWriteAll ( file, num_written_total, buffer, to_write, &num_written );
if (rc != 0)
{
break;
}
assert(num_written == to_write);
num_written_total += num_written;
}
return rc;
}
/* RunWrite
* runs write loop on background thread
*/
static
rc_t CC KQueueFileRunWrite ( const KThread *t, void *data )
{
KQueueFile *self = data;
rc_t rc;
do
{
size_t num_writ;
KQueueFileBuffer *b;
/* timeout is in mS */
timeout_t tm;
TimeoutInit ( & tm, self->timeout_ms );
/* pop buffer */
rc = KQueuePop ( self -> q, ( void** ) & b, & tm );
if ( rc != 0 )
{
/* see if the fg thread is done */
if ( GetRCState ( rc ) == rcDone && GetRCObject ( rc ) == ( enum RCObject )rcData )
{
rc = 0;
}
else if ( GetRCObject(rc) == ( enum RCObject )rcTimeout && GetRCState(rc) == rcExhausted )
{
rc = 0;
continue;
}
break;
}
/* queue won't accept NULL object references */
assert ( b != NULL );
/* look at buffer for end of input */
if ( b -> rc != 0 || b -> bytes == 0 )
{
free ( b );
break;
}
/* write to file */
rc = KFileWriteAll ( self -> f, b -> pos, b -> data, b -> bytes, & num_writ );
assert ( num_writ == b -> bytes || rc != 0 );
/* TBD - need a better way to deal with this */
if ( rc != 0 )
{
PLOGERR ( klogSys, ( klogSys, rc, "$(func): wrote $(num_writ) of $(bytes) bytes to file",
"func=%s,num_writ=%zu,bytes=%zu", __func__, num_writ, b -> bytes ) );
}
/* done with buffer */
free ( b );
}
while ( rc == 0 );
/* going to exit thread */
KQueueSeal ( self -> q );
return rc;
}
static
rc_t copy_file (const char * src, const char * dst, const KFile * fin, KFile *fout)
{
rc_t rc;
uint8_t buff [64 * 1024];
size_t num_read;
uint64_t inpos;
uint64_t outpos;
assert (src);
assert (dst);
assert (fin);
assert (fout);
inpos = 0;
outpos = 0;
#if 1
for (inpos = 0; ; inpos += num_read)
{
rc = Quitting ();
if (rc)
{
LOGMSG (klogFatal, "Received quit");
break;
}
else
{
rc = KFileReadAll (fin, inpos, buff, sizeof (buff), &num_read);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to read from file $(F) at $(P)",
"F=%s,P=%lu", src, inpos));
break;
}
else if (num_read)
{
size_t num_writ;
rc = KFileWriteAll (fout, inpos, buff, num_read, &num_writ);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to write to file $(F) at $(P)",
"F=%s,P=%lu", dst, outpos));
break;
}
else if (num_writ != num_read)
{
rc = RC (rcExe, rcFile, rcWriting, rcFile, rcInsufficient);
PLOGERR (klogErr,
(klogErr, rc,
"Failed to write all to file $(F) at $(P)",
"F=%s,P=%lu", dst, outpos));
break;
}
}
else
break;
}
}
#else
do
{
rc = Quitting ();
if (rc)
{
LOGMSG (klogFatal, "Received quit");
break;
}
rc = KFileRead (fin, inpos, buff, sizeof (buff), &num_read);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to read from file $(F) at $(P)",
"F=%s,P=%lu", src, inpos));
break;
}
else if (num_read > 0)
{
size_t to_write;
inpos += (uint64_t)num_read;
STSMSG (2, ("Read %zu bytes to %lu", num_read, inpos));
to_write = num_read;
while (to_write > 0)
{
size_t num_writ;
rc = KFileWrite (fout, outpos, buff, num_read, &num_writ);
if (rc)
{
PLOGERR (klogErr,
(klogErr, rc,
"Failed to write to file $(F) at $(P)",
"F=%s,P=%lu", dst, outpos));
break;
}
outpos += num_writ;
to_write -= num_writ;
}
}
if (rc)
break;
} while (num_read != 0);
#endif
return rc;
}
