Do not connect to the database if the replication configuration is incorrect (#8381)

XaBbl4 · web-flow · commit eac2bb6c66bf · 2026-03-25T13:07:52.000+03:00
* Do not connect to the database if the replication configuration is incorrect

Configuration errors can lead to loss of synchronization between master and replica.

* Send config errors to the client app only if report_errors is enabled

* Report a replication error if it occurs during the initial connection to the replica and the report_errors is enabled

* Add error "all configured replicas skipped"
diff --git a/src/jrd/replication/Config.cpp b/src/jrd/replication/Config.cpp
@@ -62,6 +62,7 @@ namespace
 	constexpr ULONG DEFAULT_GROUP_FLUSH_DELAY = 0;
 	constexpr ULONG DEFAULT_APPLY_IDLE_TIMEOUT = 10;			// seconds
 	constexpr ULONG DEFAULT_APPLY_ERROR_TIMEOUT = 60;			// seconds
+	constexpr bool DEFAULT_REPORT_ERRORS = false;
 
 	void parseLong(const string& input, ULONG& output)
 	{
@@ -79,36 +80,53 @@ namespace
 			output = false;
 	}
 
-	void configError(const string& type, const string& key, const string& value)
+	void configError(CheckStatusWrapper* status, const string& type, const string& key, const string& value)
 	{
-		raiseError("%s specifies %s: %s", key.c_str(), type.c_str(), value.c_str());
+		string msg;
+		if (!(status->getState() & IStatus::STATE_ERRORS))
+		{
+			msg.printf("Incorrect entry in %s", REPLICATION_CFGFILE);
+			(Arg::Gds(isc_random) << Arg::Str(msg)).appendTo(status);
+		}
+
+		msg.printf("%s specifies %s: %s", key.c_str(), type.c_str(), value.c_str());
+		(Arg::Gds(isc_random) << Arg::Str(msg)).appendTo(status);
 	}
 
-	void checkAccess(const PathName& path, const string& key)
+	bool checkAccess(CheckStatusWrapper* status, const PathName& path, const string& key)
 	{
 		if (path.hasData() && !PathUtils::canAccess(path, 6))
-			configError("missing or inaccessible directory", key, path.c_str());
+		{
+			configError(status, "missing or inaccessible directory", key, path.c_str());
+			return false;
+		}
+		return true;
 	}
 
 	void composeError(CheckStatusWrapper* status, const Exception& ex)
 	{
-		string prefix;
-		prefix.printf("Incorrect entry in %s", REPLICATION_CFGFILE);
-
 		Arg::StatusVector sv;
-		sv << Arg::Gds(isc_random) << Arg::Str(prefix);
+
+		if (!(status->getState() & IStatus::STATE_ERRORS))
+		{
+			string prefix;
+			prefix.printf("Incorrect entry in %s", REPLICATION_CFGFILE);
+			sv << Arg::Gds(isc_random) << Arg::Str(prefix);
+		}
+
+		sv << Arg::StatusVector(status);
 		sv << Arg::StatusVector(ex);
 
 		status->setErrors(sv.value());
 	}
 
-	void parseExternalValue(const string& key, const string& value, string& output)
+	bool parseExternalValue(CheckStatusWrapper* status, const string& key, const string& value, string& output)
 	{
 		const auto pos = key.rfind('_');
 		if (pos == string::npos)
 		{
 			output = value.c_str();
-			return;
+			return true;
 		}
 
 		string temp;
@@ -118,7 +136,10 @@ namespace
 		{
 			fb_utils::readenv(value.c_str(), temp);
 			if (temp.isEmpty())
-				configError("missing environment variable", key, value);
+			{
+				configError(status, "missing environment variable", key, value);
+				return false;
+			}
 		}
 		else if (key_source.equals(KEY_SUFFIX_FILE))
 		{
@@ -129,44 +150,65 @@ namespace
 
 			AutoPtr<FILE> file(os_utils::fopen(filename.c_str(), "rt"));
 			if (!file)
-				configError("missing or inaccessible file", key, filename.c_str());
+			{
+				configError(status, "missing or inaccessible file", key, filename.c_str());
+				return false;
+			}
 
 			if (temp.LoadFromFile(file))
 				temp.alltrim("\r");
 
 			if (temp.isEmpty())
-				configError("first empty line of file", key, filename.c_str());
+			{
+				configError(status, "first empty line of file", key, filename.c_str());
+				return false;
+			}
 		}
 
 		output = temp.c_str();
+		return true;
 	}
 
-	void parseSyncReplica(const ConfigFile::Parameters& params, SyncReplica& output)
+	bool parseSyncReplica(CheckStatusWrapper* status, const ConfigFile::Parameters& params, SyncReplica& output)
 	{
+		bool result = true;
 		for (const auto& el : params)
 		{
 			const string key(el.name.c_str());
 			const string value(el.value);
 
 			if (value.isEmpty())
-				continue;
+			{
+				configError(status, "empty value", output.database, key);
+				result = false;
+			}
 
 			if (key.find("username") == 0)
 			{
 				if (output.username.hasData())
-					configError("multiple values", output.database, "username");
-				parseExternalValue(key, value, output.username);
+				{
+					configError(status, "multiple values", output.database, "username");
+					result = false;
+				}
+				result &= parseExternalValue(status, key, value, output.username);
 				output.username.rtrim(" ");
 			}
 			else if (key.find("password") == 0)
 			{
 				if (output.password.hasData())
-					configError("multiple values", output.database, "password");
-				parseExternalValue(key, value, output.password);
+				{
+					configError(status, "multiple values", output.database, "password");
+					result = false;
+				}
+				result &= parseExternalValue(status, key, value, output.password);
 			}
 			else
-				configError("unknown parameter", output.database, key);
+			{
+				configError(status, "unknown key", output.database, key);
+				result = false;
+			}
 		}
+		return result;
 	}
 }
 
