X-Git-Url: http://wpitchoune.net/gitweb/?p=psensor-pkg-debian.git;a=blobdiff_plain;f=src%2Fmain.c;h=5686f5be40f37c5e2cd1df0e52bbfa462d73b214;hp=fb534d82cce211f902e723e8e85ba32afb39ff5d;hb=3361fda8735c65887a859c9faf287cb105ae6bc8;hpb=f055e7507526592d3a74c652f5f053701614c9c0 diff --git a/src/main.c b/src/main.c index fb534d8..5686f5b 100644 --- a/src/main.c +++ b/src/main.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010-2012 jeanfi@gmail.com + * Copyright (C) 2010-2016 jeanfi@gmail.com * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -28,66 +28,50 @@ #include -#include "config.h" - -#include "cfg.h" -#include "psensor.h" -#include "graph.h" -#include "ui.h" -#include "ui_sensorlist.h" -#include "ui_color.h" -#include "lmsensor.h" -#include "ui_pref.h" -#include "ui_graph.h" -#include "ui_status.h" - -#ifdef HAVE_UNITY -#include "ui_unity.h" -#endif - -#ifdef HAVE_NVIDIA -#include "nvidia.h" -#endif - -#ifdef HAVE_LIBATIADL -#include "amd.h" -#endif - -#ifdef HAVE_REMOTE_SUPPORT -#include "rsensor.h" -#endif - -#include "ui_appindicator.h" - -#ifdef HAVE_LIBNOTIFY -#include "ui_notify.h" -#endif - -#ifdef HAVE_GTOP -#include "cpu.h" -#endif - -#include "compat.h" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include static const char *program_name; -static void print_version() +static void print_version(void) { printf("psensor %s\n", VERSION); printf(_("Copyright (C) %s jeanfi@gmail.com\n" "License GPLv2: GNU GPL version 2 or later " "\n" - "This is free software: you are free to change and " + "This is free software: you are free to change and" " redistribute it.\n" "There is NO WARRANTY, to the extent permitted by law.\n"), - "2010-2012"); + "2010-2014"); } -static void print_help() +static void print_help(void) { printf(_("Usage: %s [OPTION]...\n"), program_name); - puts(_("psensor is a GTK application for monitoring hardware sensors, " + puts(_("Psensor is a GTK+ application for monitoring hardware sensors, " "including temperatures and fan speeds.")); puts(""); @@ -97,9 +81,11 @@ static void print_help() puts(""); - puts(_(" -u, --url=URL " - "the URL of the psensor-server, example: http://hostname:3131")); - + puts(_( +" -u, --url=URL the URL of the psensor-server,\n" +" example: http://hostname:3131")); + puts(_( +" -n, --new-instance force the creation of a new Psensor application")); puts(""); puts(_(" -d, --debug=LEVEL " @@ -113,96 +99,88 @@ static void print_help() } /* - Updates the size of the sensor values if different than the - configuration. + * Updates the size of the sensor values if different than the + * configuration. */ -void +static void update_psensor_values_size(struct psensor **sensors, struct config *cfg) { - struct psensor **cur; + struct psensor **cur, *s; - cur = sensors; - while (*cur) { - struct psensor *s = *cur; + for (cur = sensors; *cur; cur++) { + s = *cur; if (s->values_max_length != cfg->sensor_values_max_length) psensor_values_resize(s, cfg->sensor_values_max_length); - - cur++; } } -static void log_measures(struct psensor **sensors) +static void *update_measures(void *data) { - if (log_level == LOG_DEBUG) - while (*sensors) { - log_debug("Measure: %s %.2f", - (*sensors)->name, - psensor_get_current_value(*sensors)); - - sensors++; - } -} + struct psensor **sensors; + struct config *cfg; + int period; + struct ui_psensor *ui; -void update_psensor_measures(struct ui_psensor *ui) -{ - struct psensor **sensors = ui->sensors; - struct config *cfg = ui->config; + ui = (struct ui_psensor *)data; + cfg = ui->config; while (1) { - g_mutex_lock(ui->sensors_mutex); + pmutex_lock(&ui->sensors_mutex); + sensors = ui->sensors; if (!sensors) - return; + pthread_exit(NULL); - update_psensor_values_size(sensors, ui->config); + update_psensor_values_size(sensors, cfg); + + lmsensor_psensor_list_update(sensors); - psensor_list_update_measures(sensors); -#ifdef HAVE_REMOTE_SUPPORT remote_psensor_list_update(sensors); -#endif -#ifdef HAVE_NVIDIA nvidia_psensor_list_update(sensors); -#endif -#ifdef HAVE_LIBATIADL amd_psensor_list_update(sensors); -#endif + udisks2_psensor_list_update(sensors); + gtop2_psensor_list_update(sensors); + atasmart_psensor_list_update(sensors); + hddtemp_psensor_list_update(sensors); + + psensor_log_measures(sensors); - log_measures(sensors); + period = cfg->sensor_update_interval; - g_mutex_unlock(ui->sensors_mutex); + pmutex_unlock(&ui->sensors_mutex); - sleep(cfg->sensor_update_interval); + sleep(period); } } static void indicators_update(struct ui_psensor *ui) { - struct psensor **sensor_cur = ui->sensors; - unsigned int attention = 0; + struct psensor **ss, *s; + bool attention; - while (*sensor_cur) { - struct psensor *s = *sensor_cur; + attention = false; + ss = ui->sensors; + while (*ss) { + s = *ss; - if (s->alarm_enabled && s->alarm_raised) { - attention = 1; + if (s->alarm_raised && config_get_sensor_alarm_enabled(s->id)) { + attention = true; break; } - sensor_cur++; + ss++; } -#if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029) if (is_appindicator_supported()) ui_appindicator_update(ui, attention); -#endif if (is_status_supported()) ui_status_update(ui, attention); } -gboolean ui_refresh_thread(gpointer data) +static gboolean ui_refresh_thread(gpointer data) { struct config *cfg; gboolean ret; @@ -211,26 +189,23 @@ gboolean ui_refresh_thread(gpointer data) ret = TRUE; cfg = ui->config; - g_mutex_lock(ui->sensors_mutex); + pmutex_lock(&ui->sensors_mutex); - graph_update(ui->sensors, ui->w_graph, ui->config); + graph_update(ui->sensors, ui_get_graph(), ui->config, ui->main_window); - ui_sensorlist_update(ui); + ui_sensorlist_update(ui, 0); if (is_appindicator_supported() || is_status_supported()) indicators_update(ui); -#ifdef HAVE_UNITY - ui_unity_launcher_entry_update(ui->sensors, - !cfg->unity_launcher_count_disabled); -#endif + ui_unity_launcher_entry_update(ui->sensors); if (ui->graph_update_interval != cfg->graph_update_interval) { ui->graph_update_interval = cfg->graph_update_interval; ret = FALSE; } - g_mutex_unlock(ui->sensors_mutex); + pmutex_unlock(&ui->sensors_mutex); if (ret == FALSE) g_timeout_add(1000 * ui->graph_update_interval, @@ -239,119 +214,95 @@ gboolean ui_refresh_thread(gpointer data) return ret; } -void cb_alarm_raised(struct psensor *sensor, void *data) +static void cb_alarm_raised(struct psensor *sensor, void *data) { -#ifdef HAVE_LIBNOTIFY - if (sensor->enabled) + if (config_get_sensor_alarm_enabled(sensor->id)) { ui_notify(sensor, (struct ui_psensor *)data); -#endif -} - -static void associate_colors(struct psensor **sensors) -{ - /* number of uniq colors */ -#define COLORS_COUNT 8 - - unsigned int colors[COLORS_COUNT][3] = { - {0x0000, 0x0000, 0x0000}, /* black */ - {0xffff, 0x0000, 0x0000}, /* red */ - {0x0000, 0.0000, 0xffff}, /* blue */ - {0x0000, 0xffff, 0x0000}, /* green */ - - {0x7fff, 0x7fff, 0x7fff}, /* grey */ - {0x7fff, 0x0000, 0x0000}, /* dark red */ - {0x0000, 0x0000, 0x7fff}, /* dark blue */ - {0x0000, 0x7fff, 0x0000} /* dark green */ - }; - - struct psensor **sensor_cur = sensors; - int i = 0; - while (*sensor_cur) { - struct color default_color; - color_set(&default_color, - colors[i % COLORS_COUNT][0], - colors[i % COLORS_COUNT][1], - colors[i % COLORS_COUNT][2]); - - (*sensor_cur)->color - = config_get_sensor_color((*sensor_cur)->id, - &default_color); - - sensor_cur++; - i++; + notify_cmd(sensor); } } static void associate_cb_alarm_raised(struct psensor **sensors, struct ui_psensor *ui) { - struct psensor **sensor_cur = sensors; - while (*sensor_cur) { - struct psensor *s = *sensor_cur; + bool ret; + struct psensor *s; + double high_temp; + + high_temp = config_get_default_high_threshold_temperature(); + + while (*sensors) { + s = *sensors; s->cb_alarm_raised = cb_alarm_raised; s->cb_alarm_raised_data = ui; - if (is_temp_type(s->type)) { - s->alarm_limit - = config_get_sensor_alarm_limit(s->id, 60); - s->alarm_enabled - = config_get_sensor_alarm_enabled(s->id); - } else { - s->alarm_limit = 0; - s->alarm_enabled = 0; + ret = config_get_sensor_alarm_high_threshold + (s->id, &s->alarm_high_threshold); + + if (!ret) { + if (s->max == UNKNOWN_DBL_VALUE) { + if (s->type & SENSOR_TYPE_TEMP) + s->alarm_high_threshold = high_temp; + } else { + s->alarm_high_threshold = s->max; + } } - sensor_cur++; + ret = config_get_sensor_alarm_low_threshold + (s->id, &s->alarm_low_threshold); + + if (!ret && s->min != UNKNOWN_DBL_VALUE) + s->alarm_low_threshold = s->min; + + sensors++; } } static void associate_preferences(struct psensor **sensors) { struct psensor **sensor_cur = sensors; + while (*sensor_cur) { char *n; struct psensor *s = *sensor_cur; - s->enabled = config_is_sensor_enabled(s->id); - n = config_get_sensor_name(s->id); - if (n) + if (n) { + free(s->name); s->name = n; + } sensor_cur++; } } -static void log_init() +static void log_init(void) { - char *home, *path, *dir; - - home = getenv("HOME"); + const char *dir; + char *path; - if (!home) - return ; + dir = get_psensor_user_dir(); - dir = malloc(strlen(home)+1+strlen(".psensor")+1); - sprintf(dir, "%s/%s", home, ".psensor"); - mkdir(dir, 0777); + if (!dir) + return; path = malloc(strlen(dir)+1+strlen("log")+1); sprintf(path, "%s/%s", dir, "log"); log_open(path); - free(dir); free(path); } static struct option long_options[] = { - {"version", no_argument, 0, 'v'}, - {"help", no_argument, 0, 'h'}, - {"url", required_argument, 0, 'u'}, - {"debug", required_argument, 0, 'd'}, - {0, 0, 0, 0} + {"version", no_argument, NULL, 'v'}, + {"help", no_argument, NULL, 'h'}, + {"url", required_argument, NULL, 'u'}, + {"debug", required_argument, NULL, 'd'}, + {"new-instance", no_argument, NULL, 'n'}, + {NULL, 0, NULL, 0} }; static gboolean initial_window_show(gpointer data) @@ -376,7 +327,7 @@ static gboolean initial_window_show(gpointer data) return FALSE; } -static void log_glib_info() +static void log_glib_info(void) { log_debug("Compiled with GLib %d.%d.%d", GLIB_MAJOR_VERSION, @@ -389,13 +340,95 @@ static void log_glib_info() glib_micro_version); } +static void cb_activate(GApplication *application, + gpointer data) +{ + ui_window_show((struct ui_psensor *)data); +} + +/* + * Release memory for Valgrind. + */ +static void cleanup(struct ui_psensor *ui) +{ + pmutex_lock(&ui->sensors_mutex); + + log_debug("Cleanup..."); + + nvidia_cleanup(); + amd_cleanup(); + rsensor_cleanup(); + + psensor_list_free(ui->sensors); + ui->sensors = NULL; + + ui_appindicator_cleanup(); + + ui_status_cleanup(); + + pmutex_unlock(&ui->sensors_mutex); + + config_cleanup(); + + log_debug("Cleanup done, closing log"); +} + +/* + * Creates the list of sensors. + * + * 'url': remote psensor server url, null for local monitoring. + */ +static struct psensor **create_sensors_list(const char *url) +{ + struct psensor **sensors; + + if (url) { + if (rsensor_is_supported()) { + rsensor_init(); + sensors = get_remote_sensors(url, 600); + } else { + log_err(_("Psensor has not been compiled with remote " + "sensor support.")); + exit(EXIT_FAILURE); + } + } else { + sensors = malloc(sizeof(struct psensor *)); + *sensors = NULL; + + if (config_is_lmsensor_enabled()) + lmsensor_psensor_list_append(&sensors, 600); + + if (config_is_hddtemp_enabled()) + hddtemp_psensor_list_append(&sensors, 600); + + if (config_is_libatasmart_enabled()) + atasmart_psensor_list_append(&sensors, 600); + + if (config_is_nvctrl_enabled()) + nvidia_psensor_list_append(&sensors, 600); + + if (config_is_atiadlsdk_enabled()) + amd_psensor_list_append(&sensors, 600); + + if (config_is_gtop2_enabled()) + gtop2_psensor_list_append(&sensors, 600); + + if (config_is_udisks2_enabled()) + udisks2_psensor_list_append(&sensors, 600); + } + + associate_preferences(sensors); + + return sensors; +} + int main(int argc, char **argv) { struct ui_psensor ui; - GError *error; - GThread *thread; - int optc, cmdok; + pthread_t thread; + int optc, cmdok, opti, new_instance, ret; char *url = NULL; + GApplication *app; program_name = argv[0]; @@ -406,9 +439,11 @@ int main(int argc, char **argv) textdomain(PACKAGE); #endif + new_instance = 0; + cmdok = 1; - while ((optc = getopt_long(argc, argv, "vhd:u:", long_options, - NULL)) != -1) { + while ((optc = getopt_long(argc, argv, "vhd:u:n", long_options, + &opti)) != -1) { switch (optc) { case 'u': if (optarg) @@ -422,7 +457,10 @@ int main(int argc, char **argv) exit(EXIT_SUCCESS); case 'd': log_level = atoi(optarg); - log_printf(LOG_INFO, _("Enables debug mode.")); + log_info(_("Enables debug mode.")); + break; + case 'n': + new_instance = 1; break; default: cmdok = 0; @@ -438,6 +476,18 @@ int main(int argc, char **argv) log_init(); + app = g_application_new("wpitchoune.psensor", 0); + + g_application_register(app, NULL, NULL); + + if (!new_instance && g_application_get_is_remote(app)) { + g_application_activate(app); + log_warn(_("A Psensor instance already exists.")); + exit(EXIT_SUCCESS); + } + + g_signal_connect(app, "activate", G_CALLBACK(cb_activate), &ui); + log_glib_info(); #if !(GLIB_CHECK_VERSION(2, 31, 0)) /* @@ -448,113 +498,65 @@ int main(int argc, char **argv) g_thread_init(NULL); #endif - gdk_threads_init(); - gtk_init(NULL, NULL); - ui.sensors_mutex = g_mutex_new(); - - config_init(); + pmutex_init(&ui.sensors_mutex); ui.config = config_load(); - psensor_init(); - - if (url) { -#ifdef HAVE_REMOTE_SUPPORT - rsensor_init(); - ui.sensors = get_remote_sensors(url, 600); -#else - fprintf(stderr, - _("ERROR: Not compiled with remote sensor support.\n")); - exit(EXIT_FAILURE); -#endif - } else { - ui.sensors = get_all_sensors(600); -#ifdef HAVE_NVIDIA - ui.sensors = nvidia_psensor_list_add(ui.sensors, 600); -#endif -#ifdef HAVE_LIBATIADL - ui.sensors = amd_psensor_list_add(ui.sensors, 600); -#endif -#ifdef HAVE_GTOP - ui.sensors = cpu_psensor_list_add(ui.sensors, 600); -#endif - } - - associate_preferences(ui.sensors); - associate_colors(ui.sensors); + ui.sensors = create_sensors_list(url); associate_cb_alarm_raised(ui.sensors, &ui); -#if !defined(HAVE_APPINDICATOR) && !defined(HAVE_APPINDICATOR_029) + if (ui.config->slog_enabled) + slog_activate(NULL, + ui.sensors, + &ui.sensors_mutex, + config_get_slog_interval()); + ui_status_init(&ui); -#endif + ui_status_set_visible(1); /* main window */ ui_window_create(&ui); - ui.sensor_box = NULL; - - /* drawing box */ - ui.w_graph = ui_graph_create(&ui); - /* sensor list */ - ui_sensorlist_create(&ui); + ui_enable_alpha_channel(&ui); - thread = g_thread_create((GThreadFunc) update_psensor_measures, - &ui, TRUE, &error); + ret = pthread_create(&thread, NULL, update_measures, &ui); - if (!thread) - g_error_free(error); + if (ret) + log_err(_("Failed to create thread for monitoring sensors")); ui.graph_update_interval = ui.config->graph_update_interval; g_timeout_add(1000 * ui.graph_update_interval, ui_refresh_thread, &ui); -#if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029) ui_appindicator_init(&ui); -#endif - - /* - * show the window as soon as all gtk events have been processed - * in order to ensure that the status icon is attempted to be - * drawn before. If not, there is no way to detect that it is - * visible. - */ - g_idle_add((GSourceFunc)initial_window_show, &ui); + ui_unity_init(); gdk_notify_startup_complete(); + /* + * hack, did not find a cleaner solution. + * wait 30s to ensure that the status icon is attempted to be + * drawn before determining whether the main window must be + * show. + */ + if (ui.config->hide_on_startup) + g_timeout_add(30000, (GSourceFunc)initial_window_show, &ui); + else + initial_window_show(&ui); + /* main loop */ gtk_main(); - g_mutex_lock(ui.sensors_mutex); - - psensor_cleanup(); - -#ifdef HAVE_NVIDIA - nvidia_cleanup(); -#endif -#ifdef HAVE_LIBATIADL - amd_cleanup(); -#endif -#ifdef HAVE_REMOTE_SUPPORT - rsensor_cleanup(); -#endif - - psensor_list_free(ui.sensors); - ui.sensors = NULL; - -#if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029) - ui_appindicator_cleanup(); -#endif - - ui_status_cleanup(); - - g_mutex_unlock(ui.sensors_mutex); - - config_cleanup(); + g_object_unref(app); + cleanup(&ui); + log_debug("Quitting..."); log_close(); + if (url) + free(url); + return 0; }