12314336845

Committed 13 Dec 2024 10:55AM UTC coverage: 80.956% (-0.06%) from 81.013%

Build # 12314336845

Build Type

Pull #1012

github

Committed by

web-flow

Commit Message

Merge bb0a7370e into c31e3e539

Pull Request Pull Request #1012: Fix peer ip error log

Run Details

7 of 8 new or added lines in 3 files covered. (87.5%)

4 existing lines in 3 files now uncovered.

5386 of 6653 relevant lines covered (80.96%)

1102.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.56

/src/controller/proxy_monitor.c

/*
 * Copyright Contributors to the Eclipse BlueChi project
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */
#include "libbluechi/log/log.h"

#include "controller.h"
#include "job.h"
#include "monitor.h"
#include "node.h"
#include "proxy_monitor.h"

Subscription *create_proxy_monitor_subscription(ProxyMonitor *monitor, const char *node) {
        Subscription *subscription = subscription_new(node);
        if (subscription == NULL) {
                return NULL;
        }

        subscription->monitor = monitor; /* Weak ref to avoid circular dep */
        subscription->free_monitor = NULL;

        subscription->handle_unit_new = proxy_monitor_on_unit_new;
        subscription->handle_unit_removed = proxy_monitor_on_unit_removed;
        subscription->handle_unit_state_changed = proxy_monitor_on_unit_state_changed;
        subscription->handle_unit_property_changed = proxy_monitor_on_unit_property_changed;

        return subscription;
}

ProxyMonitor *proxy_monitor_new(
                Node *node, const char *target_node_name, const char *unit_name, const char *proxy_object_path) {
        _cleanup_proxy_monitor_ ProxyMonitor *monitor = malloc0(sizeof(ProxyMonitor));
        if (monitor == NULL) {
                return NULL;
        }

        monitor->ref_count = 1;
        monitor->node = node;

        monitor->unit_name = strdup(unit_name);
        if (monitor->unit_name == NULL) {
                return NULL;
        }

        monitor->proxy_object_path = strdup(proxy_object_path);
        if (monitor->proxy_object_path == NULL) {
                return NULL;
        }

        monitor->subscription = create_proxy_monitor_subscription(monitor, target_node_name);
        if (monitor->subscription == NULL) {
                return NULL;
        }

        if (!subscription_add_unit(monitor->subscription, unit_name)) {
                return NULL;
        }

        return steal_pointer(&monitor);
}

ProxyMonitor *proxy_monitor_ref(ProxyMonitor *monitor) {
        monitor->ref_count++;
        return monitor;
}

static void proxy_monitor_drop_dep(ProxyMonitor *monitor);

void proxy_monitor_unref(ProxyMonitor *monitor) {
        monitor->ref_count--;
        if (monitor->ref_count != 0) {
                return;
        }

        if (monitor->target_node) {
                proxy_monitor_drop_dep(monitor);
                node_unref(monitor->target_node);
        }

        if (monitor->subscription) {
                subscription_unref(monitor->subscription);
        }

        free_and_null(monitor->unit_name);
        free_and_null(monitor->proxy_object_path);
        free(monitor);
}

int proxy_monitor_set_target_node(ProxyMonitor *monitor, Node *target_node) {
        monitor->target_node = node_ref(target_node);

        int res = node_add_proxy_dependency(target_node, monitor->unit_name);
        if (res < 0) {
                return res;
        }
        monitor->added_dep = true;
        return 0;
}

static void proxy_monitor_drop_dep(ProxyMonitor *monitor) {
        if (monitor->added_dep) {
                int res = node_remove_proxy_dependency(monitor->target_node, monitor->unit_name);
                if (res < 0) {
                        bc_log_error("Failed to remove proxy dependency");
                }
                monitor->added_dep = false;
        }
}

void proxy_monitor_close(ProxyMonitor *monitor) {
        proxy_monitor_drop_dep(monitor);
}

int proxy_monitor_on_unit_new(
                UNUSED void *userdata, UNUSED const char *node, UNUSED const char *unit, const char *reason) {
        ProxyMonitor *monitor = (ProxyMonitor *) userdata;
        bc_log_debugf("ProxyMonitor processing unit new %s %s %s", node, unit, reason);
        proxy_monitor_send_new(monitor, reason);
        return 0;
}

