db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-02-19 19:44:38 +02:00
Code Issues Releases Activity

Rename HARNESS_FORK*() macros to HRN_FORK*().

Browse Source 
This matches the new pattern for harness macro naming and is shorter.
This commit is contained in:
David Steele 2021-07-13 11:58:23 -04:00
parent d6797009f8
commit 76cfbf833d
26 changed files with 384 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CONTRIBUTING.md
View File

@ -438,9 +438,9 @@ TEST_RESULT_LOG(
Sometimes it is useful to use a child process for testing. Below is a simple example. See [harnessFork.h](https://github.com/pgbackrest/pgbackrest/blob/master/test/src/common/harnessFork.h) for more details.
```
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -449,9 +449,9 @@ HARNESS_FORK_BEGIN()
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -467,9 +467,9 @@ HARNESS_FORK_BEGIN()
"text - single stanza, no valid backups, backup/expire lock detected");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
```
#### Testing using a shim

12
doc/xml/contributing.xml
View File

@ -497,9 +497,9 @@ TEST_RESULT_LOG(
<p>Sometimes it is useful to use a child process for testing. Below is a simple example. See <link url="{[github-url-test-common]}/harnessFork.h">harnessFork.h</link> for more details.</p>
<code-block>
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -508,9 +508,9 @@ HARNESS_FORK_BEGIN()
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -526,9 +526,9 @@ HARNESS_FORK_BEGIN()
"text - single stanza, no valid backups, backup/expire lock detected");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
</code-block>
</section>

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

@ -6,34 +6,34 @@ polluting memory in the main process with something that can't easily be undone.
The general form of the fork harness is:
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
// This block is required and can be repeated up to HARNESS_FORK_CHILD_MAX times.
// This block is required and can be repeated up to HRN_FORK_CHILD_MAX times.
//
// The first parameter is the expected exit code. If the child block does not have an explicit exit then it will automatically
// exit on 0.
//
// The second parameter specifies whether pipes should be setup between the parent and child processes. These can be accessed
// with the HARNESS_FORK_*() macros;
HARNESS_FORK_CHILD_BEGIN(0, true)
// with the HRN_FORK_*() macros;
HRN_FORK_CHILD_BEGIN(0, true)
{
// Child test code goes here
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
// This block is optional but generally useful
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
// Parent test code goes here
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
If the child process does not explicitly exit in HARNESS_FORK_CHILD_BEGIN/END() then it will exit with 0 at HARNESS_FORK_END().
This harness is not intended for long-lived child processes.
If the child process does not explicitly exit in HRN_FORK_CHILD_BEGIN/END() then it will exit with 0 at HRN_FORK_END(). This harness
is not intended for long-lived child processes.
There should not be any code outside the HARNESS_FORK_CHILD_BEGIN/END() and HARNESS_FORK_PARENT_BEGIN/END() blocks.
There should not be any code outside the HRN_FORK_CHILD_BEGIN/END() and HRN_FORK_PARENT_BEGIN/END() blocks.
***********************************************************************************************************************************/
#include <sys/wait.h>
#include <unistd.h>
@ -43,149 +43,149 @@ There should not be any code outside the HARNESS_FORK_CHILD_BEGIN/END() and HARN
/***********************************************************************************************************************************
Define the max number of child processes allowed
***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_MAX 4
#define HRN_FORK_CHILD_MAX 4
/***********************************************************************************************************************************
Total number of child processes forked
***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_TOTAL() \
HARNESS_FORK_processTotal
#define HRN_FORK_PROCESS_TOTAL() \
HRN_FORK_processTotal
/***********************************************************************************************************************************
Return the process index of the child (i.e. the index in the total)
***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_IDX() \
HARNESS_FORK_processIdx
#define HRN_FORK_PROCESS_IDX() \
HRN_FORK_processIdx
/***********************************************************************************************************************************
Return the id of the child process, 0 if in the child process
***********************************************************************************************************************************/
#define HARNESS_FORK_PROCESS_ID(processIdx) \
HARNESS_FORK_processIdList[processIdx]
#define HRN_FORK_PROCESS_ID(processIdx) \
HRN_FORK_processIdList[processIdx]
/***********************************************************************************************************************************
Return the pipe for the child process
***********************************************************************************************************************************/
#define HARNESS_FORK_PIPE(processIdx) \
HARNESS_FORK_pipe[processIdx]
#define HRN_FORK_PIPE(processIdx) \
HRN_FORK_pipe[processIdx]
/***********************************************************************************************************************************
Is the pipe required for this child process?
***********************************************************************************************************************************/
#define HARNESS_FORK_PIPE_REQUIRED(processIdx) \
HARNESS_FORK_pipeRequired[processIdx]
#define HRN_FORK_PIPE_REQUIRED(processIdx) \
HRN_FORK_pipeRequired[processIdx]
/***********************************************************************************************************************************
Get read/write pipe file descriptors
***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_READ_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[1][0]
#define HRN_FORK_CHILD_READ_PROCESS(processIdx) \
HRN_FORK_PIPE(processIdx)[1][0]
#define HARNESS_FORK_CHILD_READ() \
HARNESS_FORK_CHILD_READ_PROCESS(HARNESS_FORK_PROCESS_IDX())
#define HRN_FORK_CHILD_READ() \
HRN_FORK_CHILD_READ_PROCESS(HRN_FORK_PROCESS_IDX())
#define HARNESS_FORK_CHILD_WRITE_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[0][1]
#define HRN_FORK_CHILD_WRITE_PROCESS(processIdx) \
HRN_FORK_PIPE(processIdx)[0][1]
#define HARNESS_FORK_CHILD_WRITE() \
HARNESS_FORK_CHILD_WRITE_PROCESS(HARNESS_FORK_PROCESS_IDX())
#define HRN_FORK_CHILD_WRITE() \
HRN_FORK_CHILD_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())
#define HARNESS_FORK_PARENT_READ_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[0][0]
#define HRN_FORK_PARENT_READ_PROCESS(processIdx) \
HRN_FORK_PIPE(processIdx)[0][0]
#define HARNESS_FORK_PARENT_WRITE_PROCESS(processIdx) \
HARNESS_FORK_PIPE(processIdx)[1][1]
#define HRN_FORK_PARENT_WRITE_PROCESS(processIdx) \
HRN_FORK_PIPE(processIdx)[1][1]
/***********************************************************************************************************************************
At the end of the HARNESS_FORK block the parent will wait for the child to exit. By default an exit code of 0 is expected but that
can be modified when the child begins.
At the end of the HRN_FORK block the parent will wait for the child to exit. By default an exit code of 0 is expected but that can
be modified when the child begins.
***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx) \
HARNESS_FORK_expectedExitStatus[processIdx]
#define HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx) \
HRN_FORK_expectedExitStatus[processIdx]
/***********************************************************************************************************************************
Begin the fork block
***********************************************************************************************************************************/
#define HARNESS_FORK_BEGIN() \
#define HRN_FORK_BEGIN() \
do \
{ \
unsigned int HARNESS_FORK_PROCESS_TOTAL() = 0; \
pid_t HARNESS_FORK_PROCESS_ID(HARNESS_FORK_CHILD_MAX) = {0}; \
int HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(HARNESS_FORK_CHILD_MAX) = {0}; \
bool HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_CHILD_MAX) = {0}; \
int HARNESS_FORK_PIPE(HARNESS_FORK_CHILD_MAX)[2][2] = {{{0}}};
unsigned int HRN_FORK_PROCESS_TOTAL() = 0; \
pid_t HRN_FORK_PROCESS_ID(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}}};
/***********************************************************************************************************************************
Create a child process
***********************************************************************************************************************************/
#define HARNESS_FORK_CHILD_BEGIN(expectedExitStatus, pipeRequired) \
#define HRN_FORK_CHILD_BEGIN(expectedExitStatus, pipeRequired) \
do \
{ \
HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(HARNESS_FORK_PROCESS_TOTAL()) = expectedExitStatus; \
HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(HRN_FORK_PROCESS_TOTAL()) = expectedExitStatus; \
\
if (pipeRequired) \
{ \
HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_PROCESS_TOTAL()) = true; \
HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_TOTAL()) = true; \
\
THROW_ON_SYS_ERROR_FMT( \
pipe(HARNESS_FORK_PIPE(HARNESS_FORK_PROCESS_TOTAL())[0]) == -1, KernelError, \
"unable to create read pipe for child process %u", HARNESS_FORK_PROCESS_TOTAL()); \
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( \
pipe(HARNESS_FORK_PIPE(HARNESS_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \
"unable to create write pipe for child process %u", HARNESS_FORK_PROCESS_TOTAL()); \
pipe(HRN_FORK_PIPE(HRN_FORK_PROCESS_TOTAL())[1]) == -1, KernelError, \
"unable to create write pipe for child process %u", HRN_FORK_PROCESS_TOTAL()); \
} \
\
HARNESS_FORK_PROCESS_ID(HARNESS_FORK_PROCESS_TOTAL()) = fork(); \
HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) = fork(); \
\
if (HARNESS_FORK_PROCESS_ID(HARNESS_FORK_PROCESS_TOTAL()) == 0) \
if (HRN_FORK_PROCESS_ID(HRN_FORK_PROCESS_TOTAL()) == 0) \
{ \
unsigned int HARNESS_FORK_PROCESS_IDX() = HARNESS_FORK_PROCESS_TOTAL(); \
unsigned int HRN_FORK_PROCESS_IDX() = HRN_FORK_PROCESS_TOTAL(); \
\
/* Change log process id to aid in debugging */ \
hrnLogProcessIdSet(HARNESS_FORK_PROCESS_IDX() + 1); \
hrnLogProcessIdSet(HRN_FORK_PROCESS_IDX() + 1); \
\
if (pipeRequired) \
{ \
close(HARNESS_FORK_PARENT_READ_PROCESS(HARNESS_FORK_PROCESS_IDX())); \
close(HARNESS_FORK_PARENT_WRITE_PROCESS(HARNESS_FORK_PROCESS_IDX())); \
close(HRN_FORK_PARENT_READ_PROCESS(HRN_FORK_PROCESS_IDX())); \
close(HRN_FORK_PARENT_WRITE_PROCESS(HRN_FORK_PROCESS_IDX())); \
}
#define HARNESS_FORK_CHILD_END() \
if (HARNESS_FORK_PIPE_REQUIRED(HARNESS_FORK_PROCESS_IDX())) \
#define HRN_FORK_CHILD_END() \
if (HRN_FORK_PIPE_REQUIRED(HRN_FORK_PROCESS_IDX())) \
{ \
close(HARNESS_FORK_CHILD_READ()); \
close(HARNESS_FORK_CHILD_WRITE()); \
close(HRN_FORK_CHILD_READ()); \
close(HRN_FORK_CHILD_WRITE()); \
} \
\
exit(0); \
} \
\
HARNESS_FORK_PROCESS_TOTAL()++; \
HRN_FORK_PROCESS_TOTAL()++; \
} \
while (0)
/***********************************************************************************************************************************
Process in the parent
***********************************************************************************************************************************/
#define HARNESS_FORK_PARENT_BEGIN() \
#define HRN_FORK_PARENT_BEGIN() \
do \
{ \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \
for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \
if (HARNESS_FORK_PIPE_REQUIRED(processIdx)) \
if (HRN_FORK_PIPE_REQUIRED(processIdx)) \
{ \
close(HARNESS_FORK_CHILD_READ_PROCESS(processIdx)); \
close(HARNESS_FORK_CHILD_WRITE_PROCESS(processIdx)); \
close(HRN_FORK_CHILD_READ_PROCESS(processIdx)); \
close(HRN_FORK_CHILD_WRITE_PROCESS(processIdx)); \
} \
}
#define HARNESS_FORK_PARENT_END() \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \
#define HRN_FORK_PARENT_END() \
for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \
if (HARNESS_FORK_PIPE_REQUIRED(processIdx)) \
if (HRN_FORK_PIPE_REQUIRED(processIdx)) \
{ \
close(HARNESS_FORK_PARENT_READ_PROCESS(processIdx)); \
close(HARNESS_FORK_PARENT_WRITE_PROCESS(processIdx)); \
close(HRN_FORK_PARENT_READ_PROCESS(processIdx)); \
close(HRN_FORK_PARENT_WRITE_PROCESS(processIdx)); \
} \
} \
} \
@ -194,19 +194,19 @@ Process in the parent
/***********************************************************************************************************************************
End the fork block and check exit status for all child processes
***********************************************************************************************************************************/
#define HARNESS_FORK_END() \
for (unsigned int processIdx = 0; processIdx < HARNESS_FORK_PROCESS_TOTAL(); processIdx++) \
#define HRN_FORK_END() \
for (unsigned int processIdx = 0; processIdx < HRN_FORK_PROCESS_TOTAL(); processIdx++) \
{ \
int processStatus; \
\
if (waitpid(HARNESS_FORK_PROCESS_ID(processIdx), &processStatus, 0) != HARNESS_FORK_PROCESS_ID(processIdx)) \
if (waitpid(HRN_FORK_PROCESS_ID(processIdx), &processStatus, 0) != HRN_FORK_PROCESS_ID(processIdx)) \
THROW_SYS_ERROR_FMT(AssertError, "unable to find child process %u", processIdx); \
\
if (WEXITSTATUS(processStatus) != HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)) \
if (WEXITSTATUS(processStatus) != HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)) \
{ \
THROW_FMT( \
AssertError, "child %u exited with error %d but expected %d", processIdx, WEXITSTATUS(processStatus), \
HARNESS_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)); \
HRN_FORK_CHILD_EXPECTED_EXIT_STATUS(processIdx)); \
} \
} \
} \

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

