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

Add macros to create constant Variant types.

Browse Source 
These work almost exactly like the String constant macros. However, a struct per variant type was required which meant custom constructors and destructors for each type.

Propagate the variant constants out into the codebase wherever they are useful.
This commit is contained in:
David Steele
2019-04-17 08:04:22 -04:00
parent 2dac4b5986
commit 4c13955c05
37 changed files with 739 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
doc/xml/release.xml
View File

@ -27,6 +27,10 @@
<p>Add <code>STR()</code> macro to create constant <code>String</code> objects from runtime strings.</p>
</release-item>
<release-item>
<p>Add macros to create constant <code>Variant</code> types.</p>
</release-item>
<release-item>
<release-item-contributor-list>
<release-item-contributor id="cynthia.shang"/>

2
src/Makefile
View File

@ -413,7 +413,7 @@ info/infoArchive.o: info/infoArchive.c common/assert.h common/crypto/common.h co
info/infoBackup.o: info/infoBackup.c common/assert.h common/crypto/common.h common/debug.h common/error.auto.h common/error.h common/ini.h common/io/filter/filter.h common/io/filter/group.h common/io/read.h common/io/write.h common/log.h common/logLevel.h common/memContext.h common/stackTrace.h common/time.h common/type/buffer.h common/type/convert.h common/type/json.h common/type/keyValue.h common/type/list.h common/type/string.h common/type/stringList.h common/type/variant.h common/type/variantList.h info/info.h info/infoBackup.h info/infoManifest.h info/infoPg.h postgres/interface.h storage/fileRead.h storage/fileWrite.h storage/helper.h storage/info.h storage/storage.h
$(CC) $(CFLAGS) -c info/infoBackup.c -o info/infoBackup.o
info/infoManifest.o: info/infoManifest.c common/error.auto.h common/error.h common/memContext.h common/type/buffer.h common/type/string.h info/infoManifest.h
info/infoManifest.o: info/infoManifest.c common/error.auto.h common/error.h common/memContext.h common/type/buffer.h common/type/keyValue.h common/type/string.h common/type/variant.h common/type/variantList.h info/infoManifest.h
$(CC) $(CFLAGS) -c info/infoManifest.c -o info/infoManifest.o
info/infoPg.o: info/infoPg.c common/assert.h common/crypto/common.h common/debug.h common/error.auto.h common/error.h common/ini.h common/io/filter/filter.h common/io/filter/group.h common/io/read.h common/io/write.h common/log.h common/logLevel.h common/memContext.h common/stackTrace.h common/time.h common/type/buffer.h common/type/convert.h common/type/json.h common/type/keyValue.h common/type/list.h common/type/string.h common/type/stringList.h common/type/variant.h common/type/variantList.h info/info.h info/infoPg.h postgres/interface.h postgres/version.h storage/fileRead.h storage/fileWrite.h storage/helper.h storage/info.h storage/storage.h

2
src/command/archive/common.c
View File

@ -109,7 +109,7 @@ archiveAsyncStatus(ArchiveMode archiveMode, const String *walSegment, bool confe
THROW_FMT(FormatError, "%s message must be > 0", strPtr(statusFile));
// Get contents
code = varIntForce(varNewStr(strNewN(strPtr(content), (size_t)(linefeedPtr - strPtr(content)))));
code = varIntForce(VARSTR(strNewN(strPtr(content), (size_t)(linefeedPtr - strPtr(content)))));
message = strTrim(strNew(linefeedPtr + 1));
}

8
src/command/archive/get/get.c
View File

@ -211,8 +211,8 @@ cmdArchiveGet(void)
// The async process should not output on the console at all
KeyValue *optionReplace = kvNew();
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_CONSOLE_STR), varNewStrZ("off"));
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_STDERR_STR), varNewStrZ("off"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_CONSOLE_STR), VARSTRDEF("off"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_STDERR_STR), VARSTRDEF("off"));
// Generate command options
StringList *commandExec = cfgExecParam(cfgCmdArchiveGetAsync, optionReplace);
@ -318,9 +318,9 @@ cmdArchiveGetAsync(void)
const String *walSegment = strLstGet(walSegmentList, walSegmentIdx);
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_ARCHIVE_GET_STR);
protocolCommandParamAdd(command, varNewStr(walSegment));
protocolCommandParamAdd(command, VARSTR(walSegment));
protocolParallelJobAdd(parallelExec, protocolParallelJobNew(varNewStr(walSegment), command));
protocolParallelJobAdd(parallelExec, protocolParallelJobNew(VARSTR(walSegment), command));
}
// Process jobs

2
src/command/archive/get/protocol.c
View File

