16142519133

Committed 08 Jul 2025 11:56AM UTC coverage: 74.418% (-8.0%) from 82.434%

Build # 16142519133

Build Type

push

github

Committed by

engelmi

Commit Message

Added epel10 target for copr_build via packit

Signed-off-by: Michael Engel <mengel@redhat.com>

Run Details

5117 of 6876 relevant lines covered (74.42%)

870.33 hits per line

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

79.34

/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) {	10✔
15	Subscription *subscription = subscription_new(node);	10✔
16	if (subscription == NULL) {	10✔
17	return NULL;
18	}
19
20	subscription->monitor = monitor; /* Weak ref to avoid circular dep */	10✔
21	subscription->free_monitor = NULL;	10✔
22
23	subscription->handle_unit_new = proxy_monitor_on_unit_new;	10✔
24	subscription->handle_unit_removed = proxy_monitor_on_unit_removed;	10✔
25	subscription->handle_unit_state_changed = proxy_monitor_on_unit_state_changed;	10✔
26	subscription->handle_unit_property_changed = proxy_monitor_on_unit_property_changed;	10✔
27
28	return subscription;	10✔
29	}
30
31	ProxyMonitor *proxy_monitor_new(	10✔
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));	10✔
34	if (monitor == NULL) {	10✔
35	return NULL;
36	}
37
38	monitor->ref_count = 1;	10✔
39	monitor->node = node;	10✔
40
41	monitor->unit_name = strdup(unit_name);	10✔
42	if (monitor->unit_name == NULL) {	10✔
43	return NULL;
44	}
45
46	monitor->proxy_object_path = strdup(proxy_object_path);	10✔
47	if (monitor->proxy_object_path == NULL) {	10✔
48	return NULL;
49	}
50
51	monitor->subscription = create_proxy_monitor_subscription(monitor, target_node_name);	10✔
52	if (monitor->subscription == NULL) {	10✔
53	return NULL;
54	}
55
56	if (!subscription_add_unit(monitor->subscription, unit_name)) {	10✔
57	return NULL;
58	}
59
60	return steal_pointer(&monitor);
61	}
62
63	ProxyMonitor proxy_monitor_ref(ProxyMonitor monitor) {	31✔
64	monitor->ref_count++;	31✔
65	return monitor;	31✔
66	}
67
68	static void proxy_monitor_drop_dep(ProxyMonitor *monitor);
69
70	void proxy_monitor_unref(ProxyMonitor *monitor) {	41✔
71	monitor->ref_count--;	41✔
72	if (monitor->ref_count != 0) {	41✔
73	return;
74	}
75
76	if (monitor->target_node) {	10✔
77	proxy_monitor_drop_dep(monitor);	7✔
78	node_unref(monitor->target_node);	7✔
79	}
80
81	if (monitor->subscription) {	10✔
82	subscription_unref(monitor->subscription);	10✔
83	}
84
85	free_and_null(monitor->unit_name);	10✔
86	free_and_null(monitor->proxy_object_path);	10✔
87	free(monitor);	10✔
88	}
89
90	int proxy_monitor_set_target_node(ProxyMonitor monitor, Node target_node) {	7✔
91	monitor->target_node = node_ref(target_node);	7✔
92
93	int res = node_add_proxy_dependency(target_node, monitor->unit_name);	7✔
94	if (res < 0) {	7✔
95	return res;
96	}
97	monitor->added_dep = true;	7✔
98	return 0;	7✔
99	}
100
101	static void proxy_monitor_drop_dep(ProxyMonitor *monitor) {	14✔
102	if (monitor->added_dep) {	14✔
103	int res = node_remove_proxy_dependency(monitor->target_node, monitor->unit_name);	7✔
104	if (res < 0) {	7✔
105	bc_log_error("Failed to remove proxy dependency");	×
106	}
107	monitor->added_dep = false;	7✔
108	}
109	}	14✔
110
111	void proxy_monitor_close(ProxyMonitor *monitor) {	7✔
112	proxy_monitor_drop_dep(monitor);	7✔
113	}	7✔
114
115	int proxy_monitor_on_unit_new(	7✔
116	UNUSED void userdata, UNUSED const char node, UNUSED const char unit, const char reason) {
117	ProxyMonitor monitor = (ProxyMonitor ) userdata;	7✔
118	bc_log_debugf("ProxyMonitor processing unit new %s %s %s", node, unit, reason);	7✔
119	proxy_monitor_send_new(monitor, reason);	7✔
120	return 0;	7✔
121	}
122
123	int proxy_monitor_on_unit_state_changed(	14✔
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;	14✔
131
132	bc_log_debugf("ProxyMonitor processing unit state changed %s %s %s %s %s",	14✔
133	node,
134	unit,
135	active_state,
136	substate,
137	reason);
138	proxy_monitor_send_state_changed(monitor, active_state, substate, reason);	14✔
139
140	return 0;	14✔
141	}
142
143	int proxy_monitor_on_unit_removed(	×
144	UNUSED void userdata, UNUSED const char node, UNUSED const char unit, const char reason) {
145	ProxyMonitor monitor = (ProxyMonitor ) userdata;	×
146	bc_log_debugf("ProxyMonitor processing unit removed %s %s %s", node, unit, reason);	×
147	proxy_monitor_send_removed(monitor, reason);	×
148	return 0;	×
149	}
150
151	int proxy_monitor_on_unit_property_changed(	65✔
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;	65✔
158	}
159
160	static int proxy_monitor_send_error_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	3✔
161	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	6✔
162
163	if (sd_bus_message_is_method_error(m, NULL)) {	3✔
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;	3✔
170	}
171
172	void proxy_monitor_send_error(ProxyMonitor monitor, const char message) {	3✔
173	int r = sd_bus_call_method_async(	9✔
174	monitor->node->agent_bus,	3✔
175	NULL,
176	BC_INTERFACE_BASE_NAME,
177	monitor->proxy_object_path,	3✔
178	INTERNAL_PROXY_INTERFACE,
179	"Error",
180	proxy_monitor_send_error_callback,
181	proxy_monitor_ref(monitor),	3✔
182	"s",
183	message);
184	if (r < 0) {	3✔
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	}	3✔
192
193	static int proxy_monitor_send_state_changed_callback(	14✔
194	sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {
195	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	28✔
196
197	if (sd_bus_message_is_method_error(m, NULL)) {	14✔
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;	14✔
204	}
205
206	int proxy_monitor_send_state_changed(	14✔
207	ProxyMonitor monitor, const char active_state, const char substate, const char reason) {
208	int r = sd_bus_call_method_async(	42✔
209	monitor->node->agent_bus,	14✔
210	NULL,
211	BC_INTERFACE_BASE_NAME,
212	monitor->proxy_object_path,	14✔
213	INTERNAL_PROXY_INTERFACE,
214	"TargetStateChanged",
215	proxy_monitor_send_state_changed_callback,
216	proxy_monitor_ref(monitor),	14✔
217	"sss",
218	active_state,
219	substate,
220	reason);
221	if (r < 0) {	14✔
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;	14✔
228	}
229
230	static int proxy_monitor_send_new_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	7✔
231	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	14✔
232
233	if (sd_bus_message_is_method_error(m, NULL)) {	7✔
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;	7✔
240	}
241
242	int proxy_monitor_send_new(ProxyMonitor monitor, const char reason) {	7✔
243	int r = sd_bus_call_method_async(	21✔
244	monitor->node->agent_bus,	7✔
245	NULL,
246	BC_INTERFACE_BASE_NAME,
247	monitor->proxy_object_path,	7✔
248	INTERNAL_PROXY_INTERFACE,
249	"TargetNew",
250	proxy_monitor_send_new_callback,
251	proxy_monitor_ref(monitor),	7✔
252	"s",
253	reason);
254	if (r < 0) {	7✔
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;	7✔
261	}
262
263	static int proxy_monitor_send_removed_callback(sd_bus_message m, void userdata, UNUSED sd_bus_error *ret_error) {	×
264	_cleanup_proxy_monitor_ ProxyMonitor *monitor = userdata;	×
265
266	if (sd_bus_message_is_method_error(m, NULL)) {	×
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;	×
273	}
274
275	int proxy_monitor_send_removed(ProxyMonitor monitor, const char reason) {	×
276	int r = sd_bus_call_method_async(	×
277	monitor->node->agent_bus,	×
278	NULL,
279	BC_INTERFACE_BASE_NAME,
280	monitor->proxy_object_path,	×
281	INTERNAL_PROXY_INTERFACE,
282	"TargetRemoved",
283	proxy_monitor_send_removed_callback,
284	proxy_monitor_ref(monitor),	×
285	"s",
286	reason);
287	if (r < 0) {	×
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;	×
294	}

eclipse-bluechi / bluechi / 16142519133

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