/**
* @brief Clean up load status information
*
* @param self [in/out] Load status information
* @return void
*/
static WriterResult
DirectWriterClose(DirectWriter *self, bool onError)
{
WriterResult ret = { 0 };
Assert(self != NULL);
/* Flush unflushed block buffer and close the heap file. */
if (!onError)
flush_pages(self);
close_data_file(self);
UnlinkLSF(self);
if (!onError)
{
SpoolerClose(&self->spooler);
ret.num_dup_new = self->spooler.dup_new;
ret.num_dup_old = self->spooler.dup_old;
if (self->base.rel)
heap_close(self->base.rel, AccessExclusiveLock);
if (self->blocks)
pfree(self->blocks);
pfree(self);
}
return ret;
}
static int save_points(int end_track) {
int error = 0;
int i;
roadmap_log(ROADMAP_INFO, "Saving points, end_track:%d", end_track);
if (track_file == NULL) return -1;
for (i=0; i<points_count; i++) {
RoadMapGpsPosition *pos = &TrackPoints[i].gps_point;
if (fwrite(&pos->longitude, sizeof(pos->longitude), 1, track_file) != 1) {
error = 1;
}
if (fwrite(&pos->latitude, sizeof(pos->latitude), 1, track_file) != 1) {
error = 1;
}
if (fwrite(&TrackPoints[i].time, sizeof(TrackPoints[i].time), 1,
track_file) != 1) {
error = 1;
}
fflush(track_file);
if (error) {
roadmap_log(ROADMAP_ERROR, "Error writing GPS data.");
roadmap_messagebox("Error", "Error writing GPS data.");
close_data_file();
return -1;
}
}
if (end_track) {
int null[3] = {0, 0, 0};
if (fwrite(null, sizeof(null), 1, track_file) != 1) {
roadmap_messagebox("Error", "Error writing GPS data.");
close_data_file();
return -1;
}
}
points_count = 0;
return 0;
}
void open_data_file() {
if (_g_data_fd > 0)
close_data_file();
_g_data_fd = open(_g_data_filename.c_str(), O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (_g_data_fd < 0) {
fprintf(_g_error, "ERROR: failed to create file \"%s\"\n", _g_data_filename.c_str());
exit(6);
}
else {
fprintf(_g_info, "Data will be written out to `%s'\n", _g_data_filename.c_str());
}
}
static void track_rec_upload (void) {
char *file_name;
if (RecordGpsData) {
track_end ();
RecordGpsData = 0;
close_data_file();
}
file_name = roadmap_path_join(roadmap_config_get(&RoadMapConfigMapPath),
"track_data.bin");
NOPH_try(exception_handler, NULL) {
editor_upload_file (file_name, 1);
} NOPH_catch();
uint8_t test_builddata(uint8_t ev, uint16_t lparam, void* rparam)
{
printf("test_builddata()\n");
uint8_t meta[] = {DATA_COL_STEP, DATA_COL_DIST, DATA_COL_HR};
uint32_t data[] = {1234, 5678, 9012};
create_data_file(12, 11, 28);
write_data_line(0x00, 1, 1, meta, data, 3);
write_data_line(0x00, 1, 2, meta, data, 3);
write_data_line(0x01, 1, 3, meta, data, 3);
write_data_line(0x02, 1, 4, meta, data, 3);
write_data_line(0x03, 1, 5, meta, data, 3);
close_data_file();
return 0;
}
Eyelink::~Eyelink(){
boost::mutex::scoped_lock lock(EyelinkDriverLock);
if (Eyelink_Initialized) {
if (!stopped) {
mwarning(M_IODEVICE_MESSAGE_DOMAIN,"Eyelink is still running !");
//eyelink stop recording
if(eyelink_is_connected()) { stop_recording(); }
}
if (schedule_node) {
schedule_node->cancel();
schedule_node.reset();
}
if(eyelink_is_connected()) {
// Places EyeLink tracker in off-line (idle) mode
set_offline_mode();
// close any open data files
if ( close_data_file() == 0 ) {
mprintf(M_IODEVICE_MESSAGE_DOMAIN,"Eyelink closed data file %s.",data_file_name);
}
if (eyelink_close(1)) // disconnect from tracker
{
merror(M_IODEVICE_MESSAGE_DOMAIN, "Could not close Eyelink connection");
}
//close_eyelink_system();
mprintf(M_IODEVICE_MESSAGE_DOMAIN, "Eyelink %d System Version %s disconnected.",tracker_version,version_info);
}
else {
mwarning(M_IODEVICE_MESSAGE_DOMAIN,"Error, Eyelink Shutdown failed");
}
Eyelink_Initialized = false;
}
}
static void
check_file (const char* file_name)
{
FILE *fp;
int tmp;
int base;
int inex_re;
int inex_im;
mpc_t expected, got;
mpc_rnd_t rnd = MPC_RNDNN;
int inex = 0, expected_inex;
size_t expected_size, size;
known_signs_t ks = {1, 1};
fp = open_data_file (file_name);
mpc_init2 (expected, 53);
mpc_init2 (got, 53);
/* read data file */
line_number = 1;
nextchar = getc (fp);
skip_whitespace_comments (fp);
while (nextchar != EOF)
{
/* 1. read a line of data: expected result, base, rounding mode */
read_ternary (fp, &inex_re);
read_ternary (fp, &inex_im);
read_mpc (fp, expected, &ks);
if (inex_re == TERNARY_ERROR || inex_im == TERNARY_ERROR)
expected_inex = -1;
else
expected_inex = MPC_INEX (inex_re, inex_im);
read_int (fp, &tmp, "size");
expected_size = (size_t)tmp;
read_int (fp, &base, "base");
read_mpc_rounding_mode (fp, &rnd);
/* 2. read string at the same precision as the expected result */
while (nextchar != '"')
nextchar = getc (fp);
mpfr_set_prec (MPC_RE (got), MPC_PREC_RE (expected));
mpfr_set_prec (MPC_IM (got), MPC_PREC_IM (expected));
inex = mpc_inp_str (got, fp, &size, base, rnd);
/* 3. compare this result with the expected one */
if (inex != expected_inex || !same_mpc_value (got, expected, ks)
|| size != expected_size)
{
printf ("mpc_inp_str failed (line %lu) with rounding mode %s\n",
line_number, rnd_mode[rnd]);
if (inex != expected_inex)
printf(" got inexact value: %d\nexpected inexact value: %d\n",
inex, expected_inex);
if (size != expected_size)
printf (" got size: %lu\nexpected size: %lu\n ",
(unsigned long int) size, (unsigned long int) expected_size);
printf (" ");
OUT (got);
OUT (expected);
exit (1);
}
while ((nextchar = getc (fp)) != '"');
nextchar = getc (fp);
skip_whitespace_comments (fp);
}
mpc_clear (expected);
mpc_clear (got);
close_data_file (fp);
}
void close_data_file_to_prepare_for_next_spill() {
close_data_file();
}
/**
* @brief Write block buffer contents. Number of block buffer to be
* written is specified by num argument.
*
* Flow:
* <ol>
* <li>If no more space is available in the data file, switch to a new one.</li>
* <li>Compute block number which can be written to the current file.</li>
* <li>Save the last block number in the load status file.</li>
* <li>Write to the current file.</li>
* <li>If there are other data, write them too.</li>
* </ol>
*
* @param loader [in] Direct Writer.
* @return File descriptor for the current data file.
*/
static void
flush_pages(DirectWriter *loader)
{
int i;
int num;
LoadStatus *ls = &loader->ls;
num = loader->curblk;
if (!PageIsEmpty(GetCurrentPage(loader)))
num += 1;
if (num <= 0)
return; /* no work */
/*
* Add WAL entry (only the first page) to ensure the current xid will
* be recorded in xlog. We must flush some xlog records with XLogFlush()
* before write any data blocks to follow the WAL protocol.
*
* If postgres process, such as loader and COPY, is killed by "kill -9",
* database will be rewound to the last checkpoint and recovery will
* be performed using WAL.
*
* After the recovery, if there are xid's which have not been recorded
* to WAL, such xid's will be reused.
*
* However, in the loader and COPY, data file is actually updated and
* xid must not be reused.
*
* WAL entry with such xid can be added using XLogInsert(). However,
* such entries are not really written to the disk immediately.
* WAL entries are flushed to the disk by XLogFlush(), typically
* when a transaction is commited. COPY prevents xid reuse by
* this method.
*/
#if PG_VERSION_NUM >= 90100
if (ls->ls.create_cnt == 0 && !RELATION_IS_LOCAL(loader->base.rel)
&& !(loader->base.rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED) )
{
XLogRecPtr recptr;
recptr = log_newpage(&ls->ls.rnode, MAIN_FORKNUM,
ls->ls.exist_cnt, loader->blocks);
XLogFlush(recptr);
}
#else
if (ls->ls.create_cnt == 0 && !RELATION_IS_LOCAL(loader->base.rel) )
{
XLogRecPtr recptr;
recptr = log_newpage(&ls->ls.rnode, MAIN_FORKNUM,
ls->ls.exist_cnt, loader->blocks);
XLogFlush(recptr);
}
#endif
/*
* Write blocks. We might need to write multiple files on boundary of
* relation segments.
*/
for (i = 0; i < num;)
{
char *buffer;
int total;
int written;
int flush_num;
BlockNumber relblks = LS_TOTAL_CNT(ls);
/* Switch to the next file if the current file has been filled up. */
if (relblks % RELSEG_SIZE == 0)
close_data_file(loader);
if (loader->datafd == -1)
loader->datafd = open_data_file(ls->ls.rnode,
RELATION_IS_LOCAL(loader->base.rel),
relblks);
/* Number of blocks to be added to the current file. */
flush_num = Min(num - i, RELSEG_SIZE - relblks % RELSEG_SIZE);
Assert(flush_num > 0);
/* Write the last block number to the load status file. */
UpdateLSF(loader, flush_num);
#if PG_VERSION_NUM >= 90300
/* If we need a checksum, add it */
if (DataChecksumsEnabled()){
int j = 0;
Page contained_page;
for ( j=0; j<flush_num; j++ ) {
contained_page = GetTargetPage(loader,j);
((PageHeader) contained_page)->pd_checksum =
pg_checksum_page((char *) contained_page, LS_TOTAL_CNT(ls) - 1 - j);
}
}
#endif
/*
* Flush flush_num data block to the current file.
* Then the current file size becomes RELSEG_SIZE self->blocks.
*/
buffer = loader->blocks + BLCKSZ * i;
total = BLCKSZ * flush_num;
written = 0;
while (total > 0)
{
int len = write(loader->datafd, buffer + written, total);
if (len == -1)
{
/* fatal error, do not want to write blocks anymore */
ereport(ERROR, (errcode_for_file_access(),
errmsg("could not write to data file: %m")));
}
written += len;
total -= len;
}
i += flush_num;
}
/*
* NOTICE: Be sure reset curblk to 0 and reinitialize recycled page
* if you will continue to use blocks.
*/
}