@ -43,7 +43,7 @@ archiveGetProtocol(const String *command, const VariantList *paramList, Protocol
protocolServerResponse(
server,
varNewInt(
VARINT(
archiveGetFile(
storageSpoolWrite(), walSegment, strNewFmt(STORAGE_SPOOL_ARCHIVE_IN "/%s", strPtr(walSegment)), true,
cipherType(cfgOptionStr(cfgOptRepoCipherType)), cfgOptionStr(cfgOptRepoCipherPass))));

2
src/command/archive/push/file.c
View File

@ -86,7 +86,7 @@ archivePushFile(
while (!ioReadEof(read));
ioReadClose(read);
String *walSegmentChecksum = varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR));
const String *walSegmentChecksum = varStr(ioFilterGroupResult(filterGroup, CRYPTO_HASH_FILTER_TYPE_STR));
// If the wal segment already exists in the repo then compare checksums
walSegmentFile = walSegmentFind(storageRepo(), archiveId, archiveFile);

2
src/command/archive/push/protocol.c
View File

@ -41,7 +41,7 @@ archivePushProtocol(const String *command, const VariantList *paramList, Protoco
{
protocolServerResponse(
server,
varNewStr(
VARSTR(
archivePushFile(
varStr(varLstGet(paramList, 0)), varStr(varLstGet(paramList, 1)),
(unsigned int)varUInt64(varLstGet(paramList, 2)), varUInt64(varLstGet(paramList, 3)),

24
src/command/archive/push/push.c
View File

@ -296,8 +296,8 @@ cmdArchivePush(void)
// The async process should not output on the console at all
KeyValue *optionReplace = kvNew();
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_CONSOLE_STR), varNewStrZ("off"));
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_STDERR_STR), varNewStrZ("off"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_CONSOLE_STR), VARSTRDEF("off"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_STDERR_STR), VARSTRDEF("off"));
// Generate command options
StringList *commandExec = cfgExecParam(cfgCmdArchivePushAsync, optionReplace);
@ -455,17 +455,17 @@ cmdArchivePushAsync(void)
const String *walFile = strLstGet(walFileList, walFileIdx);
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_ARCHIVE_PUSH_STR);
protocolCommandParamAdd(command, varNewStr(strNewFmt("%s/%s", strPtr(walPath), strPtr(walFile))));
protocolCommandParamAdd(command, varNewStr(archiveInfo.archiveId));
protocolCommandParamAdd(command, varNewUInt64(archiveInfo.pgVersion));
protocolCommandParamAdd(command, varNewUInt64(archiveInfo.pgSystemId));
protocolCommandParamAdd(command, varNewStr(walFile));
protocolCommandParamAdd(command, varNewUInt64(cipherType(cfgOptionStr(cfgOptRepoCipherType))));
protocolCommandParamAdd(command, varNewStr(archiveInfo.archiveCipherPass));
protocolCommandParamAdd(command, varNewBool(cfgOptionBool(cfgOptCompress)));
protocolCommandParamAdd(command, varNewInt(cfgOptionInt(cfgOptCompressLevel)));
protocolCommandParamAdd(command, VARSTR(strNewFmt("%s/%s", strPtr(walPath), strPtr(walFile))));
protocolCommandParamAdd(command, VARSTR(archiveInfo.archiveId));
protocolCommandParamAdd(command, VARUINT64(archiveInfo.pgVersion));
protocolCommandParamAdd(command, VARUINT64(archiveInfo.pgSystemId));
protocolCommandParamAdd(command, VARSTR(walFile));
protocolCommandParamAdd(command, VARUINT64(cipherType(cfgOptionStr(cfgOptRepoCipherType))));
protocolCommandParamAdd(command, VARSTR(archiveInfo.archiveCipherPass));
protocolCommandParamAdd(command, VARBOOL(cfgOptionBool(cfgOptCompress)));
protocolCommandParamAdd(command, VARINT(cfgOptionInt(cfgOptCompressLevel)));
protocolParallelJobAdd(parallelExec, protocolParallelJobNew(varNewStr(walFile), command));
protocolParallelJobAdd(parallelExec, protocolParallelJobNew(VARSTR(walFile), command));
}
// Process jobs

4
src/command/help/help.c
View File

@ -237,7 +237,7 @@ helpRender(void)
section = STRDEF("command");
}
kvAdd(optionKv, varNewStr(section), varNewInt((int)optionDefId));
kvAdd(optionKv, VARSTR(section), VARINT((int)optionDefId));
if (strlen(cfgDefOptionName(optionDefId)) > optionSizeMax)
optionSizeMax = strlen(cfgDefOptionName(optionDefId));
@ -254,7 +254,7 @@ helpRender(void)
strCatFmt(result, "\n%s Options:\n\n", strPtr(strFirstUpper(strDup(section))));
// Output options
VariantList *optionList = kvGetList(optionKv, varNewStr(section));
VariantList *optionList = kvGetList(optionKv, VARSTR(section));
for (unsigned int optionIdx = 0; optionIdx < varLstSize(optionList); optionIdx++)
{

236
src/command/info/info.c
View File

@ -28,39 +28,39 @@ Constants
***********************************************************************************************************************************/
STRING_STATIC(CFGOPTVAL_INFO_OUTPUT_TEXT_STR, "text");
// Naming convention: <sectionname>_KEY_<keyname>_STR. If the key exists in multiple sections, then <sectionname>_ is omitted.
STRING_STATIC(ARCHIVE_KEY_MIN_STR, "min");
STRING_STATIC(ARCHIVE_KEY_MAX_STR, "max");
STRING_STATIC(BACKREST_KEY_FORMAT_STR, "format");
STRING_STATIC(BACKREST_KEY_VERSION_STR, "version");
STRING_STATIC(BACKUP_KEY_BACKREST_STR, "backrest");
STRING_STATIC(BACKUP_KEY_INFO_STR, "info");
STRING_STATIC(BACKUP_KEY_LABEL_STR, "label");
STRING_STATIC(BACKUP_KEY_PRIOR_STR, "prior");
STRING_STATIC(BACKUP_KEY_REFERENCE_STR, "reference");
STRING_STATIC(BACKUP_KEY_TIMESTAMP_STR, "timestamp");
STRING_STATIC(BACKUP_KEY_TYPE_STR, "type");
STRING_STATIC(DB_KEY_ID_STR, "id");
STRING_STATIC(DB_KEY_SYSTEM_ID_STR, "system-id");
STRING_STATIC(DB_KEY_VERSION_STR, "version");
STRING_STATIC(INFO_KEY_REPOSITORY_STR, "repository");
STRING_STATIC(KEY_ARCHIVE_STR, "archive");
STRING_STATIC(KEY_DATABASE_STR, "database");
STRING_STATIC(KEY_DELTA_STR, "delta");
STRING_STATIC(KEY_SIZE_STR, "size");
STRING_STATIC(KEY_START_STR, "start");
STRING_STATIC(KEY_STOP_STR, "stop");
STRING_STATIC(STANZA_KEY_BACKUP_STR, "backup");
STRING_STATIC(STANZA_KEY_CIPHER_STR, "cipher");
STRING_STATIC(STANZA_VALUE_CIPHER_NONE_STR, "none");
STRING_STATIC(STANZA_KEY_NAME_STR, "name");
STRING_STATIC(STANZA_KEY_STATUS_STR, "status");
STRING_STATIC(STANZA_KEY_DB_STR, "db");
STRING_STATIC(STATUS_KEY_CODE_STR, "code");
STRING_STATIC(STATUS_KEY_MESSAGE_STR, "message");
// Naming convention: <sectionname>_KEY_<keyname>_VAR. If the key exists in multiple sections, then <sectionname>_ is omitted.
VARIANT_STRDEF_STATIC(ARCHIVE_KEY_MIN_VAR, "min");
VARIANT_STRDEF_STATIC(ARCHIVE_KEY_MAX_VAR, "max");
VARIANT_STRDEF_STATIC(BACKREST_KEY_FORMAT_VAR, "format");
VARIANT_STRDEF_STATIC(BACKREST_KEY_VERSION_VAR, "version");
VARIANT_STRDEF_STATIC(BACKUP_KEY_BACKREST_VAR, "backrest");
VARIANT_STRDEF_STATIC(BACKUP_KEY_INFO_VAR, "info");
VARIANT_STRDEF_STATIC(BACKUP_KEY_LABEL_VAR, "label");
VARIANT_STRDEF_STATIC(BACKUP_KEY_PRIOR_VAR, "prior");
VARIANT_STRDEF_STATIC(BACKUP_KEY_REFERENCE_VAR, "reference");
VARIANT_STRDEF_STATIC(BACKUP_KEY_TIMESTAMP_VAR, "timestamp");
VARIANT_STRDEF_STATIC(BACKUP_KEY_TYPE_VAR, "type");
VARIANT_STRDEF_STATIC(DB_KEY_ID_VAR, "id");
VARIANT_STRDEF_STATIC(DB_KEY_SYSTEM_ID_VAR, "system-id");
VARIANT_STRDEF_STATIC(DB_KEY_VERSION_VAR, "version");
VARIANT_STRDEF_STATIC(INFO_KEY_REPOSITORY_VAR, "repository");
VARIANT_STRDEF_STATIC(KEY_ARCHIVE_VAR, "archive");
VARIANT_STRDEF_STATIC(KEY_DATABASE_VAR, "database");
VARIANT_STRDEF_STATIC(KEY_DELTA_VAR, "delta");
VARIANT_STRDEF_STATIC(KEY_SIZE_VAR, "size");
VARIANT_STRDEF_STATIC(KEY_START_VAR, "start");
VARIANT_STRDEF_STATIC(KEY_STOP_VAR, "stop");
VARIANT_STRDEF_STATIC(STANZA_KEY_BACKUP_VAR, "backup");
VARIANT_STRDEF_STATIC(STANZA_KEY_CIPHER_VAR, "cipher");
VARIANT_STRDEF_STATIC(STANZA_KEY_NAME_VAR, "name");
VARIANT_STRDEF_STATIC(STANZA_KEY_STATUS_VAR, "status");
VARIANT_STRDEF_STATIC(STANZA_KEY_DB_VAR, "db");
VARIANT_STRDEF_STATIC(STATUS_KEY_CODE_VAR, "code");
VARIANT_STRDEF_STATIC(STATUS_KEY_MESSAGE_VAR, "message");
#define INFO_STANZA_STATUS_OK "ok"
#define INFO_STANZA_STATUS_ERROR "error"
STRING_STATIC(INFO_STANZA_STATUS_OK, "ok");
STRING_STATIC(INFO_STANZA_STATUS_ERROR, "error");
#define INFO_STANZA_STATUS_CODE_OK 0
STRING_STATIC(INFO_STANZA_STATUS_MESSAGE_OK_STR, "ok");
#define INFO_STANZA_STATUS_CODE_MISSING_STANZA_PATH 1
@ -86,11 +86,10 @@ stanzaStatus(const int code, const String *message, Variant *stanzaInfo)
ASSERT(message != NULL);
ASSERT(stanzaInfo != NULL);
Variant *stanzaStatus = varNewStr(STANZA_KEY_STATUS_STR);
KeyValue *statusKv = kvPutKv(varKv(stanzaInfo), stanzaStatus);
KeyValue *statusKv = kvPutKv(varKv(stanzaInfo), STANZA_KEY_STATUS_VAR);
kvAdd(statusKv, varNewStr(STATUS_KEY_CODE_STR), varNewInt(code));
kvAdd(statusKv, varNewStr(STATUS_KEY_MESSAGE_STR), varNewStr(message));
kvAdd(statusKv, STATUS_KEY_CODE_VAR, VARINT(code));
kvAdd(statusKv, STATUS_KEY_MESSAGE_VAR, VARSTR(message));
FUNCTION_TEST_RETURN_VOID();
}
@ -173,14 +172,13 @@ archiveDbList(const String *stanza, const InfoPgData *pgData, VariantList *archi
if (currentDb || archiveStart != NULL)
{
// Add empty database section to archiveInfo and then fill in database id from the backup.info
KeyValue *databaseInfo = kvPutKv(varKv(archiveInfo), varNewStr(KEY_DATABASE_STR));
KeyValue *databaseInfo = kvPutKv(varKv(archiveInfo), KEY_DATABASE_VAR);
kvAdd(databaseInfo, varNewStr(DB_KEY_ID_STR), varNewUInt64(pgData->id));
kvAdd(databaseInfo, DB_KEY_ID_VAR, VARUINT64(pgData->id));
kvPut(varKv(archiveInfo), varNewStr(DB_KEY_ID_STR), varNewStr(archiveId));
kvPut(
varKv(archiveInfo), varNewStr(ARCHIVE_KEY_MIN_STR), (archiveStart != NULL ? varNewStr(archiveStart) : (Variant *)NULL));
kvPut(varKv(archiveInfo), varNewStr(ARCHIVE_KEY_MAX_STR), (archiveStop != NULL ? varNewStr(archiveStop) : (Variant *)NULL));
kvPut(varKv(archiveInfo), DB_KEY_ID_VAR, VARSTR(archiveId));
kvPut(varKv(archiveInfo), ARCHIVE_KEY_MIN_VAR, (archiveStart != NULL ? VARSTR(archiveStart) : (Variant *)NULL));
kvPut(varKv(archiveInfo), ARCHIVE_KEY_MAX_VAR, (archiveStop != NULL ? VARSTR(archiveStop) : (Variant *)NULL));
varLstAdd(archiveSection, archiveInfo);
}
@ -211,53 +209,53 @@ backupList(VariantList *backupSection, InfoBackup *info)
Variant *backupInfo = varNewKv();
// main keys
kvPut(varKv(backupInfo), varNewStr(BACKUP_KEY_LABEL_STR), varNewStr(backupData.backupLabel));
kvPut(varKv(backupInfo), varNewStr(BACKUP_KEY_TYPE_STR), varNewStr(backupData.backupType));
kvPut(varKv(backupInfo), BACKUP_KEY_LABEL_VAR, VARSTR(backupData.backupLabel));
kvPut(varKv(backupInfo), BACKUP_KEY_TYPE_VAR, VARSTR(backupData.backupType));
kvPut(
varKv(backupInfo), varNewStr(BACKUP_KEY_PRIOR_STR),
(backupData.backupPrior != NULL ? varNewStr(backupData.backupPrior) : NULL));
varKv(backupInfo), BACKUP_KEY_PRIOR_VAR,
(backupData.backupPrior != NULL ? VARSTR(backupData.backupPrior) : NULL));
kvPut(
varKv(backupInfo), varNewStr(BACKUP_KEY_REFERENCE_STR),
varKv(backupInfo), BACKUP_KEY_REFERENCE_VAR,
(backupData.backupReference != NULL ? varNewVarLst(varLstNewStrLst(backupData.backupReference)) : NULL));
// archive section
KeyValue *archiveInfo = kvPutKv(varKv(backupInfo), varNewStr(KEY_ARCHIVE_STR));
KeyValue *archiveInfo = kvPutKv(varKv(backupInfo), KEY_ARCHIVE_VAR);
kvAdd(
archiveInfo, varNewStr(KEY_START_STR),
(backupData.backupArchiveStart != NULL ? varNewStr(backupData.backupArchiveStart) : NULL));
archiveInfo, KEY_START_VAR,
(backupData.backupArchiveStart != NULL ? VARSTR(backupData.backupArchiveStart) : NULL));
kvAdd(
archiveInfo, varNewStr(KEY_STOP_STR),
(backupData.backupArchiveStop != NULL ? varNewStr(backupData.backupArchiveStop) : NULL));
archiveInfo, KEY_STOP_VAR,
(backupData.backupArchiveStop != NULL ? VARSTR(backupData.backupArchiveStop) : NULL));
// backrest section
KeyValue *backrestInfo = kvPutKv(varKv(backupInfo), varNewStr(BACKUP_KEY_BACKREST_STR));
KeyValue *backrestInfo = kvPutKv(varKv(backupInfo), BACKUP_KEY_BACKREST_VAR);
kvAdd(backrestInfo, varNewStr(BACKREST_KEY_FORMAT_STR), varNewUInt64(backupData.backrestFormat));
kvAdd(backrestInfo, varNewStr(BACKREST_KEY_VERSION_STR), varNewStr(backupData.backrestVersion));
kvAdd(backrestInfo, BACKREST_KEY_FORMAT_VAR, VARUINT64(backupData.backrestFormat));
kvAdd(backrestInfo, BACKREST_KEY_VERSION_VAR, VARSTR(backupData.backrestVersion));
// database section
KeyValue *dbInfo = kvPutKv(varKv(backupInfo), varNewStr(KEY_DATABASE_STR));
KeyValue *dbInfo = kvPutKv(varKv(backupInfo), KEY_DATABASE_VAR);
kvAdd(dbInfo, varNewStr(DB_KEY_ID_STR), varNewUInt64(backupData.backupPgId));
kvAdd(dbInfo, DB_KEY_ID_VAR, VARUINT64(backupData.backupPgId));
// info section
KeyValue *infoInfo = kvPutKv(varKv(backupInfo), varNewStr(BACKUP_KEY_INFO_STR));
KeyValue *infoInfo = kvPutKv(varKv(backupInfo), BACKUP_KEY_INFO_VAR);
kvAdd(infoInfo, varNewStr(KEY_SIZE_STR), varNewUInt64(backupData.backupInfoSize));
kvAdd(infoInfo, varNewStr(KEY_DELTA_STR), varNewUInt64(backupData.backupInfoSizeDelta));
kvAdd(infoInfo, KEY_SIZE_VAR, VARUINT64(backupData.backupInfoSize));
kvAdd(infoInfo, KEY_DELTA_VAR, VARUINT64(backupData.backupInfoSizeDelta));
// info:repository section
KeyValue *repoInfo = kvPutKv(infoInfo, varNewStr(INFO_KEY_REPOSITORY_STR));
KeyValue *repoInfo = kvPutKv(infoInfo, INFO_KEY_REPOSITORY_VAR);
kvAdd(repoInfo, varNewStr(KEY_SIZE_STR), varNewUInt64(backupData.backupInfoRepoSize));
kvAdd(repoInfo, varNewStr(KEY_DELTA_STR), varNewUInt64(backupData.backupInfoRepoSizeDelta));
kvAdd(repoInfo, KEY_SIZE_VAR, VARUINT64(backupData.backupInfoRepoSize));
kvAdd(repoInfo, KEY_DELTA_VAR, VARUINT64(backupData.backupInfoRepoSizeDelta));
// timestamp section
KeyValue *timeInfo = kvPutKv(varKv(backupInfo), varNewStr(BACKUP_KEY_TIMESTAMP_STR));
KeyValue *timeInfo = kvPutKv(varKv(backupInfo), BACKUP_KEY_TIMESTAMP_VAR);
kvAdd(timeInfo, varNewStr(KEY_START_STR), varNewUInt64(backupData.backupTimestampStart));
kvAdd(timeInfo, varNewStr(KEY_STOP_STR), varNewUInt64(backupData.backupTimestampStop));
kvAdd(timeInfo, KEY_START_VAR, VARUINT64(backupData.backupTimestampStart));
kvAdd(timeInfo, KEY_STOP_VAR, VARUINT64(backupData.backupTimestampStop));
varLstAdd(backupSection, backupInfo);
}
@ -331,8 +329,8 @@ stanzaInfoList(const String *stanza, StringList *stanzaList)
TRY_END();
// Set the stanza name and cipher
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_NAME_STR), varNewStr(stanzaListName));
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_CIPHER_STR), varNewStr(STANZA_VALUE_CIPHER_NONE_STR));
kvPut(varKv(stanzaInfo), STANZA_KEY_NAME_VAR, VARSTR(stanzaListName));
kvPut(varKv(stanzaInfo), STANZA_KEY_CIPHER_VAR, VARSTR(CIPHER_TYPE_NONE_STR));
// If the backup.info file exists, get the database history information (newest to oldest) and corresponding archive
if (info != NULL)
@ -342,16 +340,16 @@ stanzaInfoList(const String *stanza, StringList *stanzaList)
// out. No such mechanism exists so this will have to do for now. Probably the easiest thing to do is store the
// cipher type in the info file.
if (infoPgCipherPass(infoBackupPg(info)) != NULL)
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_CIPHER_STR), varNewStr(CIPHER_TYPE_AES_256_CBC_STR));
kvPut(varKv(stanzaInfo), STANZA_KEY_CIPHER_VAR, VARSTR(CIPHER_TYPE_AES_256_CBC_STR));
for (unsigned int pgIdx = infoPgDataTotal(infoBackupPg(info)) - 1; (int)pgIdx >= 0; pgIdx--)
{
InfoPgData pgData = infoPgData(infoBackupPg(info), pgIdx);
Variant *pgInfo = varNewKv();
kvPut(varKv(pgInfo), varNewStr(DB_KEY_ID_STR), varNewUInt64(pgData.id));
kvPut(varKv(pgInfo), varNewStr(DB_KEY_SYSTEM_ID_STR), varNewUInt64(pgData.systemId));
kvPut(varKv(pgInfo), varNewStr(DB_KEY_VERSION_STR), varNewStr(pgVersionToStr(pgData.version)));
kvPut(varKv(pgInfo), DB_KEY_ID_VAR, VARUINT64(pgData.id));
kvPut(varKv(pgInfo), DB_KEY_SYSTEM_ID_VAR, VARUINT64(pgData.systemId));
kvPut(varKv(pgInfo), DB_KEY_VERSION_VAR, VARSTR(pgVersionToStr(pgData.version)));
varLstAdd(dbSection, pgInfo);
@ -367,19 +365,19 @@ stanzaInfoList(const String *stanza, StringList *stanzaList)
}
// Add the database history, backup and archive sections to the stanza info
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_DB_STR), varNewVarLst(dbSection));
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_BACKUP_STR), varNewVarLst(backupSection));
kvPut(varKv(stanzaInfo), varNewStr(KEY_ARCHIVE_STR), varNewVarLst(archiveSection));
kvPut(varKv(stanzaInfo), STANZA_KEY_DB_VAR, varNewVarLst(dbSection));
kvPut(varKv(stanzaInfo), STANZA_KEY_BACKUP_VAR, varNewVarLst(backupSection));
kvPut(varKv(stanzaInfo), KEY_ARCHIVE_VAR, varNewVarLst(archiveSection));
// If a status has not already been set and there are no backups then set status to no backup
if (kvGet(varKv(stanzaInfo), varNewStr(STANZA_KEY_STATUS_STR)) == NULL &&
varLstSize(kvGetList(varKv(stanzaInfo), varNewStr(STANZA_KEY_BACKUP_STR))) == 0)
if (kvGet(varKv(stanzaInfo), STANZA_KEY_STATUS_VAR) == NULL &&
varLstSize(kvGetList(varKv(stanzaInfo), STANZA_KEY_BACKUP_VAR)) == 0)
{
stanzaStatus(INFO_STANZA_STATUS_CODE_NO_BACKUP, INFO_STANZA_STATUS_MESSAGE_NO_BACKUP_STR, stanzaInfo);
}
// If a status has still not been set then set it to OK
if (kvGet(varKv(stanzaInfo), varNewStr(STANZA_KEY_STATUS_STR)) == NULL)
if (kvGet(varKv(stanzaInfo), STANZA_KEY_STATUS_VAR) == NULL)
stanzaStatus(INFO_STANZA_STATUS_CODE_OK, INFO_STANZA_STATUS_MESSAGE_OK_STR, stanzaInfo);
varLstAdd(result, stanzaInfo);
@ -390,10 +388,10 @@ stanzaInfoList(const String *stanza, StringList *stanzaList)
{
Variant *stanzaInfo = varNewKv();
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_NAME_STR), varNewStr(stanza));
kvPut(varKv(stanzaInfo), STANZA_KEY_NAME_VAR, VARSTR(stanza));
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_DB_STR), varNewVarLst(varLstNew()));
kvPut(varKv(stanzaInfo), varNewStr(STANZA_KEY_BACKUP_STR), varNewVarLst(varLstNew()));
kvPut(varKv(stanzaInfo), STANZA_KEY_DB_VAR, varNewVarLst(varLstNew()));
kvPut(varKv(stanzaInfo), STANZA_KEY_BACKUP_VAR, varNewVarLst(varLstNew()));
stanzaStatus(INFO_STANZA_STATUS_CODE_MISSING_STANZA_PATH, INFO_STANZA_STATUS_MESSAGE_MISSING_STANZA_PATH_STR, stanzaInfo);
varLstAdd(result, stanzaInfo);
@ -415,15 +413,15 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr)
ASSERT(stanzaInfo != NULL);
VariantList *dbSection = kvGetList(stanzaInfo, varNewStr(STANZA_KEY_DB_STR));
VariantList *archiveSection = kvGetList(stanzaInfo, varNewStr(KEY_ARCHIVE_STR));
VariantList *backupSection = kvGetList(stanzaInfo, varNewStr(STANZA_KEY_BACKUP_STR));
VariantList *dbSection = kvGetList(stanzaInfo, STANZA_KEY_DB_VAR);
VariantList *archiveSection = kvGetList(stanzaInfo, KEY_ARCHIVE_VAR);
VariantList *backupSection = kvGetList(stanzaInfo, STANZA_KEY_BACKUP_VAR);
// For each database (working from oldest to newest) find the corresponding archive and backup info
for (unsigned int dbIdx = 0; dbIdx < varLstSize(dbSection); dbIdx++)
{
KeyValue *pgInfo = varKv(varLstGet(dbSection, dbIdx));
uint64_t dbId = varUInt64(kvGet(pgInfo, varNewStr(DB_KEY_ID_STR)));
uint64_t dbId = varUInt64(kvGet(pgInfo, DB_KEY_ID_VAR));
// List is ordered so 0 is always the current DB index
if (dbIdx == varLstSize(dbSection) - 1)
@ -435,21 +433,21 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr)
for (unsigned int archiveIdx = 0; archiveIdx < varLstSize(archiveSection); archiveIdx++)
{
KeyValue *archiveInfo = varKv(varLstGet(archiveSection, archiveIdx));
KeyValue *archiveDbInfo = varKv(kvGet(archiveInfo, varNewStr(KEY_DATABASE_STR)));
uint64_t archiveDbId = varUInt64(kvGet(archiveDbInfo, varNewStr(DB_KEY_ID_STR)));
KeyValue *archiveDbInfo = varKv(kvGet(archiveInfo, KEY_DATABASE_VAR));
uint64_t archiveDbId = varUInt64(kvGet(archiveDbInfo, DB_KEY_ID_VAR));
if (archiveDbId == dbId)
{
strCatFmt(
archiveResult, "\n wal archive min/max (%s): ",
strPtr(varStr(kvGet(archiveInfo, varNewStr(DB_KEY_ID_STR)))));
strPtr(varStr(kvGet(archiveInfo, DB_KEY_ID_VAR))));
// Get the archive min/max if there are any archives for the database
if (kvGet(archiveInfo, varNewStr(ARCHIVE_KEY_MIN_STR)) != NULL)
if (kvGet(archiveInfo, ARCHIVE_KEY_MIN_VAR) != NULL)
{
strCatFmt(
archiveResult, "%s/%s\n", strPtr(varStr(kvGet(archiveInfo, varNewStr(ARCHIVE_KEY_MIN_STR)))),
strPtr(varStr(kvGet(archiveInfo, varNewStr(ARCHIVE_KEY_MAX_STR)))));
archiveResult, "%s/%s\n", strPtr(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MIN_VAR))),
strPtr(varStr(kvGet(archiveInfo, ARCHIVE_KEY_MAX_VAR))));
}
else
strCat(archiveResult, "none present\n");
@ -462,22 +460,22 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr)
for (unsigned int backupIdx = 0; backupIdx < varLstSize(backupSection); backupIdx++)
{
KeyValue *backupInfo = varKv(varLstGet(backupSection, backupIdx));
KeyValue *backupDbInfo = varKv(kvGet(backupInfo, varNewStr(KEY_DATABASE_STR)));
uint64_t backupDbId = varUInt64(kvGet(backupDbInfo, varNewStr(DB_KEY_ID_STR)));
KeyValue *backupDbInfo = varKv(kvGet(backupInfo, KEY_DATABASE_VAR));
uint64_t backupDbId = varUInt64(kvGet(backupDbInfo, DB_KEY_ID_VAR));
if (backupDbId == dbId)
{
strCatFmt(
backupResult, "\n %s backup: %s\n", strPtr(varStr(kvGet(backupInfo, varNewStr(BACKUP_KEY_TYPE_STR)))),
strPtr(varStr(kvGet(backupInfo, varNewStr(BACKUP_KEY_LABEL_STR)))));
backupResult, "\n %s backup: %s\n", strPtr(varStr(kvGet(backupInfo, BACKUP_KEY_TYPE_VAR))),
strPtr(varStr(kvGet(backupInfo, BACKUP_KEY_LABEL_VAR))));
KeyValue *timestampInfo = varKv(kvGet(backupInfo, varNewStr(BACKUP_KEY_TIMESTAMP_STR)));
KeyValue *timestampInfo = varKv(kvGet(backupInfo, BACKUP_KEY_TIMESTAMP_VAR));
// Get and format the backup start/stop time
static char timeBufferStart[20];
static char timeBufferStop[20];
time_t timeStart = (time_t) varUInt64(kvGet(timestampInfo, varNewStr(KEY_START_STR)));
time_t timeStop = (time_t) varUInt64(kvGet(timestampInfo, varNewStr(KEY_STOP_STR)));
time_t timeStart = (time_t) varUInt64(kvGet(timestampInfo, KEY_START_VAR));
time_t timeStop = (time_t) varUInt64(kvGet(timestampInfo, KEY_STOP_VAR));
strftime(timeBufferStart, 20, "%Y-%m-%d %H:%M:%S", localtime(&timeStart));
strftime(timeBufferStop, 20, "%Y-%m-%d %H:%M:%S", localtime(&timeStop));
@ -486,34 +484,34 @@ formatTextDb(const KeyValue *stanzaInfo, String *resultStr)
backupResult, " timestamp start/stop: %s / %s\n", timeBufferStart, timeBufferStop);
strCat(backupResult, " wal start/stop: ");
KeyValue *archiveDBackupInfo = varKv(kvGet(backupInfo, varNewStr(KEY_ARCHIVE_STR)));
KeyValue *archiveDBackupInfo = varKv(kvGet(backupInfo, KEY_ARCHIVE_VAR));
if (kvGet(archiveDBackupInfo, varNewStr(KEY_START_STR)) != NULL &&
kvGet(archiveDBackupInfo, varNewStr(KEY_STOP_STR)) != NULL)
if (kvGet(archiveDBackupInfo, KEY_START_VAR) != NULL &&
kvGet(archiveDBackupInfo, KEY_STOP_VAR) != NULL)
{
strCatFmt(backupResult, "%s / %s\n", strPtr(varStr(kvGet(archiveDBackupInfo, varNewStr(KEY_START_STR)))),
strPtr(varStr(kvGet(archiveDBackupInfo, varNewStr(KEY_STOP_STR)))));
strCatFmt(backupResult, "%s / %s\n", strPtr(varStr(kvGet(archiveDBackupInfo, KEY_START_VAR))),
strPtr(varStr(kvGet(archiveDBackupInfo, KEY_STOP_VAR))));
}
else
strCat(backupResult, "n/a\n");
KeyValue *info = varKv(kvGet(backupInfo, varNewStr(BACKUP_KEY_INFO_STR)));
KeyValue *info = varKv(kvGet(backupInfo, BACKUP_KEY_INFO_VAR));
strCatFmt(
backupResult, " database size: %s, backup size: %s\n",
strPtr(strSizeFormat(varUInt64Force(kvGet(info, varNewStr(KEY_SIZE_STR))))),
strPtr(strSizeFormat(varUInt64Force(kvGet(info, varNewStr(KEY_DELTA_STR))))));
strPtr(strSizeFormat(varUInt64Force(kvGet(info, KEY_SIZE_VAR)))),
strPtr(strSizeFormat(varUInt64Force(kvGet(info, KEY_DELTA_VAR)))));
KeyValue *repoInfo = varKv(kvGet(info, varNewStr(INFO_KEY_REPOSITORY_STR)));
KeyValue *repoInfo = varKv(kvGet(info, INFO_KEY_REPOSITORY_VAR));
strCatFmt(
backupResult, " repository size: %s, repository backup size: %s\n",
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, varNewStr(KEY_SIZE_STR))))),
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, varNewStr(KEY_DELTA_STR))))));
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_SIZE_VAR)))),
strPtr(strSizeFormat(varUInt64Force(kvGet(repoInfo, KEY_DELTA_VAR)))));
if (kvGet(backupInfo, varNewStr(BACKUP_KEY_REFERENCE_STR)) != NULL)
if (kvGet(backupInfo, BACKUP_KEY_REFERENCE_VAR) != NULL)
{
StringList *referenceList = strLstNewVarLst(varVarLst(kvGet(backupInfo, varNewStr(BACKUP_KEY_REFERENCE_STR))));
StringList *referenceList = strLstNewVarLst(varVarLst(kvGet(backupInfo, BACKUP_KEY_REFERENCE_VAR)));
strCatFmt(backupResult, " backup reference list: %s\n", strPtr(strLstJoin(referenceList, ", ")));
}
}
@ -575,23 +573,23 @@ infoRender(void)
// Stanza name and status
strCatFmt(
resultStr, "stanza: %s\n status: ", strPtr(varStr(kvGet(stanzaInfo, varNewStr(STANZA_KEY_NAME_STR)))));
resultStr, "stanza: %s\n status: ", strPtr(varStr(kvGet(stanzaInfo, STANZA_KEY_NAME_VAR))));
// If an error has occurred, provide the information that is available and move onto next stanza
KeyValue *stanzaStatus = varKv(kvGet(stanzaInfo, varNewStr(STANZA_KEY_STATUS_STR)));
int statusCode = varInt(kvGet(stanzaStatus, varNewStr(STATUS_KEY_CODE_STR)));
KeyValue *stanzaStatus = varKv(kvGet(stanzaInfo, STANZA_KEY_STATUS_VAR));
int statusCode = varInt(kvGet(stanzaStatus, STATUS_KEY_CODE_VAR));
if (statusCode != INFO_STANZA_STATUS_CODE_OK)
{
strCatFmt(
resultStr, "%s (%s)\n", strPtr(INFO_STANZA_STATUS_ERROR),
strPtr(varStr(kvGet(stanzaStatus, varNewStr(STATUS_KEY_MESSAGE_STR)))));
resultStr, "%s (%s)\n", INFO_STANZA_STATUS_ERROR,
strPtr(varStr(kvGet(stanzaStatus, STATUS_KEY_MESSAGE_VAR))));
if (statusCode == INFO_STANZA_STATUS_CODE_MISSING_STANZA_DATA ||
statusCode == INFO_STANZA_STATUS_CODE_NO_BACKUP)
{
strCatFmt(
resultStr, " cipher: %s\n", strPtr(varStr(kvGet(stanzaInfo, varNewStr(STANZA_KEY_CIPHER_STR)))));
resultStr, " cipher: %s\n", strPtr(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
// If there is a backup.info file but no backups, then process the archive info
if (statusCode == INFO_STANZA_STATUS_CODE_NO_BACKUP)
@ -601,11 +599,11 @@ infoRender(void)
continue;
}
else
strCatFmt(resultStr, "%s\n", strPtr(INFO_STANZA_STATUS_OK));
strCatFmt(resultStr, "%s\n", INFO_STANZA_STATUS_OK);
// Cipher
strCatFmt(resultStr, " cipher: %s\n",
strPtr(varStr(kvGet(stanzaInfo, varNewStr(STANZA_KEY_CIPHER_STR)))));
strPtr(varStr(kvGet(stanzaInfo, STANZA_KEY_CIPHER_VAR))));
formatTextDb(stanzaInfo, resultStr);
}

