monitor.c

系统任务管理器

	{
	if (!gkrellm_sys_battery_init())
		return NULL;
	return &battery_monitor;
	}

/* ======================================================= */

typedef struct
	{
	gboolean	changed;
	gint		type;

	gchar		*path;			/* Pathname to sensor data or device file */

	gchar		*id_name;		/* These 4 are unique sensor identification */
	gint		id;				/*   of a particular sensor type */
	gint		iodev;			/* One or any combination may be used. */
	gint		inter;

	gchar		*vref;
	gchar		*default_label;
	gint		group;

	gfloat		factor;
	gfloat		offset;
	gfloat		raw_value;
	}
	Sensor;

static GList	*sensors_list;

static gboolean thread_busy,
				sensors_need_serve;

static gpointer
read_sensors(void *data)
	{
	GList		*list;
	Sensor		*sensor;
	gfloat		tmp;
	gboolean	need_serve = FALSE;

	for (list = sensors_list; list; list = list->next)
		{
		sensor = (Sensor *) list->data;
		tmp = sensor->raw_value;
		if (sensor->type == SENSOR_TEMPERATURE)
			gkrellm_sys_sensors_get_temperature(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		else if (sensor->type == SENSOR_FAN)
			gkrellm_sys_sensors_get_fan(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		else if (sensor->type == SENSOR_VOLTAGE)
			gkrellm_sys_sensors_get_voltage(sensor->path, sensor->id,
				sensor->iodev, sensor->inter, &sensor->raw_value);
		if (sensor->raw_value != tmp)
			{
			sensor->changed = TRUE;
			need_serve = TRUE;
			}
		else
			sensor->changed = FALSE;
		}
	thread_busy = FALSE;
	sensors_need_serve = need_serve; /* Thread, so set after data collected */

	return NULL;
	}

static void
run_sensors_thread(void)
	{
#if GLIB_CHECK_VERSION(2,0,0)
	if (thread_busy)
		return;
	thread_busy = TRUE;
	g_thread_create(read_sensors, NULL, FALSE, NULL);
#else
	read_sensors(NULL);
#endif
	}


void
gkrellm_sensors_update_volt_order_base(void)
	{
	}

void
gkrellm_sensors_set_group(gpointer sr, gint group)
	{
	Sensor	*sensor = (Sensor *) sr;

	if (sensor)
		sensor->group = group;
	}


  /* A sensor within a type is uniquely identified by its id_name.
  |  A sysdep interface may additionally use any of the triple integer
  |  set (id, iodev, inter) for internal identification.
  |  Monitor code here uses path to read the sensor values, but id_name is only
  |  passed to the client since that is all that is needed for identification
  |  (the client is no longer interfacing to sysdep code).
  */
gpointer
gkrellm_sensors_add_sensor(gint type, gchar *sensor_path, gchar *id_name,
		gint id, gint iodev, gint inter,
		gfloat factor, gfloat offset, gchar *vref, gchar *default_label)
	{
	Sensor	*sensor;

	if (!id_name || !*id_name || type < 0 || type > 2)
		return NULL;

	sensor = g_new0(Sensor, 1);
	sensor->id_name = g_strdup(id_name);

	if (sensor_path)
		sensor->path = g_strdup(sensor_path);
	else
		sensor->path = g_strdup(id_name);

	sensor->vref = g_strdup(vref ? vref : "NONE");
	sensor->default_label = g_strdup(default_label ? default_label : "NONE");

	sensor->factor = factor;
	sensor->offset = offset;
	sensor->type = type;
	sensor->id = id;
	sensor->iodev = iodev;
	sensor->inter = inter;
	sensors_list = g_list_append(sensors_list, sensor);
	return sensor;
	}

static void
update_sensors(GkrellmdMonitor *mon, gboolean first_update)
	{
	if (sensors_need_serve)		/* Asynchronously set in thread */
		gkrellmd_need_serve(mon);
	sensors_need_serve = FALSE;

	if (!GK.five_second_tick && !first_update)
		return;
	if (first_update)
		read_sensors(NULL);		/* No thread on first read */
	else
		run_sensors_thread();
	}

static void
serve_sensors_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	Sensor			*sr;
	GList			*list;
	gchar			buf[128];
	gboolean		sensor_disk_ok;

	gkrellmd_set_serve_name(mon, "sensors");
	sensor_disk_ok = gkrellmd_check_client_version(mon, 2,2,0);
	for (list = sensors_list; list; list = list->next)
		{
		sr = (Sensor *) list->data;
		if (sr->group == SENSOR_GROUP_DISK && !sensor_disk_ok)
			continue;
		if (sr->changed || first_serve)
			{
			sprintf(buf, "%d \"%s\" %d %d %d %.2f\n",
					sr->type, sr->id_name,
					sr->id, sr->iodev, sr->inter, sr->raw_value);
			gkrellmd_serve_data(mon, buf);
			}
		}
	}

static void
serve_sensors_setup(GkrellmdMonitor *mon)
	{
	GkrellmdClient	*client = mon->privat->client;
	GList			*list;
	Sensor			*s;
	gchar			buf[256];
	gboolean		sensor_disk_ok;

	gkrellmd_send_to_client(client, "<sensors_setup>\n");
	sensor_disk_ok = gkrellmd_check_client_version(mon, 2,2,0);
	for (list = sensors_list; list; list = list->next)
		{
		s = (Sensor *) list->data;
		if (s->group == SENSOR_GROUP_DISK && !sensor_disk_ok)
			continue;
		if (sensor_disk_ok)
			sprintf(buf, "%d \"%s\" %d %d %d %.4f %.4f \"%s\" \"%s\" %d\n",
					s->type, s->id_name,
					s->id, s->iodev, s->inter,
					s->factor, s->offset, s->vref, s->default_label, s->group);
		else
			sprintf(buf, "%d \"%s\" %d %d %d %.4f %.4f \"%s\" \"%s\"\n",
					s->type, s->id_name,
					s->id, s->iodev, s->inter,
					s->factor, s->offset, s->vref, s->default_label);
		gkrellmd_send_to_client(client, buf);
		}
	}

static GkrellmdMonitor sensors_monitor =
	{
	"sensors",
	update_sensors,
	serve_sensors_data,
	serve_sensors_setup
	};

static GkrellmdMonitor *
init_sensors_monitor(void)
	{
	if (!gkrellm_sys_sensors_init())
		return NULL;
	return &sensors_monitor;
	}

/* ======================================================= */
static time_t	base_uptime,
				up_seconds;
static gulong	up_minutes = -1;

void
gkrellm_uptime_set_base_uptime(time_t base)
	{
	base_uptime = base;
	}

static void
update_uptime(GkrellmdMonitor *mon, gboolean first_update)
	{
	gint	prev_up;

	if (GK.ten_second_tick || up_minutes < 0 || first_update)
		{
		prev_up = up_minutes;
		up_seconds = gkrellm_sys_uptime_read_uptime();
		if (up_seconds > 0)
			up_minutes = (gint) (up_seconds / 60);
		else
			up_minutes = (gint)(time(0) - _GK.start_time + base_uptime) / 60;
		if (up_minutes != prev_up)
			gkrellmd_need_serve(mon);
		}
	}

static void
serve_uptime_data(GkrellmdMonitor *mon, gboolean first_serve)
	{
	gchar	buf[128];

	gkrellmd_set_serve_name(mon, "uptime");
	snprintf(buf, sizeof(buf), "%lu\n", (gulong) up_minutes);
	gkrellmd_serve_data(mon, buf);
	}

static GkrellmdMonitor uptime_monitor =
	{
	"uptime",
	update_uptime,
	serve_uptime_data,
	NULL
	};

static GkrellmdMonitor *
init_uptime_monitor(void)
	{
	if (!gkrellm_sys_uptime_init())
		return NULL;
	return &uptime_monitor;
	}

/* ======================================================= */
static void
send_time(GkrellmdClient *client)
	{
	struct tm	*t;
	gchar		buf[128];

	t = &gkrellmd_current_tm;
	sprintf(buf, "<time>\n%d %d %d %d %d %d %d %d %d\n",
		t->tm_sec, t->tm_min, t->tm_hour,
		t->tm_mday, t->tm_mon, t->tm_year,
		t->tm_wday, t->tm_yday, t->tm_isdst);
	gkrellmd_send_to_client(client, buf);
	}

/* ======================================================= */

void
gkrellmd_plugin_serve_setup(GkrellmdMonitor *mon, gchar *name, gchar *line)
	{
	GkrellmdClient	*client = mon->privat->client;
	gchar			buf[256];

	if (!mon || !name || !line)
		return;
	gkrellmd_send_to_client(client, "<plugin_setup>\n");
	snprintf(buf, sizeof(buf), "%s %s\n", name, line);
	gkrellmd_send_to_client(client, buf);
	}

static void
add_monitor(GkrellmdMonitor *mon)
	{
	if (!mon)
		return;
	mon->privat = g_new0(GkrellmdMonitorPrivate, 1);
	mon->privat->serve_gstring = g_string_new("");
	gkrellmd_monitor_list = g_list_append(gkrellmd_monitor_list, mon);
	}

void
gkrellmd_load_monitors(void)
	{
	GList			*list;
	GkrellmdMonitor	*mon;

	add_monitor(init_sensors_monitor());
	add_monitor(init_cpu_monitor());
	add_monitor(init_proc_monitor());
	add_monitor(init_disk_monitor());
	add_monitor(init_net_monitor());
	add_monitor(init_inet_monitor());
	add_monitor(init_mem_monitor());
	add_monitor(init_fs_monitor());
	add_monitor(gkrellmd_init_mail_monitor());
	add_monitor(init_battery_monitor());
	add_monitor(init_uptime_monitor());

	list = gkrellmd_plugins_load();
	if (_GK.list_plugins)
		exit(0);
	if (_GK.log_plugins)
		printf("%s\n", plugin_install_log ? plugin_install_log :
				_("No plugins found\n"));
	for (  ; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mon->privat->serve_gstring = g_string_new("");
		mon->privat->is_plugin = TRUE;
		gkrellmd_monitor_list = g_list_append(gkrellmd_monitor_list, mon);
		}
	}

void
gkrellmd_need_serve(GkrellmdMonitor *mon)
	{
	if (mon)
		mon->privat->need_serve = TRUE;
	}

gint
gkrellmd_update_monitors(void)
	{
	GList			*list, *c_list;
	GkrellmdMonitor			*mon;
	GkrellmdMonitorPrivate	*mp;
	GkrellmdClient			*client;
	struct tm				*pCur;
	static time_t			time_prev;
	gchar					buf[64];
	static gboolean			first_update = TRUE;
	static GString			*serve_gstring;

	time(&_GK.time_now);
	GK.second_tick = (_GK.time_now == time_prev) ? FALSE : TRUE;
	time_prev = _GK.time_now;

	if (GK.second_tick)
		{
		pCur = localtime(&_GK.time_now);
		GK.two_second_tick  = ((pCur->tm_sec % 2) == 0) ? TRUE : FALSE;
		GK.five_second_tick = ((pCur->tm_sec % 5) == 0) ? TRUE : FALSE;
		GK.ten_second_tick  = ((pCur->tm_sec % 10) == 0) ? TRUE : FALSE;
		GK.minute_tick = (pCur->tm_min  != gkrellmd_current_tm.tm_min);
		gkrellmd_current_tm = *pCur;
		}
	else
		{
		GK.two_second_tick = FALSE;
		GK.five_second_tick = FALSE;
		GK.ten_second_tick = FALSE;
		GK.minute_tick = FALSE;
		}

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		if (mon->update_monitor)
			(*(mon->update_monitor))(mon, first_update);
		}
	++GK.timer_ticks;
	if (!serve_gstring)
		serve_gstring = g_string_new("");
	for (c_list = gkrellmd_client_list; c_list; c_list = c_list->next)
		{
		client = (GkrellmdClient *) c_list->data;
		client->last_client = !c_list->next;
		if (!client->served)
			gkrellmd_send_to_client(client, "<initial_update>\n");
		for (list = gkrellmd_monitor_list; list; list = list->next)
			{
			mon = (GkrellmdMonitor *) list->data;
			mp = mon->privat;
			if (!mon->serve_data || (!mp->need_serve && client->served))
				continue;
			mp->client = client;
			mp->serve_name_sent = FALSE;
			(*(mon->serve_data))(mon, client->served ? FALSE : TRUE);
			if (mp->serve_gstring->len > 0)
				{
				serve_gstring =
					g_string_append(serve_gstring, mp->serve_gstring->str);
				mp->serve_gstring = g_string_truncate(mp->serve_gstring, 0);
				}
			}
		gkrellmd_send_to_client(client, serve_gstring->str);
		serve_gstring = g_string_truncate(serve_gstring, 0);
		
		if (GK.minute_tick || !client->served)
			send_time(client);
		else if (GK.second_tick)
			{
			sprintf(buf, "<.%d>\n", gkrellmd_current_tm.tm_sec);
			gkrellmd_send_to_client(client, buf);
			}

		if (!client->served)
			gkrellmd_send_to_client(client, "</initial_update>\n");
		client->served = TRUE;
		}

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mp = mon->privat;
		mp->need_serve = FALSE;
		}

	for (list = serveflag_done_list; list; list = list->next)
		*((gboolean *) list->data) = FALSE;

	first_update = FALSE;
	return TRUE;
	}

