static zsync_node_t *
zsync_node_new ()
{
int rc;
zsync_node_t *self = (zsync_node_t *) zmalloc (sizeof (zsync_node_t));
self->ctx = zctx_new ();
assert (self->ctx);
self->zyre = zyre_new (self->ctx);
assert (self->zyre);
// Obtain permanent UUID
self->own_uuid = zuuid_new ();
if (zsys_file_exists (UUID_FILE)) {
// Read uuid from file
zfile_t *uuid_file = zfile_new (".", UUID_FILE);
int rc = zfile_input (uuid_file); // open file for reading
assert (rc == 0);
zchunk_t *uuid_chunk = zfile_read (uuid_file, 16, 0);
assert (zchunk_size (uuid_chunk) == 16); // make sure read succeeded
zuuid_set (self->own_uuid, zchunk_data (uuid_chunk));
zfile_destroy (&uuid_file);
} else {
// Write uuid to file
zfile_t *uuid_file = zfile_new (".", UUID_FILE);
rc = zfile_output (uuid_file); // open file for writing
assert (rc == 0);
zchunk_t *uuid_bin = zchunk_new ( zuuid_data (self->own_uuid), 16);
rc = zfile_write (uuid_file, uuid_bin, 0);
assert (rc == 0);
zfile_destroy (&uuid_file);
}
// Obtain peers and states
self->peers = zlist_new ();
if (zsys_file_exists (PEER_STATES_FILE)) {
zhash_t *peer_states = zhash_new ();
int rc = zhash_load (peer_states, PEER_STATES_FILE);
assert (rc == 0);
zlist_t *uuids = zhash_keys (peer_states);
char *uuid = zlist_first (uuids);
while (uuid) {
char * state_str = zhash_lookup (peer_states, uuid);
uint64_t state;
sscanf (state_str, "%"SCNd64, &state);
zlist_append (self->peers, zsync_peer_new (uuid, state));
uuid = zlist_next (uuids);
}
}
self->zyre_peers = zhash_new ();
self->terminated = false;
return self;
}
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;
}
static int
s_recv_from_zyre (s_agent_t *self)
{
zyre_event_t *event = zyre_event_new (self->zyre);
if (zyre_event_type (event) == ZYRE_EVENT_SHOUT
&& streq (zyre_event_group (event), "DROPS")) {
zmsg_t *msg = zyre_event_msg (event);
char *operation = zmsg_popstr (msg);
if (streq (operation, "CREATE")) {
char *filename = zmsg_popstr (msg);
zframe_t *frame = zmsg_pop (msg);
zfile_t *file = zfile_new (self->path, filename);
zfile_output (file);
fwrite (zframe_data (frame), 1, zframe_size (frame), zfile_handle (file));
zfile_destroy (&file);
zframe_destroy (&frame);
zstr_send (self->pipe, filename);
free (filename);
}
free (operation);
}
zyre_event_destroy (&event);
return 0;
}
zchunk_t *
get_chunk (char *path, uint64_t chunk_size, uint64_t offset)
{
printf("[ST] GET CHUNK\n");
char *path_new = malloc(strlen("./syncfolder/") + strlen(path) + 1);
path_new[0] = '\0';
strcat(path_new, "./syncfolder/");
strcat(path_new, path);
if (zsys_file_exists (path_new)) {
printf("[ST] File exist\n");
zfile_t *file = zfile_new (".", path_new);
if (zfile_is_readable (file)) {
printf("[ST] File read\n");
zfile_input (file);
if (zfile_size (path_new) > offset) {
zchunk_t *chunk = zfile_read (file, chunk_size, offset);
zfile_destroy (&file);
return chunk;
}
else {
return NULL;
}
}
} else {
printf("[ST] File %s not exist\n", path_new);
}
return NULL;
}
void
zdir_patch_test (bool verbose)
{
printf (" * zdir_patch: ");
// @selftest
zfile_t *file = zfile_new (".", "bilbo");
assert (file);
zdir_patch_t *patch = zdir_patch_new (".", file, patch_create, "/");
assert (patch);
zfile_destroy (&file);
file = zdir_patch_file (patch);
assert (file);
assert (streq (zfile_filename (file, "."), "bilbo"));
assert (streq (zdir_patch_vpath (patch), "/bilbo"));
zdir_patch_destroy (&patch);
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
static void
s_posix_populate_entry (zdir_t *self, struct dirent *entry)
{
// Skip . and ..
if (streq (entry->d_name, ".")
|| streq (entry->d_name, ".."))
return;
char fullpath [1024 + 1];
snprintf (fullpath, 1024, "%s/%s", self->path, entry->d_name);
struct stat stat_buf;
if (stat (fullpath, &stat_buf))
return;
if (entry->d_name [0] == '.')
; // Skip hidden files
else
// If we have a subdirectory, go load that
if (stat_buf.st_mode & S_IFDIR) {
zdir_t *subdir = zdir_new (entry->d_name, self->path);
zlist_append (self->subdirs, subdir);
}
else {
// Add file entry to directory list
zfile_t *file = zfile_new (self->path, entry->d_name);
zlist_append (self->files, 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;
}
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);
}
JNIEXPORT jlong JNICALL
Java_org_zeromq_czmq_Zfile__1_1new (JNIEnv *env, jclass c, jstring path, jstring name)
{
char *path_ = (char *) (*env)->GetStringUTFChars (env, path, NULL);
char *name_ = (char *) (*env)->GetStringUTFChars (env, name, NULL);
// Disable CZMQ signal handling; allow Java to deal with it
zsys_handler_set (NULL);
jlong new_ = (jlong) (intptr_t) zfile_new (path_, name_);
(*env)->ReleaseStringUTFChars (env, path, path_);
(*env)->ReleaseStringUTFChars (env, name, name_);
return new_;
}
zchunk_t *
hydra_post_fetch (hydra_post_t *self, size_t size, size_t offset)
{
assert (self);
if (self->content)
return zchunk_dup (self->content);
if (size == 0)
size = self->content_size;
zfile_t *file = zfile_new (NULL, self->location);
if (zfile_input (file) == 0) {
zchunk_t *chunk = zfile_read (file, size, offset);
zfile_destroy (&file);
return chunk;
}
return NULL;
}
static void
s_win32_populate_entry (zdir_t *self, WIN32_FIND_DATA *entry)
{
if (entry->cFileName [0] == '.')
; // Skip hidden files
else
// If we have a subdirectory, go load that
if (entry->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
zdir_t *subdir = zdir_new (entry->cFileName, self->path);
zlist_append (self->subdirs, subdir);
}
else {
// Add file entry to directory list
zfile_t *file = zfile_new (self->path, entry->cFileName);
zlist_append (self->files, file);
}
}
// --------------------------------------------------------------------------
// Self test of this class
int
zdir_patch_test (bool verbose)
{
printf (" * zdir_patch: ");
// @selftest
zfile_t *file = zfile_new (".", "bilbo");
zdir_patch_t *patch = zdir_patch_new (".", file, patch_create, "/");
zfile_destroy (&file);
file = zdir_patch_file (patch);
assert (streq (zfile_filename (file, "."), "bilbo"));
assert (streq (zdir_patch_vpath (patch), "/bilbo"));
zdir_patch_destroy (&patch);
// @end
printf ("OK\n");
return 0;
}
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);
}
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;
}
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));
}
///
// If file exists, populates properties. CZMQ supports portable symbolic
// links, which are files with the extension ".ln". A symbolic link is a
// text file containing one line, the filename of a target file. Reading
// data from the symbolic link actually reads from the target file. Path
// may be NULL, in which case it is not used.
QmlZfile *QmlZfileAttached::construct (const QString &path, const QString &name) {
QmlZfile *qmlSelf = new QmlZfile ();
qmlSelf->self = zfile_new (path.toUtf8().data(), name.toUtf8().data());
return qmlSelf;
};
/* parse xml file and create objects */
void* zelia_xml_parse_file(const char* xml_path, void* parser)
{
char* _buff = NULL; /* buffer to hold the file contents */
size_t _sz = 0; /* buffer file size */
xmlDocPtr _xml_doc = NULL; /* xml document pointer */
xmlNodePtr _root = NULL;
struct _zparser* obj = NULL;
/* check arguments */
ZCHECK_OBJ_INT(xml_path);
if(parser == NULL)
{
ZCONSTRUCTOR(obj, struct _zparser);
}
else
obj = (struct _zparser*) parser;
/* read the file */
if(_read_file(xml_path, &_buff, &_sz) != ZELIA_OK)
return NULL;
/* initialise object array */
blist_new(&obj->object_array, _delete_helper);
if(!zfile_new(&obj->file))
return NULL;
/* toggle the force overwrite mode */
zfile_toggle_overwrite(&obj->file);
/* parse the document */
xmlInitParser();
_xml_doc = xmlParseMemory(_buff, _sz);
if(_xml_doc == NULL)
{
ZELIA_LOG_MESSAGE("zelia_xml unable to parse the document");
goto clean_up;
}
_root = xmlDocGetRootElement(_xml_doc);
_main_loop(xmlFirstElementChild(_root), obj);
xmlFreeDoc(_xml_doc);
xmlCleanupParser();
clean_up:
if(_buff != NULL && _sz > 0)
free(_buff);
_buff = NULL;
_sz = 0;
if(ZDESTRUCTOR_CHECK)
{
_finalise_parser(obj);
free(obj);
}
else
return obj;
return NULL;
}
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");
}
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;
}
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");
}
static void
send_email (client_t *self)
{
assert (self);
assert (self->message);
zsys_info ("sending email !");
CURL *curl;
CURLcode res = CURLE_OK;
struct curl_slist *recipients = NULL;
zuuid_t *uuid = zuuid_new ();
const char *uuid_s = zuuid_str (uuid);
char filename[256];
sprintf (filename, "./data/mail-%s.txt", uuid_s);
zuuid_destroy (&uuid);
char fn[200];
sprintf (fn, "mail-%s.txt", uuid_s);
zfile_t *zf = zfile_new ("./data", fn);
zfile_output (zf);
FILE *pFile = zfile_handle (zf);
//FILE *pFile = fopen (filename,"w");
// date --------
time_t timer;
char buffer[256];
struct tm* tm_info;
time (&timer);
tm_info = localtime (&timer);
strftime (buffer, 60, "%a, %d %b %Y %T %z\r\n", tm_info);
//---------------
fprintf (pFile, "Date: %s", buffer);
zsys_info ("To: %s \r\n", zmailer_msg_to(self->message));
fprintf (pFile,"To: %s\r\n", zmailer_msg_to(self->message));
fprintf (pFile, "From: %s\r\n", zmailer_msg_from (self->message));
fprintf (pFile, "Subject: %s \r\n", zmailer_msg_subject (self->message));
fprintf (pFile, "\r\n");
fprintf (pFile, "%s Thank you. \r\n", zmailer_msg_request(self->message));
fclose (pFile);
FILE * pMail;
pMail = fopen (filename,"r");
assert (pMail);
curl = curl_easy_init();
if(curl) {
/* Set username and password */
curl_easy_setopt(curl, CURLOPT_USERNAME, zconfig_get (self->server->config, "zmailer_server/user", ""));
curl_easy_setopt(curl, CURLOPT_PASSWORD, zconfig_get (self->server->config, "zmailer_server/password", ""));
/* This is the URL for your mailserver. Note the use of port 587 here,
* instead of the normal SMTP port (25). Port 587 is commonly used for
* secure mail submission (see RFC4403), but you should use whatever
* matches your server configuration. */
curl_easy_setopt(curl, CURLOPT_URL, zconfig_get (self->server->config, "zmailer_server/server", ""));
/* In this example, we'll start with a plain text connection, and upgrade
* to Transport Layer Security (TLS) using the STARTTLS command. Be careful
* of using CURLUSESSL_TRY here, because if TLS upgrade fails, the transfer
* will continue anyway - see the security discussion in the libcurl
* tutorial for more details. */
curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
/* If your server doesn't have a valid certificate, then you can disable
* part of the Transport Layer Security protection by setting the
* CURLOPT_SSL_VERIFYPEER and CURLOPT_SSL_VERIFYHOST options to 0 (false).*/
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
/* Note that this option isn't strictly required, omitting it will result in
* libcurl sending the MAIL FROM command with empty sender data. All
* autoresponses should have an empty reverse-path, and should be directed
* to the address in the reverse-path which triggered them. Otherwise, they
* could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
*/
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, zmailer_msg_from (self->message));
/* Add two recipients, in this particular case they correspond to the
* To: and Cc: addressees in the header, but they could be any kind of
* recipient. */
recipients = curl_slist_append(recipients, zmailer_msg_to (self->message));
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
/* We're using a callback function to specify the payload (the headers and
* body of the message). You could just use the CURLOPT_READDATA option to
* specify a FILE pointer to read from. */
curl_easy_setopt(curl, CURLOPT_READDATA, pMail);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* Since the traffic will be encrypted, it is very useful to turn on debug
* information within libcurl to see what is happening during the transfer.
*/
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
/* Send the message */
res = curl_easy_perform(curl);
/* Check for errors */
if(res != CURLE_OK)
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
/* Free the list of recipients */
curl_slist_free_all(recipients);
/* Always cleanup */
curl_easy_cleanup(curl);
}
fclose (pMail);
}
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;
}
///
// If file exists, populates properties. CZMQ supports portable symbolic
// links, which are files with the extension ".ln". A symbolic link is a
// text file containing one line, the filename of a target file. Reading
// data from the symbolic link actually reads from the target file. Path
// may be NULL, in which case it is not used.
QZfile::QZfile (const QString &path, const QString &name, QObject *qObjParent) : QObject (qObjParent)
{
this->self = zfile_new (path.toUtf8().data(), name.toUtf8().data());
}
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");
}