16
src/common/ini.c
View File

@ -60,16 +60,12 @@ iniGetInternal(const Ini *this, const String *section, const String *key)
const Variant *result = NULL;
MEM_CONTEXT_TEMP_BEGIN()
{
// Get the section
KeyValue *sectionKv = varKv(kvGet(this->store, varNewStr(section)));
KeyValue *sectionKv = varKv(kvGet(this->store, VARSTR(section)));
// Section must exist to get the value
if (sectionKv != NULL)
result = kvGet(sectionKv, varNewStr(key));
}
MEM_CONTEXT_TEMP_END();
result = kvGet(sectionKv, VARSTR(key));
FUNCTION_TEST_RETURN(result);
}
@ -146,7 +142,7 @@ iniSectionKeyList(const Ini *this, const String *section)
MEM_CONTEXT_TEMP_BEGIN()
{
// Get the section
KeyValue *sectionKv = varKv(kvGet(this->store, varNewStr(section)));
KeyValue *sectionKv = varKv(kvGet(this->store, VARSTR(section)));
// Return key list if the section exists
if (sectionKv != NULL)
@ -254,7 +250,7 @@ iniParse(Ini *this, const String *content)
THROW_FMT(FormatError, "key is zero-length at line %u: %s", lineIdx++, linePtr);
// Extract the value
Variant *value = varNewStr(strTrim(strNew(lineEqual + 1)));
const Variant *value = VARSTR(strTrim(strNew(lineEqual + 1)));
// Store the section/key/value
iniSet(this, section, key, value);
@ -290,13 +286,13 @@ iniSet(Ini *this, const String *section, const String *key, const Variant *value
MEM_CONTEXT_TEMP_BEGIN()
{
Variant *sectionKey = varNewStr(section);
const Variant *sectionKey = VARSTR(section);
KeyValue *sectionKv = varKv(kvGet(this->store, sectionKey));
if (sectionKv == NULL)
sectionKv = kvPutKv(this->store, sectionKey);
kvAdd(sectionKv, varNewStr(key), value);
kvAdd(sectionKv, VARSTR(key), value);
}
MEM_CONTEXT_TEMP_END();

4
src/common/io/filter/group.c
View File

@ -342,7 +342,7 @@ ioFilterGroupClose(IoFilterGroup *this)
MEM_CONTEXT_TEMP_BEGIN()
{
kvAdd(this->filterResult, varNewStr(ioFilterType(filterData->filter)), filterResult);
kvAdd(this->filterResult, VARSTR(ioFilterType(filterData->filter)), filterResult);
}
MEM_CONTEXT_TEMP_END();
}
@ -408,7 +408,7 @@ ioFilterGroupResult(const IoFilterGroup *this, const String *filterType)
MEM_CONTEXT_TEMP_BEGIN()
{
result = kvGet(this->filterResult, varNewStr(filterType));
result = kvGet(this->filterResult, VARSTR(filterType));
}
MEM_CONTEXT_TEMP_END();

24
src/common/io/http/header.c
View File

@ -87,18 +87,14 @@ httpHeaderAdd(HttpHeader *this, const String *key, const String *value)
ASSERT(key != NULL);
ASSERT(value != NULL);
MEM_CONTEXT_BEGIN(this->memContext)
{
// Make sure the key does not already exist
Variant *keyVar = varNewStr(key);
const Variant *keyVar = VARSTR(key);
if (kvGet(this->kv, keyVar) != NULL)
THROW_FMT(AssertError, "key '%s' already exists", strPtr(key));
// Store the key
kvPut(this->kv, keyVar, varNewStr(value));
}
MEM_CONTEXT_END();
kvPut(this->kv, keyVar, VARSTR(value));
FUNCTION_TEST_RETURN(this);
}
@ -117,15 +113,7 @@ httpHeaderGet(const HttpHeader *this, const String *key)
ASSERT(this != NULL);
ASSERT(key != NULL);
String *result = NULL;
MEM_CONTEXT_BEGIN(this->memContext)
{
result = varStr(kvGet(this->kv, varNewStr(key)));
}
MEM_CONTEXT_END();
FUNCTION_TEST_RETURN(result);
FUNCTION_TEST_RETURN(varStr(kvGet(this->kv, VARSTR(key))));
}
/***********************************************************************************************************************************
@ -178,12 +166,8 @@ httpHeaderPut(HttpHeader *this, const String *key, const String *value)
ASSERT(key != NULL);
ASSERT(value != NULL);
MEM_CONTEXT_BEGIN(this->memContext)
{
// Store the key
kvPut(this->kv, varNewStr(key), varNewStr(value));
}
MEM_CONTEXT_END();
kvPut(this->kv, VARSTR(key), VARSTR(value));
FUNCTION_TEST_RETURN(this);
}

24
src/common/io/http/query.c
View File

@ -54,18 +54,14 @@ httpQueryAdd(HttpQuery *this, const String *key, const String *value)
ASSERT(key != NULL);
ASSERT(value != NULL);
MEM_CONTEXT_BEGIN(this->memContext)
{
// Make sure the key does not already exist
Variant *keyVar = varNewStr(key);
const Variant *keyVar = VARSTR(key);
if (kvGet(this->kv, keyVar) != NULL)
THROW_FMT(AssertError, "key '%s' already exists", strPtr(key));
// Store the key
kvPut(this->kv, keyVar, varNewStr(value));
}
MEM_CONTEXT_END();
kvPut(this->kv, keyVar, VARSTR(value));
FUNCTION_TEST_RETURN(this);
}
@ -84,15 +80,7 @@ httpQueryGet(const HttpQuery *this, const String *key)
ASSERT(this != NULL);
ASSERT(key != NULL);
String *result = NULL;
MEM_CONTEXT_BEGIN(this->memContext)
{
result = varStr(kvGet(this->kv, varNewStr(key)));
}
MEM_CONTEXT_END();
FUNCTION_TEST_RETURN(result);
FUNCTION_TEST_RETURN(varStr(kvGet(this->kv, VARSTR(key))));
}
/***********************************************************************************************************************************
@ -145,12 +133,8 @@ httpQueryPut(HttpQuery *this, const String *key, const String *value)
ASSERT(key != NULL);
ASSERT(value != NULL);
MEM_CONTEXT_BEGIN(this->memContext)
{
// Store the key
kvPut(this->kv, varNewStr(key), varNewStr(value));
}
MEM_CONTEXT_END();
kvPut(this->kv, VARSTR(key), VARSTR(value));
FUNCTION_TEST_RETURN(this);
}

2
src/common/type/json.c
View File

@ -436,7 +436,7 @@ kvToJsonInternal(const KeyValue *kv, String *indentSpace, String *indentDepth)
for (unsigned int keyIdx = 0; keyIdx < strLstSize(keyList); keyIdx++)
{
String *key = strLstGet(keyList, keyIdx);
const Variant *value = kvGet(kv, varNewStr(key));
const Variant *value = kvGet(kv, VARSTR(key));
// If going to add another key, prepend a comma
if (keyIdx > 0)

273
src/common/type/variant.c
View File

@ -14,15 +14,81 @@ Variant Data Type
#include "common/type/convert.h"
#include "common/type/variant.h"
/***********************************************************************************************************************************
Constant variants that are generally useful
***********************************************************************************************************************************/
// Used to declare Bool Variant constants that will be externed using VARIANT_DECLARE(). Must be used in a .c file.
#define VARIANT_BOOL_EXTERN(name, dataParam) \
const Variant *name = ((const Variant *)&(const VariantBoolConst){.type = varTypeBool, .data = dataParam})
VARIANT_BOOL_EXTERN(BOOL_FALSE_VAR, false);
VARIANT_BOOL_EXTERN(BOOL_TRUE_VAR, true);
/***********************************************************************************************************************************
Information about the variant
***********************************************************************************************************************************/
struct Variant
{
MemContext *memContext; // Mem context
unsigned int type:3; // Variant Type
MemContext *memContext; // Mem context
};
typedef struct VariantBool
{
VARIANT_COMMON
VARIANT_BOOL_COMMON
MemContext *memContext;
} VariantBool;
typedef struct VariantDouble
{
VARIANT_COMMON
VARIANT_DOUBLE_COMMON
MemContext *memContext;
} VariantDouble;
typedef struct VariantInt
{
VARIANT_COMMON
VARIANT_INT_COMMON
MemContext *memContext;
} VariantInt;
typedef struct VariantInt64
{
VARIANT_COMMON
VARIANT_INT64_COMMON
MemContext *memContext;
} VariantInt64;
typedef struct VariantKeyValue
{
VARIANT_COMMON
KeyValue *data; /* KeyValue data */
MemContext *memContext;
} VariantKeyValue;
typedef struct VariantString
{
VARIANT_COMMON
VARIANT_STRING_COMMON
MemContext *memContext;
} VariantString;
typedef struct VariantUInt64
{
VARIANT_COMMON
VARIANT_UINT64_COMMON
MemContext *memContext;
} VariantUInt64;
typedef struct VariantVariantList
{
VARIANT_COMMON
VariantList *data; /* VariantList data */
MemContext *memContext;
} VariantVariantList;
/***********************************************************************************************************************************
Variant type names
***********************************************************************************************************************************/
@ -38,47 +104,6 @@ static const char *variantTypeName[] =
"uint64", // varTypeUInt64
};
/***********************************************************************************************************************************
New variant of any supported type
***********************************************************************************************************************************/
static Variant *
varNewInternal(VariantType type, void *data, size_t dataSize)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(ENUM, type);
FUNCTION_TEST_PARAM_P(VOID, data);
FUNCTION_TEST_PARAM(SIZE, dataSize);
FUNCTION_TEST_END();
ASSERT(data != NULL);
ASSERT(dataSize > 0);
// Allocate memory for the variant and set the type
Variant *this = memNew(sizeof(Variant) + dataSize);
this->memContext = memContextCurrent();
this->type = type;
// Copy data
memcpy((unsigned char *)this + sizeof(Variant), data, dataSize);
FUNCTION_TEST_RETURN(this);
}
/***********************************************************************************************************************************
Get a pointer to the data stored in the variant. This hides the complicated pointer arithmetic.
***********************************************************************************************************************************/
static void *
varData(const Variant *this)
{
FUNCTION_TEST_BEGIN();
FUNCTION_TEST_PARAM(VARIANT, this);
FUNCTION_TEST_END();
ASSERT(this != NULL);
FUNCTION_TEST_RETURN((void *)((unsigned char *)this + sizeof(Variant)));
}
/***********************************************************************************************************************************
Duplicate a variant
***********************************************************************************************************************************/
@ -127,8 +152,12 @@ varDup(const Variant *this)
case varTypeKeyValue:
{
KeyValue *data = kvDup(varKv(this));
result = varNewInternal(varTypeKeyValue, (void *)&data, sizeof(data));
VariantKeyValue *keyValue = memNew(sizeof(VariantKeyValue));
keyValue->memContext = memContextCurrent();
keyValue->type = varTypeKeyValue;
keyValue->data = kvDup(varKv(this));
result = (Variant *)keyValue;
break;
}
@ -244,7 +273,13 @@ varNewBool(bool data)
FUNCTION_TEST_PARAM(BOOL, data);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(varNewInternal(varTypeBool, (void *)&data, sizeof(data)));
// Allocate memory for the variant and set the type and data
VariantBool *this = memNew(sizeof(VariantBool));
this->memContext = memContextCurrent();
this->type = varTypeBool;
this->data = data;
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -258,10 +293,9 @@ varBool(const Variant *this)
FUNCTION_TEST_END();
ASSERT(this != NULL);
ASSERT(this->type == varTypeBool);
FUNCTION_TEST_RETURN(*((bool *)varData(this)));
FUNCTION_TEST_RETURN(((VariantBool *)this)->data);
}
/***********************************************************************************************************************************
@ -340,7 +374,13 @@ varNewDbl(double data)
FUNCTION_TEST_PARAM(DOUBLE, data);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(varNewInternal(varTypeDouble, (unsigned char *)&data, sizeof(data)));
// Allocate memory for the variant and set the type and data
VariantDouble *this = memNew(sizeof(VariantDouble));
this->memContext = memContextCurrent();
this->type = varTypeDouble;
this->data = data;
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -354,10 +394,9 @@ varDbl(const Variant *this)
FUNCTION_TEST_END();
ASSERT(this != NULL);
ASSERT(this->type == varTypeDouble);
FUNCTION_TEST_RETURN(*((double *)varData(this)));
FUNCTION_TEST_RETURN(((VariantDouble *)this)->data);
}
/***********************************************************************************************************************************
@ -429,7 +468,13 @@ varNewInt(int data)
FUNCTION_TEST_PARAM(INT, data);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(varNewInternal(varTypeInt, (void *)&data, sizeof(data)));
// Allocate memory for the variant and set the type and data
VariantInt *this = memNew(sizeof(VariantInt));
this->memContext = memContextCurrent();
this->type = varTypeInt;
this->data = data;
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -443,10 +488,9 @@ varInt(const Variant *this)
FUNCTION_TEST_END();
ASSERT(this != NULL);
ASSERT(this->type == varTypeInt);
FUNCTION_TEST_RETURN(*((int *)varData(this)));
FUNCTION_TEST_RETURN(((VariantInt *)this)->data);
}
/***********************************************************************************************************************************
@ -528,7 +572,13 @@ varNewInt64(int64_t data)
FUNCTION_TEST_PARAM(INT64, data);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(varNewInternal(varTypeInt64, (void *)&data, sizeof(data)));
// Allocate memory for the variant and set the type and data
VariantInt64 *this = memNew(sizeof(VariantInt64));
this->memContext = memContextCurrent();
this->type = varTypeInt64;
this->data = data;
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -542,10 +592,9 @@ varInt64(const Variant *this)
FUNCTION_TEST_END();
ASSERT(this != NULL);
ASSERT(this->type == varTypeInt64);
FUNCTION_TEST_RETURN(*((int64_t *)varData(this)));
FUNCTION_TEST_RETURN(((VariantInt64 *)this)->data);
}
/***********************************************************************************************************************************
@ -622,7 +671,13 @@ varNewUInt64(uint64_t data)
FUNCTION_TEST_PARAM(UINT64, data);
FUNCTION_TEST_END();
FUNCTION_TEST_RETURN(varNewInternal(varTypeUInt64, (void *)&data, sizeof(data)));
// Allocate memory for the variant and set the type and data
VariantUInt64 *this = memNew(sizeof(VariantUInt64));
this->memContext = memContextCurrent();
this->type = varTypeUInt64;
this->data = data;
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -636,10 +691,9 @@ varUInt64(const Variant *this)
FUNCTION_TEST_END();
ASSERT(this != NULL);
ASSERT(this->type == varTypeUInt64);
FUNCTION_TEST_RETURN(*((uint64_t *)varData(this)));
FUNCTION_TEST_RETURN(((VariantUInt64 *)this)->data);
}
/***********************************************************************************************************************************
@ -725,10 +779,13 @@ varNewKv(void)
{
FUNCTION_TEST_VOID();
// Create a new kv for the variant
KeyValue *data = kvNew();
// Allocate memory for the variant and set the type and data
VariantKeyValue *this = memNew(sizeof(VariantKeyValue));
this->memContext = memContextCurrent();
this->type = varTypeKeyValue;
this->data = kvNew();
FUNCTION_TEST_RETURN(varNewInternal(varTypeKeyValue, (void *)&data, sizeof(data)));
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -746,7 +803,7 @@ varKv(const Variant *this)
if (this != NULL)
{
ASSERT(this->type == varTypeKeyValue);
result = *((KeyValue **)varData(this));
result = ((VariantKeyValue *)this)->data;
}
FUNCTION_TEST_RETURN(result);
@ -762,10 +819,13 @@ varNewStr(const String *data)
FUNCTION_TEST_PARAM(STRING, data);
FUNCTION_TEST_END();
// Create a copy of the string for the variant
String *dataCopy = strDup(data);
// Allocate memory for the variant and set the type and data
VariantString *this = memNew(sizeof(VariantString));
this->memContext = memContextCurrent();
this->type = varTypeString;
this->data = strDup(data);
FUNCTION_TEST_RETURN(varNewInternal(varTypeString, (void *)&dataCopy, sizeof(dataCopy)));
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -778,19 +838,13 @@ varNewStrZ(const char *data)
FUNCTION_TEST_PARAM(STRINGZ, data);
FUNCTION_TEST_END();
// Create a string for the variant
String *dataCopy = NULL;
if (data != NULL)
dataCopy = strNew(data);
FUNCTION_TEST_RETURN(varNewInternal(varTypeString, (void *)&dataCopy, sizeof(dataCopy)));
FUNCTION_TEST_RETURN(varNewStr(data == NULL ? NULL : strNew(data)));
}
/***********************************************************************************************************************************
Return string
***********************************************************************************************************************************/
String *
const String *
varStr(const Variant *this)
{
FUNCTION_TEST_BEGIN();
@ -802,7 +856,7 @@ varStr(const Variant *this)
if (this != NULL)
{
ASSERT(this->type == varTypeString);
result = *((String **)varData(this));
result = ((VariantString *)this)->data;
}
FUNCTION_TEST_RETURN(result);
@ -892,13 +946,15 @@ varNewVarLst(const VariantList *data)
FUNCTION_TEST_PARAM(VARIANT_LIST, data);
FUNCTION_TEST_END();
VariantList *dataCopy = NULL;
// Allocate memory for the variant and set the type and data
VariantVariantList *this = memNew(sizeof(VariantVariantList));
this->memContext = memContextCurrent();
this->type = varTypeVariantList;
// Create a copy of the variant list if it is not null
if (data != NULL)
dataCopy = varLstDup(data);
this->data = varLstDup(data);
FUNCTION_TEST_RETURN(varNewInternal(varTypeVariantList, (void *)&dataCopy, sizeof(dataCopy)));
FUNCTION_TEST_RETURN((Variant *)this);
}
/***********************************************************************************************************************************
@ -916,7 +972,7 @@ varVarLst(const Variant *this)
if (this != NULL)
{
ASSERT(this->type == varTypeVariantList);
result = *((VariantList **)varData(this));
result = ((VariantVariantList *)this)->data;
}
FUNCTION_TEST_RETURN(result);
@ -981,40 +1037,71 @@ varFree(Variant *this)
if (this != NULL)
{
MEM_CONTEXT_BEGIN(this->memContext)
MemContext *contextOld = memContextCurrent();
TRY_BEGIN()
{
switch (this->type)
{
case varTypeBool:
{
memContextSwitch(((VariantBool *)this)->memContext);
break;
}
case varTypeDouble:
{
memContextSwitch(((VariantDouble *)this)->memContext);
break;
}
case varTypeInt:
{
memContextSwitch(((VariantInt *)this)->memContext);
break;
}
case varTypeInt64:
{
memContextSwitch(((VariantInt64 *)this)->memContext);
break;
}
case varTypeKeyValue:
{
kvFree(varKv(this));
memContextSwitch(((VariantKeyValue *)this)->memContext);
kvFree(((VariantKeyValue *)this)->data);
break;
}
case varTypeString:
{
strFree(varStr(this));
memContextSwitch(((VariantString *)this)->memContext);
strFree(((VariantString *)this)->data);
break;
}
case varTypeUInt64:
{
memContextSwitch(((VariantUInt64 *)this)->memContext);
break;
}
case varTypeVariantList:
{
varLstFree(varVarLst(this));
memContextSwitch(((VariantVariantList *)this)->memContext);
varLstFree(((VariantVariantList *)this)->data);
break;
}
// Nothing additional to free for these types
case varTypeBool:
case varTypeDouble:
case varTypeInt:
case varTypeInt64:
case varTypeUInt64:
break;
}
memFree(this);
}
MEM_CONTEXT_END();
FINALLY()
{
memContextSwitch(contextOld);
}
TRY_END();
}
FUNCTION_TEST_RETURN_VOID();

125
src/common/type/variant.h
View File

@ -68,7 +68,7 @@ KeyValue *varKv(const Variant *this);
Variant *varNewStr(const String *data);
Variant *varNewStrZ(const char *data);
String *varStr(const Variant *this);
const String *varStr(const Variant *this);
String *varStrForce(const Variant *this);
Variant *varNewUInt64(uint64_t data);
@ -84,6 +84,129 @@ VariantType varType(const Variant *this);
void varFree(Variant *this);
/***********************************************************************************************************************************
Fields that are common between dynamically allocated and constant variants
There is nothing user-accessible here but this construct allows constant variants to be created and then handled by the same
functions that process dynamically allocated variant.
***********************************************************************************************************************************/
#define VARIANT_COMMON \
VariantType type; /* Variant type */
#define VARIANT_BOOL_COMMON \
bool data; /* Boolean data */
typedef struct VariantBoolConst
{
VARIANT_COMMON
const VARIANT_BOOL_COMMON
} VariantBoolConst;
#define VARIANT_DOUBLE_COMMON \
double data; /* Double data */
typedef struct VariantDoubleConst
{
VARIANT_COMMON
const VARIANT_DOUBLE_COMMON
} VariantDoubleConst;
#define VARIANT_INT_COMMON \
int data; /* Signed integer data */
typedef struct VariantIntConst
{
VARIANT_COMMON
const VARIANT_INT_COMMON
} VariantIntConst;
#define VARIANT_INT64_COMMON \
int64_t data; /* 64-bit signed integer data */
typedef struct VariantInt64Const
{
VARIANT_COMMON
const VARIANT_INT64_COMMON
} VariantInt64Const;
#define VARIANT_STRING_COMMON \
String *data; /* String data */
typedef struct VariantStringConst
{
VARIANT_COMMON
const VARIANT_STRING_COMMON
} VariantStringConst;
#define VARIANT_UINT64_COMMON \
uint64_t data; /* 64-bit unsigned integer data */
typedef struct VariantUInt64Const
{
VARIANT_COMMON
const VARIANT_UINT64_COMMON
} VariantUInt64Const;
/***********************************************************************************************************************************
Macros for constant variants
Frequently used constant variants can be declared with these macros at compile time rather than dynamically at run time.
Note that variants created in this way are declared as const so can't be modified or freed by the var*() methods. Casting to
Variant * will generally result in a segfault.
By convention all variant constant identifiers are appended with _VAR.
***********************************************************************************************************************************/
// Create a Bool Variant constant inline from a bool
#define VARBOOL(dataParam) \
(dataParam ? BOOL_TRUE_VAR : BOOL_FALSE_VAR)
// Create a Double Variant constant inline from a double
#define VARDBL(dataParam) \
((const Variant *)&(const VariantDoubleConst){.type = varTypeDouble, .data = dataParam})
// Create an Int Variant constant inline from an int
#define VARINT(dataParam) \
((const Variant *)&(const VariantIntConst){.type = varTypeInt, .data = dataParam})
// Create an Int64 Variant constant inline from an int64_t
#define VARINT64(dataParam) \
((const Variant *)&(const VariantInt64Const){.type = varTypeInt64, .data = dataParam})
// Create a String Variant constant inline from any zero-terminated string
#define VARSTRZ(dataParam) \
((const Variant *)&(const VariantStringConst){.type = varTypeString, .data = STR(dataParam)})
// Create a String Variant constant inline from a #define or inline string constant
#define VARSTRDEF(dataParam) \
((const Variant *)&(const VariantStringConst){.type = varTypeString, .data = STRDEF(dataParam)})
// Create a String Variant constant inline from a String constant
#define VARSTR(dataParam) \
((const Variant *)&(const VariantStringConst){.type = varTypeString, .data = dataParam})
// Used to declare String Variant constants that will be externed using VARIANT_DECLARE(). Must be used in a .c file.
#define VARIANT_STRDEF_EXTERN(name, dataParam) \
const Variant *name = VARSTRDEF(dataParam)
// Used to declare String Variant constants that will be local to the .c file. Must be used in a .c file.
#define VARIANT_STRDEF_STATIC(name, dataParam) \
static const Variant *name = VARSTRDEF(dataParam)
// Create a UInt64 Variant constant inline from a uint64_t
#define VARUINT64(dataParam) \
((const Variant *)&(const VariantUInt64Const){.type = varTypeUInt64, .data = dataParam})
// Used to extern String Variant constants declared with VARIANT_STRDEF_EXTERN/STATIC(). Must be used in a .h file.
#define VARIANT_DECLARE(name) \
extern const Variant *name
/***********************************************************************************************************************************
Constant variants that are generally useful
***********************************************************************************************************************************/
VARIANT_DECLARE(BOOL_FALSE_VAR);
VARIANT_DECLARE(BOOL_TRUE_VAR);
/***********************************************************************************************************************************
Macros for function logging
***********************************************************************************************************************************/

