19969138048

Committed 05 Dec 2025 04:23PM UTC coverage: 64.381% (+0.008%) from 64.373%

Build # 19969138048

Build Type

push

github

Committed by

antonvw

Commit Message

git grep improve

Run Details

18567 of 31609 branches covered (58.74%)

Branch coverage included in aggregate %.

14733 of 20114 relevant lines covered (73.25%)

1521.34 hits per line

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

66.22

/src/factory/process-imp.cpp

////////////////////////////////////////////////////////////////////////////////
// Name:      process-imp.cpp
// Purpose:   Implementation of class wex::factory::process_imp
// Author:    Anton van Wezenbeek
// Copyright: (c) 2021-2025 Anton van Wezenbeek
////////////////////////////////////////////////////////////////////////////////

#include <thread>

#include <wex/core/log.h>
#include <wex/factory/defs.h>
#include <wex/factory/process.h>
#include <wx/event.h>

#include <boost/process/v1/async_system.hpp>

#include "process-imp.h"

#define WEX_POST(ID, TEXT, DEST)                                               \
  if (DEST != nullptr)                                                         \
  {                                                                            \
    wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, ID);                     \
    event.SetString(TEXT);                                                     \
    wxPostEvent(DEST, event);                                                  \
  }

wex::factory::process_imp::process_imp()
  : m_io(std::make_shared<boost::asio::io_context>())
  , m_queue(std::make_shared<std::queue<std::string>>())
{
}

void wex::factory::process_imp::async_sleep_for(
  const std::chrono::milliseconds& ms)
{
  std::this_thread::sleep_for(ms);
}

void wex::factory::process_imp::async_system(process* p)
{
  m_debug.store(p->m_eh_debug != nullptr);

  try
  {
    boost_async_system(p);

    m_is_running.store(true);

    thread_input(p);
    thread_output(p);
    thread_error(p);
  }
  catch (std::exception& e)
  {
    log("async_system") << e.what();
  }
}

void wex::factory::process_imp::boost_async_system(process* p)
{
  bp1::async_system(
    *m_io.get(),
    [this, p](boost::system::error_code error, int i)
    {
      m_is_running.store(false);

      if (error.value() != 0 && p->m_eh_out != nullptr)
      {
        WEX_POST(ID_SHELL_APPEND_ERROR, error.message(), p->m_eh_out)
      }

      log::debug("async_system") << "exit" << p->data().exe();

      if (m_debug.load())
      {
        WEX_POST(ID_DEBUG_EXIT, "", p->m_eh_debug)
      }
    },

    // clang-format off
    p->data().exe_path(),
    bp1::args = p->data().args(),
    bp1::start_dir = p->data().start_dir(),
    bp1::std_err > m_es,
    bp1::std_in < m_os,
    bp1::std_out > m_is,
    m_group);
  // clang-format on

  log::debug("async_system")
    << p->data().exe() << "wd:" << p->data().start_dir();

  WEX_POST(ID_SHELL_APPEND, p->data().exe() + "\n", p->m_eh_out)
}

bool wex::factory::process_imp::stop(wxEvtHandler* e)
{
  if (m_is_running.load())
  {
    if (m_group.valid())
    {
      m_group.terminate();
    }

    m_io->stop();
    m_is_running.store(false);

    if (m_debug.load() && e != nullptr)
    {
      WEX_POST(ID_DEBUG_EXIT, "", e)
    }

    return true;
  }

  return false;
}

void wex::factory::process_imp::thread_error(const process* p)
{
  std::thread v(
    [debug = m_debug.load(),
     &dbg  = p->m_eh_debug,
     out   = p->m_eh_out,
     &es   = m_es]
    {
      std::string text;

      while (es.good())
      {
        text.push_back(es.get());

        if (text.back() == '\n')
        {
          WEX_POST(ID_SHELL_APPEND_ERROR, text, out)

          if (debug)
          {
            WEX_POST(ID_DEBUG_STDOUT, text, dbg)
          }

          text.clear();
        }
      }
    });

  v.detach();
}

