zalox
/
jucipp
mirror of https://gitlab.com/cppit/jucipp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Improved process methods.

merge-requests/365/head
U-olece-PC\olece 10 years ago
parent
61722b063b
commit
d9fdf27db5
4 changed files with 152 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/juci.cc
  2. 66
      src/terminal.cc
  3. 2
      src/terminal.h
  4. 192
      src/terminal_win.cc

2
src/juci.cc
Unescape View File

@ -59,7 +59,7 @@ void app::on_activate() {
} }
std::thread another_juci_app([this, directory, files_in_directory](){ std::thread another_juci_app([this, directory, files_in_directory](){
Singleton::terminal()->async_print("Executing: juci "+directory.string()+files_in_directory); Singleton::terminal()->async_print("Executing: juci "+directory.string()+files_in_directory);
Singleton::terminal()->execute("juci "+directory.string()+files_in_directory, ""); //TODO: do not open pipes here, doing this after Juci compiles on Windows Singleton::terminal()->execute("juci "+directory.string()+files_in_directory, "", false);
}); });
another_juci_app.detach(); another_juci_app.detach();
} }

66
src/terminal.cc
Unescape View File

@ -146,45 +146,53 @@ Terminal::Terminal() {
}); });
} }
int Terminal::execute(const std::string &command, const boost::filesystem::path &path) { int Terminal::execute(const std::string &command, const boost::filesystem::path &path, bool use_pipes) {
int stdin_fd, stdout_fd, stderr_fd; int stdin_fd, stdout_fd, stderr_fd;
auto pid=popen3(command, path.string(), &stdin_fd, &stdout_fd, &stderr_fd); pid_t pid;
if(use_pipes)
pid=popen3(command, path.string(), &stdin_fd, &stdout_fd, &stderr_fd);
else
pid=popen3(command, path.string(), nullptr, nullptr, nullptr);
if (pid<=0) { if (pid<=0) {
async_print("Error: Failed to run command: " + command + "\n"); async_print("Error: Failed to run command: " + command + "\n");
return -1; return -1;
} }
else { else {
std::thread stderr_thread([this, stderr_fd](){ if(use_pipes) {
char buffer[buffer_size]; std::thread stderr_thread([this, stderr_fd](){
ssize_t n; char buffer[buffer_size];
while ((n=read(stderr_fd, buffer, buffer_size)) > 0) { ssize_t n;
std::string message; while ((n=read(stderr_fd, buffer, buffer_size)) > 0) {
message.reserve(n); std::string message;
for(ssize_t c=0;c<n;c++) message.reserve(n);
message+=buffer[c]; for(ssize_t c=0;c<n;c++)
async_print(message, true); message+=buffer[c];
} async_print(message, true);
}); }
stderr_thread.detach(); });
std::thread stdout_thread([this, stdout_fd](){ stderr_thread.detach();
char buffer[buffer_size]; std::thread stdout_thread([this, stdout_fd](){
ssize_t n; char buffer[buffer_size];
while ((n=read(stdout_fd, buffer, buffer_size)) > 0) { ssize_t n;
std::string message; while ((n=read(stdout_fd, buffer, buffer_size)) > 0) {
message.reserve(n); std::string message;
for(ssize_t c=0;c<n;c++) message.reserve(n);
message+=buffer[c]; for(ssize_t c=0;c<n;c++)
async_print(message); message+=buffer[c];
} async_print(message);
}); }
stdout_thread.detach(); });
stdout_thread.detach();
}
int exit_code; int exit_code;
waitpid(pid, &exit_code, 0); waitpid(pid, &exit_code, 0);
close(stdin_fd); if(use_pipes) {
close(stdout_fd); close(stdin_fd);
close(stderr_fd); close(stdout_fd);
close(stderr_fd);
}
return exit_code; return exit_code;
} }

2
src/terminal.h
Unescape View File

@ -34,7 +34,7 @@ public:
}; };
Terminal(); Terminal();
int execute(const std::string &command, const boost::filesystem::path &path=""); int execute(const std::string &command, const boost::filesystem::path &path="", bool use_pipes=true);
int execute(std::istream &stdin_stream, std::ostream &stdout_stream, const std::string &command, const boost::filesystem::path &path=""); int execute(std::istream &stdin_stream, std::ostream &stdout_stream, const std::string &command, const boost::filesystem::path &path="");
void async_execute(const std::string &command, const boost::filesystem::path &path="", std::function<void(int exit_code)> callback=nullptr); void async_execute(const std::string &command, const boost::filesystem::path &path="", std::function<void(int exit_code)> callback=nullptr);
void kill_last_async_execute(bool force=false); void kill_last_async_execute(bool force=false);

192
src/terminal_win.cc
Unescape View File