4
src/config/exec.c
View File

@ -35,7 +35,7 @@ cfgExecParam(ConfigCommand commandId, const KeyValue *optionReplace)
continue;
// First check for a replacement
const Variant *key = varNewStr(STR(cfgOptionName(optionId)));
const Variant *key = VARSTRZ(cfgOptionName(optionId));
const Variant *value = NULL;
bool exists = false;
@ -55,7 +55,7 @@ cfgExecParam(ConfigCommand commandId, const KeyValue *optionReplace)
if (value == NULL && cfgOptionValid(optionId))
{
if (cfgOptionNegate(optionId))
value = varNewBool(false);
value = BOOL_FALSE_VAR;
else if (cfgOptionSource(optionId) != cfgSourceDefault)
value = cfgOption(optionId);
}

14
src/config/load.c
View File

@ -65,7 +65,7 @@ cfgLoadUpdateOption(void)
// Set default for repo-host-cmd
if (cfgOptionTest(cfgOptRepoHost) && cfgOptionSource(cfgOptRepoHostCmd) == cfgSourceDefault)
cfgOptionDefaultSet(cfgOptRepoHostCmd, varNewStr(cfgExe()));
cfgOptionDefaultSet(cfgOptRepoHostCmd, VARSTR(cfgExe()));
// Set default for pg-host-cmd
if (cfgOptionValid(cfgOptPgHostCmd))
@ -73,7 +73,7 @@ cfgLoadUpdateOption(void)
for (unsigned int optionIdx = 0; optionIdx < cfgOptionIndexTotal(cfgOptPgHost); optionIdx++)
{
if (cfgOptionTest(cfgOptPgHost + optionIdx) && cfgOptionSource(cfgOptPgHostCmd + optionIdx) == cfgSourceDefault)
cfgOptionDefaultSet(cfgOptPgHostCmd + optionIdx, varNewStr(cfgExe()));
cfgOptionDefaultSet(cfgOptPgHostCmd + optionIdx, VARSTR(cfgExe()));
}
}
@ -83,7 +83,7 @@ cfgLoadUpdateOption(void)
{
// If protocol-timeout is default then increase it to be greater than db-timeout
if (cfgOptionSource(cfgOptProtocolTimeout) == cfgSourceDefault)
cfgOptionSet(cfgOptProtocolTimeout, cfgSourceDefault, varNewDbl(cfgOptionDbl(cfgOptDbTimeout) + 30));
cfgOptionSet(cfgOptProtocolTimeout, cfgSourceDefault, VARDBL(cfgOptionDbl(cfgOptDbTimeout) + 30));
else if (cfgOptionSource(cfgOptDbTimeout) == cfgSourceDefault)
{
double dbTimeout = cfgOptionDbl(cfgOptProtocolTimeout) - 30;
@ -91,11 +91,11 @@ cfgLoadUpdateOption(void)
// Normally the protocol time will be greater than 45 seconds so db timeout can be at least 15 seconds
if (dbTimeout >= 15)
{
cfgOptionSet(cfgOptDbTimeout, cfgSourceDefault, varNewDbl(dbTimeout));
cfgOptionSet(cfgOptDbTimeout, cfgSourceDefault, VARDBL(dbTimeout));
}
// But in some test cases the protocol timeout will be very small so make db timeout half of protocol timeout
else
cfgOptionSet(cfgOptDbTimeout, cfgSourceDefault, varNewDbl(cfgOptionDbl(cfgOptProtocolTimeout) / 2));
cfgOptionSet(cfgOptDbTimeout, cfgSourceDefault, VARDBL(cfgOptionDbl(cfgOptProtocolTimeout) / 2));
}
else
{
@ -172,7 +172,7 @@ cfgLoadUpdateOption(void)
if (cfgOptionTest(cfgOptRepoRetentionFull + optionIdx))
{
cfgOptionSet(cfgOptRepoRetentionArchive + optionIdx, cfgSourceDefault,
varNewInt(cfgOptionInt(cfgOptRepoRetentionFull + optionIdx)));
VARINT(cfgOptionInt(cfgOptRepoRetentionFull + optionIdx)));
}
}
else if (strEqZ(archiveRetentionType, CFGOPTVAL_TMP_REPO_RETENTION_ARCHIVE_TYPE_DIFF))
@ -181,7 +181,7 @@ cfgLoadUpdateOption(void)
if (cfgOptionTest(cfgOptRepoRetentionDiff + optionIdx))
{
cfgOptionSet(cfgOptRepoRetentionArchive + optionIdx, cfgSourceDefault,
varNewInt(cfgOptionInt(cfgOptRepoRetentionDiff + optionIdx)));
VARINT(cfgOptionInt(cfgOptRepoRetentionDiff + optionIdx)));
}
else
{

24
src/config/parse.c
View File

@ -173,8 +173,8 @@ convertToByte(String **value, double *valueDbl)
}
// Convert string to bytes
double newDbl = varDblForce(varNewStr(result)) * multiplier;
result = varStrForce(varNewDbl(newDbl));
double newDbl = varDblForce(VARSTR(result)) * multiplier;
result = varStrForce(VARDBL(newDbl));
// If nothing has blown up then safe to overwrite the original values
*valueDbl = newDbl;
@ -718,7 +718,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
}
// Make sure this option does not appear in the same section with an alternate name
Variant *optionFoundKey = varNewInt(optionId);
const Variant *optionFoundKey = VARINT(optionId);
const Variant *optionFoundName = kvGet(optionFound, optionFoundKey);
if (optionFoundName != NULL)
@ -728,7 +728,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
strPtr(key), strPtr(varStr(optionFoundName)), strPtr(section));
}
else
kvPut(optionFound, optionFoundKey, varNewStr(key));
kvPut(optionFound, optionFoundKey, VARSTR(key));
// Continue if the option is not valid for this command
if (!cfgDefOptionValid(commandDefId, optionDefId))
@ -854,9 +854,9 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (dependOptionDefType == cfgDefOptTypeBoolean)
{
if (cfgOptionBool(dependOptionId))
dependValue = varNewStrZ("1");
dependValue = VARSTRDEF("1");
else
dependValue = varNewStrZ("0");
dependValue = VARSTRDEF("0");
}
}
@ -956,7 +956,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
{
if (optionDefType == cfgDefOptTypeBoolean)
{
cfgOptionSet(optionId, parseOption->source, varNewBool(!parseOption->negate));
cfgOptionSet(optionId, parseOption->source, VARBOOL(!parseOption->negate));
}
else if (optionDefType == cfgDefOptTypeHash)
{
@ -975,7 +975,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
strPtr(strLstGet(parseOption->valueList, listIdx)), cfgOptionName(optionId));
}
kvPut(keyValue, varNewStr(strNewN(pair, (size_t)(equal - pair))), varNewStr(STR(equal + 1)));
kvPut(keyValue, VARSTR(strNewN(pair, (size_t)(equal - pair))), VARSTRZ(equal + 1));
}
cfgOptionSet(optionId, parseOption->source, value);
@ -1000,14 +1000,14 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
if (optionDefType == cfgDefOptTypeInteger)
{
valueDbl = (double)varInt64Force(varNewStr(value));
valueDbl = (double)varInt64Force(VARSTR(value));
}
else if (optionDefType == cfgDefOptTypeSize)
{
convertToByte(&value, &valueDbl);
}
else
valueDbl = varDblForce(varNewStr(value));
valueDbl = varDblForce(VARSTR(value));
}
CATCH(AssertError)
{
@ -1072,7 +1072,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
cfgOptionName(optionId));
}
cfgOptionSet(optionId, parseOption->source, varNewStr(value));
cfgOptionSet(optionId, parseOption->source, VARSTR(value));
}
}
else if (parseOption->negate)
@ -1084,7 +1084,7 @@ configParse(unsigned int argListSize, const char *argList[], bool resetLogLevel)
const char *value = cfgDefOptionDefault(commandDefId, optionDefId);
if (value != NULL)
cfgOptionSet(optionId, cfgSourceDefault, varNewStrZ(value));
cfgOptionSet(optionId, cfgSourceDefault, VARSTRZ(value));
else if (cfgOptionIndex(optionId) == 0 && cfgDefOptionRequired(commandDefId, optionDefId) &&
!cfgCommandHelp())
{

7
src/info/info.c
View File

@ -159,7 +159,7 @@ infoLoad(Info *this, const Storage *storage, bool copyFile, CipherType cipherTyp
iniParse(this->ini, strNewBuf(buffer));
// Make sure the ini is valid by testing the checksum
String *infoChecksum = varStr(iniGet(this->ini, INFO_SECTION_BACKREST_STR, INFO_KEY_CHECKSUM_STR));
const String *infoChecksum = varStr(iniGet(this->ini, INFO_SECTION_BACKREST_STR, INFO_KEY_CHECKSUM_STR));
CryptoHash *hash = infoHash(this->ini);
@ -255,13 +255,10 @@ infoNew(const Storage *storage, const String *fileName, CipherType cipherType, c
TRY_END();
// Load the cipher passphrase if it exists
String *cipherPass = varStr(iniGetDefault(this->ini, INFO_SECTION_CIPHER_STR, INFO_KEY_CIPHER_PASS_STR, NULL));
const String *cipherPass = varStr(iniGetDefault(this->ini, INFO_SECTION_CIPHER_STR, INFO_KEY_CIPHER_PASS_STR, NULL));
if (cipherPass != NULL)
{
this->cipherPass = strSubN(cipherPass, 1, strSize(cipherPass) - 2);
strFree(cipherPass);
}
}
MEM_CONTEXT_NEW_END();

57
src/info/infoBackup.c
View File

@ -26,11 +26,11 @@ Internal constants
#define INFO_BACKUP_SECTION "backup"
#define INFO_BACKUP_SECTION_BACKUP_CURRENT INFO_BACKUP_SECTION ":current"
STRING_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_STR, "backup-info-repo-size");
STRING_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_DELTA_STR, "backup-info-repo-size-delta");
STRING_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_STR, "backup-info-size");
STRING_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_DELTA_STR, "backup-info-size-delta");
STRING_STATIC(INFO_BACKUP_KEY_BACKUP_REFERENCE_STR, "backup-reference");
VARIANT_STRDEF_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_VAR, "backup-info-repo-size");
VARIANT_STRDEF_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_DELTA_VAR, "backup-info-repo-size-delta");
VARIANT_STRDEF_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_VAR, "backup-info-size");
VARIANT_STRDEF_STATIC(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_DELTA_VAR, "backup-info-size-delta");
VARIANT_STRDEF_STATIC(INFO_BACKUP_KEY_BACKUP_REFERENCE_VAR, "backup-reference");
/***********************************************************************************************************************************
Object type
@ -104,35 +104,34 @@ infoBackupNew(const Storage *storage, const String *fileName, bool ignoreMissing
InfoBackupData infoBackupData =
{
.backrestFormat = (unsigned int)varUInt64(kvGet(backupKv, varNewStr(INFO_KEY_FORMAT_STR))),
.backrestVersion = varStrForce(kvGet(backupKv, varNewStr(INFO_KEY_VERSION_STR))),
.backupInfoRepoSize = varUInt64(kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_STR))),
.backupInfoRepoSizeDelta = varUInt64(
kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_DELTA_STR))),
.backupInfoSize = varUInt64(kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_STR))),
.backupInfoSizeDelta = varUInt64(kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_INFO_SIZE_DELTA_STR))),
.backrestFormat = (unsigned int)varUInt64(kvGet(backupKv, VARSTR(INFO_KEY_FORMAT_STR))),
.backrestVersion = varStrForce(kvGet(backupKv, VARSTR(INFO_KEY_VERSION_STR))),
.backupInfoRepoSize = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_VAR)),
.backupInfoRepoSizeDelta = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_REPO_SIZE_DELTA_VAR)),
.backupInfoSize = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_SIZE_VAR)),
.backupInfoSizeDelta = varUInt64(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_INFO_SIZE_DELTA_VAR)),
.backupLabel = strDup(backupLabelKey),
.backupPgId = cvtZToUInt(strPtr(varStrForce(kvGet(backupKv, varNewStr(INFO_KEY_DB_ID_STR))))),
.backupTimestampStart = varUInt64(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_STR))),
.backupTimestampStop= varUInt64(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_STR))),
.backupType = varStrForce(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_TYPE_STR))),
.backupPgId = cvtZToUInt(strPtr(varStrForce(kvGet(backupKv, INFO_KEY_DB_ID_VAR)))),
.backupTimestampStart = varUInt64(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_VAR)),
.backupTimestampStop= varUInt64(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_VAR)),
.backupType = varStrForce(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_TYPE_VAR)),
// Possible NULL values
.backupArchiveStart = varStr(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_STR))),
.backupArchiveStop = varStr(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_STR))),
.backupPrior = varStr(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_BACKUP_PRIOR_STR))),
.backupReference = (kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_REFERENCE_STR)) != NULL ?
strLstNewVarLst(varVarLst(kvGet(backupKv, varNewStr(INFO_BACKUP_KEY_BACKUP_REFERENCE_STR)))) :
NULL),
.backupArchiveStart = varStr(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_VAR)),
.backupArchiveStop = varStr(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_VAR)),
.backupPrior = varStr(kvGet(backupKv, INFO_MANIFEST_KEY_BACKUP_PRIOR_VAR)),
.backupReference =
kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_REFERENCE_VAR) != NULL ?
strLstNewVarLst(varVarLst(kvGet(backupKv, INFO_BACKUP_KEY_BACKUP_REFERENCE_VAR))) : NULL,
// Options
.optionArchiveCheck = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_STR))),
.optionArchiveCopy = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_STR))),
.optionBackupStandby = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_STR))),
.optionChecksumPage = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_STR))),
.optionCompress = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_COMPRESS_STR))),
.optionHardlink = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_HARDLINK_STR))),
.optionOnline = varBool(kvGet(backupKv, varNewStr(INFO_MANIFEST_KEY_OPT_ONLINE_STR))),
.optionArchiveCheck = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_VAR)),
.optionArchiveCopy = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_VAR)),
.optionBackupStandby = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_VAR)),
.optionChecksumPage = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_VAR)),
.optionCompress = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_COMPRESS_VAR)),
.optionHardlink = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_HARDLINK_VAR)),
.optionOnline = varBool(kvGet(backupKv, INFO_MANIFEST_KEY_OPT_ONLINE_VAR)),
};
// Add the backup data to the list

27
src/info/infoManifest.c
View File

@ -1,22 +1,21 @@
/***********************************************************************************************************************************
Manifest Info Handler
***********************************************************************************************************************************/
#include "common/type/string.h"
#include "info/infoManifest.h"
/***********************************************************************************************************************************
Constants
***********************************************************************************************************************************/
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_STR, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START);
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_STR, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP);
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_PRIOR_STR, INFO_MANIFEST_KEY_BACKUP_PRIOR);
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_STR, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START);
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_STR, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP);
STRING_EXTERN(INFO_MANIFEST_KEY_BACKUP_TYPE_STR, INFO_MANIFEST_KEY_BACKUP_TYPE);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_STR, INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_STR, INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_STR, INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_STR, INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_COMPRESS_STR, INFO_MANIFEST_KEY_OPT_COMPRESS);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_HARDLINK_STR, INFO_MANIFEST_KEY_OPT_HARDLINK);
STRING_EXTERN(INFO_MANIFEST_KEY_OPT_ONLINE_STR, INFO_MANIFEST_KEY_OPT_ONLINE);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_VAR, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_VAR, INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_PRIOR_VAR, INFO_MANIFEST_KEY_BACKUP_PRIOR);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_VAR, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_VAR, INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_BACKUP_TYPE_VAR, INFO_MANIFEST_KEY_BACKUP_TYPE);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_VAR, INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_VAR, INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_VAR, INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_VAR, INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_COMPRESS_VAR, INFO_MANIFEST_KEY_OPT_COMPRESS);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_HARDLINK_VAR, INFO_MANIFEST_KEY_OPT_HARDLINK);
VARIANT_STRDEF_EXTERN(INFO_MANIFEST_KEY_OPT_ONLINE_VAR, INFO_MANIFEST_KEY_OPT_ONLINE);