@@ -196,7 +238,7 @@ Config::Config()
 	  schemaSearchPath(getPool()),
 	  pluginName(getPool()),
 	  logErrors(true),
-	  reportErrors(false),
+	  reportErrors(DEFAULT_REPORT_ERRORS),
 	  disableOnError(true),
 	  cascadeReplication(false)
 {
@@ -238,6 +280,7 @@ Config* Config::get(const PathName& lookupName)
 {
 	fb_assert(lookupName.hasData());
 
+	bool reportErrors = DEFAULT_REPORT_ERRORS;
 	try
 	{
 		const PathName filename =
@@ -249,7 +292,8 @@ Config* Config::get(const PathName& lookupName)
 
 		AutoPtr<Config> config(FB_NEW Config);
 
-		bool defaultFound = false, exactMatch = false;
+		FbLocalStatus localStatus;
+		bool defaultFound = false, exactMatch = false, replicaSkip = false;
 
 		for (const auto& section : cfgFile.getParameters())
 		{
@@ -287,15 +331,24 @@ Config* Config::get(const PathName& lookupName)
 				string value(el.value);
 
 				if (value.isEmpty())
+				{
+					configError(&localStatus, "empty value of key",
+					                          exactMatch ? lookupName.c_str() : section.name.c_str(),
+					                          key);
 					continue;
+				}
 
 				if (key == "sync_replica")
 				{
 					SyncReplica syncReplica(config->getPool());
 					if (el.sub)
 					{
 						syncReplica.database = value;
-						parseSyncReplica(el.sub->getParameters(), syncReplica);
+						if (!parseSyncReplica(&localStatus, el.sub->getParameters(), syncReplica))
+						{
+							replicaSkip = true;
+							continue;
+						}
 					}
 					else
 						splitConnectionString(value, syncReplica.database, syncReplica.username, syncReplica.password);
@@ -338,7 +391,12 @@ Config* Config::get(const PathName& lookupName)
 				{
 					config->journalDirectory = value.c_str();
 					PathUtils::ensureSeparator(config->journalDirectory);
-					checkAccess(config->journalDirectory, key);
+					if (!checkAccess(&localStatus, config->journalDirectory, key))
+					{
+						config->journalDirectory.erase();
+						replicaSkip = true;
+						continue;
+					}
 				}
 				else if (key == "journal_file_prefix")
 				{
@@ -352,7 +410,11 @@ Config* Config::get(const PathName& lookupName)
 				{
 					config->archiveDirectory = value.c_str();
 					PathUtils::ensureSeparator(config->archiveDirectory);
-					checkAccess(config->archiveDirectory, key);
+					if (!checkAccess(&localStatus, config->archiveDirectory, key))
+					{
+						config->archiveDirectory.erase();
+						continue;
+					}
 				}
 				else if (key == "journal_archive_command")
 				{
@@ -373,6 +435,7 @@ Config* Config::get(const PathName& lookupName)
 				else if (key == "report_errors")
 				{
 					parseBoolean(value, config->reportErrors);
+					reportErrors = config->reportErrors;
 				}
 				else if (key == "disable_on_error")
 				{
@@ -382,12 +445,28 @@ Config* Config::get(const PathName& lookupName)
 				{
 					parseBoolean(value, config->cascadeReplication);
 				}
+				else if ((key != "journal_source_directory") &&
+						(key != "source_guid") &&
+						(key != "verbose_logging") &&
+						(key != "apply_idle_timeout") &&
+						(key != "apply_error_timeout"))
+				{
+					configError(&localStatus, "unknown key",
+					                          exactMatch ? lookupName.c_str() : section.name.c_str(),
+					                          key);
+				}
 			}
 
 			if (exactMatch)
 				break;
 		}
 
+		if (localStatus->getState() & IStatus::STATE_ERRORS)
+			logPrimaryStatus(lookupName, &localStatus);
+
+		if (replicaSkip && !config->disableOnError)
+			raiseError("One or more replicas configured with errors");
+
 		// TODO: As soon as plugin name is moved into RDB$PUBLICATIONS,
 		// delay config parse until real replication start
 		if (config->pluginName.hasData())
@@ -410,13 +489,18 @@ Config* Config::get(const PathName& lookupName)
 
 			return config.release();
 		}
+
+		if (replicaSkip)
+			raiseError("All configured replicas skipped");
 	}
 	catch (const Exception& ex)
 	{
 		FbLocalStatus localStatus;
 		composeError(&localStatus, ex);
 
 		logPrimaryStatus(lookupName, &localStatus);
+		if (reportErrors)
+			localStatus.raise();
 	}
 
 	return nullptr;
@@ -428,6 +512,7 @@ Config* Config::get(const PathName& lookupName)
 void Config::enumerate(ReplicaList& replicas)
 {
 	PathName dbName;
+	FbLocalStatus localStatus;
 
 	try
 	{
@@ -480,12 +565,20 @@ void Config::enumerate(ReplicaList& replicas)
 				{
 					config->sourceDirectory = value.c_str();
 					PathUtils::ensureSeparator(config->sourceDirectory);
+					if (!checkAccess(&localStatus, config->sourceDirectory, key))
+					{
+						config->sourceDirectory.erase();
+						continue;
+					}
 				}
 				else if (key == "source_guid")
 				{
 					config->sourceGuid = Guid::fromString(value);
 					if (!config->sourceGuid)
-						configError("invalid (misformatted) value", key, value);
+					{
+						configError(&localStatus, "invalid (misformatted) value", key, value);
+						continue;
+					}
 				}
 				else if (key == "verbose_logging")
 				{
@@ -517,11 +610,11 @@ void Config::enumerate(ReplicaList& replicas)
 	}
 	catch (const Exception& ex)
 	{
-		FbLocalStatus localStatus;
 		composeError(&localStatus, ex);
+	}
 
+	if (localStatus->getState() & IStatus::STATE_ERRORS)
 		logReplicaStatus(dbName, &localStatus);
-	}
 }
 
 // This routine is used for split input connection string to parts
diff --git a/src/jrd/replication/Manager.cpp b/src/jrd/replication/Manager.cpp
@@ -184,6 +184,8 @@ Manager::Manager(const string& dbId,
 		if (localStatus->getState() & IStatus::STATE_ERRORS)
 		{
 			logPrimaryStatus(m_config->dbName, &localStatus);
+			if (m_config->reportErrors)
+				(Arg::Gds(isc_repl_error) << Arg::StatusVector(&localStatus)).raise();
 			continue;
 		}
 
@@ -192,6 +194,8 @@ Manager::Manager(const string& dbId,
 		{
 			logPrimaryStatus(m_config->dbName, &localStatus);
 			attachment->detach(&localStatus);
+			if (m_config->reportErrors)
+				(Arg::Gds(isc_repl_error) << Arg::StatusVector(&localStatus)).raise();
 			continue;
 		}
 

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ namespace`
`62`	`62`	`constexpr ULONG DEFAULT_GROUP_FLUSH_DELAY = 0;`
`63`	`63`	`constexpr ULONG DEFAULT_APPLY_IDLE_TIMEOUT = 10; // seconds`
`64`	`64`	`constexpr ULONG DEFAULT_APPLY_ERROR_TIMEOUT = 60; // seconds`
	`65`	`+ constexpr bool DEFAULT_REPORT_ERRORS = false;`
`65`	`66`
`66`	`67`	`void parseLong(const string& input, ULONG& output)`
`67`	`68`	`{`
`@@ -79,36 +80,53 @@ namespace`
`79`	`80`	`output = false;`
`80`	`81`	`}`
`81`	`82`
`82`		`- void configError(const string& type, const string& key, const string& value)`
	`83`	`+ void configError(CheckStatusWrapper* status, const string& type, const string& key, const string& value)`
`83`	`84`	`{`
`84`		`- raiseError("%s specifies %s: %s", key.c_str(), type.c_str(), value.c_str());`
	`85`	`+ string msg;`
	`86`	`+ if (!(status->getState() & IStatus::STATE_ERRORS))`
	`87`	`+ {`
	`88`	`+ msg.printf("Incorrect entry in %s", REPLICATION_CFGFILE);`
	`89`	`+ (Arg::Gds(isc_random) << Arg::Str(msg)).appendTo(status);`
	`90`	`+ }`
	`91`	`+`
	`92`	`+ msg.printf("%s specifies %s: %s", key.c_str(), type.c_str(), value.c_str());`
	`93`	`+ (Arg::Gds(isc_random) << Arg::Str(msg)).appendTo(status);`
`85`	`94`	`}`
`86`	`95`
`87`		`- void checkAccess(const PathName& path, const string& key)`
	`96`	`+ bool checkAccess(CheckStatusWrapper* status, const PathName& path, const string& key)`
`88`	`97`	`{`
`89`	`98`	`if (path.hasData() && !PathUtils::canAccess(path, 6))`
`90`		`- configError("missing or inaccessible directory", key, path.c_str());`
	`99`	`+ {`
	`100`	`+ configError(status, "missing or inaccessible directory", key, path.c_str());`
	`101`	`+ return false;`
	`102`	`+ }`
	`103`	`+ return true;`
`91`	`104`	`}`
`92`	`105`
`93`	`106`	`void composeError(CheckStatusWrapper* status, const Exception& ex)`
`94`	`107`	`{`
`95`		`- string prefix;`
`96`		`- prefix.printf("Incorrect entry in %s", REPLICATION_CFGFILE);`
`97`		`-`
`98`	`108`	`Arg::StatusVector sv;`
`99`		`- sv << Arg::Gds(isc_random) << Arg::Str(prefix);`
	`109`	`+`
	`110`	`+ if (!(status->getState() & IStatus::STATE_ERRORS))`
	`111`	`+ {`
	`112`	`+ string prefix;`
	`113`	`+ prefix.printf("Incorrect entry in %s", REPLICATION_CFGFILE);`
	`114`	`+ sv << Arg::Gds(isc_random) << Arg::Str(prefix);`
	`115`	`+ }`
	`116`	`+`
	`117`	`+ sv << Arg::StatusVector(status);`
`100`	`118`	`sv << Arg::StatusVector(ex);`
`101`	`119`
`102`	`120`	`status->setErrors(sv.value());`
`103`	`121`	`}`
`104`	`122`
`105`		`- void parseExternalValue(const string& key, const string& value, string& output)`
	`123`	`+ bool parseExternalValue(CheckStatusWrapper* status, const string& key, const string& value, string& output)`
`106`	`124`	`{`
`107`	`125`	`const auto pos = key.rfind('_');`
`108`	`126`	`if (pos == string::npos)`
`109`	`127`	`{`
`110`	`128`	`output = value.c_str();`
`111`		`- return;`
	`129`	`+ return true;`
`112`	`130`	`}`
`113`	`131`
`114`	`132`	`string temp;`
`@@ -118,7 +136,10 @@ namespace`
`118`	`136`	`{`
`119`	`137`	`fb_utils::readenv(value.c_str(), temp);`
`120`	`138`	`if (temp.isEmpty())`
`121`		`- configError("missing environment variable", key, value);`
	`139`	`+ {`
	`140`	`+ configError(status, "missing environment variable", key, value);`
	`141`	`+ return false;`
	`142`	`+ }`
`122`	`143`	`}`
`123`	`144`	`else if (key_source.equals(KEY_SUFFIX_FILE))`
`124`	`145`	`{`
`@@ -129,44 +150,65 @@ namespace`
`129`	`150`
`130`	`151`	`AutoPtr<FILE> file(os_utils::fopen(filename.c_str(), "rt"));`
`131`	`152`	`if (!file)`
`132`		`- configError("missing or inaccessible file", key, filename.c_str());`
	`153`	`+ {`
	`154`	`+ configError(status, "missing or inaccessible file", key, filename.c_str());`
	`155`	`+ return false;`
	`156`	`+ }`
`133`	`157`
`134`	`158`	`if (temp.LoadFromFile(file))`
`135`	`159`	`temp.alltrim("\r");`
`136`	`160`
`137`	`161`	`if (temp.isEmpty())`
`138`		`- configError("first empty line of file", key, filename.c_str());`
	`162`	`+ {`
	`163`	`+ configError(status, "first empty line of file", key, filename.c_str());`
	`164`	`+ return false;`
	`165`	`+ }`
`139`	`166`	`}`
`140`	`167`
`141`	`168`	`output = temp.c_str();`
	`169`	`+ return true;`
`142`	`170`	`}`
`143`	`171`
`144`		`- void parseSyncReplica(const ConfigFile::Parameters& params, SyncReplica& output)`
	`172`	`+ bool parseSyncReplica(CheckStatusWrapper* status, const ConfigFile::Parameters& params, SyncReplica& output)`
`145`	`173`	`{`
	`174`	`+ bool result = true;`
`146`	`175`	`for (const auto& el : params)`
`147`	`176`	`{`
`148`	`177`	`const string key(el.name.c_str());`
`149`	`178`	`const string value(el.value);`
`150`	`179`
`151`	`180`	`if (value.isEmpty())`
`152`		`- continue;`
	`181`	`+ {`
	`182`	`+ configError(status, "empty value", output.database, key);`
	`183`	`+ result = false;`
	`184`	`+ }`
`153`	`185`
`154`	`186`	`if (key.find("username") == 0)`
`155`	`187`	`{`
`156`	`188`	`if (output.username.hasData())`
`157`		`- configError("multiple values", output.database, "username");`
`158`		`- parseExternalValue(key, value, output.username);`
	`189`	`+ {`
	`190`	`+ configError(status, "multiple values", output.database, "username");`
	`191`	`+ result = false;`
	`192`	`+ }`
	`193`	`+ result &= parseExternalValue(status, key, value, output.username);`
`159`	`194`	`output.username.rtrim(" ");`
`160`	`195`	`}`
`161`	`196`	`else if (key.find("password") == 0)`
`162`	`197`	`{`
`163`	`198`	`if (output.password.hasData())`
`164`		`- configError("multiple values", output.database, "password");`
`165`		`- parseExternalValue(key, value, output.password);`
	`199`	`+ {`
	`200`	`+ configError(status, "multiple values", output.database, "password");`
	`201`	`+ result = false;`
	`202`	`+ }`
	`203`	`+ result &= parseExternalValue(status, key, value, output.password);`
`166`	`204`	`}`
`167`	`205`	`else`
`168`		`- configError("unknown parameter", output.database, key);`
	`206`	`+ {`
	`207`	`+ configError(status, "unknown key", output.database, key);`
	`208`	`+ result = false;`
	`209`	`+ }`
`169`	`210`	`}`
	`211`	`+ return result;`
`170`	`212`	`}`
`171`	`213`	`}`
`172`	`214`
`@@ -196,7 +238,7 @@ Config::Config()`
`196`	`238`	`schemaSearchPath(getPool()),`
`197`	`239`	`pluginName(getPool()),`
`198`	`240`	`logErrors(true),`
`199`		`- reportErrors(false),`
	`241`	`+ reportErrors(DEFAULT_REPORT_ERRORS),`
`200`	`242`	`disableOnError(true),`
`201`	`243`	`cascadeReplication(false)`
`202`	`244`	`{`
`@@ -238,6 +280,7 @@ Config* Config::get(const PathName& lookupName)`
`238`	`280`	`{`
`239`	`281`	`fb_assert(lookupName.hasData());`
`240`	`282`
	`283`	`+ bool reportErrors = DEFAULT_REPORT_ERRORS;`
`241`	`284`	`try`
`242`	`285`	`{`
`243`	`286`	`const PathName filename =`
`@@ -249,7 +292,8 @@ Config* Config::get(const PathName& lookupName)`
`249`	`292`
`250`	`293`	`AutoPtr<Config> config(FB_NEW Config);`
`251`	`294`
`252`		`- bool defaultFound = false, exactMatch = false;`
	`295`	`+ FbLocalStatus localStatus;`
	`296`	`+ bool defaultFound = false, exactMatch = false, replicaSkip = false;`
`253`	`297`
`254`	`298`	`for (const auto& section : cfgFile.getParameters())`
`255`	`299`	`{`
`@@ -287,15 +331,24 @@ Config* Config::get(const PathName& lookupName)`
`287`	`331`	`string value(el.value);`
`288`	`332`
`289`	`333`	`if (value.isEmpty())`
	`334`	`+ {`
	`335`	`+ configError(&localStatus, "empty value of key",`
	`336`	`+ exactMatch ? lookupName.c_str() : section.name.c_str(),`
	`337`	`+ key);`
`290`	`338`	`continue;`
	`339`	`+ }`
`291`	`340`
`292`	`341`	`if (key == "sync_replica")`
`293`	`342`	`{`
`294`	`343`	`SyncReplica syncReplica(config->getPool());`
`295`	`344`	`if (el.sub)`
`296`	`345`	`{`
`297`	`346`	`syncReplica.database = value;`
`298`		`- parseSyncReplica(el.sub->getParameters(), syncReplica);`
	`347`	`+ if (!parseSyncReplica(&localStatus, el.sub->getParameters(), syncReplica))`
	`348`	`+ {`
	`349`	`+ replicaSkip = true;`
	`350`	`+ continue;`
	`351`	`+ }`
`299`	`352`	`}`
`300`	`353`	`else`
`301`	`354`	`splitConnectionString(value, syncReplica.database, syncReplica.username, syncReplica.password);`
`@@ -338,7 +391,12 @@ Config* Config::get(const PathName& lookupName)`
`338`	`391`	`{`
`339`	`392`	`config->journalDirectory = value.c_str();`
`340`	`393`	`PathUtils::ensureSeparator(config->journalDirectory);`
`341`		`- checkAccess(config->journalDirectory, key);`
	`394`	`+ if (!checkAccess(&localStatus, config->journalDirectory, key))`
	`395`	`+ {`
	`396`	`+ config->journalDirectory.erase();`
	`397`	`+ replicaSkip = true;`
	`398`	`+ continue;`
	`399`	`+ }`
`342`	`400`	`}`
`343`	`401`	`else if (key == "journal_file_prefix")`
`344`	`402`	`{`
`@@ -352,7 +410,11 @@ Config* Config::get(const PathName& lookupName)`
`352`	`410`	`{`
`353`	`411`	`config->archiveDirectory = value.c_str();`
`354`	`412`	`PathUtils::ensureSeparator(config->archiveDirectory);`
`355`		`- checkAccess(config->archiveDirectory, key);`
	`413`	`+ if (!checkAccess(&localStatus, config->archiveDirectory, key))`
	`414`	`+ {`
	`415`	`+ config->archiveDirectory.erase();`
	`416`	`+ continue;`
	`417`	`+ }`
`356`	`418`	`}`
`357`	`419`	`else if (key == "journal_archive_command")`
`358`	`420`	`{`
`@@ -373,6 +435,7 @@ Config* Config::get(const PathName& lookupName)`
`373`	`435`	`else if (key == "report_errors")`
`374`	`436`	`{`
`375`	`437`	`parseBoolean(value, config->reportErrors);`
	`438`	`+ reportErrors = config->reportErrors;`
`376`	`439`	`}`
`377`	`440`	`else if (key == "disable_on_error")`
`378`	`441`	`{`
`@@ -382,12 +445,28 @@ Config* Config::get(const PathName& lookupName)`
`382`	`445`	`{`
`383`	`446`	`parseBoolean(value, config->cascadeReplication);`
`384`	`447`	`}`
	`448`	`+ else if ((key != "journal_source_directory") &&`
	`449`	`+ (key != "source_guid") &&`
	`450`	`+ (key != "verbose_logging") &&`
	`451`	`+ (key != "apply_idle_timeout") &&`
	`452`	`+ (key != "apply_error_timeout"))`
	`453`	`+ {`
	`454`	`+ configError(&localStatus, "unknown key",`
	`455`	`+ exactMatch ? lookupName.c_str() : section.name.c_str(),`
	`456`	`+ key);`
	`457`	`+ }`
`385`	`458`	`}`
`386`	`459`
`387`	`460`	`if (exactMatch)`
`388`	`461`	`break;`
`389`	`462`	`}`
`390`	`463`
	`464`	`+ if (localStatus->getState() & IStatus::STATE_ERRORS)`
	`465`	`+ logPrimaryStatus(lookupName, &localStatus);`
	`466`	`+`
	`467`	`+ if (replicaSkip && !config->disableOnError)`
	`468`	`+ raiseError("One or more replicas configured with errors");`
	`469`	`+`
`391`	`470`	`// TODO: As soon as plugin name is moved into RDB$PUBLICATIONS,`
`392`	`471`	`// delay config parse until real replication start`
`393`	`472`	`if (config->pluginName.hasData())`
`@@ -410,13 +489,18 @@ Config* Config::get(const PathName& lookupName)`
`410`	`489`
`411`	`490`	`return config.release();`
`412`	`491`	`}`
	`492`	`+`
	`493`	`+ if (replicaSkip)`
	`494`	`+ raiseError("All configured replicas skipped");`
`413`	`495`	`}`
`414`	`496`	`catch (const Exception& ex)`
`415`	`497`	`{`
`416`	`498`	`FbLocalStatus localStatus;`
`417`	`499`	`composeError(&localStatus, ex);`
`418`	`500`
`419`	`501`	`logPrimaryStatus(lookupName, &localStatus);`
	`502`	`+ if (reportErrors)`
	`503`	`+ localStatus.raise();`
`420`	`504`	`}`
`421`	`505`
`422`	`506`	`return nullptr;`
`@@ -428,6 +512,7 @@ Config* Config::get(const PathName& lookupName)`
`428`	`512`	`void Config::enumerate(ReplicaList& replicas)`
`429`	`513`	`{`
`430`	`514`	`PathName dbName;`
	`515`	`+ FbLocalStatus localStatus;`
`431`	`516`
`432`	`517`	`try`
`433`	`518`	`{`
`@@ -480,12 +565,20 @@ void Config::enumerate(ReplicaList& replicas)`
`480`	`565`	`{`
`481`	`566`	`config->sourceDirectory = value.c_str();`
`482`	`567`	`PathUtils::ensureSeparator(config->sourceDirectory);`
	`568`	`+ if (!checkAccess(&localStatus, config->sourceDirectory, key))`
	`569`	`+ {`
	`570`	`+ config->sourceDirectory.erase();`
	`571`	`+ continue;`
	`572`	`+ }`
`483`	`573`	`}`
`484`	`574`	`else if (key == "source_guid")`
`485`	`575`	`{`
`486`	`576`	`config->sourceGuid = Guid::fromString(value);`
`487`	`577`	`if (!config->sourceGuid)`
`488`		`- configError("invalid (misformatted) value", key, value);`
	`578`	`+ {`
	`579`	`+ configError(&localStatus, "invalid (misformatted) value", key, value);`
	`580`	`+ continue;`
	`581`	`+ }`
`489`	`582`	`}`
`490`	`583`	`else if (key == "verbose_logging")`
`491`	`584`	`{`
`@@ -517,11 +610,11 @@ void Config::enumerate(ReplicaList& replicas)`
`517`	`610`	`}`
`518`	`611`	`catch (const Exception& ex)`
`519`	`612`	`{`
`520`		`- FbLocalStatus localStatus;`
`521`	`613`	`composeError(&localStatus, ex);`
	`614`	`+ }`
`522`	`615`
	`616`	`+ if (localStatus->getState() & IStatus::STATE_ERRORS)`
`523`	`617`	`logReplicaStatus(dbName, &localStatus);`
`524`		`- }`
`525`	`618`	`}`
`526`	`619`
`527`	`620`	`// This routine is used for split input connection string to parts`
Original file line number	Diff line number	Diff line change
`@@ -184,6 +184,8 @@ Manager::Manager(const string& dbId,`
`184`	`184`	`if (localStatus->getState() & IStatus::STATE_ERRORS)`
`185`	`185`	`{`
`186`	`186`	`logPrimaryStatus(m_config->dbName, &localStatus);`
	`187`	`+ if (m_config->reportErrors)`
	`188`	`+ (Arg::Gds(isc_repl_error) << Arg::StatusVector(&localStatus)).raise();`
`187`	`189`	`continue;`
`188`	`190`	`}`
`189`	`191`
`@@ -192,6 +194,8 @@ Manager::Manager(const string& dbId,`
`192`	`194`	`{`
`193`	`195`	`logPrimaryStatus(m_config->dbName, &localStatus);`
`194`	`196`	`attachment->detach(&localStatus);`
	`197`	`+ if (m_config->reportErrors)`
	`198`	`+ (Arg::Gds(isc_repl_error) << Arg::StatusVector(&localStatus)).raise();`
`195`	`199`	`continue;`
`196`	`200`	`}`
`197`	`201`