@ -10,6 +10,9 @@ using namespace std; //TODO: remove
const size_t buffer_size=131072; const size_t buffer_size=131072;
//Based on the example at https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499(v=vs.85).aspx
//Note: on Windows it seems impossible to specify which pipes to use
//Thus, if stdin_h, stdout_h and stderr all are NULL, the out,err,in is sent to the parent process instead
HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin_h, HANDLE *stdout_h, HANDLE *stderr_h) { HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin_h, HANDLE *stdout_h, HANDLE *stderr_h) {
HANDLE g_hChildStd_IN_Rd = NULL; HANDLE g_hChildStd_IN_Rd = NULL;
HANDLE g_hChildStd_IN_Wr = NULL; HANDLE g_hChildStd_IN_Wr = NULL;
@ -24,40 +27,46 @@ HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin
saAttr.bInheritHandle = TRUE; saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL; saAttr.lpSecurityDescriptor = NULL;
if (!CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)) bool use_pipes=(stdin_h!=nullptr || stdout_h!=nullptr || stderr_h!=nullptr);
return NULL;
if(!SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0)) { if(use_pipes) {
CloseHandle(g_hChildStd_IN_Rd); if (!CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
CloseHandle(g_hChildStd_IN_Wr); return NULL;
return NULL; if(!SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0)) {
} CloseHandle(g_hChildStd_IN_Rd);
if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0)) { CloseHandle(g_hChildStd_IN_Wr);
CloseHandle(g_hChildStd_IN_Rd); return NULL;
CloseHandle(g_hChildStd_IN_Wr); }
return NULL;
} if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0)) {
if(!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0)) { CloseHandle(g_hChildStd_IN_Rd);
CloseHandle(g_hChildStd_IN_Rd); CloseHandle(g_hChildStd_IN_Wr);
CloseHandle(g_hChildStd_IN_Wr); return NULL;
CloseHandle(g_hChildStd_OUT_Rd); }
CloseHandle(g_hChildStd_OUT_Wr); if(!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0)) {
return NULL; CloseHandle(g_hChildStd_IN_Rd);
} CloseHandle(g_hChildStd_IN_Wr);
if (!CreatePipe(&g_hChildStd_ERR_Rd, &g_hChildStd_ERR_Wr, &saAttr, 0)) { CloseHandle(g_hChildStd_OUT_Rd);
CloseHandle(g_hChildStd_IN_Rd); CloseHandle(g_hChildStd_OUT_Wr);
CloseHandle(g_hChildStd_IN_Wr); return NULL;
CloseHandle(g_hChildStd_OUT_Rd); }
CloseHandle(g_hChildStd_OUT_Wr);
return NULL; if (!CreatePipe(&g_hChildStd_ERR_Rd, &g_hChildStd_ERR_Wr, &saAttr, 0)) {
} CloseHandle(g_hChildStd_IN_Rd);
if(!SetHandleInformation(g_hChildStd_ERR_Rd, HANDLE_FLAG_INHERIT, 0)) { CloseHandle(g_hChildStd_IN_Wr);
CloseHandle(g_hChildStd_IN_Rd); CloseHandle(g_hChildStd_OUT_Rd);
CloseHandle(g_hChildStd_IN_Wr); CloseHandle(g_hChildStd_OUT_Wr);
CloseHandle(g_hChildStd_OUT_Rd); return NULL;
CloseHandle(g_hChildStd_OUT_Wr); }
CloseHandle(g_hChildStd_ERR_Rd); if(!SetHandleInformation(g_hChildStd_ERR_Rd, HANDLE_FLAG_INHERIT, 0)) {
CloseHandle(g_hChildStd_ERR_Wr); CloseHandle(g_hChildStd_IN_Rd);
return NULL; CloseHandle(g_hChildStd_IN_Wr);
CloseHandle(g_hChildStd_OUT_Rd);
CloseHandle(g_hChildStd_OUT_Wr);
CloseHandle(g_hChildStd_ERR_Rd);
CloseHandle(g_hChildStd_ERR_Wr);
return NULL;
}
} }
PROCESS_INFORMATION process_info; PROCESS_INFORMATION process_info;
@ -67,10 +76,12 @@ HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO)); ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
siStartInfo.cb = sizeof(STARTUPINFO); siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.hStdError = g_hChildStd_ERR_Wr; if(use_pipes) {
siStartInfo.hStdOutput = g_hChildStd_OUT_Wr; siStartInfo.hStdInput = g_hChildStd_IN_Rd;
siStartInfo.hStdInput = g_hChildStd_IN_Rd; siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
siStartInfo.dwFlags |= STARTF_USESTDHANDLES; siStartInfo.hStdError = g_hChildStd_ERR_Wr;
siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
}
char* path_ptr; char* path_ptr;
if(path=="") if(path=="")
@ -95,9 +106,11 @@ HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin
if(!bSuccess) { if(!bSuccess) {
CloseHandle(process_info.hProcess); CloseHandle(process_info.hProcess);
CloseHandle(process_info.hThread); CloseHandle(process_info.hThread);
CloseHandle(g_hChildStd_IN_Rd); if(use_pipes) {
CloseHandle(g_hChildStd_OUT_Wr); CloseHandle(g_hChildStd_IN_Rd);
CloseHandle(g_hChildStd_ERR_Wr); CloseHandle(g_hChildStd_OUT_Wr);
CloseHandle(g_hChildStd_ERR_Wr);
}
return NULL; return NULL;
} }
else { else {
@ -106,14 +119,16 @@ HANDLE popen3(const std::string &command, const std::string &path, HANDLE *stdin
// of the child process, for example. // of the child process, for example.
CloseHandle(process_info.hThread); CloseHandle(process_info.hThread);
CloseHandle(g_hChildStd_IN_Rd); if(use_pipes) {
CloseHandle(g_hChildStd_OUT_Wr); CloseHandle(g_hChildStd_IN_Rd);
CloseHandle(g_hChildStd_ERR_Wr); CloseHandle(g_hChildStd_OUT_Wr);
CloseHandle(g_hChildStd_ERR_Wr);
}
} }
*stdin_h=g_hChildStd_IN_Wr; if(stdin_h!=NULL) *stdin_h=g_hChildStd_IN_Wr;
*stdout_h=g_hChildStd_OUT_Rd; if(stdout_h!=NULL) *stdout_h=g_hChildStd_OUT_Rd;
*stderr_h=g_hChildStd_ERR_Rd; if(stderr_h!=NULL) *stderr_h=g_hChildStd_ERR_Rd;
return process_info.hProcess; return process_info.hProcess;
} }
@ -181,57 +196,64 @@ Terminal::Terminal() {
}); });
} }
//Based on the example at https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499(v=vs.85).aspx int Terminal::execute(const std::string &command, const boost::filesystem::path &path, bool use_pipes) {
int Terminal::execute(const std::string &command, const boost::filesystem::path &path) {
HANDLE stdin_h, stdout_h, stderr_h; HANDLE stdin_h, stdout_h, stderr_h;
auto process=popen3(command, path.string(), &stdin_h, &stdout_h, &stderr_h); HANDLE process;
if(use_pipes)
process=popen3(command, path.string(), &stdin_h, &stdout_h, &stderr_h);
else
process=popen3(command, path.string(), nullptr, nullptr, nullptr);
if(process==NULL) { if(process==NULL) {
async_print("Error: Failed to run command: " + command + "\n"); async_print("Error: Failed to run command: " + command + "\n");
return -1; return -1;
} }
std::thread stderr_thread([this, stderr_h](){ if(use_pipes) {
DWORD n; std::thread stderr_thread([this, stderr_h](){
CHAR buffer[buffer_size]; DWORD n;
for (;;) { CHAR buffer[buffer_size];
BOOL bSuccess = ReadFile(stderr_h, buffer, static_cast<DWORD>(buffer_size), &n, NULL); for (;;) {
if(!bSuccess || n == 0) BOOL bSuccess = ReadFile(stderr_h, buffer, static_cast<DWORD>(buffer_size), &n, NULL);
break; if(!bSuccess || n == 0)
break;
std::string message;
message.reserve(n); std::string message;
for(DWORD c=0;c<n;c++) message.reserve(n);
message+=buffer[c]; for(DWORD c=0;c<n;c++)
async_print(message, true); message+=buffer[c];
} async_print(message, true);
}); }
stderr_thread.detach(); });
stderr_thread.detach();
std::thread stdout_thread([this, stdout_h](){
DWORD n;
CHAR buffer[buffer_size];
for (;;) {
BOOL bSuccess = ReadFile(stdout_h, buffer, static_cast<DWORD>(buffer_size), &n, NULL);
if(!bSuccess || n == 0)
break;
std::string message; std::thread stdout_thread([this, stdout_h](){
message.reserve(n); DWORD n;
for(DWORD c=0;c<n;c++) CHAR buffer[buffer_size];
message+=buffer[c]; for (;;) {
async_print(message); BOOL bSuccess = ReadFile(stdout_h, buffer, static_cast<DWORD>(buffer_size), &n, NULL);
} if(!bSuccess || n == 0)
}); break;
stdout_thread.detach();
std::string message;
message.reserve(n);
for(DWORD c=0;c<n;c++)
message+=buffer[c];
async_print(message);
}
});
stdout_thread.detach();
}
unsigned long exit_code; unsigned long exit_code;
WaitForSingleObject(process, INFINITE); WaitForSingleObject(process, INFINITE);
GetExitCodeProcess(process, &exit_code); GetExitCodeProcess(process, &exit_code);
CloseHandle(process); CloseHandle(process);
CloseHandle(stdin_h); if(use_pipes) {
CloseHandle(stdout_h); CloseHandle(stdin_h);
CloseHandle(stderr_h); CloseHandle(stdout_h);
CloseHandle(stderr_h);
}
return exit_code; return exit_code;
} }

Write Preview
Loading…
Cancel
Save