28
src/info/infoManifest.h
View File

@ -4,34 +4,36 @@ Manifest Info Handler
#ifndef INFO_INFOMANIFEST_H
#define INFO_INFOMANIFEST_H
#include "common/type/variant.h"
/***********************************************************************************************************************************
Constants
***********************************************************************************************************************************/
#define INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START "backup-archive-start"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_START_VAR);
#define INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP "backup-archive-stop"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_ARCHIVE_STOP_VAR);
#define INFO_MANIFEST_KEY_BACKUP_PRIOR "backup-prior"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_PRIOR_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_PRIOR_VAR);
#define INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START "backup-timestamp-start"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_START_VAR);
#define INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP "backup-timestamp-stop"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_TIMESTAMP_STOP_VAR);
#define INFO_MANIFEST_KEY_BACKUP_TYPE "backup-type"
STRING_DECLARE(INFO_MANIFEST_KEY_BACKUP_TYPE_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_BACKUP_TYPE_VAR);
#define INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK "option-archive-check"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_ARCHIVE_CHECK_VAR);
#define INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY "option-archive-copy"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_ARCHIVE_COPY_VAR);
#define INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY "option-backup-standby"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_BACKUP_STANDBY_VAR);
#define INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE "option-checksum-page"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_CHECKSUM_PAGE_VAR);
#define INFO_MANIFEST_KEY_OPT_COMPRESS "option-compress"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_COMPRESS_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_COMPRESS_VAR);
#define INFO_MANIFEST_KEY_OPT_HARDLINK "option-hardlink"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_HARDLINK_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_HARDLINK_VAR);
#define INFO_MANIFEST_KEY_OPT_ONLINE "option-online"
STRING_DECLARE(INFO_MANIFEST_KEY_OPT_ONLINE_STR);
VARIANT_DECLARE(INFO_MANIFEST_KEY_OPT_ONLINE_VAR);
#endif

