db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-07-17 01:12:23 +02:00
Code Issues Releases Activity

Improve HRN_FORK*() macros.

Browse Source 
Simplify HRN_FORK_CHILD_BEGIN() by adding optional parameters with the common defaults.

Add _FD() to macros that retrieve file descriptors to make their purpose clearer.
This commit is contained in:
David Steele
2021-07-13 14:22:53 -04:00
parent 76cfbf833d
commit 1ace1ac938
26 changed files with 161 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CONTRIBUTING.md
View File

@ -440,7 +440,7 @@ Sometimes it is useful to use a child process for testing. Below is a simple exa
``` ```
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),

2
doc/xml/contributing.xml
View File

@ -499,7 +499,7 @@ TEST_RESULT_LOG(
<code-block> <code-block>
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),

91
test/src/common/harnessFork.h
View File

@ -15,7 +15,7 @@ HRN_FORK_BEGIN()
// //
// The second parameter specifies whether pipes should be setup between the parent and child processes. These can be accessed // The second parameter specifies whether pipes should be setup between the parent and child processes. These can be accessed
// with the HRN_FORK_*() macros; // with the HRN_FORK_*() macros;
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
// Child test code goes here // Child test code goes here
} }
@ -69,31 +69,19 @@ Return the pipe for the child process
#define HRN_FORK_PIPE(processIdx) \ #define HRN_FORK_PIPE(processIdx) \
HRN_FORK_pipe[processIdx] HRN_FORK_pipe[processIdx]
/***********************************************************************************************************************************
Is the pipe required for this child process?
***********************************************************************************************************************************/
#define HRN_FORK_PIPE_REQUIRED(processIdx) \
HRN_FORK_pipeRequired[processIdx]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Get read/write pipe file descriptors Get read/write pipe file descriptors
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HRN_FORK_CHILD_READ_PROCESS(processIdx) \ #define HRN_FORK_CHILD_READ_FD() \
HRN_FORK_PIPE(processIdx)[1][0] HRN_FORK_PIPE(HRN_FORK_PROCESS_IDX())[1][0]
#define HRN_FORK_CHILD_READ() \ #define HRN_FORK_CHILD_WRITE_FD() \
HRN_FORK_CHILD_READ_PROCESS(HRN_FORK_PROCESS_IDX()) HRN_FORK_PIPE(HRN_FORK_PROCESS_IDX())[0][1]
#define HRN_FORK_CHILD_WRITE_PROCESS(processIdx) \ #define HRN_FORK_PARENT_READ_FD(processIdx) \
HRN_FORK_PIPE(processIdx)[0][1]
#define HRN_FORK_CHILD_WRITE() \
HRN_FORK_CHILD_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())
#define HRN_FORK_PARENT_READ_PROCESS(processIdx) \
HRN_FORK_PIPE(processIdx)[0][0] HRN_FORK_PIPE(processIdx)[0][0]
#define HRN_FORK_PARENT_WRITE_PROCESS(processIdx) \ #define HRN_FORK_PARENT_WRITE_FD(processIdx) \
HRN_FORK_PIPE(processIdx)[1][1] HRN_FORK_PIPE(processIdx)[1][1]
/*********************************************************************************************************************************** /***********************************************************************************************************************************
@ -112,29 +100,32 @@ Begin the fork block
unsigned int HRN_FORK_PROCESS_TOTAL() = 0; \ unsigned int HRN_FORK_PROCESS_TOTAL() = 0; \
pid_t HRN_FORK_PROCESS_ID(HRN_FORK_CHILD_MAX) = {0}; \ pid_t HRN_FORK_PROCESS_ID(HRN_FORK_CHILD_MAX) = {0}; \
int HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_CHILD_MAX) = {0}; \ int HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_CHILD_MAX) = {0}; \
bool HRN_FORK_PIPE_REQUIRED(HRN_FORK_CHILD_MAX) = {0}; \
int HRN_FORK_PIPE(HRN_FORK_CHILD_MAX)[2][2] = {{{0}}}; int HRN_FORK_PIPE(HRN_FORK_CHILD_MAX)[2][2] = {{{0}}};
/*********************************************************************************************************************************** /***********************************************************************************************************************************
Create a child process Create a child process
***********************************************************************************************************************************/ ***********************************************************************************************************************************/
#define HRN_FORK_CHILD_BEGIN(expectedExitStatus, pipeRequired) \ typedef struct HrnForkChildParam
{
VAR_PARAM_HEADER;
int expectedExitStatus;
} HrnForkChildParam;
#define HRN_FORK_CHILD_BEGIN(...) \
do \ do \
{ \ { \
HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_PROCESS_TOTAL()) = expectedExitStatus; \ const HrnForkChildParam param = {VAR_PARAM_INIT, __VA_ARGS__}; \
HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_PROCESS_TOTAL()) = param.expectedExitStatus; \
\ \
if (pipeRequired) \ /* Create pipe for parent/child communication */ \
{ \ THROW_ON_SYS_ERROR_FMT( \
HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_TOTAL()) = true; \ pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[0]) == -1, KernelError, \
\ "unable to create read pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
THROW_ON_SYS_ERROR_FMT( \ THROW_ON_SYS_ERROR_FMT( \
pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[0]) == -1, KernelError, \ pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \
"unable to create read pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \ "unable to create write pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
THROW_ON_SYS_ERROR_FMT( \
pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \
"unable to create write pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
} \
\ \
/* Fork child process */ \
HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) = fork(); \ HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) = fork(); \
\ \
if (HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) == 0) \ if (HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) == 0) \
@ -142,20 +133,16 @@ Create a child process
unsigned int HRN_FORK_PROCESS_IDX() = HRN_FORK_PROCESS_TOTAL(); \ unsigned int HRN_FORK_PROCESS_IDX() = HRN_FORK_PROCESS_TOTAL(); \
\ \
/* Change log process id to aid in debugging */ \ /* Change log process id to aid in debugging */ \
hrnLogProcessIdSet(HRN_FORK_PROCESS_IDX() + 1); \ hrnLogProcessIdSet(HRN_FORK_PROCESS_IDX() + 1); \
\ \
if (pipeRequired) \ /* Close parent side of pipe */ \
{ \ close(HRN_FORK_PARENT_READ_FD(HRN_FORK_PROCESS_IDX())); \
close(HRN_FORK_PARENT_READ_PROCESS(HRN_FORK_PROCESS_IDX())); \ close(HRN_FORK_PARENT_WRITE_FD(HRN_FORK_PROCESS_IDX())); \
close(HRN_FORK_PARENT_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())); \
}
#define HRN_FORK_CHILD_END() \ #define HRN_FORK_CHILD_END() \
if (HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_IDX())) \ /* Close child side of pipe */ \
{ \ close(HRN_FORK_CHILD_READ_FD()); \
close(HRN_FORK_CHILD_READ()); \ close(HRN_FORK_CHILD_WRITE_FD()); \
close(HRN_FORK_CHILD_WRITE()); \
} \
\ \
exit(0); \ exit(0); \
} \ } \
@ -172,21 +159,17 @@ Process in the parent
{ \ { \
for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \ for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \ { \
if (HRN_FORK_PIPE_REQUIRED(processIdx)) \ /* Close child side of pipe */ \
{ \ close(HRN_FORK_PIPE(processIdx)[1][0]); \
close(HRN_FORK_CHILD_READ_PROCESS(processIdx)); \ close(HRN_FORK_PIPE(processIdx)[0][1]); \
close(HRN_FORK_CHILD_WRITE_PROCESS(processIdx)); \
} \
} }
#define HRN_FORK_PARENT_END() \ #define HRN_FORK_PARENT_END() \
for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \ for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \ { \
if (HRN_FORK_PIPE_REQUIRED(processIdx)) \ /* Close parent side of pipe */ \
{ \ close(HRN_FORK_PARENT_READ_FD(processIdx)); \
close(HRN_FORK_PARENT_READ_PROCESS(processIdx)); \ close(HRN_FORK_PARENT_WRITE_FD(processIdx)); \
close(HRN_FORK_PARENT_WRITE_PROCESS(processIdx)); \
} \
} \ } \
} \ } \
while (0) while (0)

