GCC Code Coverage Report

Line	Branch	Exec	Source
1			/* GATE PROJECT LICENSE:
2			+----------------------------------------------------------------------------+
3			| Copyright(c) 2018-2026, Stefan Meislinger |
4			| All rights reserved. |
5			| |
6			| Redistribution and use in source and binary forms, with or without |
7			| modification, are permitted provided that the following conditions are met:|
8			| |
9			| 1. Redistributions of source code must retain the above copyright notice, |
10			| this list of conditions and the following disclaimer. |
11			| 2. Redistributions in binary form must reproduce the above copyright |
12			| notice, this list of conditions and the following disclaimer in the |
13			| documentation and/or other materials provided with the distribution. |
14			| |
15			| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
16			| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
17			| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
18			| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
19			| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
20			| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
21			| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
22			| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
23			| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
24			| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
25			| THE POSSIBILITY OF SUCH DAMAGE. |
26			+----------------------------------------------------------------------------+
27			*/
28
29			#include "gate/system/services.hpp"
30
31			namespace gate
32			{
33			namespace sys
34			{
35
36			uint32_t const ServiceInfo::Flag_Autostart = GATE_SERVICE_FLAG_AUTOSTART;
37			uint32_t const ServiceInfo::Flag_Disabled = GATE_SERVICE_FLAG_DISABLED;
38
39		✗	ServiceInfo::ServiceInfo(String const& name, String const& description, String const& address, uint32_t flags)
40			{
41		✗	name.copyTo(this->impl.name, sizeof(this->impl.name));
42		✗	description.copyTo(this->impl.description, sizeof(this->impl.description));
43		✗	address.copyTo(this->impl.address, sizeof(this->impl.address));
44		✗	this->impl.flags = flags;
45		✗	}
46		✗	ServiceInfo::ServiceInfo(gate_service_t const& svc)
47			{
48		✗	gate_mem_copy(&this->impl, &svc, sizeof(this->impl));
49		✗	}
50
51		✗	String ServiceInfo::getName() const
52			{
53		✗	return String(this->impl.name);
54			}
55		✗	String ServiceInfo::getDescription() const
56			{
57		✗	return String(this->impl.description);
58			}
59		✗	String ServiceInfo::getAddress() const
60			{
61		✗	return String(this->impl.address);
62			}
63		✗	uint32_t ServiceInfo::getFlags() const
64			{
65		✗	return this->impl.flags;
66			}
67
68
69
70		✗	ServiceConfig::ServiceConfig(String const& name, String const& description, uint32_t flags,
71		✗	String const& command, Array<String> const& dependencies)
72			{
73		✗	name.copyTo(this->impl.name, sizeof(this->impl.name));
74		✗	description.copyTo(this->impl.description, sizeof(this->impl.description));
75		✗	this->impl.flags = flags;
76		✗	command.copyTo(this->impl.command, sizeof(this->impl.command));
77
78		✗	StringBuilder builder(this->impl.dependencies, sizeof(this->impl.dependencies), 0);
79		✗	for (Array<String>::const_iterator it(dependencies.begin()), end(dependencies.end()); ; )
80			{
81		✗	builder << *it;
82		✗	++it;
83		✗	if (it != end)
84			{
85		✗	builder << ",";
86			}
87			else
88			{
89		✗	break;
90			}
91			}
92		✗	}
93		✗	ServiceConfig::ServiceConfig(gate_service_config_t const& cfg)
94			{
95		✗	gate_mem_copy(&this->impl, &cfg, sizeof(cfg));
96		✗	}
97		✗	String ServiceConfig::getName() const
98			{
99		✗	return String(this->impl.name);
100			}
101		✗	String ServiceConfig::getDescription() const
102			{
103		✗	return String(this->impl.description);
104			}
105		✗	uint32_t ServiceConfig::getFlags() const
106			{
107		✗	return this->impl.flags;
108			}
109		✗	String ServiceConfig::getCommand() const
110			{
111		✗	return String(this->impl.command);
112			}
113		✗	Array<String> ServiceConfig::getDependencies() const
114			{
115		✗	ArrayList<String> deps;
116		✗	static StaticString const separator = ",";
117		✗	String text(this->impl.dependencies);
118		✗	String head, tail;
119		✗	while (!text.empty())
120			{
121		✗	if (text.parse(separator, 0, &head, &tail, false))
122			{
123		✗	deps.add(head);
124		✗	text = tail;
125			}
126			else
127			{
128			// last token
129		✗	deps.add(text);
130		✗	text = String();
131			}
132			}
133		✗	return deps.toArray();
134			}
135
136
137
138		✗	static gate_bool_t GATE_CALL ServiceMgr_enum_callback(gate_service_t const* service, void* user_param)
139			{
140		✗	ServiceMgr::EnumCallback const* cb = (ServiceMgr::EnumCallback const*)user_param;
141		✗	GATEXX_TRY_IGNORE({
142			ServiceInfo info(*service);
143			cb->invoke(info);
144			})
145		✗	return true;
146			}
147
148		✗	static gate_bool_t GATE_CALL ServiceMgr_get_services_callback(gate_service_t const* service, void* user_param)
149			{
150		✗	ArrayList<ServiceInfo>* ptrLst = (ArrayList<ServiceInfo>*)user_param;
151		✗	ServiceInfo info(*service);
152		✗	ptrLst->tryAdd(info);
153		✗	return true;
154			}
155
156		✗	void ServiceMgr::enumServices(EnumCallback const& cb)
157			{
158		✗	result_t result = gate_services_enum(&ServiceMgr_enum_callback, (void*)(&cb));
159		✗	GATEXX_CHECK_EXCEPTION(result);
160		✗	}
161		✗	Array<ServiceInfo> ServiceMgr::getServices()
162			{
163		✗	ArrayList<ServiceInfo> lst;
164		✗	result_t result = gate_services_enum(&ServiceMgr_get_services_callback, (void*)(&lst));
165		✗	GATEXX_CHECK_EXCEPTION(result);
166		✗	return lst.toArray();
167			}
168
169		✗	static void GATE_CALL ServiceMgr_message_to_delegate(gate_string_t const* message, void* user_param)
170			{
171		✗	ServiceMgr::MessageCallback const* ptrDelegate = (ServiceMgr::MessageCallback const*)user_param;
172		✗	if (ptrDelegate)
173			{
174		✗	GATEXX_TRY_IGNORE({
175			String text = String::clone(*message);
176			ptrDelegate->invoke(text);
177			});
178			}
179		✗	}
180
181		✗	void ServiceMgr::start(String const& name, MessageCallback const& cb)
182			{
183		✗	result_t result = gate_service_start(name.c_impl(), &ServiceMgr_message_to_delegate, !cb ? NULL : (void*)&cb);
184		✗	GATEXX_CHECK_EXCEPTION(result);
185		✗	}
186		✗	void ServiceMgr::stop(String const& name, uint32_t waitTimeout, bool_t force, MessageCallback const& cb)
187			{
188		✗	result_t result = gate_service_stop(name.c_impl(), waitTimeout, force, &ServiceMgr_message_to_delegate, !cb ? NULL : (void*)&cb);
189		✗	GATEXX_CHECK_EXCEPTION(result);
190		✗	}
191		✗	ServiceConfig ServiceMgr::getConfig(String const& name)
192			{
193		✗	gate_service_config_t cfg = GATE_INIT_EMPTY;
194		✗	result_t result = gate_service_get_config(name.c_impl(), &cfg);
195		✗	GATEXX_CHECK_EXCEPTION(result);
196		✗	return ServiceConfig(cfg);
197			}
198		✗	ServiceMgr::StateEnum ServiceMgr::getStatus(String const& name, String* ptrProcessId)
199			{
200		✗	enumint_t ret = 0;
201		✗	gate_string_t proc = GATE_STRING_INIT_EMPTY;
202		✗	result_t result = gate_service_get_status(name.c_impl(), &ret, &proc);
203		✗	GATEXX_CHECK_EXCEPTION(result);
204		✗	if (ptrProcessId)
205			{
206		✗	*ptrProcessId = String::createFrom(proc);
207			}
208			else
209			{
210		✗	gate_string_release(&proc);
211			}
212		✗	return ServiceMgr::StateEnum(ret);
213			}
214
215		✗	void ServiceMgr::registerHost(String const& name, String const& command, String const& description,
216			uint32_t flags, Array<String> const& dependencies, MessageCallback const& cb)
217			{
218		✗	gate_string_t const* ptr_deps = NULL;
219		✗	String deps;
220		✗	if (!dependencies.empty())
221			{
222		✗	StringBuilder builder;
223		✗	for (Array<String>::const_iterator it(dependencies.begin()), end(dependencies.end()); it != end; )
224			{
225		✗	builder << *it;
226		✗	++it;
227		✗	if (it == end)
228			{
229		✗	break;
230			}
231		✗	builder << ",";
232			}
233		✗	deps = builder.toString();
234		✗	ptr_deps = deps.c_impl();
235			}
236
237		✗	result_t result = gate_service_register(name.c_impl(), command.c_impl(), description.c_impl(), flags, ptr_deps,
238		✗	&ServiceMgr_message_to_delegate, !cb ? NULL : (void*)&cb);
239		✗	GATEXX_CHECK_EXCEPTION(result);
240		✗	}
241		✗	void ServiceMgr::unregisterHost(String const& name, MessageCallback const& cb)
242			{
243		✗	result_t result = gate_service_unregister(name.c_impl(), &ServiceMgr_message_to_delegate, !cb ? NULL : (void*)&cb);
244		✗	GATEXX_CHECK_EXCEPTION(result);
245		✗	}
246
247
248			} // end of namespace sys
249			} // end of namespace gate
250