void wex::factory::process_imp::thread_input(const process* p)
{
  std::thread t(
    [debug = m_debug.load(),
     &dbg  = p->m_eh_debug,
     &out  = p->m_eh_out,
     &is   = m_is]
    {
      std::string text, line;
      line.reserve(1000000);
      text.reserve(1000000);
      int  linesize = 0;
      bool error    = false;

      while (is.good() && !error)
      {
        text.push_back(is.get());
        linesize++;

        if (linesize > 20000)
        {
          error = true;
          WEX_POST(ID_SHELL_APPEND, "\n*** LINE LIMIT ***\n", out)
        }
        else if (isspace(text.back()))
        {
          WEX_POST(ID_SHELL_APPEND, text, out)

          if (text.back() == '\n')
          {
            linesize = 0;
          }

          if (debug)
          {
            line.append(text);

            if (line.back() == '\n')
            {
              WEX_POST(ID_DEBUG_STDOUT, line, dbg)
              line.clear();
            }
          }

          text.clear();
        }
      }
    });

  t.detach();
}

void wex::factory::process_imp::thread_output(const process* p)
{
  std::thread u(
    [debug = m_debug.load(),
     io    = m_io,
     &os   = m_os,
     dbg   = p->m_eh_debug,
     queue = m_queue]
    {
      while (os.good() && !io->stopped())
      {
        io->run_one_for(std::chrono::milliseconds(10));

        if (!queue->empty())
        {
          if (const auto& text(queue->front()); os.good() && !io->stopped())
          {
            log::debug("async_system") << "write:" << text;

            os << text << "\n";

            if (debug)
            {
              WEX_POST(ID_DEBUG_STDIN, text, dbg)
            }
          }
          else
          {
            log::debug("async_system") << "skip:" << text;
          }

          queue->pop();
        }
      }
    });

  u.detach();
}

bool wex::factory::process_imp::write(const std::string& text)
{
  if (text.empty() || !m_is_running.load())
  {
    return false;
  }

  m_queue->push(text);

  return true;
}