2
test/src/module/command/archiveCommonTest.c
View File

@ -254,7 +254,7 @@ testRun(void)
// Check timeout by making the wal segment appear after 250ms // Check timeout by making the wal segment appear after 250ms
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);

10
test/src/module/command/archiveGetTest.c
View File

@ -733,10 +733,10 @@ testRun(void)
// Make sure the process times out when it can't get a lock // Make sure the process times out when it can't get a lock
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
TEST_RESULT_VOID( TEST_RESULT_VOID(
lockAcquire( lockAcquire(
@ -755,8 +755,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);

10
test/src/module/command/archivePushTest.c
View File

@ -711,10 +711,10 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
lockAcquire( lockAcquire(
cfgOptionStr(cfgOptLockPath), cfgOptionStr(cfgOptStanza), STRDEF("555-fefefefe"), cfgLockType(), 30000, true); cfgOptionStr(cfgOptLockPath), cfgOptionStr(cfgOptStanza), STRDEF("555-fefefefe"), cfgLockType(), 30000, true);
@ -730,8 +730,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);

38
test/src/module/command/controlTest.c
View File

@ -162,10 +162,10 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -185,8 +185,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -212,10 +212,10 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -235,8 +235,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -260,10 +260,10 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file"); HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
TEST_RESULT_BOOL( TEST_RESULT_BOOL(
lockAcquire(STRDEF(HRN_PATH "/lock"), cfgOptionStr(cfgOptStanza), cfgOptionStr(cfgOptExecId), 0, 30000, true), lockAcquire(STRDEF(HRN_PATH "/lock"), cfgOptionStr(cfgOptStanza), cfgOptionStr(cfgOptExecId), 0, 30000, true),
@ -280,7 +280,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);
@ -302,10 +302,10 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
int lockFd = open(HRN_PATH "/lock/badpid" LOCK_FILE_EXT, O_RDONLY, 0); int lockFd = open(HRN_PATH "/lock/badpid" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired"); TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -326,8 +326,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// Wait for the child to acquire the lock // Wait for the child to acquire the lock
ioReadLine(read); ioReadLine(read);

8
test/src/module/command/infoTest.c
View File

@ -228,7 +228,7 @@ testRun(void)
// backup.info. Execute while a backup lock is held. // backup.info. Execute while a backup lock is held.
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -411,7 +411,7 @@ testRun(void)
// Execute while a backup lock is held // Execute while a backup lock is held
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("777-afafafaf"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("777-afafafaf"), lockTypeBackup, 0, true),
@ -991,7 +991,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -1409,7 +1409,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE( TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true), lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),

8
test/src/module/command/localTest.c
View File

@ -28,7 +28,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -37,7 +37,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal); HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
cmdLocal(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdLocal(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -45,8 +45,8 @@ testRun(void)
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_LOCAL_STR, STRDEF("test"), PROTOCOL_SERVICE_LOCAL_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
} }

40
test/src/module/command/remoteTest.c
View File

@ -29,7 +29,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -37,7 +37,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote);
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -45,8 +45,8 @@ testRun(void)
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
} }
@ -59,7 +59,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--process=0"); strLstAddZ(argList, "--process=0");
@ -69,7 +69,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg"); hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true); HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -79,8 +79,8 @@ testRun(void)
TEST_ASSIGN( TEST_ASSIGN(
client, client,
protocolClientNew(STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, protocolClientNew(STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000)),
"create client"); "create client");
protocolClientNoOp(client); protocolClientNoOp(client);
protocolClientFree(client); protocolClientFree(client);
@ -94,7 +94,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -103,7 +103,7 @@ testRun(void)
strLstAddZ(argList, "--lock-path=/bogus"); strLstAddZ(argList, "--lock-path=/bogus");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -112,8 +112,8 @@ testRun(void)
TEST_ERROR( TEST_ERROR(
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000)),
PathCreateError, "raised from test: unable to create path '/bogus': [13] Permission denied"); PathCreateError, "raised from test: unable to create path '/bogus': [13] Permission denied");
} }
HRN_FORK_PARENT_END(); HRN_FORK_PARENT_END();
@ -125,7 +125,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -134,7 +134,7 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "1"); hrnCfgArgRawZ(argList, cfgOptRepo, "1");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -145,8 +145,8 @@ testRun(void)
client, client,
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000)),
"create client"); "create client");
protocolClientNoOp(client); protocolClientNoOp(client);
@ -165,7 +165,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test"); strLstAddZ(argList, "--stanza=test");
@ -173,7 +173,7 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo); hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote); HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE()); cmdRemote(HRN_FORK_CHILD_READ_FD(), HRN_FORK_CHILD_WRITE_FD());
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -184,8 +184,8 @@ testRun(void)
TEST_ERROR( TEST_ERROR(
protocolClientNew( protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR, STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000)),
StopError, "raised from test: stop file exists for all stanzas"); StopError, "raised from test: stop file exists for all stanzas");
storageRemoveP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT)); storageRemoveP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT));