@ -252,9 +252,9 @@ testRun(void)
TEST_TITLE("timeout");
// Check timeout by making the wal segment appear after 250ms
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
sleepMSec(250);
@ -262,17 +262,17 @@ testRun(void)
storageTest,
"archive/db/9.6-2/1234567812345678/123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
TEST_RESULT_STR_Z(
walSegmentFind(storageRepo(), STRDEF("9.6-2"), STRDEF("123456781234567812345678"), 1000),
"123456781234567812345678-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "found segment");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("duplicate");

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

@ -731,12 +731,12 @@ testRun(void)
TEST_TITLE("unable to get lock");
// Make sure the process times out when it can't get a lock
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
TEST_RESULT_VOID(
lockAcquire(
@ -751,12 +751,12 @@ testRun(void)
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -769,9 +769,9 @@ testRun(void)
ioWriteLine(write, bufNew(0));
ioWriteFlush(write);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("too many parameters specified");

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

@ -709,12 +709,12 @@ testRun(void)
THROW_ON_SYS_ERROR(chdir(strZ(cfgOptionStr(cfgOptPgPath))) != 0, PathMissingError, "unable to chdir()");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
lockAcquire(
cfgOptionStr(cfgOptLockPath), cfgOptionStr(cfgOptStanza), STRDEF("555-fefefefe"), cfgLockType(), 30000, true);
@ -726,12 +726,12 @@ testRun(void)
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -744,9 +744,9 @@ testRun(void)
ioWriteLine(write, bufNew(0));
ioWriteFlush(write);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("async WAL push");

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

@ -160,12 +160,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_EMPTY(hrnStorage, "lock/empty" LOCK_FILE_EXT, .comment = "create empty lock file");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -181,12 +181,12 @@ testRun(void)
// Parent removed the file so just close the file descriptor
close(lockFd);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -200,9 +200,9 @@ testRun(void)
ioWriteLine(write, bufNew(0));
ioWriteFlush(write);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("not empty lock file with another process lock, processId size trimmed to 0");
@ -210,12 +210,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_Z(hrnStorage, "lock/empty" LOCK_FILE_EXT, " ", .comment = "create non-empty lock file");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/empty" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -231,12 +231,12 @@ testRun(void)
// Parent removed the file so just close the file descriptor
close(lockFd);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -250,20 +250,20 @@ testRun(void)
ioWriteLine(write, bufNew(0));
ioWriteFlush(write);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("lock file with another process lock, processId is valid");
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
TEST_RESULT_BOOL(
lockAcquire(STRDEF(HRN_PATH "/lock"), cfgOptionStr(cfgOptStanza), cfgOptionStr(cfgOptExecId), 0, 30000, true),
@ -276,11 +276,11 @@ testRun(void)
// Wait for a linefeed from the parent but it will not arrive before the process is terminated
ioReadLine(read);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -288,11 +288,11 @@ testRun(void)
TEST_RESULT_VOID(
cmdStop(), "stanza, create stop file, force - lock file with another process lock, processId is valid");
TEST_RESULT_LOG_FMT("P00 INFO: sent term signal to process %d", HARNESS_FORK_PROCESS_ID(0));
TEST_RESULT_LOG_FMT("P00 INFO: sent term signal to process %d", HRN_FORK_PROCESS_ID(0));
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("lock file with another process lock, processId is invalid");
@ -300,12 +300,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/db" STOP_FILE_EXT, .errorOnMissing = true, .comment = "remove stanza stop file");
HRN_STORAGE_PUT_Z(hrnStorage, "lock/badpid" LOCK_FILE_EXT, "-32768", .comment = "create lock file with invalid PID");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("child read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("child write"), HRN_FORK_CHILD_WRITE(), 2000);
int lockFd = open(HRN_PATH "/lock/badpid" LOCK_FILE_EXT, O_RDONLY, 0);
TEST_RESULT_BOOL(lockFd != -1, true, "file descriptor acquired");
@ -322,12 +322,12 @@ testRun(void)
HRN_STORAGE_REMOVE(hrnStorage, "lock/badpid" LOCK_FILE_EXT);
close(lockFd);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("parent read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("parent write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// Wait for the child to acquire the lock
ioReadLine(read);
@ -341,9 +341,9 @@ testRun(void)
ioWriteLine(write, bufNew(0));
ioWriteFlush(write);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -226,9 +226,9 @@ testRun(void)
// archive section will cross reference backup db-id 2 to archive db-id 3 but db section will only use the db-ids from
// backup.info. Execute while a backup lock is held.
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -237,9 +237,9 @@ testRun(void)
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -307,9 +307,9 @@ testRun(void)
"text - single stanza, no valid backups, backup/expire lock detected");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
//--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("multi-repo - stanza missing on specified repo");
@ -409,9 +409,9 @@ testRun(void)
"\"db-version\":\"9.4\"}\n");
// Execute while a backup lock is held
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza1"), STRDEF("777-afafafaf"), lockTypeBackup, 0, true),
@ -420,9 +420,9 @@ testRun(void)
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -589,9 +589,9 @@ testRun(void)
" repo1: backup set size: 3MB, backup size: 3KB\n",
"text - single stanza, valid backup, no priors, no archives in latest DB, backup/expire lock detected");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// Cleanup
HRN_STORAGE_PATH_REMOVE(storageTest, TEST_PATH "/repo/" STORAGE_PATH_ARCHIVE "/stanza1/9.3-2", .recurse = true);
@ -989,9 +989,9 @@ testRun(void)
StringList *argListMultiRepoJson = strLstDup(argListMultiRepo);
hrnCfgArgRawZ(argListMultiRepoJson, cfgOptOutput, "json");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -1000,9 +1000,9 @@ testRun(void)
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -1403,13 +1403,13 @@ testRun(void)
"]",
"json - multiple stanzas, some with valid backups, archives in latest DB, backup lock held on one stanza");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(
lockAcquire(cfgOptionStr(cfgOptLockPath), STRDEF("stanza2"), STRDEF("999-ffffffff"), lockTypeBackup, 0, true),
@ -1418,9 +1418,9 @@ testRun(void)
sleepMSec(1000);
lockRelease(true);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
@ -1507,9 +1507,9 @@ testRun(void)
" repo2: backup set size: 3MB, backup size: 3KB\n",
"text - multiple stanzas, multi-repo with valid backups, backup lock held on one stanza");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
//--------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("multi-repo: stanza exists but requested backup does not");

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

@ -26,9 +26,9 @@ testRun(void)
THROW_ON_SYS_ERROR(pipe(pipeRead) == -1, KernelError, "unable to read test pipe");
THROW_ON_SYS_ERROR(pipe(pipeWrite) == -1, KernelError, "unable to write test pipe");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1");
@ -37,22 +37,22 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleLocal);
cmdLocal(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdLocal(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_LOCAL_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
protocolClientNoOp(client);
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -27,9 +27,9 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("no lock is required because process is > 0 (not the main remote)");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1");
@ -37,29 +37,29 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdInfo, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
ProtocolClient *client = protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
protocolClientNoOp(client);
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("no remote lock is required for this command");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--process=0");
@ -69,32 +69,32 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptPgPath, "/path/to/pg");
HRN_CFG_LOAD(cfgCmdArchiveGet, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
ProtocolClient *client = NULL;
TEST_ASSIGN(
client,
protocolClientNew(STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client");
protocolClientNoOp(client);
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required but lock path is invalid");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test");
@ -103,29 +103,29 @@ testRun(void)
strLstAddZ(argList, "--lock-path=/bogus");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote, .noStd = true);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
TEST_ERROR(
protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
PathCreateError, "raised from test: unable to create path '/bogus': [13] Permission denied");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required and succeeds");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test");
@ -134,19 +134,19 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptRepo, "1");
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
ProtocolClient *client = NULL;
TEST_ASSIGN(
client,
protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client");
protocolClientNoOp(client);
@ -156,16 +156,16 @@ testRun(void)
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("remote lock is required but stop file exists");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test");
@ -173,26 +173,26 @@ testRun(void)
hrnCfgArgRawStrId(argList, cfgOptRemoteType, protocolStorageTypeRepo);
HRN_CFG_LOAD(cfgCmdArchivePush, argList, .role = cfgCmdRoleRemote);
cmdRemote(HARNESS_FORK_CHILD_READ(), HARNESS_FORK_CHILD_WRITE());
cmdRemote(HRN_FORK_CHILD_READ(), HRN_FORK_CHILD_WRITE());
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
storagePutP(storageNewWriteP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT)), NULL);
TEST_ERROR(
protocolClientNew(
STRDEF("test"), PROTOCOL_SERVICE_REMOTE_STR,
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
StopError, "raised from test: stop file exists for all stanzas");
storageRemoveP(hrnStorage, STRDEF("lock/all" STOP_FILE_EXT));
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -378,15 +378,15 @@ testRun(void)
if (testBegin("Uncaught error"))
{
// Test in a fork so the process does not actually exit
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(UnhandledError.code, false)
HRN_FORK_CHILD_BEGIN(UnhandledError.code, false)
{
THROW(TestChildError, "does not get caught!");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -68,9 +68,9 @@ testRun(void)
// Run the same test as above but close all file descriptors first to ensure we don't accidentally close a required
// descriptor while running dup2()/close() between the fork() and the exec().
// -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
// 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++)
@ -87,9 +87,9 @@ testRun(void)
TEST_RESULT_STR_Z(ioReadLine(execIoRead(exec)), " 1\tACKBYACK", "read cat exec");
TEST_RESULT_VOID(execFree(exec), "free exec");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
option = strLstNew();

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

@ -32,16 +32,16 @@ testRun(void)
{
HRN_CFG_LOAD(cfgCmdHelp, strLstNew());
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(errorTypeCode(&TermError), false)
HRN_FORK_CHILD_BEGIN(errorTypeCode(&TermError), false)
{
exitInit();
raise(SIGTERM);
}
HARNESS_FORK_CHILD_END(); // {uncoverable - signal is raised in block}
HRN_FORK_CHILD_END(); // {uncoverable - signal is raised in block}
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************

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

@ -16,9 +16,9 @@ testRun(void)
{
int sessionId = getsid(0);
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
char buffer[1024];
@ -30,9 +30,9 @@ testRun(void)
TEST_RESULT_INT(write(STDOUT_FILENO, buffer, strlen(buffer)), -1, "write to stdout fails");
TEST_RESULT_INT(write(STDERR_FILENO, buffer, strlen(buffer)), -1, "write to stderr fails");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -279,22 +279,22 @@ testRun(void)
httpRequestResponse(httpRequestNewP(client, STRDEF("GET"), STRDEF("/")), false), HostConnectError,
"unable to connect to 'localhost:%u': [111] Connection refused", hrnServerPort(0));
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
// Start HTTP test server
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket),
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket),
"http server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *http = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("create client");
@ -717,9 +717,9 @@ testRun(void)
hrnServerScriptClose(http);
hrnServerScriptEnd(http);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("statistics exist");

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

@ -537,13 +537,13 @@ testRun(void)
{
ioBufferSizeSet(16);
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoWrite *write = NULL;
TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HARNESS_FORK_CHILD_WRITE(), 1000), "move write");
TEST_ASSIGN(write, ioFdWriteNewOpen(STRDEF("write test"), HRN_FORK_CHILD_WRITE(), 1000), "move write");
TEST_RESULT_BOOL(ioWriteReadyP(write), true, "write is ready");
TEST_RESULT_INT(ioWriteFd(write), ((IoFdWrite *)write->driver)->fd, "check write fd");
@ -563,11 +563,11 @@ testRun(void)
TEST_RESULT_VOID(ioWrite(write, buffer), "write buffer");
ioWriteFlush(write);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HARNESS_FORK_PARENT_READ_PROCESS(0), 1000);
IoRead *read = ioFdReadNewOpen(STRDEF("read test"), HRN_FORK_PARENT_READ_PROCESS(0), 1000);
TEST_RESULT_INT(ioReadFd(read), ((IoFdRead *)ioReadDriver(read))->fd, "check fd");
TEST_RESULT_PTR(ioReadInterface(read), &read->pub.interface, "check interface");
@ -601,9 +601,9 @@ testRun(void)
TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof");
TEST_RESULT_UINT(ioFdRead(ioReadDriver(read), buffer, true), 0, "read buffer at eof again");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(ioFdWriteOneStr(999999, STRDEF("test")), FileWriteError, "unable to write to fd: [9] Bad file descriptor");

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