1	////////////////////////////////////////////////////////////////////////////////
2	// Name: process-imp.cpp
3	// Purpose: Implementation of class wex::factory::process_imp
4	// Author: Anton van Wezenbeek
5	// Copyright: (c) 2021-2025 Anton van Wezenbeek
6	////////////////////////////////////////////////////////////////////////////////
7
8	#include <thread>
9
10	#include <wex/core/log.h>
11	#include <wex/factory/defs.h>
12	#include <wex/factory/process.h>
13	#include <wx/event.h>
14
15	#include <boost/process/v1/async_system.hpp>
16
17	#include "process-imp.h"
18
19	#define WEX_POST(ID, TEXT, DEST) \
20	if (DEST != nullptr) \
21	{ \
22	wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, ID); \
23	event.SetString(TEXT); \
24	wxPostEvent(DEST, event); \
25	}
26
27	wex::factory::process_imp::process_imp()	9✔
28	: m_io(std::make_shared<boost::asio::io_context>())	9✔
29	, m_queue(std::make_shared<std::queue<std::string>>())	9✔
30	{
31	}	9✔
32
33	void wex::factory::process_imp::async_sleep_for(	2✔
34	const std::chrono::milliseconds& ms)
35	{
36	std::this_thread::sleep_for(ms);	2✔
37	}	2✔
38
39	void wex::factory::process_imp::async_system(process* p)	9✔
40	{
41	m_debug.store(p->m_eh_debug != nullptr);	9✔
42
43	try
44	{
45	boost_async_system(p);	9✔
46
47	m_is_running.store(true);	8✔
48
49	thread_input(p);	8✔
50	thread_output(p);	8✔
51	thread_error(p);	8✔
52	}
53	catch (std::exception& e)	1!
54	{
55	log("async_system") << e.what();	1✔
56	}	1✔
57	}	9✔
58
59	void wex::factory::process_imp::boost_async_system(process* p)	9✔
60	{
61	bp1::async_system(	8✔
62	*m_io.get(),	8✔
63	[this, p](boost::system::error_code error, int i)	8✔
64	{
65	m_is_running.store(false);	4✔
66
67	if (error.value() != 0 && p->m_eh_out != nullptr)	4!
68	{
69	WEX_POST(ID_SHELL_APPEND_ERROR, error.message(), p->m_eh_out)	×
70	}
71
72	log::debug("async_system") << "exit" << p->data().exe();	4✔
73
74	if (m_debug.load())	4!
75	{
76	WEX_POST(ID_DEBUG_EXIT, "", p->m_eh_debug)	×
77	}
78	},	4✔
79
80	// clang-format off
81	p->data().exe_path(),	17✔
82	bp1::args = p->data().args(),	20✔
83	bp1::start_dir = p->data().start_dir(),	19✔
84	bp1::std_err > m_es,	10✔
85	bp1::std_in < m_os,	10✔
86	bp1::std_out > m_is,	9✔
87	m_group);	9✔
88	// clang-format on
89
90	log::debug("async_system")	16✔
91	<< p->data().exe() << "wd:" << p->data().start_dir();	8✔
92
93	WEX_POST(ID_SHELL_APPEND, p->data().exe() + "\n", p->m_eh_out)	8!
94	}	8✔
95
96	bool wex::factory::process_imp::stop(wxEvtHandler* e)	12✔
97	{
98	if (m_is_running.load())	12✔
99	{
100	if (m_group.valid())	4!
101	{
102	m_group.terminate();	4✔
103	}
104
105	m_io->stop();	4✔
106	m_is_running.store(false);	4✔
107
108	if (m_debug.load() && e != nullptr)	4!
109	{
110	WEX_POST(ID_DEBUG_EXIT, "", e)	×
111	}
112
113	return true;	4✔
114	}
115
116	return false;	8✔
117	}
118
119	void wex::factory::process_imp::thread_error(const process* p)	8✔
120	{
121	std::thread v(
122	[debug = m_debug.load(),	8✔
123	&dbg = p->m_eh_debug,	8✔
124	out = p->m_eh_out,	8✔
125	&es = m_es]	8✔
126	{
127	std::string text;	8✔
128
129	while (es.good())	24✔
130	{
131	text.push_back(es.get());	8✔
132
133	if (text.back() == '\n')	8!
134	{
135	WEX_POST(ID_SHELL_APPEND_ERROR, text, out)	×
136
137	if (debug)	×
138	{
139	WEX_POST(ID_DEBUG_STDOUT, text, dbg)	×
140	}
141
142	text.clear();	×
143	}
144	}
145	});	16✔
146
147	v.detach();	8✔
148	}	8✔
149
150	void wex::factory::process_imp::thread_input(const process* p)	8✔
151	{
152	std::thread t(
153	[debug = m_debug.load(),	8✔
154	&dbg = p->m_eh_debug,	8✔
155	&out = p->m_eh_out,	8✔
156	&is = m_is]	8✔
157	{
158	std::string text, line;	8✔
159	line.reserve(1000000);	8✔
160	text.reserve(1000000);	8✔
161	int linesize = 0;	8✔
162	bool error = false;	8✔
163
164	while (is.good() && !error)	449!
165	{
166	text.push_back(is.get());	441✔
167	linesize++;	441✔
168
169	if (linesize > 20000)	441!
170	{
171	error = true;	×
172	WEX_POST(ID_SHELL_APPEND, "\n* LINE LIMIT *\n", out)	×
173	}
174	else if (isspace(text.back()))	441✔
175	{
176	WEX_POST(ID_SHELL_APPEND, text, out)	29!
177
178	if (text.back() == '\n')	29✔
179	{
180	linesize = 0;	28✔
181	}
182
183	if (debug)	29!
184	{
185	line.append(text);	×
186
187	if (line.back() == '\n')	×
188	{
189	WEX_POST(ID_DEBUG_STDOUT, line, dbg)	×
190	line.clear();	×
191	}
192	}
193
194	text.clear();	29✔
195	}
196	}
197	});	16✔
198
199	t.detach();	8✔
200	}	8✔
201
202	void wex::factory::process_imp::thread_output(const process* p)	8✔
203	{
204	std::thread u(
205	[debug = m_debug.load(),	16!
206	io = m_io,	8✔
207	&os = m_os,	8✔
208	dbg = p->m_eh_debug,	8✔
209	queue = m_queue]	8✔
210	{
211	while (os.good() && !io->stopped())	28!
212	{
213	io->run_one_for(std::chrono::milliseconds(10));	12✔
214
215	if (!queue->empty())	12✔
216	{
217	if (const auto& text(queue->front()); os.good() && !io->stopped())	2!
218	{
219	log::debug("async_system") << "write:" << text;	×
220
221	os << text << "\n";	×
222
223	if (debug)	×
224	{
225	WEX_POST(ID_DEBUG_STDIN, text, dbg)	×
226	}
227	}
228	else
229	{
230	log::debug("async_system") << "skip:" << text;	4✔
231	}
232
233	queue->pop();	2✔
234	}
235	}
236	});	16✔
237
238	u.detach();	8✔
239	}	8✔
240
241	bool wex::factory::process_imp::write(const std::string& text)	5✔
242	{
243	if (text.empty() \|\| !m_is_running.load())	5!
244	{
245	return false;	1✔
246	}
247
248	m_queue->push(text);	4✔
249
250	return true;	4✔
251	}

antonvw / wex / 19969138048

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