2
test/src/module/common/errorTest.c
View File

@ -380,7 +380,7 @@ testRun(void)
// Test in a fork so the process does not actually exit // Test in a fork so the process does not actually exit
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(UnhandledError.code, false) HRN_FORK_CHILD_BEGIN(.expectedExitStatus = UnhandledError.code)
{ {
THROW(TestChildError, "does not get caught!"); THROW(TestChildError, "does not get caught!");
} }

2
test/src/module/common/execTest.c
View File

@ -70,7 +70,7 @@ testRun(void)
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
// This is not really fd max but for the purposes of testing is fine -- we won't have more than 64 fds open // This is not really fd max but for the purposes of testing is fine -- we won't have more than 64 fds open
for (int fd = 0; fd < 64; fd++) for (int fd = 0; fd < 64; fd++)

2
test/src/module/common/exitTest.c
View File

@ -34,7 +34,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(errorTypeCode(&TermError), false) HRN_FORK_CHILD_BEGIN(.expectedExitStatus = errorTypeCode(&TermError))
{ {
exitInit(); exitInit();
raise(SIGTERM); raise(SIGTERM);

2
test/src/module/common/forkTest.c
View File

@ -18,7 +18,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
char buffer[1024]; char buffer[1024];

6
test/src/module/common/ioHttpTest.c
View File

@ -281,12 +281,12 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
// Start HTTP test server // Start HTTP test server
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket), ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolSocket),
"http server run"); "http server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -294,7 +294,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *http = hrnServerScriptBegin( IoWrite *http = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("create client"); TEST_TITLE("create client");

