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
|
/**
* @file llprocesslauncher_test.cpp
* @author Nat Goodspeed
* @date 2011-12-19
* @brief Test for llprocesslauncher.
*
* $LicenseInfo:firstyear=2011&license=viewerlgpl$
* Copyright (c) 2011, Linden Research, Inc.
* $/LicenseInfo$
*/
// Precompiled header
#include "linden_common.h"
// associated header
#define WIN32_LEAN_AND_MEAN
#include "llprocesslauncher.h"
// STL headers
#include <vector>
// std headers
// external library headers
#include "llapr.h"
#include "apr_thread_proc.h"
#include "apr_file_io.h"
// other Linden headers
#include "../test/lltut.h"
#if defined(LL_WINDOWS)
#define sleep _sleep
#endif
class APR
{
public:
APR():
pool(NULL)
{
apr_initialize();
apr_pool_create(&pool, NULL);
}
~APR()
{
apr_terminate();
}
std::string strerror(apr_status_t rv)
{
char errbuf[256];
apr_strerror(rv, errbuf, sizeof(errbuf));
return errbuf;
}
apr_pool_t *pool;
};
/*****************************************************************************
* TUT
*****************************************************************************/
namespace tut
{
struct llprocesslauncher_data
{
void aprchk(apr_status_t rv)
{
ensure_equals(apr.strerror(rv), rv, APR_SUCCESS);
}
APR apr;
};
typedef test_group<llprocesslauncher_data> llprocesslauncher_group;
typedef llprocesslauncher_group::object object;
llprocesslauncher_group llprocesslaunchergrp("llprocesslauncher");
template<> template<>
void object::test<1>()
{
set_test_name("raw APR nonblocking I/O");
apr_procattr_t *procattr = NULL;
aprchk(apr_procattr_create(&procattr, apr.pool));
aprchk(apr_procattr_io_set(procattr, APR_CHILD_BLOCK, APR_CHILD_BLOCK, APR_CHILD_BLOCK));
aprchk(apr_procattr_cmdtype_set(procattr, APR_PROGRAM_PATH));
std::vector<const char*> argv;
apr_proc_t child;
argv.push_back("python");
argv.push_back("-c");
argv.push_back("raise RuntimeError('Hello from Python!')");
argv.push_back(NULL);
aprchk(apr_proc_create(&child, argv[0],
static_cast<const char* const*>(&argv[0]),
NULL, // if we wanted to pass explicit environment
procattr,
apr.pool));
typedef std::pair<std::string, apr_file_t*> DescFile;
typedef std::vector<DescFile> DescFileVec;
DescFileVec outfiles;
outfiles.push_back(DescFile("out", child.out));
outfiles.push_back(DescFile("err", child.err));
while (! outfiles.empty())
{
DescFileVec iterfiles(outfiles);
for (size_t i = 0; i < iterfiles.size(); ++i)
{
char buf[4096];
apr_status_t rv = apr_file_gets(buf, sizeof(buf), iterfiles[i].second);
if (APR_STATUS_IS_EOF(rv))
{
std::cout << "(EOF on " << iterfiles[i].first << ")\n";
outfiles.erase(outfiles.begin() + i);
continue;
}
if (rv != APR_SUCCESS)
{
std::cout << "(waiting; apr_file_gets(" << iterfiles[i].first << ") => " << rv << ": " << apr.strerror(rv) << ")\n";
continue;
}
// Is it even possible to get APR_SUCCESS but read 0 bytes?
// Hope not, but defend against that anyway.
if (buf[0])
{
std::cout << iterfiles[i].first << ": " << buf;
// Just for pretty output... if we only read a partial
// line, terminate it.
if (buf[strlen(buf) - 1] != '\n')
std::cout << "...\n";
}
}
sleep(1);
}
apr_file_close(child.in);
apr_file_close(child.out);
apr_file_close(child.err);
int rc = 0;
apr_exit_why_e why;
apr_status_t rv;
while (! APR_STATUS_IS_CHILD_DONE(rv = apr_proc_wait(&child, &rc, &why, APR_NOWAIT)))
{
std::cout << "child not done (" << rv << "): " << apr.strerror(rv) << '\n';
sleep(0.5);
}
std::cout << "child done: rv = " << rv << " (" << apr.strerror(rv) << "), why = " << why << ", rc = " << rc << '\n';
}
} // namespace tut
|
