/***********************************************************************************************************************************
Return signal names
***********************************************************************************************************************************/
static const char *
exitSignalName(int signalType)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(INT, signalType);
FUNCTION_TEST_END();
const char *name = NULL;
switch (signalType)
{
case signalTypeHup:
{
name = "HUP";
break;
}
case signalTypeInt:
{
name = "INT";
break;
}
case signalTypeTerm:
{
name = "TERM";
break;
}
case signalTypeNone:
THROW(AssertError, "no name for signal none");
}
FUNCTION_TEST_RETURN(name);
}
/***********************************************************************************************************************************
Read all IO into a buffer
***********************************************************************************************************************************/
Buffer *
ioReadBuf(IoRead *read)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(IO_READ, read);
FUNCTION_TEST_END();
ASSERT(read != NULL);
Buffer *result = NULL;
MEM_CONTEXT_TEMP_BEGIN()
{
// Read IO into the buffer
result = bufNew(0);
do
{
bufResize(result, bufSize(result) + ioBufferSize());
ioRead(read, result);
}
while (!ioReadEof(read));
// Resize the buffer and move to calling context
bufResize(result, bufUsed(result));
bufMove(result, MEM_CONTEXT_OLD());
}
MEM_CONTEXT_TEMP_END();
FUNCTION_TEST_RETURN(result);
}
/***********************************************************************************************************************************
Dynamic module loader
***********************************************************************************************************************************/
static const char *
embeddedModuleGetInternal(const char *moduleName)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(STRINGZ, moduleName);
FUNCTION_TEST_END();
// Find module
const char *result = NULL;
for (unsigned int moduleIdx = 0; moduleIdx < sizeof(embeddedModule) / sizeof(EmbeddedModule); moduleIdx++)
{
if (strcmp(embeddedModule[moduleIdx].name, moduleName) == 0)
{
result = embeddedModule[moduleIdx].data;
break;
}
}
// Error if the module was not found
if (result == NULL)
THROW_FMT(AssertError, "unable to load embedded module '%s'", moduleName);
FUNCTION_TEST_RETURN(result);
}
void
ioBufferSizeSet(size_t bufferSizeParam)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(SIZE, bufferSizeParam);
FUNCTION_TEST_END();
bufferSize = bufferSizeParam;
FUNCTION_TEST_RETURN_VOID();
}
/***********************************************************************************************************************************
Evaluate a perl statement
***********************************************************************************************************************************/
static void
perlEval(const String *statement)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(STRING, statement);
FUNCTION_TEST_END();
eval_pv(strPtr(statement), TRUE);
FUNCTION_TEST_RETURN_VOID();
}
/***********************************************************************************************************************************
Create the stop filename
***********************************************************************************************************************************/
String *
lockStopFileName(const String *stanza)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(STRING, stanza);
FUNCTION_TEST_END();
String *result = strNewFmt("%s/%s.stop", strPtr(cfgOptionStr(cfgOptLockPath)), stanza != NULL ? strPtr(stanza) : "all");
FUNCTION_TEST_RETURN(result);
}
/***********************************************************************************************************************************
Format the warning when a file is dropped
***********************************************************************************************************************************/
static String *
archivePushDropWarning(const String *walFile, uint64_t queueMax)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(STRING, walFile);
FUNCTION_TEST_PARAM(UINT64, queueMax);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(
strNewFmt("dropped WAL file '%s' because archive queue exceeded %s", strPtr(walFile), strPtr(strSizeFormat(queueMax))));
}
/***********************************************************************************************************************************
Free Perl objects
Don't bother freeing Perl itself since we are about to exit.
***********************************************************************************************************************************/
void
perlFree(int result)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(INT, result);
FUNCTION_TEST_END();
if (my_perl != NULL)
perlEval(strNewFmt(PGBACKREST_MAIN "Cleanup(%d)", result));
FUNCTION_TEST_RETURN_VOID();
}
/***********************************************************************************************************************************
Execute main function in Perl
***********************************************************************************************************************************/
static int perlExecResult(int code, bool errorC, const char *message)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(INT, code);
FUNCTION_TEST_PARAM(BOOL, errorC);
FUNCTION_TEST_PARAM(STRINGZ, message);
FUNCTION_TEST_END();
int result = code;
if (code >= errorTypeCode(&AssertError))
{
if (errorC)
RETHROW();
else
THROW_CODE(code, strlen(message) == 0 ? PERL_EMBED_ERROR : message);
}
FUNCTION_TEST_RETURN(result);
}
