char *
zfile_digest (zfile_t *self)
{
if (!self->digest) {
if (zfile_input (self) == -1)
return NULL; // Problem reading file
// Now calculate hash for file data, chunk by chunk
size_t blocksz = 65535;
off_t offset = 0;
self->digest = zdigest_new ();
zchunk_t *chunk = zfile_read (self, blocksz, offset);
while (zchunk_size (chunk)) {
zdigest_update (self->digest,
zchunk_data (chunk), zchunk_size (chunk));
zchunk_destroy (&chunk);
offset += blocksz;
chunk = zfile_read (self, blocksz, offset);
}
zchunk_destroy (&chunk);
zfile_close (self);
}
return zdigest_string (self->digest);
}
void
zfile_remove (zfile_t *self)
{
assert (self);
zfile_close (self);
zsys_file_delete (self->fullname);
}
int
zfile_output (zfile_t *self)
{
assert (self);
// Wipe symbolic link if that's what the file was
if (self->link) {
free (self->link);
self->link = NULL;
}
// Create file path if it doesn't exist
char *file_path = strdup (self->fullname);
char *last_slash = strrchr (file_path, '/');
if (last_slash)
*last_slash = 0;
if (zsys_dir_create (file_path))
return -1;
free (file_path);
// Create file if it doesn't exist
if (self->handle)
zfile_close (self);
self->handle = fopen (self->fullname, "r+b");
if (!self->handle) {
self->handle = fopen (self->fullname, "w+b");
if (!self->handle)
self->handle = fopen (self->fullname, "w+b");
}
return self->handle? 0: -1;
}
void
zfile_remove (zfile_t *self)
{
assert (self);
// Restore ".ln" in file name if this was a symbolic link
if (self->link)
self->fullname [strlen (self->fullname)] = '.';
zfile_close (self);
zsys_file_delete (self->fullname);
}
void
pass_chunk (zchunk_t *chunk, char *path, uint64_t sequence, uint64_t offset)
{
// save chunk
printf ("[ST] PASS_CHUNK %s, %"PRId64", %"PRId64", %"PRId64"\n", path, sequence, zchunk_size (chunk), offset);
zfile_t *file = zfile_new("./syncfolder", path);
zfile_output(file);
zfile_write(file, chunk, offset);
zfile_close(file);
zfile_destroy(&file);
}
int
zfile_test (bool verbose)
{
printf (" * zfile: ");
// @selftest
zfile_t *file = zfile_new (".", "bilbo");
assert (streq (zfile_filename (file, "."), "bilbo"));
assert (zfile_is_readable (file) == false);
zfile_destroy (&file);
// Create a test file in some random subdirectory
file = zfile_new ("./this/is/a/test", "bilbo");
int rc = zfile_output (file);
assert (rc == 0);
zchunk_t *chunk = zchunk_new (NULL, 100);
zchunk_fill (chunk, 0, 100);
// Write 100 bytes at position 1,000,000 in the file
rc = zfile_write (file, chunk, 1000000);
assert (rc == 0);
zfile_close (file);
assert (zfile_is_readable (file));
assert (zfile_cursize (file) == 1000100);
assert (!zfile_is_stable (file));
zchunk_destroy (&chunk);
zclock_sleep (1001);
assert (zfile_is_stable (file));
// Check we can read from file
rc = zfile_input (file);
assert (rc == 0);
chunk = zfile_read (file, 1000100, 0);
assert (chunk);
assert (zchunk_size (chunk) == 1000100);
zchunk_destroy (&chunk);
// Remove file and directory
zdir_t *dir = zdir_new ("./this", NULL);
assert (zdir_cursize (dir) == 1000100);
zdir_remove (dir, true);
assert (zdir_cursize (dir) == 0);
zdir_destroy (&dir);
// Check we can no longer read from file
assert (!zfile_is_readable (file));
rc = zfile_input (file);
assert (rc == -1);
zfile_destroy (&file);
// @end
printf ("OK\n");
return 0;
}
int
zfile_input (zfile_t *self)
{
assert (self);
if (self->handle)
zfile_close (self);
self->handle = fopen (self->fullname, "rb");
if (self->handle) {
struct stat stat_buf;
if (stat (self->fullname, &stat_buf) == 0)
self->cursize = stat_buf.st_size;
else
self->cursize = 0;
}
return self->handle? 0: -1;
}
void
zfile_destroy (zfile_t **self_p)
{
assert (self_p);
if (*self_p) {
zfile_t *self = *self_p;
zdigest_destroy (&self->digest);
if (self->remove_on_destroy)
zfile_remove (self);
zfile_close (self);
freen (self->fullname);
freen (self->curline);
freen (self->link);
freen (self);
*self_p = NULL;
}
}
int
zfile_input (zfile_t *self)
{
assert (self);
if (self->handle)
zfile_close (self);
char *real_name = self->link? self->link: self->fullname;
self->handle = fopen (real_name, "rb");
if (self->handle) {
struct stat stat_buf;
if (stat (real_name, &stat_buf) == 0) {
self->cursize = stat_buf.st_size;
} else {
long cpos = ftell(self->handle);
fseek(self->handle, 0L, SEEK_END);
self->cursize = ftell(self->handle);
fseek(self->handle, cpos, SEEK_SET);
}
}
return self->handle? 0: -1;
}
zconfig_t *
zconfig_load (const char *filename)
{
// Load entire file into memory as a chunk, then process it
zconfig_t *self = NULL;
zfile_t *file = zfile_new (NULL, filename);
if (!file)
return NULL;
if (zfile_input (file) == 0) {
zchunk_t *chunk = zfile_read (file, zfile_cursize (file), 0);
if (chunk) {
self = zconfig_chunk_load (chunk);
zchunk_destroy (&chunk);
if (self)
self->file = file;
zfile_close (file);
file = NULL; // Config tree now owns file handle
}
}
zfile_destroy (&file);
return self;
}
JNIEXPORT void JNICALL
Java_org_zeromq_czmq_Zfile__1_1close (JNIEnv *env, jclass c, jlong self)
{
zfile_close ((zfile_t *) (intptr_t) self);
}
void
zfile_test (bool verbose)
{
printf (" * zfile: ");
// @selftest
zfile_t *file = zfile_new (NULL, "bilbo");
assert (streq (zfile_filename (file, "."), "bilbo"));
assert (zfile_is_readable (file) == false);
zfile_destroy (&file);
// Create a test file in some random subdirectory
file = zfile_new ("./this/is/a/test", "bilbo");
int rc = zfile_output (file);
assert (rc == 0);
zchunk_t *chunk = zchunk_new (NULL, 100);
zchunk_fill (chunk, 0, 100);
// Write 100 bytes at position 1,000,000 in the file
rc = zfile_write (file, chunk, 1000000);
assert (rc == 0);
zchunk_destroy (&chunk);
zfile_close (file);
assert (zfile_is_readable (file));
assert (zfile_cursize (file) == 1000100);
assert (!zfile_is_stable (file));
// Now append one byte to file from outside
int handle = open ("./this/is/a/test/bilbo", O_WRONLY | O_TRUNC | O_BINARY, 0);
assert (handle >= 0);
rc = write (handle, "Hello, World\n", 13);
assert (rc == 13);
close (handle);
assert (zfile_has_changed (file));
zclock_sleep (1001);
assert (zfile_has_changed (file));
assert (!zfile_is_stable (file));
zfile_restat (file);
assert (zfile_is_stable (file));
assert (streq (zfile_digest (file), "4AB299C8AD6ED14F31923DD94F8B5F5CB89DFB54"));
// Check we can read from file
rc = zfile_input (file);
assert (rc == 0);
chunk = zfile_read (file, 1000100, 0);
assert (chunk);
assert (zchunk_size (chunk) == 13);
zchunk_destroy (&chunk);
zfile_close (file);
// Try some fun with symbolic links
zfile_t *link = zfile_new ("./this/is/a/test", "bilbo.ln");
rc = zfile_output (link);
assert (rc == 0);
fprintf (zfile_handle (link), "./this/is/a/test/bilbo\n");
zfile_destroy (&link);
link = zfile_new ("./this/is/a/test", "bilbo.ln");
rc = zfile_input (link);
assert (rc == 0);
chunk = zfile_read (link, 1000100, 0);
assert (chunk);
assert (zchunk_size (chunk) == 13);
zchunk_destroy (&chunk);
zfile_destroy (&link);
// Remove file and directory
zdir_t *dir = zdir_new ("./this", NULL);
assert (zdir_cursize (dir) == 26);
zdir_remove (dir, true);
assert (zdir_cursize (dir) == 0);
zdir_destroy (&dir);
// Check we can no longer read from file
assert (zfile_is_readable (file));
zfile_restat (file);
assert (!zfile_is_readable (file));
rc = zfile_input (file);
assert (rc == -1);
zfile_destroy (&file);
// @end
printf ("OK\n");
}
///
// Close file, if open
void QZfile::close ()
{
zfile_close (self);
}
void
zfile_test (bool verbose)
{
printf (" * zfile: ");
// @selftest
const char *SELFTEST_DIR_RW = "src/selftest-rw";
const char *testbasedir = "this";
const char *testsubdir = "is/a/test";
const char *testfile = "bilbo";
const char *testlink = "bilbo.ln";
char *basedirpath = NULL; // subdir in a test, under SELFTEST_DIR_RW
char *dirpath = NULL; // subdir in a test, under basedirpath
char *filepath = NULL; // pathname to testfile in a test, in dirpath
char *linkpath = NULL; // pathname to testlink in a test, in dirpath
basedirpath = zsys_sprintf ("%s/%s", SELFTEST_DIR_RW, testbasedir);
assert (basedirpath);
dirpath = zsys_sprintf ("%s/%s", basedirpath, testsubdir);
assert (dirpath);
filepath = zsys_sprintf ("%s/%s", dirpath, testfile);
assert (filepath);
linkpath = zsys_sprintf ("%s/%s", dirpath, testlink);
assert (linkpath);
// This subtest is specifically for NULL as current directory, so
// no SELFTEST_DIR_RW here; testfile should have no slashes inside.
// Normally tests clean up in zfile_destroy(), but if a selftest run
// dies e.g. on assert(), workspace remains dirty. Better clean it up.
if (zfile_exists (testfile) ) {
if (verbose)
zsys_debug ("zfile_test() has to remove ./%s that should not have been here", testfile);
zfile_delete (testfile);
}
zfile_t *file = zfile_new (NULL, testfile);
assert (file);
assert (streq (zfile_filename (file, "."), testfile));
assert (zfile_is_readable (file) == false);
zfile_destroy (&file);
// Create a test file in some random subdirectory
if (verbose)
zsys_debug ("zfile_test() at timestamp %" PRIi64 ": "
"Creating new zfile %s",
zclock_time(), filepath );
if (zfile_exists (filepath) ) {
if (verbose)
zsys_debug ("zfile_test() has to remove %s that should not have been here", filepath);
zfile_delete (filepath);
}
file = zfile_new (dirpath, testfile);
assert (file);
int rc = zfile_output (file);
assert (rc == 0);
zchunk_t *chunk = zchunk_new (NULL, 100);
assert (chunk);
zchunk_fill (chunk, 0, 100);
// Write 100 bytes at position 1,000,000 in the file
if (verbose)
zsys_debug ("zfile_test() at timestamp %" PRIi64 ": "
"Writing 100 bytes at position 1,000,000 in the file",
zclock_time() );
rc = zfile_write (file, chunk, 1000000);
if (verbose)
zsys_debug ("zfile_test() at timestamp %" PRIi64 ": "
"Wrote 100 bytes at position 1,000,000 in the file, result code %d",
zclock_time(), rc );
assert (rc == 0);
zchunk_destroy (&chunk);
zfile_close (file);
assert (zfile_is_readable (file));
assert (zfile_cursize (file) == 1000100);
if (verbose)
zsys_debug ("zfile_test() at timestamp %" PRIi64 ": "
"Testing if file is NOT stable (is younger than 1 sec)",
zclock_time() );
assert (!zfile_is_stable (file));
if (verbose)
zsys_debug ("zfile_test() at timestamp %" PRIi64 ": "
"Passed the lag-dependent tests",
zclock_time() );
assert (zfile_digest (file));
// Now truncate file from outside
int handle = open (filepath, O_WRONLY | O_TRUNC | O_BINARY, 0);
assert (handle >= 0);
rc = write (handle, "Hello, World\n", 13);
assert (rc == 13);
close (handle);
assert (zfile_has_changed (file));
#ifdef CZMQ_BUILD_DRAFT_API
zclock_sleep ((int)zsys_file_stable_age_msec() + 50);
#else
zclock_sleep (5050);
#endif
assert (zfile_has_changed (file));
assert (!zfile_is_stable (file));
zfile_restat (file);
assert (zfile_is_stable (file));
assert (streq (zfile_digest (file), "4AB299C8AD6ED14F31923DD94F8B5F5CB89DFB54"));
// Check we can read from file
rc = zfile_input (file);
assert (rc == 0);
chunk = zfile_read (file, 1000100, 0);
assert (chunk);
assert (zchunk_size (chunk) == 13);
zchunk_destroy (&chunk);
zfile_close (file);
// Check we can read lines from file
rc = zfile_input (file);
assert (rc == 0);
const char *line = zfile_readln (file);
assert (streq (line, "Hello, World"));
line = zfile_readln (file);
assert (line == NULL);
zfile_close (file);
// Try some fun with symbolic links
zfile_t *link = zfile_new (dirpath, testlink);
assert (link);
rc = zfile_output (link);
assert (rc == 0);
fprintf (zfile_handle (link), "%s\n", filepath);
zfile_destroy (&link);
link = zfile_new (dirpath, testlink);
assert (link);
rc = zfile_input (link);
assert (rc == 0);
chunk = zfile_read (link, 1000100, 0);
assert (chunk);
assert (zchunk_size (chunk) == 13);
zchunk_destroy (&chunk);
zfile_destroy (&link);
// Remove file and directory
zdir_t *dir = zdir_new (basedirpath, NULL);
assert (dir);
assert (zdir_cursize (dir) == 26);
zdir_remove (dir, true);
assert (zdir_cursize (dir) == 0);
zdir_destroy (&dir);
// Check we can no longer read from file
assert (zfile_is_readable (file));
zfile_restat (file);
assert (!zfile_is_readable (file));
rc = zfile_input (file);
assert (rc == -1);
zfile_destroy (&file);
// This set of tests is done, free the strings for reuse
zstr_free (&basedirpath);
zstr_free (&dirpath);
zstr_free (&filepath);
zstr_free (&linkpath);
const char *eof_checkfile = "eof_checkfile";
filepath = zsys_sprintf ("%s/%s", SELFTEST_DIR_RW, eof_checkfile);
assert (filepath);
if (zfile_exists (filepath) ) {
if (verbose)
zsys_debug ("zfile_test() has to remove %s that should not have been here", filepath);
zfile_delete (filepath);
}
zstr_free (&filepath);
file = zfile_new (SELFTEST_DIR_RW, eof_checkfile);
assert (file);
// 1. Write something first
rc = zfile_output (file);
assert (rc == 0);
chunk = zchunk_new ("123456789", 9);
assert (chunk);
rc = zfile_write (file, chunk, 0);
assert (rc == 0);
zchunk_destroy (&chunk);
zfile_close (file);
assert (zfile_cursize (file) == 9);
// 2. Read the written something
rc = zfile_input (file);
assert (rc != -1);
// try to read more bytes than there is in the file
chunk = zfile_read (file, 1000, 0);
assert (zfile_eof(file));
assert (zchunk_streq (chunk, "123456789"));
zchunk_destroy (&chunk);
// reading is ok
chunk = zfile_read (file, 5, 0);
assert (!zfile_eof(file));
assert (zchunk_streq (chunk, "12345"));
zchunk_destroy (&chunk);
// read from non zero offset until the end
chunk = zfile_read (file, 5, 5);
assert (zfile_eof(file));
assert (zchunk_streq (chunk, "6789"));
zchunk_destroy (&chunk);
zfile_remove (file);
zfile_close (file);
zfile_destroy (&file);
#ifdef CZMQ_BUILD_DRAFT_API
zfile_t *tempfile = zfile_tmp ();
assert (tempfile);
assert (zfile_filename (tempfile, NULL));
assert (zsys_file_exists (zfile_filename (tempfile, NULL)));
zchunk_t *tchunk = zchunk_new ("HELLO", 6);
assert (zfile_write (tempfile, tchunk, 0) == 0);
zchunk_destroy (&tchunk);
char *filename = strdup (zfile_filename (tempfile, NULL));
zfile_destroy (&tempfile);
assert (!zsys_file_exists (filename));
zstr_free (&filename);
#endif // CZMQ_BUILD_DRAFT_API
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
void
zdir_test (bool verbose)
{
printf (" * zdir: ");
// @selftest
// need to create a file in the test directory we're watching
// in order to ensure the directory exists
zfile_t *initfile = zfile_new ("./zdir-test-dir", "initial_file");
assert (initfile);
zfile_output (initfile);
fprintf (zfile_handle (initfile), "initial file\n");
zfile_close (initfile);
zfile_destroy (&initfile);
zdir_t *older = zdir_new ("zdir-test-dir", NULL);
assert (older);
if (verbose) {
printf ("\n");
zdir_dump (older, 0);
}
zdir_t *newer = zdir_new (".", NULL);
assert (newer);
zlist_t *patches = zdir_diff (older, newer, "/");
assert (patches);
while (zlist_size (patches)) {
zdir_patch_t *patch = (zdir_patch_t *) zlist_pop (patches);
zdir_patch_destroy (&patch);
}
zlist_destroy (&patches);
zdir_destroy (&older);
zdir_destroy (&newer);
zdir_t *nosuch = zdir_new ("does-not-exist", NULL);
assert (nosuch == NULL);
// zdir_watch test:
zactor_t *watch = zactor_new (zdir_watch, NULL);
assert (watch);
int synced;
if (verbose) {
zsock_send (watch, "s", "VERBOSE");
synced = zsock_wait(watch);
assert ( synced == 0);
}
zclock_sleep (1001); // wait for initial file to become 'stable'
zsock_send (watch, "si", "TIMEOUT", 100);
synced = zsock_wait(watch);
assert (synced == 0);
zsock_send (watch, "ss", "SUBSCRIBE", "zdir-test-dir");
synced = zsock_wait(watch);
assert(synced == 0);
zsock_send (watch, "ss", "UNSUBSCRIBE", "zdir-test-dir");
synced = zsock_wait(watch);
assert(synced == 0);
zsock_send (watch, "ss", "SUBSCRIBE", "zdir-test-dir");
synced = zsock_wait(watch);
assert(synced == 0);
zfile_t *newfile = zfile_new ("zdir-test-dir", "test_abc");
zfile_output (newfile);
fprintf (zfile_handle (newfile), "test file\n");
zfile_close (newfile);
zpoller_t *watch_poll = zpoller_new (watch, NULL);
// poll for a certain timeout before giving up and failing the test.
void* polled = zpoller_wait(watch_poll, 1001);
assert (polled == watch);
// wait for notification of the file being added
char *path;
int rc = zsock_recv (watch, "sp", &path, &patches);
assert (rc == 0);
assert (streq (path, "zdir-test-dir"));
freen (path);
assert (zlist_size (patches) == 1);
zdir_patch_t *patch = (zdir_patch_t *) zlist_pop (patches);
assert (streq (zdir_patch_path (patch), "zdir-test-dir"));
zfile_t *patch_file = zdir_patch_file (patch);
assert (streq (zfile_filename (patch_file, ""), "zdir-test-dir/test_abc"));
zdir_patch_destroy (&patch);
zlist_destroy (&patches);
// remove the file
zfile_remove (newfile);
zfile_destroy (&newfile);
// poll for a certain timeout before giving up and failing the test.
polled = zpoller_wait(watch_poll, 1001);
assert (polled == watch);
// wait for notification of the file being removed
rc = zsock_recv (watch, "sp", &path, &patches);
assert (rc == 0);
assert (streq (path, "zdir-test-dir"));
freen (path);
assert (zlist_size (patches) == 1);
patch = (zdir_patch_t *) zlist_pop (patches);
assert (streq (zdir_patch_path (patch), "zdir-test-dir"));
patch_file = zdir_patch_file (patch);
assert (streq (zfile_filename (patch_file, ""), "zdir-test-dir/test_abc"));
zdir_patch_destroy (&patch);
zlist_destroy (&patches);
zpoller_destroy (&watch_poll);
zactor_destroy (&watch);
// clean up by removing the test directory.
zdir_t *testdir = zdir_new ("zdir-test-dir", NULL);
zdir_remove (testdir, true);
zdir_destroy (&testdir);
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