@ -245,24 +245,24 @@ testRun(void)
"echo \"127.0.0.1 test.pgbackrest.org host.test2.pgbackrest.org test3.pgbackrest.org\" | sudo tee -a /etc/hosts >"
" /dev/null");
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
// Start server to test various certificate errors
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.certificate = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX "-alt-name.crt"),
.key = STRDEF(HRN_PATH_REPO "/" HRN_SERVER_CERT_PREFIX ".key")),
"tls alt name server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *tls = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000));
ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("certificate error on invalid ca path");
@ -351,9 +351,9 @@ testRun(void)
// -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(tls);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
#endif // TEST_CONTAINER_REQUIRED
}
@ -363,21 +363,21 @@ testRun(void)
IoClient *client = NULL;
IoSession *session = NULL;
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("test server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
ioFdReadNew(STRDEF("test server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
"tls server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *tls =
hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000));
hrnServerScriptBegin(ioFdWriteNew(STRDEF("test client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
ioBufferSizeSet(12);
TEST_ASSIGN(
@ -493,9 +493,9 @@ testRun(void)
// -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(tls);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("stastistics exist");

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

@ -91,16 +91,16 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
const String *backupLock = STRDEF(TEST_PATH "/main-backup" LOCK_FILE_EXT);
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
TEST_RESULT_INT_NE(lockAcquireFile(backupLock, STRDEF("1-test"), 0, true), -1, "lock on fork");
sleepMSec(500);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
sleepMSec(250);
TEST_ERROR(
@ -111,9 +111,9 @@ testRun(void)
"unable to acquire lock on file '%s': Resource temporarily unavailable\n"
"HINT: is another pgBackRest process running?", strZ(backupLock))));
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************

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

@ -20,9 +20,9 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("configOptionProtocol() and configOptionRemote()"))
{
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
StringList *argList = strLstNew();
strLstAddZ(argList, "--stanza=test1");
@ -32,20 +32,20 @@ testRun(void)
HRN_CFG_LOAD(cfgCmdArchiveGet, argList);
ProtocolServer *server = protocolServerNew(
STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_CHILD_WRITE(), 2000));
STRDEF("test"), STRDEF("config"), ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_OPTION_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
ProtocolClient *client = protocolClientNew(
STRDEF("test"), STRDEF("config"),
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
VariantList *list = varLstNew();
varLstAdd(list, varNewStr(STRDEF("repo1-host")));
@ -56,9 +56,9 @@ testRun(void)
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -59,9 +59,9 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("Db and dbProtocol()"))
{
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
// Set options
StringList *argList = strLstNew();
@ -98,8 +98,8 @@ testRun(void)
server,
protocolServerNew(
STRDEF("db test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_CHILD_WRITE(), 2000)),
ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_CHILD_READ(), 2000),
ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_CHILD_WRITE(), 2000)),
"create server");
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_DB_LIST};
@ -109,9 +109,9 @@ testRun(void)
"run process loop");
TEST_RESULT_VOID(protocolServerFree(server), "free server");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
// Create client
ProtocolClient *client = NULL;
@ -121,8 +121,8 @@ testRun(void)
client,
protocolClientNew(
STRDEF("db test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000)),
ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000),
ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000)),
"create client");
TRY_BEGIN()
@ -171,9 +171,9 @@ testRun(void)
}
TRY_END();
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************

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

@ -147,9 +147,9 @@ testRun(void)
CHECK(TEST_SCALE <= 2000);
uint64_t fileTotal = (uint64_t)1000000 * TEST_SCALE;
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
// Create a basic configuration so the remote storage driver can determine the storage type
StringList *argList = strLstNew();
@ -174,22 +174,22 @@ testRun(void)
// Setup handler for remote storage protocol
ProtocolServer *server = protocolServerNew(
STRDEF("storage test server"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage server read"), HARNESS_FORK_CHILD_READ(), 60000),
ioFdWriteNewOpen(STRDEF("storage server write"), HARNESS_FORK_CHILD_WRITE(), 1000));
ioFdReadNewOpen(STRDEF("storage server read"), HRN_FORK_CHILD_READ(), 60000),
ioFdWriteNewOpen(STRDEF("storage server write"), HRN_FORK_CHILD_WRITE(), 1000));
static const ProtocolServerHandler commandHandler[] = {PROTOCOL_SERVER_HANDLER_STORAGE_REMOTE_LIST};
protocolServerProcess(server, NULL, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
// Create client
ProtocolClient *client = protocolClientNew(
STRDEF("storage test client"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("storage client read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 60000),
ioFdWriteNewOpen(STRDEF("storage client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 1000));
ioFdReadNewOpen(STRDEF("storage client read"), HRN_FORK_PARENT_READ_PROCESS(0), 60000),
ioFdWriteNewOpen(STRDEF("storage client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 1000));
// Create remote storage
Storage *storageRemote = storageRemoteNew(
@ -206,9 +206,9 @@ testRun(void)
// Free client
protocolClientFree(client);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************

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

@ -433,12 +433,12 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("ProtocolClient, ProtocolCommand, and ProtocolServer"))
{
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HARNESS_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HARNESS_FORK_CHILD_WRITE(), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("server read"), HRN_FORK_CHILD_READ(), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("server write"), HRN_FORK_CHILD_WRITE(), 2000);
// Various bogus greetings
// -----------------------------------------------------------------------------------------------------------------
@ -488,12 +488,12 @@ testRun(void)
// This cannot run in a TEST* macro because tests are run by the command handlers
protocolServerProcess(server, retryList, commandHandler, PROTOCOL_SERVER_HANDLER_LIST_SIZE(commandHandler));
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HARNESS_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000);
IoRead *read = ioFdReadNewOpen(STRDEF("client read"), HRN_FORK_PARENT_READ_PROCESS(0), 2000);
IoWrite *write = ioFdWriteNewOpen(STRDEF("client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000);
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("bogus greetings");
@ -622,9 +622,9 @@ testRun(void)
TEST_RESULT_VOID(protocolClientFree(client), "free");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************
@ -656,18 +656,18 @@ testRun(void)
TEST_RESULT_VOID(protocolParallelJobFree(job), "free job");
// -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
// Local 1
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
ProtocolServer *server = NULL;
TEST_ASSIGN(
server,
protocolServerNew(
STRDEF("local server 1"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 1 read"), HARNESS_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 1 write"), HARNESS_FORK_CHILD_WRITE(), 2000)),
ioFdReadNewOpen(STRDEF("local server 1 read"), HRN_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 1 write"), HRN_FORK_CHILD_WRITE(), 2000)),
"local server 1");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -684,18 +684,18 @@ testRun(void)
// Wait for exit
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_EXIT, "noop command get");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
// Local 2
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
ProtocolServer *server = NULL;
TEST_ASSIGN(
server,
protocolServerNew(
STRDEF("local server 2"), STRDEF("test"),
ioFdReadNewOpen(STRDEF("local server 2 read"), HARNESS_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 2 write"), HARNESS_FORK_CHILD_WRITE(), 2000)),
ioFdReadNewOpen(STRDEF("local server 2 read"), HRN_FORK_CHILD_READ(), 10000),
ioFdWriteNewOpen(STRDEF("local server 2 write"), HRN_FORK_CHILD_WRITE(), 2000)),
"local server 2");
TEST_RESULT_UINT(protocolServerCommandGet(server).id, PROTOCOL_COMMAND_NOOP, "noop command get");
@ -716,9 +716,9 @@ testRun(void)
// Wait for exit
CHECK(protocolServerCommandGet(server).id == PROTOCOL_COMMAND_EXIT);
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
TestParallelJobCallback data = {.jobList = lstNewP(sizeof(ProtocolParallelJob *))};
ProtocolParallel *parallel = NULL;
@ -727,7 +727,7 @@ testRun(void)
// Add client
unsigned int clientTotal = 2;
ProtocolClient *client[HARNESS_FORK_CHILD_MAX];
ProtocolClient *client[HRN_FORK_CHILD_MAX];
for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++)
{
@ -736,9 +736,9 @@ testRun(void)
protocolClientNew(
strNewFmt("local client %u", clientIdx), STRDEF("test"),
ioFdReadNewOpen(
strNewFmt("local client %u read", clientIdx), HARNESS_FORK_PARENT_READ_PROCESS(clientIdx), 2000),
strNewFmt("local client %u read", clientIdx), HRN_FORK_PARENT_READ_PROCESS(clientIdx), 2000),
ioFdWriteNewOpen(
strNewFmt("local client %u write", clientIdx), HARNESS_FORK_PARENT_WRITE_PROCESS(clientIdx), 2000)),
strNewFmt("local client %u write", clientIdx), HRN_FORK_PARENT_WRITE_PROCESS(clientIdx), 2000)),
strZ(strNewFmt("local client %u new", clientIdx)));
TEST_RESULT_VOID(
protocolParallelClientAdd(parallel, client[clientIdx]), strZ(strNewFmt("local client %u add", clientIdx)));
@ -848,9 +848,9 @@ testRun(void)
for (unsigned int clientIdx = 0; clientIdx < clientTotal; clientIdx++)
TEST_RESULT_VOID(protocolClientFree(client[clientIdx]), strZ(strNewFmt("free client %u", clientIdx)));
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
// *****************************************************************************************************************************

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

@ -265,20 +265,20 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("StorageAzure, StorageReadAzure, and StorageWriteAzure"))
{
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
hrnServerRunP(ioFdReadNew(STRDEF("azure server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls),
"azure server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("azure client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdWriteNew(STRDEF("azure client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test against local host");
@ -857,9 +857,9 @@ testRun(void)
// -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -277,46 +277,46 @@ testRun(void)
{
HRN_STORAGE_PUT(storageTest, TEST_KEY_FILE, BUFSTR(strNewFmt(TEST_KEY, strZ(testHost), testPortAuth)));
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("gcs server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
ioFdReadNew(STRDEF("gcs server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.port = testPort),
"gcs server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls,
.port = testPortAuth),
"auth server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("meta server read"), HARNESS_FORK_CHILD_READ(), 10000), hrnServerProtocolSocket,
ioFdReadNew(STRDEF("meta server read"), HRN_FORK_CHILD_READ(), 10000), hrnServerProtocolSocket,
.port = testPortMeta),
"meta server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("gcs client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdWriteNew(STRDEF("gcs client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(1), 2000));
ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000));
IoWrite *meta = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("meta client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(2), 2000));
ioFdWriteNew(STRDEF("meta client write"), HRN_FORK_PARENT_WRITE_PROCESS(2), 2000));
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("test service auth");
@ -976,9 +976,9 @@ testRun(void)
// -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();

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

@ -143,22 +143,22 @@ testRun(void)
HRN_SYSTEM_FMT("rm %s", strZ(fileExists));
// -------------------------------------------------------------------------------------------------------------------------
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, false)
HRN_FORK_CHILD_BEGIN(0, false)
{
sleepMSec(250);
HRN_SYSTEM_FMT("touch %s", strZ(fileExists));
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
TEST_RESULT_BOOL(storageExistsP(storageTest, fileExists, .timeout = 1000), true, "file exists after wait");
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
HRN_SYSTEM_FMT("rm %s", strZ(fileExists));
}

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

@ -351,33 +351,33 @@ testRun(void)
// *****************************************************************************************************************************
if (testBegin("storageS3*(), StorageReadS3, and StorageWriteS3"))
{
HARNESS_FORK_BEGIN()
HRN_FORK_BEGIN()
{
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("s3 server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, .port = port),
ioFdReadNew(STRDEF("s3 server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolTls, .port = port),
"s3 server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_CHILD_BEGIN(0, true)
HRN_FORK_CHILD_BEGIN(0, true)
{
TEST_RESULT_VOID(
hrnServerRunP(
ioFdReadNew(STRDEF("auth server read"), HARNESS_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket,
ioFdReadNew(STRDEF("auth server read"), HRN_FORK_CHILD_READ(), 5000), hrnServerProtocolSocket,
.port = authPort),
"auth server run");
}
HARNESS_FORK_CHILD_END();
HRN_FORK_CHILD_END();
HARNESS_FORK_PARENT_BEGIN()
HRN_FORK_PARENT_BEGIN()
{
IoWrite *service = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("s3 client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(0), 2000));
ioFdWriteNew(STRDEF("s3 client write"), HRN_FORK_PARENT_WRITE_PROCESS(0), 2000));
IoWrite *auth = hrnServerScriptBegin(
ioFdWriteNew(STRDEF("auth client write"), HARNESS_FORK_PARENT_WRITE_PROCESS(1), 2000));
ioFdWriteNew(STRDEF("auth client write"), HRN_FORK_PARENT_WRITE_PROCESS(1), 2000));
// -----------------------------------------------------------------------------------------------------------------
TEST_TITLE("config with keys, token, and host with custom port");
@ -1240,9 +1240,9 @@ testRun(void)
// -----------------------------------------------------------------------------------------------------------------
hrnServerScriptEnd(service);
}
HARNESS_FORK_PARENT_END();
HRN_FORK_PARENT_END();
}
HARNESS_FORK_END();
HRN_FORK_END();
}
FUNCTION_HARNESS_RETURN_VOID();