int proxy_monitor_on_unit_state_changed(
                UNUSED void *userdata,
                UNUSED const char *node,
                UNUSED const char *unit,
                const char *active_state,
                const char *substate,
                const char *reason) {
        ProxyMonitor *monitor = (ProxyMonitor *) userdata;

        bc_log_debugf("ProxyMonitor processing unit state changed %s %s %s %s %s",
                      node,
                      unit,
                      active_state,
                      substate,
                      reason);
        proxy_monitor_send_state_changed(monitor, active_state, substate, reason);

        return 0;
}

int proxy_monitor_on_unit_removed(
                UNUSED void *userdata, UNUSED const char *node, UNUSED const char *unit, const char *reason) {
        ProxyMonitor *monitor = (ProxyMonitor *) userdata;
        bc_log_debugf("ProxyMonitor processing unit removed %s %s %s", node, unit, reason);
        proxy_monitor_send_removed(monitor, reason);
        return 0;
}

int proxy_monitor_on_unit_property_changed(
                UNUSED void *userdata,
                UNUSED const char *node,
                UNUSED const char *unit,
                UNUSED const char *interface,
                UNUSED sd_bus_message *m) {
        return 0;
}

static int proxy_monitor_send_error_callback(sd_bus_message *m, void *userdata, UNUSED sd_bus_error *ret_error) {
        _cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;

        if (sd_bus_message_is_method_error(m, NULL)) {
                bc_log_errorf("Failed to send proxy error on node %s with object path %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              sd_bus_message_get_error(m)->message);
        }
        return 0;
}

void proxy_monitor_send_error(ProxyMonitor *monitor, const char *message) {
        int r = sd_bus_call_method_async(
                        monitor->node->agent_bus,
                        NULL,
                        BC_INTERFACE_BASE_NAME,
                        monitor->proxy_object_path,
                        INTERNAL_PROXY_INTERFACE,
                        "Error",
                        proxy_monitor_send_error_callback,
                        proxy_monitor_ref(monitor),
                        "s",
                        message);
        if (r < 0) {
                bc_log_errorf("Failed to call Error on node %s object %s with message '%s': %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              message,
                              strerror(-r));
        }
}

static int proxy_monitor_send_state_changed_callback(
                sd_bus_message *m, void *userdata, UNUSED sd_bus_error *ret_error) {
        _cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;

        if (sd_bus_message_is_method_error(m, NULL)) {
                bc_log_errorf("Failed to send proxy state change node %s with object path %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              sd_bus_message_get_error(m)->message);
        }
        return 0;
}

int proxy_monitor_send_state_changed(
                ProxyMonitor *monitor, const char *active_state, const char *substate, const char *reason) {
        int r = sd_bus_call_method_async(
                        monitor->node->agent_bus,
                        NULL,
                        BC_INTERFACE_BASE_NAME,
                        monitor->proxy_object_path,
                        INTERNAL_PROXY_INTERFACE,
                        "TargetStateChanged",
                        proxy_monitor_send_state_changed_callback,
                        proxy_monitor_ref(monitor),
                        "sss",
                        active_state,
                        substate,
                        reason);
        if (r < 0) {
                bc_log_errorf("Failed to send proxy state changed on node %s object %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              strerror(-r));
        }
        return r;
}

static int proxy_monitor_send_new_callback(sd_bus_message *m, void *userdata, UNUSED sd_bus_error *ret_error) {
        _cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;

        if (sd_bus_message_is_method_error(m, NULL)) {
                bc_log_errorf("Failed to send proxy new %s with object path %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              sd_bus_message_get_error(m)->message);
        }
        return 0;
}

int proxy_monitor_send_new(ProxyMonitor *monitor, const char *reason) {
        int r = sd_bus_call_method_async(
                        monitor->node->agent_bus,
                        NULL,
                        BC_INTERFACE_BASE_NAME,
                        monitor->proxy_object_path,
                        INTERNAL_PROXY_INTERFACE,
                        "TargetNew",
                        proxy_monitor_send_new_callback,
                        proxy_monitor_ref(monitor),
                        "s",
                        reason);
        if (r < 0) {
                bc_log_errorf("Failed to send proxy new on node %s object %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              strerror(-r));
        }
        return r;
}

static int proxy_monitor_send_removed_callback(sd_bus_message *m, void *userdata, UNUSED sd_bus_error *ret_error) {
        _cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;

        if (sd_bus_message_is_method_error(m, NULL)) {
                bc_log_errorf("Failed to send proxy removed %s with object path %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              sd_bus_message_get_error(m)->message);
        }
        return 0;
}

int proxy_monitor_send_removed(ProxyMonitor *monitor, const char *reason) {
        int r = sd_bus_call_method_async(
                        monitor->node->agent_bus,
                        NULL,
                        BC_INTERFACE_BASE_NAME,
                        monitor->proxy_object_path,
                        INTERNAL_PROXY_INTERFACE,
                        "TargetRemoved",
                        proxy_monitor_send_removed_callback,
                        proxy_monitor_ref(monitor),
                        "s",
                        reason);
        if (r < 0) {
                bc_log_errorf("Failed to send proxy removed on node %s object %s: %s",
                              monitor->node->name,
                              monitor->proxy_object_path,
                              strerror(-r));
        }
        return r;
}

1	/*
2	* Copyright Contributors to the Eclipse BlueChi project
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*/
6	#include "libbluechi/log/log.h"
7
8	#include "controller.h"
9	#include "job.h"
10	#include "monitor.h"
11	#include "node.h"
12	#include "proxy_monitor.h"
13
14	Subscription create_proxy_monitor_subscription(ProxyMonitor monitor, const char *node) {	13✔
15	Subscription *subscription = subscription_new(node);	13✔
16	if (subscription == NULL) {	13✔
17	return NULL;
18	}
19
20	subscription->monitor = monitor; /* Weak ref to avoid circular dep */	13✔
21	subscription->free_monitor = NULL;	13✔
22
23	subscription->handle_unit_new = proxy_monitor_on_unit_new;	13✔
24	subscription->handle_unit_removed = proxy_monitor_on_unit_removed;	13✔
25	subscription->handle_unit_state_changed = proxy_monitor_on_unit_state_changed;	13✔
26	subscription->handle_unit_property_changed = proxy_monitor_on_unit_property_changed;	13✔
27
28	return subscription;	13✔
29	}
30
31	ProxyMonitor *proxy_monitor_new(	13✔
32	Node node, const char target_node_name, const char unit_name, const char proxy_object_path) {
33	_cleanup_proxy_monitor_ ProxyMonitor *monitor = malloc0(sizeof(ProxyMonitor));	13✔
34	if (monitor == NULL) {	13✔
35	return NULL;
36	}
37
38	monitor->ref_count = 1;	13✔
39	monitor->node = node;	13✔
40
41	monitor->unit_name = strdup(unit_name);	13✔
42	if (monitor->unit_name == NULL) {	13✔
43	return NULL;
44	}
45
46	monitor->proxy_object_path = strdup(proxy_object_path);	13✔
47	if (monitor->proxy_object_path == NULL) {	13✔
48	return NULL;
49	}
50
51	monitor->subscription = create_proxy_monitor_subscription(monitor, target_node_name);	13✔
52	if (monitor->subscription == NULL) {	13✔
53	return NULL;
54	}
55
56	if (!subscription_add_unit(monitor->subscription, unit_name)) {	13✔
57	return NULL;
58	}
59
60	return steal_pointer(&monitor);
61	}
62
63	ProxyMonitor proxy_monitor_ref(ProxyMonitor monitor) {	47✔
64	monitor->ref_count++;	47✔
65	return monitor;	47✔
66	}
67
68	static void proxy_monitor_drop_dep(ProxyMonitor *monitor);
69
70	void proxy_monitor_unref(ProxyMonitor *monitor) {	60✔
71	monitor->ref_count--;	60✔
72	if (monitor->ref_count != 0) {	60✔
73	return;
74	}
75
76	if (monitor->target_node) {	13✔
77	proxy_monitor_drop_dep(monitor);	12✔
78	node_unref(monitor->target_node);	12✔
79	}
80
81	if (monitor->subscription) {	13✔
82	subscription_unref(monitor->subscription);	13✔
83	}
84
85	free_and_null(monitor->unit_name);	13✔
86	free_and_null(monitor->proxy_object_path);	13✔
87	free(monitor);	13✔
88	}
89
90	int proxy_monitor_set_target_node(ProxyMonitor monitor, Node target_node) {	12✔
91	monitor->target_node = node_ref(target_node);	12✔
92
93	int res = node_add_proxy_dependency(target_node, monitor->unit_name);	12✔
94	if (res < 0) {	12✔
95	return res;
96	}
97	monitor->added_dep = true;	12✔
98	return 0;	12✔
99	}
100
101	static void proxy_monitor_drop_dep(ProxyMonitor *monitor) {	24✔
102	if (monitor->added_dep) {	24✔
103	int res = node_remove_proxy_dependency(monitor->target_node, monitor->unit_name);	12✔
104	if (res < 0) {	12✔
105	bc_log_error("Failed to remove proxy dependency");	×
106	}
107	monitor->added_dep = false;	12✔
108	}
109	}	24✔
110
111	void proxy_monitor_close(ProxyMonitor *monitor) {	12✔
112	proxy_monitor_drop_dep(monitor);	12✔
113	}	12✔
114
115	int proxy_monitor_on_unit_new(	12✔
116	UNUSED void userdata, UNUSED const char node, UNUSED const char unit, const char reason) {
117	ProxyMonitor monitor = (ProxyMonitor ) userdata;	12✔
118	bc_log_debugf("ProxyMonitor processing unit new %s %s %s", node, unit, reason);	12✔
119	proxy_monitor_send_new(monitor, reason);	12✔
120	return 0;	12✔
121	}
122
123	int proxy_monitor_on_unit_state_changed(	20✔
124	UNUSED void *userdata,
125	UNUSED const char *node,
126	UNUSED const char *unit,
127	const char *active_state,
128	const char *substate,
129	const char *reason) {
130	ProxyMonitor monitor = (ProxyMonitor ) userdata;	20✔
131
132	bc_log_debugf("ProxyMonitor processing unit state changed %s %s %s %s %s",	20✔
133	node,
134	unit,
135	active_state,
136	substate,
137	reason);
138	proxy_monitor_send_state_changed(monitor, active_state, substate, reason);	20✔
139
140	return 0;	20✔
141	}
142
143	int proxy_monitor_on_unit_removed(	2✔
144	UNUSED void userdata, UNUSED const char node, UNUSED const char unit, const char reason) {
145	ProxyMonitor monitor = (ProxyMonitor ) userdata;	2✔
146	bc_log_debugf("ProxyMonitor processing unit removed %s %s %s", node, unit, reason);	2✔
147	proxy_monitor_send_removed(monitor, reason);	2✔
148	return 0;	2✔
149	}
150
151	int proxy_monitor_on_unit_property_changed(	79✔
152	UNUSED void *userdata,
153	UNUSED const char *node,
154	UNUSED const char *unit,
155	UNUSED const char *interface,
156	UNUSED sd_bus_message *m) {
157	return 0;	79✔
158	}
159
160	static int proxy_monitor_send_error_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	1✔
161	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	2✔
162
163	if (sd_bus_message_is_method_error(m, NULL)) {	1✔
164	bc_log_errorf("Failed to send proxy error on node %s with object path %s: %s",	×
165	monitor->node->name,
166	monitor->proxy_object_path,
167	sd_bus_message_get_error(m)->message);
168	}
169	return 0;	2✔
170	}
171
172	void proxy_monitor_send_error(ProxyMonitor monitor, const char message) {	1✔
173	int r = sd_bus_call_method_async(	3✔
174	monitor->node->agent_bus,	1✔
175	NULL,
176	BC_INTERFACE_BASE_NAME,
177	monitor->proxy_object_path,	1✔
178	INTERNAL_PROXY_INTERFACE,
179	"Error",
180	proxy_monitor_send_error_callback,
181	proxy_monitor_ref(monitor),	1✔
182	"s",
183	message);
184	if (r < 0) {	1✔
185	bc_log_errorf("Failed to call Error on node %s object %s with message '%s': %s",	×
186	monitor->node->name,
187	monitor->proxy_object_path,
188	message,
189	strerror(-r));
190	}
191	}	1✔
192
193	static int proxy_monitor_send_state_changed_callback(	20✔
194	sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {
195	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	40✔
196
197	if (sd_bus_message_is_method_error(m, NULL)) {	20✔
198	bc_log_errorf("Failed to send proxy state change node %s with object path %s: %s",	×
199	monitor->node->name,
200	monitor->proxy_object_path,
201	sd_bus_message_get_error(m)->message);
202	}
203	return 0;	40✔
204	}
205
206	int proxy_monitor_send_state_changed(	20✔
207	ProxyMonitor monitor, const char active_state, const char substate, const char reason) {
208	int r = sd_bus_call_method_async(	60✔
209	monitor->node->agent_bus,	20✔
210	NULL,
211	BC_INTERFACE_BASE_NAME,
212	monitor->proxy_object_path,	20✔
213	INTERNAL_PROXY_INTERFACE,
214	"TargetStateChanged",
215	proxy_monitor_send_state_changed_callback,
216	proxy_monitor_ref(monitor),	20✔
217	"sss",
218	active_state,
219	substate,
220	reason);
221	if (r < 0) {	20✔
222	bc_log_errorf("Failed to send proxy state changed on node %s object %s: %s",	×
223	monitor->node->name,
224	monitor->proxy_object_path,
225	strerror(-r));
226	}
227	return r;	20✔
228	}
229
230	static int proxy_monitor_send_new_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	12✔
231	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	24✔
232
233	if (sd_bus_message_is_method_error(m, NULL)) {	12✔
234	bc_log_errorf("Failed to send proxy new %s with object path %s: %s",	×
235	monitor->node->name,
236	monitor->proxy_object_path,
237	sd_bus_message_get_error(m)->message);
238	}
239	return 0;	24✔
240	}
241
242	int proxy_monitor_send_new(ProxyMonitor monitor, const char reason) {	12✔
243	int r = sd_bus_call_method_async(	36✔
244	monitor->node->agent_bus,	12✔
245	NULL,
246	BC_INTERFACE_BASE_NAME,
247	monitor->proxy_object_path,	12✔
248	INTERNAL_PROXY_INTERFACE,
249	"TargetNew",
250	proxy_monitor_send_new_callback,
251	proxy_monitor_ref(monitor),	12✔
252	"s",
253	reason);
254	if (r < 0) {	12✔
255	bc_log_errorf("Failed to send proxy new on node %s object %s: %s",	×
256	monitor->node->name,
257	monitor->proxy_object_path,
258	strerror(-r));
259	}
260	return r;	12✔
261	}
262
263	static int proxy_monitor_send_removed_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	2✔
264	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	4✔
265
266	if (sd_bus_message_is_method_error(m, NULL)) {	2✔
UNCOV 267	bc_log_errorf("Failed to send proxy removed %s with object path %s: %s",	×
268	monitor->node->name,
269	monitor->proxy_object_path,
270	sd_bus_message_get_error(m)->message);
271	}
272	return 0;	4✔
273	}
274
275	int proxy_monitor_send_removed(ProxyMonitor monitor, const char reason) {	2✔
276	int r = sd_bus_call_method_async(	6✔
277	monitor->node->agent_bus,	2✔
278	NULL,
279	BC_INTERFACE_BASE_NAME,
280	monitor->proxy_object_path,	2✔
281	INTERNAL_PROXY_INTERFACE,
282	"TargetRemoved",
283	proxy_monitor_send_removed_callback,
284	proxy_monitor_ref(monitor),	2✔
285	"s",
286	reason);
287	if (r < 0) {	2✔
288	bc_log_errorf("Failed to send proxy removed on node %s object %s: %s",	×
289	monitor->node->name,
290	monitor->proxy_object_path,
291	strerror(-r));
292	}
293	return r;	2✔
294	}

eclipse-bluechi / bluechi / 12314336845

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous