void zsys_set_interface (const char *value) { zsys_init (); free (s_interface); s_interface = strdup (value); }
void zargs_test (bool verbose) { zsys_init (); printf (" * zargs: "); // @selftest // Simple create/destroy test char *argv1[] = {"progname", "--named1", "-n1", "val1", "positional1", "--with", "value", "--with2=value2", "-W3value3", "--", "--thisis", "considered", "positional", NULL}; zargs_t *self = zargs_new (13, argv1); assert (self); assert (streq (zargs_progname (self), "progname")); assert (streq (zargs_first (self), "positional1")); assert (streq (zargs_next (self), "--thisis")); assert (streq (zargs_next (self), "considered")); assert (streq (zargs_next (self), "positional")); assert (!zargs_next (self)); assert (zargs_param_empty (zargs_param_lookup (self, "--named1"))); assert (!zargs_param_empty (zargs_param_lookup (self, "-n1"))); assert (streq (zargs_param_lookupx (self, "--not at all", "-n1", NULL), "val1")); // TODO: this does not look like an easy hack w/o allocating extra memory // ??? //assert (streq (zargs_param_lookup (self, "--with", NULL), "value2")); zargs_destroy (&self); // @end printf ("OK\n"); }
void zsys_set_ipv6 (int ipv6) { zsys_init (); ZMUTEX_LOCK (s_mutex); s_ipv6 = ipv6; ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_rcvhwm (size_t rcvhwm) { zsys_init (); ZMUTEX_LOCK (s_mutex); s_rcvhwm = rcvhwm; ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_pipehwm (size_t pipehwm) { zsys_init (); ZMUTEX_LOCK (s_mutex); s_pipehwm = pipehwm; ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_sndhwm (size_t sndhwm) { zsys_init (); ZMUTEX_LOCK (s_mutex); s_sndhwm = sndhwm; ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_linger (size_t linger) { zsys_init (); ZMUTEX_LOCK (s_mutex); s_linger = linger; ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_logsystem (bool logsystem) { zsys_init (); s_logsystem = logsystem; #if defined (__UNIX__) if (s_logsystem) openlog (s_logident, LOG_PID, LOG_USER); #elif defined (__WINDOWS__) // TODO: hook into Windows event log #endif }
void zsys_set_max_sockets (size_t max_sockets) { zsys_init (); ZMUTEX_LOCK (s_mutex); // If the app is misusing this method, burn it with fire if (s_open_sockets) zsys_error ("zsys_max_sockets() is not valid after creating sockets"); assert (s_open_sockets == 0); s_max_sockets = max_sockets ? max_sockets : zsys_socket_limit (); ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_logident (const char *value) { zsys_init (); free (s_logident); s_logident = strdup (value); #if defined (__UNIX__) if (s_logsystem) openlog (s_logident, LOG_PID, LOG_USER); #elif defined (__WINDOWS__) // TODO: hook in Windows event log for Windows #endif }
int graylog_forwarder_run_controller_loop(zconfig_t* config, zlist_t* devices, zlist_t *subscriptions, int rcv_hwm, int send_hwm) { set_thread_name("controller"); zsys_init(); controller_state_t state = {.config = config}; bool start_up_complete = controller_create_actors(&state, devices, subscriptions, rcv_hwm, send_hwm); if (!start_up_complete) goto exit; // set up event loop zloop_t *loop = zloop_new(); assert(loop); zloop_set_verbose(loop, 0); // send tick commands every second int rc = zloop_timer(loop, 1000, 1, send_tick_commands, &state); assert(rc != -1); // run the loop // when running under the google profiler, zmq_poll terminates with EINTR // so we keep the loop running in this case if (!zsys_interrupted) { bool should_continue_to_run = getenv("CPUPROFILE") != NULL; do { rc = zloop_start(loop); should_continue_to_run &= errno == EINTR && !zsys_interrupted; log_zmq_error(rc, __FILE__, __LINE__); } while (should_continue_to_run); } printf("[I] controller: shutting down\n"); // shutdown zloop_destroy(&loop); assert(loop == NULL); exit: printf("[I] controller: destroying actor threads\n"); controller_destroy_actors(&state); printf("[I] controller: calling zsys_shutdown\n"); zsys_shutdown(); printf("[I] controller: terminated\n"); return 0; }
void zsys_set_io_threads (size_t io_threads) { zsys_init (); ZMUTEX_LOCK (s_mutex); if (s_open_sockets) zsys_error ("zsys_io_threads() is not valid after creating sockets"); assert (s_open_sockets == 0); zmq_term (s_process_ctx); s_io_threads = io_threads; s_process_ctx = zmq_init ((int) s_io_threads); #if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3, 2, 0)) // TODO: this causes TravisCI to break; libzmq does not return a // valid socket on zmq_socket(), after this... zmq_ctx_set (s_process_ctx, ZMQ_MAX_SOCKETS, s_max_sockets); #endif ZMUTEX_UNLOCK (s_mutex); }
void zsys_set_logsender (const char *endpoint) { zsys_init (); if (endpoint) { // Create log sender if needed if (!s_logsender) { s_logsender = zsys_socket (ZMQ_PUB, NULL, 0); assert (s_logsender); } // Bind to specified endpoint int rc = zmq_bind (s_logsender, endpoint); assert (rc == 0); } else if (s_logsender) { zsys_close (s_logsender, NULL, 0); s_logsender = NULL; } }
void * zsys_socket (int type, const char *filename, size_t line_nbr) { // First time initialization; if the application is mixing // its own threading calls with zsock, this may fail if two // threads try to create sockets at the same time. In such // apps, they MUST create a socket in the main program before // starting any threads. If the app uses zactor for its threads // then we can guarantee this to always be safe. zsys_init (); ZMUTEX_LOCK (s_mutex); void *handle = zmq_socket (s_process_ctx, type); // Configure socket with process defaults zsocket_set_linger (handle, (int) s_linger); #if (ZMQ_VERSION_MAJOR == 2) // For ZeroMQ/2.x we use sndhwm for both send and receive zsocket_set_hwm (handle, s_sndhwm); #else // For later versions we use separate SNDHWM and RCVHWM zsocket_set_sndhwm (handle, (int) s_sndhwm); zsocket_set_rcvhwm (handle, (int) s_rcvhwm); # if defined (ZMQ_IPV6) zsocket_set_ipv6 (handle, s_ipv6); # else zsocket_set_ipv4only (handle, s_ipv6 ? 0 : 1); # endif #endif // Add socket to reference tracker so we can report leaks; this is // done only when the caller passes a filename/line_nbr if (filename) { s_sockref_t *sockref = (s_sockref_t *) malloc (sizeof (s_sockref_t)); sockref->handle = handle; sockref->type = type; sockref->filename = filename; sockref->line_nbr = line_nbr; zlist_append (s_sockref_list, sockref); } s_open_sockets++; ZMUTEX_UNLOCK (s_mutex); return handle; }
int main (int argc, char *argv []) { int argn = 1; bool verbose = false; if (argc > argn && streq (argv [argn], "-v")) { verbose = true; argn++; } if (argc > argn && streq (argv [argn], "-h")) { puts ("Usage: zs [ -v ]"); return 0; } // Main thread is read/parse/execute input text zsys_init (); zs_repl_t *repl = zs_repl_new (); zs_repl_verbose (repl, verbose); while (!zctx_interrupted) { char input [1024 + 2]; // 1024 chars + LF + null if (!fgets (input, 1026, stdin)) break; if (zs_repl_execute (repl, input) == 0) { if (zs_repl_completed (repl)) { char *results = zs_repl_results (repl); printf ("[%s]\n", results); zstr_free (&results); } } else { printf ("%*c\n", zs_repl_offset (repl), '^'); puts ("Syntax error"); } } zs_repl_destroy (&repl); return 0; }
/// // Initialize CZMQ zsys layer; this happens automatically when you create // a socket or an actor; however this call lets you force initialization // earlier, so e.g. logging is properly set-up before you start working. // Not threadsafe, so call only from main thread. Safe to call multiple // times. Returns global CZMQ context. void *QmlZsysAttached::init () { return zsys_init (); };
void zsys_set_logstream (FILE *stream) { zsys_init (); s_logstream = stream; }
int main(int argc, char * const *argv) { int rc = 0; process_arguments(argc, argv); setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); if (!quiet) printf("[I] started %s\n" "[I] sub-port: %d\n" "[I] push-port: %d\n" "[I] io-threads: %lu\n" "[I] rcv-hwm: %d\n" "[I] snd-hwm: %d\n" , argv[0], pull_port, pub_port, io_threads, rcv_hwm, snd_hwm); // load config config_file_exists = zsys_file_exists(config_file_name); if (config_file_exists) { config_file_init(); config = zconfig_load((char*)config_file_name); } // set global config zsys_init(); zsys_set_rcvhwm(10000); zsys_set_sndhwm(10000); zsys_set_pipehwm(1000); zsys_set_linger(100); zsys_set_io_threads(io_threads); // create socket to receive messages on zsock_t *receiver = zsock_new(ZMQ_SUB); assert_x(receiver != NULL, "sub socket creation failed", __FILE__, __LINE__); zsock_set_rcvhwm(receiver, rcv_hwm); // bind externally char* host = zlist_first(hosts); while (host) { if (!quiet) printf("[I] connecting to: %s\n", host); rc = zsock_connect(receiver, "%s", host); assert_x(rc == 0, "sub socket connect failed", __FILE__, __LINE__); host = zlist_next(hosts); } tracker = device_tracker_new(hosts, receiver); // create socket for publishing zsock_t *publisher = zsock_new(ZMQ_PUSH); assert_x(publisher != NULL, "pub socket creation failed", __FILE__, __LINE__); zsock_set_sndhwm(publisher, snd_hwm); rc = zsock_bind(publisher, "tcp://%s:%d", "*", pub_port); assert_x(rc == pub_port, "pub socket bind failed", __FILE__, __LINE__); // create compressor sockets zsock_t *compressor_input = zsock_new(ZMQ_PUSH); assert_x(compressor_input != NULL, "compressor input socket creation failed", __FILE__, __LINE__); rc = zsock_bind(compressor_input, "inproc://compressor-input"); assert_x(rc==0, "compressor input socket bind failed", __FILE__, __LINE__); zsock_t *compressor_output = zsock_new(ZMQ_PULL); assert_x(compressor_output != NULL, "compressor output socket creation failed", __FILE__, __LINE__); rc = zsock_bind(compressor_output, "inproc://compressor-output"); assert_x(rc==0, "compressor output socket bind failed", __FILE__, __LINE__); // create compressor agents zactor_t *compressors[MAX_COMPRESSORS]; for (size_t i = 0; i < num_compressors; i++) compressors[i] = message_decompressor_new(i); // set up event loop zloop_t *loop = zloop_new(); assert(loop); zloop_set_verbose(loop, 0); // calculate statistics every 1000 ms int timer_id = zloop_timer(loop, 1000, 0, timer_event, NULL); assert(timer_id != -1); // setup handler for the receiver socket publisher_state_t publisher_state = { .receiver = zsock_resolve(receiver), .publisher = zsock_resolve(publisher), .compressor_input = zsock_resolve(compressor_input), .compressor_output = zsock_resolve(compressor_output), }; // setup handler for compression results rc = zloop_reader(loop, compressor_output, read_zmq_message_and_forward, &publisher_state); assert(rc == 0); zloop_reader_set_tolerant(loop, compressor_output); // setup handdler for messages incoming from the outside or rabbit_listener rc = zloop_reader(loop, receiver, read_zmq_message_and_forward, &publisher_state); assert(rc == 0); zloop_reader_set_tolerant(loop, receiver); // initialize clock global_time = zclock_time(); // setup subscriptions if (subscriptions == NULL || zlist_size(subscriptions) == 0) { if (!quiet) printf("[I] subscribing to all log messages\n"); zsock_set_subscribe(receiver, ""); } else { char *subscription = zlist_first(subscriptions); while (subscription) { if (!quiet) printf("[I] subscribing to %s\n", subscription); zsock_set_subscribe(receiver, subscription); subscription = zlist_next(subscriptions); } zsock_set_subscribe(receiver, "heartbeat"); } // run the loop if (!zsys_interrupted) { if (verbose) printf("[I] starting main event loop\n"); bool should_continue_to_run = getenv("CPUPROFILE") != NULL; do { rc = zloop_start(loop); should_continue_to_run &= errno == EINTR && !zsys_interrupted; log_zmq_error(rc, __FILE__, __LINE__); } while (should_continue_to_run); if (verbose) printf("[I] main event zloop terminated with return code %d\n", rc); } zloop_destroy(&loop); assert(loop == NULL); if (!quiet) { printf("[I] received %zu messages\n", received_messages_count); printf("[I] shutting down\n"); } zlist_destroy(&hosts); zlist_destroy(&subscriptions); zsock_destroy(&receiver); zsock_destroy(&publisher); zsock_destroy(&compressor_input); zsock_destroy(&compressor_output); device_tracker_destroy(&tracker); for (size_t i = 0; i < num_compressors; i++) zactor_destroy(&compressors[i]); zsys_shutdown(); if (!quiet) printf("[I] terminated\n"); return rc; }
int main (int argc, char *argv []) { puts (PRODUCT); puts (COPYRIGHT); puts (NOWARRANTY); int argn = 1; bool verbose = false; bool force_foreground = false; if (argc > argn && streq (argv [argn], "-v")) { verbose = true; argn++; } if (argc > argn && streq (argv [argn], "-f")) { force_foreground = true; argn++; } if (argc > argn && streq (argv [argn], "-h")) { puts ("Usage: malamute [ -v ] [ -f ] [ -h | config-file ]"); puts (" Default config-file is 'malamute.cfg'"); return 0; } // Collect configuration file name const char *config_file = "malamute.cfg"; if (argc > argn) { config_file = argv [argn]; argn++; } // Send logging to system facility as well as stdout zsys_init (); zsys_set_logsystem (true); zsys_set_pipehwm (0); zsys_set_sndhwm (0); zsys_set_rcvhwm (0); // Load config file for our own use here zsys_info ("starting Malamute using config in '%s'", config_file); zconfig_t *config = zconfig_load (config_file); if (config) { // Do we want to run broker in the background? int as_daemon = !force_foreground && atoi (zconfig_resolve (config, "server/background", "0")); const char *workdir = zconfig_resolve (config, "server/workdir", "."); if (as_daemon) { zsys_info ("switching Malamute to background..."); if (zsys_daemonize (workdir)) return -1; } // Switch to user/group to run process under, if any if (zsys_run_as ( zconfig_resolve (config, "server/lockfile", NULL), zconfig_resolve (config, "server/group", NULL), zconfig_resolve (config, "server/user", NULL))) return -1; } else { zsys_error ("cannot load config file '%s'\n", config_file); return 1; } // Install authenticator (NULL or PLAIN) zactor_t *auth = zactor_new (zauth, NULL); assert (auth); if (verbose || atoi (zconfig_resolve (config, "server/auth/verbose", "0"))) { zstr_sendx (auth, "VERBOSE", NULL); zsock_wait (auth); } // Do PLAIN password authentication if requested const char *passwords = zconfig_resolve (config, "server/auth/plain", NULL); if (passwords) { zstr_sendx (auth, "PLAIN", passwords, NULL); zsock_wait (auth); } // Start Malamute server instance zactor_t *server = zactor_new (mlm_server, "Malamute"); if (verbose) zstr_send (server, "VERBOSE"); zstr_sendx (server, "LOAD", config_file, NULL); // Accept and print any message back from server while (true) { char *message = zstr_recv (server); if (message) { puts (message); free (message); } else { puts ("interrupted"); break; } } // Shutdown all services zactor_destroy (&server); zactor_destroy (&auth); // Destroy config tree zconfig_destroy (&config); return 0; }
/// // Initialize CZMQ zsys layer; this happens automatically when you create // a socket or an actor; however this call lets you force initialization // earlier, so e.g. logging is properly set-up before you start working. // Not threadsafe, so call only from main thread. Safe to call multiple // times. Returns global CZMQ context. void * QZsys::init () { void * rv = zsys_init (); return rv; }
JNIEXPORT jlong JNICALL Java_org_zeromq_czmq_Zsys__1_1init (JNIEnv *env, jclass c) { jlong init_ = (jlong) (intptr_t) zsys_init (); return init_; }
int main (int argc, char *argv []) { puts (PRODUCT); puts (COPYRIGHT); puts (NOWARRANTY); int argn = 1; bool verbose = false; bool force_foreground = false; if (argc > argn && streq (argv [argn], "-v")) { verbose = true; argn++; } if (argc > argn && streq (argv [argn], "-f")) { force_foreground = true; argn++; } if (argc > argn && streq (argv [argn], "-h")) { puts ("Usage: malamute [ -v ] [ -f ] [ -h | config-file ]"); puts (" Default config-file is 'malamute.cfg'"); return 0; } // Collect configuration file name const char *config_file = "malamute.cfg"; if (argc > argn) { config_file = argv [argn]; argn++; } zsys_init (); // Keep old behavior unless specified otherwise. if (!getenv ("ZSYS_LOGSYSTEM")) { zsys_set_logsystem(true); } zsys_set_pipehwm (0); zsys_set_sndhwm (0); zsys_set_rcvhwm (0); // Load config file for our own use here zsys_info ("loading configuration from '%s'...", config_file); zconfig_t *config = zconfig_load (config_file); if (!config) { zsys_info ("'%s' is missing, creating with defaults:", config_file); config = zconfig_new ("root", NULL); zconfig_put (config, "server/timeout", "5000"); zconfig_put (config, "server/background", "0"); zconfig_put (config, "server/workdir", "."); zconfig_put (config, "server/verbose", "0"); zconfig_put (config, "mlm_server/security/mechanism", "null"); zconfig_put (config, "mlm_server/bind/endpoint", MLM_DEFAULT_ENDPOINT); zconfig_print (config); zconfig_save (config, config_file); } // Do we want to run broker in the background? int as_daemon = !force_foreground && atoi (zconfig_resolve (config, "server/background", "0")); const char *workdir = zconfig_resolve (config, "server/workdir", "."); if (as_daemon) { zsys_info ("switching Malamute to background..."); if (zsys_daemonize (workdir)) return -1; } // Switch to user/group to run process under, if any if (zsys_run_as ( zconfig_resolve (config, "server/lockfile", NULL), zconfig_resolve (config, "server/group", NULL), zconfig_resolve (config, "server/user", NULL))) return -1; // Install authenticator (NULL or PLAIN) zactor_t *auth = zactor_new (zauth, NULL); assert (auth); if (verbose || atoi (zconfig_resolve (config, "server/auth/verbose", "0"))) { zstr_sendx (auth, "VERBOSE", NULL); zsock_wait (auth); } // Do PLAIN password authentication if requested const char *passwords = zconfig_resolve (config, "server/auth/plain", NULL); if (passwords) { zstr_sendx (auth, "PLAIN", passwords, NULL); zsock_wait (auth); } // Start Malamute server instance zactor_t *server = zactor_new (mlm_server, "Malamute"); if (verbose) zstr_send (server, "VERBOSE"); zstr_sendx (server, "LOAD", config_file, NULL); // Accept and print any message back from server while (true) { char *message = zstr_recv (server); if (message) { puts (message); free (message); } else { puts ("interrupted"); break; } } // Shutdown all services zactor_destroy (&server); zactor_destroy (&auth); // Destroy config tree zconfig_destroy (&config); #if defined (__WINDOWS__) zsys_shutdown (); #endif return 0; }