6
test/src/module/common/ioTest.c
View File

@ -539,11 +539,11 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoWrite *write = NULL; IoWrite *write = NULL;
TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HRN_FORK_CHILD_WRITE(), 1000), "move write"); TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HRN_FORK_CHILD_WRITE_FD(), 1000), "move write");
TEST_RESULT_BOOL(ioWriteReadyP(write), true, "write is ready"); TEST_RESULT_BOOL(ioWriteReadyP(write), true, "write is ready");
TEST_RESULT_INT(ioWriteFd(write), ((IoFdWrite *)write->driver)->fd, "check write fd"); TEST_RESULT_INT(ioWriteFd(write), ((IoFdWrite *)write->driver)->fd, "check write fd");
@ -567,7 +567,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HRN_FORK_PARENT_READ_PROCESS(0), 1000); IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HRN_FORK_PARENT_READ_FD(0), 1000);
TEST_RESULT_INT(ioReadFd(read), ((IoFdRead *)ioReadDriver(read))->fd, "check fd"); TEST_RESULT_INT(ioReadFd(read), ((IoFdRead *)ioReadDriver(read))->fd, "check fd");
TEST_RESULT_PTR(ioReadInterface(read), &read->pub.interface, "check interface"); TEST_RESULT_PTR(ioReadInterface(read), &read->pub.interface, "check interface");