33
src/info/infoPg.c
View File

@ -25,11 +25,11 @@ Internal constants
STRING_STATIC(INFO_SECTION_DB_STR, "db");
STRING_STATIC(INFO_SECTION_DB_HISTORY_STR, "db:history");
STRING_EXTERN(INFO_KEY_DB_ID_STR, INFO_KEY_DB_ID);
STRING_STATIC(INFO_KEY_DB_CATALOG_VERSION_STR, "db-catalog-version");
STRING_STATIC(INFO_KEY_DB_CONTROL_VERSION_STR, "db-control-version");
STRING_STATIC(INFO_KEY_DB_SYSTEM_ID_STR, "db-system-id");
STRING_STATIC(INFO_KEY_DB_VERSION_STR, "db-version");
VARIANT_STRDEF_EXTERN(INFO_KEY_DB_ID_VAR, INFO_KEY_DB_ID);
VARIANT_STRDEF_STATIC(INFO_KEY_DB_CATALOG_VERSION_VAR, "db-catalog-version");
VARIANT_STRDEF_STATIC(INFO_KEY_DB_CONTROL_VERSION_VAR, "db-control-version");
VARIANT_STRDEF_STATIC(INFO_KEY_DB_SYSTEM_ID_VAR, "db-system-id");
VARIANT_STRDEF_STATIC(INFO_KEY_DB_VERSION_VAR, "db-version");
/***********************************************************************************************************************************
Object type
@ -80,15 +80,10 @@ infoPgNew(const Storage *storage, const String *fileName, InfoPgType type, Ciphe
MEM_CONTEXT_TEMP_BEGIN()
{
const Ini *infoPgIni = infoIni(this->info);
const String *pgSection = INFO_SECTION_DB_STR;
const String *pgHistorySection = INFO_SECTION_DB_HISTORY_STR;
const StringList *pgHistoryKey = iniSectionKeyList(infoPgIni, pgHistorySection);
const Variant *idKey = varNewStr(INFO_KEY_DB_ID_STR);
const Variant *systemIdKey = varNewStr(INFO_KEY_DB_SYSTEM_ID_STR);
const Variant *versionKey = varNewStr(INFO_KEY_DB_VERSION_STR);
const StringList *pgHistoryKey = iniSectionKeyList(infoPgIni, INFO_SECTION_DB_HISTORY_STR);
// Get the current history id
unsigned int pgId = (unsigned int)varUInt64Force(iniGet(infoPgIni, pgSection, varStr(idKey)));
unsigned int pgId = (unsigned int)varUInt64Force(iniGet(infoPgIni, INFO_SECTION_DB_STR, varStr(INFO_KEY_DB_ID_VAR)));
// History must include at least one item or the file is corrupt
ASSERT(strLstSize(pgHistoryKey) > 0);
@ -100,16 +95,17 @@ infoPgNew(const Storage *storage, const String *fileName, InfoPgType type, Ciphe
{
// Load JSON data into a KeyValue
const KeyValue *pgDataKv = varKv(
jsonToVar(varStr(iniGet(infoPgIni, pgHistorySection, strLstGet(pgHistoryKey, pgHistoryIdx)))));
jsonToVar(varStr(iniGet(infoPgIni, INFO_SECTION_DB_HISTORY_STR, strLstGet(pgHistoryKey, pgHistoryIdx)))));
// Get db values that are common to all info files
InfoPgData infoPgData =
{
.id = cvtZToUInt(strPtr(strLstGet(pgHistoryKey, pgHistoryIdx))),
.version = pgVersionFromStr(varStr(kvGet(pgDataKv, versionKey))),
.version = pgVersionFromStr(varStr(kvGet(pgDataKv, INFO_KEY_DB_VERSION_VAR))),
// This is different in archive.info due to a typo that can't be fixed without a format version bump
.systemId = varUInt64Force(kvGet(pgDataKv, type == infoPgArchive ? idKey : systemIdKey)),
.systemId = varUInt64Force(
kvGet(pgDataKv, type == infoPgArchive ? INFO_KEY_DB_ID_VAR : INFO_KEY_DB_SYSTEM_ID_VAR)),
};
// Set index if this is the current history item
@ -121,11 +117,8 @@ infoPgNew(const Storage *storage, const String *fileName, InfoPgType type, Ciphe
// we must write them at least, even if we give up reading them.
if (type == infoPgBackup || type == infoPgManifest)
{
const Variant *catalogVersionKey = varNewStr(INFO_KEY_DB_CATALOG_VERSION_STR);
const Variant *controlVersionKey = varNewStr(INFO_KEY_DB_CONTROL_VERSION_STR);
infoPgData.catalogVersion = (unsigned int)varUInt64Force(kvGet(pgDataKv, catalogVersionKey));
infoPgData.controlVersion = (unsigned int)varUInt64Force(kvGet(pgDataKv, controlVersionKey));
infoPgData.catalogVersion = (unsigned int)varUInt64Force(kvGet(pgDataKv, INFO_KEY_DB_CATALOG_VERSION_VAR));
infoPgData.controlVersion = (unsigned int)varUInt64Force(kvGet(pgDataKv, INFO_KEY_DB_CONTROL_VERSION_VAR));
}
else if (type != infoPgArchive)
THROW_FMT(AssertError, "invalid InfoPg type %u", type);

2
src/info/infoPg.h
View File

@ -19,7 +19,7 @@ typedef struct InfoPg InfoPg;
Constants
***********************************************************************************************************************************/
#define INFO_KEY_DB_ID "db-id"
STRING_DECLARE(INFO_KEY_DB_ID_STR);
VARIANT_DECLARE(INFO_KEY_DB_ID_VAR);
/***********************************************************************************************************************************
Information about the PostgreSQL cluster

22
src/perl/config.c
View File

@ -31,37 +31,37 @@ perlOptionJson(void)
Variant *optionVar = varNewKv();
// Add valid
kvPut(varKv(optionVar), varNewStr(STRDEF("valid")), varNewBool(true));
kvPut(varKv(optionVar), VARSTRDEF("valid"), BOOL_TRUE_VAR);
// Add source
const char *source = NULL;
const Variant *source = NULL;
switch (cfgOptionSource(optionId))
{
case cfgSourceParam:
{
source = "param";
source = VARSTRDEF("param");
break;
}
case cfgSourceConfig:
{
source = "config";
source = VARSTRDEF("config");
break;
}
case cfgSourceDefault:
{
source = "default";
source = VARSTRDEF("default");
break;
}
}
kvPut(varKv(optionVar), varNewStr(STRDEF("source")), varNewStr(STR(source)));
kvPut(varKv(optionVar), VARSTRDEF("source"), source);
// Add negate and reset
kvPut(varKv(optionVar), varNewStr(STRDEF("negate")), varNewBool(cfgOptionNegate(optionId)));
kvPut(varKv(optionVar), varNewStr(STRDEF("reset")), varNewBool(cfgOptionReset(optionId)));
kvPut(varKv(optionVar), VARSTRDEF("negate"), VARBOOL(cfgOptionNegate(optionId)));
kvPut(varKv(optionVar), VARSTRDEF("reset"), VARBOOL(cfgOptionReset(optionId)));
// Add value if it is set
if (cfgOptionTest(optionId))
@ -101,16 +101,16 @@ perlOptionJson(void)
const VariantList *valueList = cfgOptionLst(optionId);
for (unsigned int listIdx = 0; listIdx < varLstSize(valueList); listIdx++)
kvPut(varKv(valueVar), varLstGet(valueList, listIdx), varNewBool(true));
kvPut(varKv(valueVar), varLstGet(valueList, listIdx), BOOL_TRUE_VAR);
break;
}
}
kvPut(varKv(optionVar), varNewStr(STRDEF("value")), valueVar);
kvPut(varKv(optionVar), VARSTRDEF("value"), valueVar);
}
kvPut(configKv, varNewStr(STR(cfgOptionName(optionId))), optionVar);
kvPut(configKv, VARSTRZ(cfgOptionName(optionId)), optionVar);
}
memContextSwitch(MEM_CONTEXT_OLD());

8
src/protocol/client.c
View File

@ -85,7 +85,7 @@ protocolClientNew(const String *name, const String *service, IoRead *read, IoWri
const String *expectedKey = expected[expectedIdx * 2];
const String *expectedValue = expected[expectedIdx * 2 + 1];
const Variant *actualValue = kvGet(greetingKv, varNewStr(expectedKey));
const Variant *actualValue = kvGet(greetingKv, VARSTR(expectedKey));
if (actualValue == NULL)
THROW_FMT(ProtocolError, "unable to find greeting key '%s'", strPtr(expectedKey));
@ -136,11 +136,11 @@ protocolClientReadOutput(ProtocolClient *this, bool outputRequired)
KeyValue *responseKv = varKv(jsonToVar(response));
// Process error if any
const Variant *error = kvGet(responseKv, varNewStr(PROTOCOL_ERROR_STR));
const Variant *error = kvGet(responseKv, VARSTR(PROTOCOL_ERROR_STR));
if (error != NULL)
{
const String *message = varStr(kvGet(responseKv, varNewStr(PROTOCOL_OUTPUT_STR)));
const String *message = varStr(kvGet(responseKv, VARSTR(PROTOCOL_OUTPUT_STR)));
THROWP_FMT(
errorTypeFromCode(varIntForce(error)), "%s: %s", strPtr(this->errorPrefix),
@ -148,7 +148,7 @@ protocolClientReadOutput(ProtocolClient *this, bool outputRequired)
}
// Get output
result = kvGet(responseKv, varNewStr(PROTOCOL_OUTPUT_STR));
result = kvGet(responseKv, VARSTR(PROTOCOL_OUTPUT_STR));
if (outputRequired)
{

4
src/protocol/command.c
View File

@ -112,10 +112,10 @@ protocolCommandJson(const ProtocolCommand *this)
MEM_CONTEXT_TEMP_BEGIN()
{
KeyValue *command = kvPut(kvNew(), varNewStr(PROTOCOL_KEY_COMMAND_STR), varNewStr(this->command));
KeyValue *command = kvPut(kvNew(), VARSTR(PROTOCOL_KEY_COMMAND_STR), VARSTR(this->command));
if (this->parameterList != NULL)
kvPut(command, varNewStr(PROTOCOL_KEY_PARAMETER_STR), this->parameterList);
kvPut(command, VARSTR(PROTOCOL_KEY_PARAMETER_STR), this->parameterList);
memContextSwitch(MEM_CONTEXT_OLD());
result = kvToJson(command, 0);

38
src/protocol/helper.c
View File

@ -1,6 +1,8 @@
/***********************************************************************************************************************************
Protocol Helper
***********************************************************************************************************************************/
#include <string.h>
#include "common/crypto/common.h"
#include "common/debug.h"
#include "common/exec.h"
@ -85,24 +87,24 @@ protocolLocalParam(ProtocolStorageType protocolStorageType, unsigned int protoco
KeyValue *optionReplace = kvNew();
// Add the command option
kvPut(optionReplace, varNewStr(CFGOPT_COMMAND_STR), varNewStrZ(cfgCommandName(cfgCommand())));
kvPut(optionReplace, VARSTR(CFGOPT_COMMAND_STR), VARSTRZ(cfgCommandName(cfgCommand())));
// Add the process id -- used when more than one process will be called
kvPut(optionReplace, varNewStr(CFGOPT_PROCESS_STR), varNewInt((int)protocolId));
kvPut(optionReplace, VARSTR(CFGOPT_PROCESS_STR), VARINT((int)protocolId));
// Add the host id -- for now this is hard-coded to 1
kvPut(optionReplace, varNewStr(CFGOPT_HOST_ID_STR), varNewInt(1));
kvPut(optionReplace, VARSTR(CFGOPT_HOST_ID_STR), VARINT(1));
// Add the type
kvPut(optionReplace, varNewStr(CFGOPT_TYPE_STR), varNewStrZ("backup"));
kvPut(optionReplace, VARSTR(CFGOPT_TYPE_STR), VARSTRDEF("backup"));
// Only enable file logging on the local when requested
kvPut(
optionReplace, varNewStr(CFGOPT_LOG_LEVEL_FILE_STR),
cfgOptionBool(cfgOptLogSubprocess) ? cfgOption(cfgOptLogLevelFile) : varNewStrZ("off"));
optionReplace, VARSTR(CFGOPT_LOG_LEVEL_FILE_STR),
cfgOptionBool(cfgOptLogSubprocess) ? cfgOption(cfgOptLogLevelFile) : VARSTRDEF("off"));
// Always output errors on stderr for debugging purposes
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_STDERR_STR), varNewStrZ("error"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_STDERR_STR), VARSTRDEF("error"));
result = strLstMove(cfgExecParam(cfgCmdLocal, optionReplace), MEM_CONTEXT_OLD());
}
@ -202,36 +204,36 @@ protocolRemoteParam(ProtocolStorageType protocolStorageType, unsigned int protoc
// Replace config options with the host versions
if (cfgOptionSource(cfgOptRepoHostConfig) != cfgSourceDefault)
kvPut(optionReplace, varNewStr(CFGOPT_CONFIG_STR), cfgOption(cfgOptRepoHostConfig));
kvPut(optionReplace, VARSTR(CFGOPT_CONFIG_STR), cfgOption(cfgOptRepoHostConfig));
if (cfgOptionSource(cfgOptRepoHostConfigIncludePath) != cfgSourceDefault)
kvPut(optionReplace, varNewStr(CFGOPT_CONFIG_INCLUDE_PATH_STR), cfgOption(cfgOptRepoHostConfigIncludePath));
kvPut(optionReplace, VARSTR(CFGOPT_CONFIG_INCLUDE_PATH_STR), cfgOption(cfgOptRepoHostConfigIncludePath));
if (cfgOptionSource(cfgOptRepoHostConfigPath) != cfgSourceDefault)
kvPut(optionReplace, varNewStr(CFGOPT_CONFIG_PATH_STR), cfgOption(cfgOptRepoHostConfigPath));
kvPut(optionReplace, VARSTR(CFGOPT_CONFIG_PATH_STR), cfgOption(cfgOptRepoHostConfigPath));
// Add the command option (or use the current command option if it is valid)
if (!cfgOptionTest(cfgOptCommand))
kvPut(optionReplace, varNewStr(CFGOPT_COMMAND_STR), varNewStrZ(cfgCommandName(cfgCommand())));
kvPut(optionReplace, VARSTR(CFGOPT_COMMAND_STR), VARSTRZ(cfgCommandName(cfgCommand())));
// Add the process id (or use the current process id if it is valid)
if (!cfgOptionTest(cfgOptProcess))
kvPut(optionReplace, varNewStr(CFGOPT_PROCESS_STR), varNewInt((int)protocolId));
kvPut(optionReplace, VARSTR(CFGOPT_PROCESS_STR), VARINT((int)protocolId));
// Don't pass log-path or lock-path since these are host specific
kvPut(optionReplace, varNewStr(CFGOPT_LOG_PATH_STR), NULL);
kvPut(optionReplace, varNewStr(CFGOPT_LOCK_PATH_STR), NULL);
kvPut(optionReplace, VARSTR(CFGOPT_LOG_PATH_STR), NULL);
kvPut(optionReplace, VARSTR(CFGOPT_LOCK_PATH_STR), NULL);
// Only enable file logging on the remote when requested
kvPut(
optionReplace, varNewStr(CFGOPT_LOG_LEVEL_FILE_STR),
cfgOptionBool(cfgOptLogSubprocess) ? cfgOption(cfgOptLogLevelFile) : varNewStrZ("off"));
optionReplace, VARSTR(CFGOPT_LOG_LEVEL_FILE_STR),
cfgOptionBool(cfgOptLogSubprocess) ? cfgOption(cfgOptLogLevelFile) : VARSTRDEF("off"));
// Always output errors on stderr for debugging purposes
kvPut(optionReplace, varNewStr(CFGOPT_LOG_LEVEL_STDERR_STR), varNewStrZ("error"));
kvPut(optionReplace, VARSTR(CFGOPT_LOG_LEVEL_STDERR_STR), VARSTRDEF("error"));
// Add the type
kvPut(optionReplace, varNewStr(CFGOPT_TYPE_STR), varNewStrZ("backup"));
kvPut(optionReplace, VARSTR(CFGOPT_TYPE_STR), VARSTRDEF("backup"));
StringList *commandExec = cfgExecParam(cfgCmdRemote, optionReplace);
strLstInsert(commandExec, 0, cfgOptionStr(cfgOptRepoHostCmd));