void
gkrellmd_serve_setup(GkrellmdClient *client)
	{
	GList			*list;
	GkrellmdMonitor	*mon;
	struct lconv	*lc;
	gchar			buf[32], *s, *name;

	gkrellmd_send_to_client(client, "<gkrellmd_setup>\n");

	s = g_strdup_printf("<version>\ngkrellmd %d.%d.%d%s\n",
				GKRELLMD_VERSION_MAJOR, GKRELLMD_VERSION_MINOR,
				GKRELLMD_VERSION_REV, GKRELLMD_EXTRAVERSION);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	lc = localeconv();
	sprintf(buf, "%c\n", *lc->decimal_point);
	s = g_strconcat("<decimal_point>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		mon->privat->client = client;
		if (mon->serve_setup)
			(*(mon->serve_setup))(mon);
		}
	name = gkrellm_sys_get_host_name();
	s = g_strconcat("<hostname>\n", name, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	name = gkrellm_sys_get_system_name();
	s = g_strconcat("<sysname>\n", name, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	send_time(client);

	gkrellmd_send_to_client(client, "<monitors>\n");
	for (list = gkrellmd_monitor_list; list; list = list->next)
		{
		mon = (GkrellmdMonitor *) list->data;
		sprintf(buf, "%s\n", mon->name);
		gkrellmd_send_to_client(client, buf);
		}

	sprintf(buf, "%d\n", _GK.io_timeout);
	s = g_strconcat("<io_timeout>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	sprintf(buf, "%d\n", _GK.reconnect_timeout);
	s = g_strconcat("<reconnect_timeout>\n", buf, "\n", NULL);
	gkrellmd_send_to_client(client, s);
	g_free(s);

	gkrellmd_send_to_client(client, "</gkrellmd_setup>\n");
	}

void
gkrellmd_client_input_connect(GkrellmdMonitor *mon,
			void (*func)(GkrellmdClient *, gchar *))
	{
	mon->privat->client_input_func = func;
	}

void
gkrellmd_client_read(gint fd, gint nbytes)
	{
	GList					*list;
	GkrellmdClient			*client = NULL;
	GkrellmdMonitor			*mon;
	GkrellmdMonitorPrivate	*mp;
	gchar					buf[513], *s, *e;
	gint					n, buflen;

	for (list = gkrellmd_client_list; list; list = list->next)
		{
		client = (GkrellmdClient *) list->data;
		if (client->fd != fd)
			continue;

		if (!client->input_gstring)
			client->input_gstring = g_string_new("");

		buflen = sizeof(buf) - 1;
		while (nbytes > 0)
			{
			n = (nbytes > buflen) ? buflen : nbytes;
			n = recv(fd, buf, n, 0);
			if (n <= 0)
				break;
			nbytes -= n;
			buf[n] = '\0';
			client->input_gstring =
						g_string_append(client->input_gstring, buf);
			}
		break;
		}
	if (!list)
		return;

	while (gkrellmd_getline_from_gstring(&client->input_gstring,
				buf, sizeof(buf) - 1))
		{
		if (*buf == '<')
			{
			client->input_func = NULL;
			s = buf + 1;
			for (list = gkrellmd_monitor_list; list; list = list->next)
				{
				mon = (GkrellmdMonitor *) list->data;
				mp = mon->privat;
				n = strlen(mp->serve_name);
				e = s + n;
				if (*e == '>' && !strncmp(mp->serve_name, s, n))
					{
					client->input_func = mp->client_input_func;
					break;
					}
				}
			}
		else if (client->input_func)
			(*client->input_func)(client, buf);
//		printf("%s: %s", client->hostname, buf);
		}
	}