1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
//
// Process.h
//
// Library: Foundation
// Package: Processes
// Module: Process
//
// Definition of the Process class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Process_INCLUDED
#define Foundation_Process_INCLUDED
#include "Poco/Foundation.h"
#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
#if defined(_WIN32_WCE)
#include "Process_WINCE.h"
#else
#include "Poco/Process_WIN32U.h"
#endif
#elif defined(POCO_OS_FAMILY_WINDOWS)
#include "Poco/Process_WIN32.h"
#elif defined(POCO_VXWORKS)
#include "Poco/Process_VX.h"
#elif defined(POCO_OS_FAMILY_UNIX)
#include "Poco/Process_UNIX.h"
#endif
namespace Poco {
class Pipe;
class Foundation_API ProcessHandle
/// A handle for a process created with Process::launch().
///
/// This handle can be used to determine the process ID of
/// the newly created process and it can be used to wait for
/// the completion of a process.
{
public:
typedef ProcessImpl::PIDImpl PID;
ProcessHandle(const ProcessHandle& handle);
/// Creates a ProcessHandle by copying another one.
~ProcessHandle();
/// Destroys the ProcessHandle.
ProcessHandle& operator = (const ProcessHandle& handle);
/// Assigns another handle.
PID id() const;
/// Returns the process ID.
int wait() const;
/// Waits for the process to terminate
/// and returns the exit code of the process.
protected:
ProcessHandle(ProcessHandleImpl* pImpl);
private:
ProcessHandle();
ProcessHandleImpl* _pImpl;
friend class Process;
};
class Foundation_API Process: public ProcessImpl
/// This class provides methods for working with processes.
{
public:
typedef PIDImpl PID;
typedef ArgsImpl Args;
typedef EnvImpl Env;
static PID id();
/// Returns the process ID of the current process.
static void times(long& userTime, long& kernelTime);
/// Returns the number of seconds spent by the
/// current process in user and kernel mode.
static ProcessHandle launch(const std::string& command, const Args& args);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& initialDirectory);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
/// The process starts executing in the specified initial directory.
static ProcessHandle launch(
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
///
/// If inPipe, outPipe or errPipe is non-null, the corresponding
/// standard input, standard output or standard error stream
/// of the launched process is redirected to the Pipe.
/// PipeInputStream or PipeOutputStream can be used to
/// send receive data from, or send data to the process.
///
/// Note: the same Pipe can be used for both outPipe and errPipe.
///
/// After a Pipe has been passed as inPipe, only write operations
/// are valid. After a Pipe has been passed as outPipe or errPipe,
/// only read operations are valid.
///
/// It is forbidden to pass the same pipe as inPipe and outPipe or errPipe.
///
/// Usage example:
/// Pipe outPipe;
/// Process::Args args;
/// ProcessHandle ph(launch("/bin/ps", args, 0, &outPipe, 0));
/// PipeInputStream istr(outPipe);
/// ... // read output of ps from istr
/// int rc = ph.wait();
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& initialDirectory,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
/// The process starts executing in the specified initial directory.
///
/// If inPipe, outPipe or errPipe is non-null, the corresponding
/// standard input, standard output or standard error stream
/// of the launched process is redirected to the Pipe.
/// PipeInputStream or PipeOutputStream can be used to
/// send receive data from, or send data to the process.
///
/// Note: the same Pipe can be used for both outPipe and errPipe.
///
/// After a Pipe has been passed as inPipe, only write operations
/// are valid. After a Pipe has been passed as outPipe or errPipe,
/// only read operations are valid.
///
/// It is forbidden to pass the same pipe as inPipe and outPipe or errPipe.
///
/// Usage example:
/// Pipe outPipe;
/// Process::Args args;
/// ProcessHandle ph(launch("/bin/ps", args, 0, &outPipe, 0));
/// PipeInputStream istr(outPipe);
/// ... // read output of ps from istr
/// int rc = ph.wait();
static ProcessHandle launch(
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe,
const Env& env);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
///
/// If inPipe, outPipe or errPipe is non-null, the corresponding
/// standard input, standard output or standard error stream
/// of the launched process is redirected to the Pipe.
///
/// The launched process is given the specified environment variables.
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& initialDirectory,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe,
const Env& env);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
/// The process starts executing in the specified initial directory.
/// If inPipe, outPipe or errPipe is non-null, the corresponding
/// standard input, standard output or standard error stream
/// of the launched process is redirected to the Pipe.
/// The launched process is given the specified environment variables.
static int wait(const ProcessHandle& handle);
/// Waits for the process specified by handle to terminate
/// and returns the exit code of the process.
static bool isRunning(const ProcessHandle& handle);
/// check if the process specified by handle is running or not
///
/// This is preferable on Windows where process IDs
/// may be reused.
static bool isRunning(PID pid);
/// Check if the process specified by given pid is running or not.
static void kill(ProcessHandle& handle);
/// Kills the process specified by handle.
///
/// This is preferable on Windows where process IDs
/// may be reused.
static void kill(PID pid);
/// Kills the process with the given pid.
static void requestTermination(PID pid);
/// Requests termination of the process with the give PID.
///
/// On Unix platforms, this will send a SIGINT to the
/// process and thus work with arbitrary processes.
///
/// On other platforms, a global event flag
/// will be set. Setting the flag will cause
/// Util::ServerApplication::waitForTerminationRequest() to
/// return. Therefore this will only work with applications
/// based on Util::ServerApplication.
};
//
// inlines
//
inline Process::PID Process::id()
{
return ProcessImpl::idImpl();
}
inline void Process::times(long& userTime, long& kernelTime)
{
ProcessImpl::timesImpl(userTime, kernelTime);
}
} // namespace Poco
#endif // Foundation_Process_INCLUDED
|