16
src/protocol/server.c
View File

@ -61,9 +61,9 @@ protocolServerNew(const String *name, const String *service, IoRead *read, IoWri
MEM_CONTEXT_TEMP_BEGIN()
{
KeyValue *greetingKv = kvNew();
kvPut(greetingKv, varNewStr(PROTOCOL_GREETING_NAME_STR), varNewStrZ(PROJECT_NAME));
kvPut(greetingKv, varNewStr(PROTOCOL_GREETING_SERVICE_STR), varNewStr(service));
kvPut(greetingKv, varNewStr(PROTOCOL_GREETING_VERSION_STR), varNewStrZ(PROJECT_VERSION));
kvPut(greetingKv, VARSTR(PROTOCOL_GREETING_NAME_STR), VARSTRZ(PROJECT_NAME));
kvPut(greetingKv, VARSTR(PROTOCOL_GREETING_SERVICE_STR), VARSTR(service));
kvPut(greetingKv, VARSTR(PROTOCOL_GREETING_VERSION_STR), VARSTRZ(PROJECT_VERSION));
ioWriteLine(this->write, kvToJson(greetingKv, 0));
ioWriteFlush(this->write);
@ -108,8 +108,8 @@ protocolServerError(ProtocolServer *this, int code, const String *message)
ASSERT(message != NULL);
KeyValue *error = kvNew();
kvPut(error, varNewStr(PROTOCOL_ERROR_STR), varNewInt(errorCode()));
kvPut(error, varNewStr(PROTOCOL_OUTPUT_STR), varNewStrZ(errorMessage()));
kvPut(error, VARSTR(PROTOCOL_ERROR_STR), VARINT(errorCode()));
kvPut(error, VARSTR(PROTOCOL_OUTPUT_STR), VARSTRZ(errorMessage()));
ioWriteLine(this->write, kvToJson(error, 0));
ioWriteFlush(this->write);
@ -138,8 +138,8 @@ protocolServerProcess(ProtocolServer *this)
{
// Read command
KeyValue *commandKv = varKv(jsonToVar(ioReadLine(this->read)));
String *command = varStr(kvGet(commandKv, varNewStr(PROTOCOL_KEY_COMMAND_STR)));
VariantList *paramList = varVarLst(kvGet(commandKv, varNewStr(PROTOCOL_KEY_PARAMETER_STR)));
const String *command = varStr(kvGet(commandKv, VARSTR(PROTOCOL_KEY_COMMAND_STR)));
VariantList *paramList = varVarLst(kvGet(commandKv, VARSTR(PROTOCOL_KEY_PARAMETER_STR)));
// Process command
bool found = false;
@ -199,7 +199,7 @@ protocolServerResponse(ProtocolServer *this, const Variant *output)
KeyValue *result = kvNew();
if (output != NULL)
kvAdd(result, varNewStr(PROTOCOL_OUTPUT_STR), output);
kvAdd(result, VARSTR(PROTOCOL_OUTPUT_STR), output);
ioWriteLine(this->write, kvToJson(result, 0));
ioWriteFlush(this->write);

4
src/storage/driver/remote/fileRead.c
View File

@ -92,8 +92,8 @@ storageDriverRemoteFileReadOpen(StorageDriverRemoteFileRead *this)
MEM_CONTEXT_TEMP_BEGIN()
{
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_STORAGE_OPEN_READ_STR);
protocolCommandParamAdd(command, varNewStr(this->name));
protocolCommandParamAdd(command, varNewBool(this->ignoreMissing));
protocolCommandParamAdd(command, VARSTR(this->name));
protocolCommandParamAdd(command, VARBOOL(this->ignoreMissing));
result = varBool(protocolClientExecute(this->client, command, true));
}

14
src/storage/driver/remote/fileWrite.c
View File

@ -106,13 +106,13 @@ storageDriverRemoteFileWriteOpen(StorageDriverRemoteFileWrite *this)
MEM_CONTEXT_TEMP_BEGIN()
{
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_STORAGE_OPEN_WRITE_STR);
protocolCommandParamAdd(command, varNewStr(this->name));
protocolCommandParamAdd(command, varNewUInt64(this->modeFile));
protocolCommandParamAdd(command, varNewUInt64(this->modePath));
protocolCommandParamAdd(command, varNewBool(this->createPath));
protocolCommandParamAdd(command, varNewBool(this->syncFile));
protocolCommandParamAdd(command, varNewBool(this->syncPath));
protocolCommandParamAdd(command, varNewBool(this->atomic));
protocolCommandParamAdd(command, VARSTR(this->name));
protocolCommandParamAdd(command, VARUINT64(this->modeFile));
protocolCommandParamAdd(command, VARUINT64(this->modePath));
protocolCommandParamAdd(command, VARBOOL(this->createPath));
protocolCommandParamAdd(command, VARBOOL(this->syncFile));
protocolCommandParamAdd(command, VARBOOL(this->syncPath));
protocolCommandParamAdd(command, VARBOOL(this->atomic));
protocolClientExecute(this->client, command, false);
}

6
src/storage/driver/remote/protocol.c
View File

@ -58,8 +58,8 @@ storageDriverRemoteProtocol(const String *command, const VariantList *paramList,
{
if (strEq(command, PROTOCOL_COMMAND_STORAGE_EXISTS_STR))
{
protocolServerResponse(
server, varNewBool(interface.exists(driver, storagePathNP(storage, varStr(varLstGet(paramList, 0))))));
protocolServerResponse(server, VARBOOL( // The unusual line break is to make coverage happy -- not sure why
interface.exists(driver, storagePathNP(storage, varStr(varLstGet(paramList, 0))))));
}
else if (strEq(command, PROTOCOL_COMMAND_STORAGE_LIST_STR))
{
@ -80,7 +80,7 @@ storageDriverRemoteProtocol(const String *command, const VariantList *paramList,
// Check if the file exists
bool exists = ioReadOpen(fileRead);
protocolServerResponse(server, varNewBool(exists));
protocolServerResponse(server, VARBOOL(exists));
// Transfer the file if it exists
if (exists)

8
src/storage/driver/remote/storage.c
View File

@ -89,7 +89,7 @@ storageDriverRemoteExists(StorageDriverRemote *this, const String *path)
MEM_CONTEXT_TEMP_BEGIN()
{
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_STORAGE_EXISTS_STR);
protocolCommandParamAdd(command, varNewStr(path));
protocolCommandParamAdd(command, VARSTR(path));
result = varBool(protocolClientExecute(this->client, command, true));
}
@ -139,9 +139,9 @@ storageDriverRemoteList(StorageDriverRemote *this, const String *path, bool erro
MEM_CONTEXT_TEMP_BEGIN()
{
ProtocolCommand *command = protocolCommandNew(PROTOCOL_COMMAND_STORAGE_LIST_STR);
protocolCommandParamAdd(command, varNewStr(path));
protocolCommandParamAdd(command, varNewBool(errorOnMissing));
protocolCommandParamAdd(command, varNewStr(expression));
protocolCommandParamAdd(command, VARSTR(path));
protocolCommandParamAdd(command, VARBOOL(errorOnMissing));
protocolCommandParamAdd(command, VARSTR(expression));
result = strLstMove(strLstNewVarLst(varVarLst(protocolClientExecute(this->client, command, true))), MEM_CONTEXT_OLD());
}

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

@ -788,37 +788,37 @@ testRun(void)
KeyValue *stanzaInfo = kvNew();
VariantList *dbSection = varLstNew();
Variant *pgInfo = varNewKv();
kvPut(varKv(pgInfo), varNewStr(DB_KEY_ID_STR), varNewUInt64(1));
kvPut(varKv(pgInfo), varNewStr(DB_KEY_SYSTEM_ID_STR), varNewUInt64(6625633699176220261));
kvPut(varKv(pgInfo), varNewStr(DB_KEY_VERSION_STR), varNewStr(pgVersionToStr(90500)));
kvPut(varKv(pgInfo), DB_KEY_ID_VAR, varNewUInt64(1));
kvPut(varKv(pgInfo), DB_KEY_SYSTEM_ID_VAR, varNewUInt64(6625633699176220261));
kvPut(varKv(pgInfo), DB_KEY_VERSION_VAR, VARSTR(pgVersionToStr(90500)));
varLstAdd(dbSection, pgInfo);
// Add the database history, backup and archive sections to the stanza info
kvPut(stanzaInfo, varNewStr(STANZA_KEY_DB_STR), varNewVarLst(dbSection));
kvPut(stanzaInfo, STANZA_KEY_DB_VAR, varNewVarLst(dbSection));
VariantList *backupSection = varLstNew();
Variant *backupInfo = varNewKv();
kvPut(varKv(backupInfo), varNewStr(BACKUP_KEY_LABEL_STR), varNewStr(strNew("20181119-152138F")));
kvPut(varKv(backupInfo), varNewStr(BACKUP_KEY_TYPE_STR), varNewStr(strNew("full")));
kvPutKv(varKv(backupInfo), varNewStr(KEY_ARCHIVE_STR));
KeyValue *infoInfo = kvPutKv(varKv(backupInfo), varNewStr(BACKUP_KEY_INFO_STR));
kvPut(infoInfo, varNewStr(KEY_SIZE_STR), varNewUInt64(0));
kvPut(infoInfo, varNewStr(KEY_DELTA_STR), varNewUInt64(0));
KeyValue *repoInfo = kvPutKv(infoInfo, varNewStr(INFO_KEY_REPOSITORY_STR));
kvAdd(repoInfo, varNewStr(KEY_SIZE_STR), varNewUInt64(0));
kvAdd(repoInfo, varNewStr(KEY_DELTA_STR), varNewUInt64(0));
KeyValue *databaseInfo = kvPutKv(varKv(backupInfo), varNewStr(KEY_DATABASE_STR));
kvAdd(databaseInfo, varNewStr(DB_KEY_ID_STR), varNewUInt64(1));
KeyValue *timeInfo = kvPutKv(varKv(backupInfo), varNewStr(BACKUP_KEY_TIMESTAMP_STR));
kvAdd(timeInfo, varNewStr(KEY_START_STR), varNewUInt64(1542383276));
kvAdd(timeInfo, varNewStr(KEY_STOP_STR), varNewUInt64(1542383289));
kvPut(varKv(backupInfo), BACKUP_KEY_LABEL_VAR, VARSTRDEF("20181119-152138F"));
kvPut(varKv(backupInfo), BACKUP_KEY_TYPE_VAR, VARSTRDEF("full"));
kvPutKv(varKv(backupInfo), KEY_ARCHIVE_VAR);
KeyValue *infoInfo = kvPutKv(varKv(backupInfo), BACKUP_KEY_INFO_VAR);
kvPut(infoInfo, KEY_SIZE_VAR, varNewUInt64(0));
kvPut(infoInfo, KEY_DELTA_VAR, varNewUInt64(0));
KeyValue *repoInfo = kvPutKv(infoInfo, INFO_KEY_REPOSITORY_VAR);
kvAdd(repoInfo, KEY_SIZE_VAR, varNewUInt64(0));
kvAdd(repoInfo, KEY_DELTA_VAR, varNewUInt64(0));
KeyValue *databaseInfo = kvPutKv(varKv(backupInfo), KEY_DATABASE_VAR);
kvAdd(databaseInfo, DB_KEY_ID_VAR, varNewUInt64(1));
KeyValue *timeInfo = kvPutKv(varKv(backupInfo), BACKUP_KEY_TIMESTAMP_VAR);
kvAdd(timeInfo, KEY_START_VAR, varNewUInt64(1542383276));
kvAdd(timeInfo, KEY_STOP_VAR, varNewUInt64(1542383289));
varLstAdd(backupSection, backupInfo);
kvPut(stanzaInfo, varNewStr(STANZA_KEY_BACKUP_STR), varNewVarLst(backupSection));
kvPut(stanzaInfo, varNewStr(KEY_ARCHIVE_STR), varNewVarLst(varLstNew()));
kvPut(stanzaInfo, STANZA_KEY_BACKUP_VAR, varNewVarLst(backupSection));
kvPut(stanzaInfo, KEY_ARCHIVE_VAR, varNewVarLst(varLstNew()));
String *result = strNew("");
formatTextDb(stanzaInfo, result);

143
test/src/module/common/typeVariantTest.c
View File

@ -22,14 +22,14 @@ testRun(void)
TEST_ERROR(varBool(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeBool' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varBool(varNewBool(true)), true, "true bool variant");
TEST_RESULT_BOOL(varBool(varNewBool(false)), false, "false bool variant");
TEST_RESULT_BOOL(varBool(BOOL_TRUE_VAR), true, "true bool variant");
TEST_RESULT_BOOL(varBool(BOOL_FALSE_VAR), false, "false bool variant");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varBoolForce(varNewBool(false)), false, "force bool to bool");
TEST_RESULT_BOOL(varBoolForce(varNewInt(1)), true, "force int to bool");
TEST_RESULT_BOOL(varBoolForce(varNewInt64(false)), false, "force int64 to bool");
TEST_RESULT_BOOL(varBoolForce(varNewUInt64(12)), true, "force uint64 to bool");
TEST_RESULT_BOOL(varBoolForce(VARBOOL(false)), false, "force bool to bool");
TEST_RESULT_BOOL(varBoolForce(VARINT(1)), true, "force int to bool");
TEST_RESULT_BOOL(varBoolForce(VARINT64(false)), false, "force int64 to bool");
TEST_RESULT_BOOL(varBoolForce(VARUINT64(12)), true, "force uint64 to bool");
TEST_ERROR(varBoolForce(varNewVarLst(varLstNew())), AssertError, "unable to force VariantList to bool");
@ -37,13 +37,13 @@ testRun(void)
TEST_RESULT_VOID(varFree(NULL), "ok to free null variant");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varBool(varDup(varNewBool(true))), true, "dup bool");
TEST_RESULT_BOOL(varBool(varDup(BOOL_TRUE_VAR)), true, "dup bool");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varEq(varNewBool(true), varNewInt(1)), false, "bool, int not eq");
TEST_RESULT_BOOL(varEq(BOOL_TRUE_VAR, VARINT(1)), false, "bool, int not eq");
TEST_RESULT_BOOL(varEq(varNewBool(true), varNewBool(true)), true, "bool, bool eq");
TEST_RESULT_BOOL(varEq(varNewBool(false), varNewBool(true)), false, "bool, bool not eq");
TEST_RESULT_BOOL(varEq(BOOL_TRUE_VAR, BOOL_TRUE_VAR), true, "bool, bool eq");
TEST_RESULT_BOOL(varEq(BOOL_FALSE_VAR, BOOL_TRUE_VAR), false, "bool, bool not eq");
}
// *****************************************************************************************************************************
@ -57,25 +57,25 @@ testRun(void)
TEST_ERROR(varDbl(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeDouble' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_DOUBLE(varDblForce(varNewDbl(4.567)), 4.567, "force double to double");
TEST_RESULT_DOUBLE(varDblForce(VARDBL(4.567)), 4.567, "force double to double");
TEST_RESULT_DOUBLE(varDblForce(varNewBool(false)), 0, "force bool to double");
TEST_RESULT_DOUBLE(varDblForce(varNewInt(123)), 123, "force int to double");
TEST_RESULT_DOUBLE(varDblForce(varNewInt64(999999999999)), 999999999999, "force int64 to double");
TEST_RESULT_DOUBLE(varDblForce(varNewUInt64(9223372036854775807U)), 9223372036854775807U, "force uint64 to double");
TEST_RESULT_DOUBLE(varDblForce(varNewStr(strNew("879.01"))), 879.01, "force String to double");
TEST_RESULT_DOUBLE(varDblForce(varNewStr(strNew("0"))), 0, "force String to double");
TEST_RESULT_DOUBLE(varDblForce(VARINT(123)), 123, "force int to double");
TEST_RESULT_DOUBLE(varDblForce(VARINT64(999999999999)), 999999999999, "force int64 to double");
TEST_RESULT_DOUBLE(varDblForce(VARUINT64(9223372036854775807U)), 9223372036854775807U, "force uint64 to double");
TEST_RESULT_DOUBLE(varDblForce(VARSTRDEF("879.01")), 879.01, "force String to double");
TEST_RESULT_DOUBLE(varDblForce(VARSTRDEF("0")), 0, "force String to double");
TEST_RESULT_DOUBLE(
varDblForce(varNewUInt64(UINT64_MAX)), 18446744073709551616.0, "force max uint64 to double (it will be rounded)");
varDblForce(VARUINT64(UINT64_MAX)), 18446744073709551616.0, "force max uint64 to double (it will be rounded)");
TEST_ERROR(varDblForce(varNewStr(strNew("AAA"))), FormatError, "unable to convert string 'AAA' to double");
TEST_ERROR(varDblForce(VARSTRDEF("AAA")), FormatError, "unable to convert string 'AAA' to double");
TEST_ERROR(varDblForce(varNewVarLst(varLstNew())), AssertError, "unable to force VariantList to double");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_DOUBLE(varDbl(varDup(varNewDbl(3.1415))), 3.1415, "dup double");
TEST_RESULT_DOUBLE(varDbl(varDup(VARDBL(3.1415))), 3.1415, "dup double");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varEq(varNewDbl(1.234), varNewDbl(1.234)), true, "double, double eq");
TEST_RESULT_BOOL(varEq(varNewDbl(4.321), varNewDbl(1.234)), false, "double, double not eq");
TEST_RESULT_BOOL(varEq(VARDBL(1.234), VARDBL(1.234)), true, "double, double eq");
TEST_RESULT_BOOL(varEq(VARDBL(4.321), VARDBL(1.234)), false, "double, double not eq");
}
// *****************************************************************************************************************************
@ -89,25 +89,25 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varIntForce(varNewBool(true)), 1, "force bool to int");
TEST_ERROR(varIntForce(varNewVarLst(varLstNew())), AssertError, "unable to force VariantList to int");
TEST_RESULT_INT(varIntForce(varNewInt64(999)), 999, "force int64 to int");
TEST_ERROR(varIntForce(varNewInt64(2147483648)), FormatError, "unable to convert int64 2147483648 to int");
TEST_ERROR(varIntForce(varNewInt64(-2147483649)), FormatError, "unable to convert int64 -2147483649 to int");
TEST_RESULT_INT(varIntForce(varNewUInt64(12345)), 12345, "force uint64 to int");
TEST_ERROR(varIntForce(varNewUInt64(2147483648)), FormatError, "unable to convert uint64 2147483648 to int");
TEST_RESULT_INT(varIntForce(VARINT64(999)), 999, "force int64 to int");
TEST_ERROR(varIntForce(VARINT64(2147483648)), FormatError, "unable to convert int64 2147483648 to int");
TEST_ERROR(varIntForce(VARINT64(-2147483649)), FormatError, "unable to convert int64 -2147483649 to int");
TEST_RESULT_INT(varIntForce(VARUINT64(12345)), 12345, "force uint64 to int");
TEST_ERROR(varIntForce(VARUINT64(2147483648)), FormatError, "unable to convert uint64 2147483648 to int");
// -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(varInt(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeInt' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varInt(varDup(varNewInt(88976))), 88976, "dup int");
TEST_RESULT_INT(varInt(varDup(VARINT(88976))), 88976, "dup int");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varEq(NULL, NULL), true, "null, null eq");
TEST_RESULT_BOOL(varEq(NULL, varNewInt(123)), false, "null, int not eq");
TEST_RESULT_BOOL(varEq(varNewInt(123), NULL), false, "int, null not eq");
TEST_RESULT_BOOL(varEq(NULL, VARINT(123)), false, "null, int not eq");
TEST_RESULT_BOOL(varEq(VARINT(123), NULL), false, "int, null not eq");
TEST_RESULT_BOOL(varEq(varNewInt(123), varNewInt(123)), true, "int, int eq");
TEST_RESULT_BOOL(varEq(varNewInt(444), varNewInt(123)), false, "int, int not eq");
TEST_RESULT_BOOL(varEq(VARINT(123), VARINT(123)), true, "int, int eq");
TEST_RESULT_BOOL(varEq(VARINT(444), VARINT(123)), false, "int, int not eq");
}
// *****************************************************************************************************************************
@ -120,29 +120,29 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varInt64Force(varNewBool(true)), 1, "force bool to int64");
TEST_RESULT_INT(varInt64Force(varNewInt(2147483647)), 2147483647, "force int to int64");
TEST_RESULT_INT(varInt64Force(VARINT(2147483647)), 2147483647, "force int to int64");
TEST_RESULT_INT(varInt64Force(varNewStrZ("9223372036854775807")), 9223372036854775807L, "force str to int64");
TEST_RESULT_INT(varInt64Force(varNewUInt64(9223372036854775807U)), 9223372036854775807L, "force uint64 to int64");
TEST_RESULT_INT(varInt64Force(VARUINT64(9223372036854775807U)), 9223372036854775807L, "force uint64 to int64");
TEST_ERROR(
varInt64Force(varNewStrZ("9223372036854775808")), FormatError,
"unable to convert base 10 string '9223372036854775808' to int64");
TEST_ERROR(varInt64Force(varNewVarLst(varLstNew())), AssertError, "unable to force VariantList to int64");
TEST_ERROR(varInt64Force(varNewUInt64(9223372036854775808U)), FormatError,
TEST_ERROR(varInt64Force(VARUINT64(9223372036854775808U)), FormatError,
"unable to convert uint64 9223372036854775808 to int64");
// -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(varInt64(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeInt64' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varInt64(varDup(varNewInt64(88976))), 88976, "dup int64");
TEST_RESULT_INT(varInt64(varDup(VARINT64(88976))), 88976, "dup int64");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varEq(NULL, NULL), true, "null, null eq");
TEST_RESULT_BOOL(varEq(NULL, varNewInt64(123)), false, "null, int64 not eq");
TEST_RESULT_BOOL(varEq(NULL, VARINT64(123)), false, "null, int64 not eq");
TEST_RESULT_BOOL(varEq(varNewInt64(9223372036854775807L), varNewInt64(9223372036854775807L)), true, "int64, int64 eq");
TEST_RESULT_BOOL(varEq(varNewInt64(444), varNewInt64(123)), false, "int64, int64 not eq");
TEST_RESULT_BOOL(varEq(VARINT64(9223372036854775807L), VARINT64(9223372036854775807L)), true, "int64, int64 eq");
TEST_RESULT_BOOL(varEq(VARINT64(444), VARINT64(123)), false, "int64, int64 not eq");
}
// *****************************************************************************************************************************
@ -155,51 +155,51 @@ testRun(void)
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_DOUBLE(varUInt64Force(varNewBool(true)), 1, "force bool to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(varNewInt(2147483647)), 2147483647, "force int to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(varNewInt64(2147483647)), 2147483647, "force int64 to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARINT(2147483647)), 2147483647, "force int to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARINT64(2147483647)), 2147483647, "force int64 to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(varNewStrZ("18446744073709551615")), 18446744073709551615U, "force str to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(varNewUInt64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64");
TEST_RESULT_DOUBLE(varUInt64Force(VARUINT64(18446744073709551615U)), 18446744073709551615U, "force uint64 to uint64");
TEST_ERROR(
varUInt64Force(varNewStrZ("18446744073709551616")), FormatError,
"unable to convert base 10 string '18446744073709551616' to uint64"); // string value is out of bounds for uint64
TEST_ERROR(varUInt64Force(varNewStrZ(" 16")), FormatError,"unable to convert base 10 string ' 16' to uint64");
TEST_ERROR(varUInt64Force(varNewVarLst(varLstNew())), AssertError, "unable to force VariantList to uint64");
TEST_ERROR(varUInt64Force(varNewInt64(-1)), FormatError, "unable to convert int64 -1 to uint64");
TEST_ERROR(varUInt64Force(varNewInt(-1)), FormatError, "unable to convert int -1 to uint64");
TEST_ERROR(varUInt64Force(VARINT64(-1)), FormatError, "unable to convert int64 -1 to uint64");
TEST_ERROR(varUInt64Force(VARINT(-1)), FormatError, "unable to convert int -1 to uint64");
// -------------------------------------------------------------------------------------------------------------------------
TEST_ERROR(varUInt64(varNewStrZ("string")), AssertError, "assertion 'this->type == varTypeUInt64' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_DOUBLE(varUInt64(varDup(varNewUInt64(88976))), 88976, "dup uint64");
TEST_RESULT_DOUBLE(varUInt64(varDup(VARUINT64(88976))), 88976, "dup uint64");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_BOOL(varEq(NULL, NULL), true, "null, null eq");
TEST_RESULT_BOOL(varEq(NULL, varNewUInt64(123)), false, "null, uint64 not eq");
TEST_RESULT_BOOL(varEq(NULL, VARUINT64(123)), false, "null, uint64 not eq");
TEST_RESULT_BOOL(varEq(varNewUInt64(9223372036854775807L), varNewUInt64(9223372036854775807L)), true, "uint64, uint64 eq");
TEST_RESULT_BOOL(varEq(varNewUInt64(444), varNewUInt64(123)), false, "uint64, uint64 not eq");
TEST_RESULT_BOOL(varEq(VARUINT64(9223372036854775807L), VARUINT64(9223372036854775807L)), true, "uint64, uint64 eq");
TEST_RESULT_BOOL(varEq(VARUINT64(444), VARUINT64(123)), false, "uint64, uint64 not eq");
}
// *****************************************************************************************************************************
if (testBegin("keyValue"))
{
TEST_ERROR(varKv(varNewInt(66)), AssertError, "assertion 'this->type == varTypeKeyValue' failed");
TEST_ERROR(varKv(VARINT(66)), AssertError, "assertion 'this->type == varTypeKeyValue' failed");
// -------------------------------------------------------------------------------------------------------------------------
Variant *keyValue = NULL;
TEST_ASSIGN(keyValue, varNewKv(), "new");
TEST_RESULT_PTR(kvPut(varKv(keyValue), varNewInt(44), varNewInt(55)), varKv(keyValue), " put int/int");
TEST_RESULT_INT(varInt(kvGet(varKv(keyValue), varNewInt(44))), 55, " get int/int");
TEST_RESULT_PTR(kvPut(varKv(keyValue), VARINT(44), VARINT(55)), varKv(keyValue), " put int/int");
TEST_RESULT_INT(varInt(kvGet(varKv(keyValue), VARINT(44))), 55, " get int/int");
TEST_RESULT_PTR(varKv(NULL), NULL, "get null kv");
// -------------------------------------------------------------------------------------------------------------------------
Variant *keyValueDup = NULL;
TEST_ASSIGN(keyValueDup, varDup(keyValue), "duplicate");
TEST_RESULT_INT(varInt(kvGet(varKv(keyValueDup), varNewInt(44))), 55, " get int/int");
TEST_RESULT_INT(varInt(kvGet(varKv(keyValueDup), VARINT(44))), 55, " get int/int");
varFree(keyValue);
varFree(keyValueDup);
@ -224,52 +224,53 @@ testRun(void)
TEST_ERROR(varStr(varNewBool(true)), AssertError, "assertion 'this->type == varTypeString' failed");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varIntForce(varNewStrZ("777")), 777, "int from string");
TEST_RESULT_INT(varIntForce(VARSTR(STRDEF("777"))), 777, "int from string");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_INT(varBoolForce(varNewStr(strNew("y"))), true, "bool from string");
TEST_RESULT_INT(varBoolForce(varNewStr(strNew("on"))), true, "bool from string");
TEST_RESULT_INT(varBoolForce(VARSTRDEF("y")), true, "bool from string");
TEST_RESULT_INT(varBoolForce(VARSTRZ("on")), true, "bool from string");
TEST_RESULT_INT(varBoolForce(varNewStr(strNew("n"))), false, "bool from string");
TEST_RESULT_INT(varBoolForce(varNewStr(strNew("off"))), false, "bool from string");
TEST_RESULT_INT(varBoolForce(varNewStrZ("n")), false, "bool from string");
TEST_RESULT_INT(varBoolForce(VARSTRDEF("off")), false, "bool from string");
TEST_RESULT_INT(varBoolForce(varNewStr(strNew("OFF"))), false, "bool from string");
TEST_RESULT_INT(varBoolForce(VARSTRDEF("OFF")), false, "bool from string");
TEST_ERROR(varBoolForce(varNewStr(strNew(BOGUS_STR))), FormatError, "unable to convert str 'BOGUS' to bool");
TEST_ERROR(varBoolForce(VARSTRDEF(BOGUS_STR)), FormatError, "unable to convert str 'BOGUS' to bool");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_STR(strPtr(varStrForce(varNewStr(strNew("teststring")))), "teststring", "force string to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewInt(999))), "999", "force int to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewInt64(9223372036854775807L))), "9223372036854775807", "force int64 to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewDbl((double)999999999.123456))), "999999999.123456", "force double to string");
TEST_RESULT_STR(strPtr(varStrForce(VARSTRDEF("teststring"))), "teststring", "force string to string");
TEST_RESULT_STR(strPtr(varStrForce(VARINT(999))), "999", "force int to string");
TEST_RESULT_STR(strPtr(varStrForce(VARINT64(9223372036854775807L))), "9223372036854775807", "force int64 to string");
TEST_RESULT_STR(strPtr(varStrForce(VARDBL((double)999999999.123456))), "999999999.123456", "force double to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewBool(true))), "true", "force bool to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewBool(false))), "false", "force bool to string");
TEST_RESULT_STR(strPtr(varStrForce(varNewUInt64(18446744073709551615U))), "18446744073709551615", "force uint64 to string");
TEST_RESULT_STR(strPtr(varStrForce(VARUINT64(18446744073709551615U))), "18446744073709551615", "force uint64 to string");
TEST_ERROR(varStrForce(varNewKv()), FormatError, "unable to force KeyValue to String");
// -------------------------------------------------------------------------------------------------------------------------
string = varNewStr(strNew("not-an-int"));
string = varNewStrZ("not-an-int");
TEST_ERROR(varIntForce(string), FormatError, "unable to convert base 10 string 'not-an-int' to int");
varFree(string);
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_STR(strPtr(varStr(varNewStrZ("test-z-str"))), "test-z-str", "new zero-terminated string");
TEST_RESULT_STR(strPtr(varStr(VARSTRDEF("test-z-str"))), "test-z-str", "new zero-terminated string");
TEST_RESULT_PTR(strPtr(varStr(VARSTR(NULL))), NULL, "new null strz");
TEST_RESULT_PTR(strPtr(varStr(varNewStrZ(NULL))), NULL, "new null strz");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_STR(strPtr(varStr(varDup(varNewStr(strNew("yabba-dabba-doo"))))), "yabba-dabba-doo", "dup string");
TEST_RESULT_STR(strPtr(varStr(varDup(VARSTRDEF("yabba-dabba-doo")))), "yabba-dabba-doo", "dup string");
// -------------------------------------------------------------------------------------------------------------------------
TEST_RESULT_PTR(varDup(NULL), NULL, "dup NULL");
TEST_RESULT_BOOL(varEq(varNewStr(strNew("expect-equal")), varNewStr(strNew("expect-equal"))), true, "string, string eq");
TEST_RESULT_BOOL(varEq(varNewStr(strNew("Y")), varNewStr(strNew("X"))), false, "string, string not eq");
TEST_RESULT_BOOL(varEq(VARSTRDEF("expect-equal"), VARSTRDEF("expect-equal")), true, "string, string eq");
TEST_RESULT_BOOL(varEq(VARSTRDEF("Y"), VARSTRDEF("X")), false, "string, string not eq");
}
// *****************************************************************************************************************************
if (testBegin("VariantList"))
{
TEST_ERROR(varVarLst(varNewInt(66)), AssertError, "assertion 'this->type == varTypeVariantList' failed");
TEST_ERROR(varVarLst(VARINT(66)), AssertError, "assertion 'this->type == varTypeVariantList' failed");
// -------------------------------------------------------------------------------------------------------------------------
Variant *listVar = NULL;
@ -345,8 +346,8 @@ testRun(void)
{
VariantList *list = varLstNew();
varLstAdd(list, varNewStr(strNew("string1")));
varLstAdd(list, varNewStr(strNew("string2")));
varLstAdd(list, varNewStrZ("string1"));
varLstAdd(list, varNewStrZ("string2"));
TEST_RESULT_STR(
strPtr(strLstJoin(strLstNewVarLst(varLstDup(list)), ", ")),