int main(int argc, char **argv)
{
static GOptionEntry options[] = {
{ "load", 'l', 0, G_OPTION_ARG_STRING, &autoload_module, "Module to load (default = bot)", "MODULE" },
{ NULL }
};
autoload_module = NULL;
core_register_options();
args_register(options);
args_execute(argc, argv);
core_preinit(argv[0]);
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
noui_init();
if (autoload_module == NULL)
autoload_module = "bot";
do {
reload = FALSE;
module_load(autoload_module, NULL);
main_loop = g_main_new(TRUE);
g_main_run(main_loop);
g_main_destroy(main_loop);
}
while (reload);
noui_deinit();
return 0;
}
int
servant_cluster(const char *diskname, int mode, const void* argp)
{
enum cluster_type_e cluster_stack = get_cluster_type();
crm_system_name = strdup("sbd:cluster");
cl_log(LOG_INFO, "Monitoring %s cluster health", name_for_cluster_type(cluster_stack));
set_proc_title("sbd: watcher: Cluster");
sbd_membership_connect();
/* stonith_our_uname = cluster.uname; */
/* stonith_our_uuid = cluster.uuid; */
mainloop = g_main_new(FALSE);
notify_timer = g_timeout_add(timeout_loop * 1000, notify_timer_cb, NULL);
mainloop_add_signal(SIGTERM, cluster_shutdown);
mainloop_add_signal(SIGINT, cluster_shutdown);
g_main_run(mainloop);
g_main_destroy(mainloop);
clean_up(0);
return 0; /* never reached */
}
int main(int argc, char **argv)
{
core_init_paths(argc, argv);
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
noui_init();
args_execute(argc, argv);
if (autoload_module == NULL)
autoload_module = "bot";
do {
reload = FALSE;
module_load(autoload_module, NULL);
main_loop = g_main_new(TRUE);
g_main_run(main_loop);
g_main_destroy(main_loop);
}
while (reload);
noui_deinit();
return 0;
}
int main(int argc, char **argv)
{
check_files();
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
#ifdef ENABLE_NLS
/* initialize the i18n stuff */
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
textui_init();
args_execute(argc, argv);
if (!init_screen())
g_error(_("Can't initialize screen handling, quitting.\n"));
textui_finish_init();
main_loop = g_main_new(TRUE);
g_main_run(main_loop);
g_main_destroy(main_loop);
textui_deinit();
#ifdef MEM_DEBUG
ig_mem_profile();
#endif
return 0;
}
int main(int argc, char **argv)
{
static struct poptOption options[] = {
{ "dummy", 'd', POPT_ARG_NONE, &dummy, 0, "Use the dummy terminal mode", NULL },
{ NULL, '\0', 0, NULL }
};
dummy = FALSE;
quitting = FALSE;
core_init_paths(argc, argv);
check_files();
#ifdef WIN32
winsock_init();
#endif
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
#ifdef ENABLE_NLS
/* initialize the i18n stuff */
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
textui_init();
args_register(options);
args_execute(argc, argv);
if (!dummy && !term_init()) {
fprintf(stderr, "Can't initialize screen handling, quitting.\n");
fprintf(stderr, "You can still use the dummy mode with -d parameter\n");
return 1;
}
textui_finish_init();
main_loop = g_main_new(TRUE);
/* Does the same as g_main_run(main_loop), except we
can call our dirty-checker after each iteration */
while (!quitting) {
g_main_iteration(TRUE);
if (reload_config) {
/* SIGHUP received, do /RELOAD */
reload_config = FALSE;
signal_emit("command reload", 1, "");
}
dirty_check();
}
g_main_destroy(main_loop);
textui_deinit();
session_upgrade(); /* if we /UPGRADEd, start the new process */
return 0;
}
int main(int argc, char **argv)
{
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
textui_init();
args_execute(argc, argv);
if (!init_screen())
g_error(_("Can't initialize screen handling, quitting.\n"));
textui_finish_init();
main_loop = g_main_new(TRUE);
g_main_run(main_loop);
g_main_destroy(main_loop);
textui_deinit();
#ifdef MEM_DEBUG
ig_mem_profile();
#endif
return 0;
}
int main(int argc, char **argv)
{
static int version = 0;
static GOptionEntry options[] = {
{ "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, "Use the dummy terminal mode", NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &version, "Display irssi version", NULL },
{ NULL }
};
#ifdef USE_GC
g_mem_set_vtable(&gc_mem_table);
#endif
core_register_options();
fe_common_core_register_options();
args_register(options);
args_execute(argc, argv);
if (version) {
printf(PACKAGE_TARNAME" " PACKAGE_VERSION" (%d %04d)\n",
IRSSI_VERSION_DATE, IRSSI_VERSION_TIME);
return 0;
}
srand(time(NULL));
dummy = FALSE;
quitting = FALSE;
core_preinit(argv[0]);
check_files();
#ifdef WIN32
winsock_init();
#endif
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
/* setlocale() must be called at the beginning before any calls that
affect it, especially regexps seem to break if they're generated
before this call.
locales aren't actually used for anything else than autodetection
of UTF-8 currently..
furthermore to get the users's charset with g_get_charset() properly
you have to call setlocale(LC_ALL, "") */
setlocale(LC_ALL, "");
textui_init();
if (!dummy && !term_init()) {
fprintf(stderr, "Can't initialize screen handling, quitting.\n");
fprintf(stderr, "You can still use the dummy mode with -d parameter\n");
return 1;
}
textui_finish_init();
main_loop = g_main_new(TRUE);
/* Does the same as g_main_run(main_loop), except we
can call our dirty-checker after each iteration */
while (!quitting) {
#ifdef USE_GC
GC_collect_a_little();
#endif
if (!dummy) term_refresh_freeze();
g_main_iteration(TRUE);
if (!dummy) term_refresh_thaw();
if (reload_config) {
/* SIGHUP received, do /RELOAD */
reload_config = FALSE;
signal_emit("command reload", 1, "");
}
dirty_check();
}
g_main_destroy(main_loop);
textui_deinit();
session_upgrade(); /* if we /UPGRADEd, start the new process */
return 0;
}
int
main(int argc, char **argv)
{
int rc;
int flag;
int argerr = 0;
int option_index = 0;
gboolean shutdown = FALSE;
uid_t pcmk_uid = 0;
gid_t pcmk_gid = 0;
struct rlimit cores;
crm_ipc_t *old_instance = NULL;
qb_ipcs_service_t *ipcs = NULL;
const char *facility = daemon_option("logfacility");
static crm_cluster_t cluster;
crm_log_preinit(NULL, argc, argv);
crm_set_options(NULL, "mode [options]", long_options, "Start/Stop Pacemaker\n");
mainloop_add_signal(SIGHUP, pcmk_ignore);
mainloop_add_signal(SIGQUIT, pcmk_sigquit);
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
case 'V':
crm_bump_log_level(argc, argv);
break;
case 'f':
/* Legacy */
break;
case 'p':
pid_file = optarg;
break;
case '$':
case '?':
crm_help(flag, EX_OK);
break;
case 'S':
shutdown = TRUE;
break;
case 'F':
printf("Pacemaker %s (Build: %s)\n Supporting v%s: %s\n", PACEMAKER_VERSION, BUILD_VERSION,
CRM_FEATURE_SET, CRM_FEATURES);
crm_exit(pcmk_ok);
default:
printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
}
if (argerr) {
crm_help('?', EX_USAGE);
}
setenv("LC_ALL", "C", 1);
setenv("HA_LOGD", "no", 1);
set_daemon_option("mcp", "true");
set_daemon_option("use_logd", "off");
crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);
/* Restore the original facility so that mcp_read_config() does the right thing */
set_daemon_option("logfacility", facility);
crm_debug("Checking for old instances of %s", CRM_SYSTEM_MCP);
old_instance = crm_ipc_new(CRM_SYSTEM_MCP, 0);
crm_ipc_connect(old_instance);
if (shutdown) {
crm_debug("Terminating previous instance");
while (crm_ipc_connected(old_instance)) {
xmlNode *cmd =
create_request(CRM_OP_QUIT, NULL, NULL, CRM_SYSTEM_MCP, CRM_SYSTEM_MCP, NULL);
crm_debug(".");
crm_ipc_send(old_instance, cmd, 0, 0, NULL);
free_xml(cmd);
sleep(2);
}
crm_ipc_close(old_instance);
crm_ipc_destroy(old_instance);
crm_exit(pcmk_ok);
} else if (crm_ipc_connected(old_instance)) {
crm_ipc_close(old_instance);
crm_ipc_destroy(old_instance);
crm_err("Pacemaker is already active, aborting startup");
crm_exit(DAEMON_RESPAWN_STOP);
}
crm_ipc_close(old_instance);
crm_ipc_destroy(old_instance);
if (mcp_read_config() == FALSE) {
crm_notice("Could not obtain corosync config data, exiting");
crm_exit(ENODATA);
}
crm_notice("Starting Pacemaker %s (Build: %s): %s", PACEMAKER_VERSION, BUILD_VERSION, CRM_FEATURES);
mainloop = g_main_new(FALSE);
sysrq_init();
rc = getrlimit(RLIMIT_CORE, &cores);
if (rc < 0) {
crm_perror(LOG_ERR, "Cannot determine current maximum core size.");
} else {
if (cores.rlim_max == 0 && geteuid() == 0) {
cores.rlim_max = RLIM_INFINITY;
} else {
crm_info("Maximum core file size is: %lu", (unsigned long)cores.rlim_max);
}
cores.rlim_cur = cores.rlim_max;
rc = setrlimit(RLIMIT_CORE, &cores);
if (rc < 0) {
crm_perror(LOG_ERR,
"Core file generation will remain disabled."
" Core files are an important diagnositic tool,"
" please consider enabling them by default.");
}
#if 0
/* system() is not thread-safe, can't call from here
* Actually, its a pretty hacky way to try and achieve this anyway
*/
if (system("echo 1 > /proc/sys/kernel/core_uses_pid") != 0) {
crm_perror(LOG_ERR, "Could not enable /proc/sys/kernel/core_uses_pid");
}
#endif
}
rc = pcmk_ok;
if (crm_user_lookup(CRM_DAEMON_USER, &pcmk_uid, &pcmk_gid) < 0) {
crm_err("Cluster user %s does not exist, aborting Pacemaker startup", CRM_DAEMON_USER);
crm_exit(ENOKEY);
}
mkdir(CRM_STATE_DIR, 0750);
mcp_chown(CRM_STATE_DIR, pcmk_uid, pcmk_gid);
/* Used to store core files in */
crm_build_path(CRM_CORE_DIR, 0775);
mcp_chown(CRM_CORE_DIR, pcmk_uid, pcmk_gid);
/* Used to store blackbox dumps in */
crm_build_path(CRM_BLACKBOX_DIR, 0755);
mcp_chown(CRM_BLACKBOX_DIR, pcmk_uid, pcmk_gid);
/* Used to store policy engine inputs in */
crm_build_path(PE_STATE_DIR, 0755);
mcp_chown(PE_STATE_DIR, pcmk_uid, pcmk_gid);
/* Used to store the cluster configuration */
crm_build_path(CRM_CONFIG_DIR, 0755);
mcp_chown(CRM_CONFIG_DIR, pcmk_uid, pcmk_gid);
/* Resource agent paths are constructed by the lrmd */
ipcs = mainloop_add_ipc_server(CRM_SYSTEM_MCP, QB_IPC_NATIVE, &mcp_ipc_callbacks);
if (ipcs == NULL) {
crm_err("Couldn't start IPC server");
crm_exit(EIO);
}
/* Allows us to block shutdown */
if (cluster_connect_cfg(&local_nodeid) == FALSE) {
crm_err("Couldn't connect to Corosync's CFG service");
crm_exit(ENOPROTOOPT);
}
if(pcmk_locate_sbd() > 0) {
setenv("PCMK_watchdog", "true", 1);
} else {
setenv("PCMK_watchdog", "false", 1);
}
find_and_track_existing_processes();
cluster.destroy = mcp_cpg_destroy;
cluster.cpg.cpg_deliver_fn = mcp_cpg_deliver;
cluster.cpg.cpg_confchg_fn = mcp_cpg_membership;
crm_set_autoreap(FALSE);
if(cluster_connect_cpg(&cluster) == FALSE) {
crm_err("Couldn't connect to Corosync's CPG service");
rc = -ENOPROTOOPT;
}
if (rc == pcmk_ok && is_corosync_cluster()) {
/* Keep the membership list up-to-date for crm_node to query */
if(cluster_connect_quorum(mcp_quorum_callback, mcp_quorum_destroy) == FALSE) {
rc = -ENOTCONN;
}
}
#if SUPPORT_CMAN
if (rc == pcmk_ok && is_cman_cluster()) {
init_cman_connection(mcp_cman_dispatch, mcp_cman_destroy);
}
#endif
if(rc == pcmk_ok) {
local_name = get_local_node_name();
update_node_processes(local_nodeid, local_name, get_process_list());
mainloop_add_signal(SIGTERM, pcmk_shutdown);
mainloop_add_signal(SIGINT, pcmk_shutdown);
init_children_processes();
crm_info("Starting mainloop");
g_main_run(mainloop);
}
if (ipcs) {
crm_trace("Closing IPC server");
mainloop_del_ipc_server(ipcs);
ipcs = NULL;
}
g_main_destroy(mainloop);
cluster_disconnect_cpg(&cluster);
cluster_disconnect_cfg();
crm_info("Exiting %s", crm_system_name);
return crm_exit(rc);
}
int main(int argc, char **argv)
{
static int version = 0;
static GOptionEntry options[] = {
{ "version", 'v', 0, G_OPTION_ARG_NONE, &version, "Display Irssi version", NULL },
{ NULL }
};
int loglev;
core_register_options();
fe_common_core_register_options();
args_register(options);
args_execute(argc, argv);
if (version) {
printf(PACKAGE_TARNAME" " PACKAGE_VERSION" (%d %04d)\n",
IRSSI_VERSION_DATE, IRSSI_VERSION_TIME);
return 0;
}
srand(time(NULL));
quitting = FALSE;
core_preinit(argv[0]);
check_files();
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
/* setlocale() must be called at the beginning before any calls that
affect it, especially regexps seem to break if they're generated
before this call.
locales aren't actually used for anything else than autodetection
of UTF-8 currently..
furthermore to get the users's charset with g_get_charset() properly
you have to call setlocale(LC_ALL, "") */
setlocale(LC_ALL, "");
/* Temporarily raise the fatal level to abort on config errors. */
loglev = g_log_set_always_fatal(G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL);
textui_init();
if (!term_init()) {
fprintf(stderr, "Can't initialize screen handling.\n");
return 1;
}
g_log_set_always_fatal(loglev);
textui_finish_init();
main_loop = g_main_new(TRUE);
/* Does the same as g_main_run(main_loop), except we
can call our dirty-checker after each iteration */
while (!quitting) {
if (reload_config) {
/* SIGHUP received, do /RELOAD */
reload_config = FALSE;
signal_emit("command reload", 1, "");
}
dirty_check();
term_refresh_freeze();
g_main_iteration(TRUE);
term_refresh_thaw();
}
g_main_destroy(main_loop);
textui_deinit();
session_upgrade(); /* if we /UPGRADEd, start the new process */
return 0;
}
int
servant_pcmk(const char *diskname, int mode, const void* argp)
{
int exit_code = 0;
crm_cluster_t crm_cluster;
cl_log(LOG_INFO, "Monitoring Pacemaker health");
set_proc_title("sbd: watcher: Pacemaker");
setenv("PCMK_watchdog", "true", 1);
if(debug == 0) {
/* We don't want any noisy crm messages */
set_crm_log_level(LOG_CRIT);
}
#ifdef SUPPORT_PLUGIN
cluster_stack = get_cluster_type();
if (cluster_stack != pcmk_cluster_classic_ais) {
check_ais = 0;
} else {
check_ais = 1;
cl_log(LOG_INFO, "Legacy plug-in detected, AIS quorum check enabled");
if(is_openais_cluster()) {
crm_cluster.destroy = ais_membership_destroy;
crm_cluster.cpg.cpg_deliver_fn = ais_membership_dispatch;
/* crm_cluster.cpg.cpg_confchg_fn = pcmk_cpg_membership; TODO? */
crm_cluster.cpg.cpg_confchg_fn = NULL;
}
while (!crm_cluster_connect(&crm_cluster)) {
cl_log(LOG_INFO, "Waiting to sign in with cluster ...");
sleep(reconnect_msec / 1000);
}
}
#endif
if (current_cib == NULL) {
cib = cib_new();
do {
exit_code = cib_connect(TRUE);
if (exit_code != 0) {
sleep(reconnect_msec / 1000);
}
} while (exit_code == -ENOTCONN);
if (exit_code != 0) {
clean_up(-exit_code);
}
}
mainloop = g_main_new(FALSE);
mainloop_add_signal(SIGTERM, mon_shutdown);
mainloop_add_signal(SIGINT, mon_shutdown);
timer_id_notify = g_timeout_add(timeout_loop * 1000, mon_timer_notify, NULL);
#ifdef SUPPORT_PLUGIN
if (check_ais) {
timer_id_ais = g_timeout_add(timeout_loop * 1000, mon_timer_ais, NULL);
}
#endif
g_main_run(mainloop);
g_main_destroy(mainloop);
clean_up(0);
return 0; /* never reached */
}
int main(int argc, char **argv)
{
static struct poptOption options[] = {
{ "dummy", 'd', POPT_ARG_NONE, &dummy, 0, "Use the dummy terminal mode", NULL },
{ NULL, '\0', 0, NULL }
};
dummy = FALSE;
quitting = FALSE;
core_init_paths(argc, argv);
check_files();
#ifdef WIN32
winsock_init();
#endif
#ifdef HAVE_SOCKS
SOCKSinit(argv[0]);
#endif
#ifdef ENABLE_NLS
/* initialize the i18n stuff */
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#endif
/* setlocale() must be called at the beginning before any calls that
affect it, especially regexps seem to break if they're generated
before t his call.
locales aren't actually used for anything else than autodetection
of UTF-8 currently.. */
setlocale(LC_CTYPE, "");
textui_init();
args_register(options);
args_execute(argc, argv);
if (!dummy && !term_init()) {
fprintf(stderr, "Can't initialize screen handling, quitting.\n");
fprintf(stderr, "You can still use the dummy mode with -d parameter\n");
return 1;
}
textui_finish_init();
main_loop = g_main_new(TRUE);
/* Does the same as g_main_run(main_loop), except we
can call our dirty-checker after each iteration */
while (!quitting) {
if (!dummy) term_refresh_freeze();
g_main_iteration(TRUE);
if (!dummy) term_refresh_thaw();
if (reload_config) {
/* SIGHUP received, do /RELOAD */
reload_config = FALSE;
signal_emit("command reload", 1, "");
}
dirty_check();
}
g_main_destroy(main_loop);
textui_deinit();
session_upgrade(); /* if we /UPGRADEd, start the new process */
return 0;
}
