15103039427

Committed 19 May 2025 02:37AM UTC coverage: 66.7% (-12.8%) from 79.465%

Build # 15103039427

Build Type

push

github

Committed by

web-flow

Commit Message

Finally wrote daemon class (#50)

* First becoming of a daemon
(have to comment '-Werror' as it again goes to check build deps)

* Second becoming of a daemon
Add lots of tests (many lack container implementation to work)

Run Details

193 of 424 branches covered (45.52%)

Branch coverage included in aggregate %.

377 of 536 new or added lines in 3 files covered. (70.34%)

5 existing lines in 1 file now uncovered.

1812 of 2582 relevant lines covered (70.18%)

12.61 hits per line

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

64.81

/dasboot/core/daemon/daemon.cpp

#include "daemon.hpp"

#include <dasboot/cru/os.hpp>
#include <messages.pb.h>

#include <fcntl.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>


namespace NDaemon
{

TDaemon::TDaemon(const std::string& address) : SocketAddress(address)
{
        Sock = zmq::socket_t(Ctx, zmq::socket_type::rep);
        Sock.bind(std::string("ipc://") + SocketAddress);
}

TDaemon::TDaemon(const char* address) : SocketAddress(address)
{
        Sock = zmq::socket_t(Ctx, zmq::socket_type::rep);
        Sock.bind(std::string("ipc://") + SocketAddress);
}

TDaemon::~TDaemon()
{
        Sock.close();
        Ctx.close();

        NOs::RemoveFile(SocketAddress);
}

NMessages::TResult TDaemon::GetAndParseRequest()
{
        zmq::message_t request;
        NMessages::TResult result;

        auto res = Sock.recv(request, zmq::recv_flags::none);
        if(!res.has_value())
        {
                throw "Got EAGAIN, exiting";
        }

        if(request.to_string() == "STOP")
        {
                Stop();
        }

        NMessages::TOptionsWrapper wrapper;
        wrapper.ParseFromString(request.to_string());

        switch(wrapper.option_case())
        {
                case NMessages::TOptionsWrapper::OptionCase::kBuildOptions:
                        result = DoBuild(wrapper.buildoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kRunOptions:
                        result = DoRun(wrapper.runoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kStartOptions:
                        result = DoStart(wrapper.startoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kStopOptions:
                        result = DoStop(wrapper.stopoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kPsOptions:
                        result = DoPs(wrapper.psoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kRmOptions:
                        result = DoRm(wrapper.rmoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kExecOptions:
                        result = DoExec(wrapper.execoptions());
                        break;
                case NMessages::TOptionsWrapper::OptionCase::kAttachOptions:
                        result = DoAttach(wrapper.attachoptions());
                        break;
        
                default:
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Unknown request");
        }

        return result;
}

void TDaemon::SendResponse(const NMessages::TResult& response)
{
        zmq::message_t responseString(response.SerializeAsString());
        Sock.send(responseString, zmq::send_flags::none);
}

void TDaemon::Run()
{
        while(true)
        {
                SendResponse(GetAndParseRequest());
        }
}

void TDaemon::Stop()
{
        exit(0);
}

NMessages::TResult TDaemon::DoBuild(const NMessages::TBuildOptions& options)
{
        NMessages::TResult result;

        if(options.has_name())
        {
                if(NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Container with such name already exists");
                }
                else
                {
                        // uint64_t id = NextId++;
                        // NContainer::TContainer container({.id = id});

                        // container.Build();

                        // Containers.emplace(id, std::move(container));

                        // result.set_code(NMessages::ReturnCode::SUCESS);
                        // result.set_text("Container has been successfully built");

                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name given");
        }

        return result;
}

NMessages::TResult TDaemon::DoRun(const NMessages::TRunOptions &options)
{
        NMessages::TResult result;

        if(options.has_name())
        {
                if(NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Container with such name already exists");
                }
                else
                {
                        // uint64_t id = NextId++;
                        // NContainer::TContainer container({.id = id});

                        // container.Build();
                        // container.Exec();

                        // Containers.emplace(id, std::move(container));

                        // result.set_code(NMessages::ReturnCode::SUCESS);
                        // result.set_text("Container has been successfully ran");

                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name given");
        }

        return result;
}

NMessages::TResult TDaemon::DoStart(const NMessages::TStartOptions &options)
{
        NMessages::TResult result;

        if (options.has_id())
        {
                uint64_t id = std::stoull(options.id());
                if (!Containers.contains(id))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such id");
                }
                else
                {
                        // Containers.at(id).Exec();
                        result.set_code(NMessages::ReturnCode::SUCESS);
                        result.set_text("Successfully started container");
                }
        }
        else if (options.has_name())
        {
                if (!NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such name");
                }
                else
                {
                        // Containers.at(NameToId.at(options.name())).Exec();

                        result.set_code(NMessages::ReturnCode::SUCESS);
                        result.set_text("Successfully started container");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name or id given");
        }

        return result;
}

NMessages::TResult TDaemon::DoStop(const NMessages::TStopOptions &options)
{
        NMessages::TResult result;

        if (options.has_id())
        {
                uint64_t id = std::stoull(options.id());
                if (!Containers.contains(id))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such id");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else if (options.has_name())
        {
                if (!NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such name");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name or id given");
        }

        return result;
}

NMessages::TResult TDaemon::DoPs([[maybe_unused]] const NMessages::TPsOptions &options)
{
        NMessages::TResult result;

        MakeString text;
        for(auto& [name, id] : NameToId)
        {
                text << name << " - " << id << "\n";
        }

        result.set_code(NMessages::ReturnCode::SUCESS);
        result.set_text(text);

        return result;
}

NMessages::TResult TDaemon::DoRm(const NMessages::TRmOptions &options)
{
        NMessages::TResult result;

        if(options.has_id())
        {
                if(!Containers.contains(std::stoull(options.id())))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such id");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else if(options.has_name())
        {
                if(!NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such name");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name or id given");
        }        
        
        return result;
}

NMessages::TResult TDaemon::DoExec(const NMessages::TExecOptions & options)
{
        NMessages::TResult result;

        if(options.has_id())
        {
                if(!Containers.contains(std::stoull(options.id())))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such id");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else if(options.has_name())
        {
                if(!NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such name");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name or id given");
        }        

        return result;
}

NMessages::TResult TDaemon::DoAttach(const NMessages::TAttachOptions & options)
{
        NMessages::TResult result;

        if(options.has_id())
        {
                if(!Containers.contains(std::stoull(options.id())))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such id");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else if(options.has_name())
        {
                if(!NameToId.contains(options.name()))
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("No container with such name");
                }
                else
                {
                        result.set_code(NMessages::ReturnCode::ERROR);
                        result.set_text("Not implemented");
                }
        }
        else
        {
                result.set_code(NMessages::ReturnCode::ERROR);
                result.set_text("No name or id given");
        }        

        return result;
}

}; // namespace NDaemon

1	#include "daemon.hpp"
2
3	#include <dasboot/cru/os.hpp>
4	#include <messages.pb.h>
5
6	#include <fcntl.h>
7	#include <stdlib.h>
8	#include <sys/stat.h>
9	#include <unistd.h>
10
11
12	namespace NDaemon
13	{
14
NEW 15	TDaemon::TDaemon(const std::string& address) : SocketAddress(address)	×
NEW 16	{	×
NEW 17	Sock = zmq::socket_t(Ctx, zmq::socket_type::rep);	×
NEW 18	Sock.bind(std::string("ipc://") + SocketAddress);	×
NEW 19	}	×
20
21	TDaemon::TDaemon(const char* address) : SocketAddress(address)	22✔
22	{	22✔
23	Sock = zmq::socket_t(Ctx, zmq::socket_type::rep);	22✔
24	Sock.bind(std::string("ipc://") + SocketAddress);	22✔
25	}	22✔
26
27	TDaemon::~TDaemon()
28	{	22✔
29	Sock.close();	22✔
30	Ctx.close();	22✔
31
32	NOs::RemoveFile(SocketAddress);	22✔
33	}	22✔
34
35	NMessages::TResult TDaemon::GetAndParseRequest()
36	{	1✔
37	zmq::message_t request;	1✔
38	NMessages::TResult result;	1✔
39
40	auto res = Sock.recv(request, zmq::recv_flags::none);	1✔
41	if(!res.has_value())	1!
NEW 42	{	×
NEW 43	throw "Got EAGAIN, exiting";	×
NEW 44	}	×
45
46	if(request.to_string() == "STOP")	1!
NEW 47	{	×
NEW 48	Stop();	×
NEW 49	}	×
50
51	NMessages::TOptionsWrapper wrapper;	1✔
52	wrapper.ParseFromString(request.to_string());	1✔
53
54	switch(wrapper.option_case())	1✔
55	{	1✔
NEW 56	case NMessages::TOptionsWrapper::OptionCase::kBuildOptions:	×
NEW 57	result = DoBuild(wrapper.buildoptions());	×
NEW 58	break;	×
NEW 59	case NMessages::TOptionsWrapper::OptionCase::kRunOptions:	×
NEW 60	result = DoRun(wrapper.runoptions());	×
NEW 61	break;	×
NEW 62	case NMessages::TOptionsWrapper::OptionCase::kStartOptions:	×
NEW 63	result = DoStart(wrapper.startoptions());	×
NEW 64	break;	×
NEW 65	case NMessages::TOptionsWrapper::OptionCase::kStopOptions:	×
NEW 66	result = DoStop(wrapper.stopoptions());	×
NEW 67	break;	×
NEW 68	case NMessages::TOptionsWrapper::OptionCase::kPsOptions:	×
NEW 69	result = DoPs(wrapper.psoptions());	×
NEW 70	break;	×
NEW 71	case NMessages::TOptionsWrapper::OptionCase::kRmOptions:	×
NEW 72	result = DoRm(wrapper.rmoptions());	×
NEW 73	break;	×
NEW 74	case NMessages::TOptionsWrapper::OptionCase::kExecOptions:	×
NEW 75	result = DoExec(wrapper.execoptions());	×
NEW 76	break;	×
NEW 77	case NMessages::TOptionsWrapper::OptionCase::kAttachOptions:	×
NEW 78	result = DoAttach(wrapper.attachoptions());	×
NEW 79	break;	×
80
81	default:	1!
82	result.set_code(NMessages::ReturnCode::ERROR);	1✔
83	result.set_text("Unknown request");	1✔
84	}	1✔
85
86	return result;	1✔
87	}	1✔
88
89	void TDaemon::SendResponse(const NMessages::TResult& response)
NEW 90	{	×
NEW 91	zmq::message_t responseString(response.SerializeAsString());	×
NEW 92	Sock.send(responseString, zmq::send_flags::none);	×
NEW 93	}	×
94
95	void TDaemon::Run()
NEW 96	{	×
NEW 97	while(true)	×
NEW 98	{	×
NEW 99	SendResponse(GetAndParseRequest());	×
NEW 100	}	×
NEW 101	}	×
102
103	void TDaemon::Stop()
NEW 104	{	×
NEW 105	exit(0);	×
NEW 106	}	×
107
108	NMessages::TResult TDaemon::DoBuild(const NMessages::TBuildOptions& options)
109	{	2✔
110	NMessages::TResult result;	2✔
111
112	if(options.has_name())	2✔
113	{	1✔
114	if(NameToId.contains(options.name()))	1!
NEW 115	{	×
NEW 116	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 117	result.set_text("Container with such name already exists");	×
NEW 118	}	×
119	else	1✔
120	{	1✔
121	// uint64_t id = NextId++;
122	// NContainer::TContainer container({.id = id});
123
124	// container.Build();
125
126	// Containers.emplace(id, std::move(container));
127
128	// result.set_code(NMessages::ReturnCode::SUCESS);
129	// result.set_text("Container has been successfully built");
130
131	result.set_code(NMessages::ReturnCode::ERROR);	1✔
132	result.set_text("Not implemented");	1✔
133	}	1✔
134	}	1✔
135	else	1✔
136	{	1✔
137	result.set_code(NMessages::ReturnCode::ERROR);	1✔
138	result.set_text("No name given");	1✔
139	}	1✔
140
141	return result;	2✔
142	}	2✔
143
144	NMessages::TResult TDaemon::DoRun(const NMessages::TRunOptions &options)
145	{	2✔
146	NMessages::TResult result;	2✔
147
148	if(options.has_name())	2✔
149	{	1✔
150	if(NameToId.contains(options.name()))	1!
NEW 151	{	×
NEW 152	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 153	result.set_text("Container with such name already exists");	×
NEW 154	}	×
155	else	1✔
156	{	1✔
157	// uint64_t id = NextId++;
158	// NContainer::TContainer container({.id = id});
159
160	// container.Build();
161	// container.Exec();
162
163	// Containers.emplace(id, std::move(container));
164
165	// result.set_code(NMessages::ReturnCode::SUCESS);
166	// result.set_text("Container has been successfully ran");
167
168	result.set_code(NMessages::ReturnCode::ERROR);	1✔
169	result.set_text("Not implemented");	1✔
170	}	1✔
171	}	1✔
172	else	1✔
173	{	1✔
174	result.set_code(NMessages::ReturnCode::ERROR);	1✔
175	result.set_text("No name given");	1✔
176	}	1✔
177
178	return result;	2✔
179	}	2✔
180
181	NMessages::TResult TDaemon::DoStart(const NMessages::TStartOptions &options)
182	{	3✔
183	NMessages::TResult result;	3✔
184
185	if (options.has_id())	3✔
186	{	1✔
187	uint64_t id = std::stoull(options.id());	1✔
188	if (!Containers.contains(id))	1!
189	{	1✔
190	result.set_code(NMessages::ReturnCode::ERROR);	1✔
191	result.set_text("No container with such id");	1✔
192	}	1✔
NEW 193	else	×
NEW 194	{	×
195	// Containers.at(id).Exec();
NEW 196	result.set_code(NMessages::ReturnCode::SUCESS);	×
NEW 197	result.set_text("Successfully started container");	×
NEW 198	}	×
199	}	1✔
200	else if (options.has_name())	2✔
201	{	1✔
202	if (!NameToId.contains(options.name()))	1!
203	{	1✔
204	result.set_code(NMessages::ReturnCode::ERROR);	1✔
205	result.set_text("No container with such name");	1✔
206	}	1✔
NEW 207	else	×
NEW 208	{	×
209	// Containers.at(NameToId.at(options.name())).Exec();
210
NEW 211	result.set_code(NMessages::ReturnCode::SUCESS);	×
NEW 212	result.set_text("Successfully started container");	×
NEW 213	}	×
214	}	1✔
215	else	1✔
216	{	1✔
217	result.set_code(NMessages::ReturnCode::ERROR);	1✔
218	result.set_text("No name or id given");	1✔
219	}	1✔
220
221	return result;	3✔
222	}	3✔
223
224	NMessages::TResult TDaemon::DoStop(const NMessages::TStopOptions &options)
225	{	3✔
226	NMessages::TResult result;	3✔
227
228	if (options.has_id())	3✔
229	{	1✔
230	uint64_t id = std::stoull(options.id());	1✔
231	if (!Containers.contains(id))	1!
232	{	1✔
233	result.set_code(NMessages::ReturnCode::ERROR);	1✔
234	result.set_text("No container with such id");	1✔
235	}	1✔
NEW 236	else	×
NEW 237	{	×
NEW 238	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 239	result.set_text("Not implemented");	×
NEW 240	}	×
241	}	1✔
242	else if (options.has_name())	2✔
243	{	1✔
244	if (!NameToId.contains(options.name()))	1!
245	{	1✔
246	result.set_code(NMessages::ReturnCode::ERROR);	1✔
247	result.set_text("No container with such name");	1✔
248	}	1✔
NEW 249	else	×
NEW 250	{	×
NEW 251	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 252	result.set_text("Not implemented");	×
NEW 253	}	×
254	}	1✔
255	else	1✔
256	{	1✔
257	result.set_code(NMessages::ReturnCode::ERROR);	1✔
258	result.set_text("No name or id given");	1✔
259	}	1✔
260
261	return result;	3✔
262	}	3✔
263
264	NMessages::TResult TDaemon::DoPs([[maybe_unused]] const NMessages::TPsOptions &options)
265	{	1✔
266	NMessages::TResult result;	1✔
267
268	MakeString text;	1✔
269	for(auto& [name, id] : NameToId)	1!
NEW 270	{	×
NEW 271	text << name << " - " << id << "\n";	×
NEW 272	}	×
273
274	result.set_code(NMessages::ReturnCode::SUCESS);	1✔
275	result.set_text(text);	1✔
276
277	return result;	1✔
278	}	1✔
279
280	NMessages::TResult TDaemon::DoRm(const NMessages::TRmOptions &options)
281	{	3✔
282	NMessages::TResult result;	3✔
283
284	if(options.has_id())	3✔
285	{	1✔
286	if(!Containers.contains(std::stoull(options.id())))	1!
287	{	1✔
288	result.set_code(NMessages::ReturnCode::ERROR);	1✔
289	result.set_text("No container with such id");	1✔
290	}	1✔
NEW 291	else	×
NEW 292	{	×
NEW 293	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 294	result.set_text("Not implemented");	×
NEW 295	}	×
296	}	1✔
297	else if(options.has_name())	2✔
298	{	1✔
299	if(!NameToId.contains(options.name()))	1!
300	{	1✔
301	result.set_code(NMessages::ReturnCode::ERROR);	1✔
302	result.set_text("No container with such name");	1✔
303	}	1✔
NEW 304	else	×
NEW 305	{	×
NEW 306	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 307	result.set_text("Not implemented");	×
NEW 308	}	×
309	}	1✔
310	else	1✔
311	{	1✔
312	result.set_code(NMessages::ReturnCode::ERROR);	1✔
313	result.set_text("No name or id given");	1✔
314	}	1✔
315
316	return result;	3✔
317	}	3✔
318
319	NMessages::TResult TDaemon::DoExec(const NMessages::TExecOptions & options)
320	{	3✔
321	NMessages::TResult result;	3✔
322
323	if(options.has_id())	3✔
324	{	1✔
325	if(!Containers.contains(std::stoull(options.id())))	1!
326	{	1✔
327	result.set_code(NMessages::ReturnCode::ERROR);	1✔
328	result.set_text("No container with such id");	1✔
329	}	1✔
NEW 330	else	×
NEW 331	{	×
NEW 332	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 333	result.set_text("Not implemented");	×
NEW 334	}	×
335	}	1✔
336	else if(options.has_name())	2✔
337	{	1✔
338	if(!NameToId.contains(options.name()))	1!
339	{	1✔
340	result.set_code(NMessages::ReturnCode::ERROR);	1✔
341	result.set_text("No container with such name");	1✔
342	}	1✔
NEW 343	else	×
NEW 344	{	×
NEW 345	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 346	result.set_text("Not implemented");	×
NEW 347	}	×
348	}	1✔
349	else	1✔
350	{	1✔
351	result.set_code(NMessages::ReturnCode::ERROR);	1✔
352	result.set_text("No name or id given");	1✔
353	}	1✔
354
355	return result;	3✔
356	}	3✔
357
358	NMessages::TResult TDaemon::DoAttach(const NMessages::TAttachOptions & options)
359	{	3✔
360	NMessages::TResult result;	3✔
361
362	if(options.has_id())	3✔
363	{	1✔
364	if(!Containers.contains(std::stoull(options.id())))	1!
365	{	1✔
366	result.set_code(NMessages::ReturnCode::ERROR);	1✔
367	result.set_text("No container with such id");	1✔
368	}	1✔
NEW 369	else	×
NEW 370	{	×
NEW 371	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 372	result.set_text("Not implemented");	×
NEW 373	}	×
374	}	1✔
375	else if(options.has_name())	2✔
376	{	1✔
377	if(!NameToId.contains(options.name()))	1!
378	{	1✔
379	result.set_code(NMessages::ReturnCode::ERROR);	1✔
380	result.set_text("No container with such name");	1✔
381	}	1✔
NEW 382	else	×
NEW 383	{	×
NEW 384	result.set_code(NMessages::ReturnCode::ERROR);	×
NEW 385	result.set_text("Not implemented");	×
NEW 386	}	×
387	}	1✔
388	else	1✔
389	{	1✔
390	result.set_code(NMessages::ReturnCode::ERROR);	1✔
391	result.set_text("No name or id given");	1✔
392	}	1✔
393
394	return result;	3✔
395	}	3✔
396
397	}; // namespace NDaemon

KittensBasket / dasboot / 15103039427

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