12
test/src/module/common/ioTlsTest.c
View File

@ -247,12 +247,12 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
// Start server to test various certificate errors // Start server to test various certificate errors
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls,
.certificate = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX "-alt-name.crt"), .certificate = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX "-alt-name.crt"),
.key = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".key")), .key = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".key")),
"tls alt name server run"); "tls alt name server run");
@ -262,7 +262,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *tls = hrnServerScriptBegin( IoWrite *tls = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000)); ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_FD(0), 1000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("certificate error on invalid ca path"); TEST_TITLE("certificate error on invalid ca path");
@ -365,11 +365,11 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls), ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls),
"tls server run"); "tls server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -377,7 +377,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *tls = IoWrite *tls =
hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000)); hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_FD(0), 1000));
ioBufferSizeSet(12); ioBufferSizeSet(12);
TEST_ASSIGN( TEST_ASSIGN(

2
test/src/module/common/lockTest.c
View File

@ -93,7 +93,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_INT_NE(lockAcquireFile(backupLock, STRDEF("1-test"), 0, true), -1, "lock on fork"); TEST_RESULT_INT_NE(lockAcquireFile(backupLock, STRDEF("1-test"), 0, true), -1, "lock on fork");
sleepMSec(500); sleepMSec(500);

10
test/src/module/config/protocolTest.c
View File

@ -22,7 +22,7 @@ testRun(void)
{ {
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
StringList *argList = strLstNew(); StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1"); strLstAddZ(argList, "--stanza=test1");
@ -32,8 +32,8 @@ testRun(void)
HRN_CFG_LOAD(cfgCmdArchiveGet, argList); HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
ProtocolServer *server = protocolServerNew( ProtocolServer *server = protocolServerNew(
STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000), STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ_FD(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000)); ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE_FD(), 2000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_OPTION_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_OPTION_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler)); protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
@ -44,8 +44,8 @@ testRun(void)
{ {
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("test"), STRDEF("config"), STRDEF("test"), STRDEF("config"),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
VariantList *list = varLstNew(); VariantList *list = varLstNew();
varLstAdd(list, varNewStr(STRDEF("repo1-host"))); varLstAdd(list, varNewStr(STRDEF("repo1-host")));

10
test/src/module/db/dbTest.c
View File

@ -61,7 +61,7 @@ testRun(void)
{ {
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
// Set options // Set options
StringList *argList = strLstNew(); StringList *argList = strLstNew();
@ -98,8 +98,8 @@ testRun(void)
server, server,
protocolServerNew( protocolServerNew(
STRDEF("db test server"), STRDEF("test"), STRDEF("db test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ_FD(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE_FD(), 2000)),
"create server"); "create server");
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_DB_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_DB_LIST};
@ -121,8 +121,8 @@ testRun(void)
client, client,
protocolClientNew( protocolClientNew(
STRDEF("db test client"), STRDEF("test"), STRDEF("db test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000), ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_FD(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)), ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_FD(0), 2000)),
"create client"); "create client");
TRY_BEGIN() TRY_BEGIN()

10
test/src/module/performance/storageTest.c
View File

@ -149,7 +149,7 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
// Create a basic configuration so the remote storage driver can determine the storage type // Create a basic configuration so the remote storage driver can determine the storage type
StringList *argList = strLstNew(); StringList *argList = strLstNew();
@ -174,8 +174,8 @@ testRun(void)
// Setup handler for remote storage protocol // Setup handler for remote storage protocol
ProtocolServer *server = protocolServerNew( ProtocolServer *server = protocolServerNew(
STRDEF("storage test server"), STRDEF("test"), STRDEF("storage test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage server read"), HRN_FORK_CHILD_READ(), 60000), ioFdReadNewOpen(STRDEF("storage server read"), HRN_FORK_CHILD_READ_FD(), 60000),
ioFdWriteNewOpen(STRDEF("storage server write"), HRN_FORK_CHILD_WRITE(), 1000)); ioFdWriteNewOpen(STRDEF("storage server write"), HRN_FORK_CHILD_WRITE_FD(), 1000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_STORAGE_REMOTE_LIST}; static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_STORAGE_REMOTE_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler)); protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
@ -188,8 +188,8 @@ testRun(void)
// Create client // Create client
ProtocolClient *client = protocolClientNew( ProtocolClient *client = protocolClientNew(
STRDEF("storage test client"), STRDEF("test"), STRDEF("storage test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage client read"), HRN_FORK_PARENT_READ_PROCESS(0), 60000), ioFdReadNewOpen(STRDEF("storage client read"), HRN_FORK_PARENT_READ_FD(0), 60000),
ioFdWriteNewOpen(STRDEF("storage client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000)); ioFdWriteNewOpen(STRDEF("storage client write"), HRN_FORK_PARENT_WRITE_FD(0), 1000));
// Create remote storage // Create remote storage
Storage *storageRemote = storageRemoteNew( Storage *storageRemote = storageRemoteNew(

26
test/src/module/protocol/protocolTest.c
View File

@ -435,10 +435,10 @@ testRun(void)
{ {
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_CHILD_READ(), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_CHILD_READ_FD(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_CHILD_WRITE(), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_CHILD_WRITE_FD(), 2000);
// Various bogus greetings // Various bogus greetings
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
@ -492,8 +492,8 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000); IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_PARENT_READ_FD(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000); IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_PARENT_WRITE_FD(0), 2000);
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("bogus greetings"); TEST_TITLE("bogus greetings");
@ -659,15 +659,15 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
// Local 1 // Local 1
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
ProtocolServer *server = NULL; ProtocolServer *server = NULL;
TEST_ASSIGN( TEST_ASSIGN(
server, server,
protocolServerNew( protocolServerNew(
STRDEF("local server 1"), STRDEF("test"), STRDEF("local server 1"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 1 read"), HRN_FORK_CHILD_READ(), 10000), ioFdReadNewOpen(STRDEF("local server 1 read"), HRN_FORK_CHILD_READ_FD(), 10000),
ioFdWriteNewOpen(STRDEF("local server 1 write"), HRN_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("local server 1 write"), HRN_FORK_CHILD_WRITE_FD(), 2000)),
"local server 1"); "local server 1");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get"); TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -687,15 +687,15 @@ testRun(void)
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
// Local 2 // Local 2
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
ProtocolServer *server = NULL; ProtocolServer *server = NULL;
TEST_ASSIGN( TEST_ASSIGN(
server, server,
protocolServerNew( protocolServerNew(
STRDEF("local server 2"), STRDEF("test"), STRDEF("local server 2"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 2 read"), HRN_FORK_CHILD_READ(), 10000), ioFdReadNewOpen(STRDEF("local server 2 read"), HRN_FORK_CHILD_READ_FD(), 10000),
ioFdWriteNewOpen(STRDEF("local server 2 write"), HRN_FORK_CHILD_WRITE(), 2000)), ioFdWriteNewOpen(STRDEF("local server 2 write"), HRN_FORK_CHILD_WRITE_FD(), 2000)),
"local server 2"); "local server 2");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get"); TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -736,9 +736,9 @@ testRun(void)
protocolClientNew( protocolClientNew(
strNewFmt("local client %u", clientIdx), STRDEF("test"), strNewFmt("local client %u", clientIdx), STRDEF("test"),
ioFdReadNewOpen( ioFdReadNewOpen(
strNewFmt("local client %u read", clientIdx), HRN_FORK_PARENT_READ_PROCESS(clientIdx), 2000), strNewFmt("local client %u read", clientIdx), HRN_FORK_PARENT_READ_FD(clientIdx), 2000),
ioFdWriteNewOpen( ioFdWriteNewOpen(
strNewFmt("local client %u write", clientIdx), HRN_FORK_PARENT_WRITE_PROCESS(clientIdx), 2000)), strNewFmt("local client %u write", clientIdx), HRN_FORK_PARENT_WRITE_FD(clientIdx), 2000)),
strZ(strNewFmt("local client %u new", clientIdx))); strZ(strNewFmt("local client %u new", clientIdx)));
TEST_RESULT_VOID( TEST_RESULT_VOID(
protocolParallelClientAdd(parallel, client[clientIdx]), strZ(strNewFmt("local client %u add", clientIdx))); protocolParallelClientAdd(parallel, client[clientIdx]), strZ(strNewFmt("local client %u add", clientIdx)));

6
test/src/module/storage/azureTest.c
View File

@ -267,10 +267,10 @@ testRun(void)
{ {
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls), hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls),
"azure server run"); "azure server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
@ -278,7 +278,7 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("azure client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("azure client write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test against local host"); TEST_TITLE("test against local host");

18
test/src/module/storage/gcsTest.c
View File

@ -279,31 +279,31 @@ testRun(void)
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("gcs server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("gcs server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls,
.port = testPort), .port = testPort),
"gcs server run"); "gcs server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls,
.port = testPortAuth), .port = testPortAuth),
"auth server run"); "auth server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("meta server read"), HRN_FORK_CHILD_READ(), 10000), hrnServerProtocolSocket, ioFdReadNew(STRDEF("meta server read"), HRN_FORK_CHILD_READ_FD(), 10000), hrnServerProtocolSocket,
.port = testPortMeta), .port = testPortMeta),
"meta server run"); "meta server run");
} }
@ -312,11 +312,11 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("gcs client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("gcs client write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
IoWrite *auth = hrnServerScriptBegin( IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000)); ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_FD(1), 2000));
IoWrite *meta = hrnServerScriptBegin( IoWrite *meta = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("meta client write"), HRN_FORK_PARENT_WRITE_PROCESS(2), 2000)); ioFdWriteNew(STRDEF("meta client write"), HRN_FORK_PARENT_WRITE_FD(2), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test service auth"); TEST_TITLE("test service auth");

2
test/src/module/storage/posixTest.c
View File

@ -145,7 +145,7 @@ testRun(void)
// ------------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------------
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, false) HRN_FORK_CHILD_BEGIN()
{ {
sleepMSec(250); sleepMSec(250);
HRN_SYSTEM_FMT("touch %s", strZ(fileExists)); HRN_SYSTEM_FMT("touch %s", strZ(fileExists));

12
test/src/module/storage/s3Test.c
View File

@ -353,20 +353,20 @@ testRun(void)
{ {
HRN_FORK_BEGIN() HRN_FORK_BEGIN()
{ {
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("s3 server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, .port = port), ioFdReadNew(STRDEF("s3 server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolTls, .port = port),
"s3 server run"); "s3 server run");
} }
HRN_FORK_CHILD_END(); HRN_FORK_CHILD_END();
HRN_FORK_CHILD_BEGIN(0, true) HRN_FORK_CHILD_BEGIN()
{ {
TEST_RESULT_VOID( TEST_RESULT_VOID(
hrnServerRunP( hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket, ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ_FD(), 5000), hrnServerProtocolSocket,
.port = authPort), .port = authPort),
"auth server run"); "auth server run");
} }
@ -375,9 +375,9 @@ testRun(void)
HRN_FORK_PARENT_BEGIN() HRN_FORK_PARENT_BEGIN()
{ {
IoWrite *service = hrnServerScriptBegin( IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("s3 client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)); ioFdWriteNew(STRDEF("s3 client write"), HRN_FORK_PARENT_WRITE_FD(0), 2000));
IoWrite *auth = hrnServerScriptBegin( IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000)); ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_FD(1), 2000));
// ----------------------------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("config with keys, token, and host with custom port"); TEST_TITLE("config with keys, token, and host with custom port");