JNIEXPORT jstring JNICALL
Java_org_zeromq_czmq_Zfile__1_1digest (JNIEnv *env, jclass c, jlong self)
{
char *digest_ = (char *) zfile_digest ((zfile_t *) (intptr_t) self);
jstring return_string_ = (*env)->NewStringUTF (env, digest_);
return return_string_;
}
void
zdir_patch_digest_set (zdir_patch_t *self)
{
if ( self->op == patch_create
&& self->digest == NULL)
self->digest = strdup (zfile_digest (self->file));
}
/* Calculate file digest using zfile() class from czmq.
* Caller must free.
*/
char *digest (const char *path)
{
zfile_t *zf = zfile_new (NULL, path);
char *digest = NULL;
if (zf)
digest = xstrdup (zfile_digest (zf));
zfile_destroy (&zf);
return digest;
}
static bool config_file_has_changed()
{
bool changed = false;
if (config_file_exists) {
zfile_restat(config_file);
if (config_file_last_modified != zfile_modified(config_file)) {
const char *new_digest = zfile_digest(config_file);
// printf("[D] old digest: %s\n[D] new digest: %s\n", config_file_digest, new_digest);
changed = strcmp(config_file_digest, new_digest) != 0;
}
}
return changed;
}
zhash_t *
zdir_cache (zdir_t *self)
{
assert (self);
// Load any previous cache from disk
zhash_t *cache = zhash_new ();
if (!cache)
return NULL;
zhash_autofree (cache);
char *cache_file = (char *) zmalloc (strlen (self->path) + strlen ("/.cache") + 1);
if (!cache_file) {
zhash_destroy (&cache);
return NULL;
}
sprintf (cache_file, "%s/.cache", self->path);
zhash_load (cache, cache_file);
// Recalculate digest for any new files
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
const char *filename = zfile_filename (file, self->path);
if (zhash_lookup (cache, zfile_filename (file, self->path)) == NULL) {
int rc = zhash_insert (cache, filename, (void *) zfile_digest (file));
if (rc != 0) {
zhash_destroy (&cache);
break;
}
}
}
freen (files);
// Save cache to disk for future reference
if (cache)
zhash_save (cache, cache_file);
freen (cache_file);
return cache;
}
int
hydra_post_set_file (hydra_post_t *self, const char *location)
{
assert (self);
free (self->location);
int rc = 0;
self->location = strdup (location);
zchunk_destroy (&self->content);
zfile_t *file = zfile_new (NULL, self->location);
if (file && zfile_is_readable (file)) {
self->content_size = zfile_cursize (file);
strcpy (self->digest, zfile_digest (file));
}
else
rc = -1;
zfile_destroy (&file);
return rc;
}
static void lsmod_cb (flux_t *h, flux_msg_handler_t *w,
const flux_msg_t *msg, void *arg)
{
struct sched_plugin_loader *sploader = arg;
struct sched_plugin *plugin = sched_plugin_get (sploader);
flux_modlist_t *mods = NULL;
zfile_t *zf = NULL;
char *json_str = NULL;
struct stat sb;
int rc = -1;
if (flux_request_decode (msg, NULL, NULL) < 0)
goto done;
if (!(mods = flux_modlist_create ()))
goto done;
if (plugin) {
if (stat (plugin->path, &sb) < 0)
goto done;
if (!(zf = zfile_new (NULL, plugin->path)))
goto done;
if (flux_modlist_append (mods, plugin->name, sb.st_size,
zfile_digest (zf),
0, FLUX_MODSTATE_RUNNING) < 0)
goto done;
}
if (!(json_str = flux_lsmod_json_encode (mods)))
goto done;
rc = 0;
done:
if (flux_respond (h, msg, rc < 0 ? errno : 0,
rc < 0 ? NULL : json_str) < 0)
flux_log_error (h, "%s: flux_respond", __FUNCTION__);
if (mods)
flux_modlist_destroy (mods);
zfile_destroy (&zf);
if (json_str)
free (json_str);
}
static void config_file_init()
{
config_file = zfile_new(NULL, config_file_name);
config_file_last_modified = zfile_modified(config_file);
config_file_digest = strdup(zfile_digest(config_file));
}
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");
}
///
// Calculate SHA1 digest for file, using zdigest class.
const QString QZfile::digest ()
{
const QString rv = QString (zfile_digest (self));
return rv;
}
int main (int argc, char *argv[])
{
flux_t h = NULL;
int ch;
char *cmd;
func_t *f;
opt_t opt = {
.fanout = 1024,
.nodeset = NULL,
};
log_init ("flux-module");
if (argc < 2)
usage ();
cmd = argv[1];
argc--;
argv++;
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 'r': /* --rank=[nodeset|all] */
if (opt.nodeset)
free (opt.nodeset);
opt.nodeset = xstrdup (optarg);
break;
case 'd': /* --direct */
opt.direct = true;
break;
case 'f': /* --fanout */
opt.fanout = strtoul (optarg, NULL, 10);
break;
default:
usage ();
break;
}
}
opt.argc = argc - optind;
opt.argv = argv + optind;
if (!(f = func_lookup (cmd)))
msg_exit ("unknown function '%s'", cmd);
if (strcmp (cmd, "info") != 0) {
if (!(h = flux_open (NULL, 0)))
err_exit ("flux_open");
if (!opt.nodeset) {
opt.nodeset = xasprintf ("%d", flux_rank (h));
} else if (!strcmp (opt.nodeset, "all") && flux_size (h) == 1) {
free (opt.nodeset);
opt.nodeset= xasprintf ("%d", flux_rank (h));
} else if (!strcmp (opt.nodeset, "all")) {
free (opt.nodeset);
opt.nodeset = xasprintf ("[0-%d]", flux_size (h) - 1);
}
}
f->fun (h, opt);
if (opt.nodeset)
free (opt.nodeset);
if (h)
flux_close (h);
log_fini ();
return 0;
}
char *sha1 (const char *path)
{
zfile_t *zf = zfile_new (NULL, path);
char *digest = NULL;
if (zf)
digest = xstrdup (zfile_digest (zf));
zfile_destroy (&zf);
return digest;
}
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");
}
module_t *module_add (modhash_t *mh, const char *path)
{
module_t *p;
void *dso;
const char **mod_namep;
mod_main_f *mod_main;
zfile_t *zf;
int rc;
dlerror ();
if (!(dso = dlopen (path, RTLD_NOW | RTLD_LOCAL))) {
msg ("%s", dlerror ());
errno = ENOENT;
return NULL;
}
mod_main = dlsym (dso, "mod_main");
mod_namep = dlsym (dso, "mod_name");
if (!mod_main || !mod_namep || !*mod_namep) {
dlclose (dso);
errno = ENOENT;
return NULL;
}
p = xzmalloc (sizeof (*p));
p->name = xstrdup (*mod_namep);
p->magic = MODULE_MAGIC;
p->main = mod_main;
p->dso = dso;
zf = zfile_new (NULL, path);
p->digest = xstrdup (zfile_digest (zf));
p->size = (int)zfile_cursize (zf);
zfile_destroy (&zf);
if (!(p->uuid = zuuid_new ()))
oom ();
if (!(p->rmmod = zlist_new ()))
oom ();
if (!(p->subs = zlist_new ()))
oom ();
p->rank = mh->rank;
p->zctx = mh->zctx;
p->broker_h = mh->broker_h;
p->heartbeat = mh->heartbeat;
/* Broker end of PAIR socket is opened here.
*/
if (!(p->sock = zsocket_new (p->zctx, ZMQ_PAIR)))
err_exit ("zsocket_new");
zsocket_set_hwm (p->sock, 0);
if (zsocket_bind (p->sock, "inproc://%s", module_get_uuid (p)) < 0)
err_exit ("zsock_bind inproc://%s", module_get_uuid (p));
if (!(p->broker_w = flux_zmq_watcher_create (flux_get_reactor (p->broker_h),
p->sock, FLUX_POLLIN,
module_cb, p)))
err_exit ("flux_zmq_watcher_create");
/* Update the modhash.
*/
rc = zhash_insert (mh->zh_byuuid, module_get_uuid (p), p);
assert (rc == 0); /* uuids are by definition unique */
zhash_freefn (mh->zh_byuuid, module_get_uuid (p),
(zhash_free_fn *)module_destroy);
return p;
}
///
// Calculate SHA1 digest for file, using zdigest class.
const QString QmlZfile::digest () {
return QString (zfile_digest (self));
};
