private void SafeEndTransaction(TransactionInfo transInfo, bool commit, bool toFreeResources, out CloseConnectionTransactionException closeConnectionException)
{
closeConnectionException = null;
try {
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Error("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "] - returned to pool");
OSTrace.Error(new StackTrace().ToString());
#endif
EndTransaction(transInfo, commit, toFreeResources);
} catch (InvalidOperationException e) {
//Do not collect exception in case of invalid operation exception.
// End transaction throws this exception if connection is already commited and we don't want to throw that to client
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Error("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "]");
OSTrace.Error(new StackTrace().ToString());
#endif
EventLogger.WriteError(String.Format("Error closing the transaction to the database: {0}\n{1}\n{2}", e.Message, e.StackTrace,
new StackTrace(true)));
} catch (Exception e) {
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Error("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "]");
OSTrace.Error(new StackTrace().ToString());
#endif
//collect here exception, so it can be bubbled up and thrown if needed
closeConnectionException = new CloseConnectionTransactionException("Error closing the transaction to the database", e);
EventLogger.WriteError(String.Format("Error closing the transaction to the database: {0}\n{1}\n{2}", e.Message, e.StackTrace,
new StackTrace(true)));
}
}
protected TransactionInfo AddToPoolAndReserve()
{
lock (this) {
TransactionInfo transInfo = null;
while (transInfo == null)
{
transInfo = BuildTransactionInfo();
transInfo.Reserve();
//drivers doesn't ensure connection is good so make sure
if (transInfo.Transaction.Connection == null || transInfo.Transaction.Connection.State == ConnectionState.Closed)
{
if (transInfo.Transaction.Connection != null)
{
transInfo.ReturnConnectionToPool();
}
LogException(new InvalidTransactionException("Connection in transaction is null."), new StackTrace(), "Releasing connection pools and retrying");
transInfo = null; // retry;
TransactionService.ReleasePooledConnections("Connection in transaction is null.");
Thread.Sleep(TransactionServiceConstants.RETRY_CONNECTION_TIME);
}
}
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Info("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "] - reserved from pool");
OSTrace.Error(new StackTrace().ToString());
#endif
TransactionPool.Add(transInfo.Transaction, transInfo);
return(transInfo);
}
}
protected StaticRecordMetadata GetRecordMetadataByKey(ObjectKey key)
{
StaticRecordMetadata record;
if (!RecordsMetaByKey.TryGetValue(key, out record) || record == null || !record.Valid)
{
record = newStaticRecord();
using (Transaction systemTransaction = DatabaseAccess.ForSystemDatabase.GetReadOnlyTransaction()) {
using (IDataReader reader = DBRuntimePlatform.Instance.GetStaticRecordBykey(systemTransaction, key, EntityKey, EspaceId)) {
if (reader.Read())
{
record.Read(reader);
AddToMetadataCache(record);
}
else
{
//Not found on db so we can return a empty record
OSTrace.Error("GetRecordMetadataByKey(Key=" + ObjectKeyUtils.DatabaseValue(key) +
", EntityKey=" + ObjectKeyUtils.DatabaseValue(EntityKey) +
", EspaceId=" + EspaceId + ") found no metadata!");
}
}
}
}
return(record);
}
public static List <IPAddress> DnsLookup(string address)
{
IPAddress[] ip_list = null;
try {
ip_list = Dns.GetHostEntry(address).AddressList;
} catch (Exception e) {
OSTrace.Error("Dns Lookup", e);
}
if (ip_list != null && ip_list.Length > 0)
{
return(ip_list.ToList());
}
// Dns.GetHostEntry performs a more thorough lookup (reverse dns lookup in addition to the forward dns lookup)
// which will fail to retrieve the ip address in some scenarios where the GetHostAddresses will succeed.
try {
ip_list = Dns.GetHostAddresses(address);
} catch (Exception e) {
OSTrace.Error("Dns Lookup Extended", e);
}
if (ip_list != null && ip_list.Length > 0)
{
return(ip_list.ToList());
}
throw new Exception("Unable to resolve address:" + address);
}
/// <summary>
/// Aborts a transaction and releases it.
/// </summary>
/// <param name="trans">Transaction to be aborted.</param>
public void AbortTransaction(IDbTransaction trans)
{
if (trans == null)
{
return;
}
bool isRequestTransaction;
TransactionInfo transInfo = GetTransactionInfo(trans, out isRequestTransaction);
if (transInfo != null)
{
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Info("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "] - returned to pool");
OSTrace.Error(new StackTrace().ToString());
#endif
transInfo.Release();
if (isRequestTransaction)
{
RequestTransactionInfo = null;
}
else
{
TransactionPool.Remove(transInfo.Transaction);
}
transInfo.ReturnConnectionToPool();
}
}
public static bool IsLoopbackAddress(string hostnameOrIp)
{
hostnameOrIp = RemoveScopeIdFromIp(hostnameOrIp).Trim().ToLower();
string internalAddress;
if (HttpContext.Current == null)
{
// Can't cache this in services because settings change as diferent sandboxes are served
internalAddress = RuntimePlatformSettings.Misc.InternalAddress.GetValue();
}
else
{
if (cachedInternalAddress == null)
{
internalAddress = cachedInternalAddress = RuntimePlatformSettings.Misc.InternalAddress.GetValue();
}
else
{
internalAddress = cachedInternalAddress;
}
}
var toRetrun = hostnameOrIp.IsOneOf("127.0.0.1", "::1", "localhost", internalAddress);
OSTrace.Debug("IsLoopbackAddress - hostnameOrIp: " + hostnameOrIp + " - internalAddress: " + internalAddress + " result: " + toRetrun);
return(toRetrun);
}
internal static string MD5HashWithPrivateSalt(string str)
{
var toReturn = MD5PasswordHelper.HexDeriveUsingUTF16(str, SharedKeys.PrivateSalt());
OSTrace.Debug("MD5HashWithPrivateSalt returned:" + toReturn);
return(toReturn);
}
static IEnumerable <IPlatformTableSourceColumnInfo> TryGetColumnsFromExpression(string indexName, string columnExpression, IEnumerable <IPlatformTableSourceColumnInfo> columns)
{
var setOfColumns = new HashSet <IPlatformTableSourceColumnInfo>();
try {
var matches = ColumnNameRegex.Matches(columnExpression);
foreach (Match match in matches)
{
// Second group matches the capturing group in the regex above (first group matches the whole regex).
var column = columns.SingleOrDefault(c => c.Name.EqualsIgnoreCase(match.Groups[1].Value));
if (column != null)
{
// Workaround for yield return inside try-catch block.
setOfColumns.Add(column);
}
else
{
OSTrace.Info("Unable to find a column in index {0} with expression {1}".F(indexName, columnExpression));
}
}
} catch (Exception e) {
// No need to propagete the exception. Just tolerate the error and proceed.
// The result is a possible inconsistency warning while publishing.
OSTrace.Error("Error while parsing index {0} with expression {1}".F(indexName, columnExpression), e);
}
return(setOfColumns.AsEnumerable());
}
protected void SetContextInfo(HeContext heContext, SecurityTokenAPI.RequestSecurityTokenPayload authorizationPayload)
{
try {
if (authorizationPayload.TenantId != 0)
{
heContext.Session.TenantId = authorizationPayload.TenantId;
}
if (authorizationPayload.UserId != 0)
{
heContext.Session.UserId = authorizationPayload.UserId;
}
} catch (Exception e) {
OSTrace.Warning("Invalid authentication information.", e);
}
if (Request.Content.Headers.TryGetValues("Content-Language", out var headerValues))
{
string locale = headerValues.First();
if (!string.IsNullOrWhiteSpace(locale))
{
GenericExtendedActions.SetCurrentLocale(heContext, locale);
}
}
else
{
OSTrace.Warning("Locale information missing from the request.");
}
}
public static void InitializeRunningInfo()
{
if (initialized)
{
return;
}
lock (typeof(RunningInfo)) {
if (initialized)
{
return;
}
AppInfo appInfo = AppInfo.GetAppInfo();
if (appInfo == null)
{
InitializingErrorMessage = "AppInfo is null";
return;
}
try {
using (Transaction tran = DatabaseAccess.ForSystemDatabase.GetCommitableTransaction()) {
EspaceName = appInfo.eSpaceName;
PAName = appInfo.PtaName;
PAUserName = appInfo.PtaUserName;
tenantId = appInfo.Tenant.Id;
espaceId = DBRuntimePlatform.Instance.GetEspaceId(tran, EspaceName);
if (espaceId == 0)
{
initialized = false;
}
if (PAName == "")
{
PAName = null;
}
if (PAUserName == "")
{
PAUserName = null;
}
else if (PAUserName != null)
{
int scTenantId = DBRuntimePlatform.Instance.GetTenantIdByName(tran, Constants.ServiceCenterName, Constants.ServiceCenterName);
userId = DBRuntimePlatform.Instance.GetUserId(tran, scTenantId, PAUserName);
}
}
} catch (Exception e) {
initialized = false;
InitializingErrorMessage = "An exception ocurred during RunningInfo initialization: " + e.Message;
Log.ErrorLog.LogApplicationError(InitializingErrorMessage, e.StackTrace, null, "InitializeRunningInfo");
OSTrace.Error(InitializingErrorMessage, e);
throw;
}
initialized = true;
}
}
public DatabasePluginProvider(IEnumerable <DirectoryInfo> plugins)
{
pluginDirectories = plugins;
LoadPlugins((e, s) => {
OSTrace.Info(s, e);
});
}
protected void LogException(Exception e, string additionalMessage)
{
try {
OSTrace.Error((e != null ? e.Message : "") + Environment.NewLine + additionalMessage +
(e != null && e.StackTrace != null ? e.StackTrace : ""));
} catch {
}
}
/// <summary>
/// Executes a command and returns the value of the first column of the first row in the resultset returned by the query.
/// This implementation logs exceptions.
/// </summary>
/// <param name="cmd">The command to execute.</param>
/// <returns>An object with the resulting first row and first column of the query defined in the query command.</returns>
public virtual object ExecuteScalar(IDbCommand cmd)
{
try {
return(cmd.ExecuteScalar());
} catch (DbException e) {
OSTrace.Error("Error executing ExecuteScalar (" + e.Message + ") with statement:" + Environment.NewLine + cmd.CommandText);
throw;
}
}
public override IDataReader ExecuteReader(IDbCommand cmd)
{
try {
return(new SQLServerDataReaderWrapper((SqlDataReader)cmd.ExecuteReader(), this));
} catch (DbException e) {
OSTrace.Error("Error executing ExecuteReader (" + e.Message + ") with statement:" + Environment.NewLine + cmd.CommandText);
throw;
}
}
/// <summary>
/// Logs an error with information about the exception, the stack trace and a message.
/// </summary>
/// <param name="e">Exception to log.</param>
/// <param name="additionalStack">Stack trace to add to the log.</param>
/// <param name="additionalMessage">Message to add to the log.</param>
protected void LogException(Exception e, StackTrace additionalStack, string additionalMessage)
{
try {
String additionalStackString = (additionalStack != null ? additionalStack.ToString() : "");
OSTrace.Error((e != null ? e.Message : "") + Environment.NewLine + additionalMessage +
(e != null && e.StackTrace != null ? e.StackTrace.ToString() + (String.IsNullOrEmpty(additionalStackString) ? "" : "\n" + additionalStackString) : additionalStackString));
} catch {
}
}
protected IEnumerable <ITableSourceForeignKeyInfo> GetForeignKeys_Old(IEnumerable <CacheTableSourceInfo> tableSources)
{
string paramPrefix = DatabaseServices.ExecutionService.ParameterPrefix;
string tableNames = "";
try {
tableNames = "'" + tableSources.Select(t => t.Name).StrCat("','") + "'";
IList <ITableSourceForeignKeyInfo> foreignKeys = new List <ITableSourceForeignKeyInfo>();
//on mysql table_schema always equal to constraint_schema so we can shortcut to optimize
string query = string.Format(@"SELECT t.TABLE_NAME,
c.CONSTRAINT_NAME, c.COLUMN_NAME, c.REFERENCED_TABLE_NAME, c.REFERENCED_COLUMN_NAME,
r.DELETE_RULE
FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE c
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS t ON c.CONSTRAINT_NAME = t.CONSTRAINT_NAME
INNER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS r ON r.CONSTRAINT_NAME = t.CONSTRAINT_NAME
WHERE t.CONSTRAINT_TYPE = 'FOREIGN KEY'
AND t.TABLE_SCHEMA = {0}
AND c.CONSTRAINT_SCHEMA = {0}
AND r.CONSTRAINT_SCHEMA = {0}
AND t.TABLE_NAME IN (" + tableNames + @")", paramPrefix + "schema");
using (IDbConnection conn = DatabaseServices.TransactionService.CreateConnection()) {
IDbCommand cmd = DatabaseServices.ExecutionService.CreateCommand(conn, query);
//----------------- Caché --------------------
// Caché does not look at the parameter name, it assigns parameters in the order they appear, one per question mark "?"
// So the above query expects 3 parameters, although it is the same Caché expects 3, so add 3 parameters.
DatabaseServices.ExecutionService.CreateParameter(cmd, paramPrefix + "schema", DbType.String, tableSources.First().Database.Name);
cmd.CommandTimeout = QueryTimeout;
using (IDataReader reader = cmd.ExecuteReader()) {
while (reader.Read())
{
string tableName = (string)reader["TABLE_NAME"];
string foreignKeyName = (string)reader["CONSTRAINT_NAME"];
string columnName = (string)reader["COLUMN_NAME"];
string referencedColumnName = (string)reader["REFERENCED_COLUMN_NAME"];
string referencedTableName = (string)reader["REFERENCED_TABLE_NAME"];
bool isCascadeDelete = "CASCADE".EqualsIgnoreCase((string)reader["DELETE_RULE"]);
CacheTableSourceInfo tableSource = tableSources.First(t => t.Name.EqualsIgnoreCase(tableName));
string qualifiedReferencedTableName = GetQualifiedIdentifier(tableSource.Database.Name, referencedTableName);
ITableSourceInfo referencedTableSource = new CacheTableSourceInfo(DatabaseServices, tableSource.Database, referencedTableName, qualifiedReferencedTableName);
ITableSourceForeignKeyInfo foreignKeyInfo = new CacheTableSourceForeignKeyInfo(tableSource, foreignKeyName, columnName, referencedTableSource, referencedColumnName, isCascadeDelete);
foreignKeys.Add(foreignKeyInfo);
}
}
return(foreignKeys);
}
}
catch (Exception e) {
OSTrace.Error(string.Format("Failed to retrieve foreign key information from database. Tables: {0}", tableNames), e);
return(new List <ITableSourceForeignKeyInfo>());
}
}
private static bool IsResponsePayloadValid(string responseString, ResponseSecurityTokenPayload authorizationPayload)
{
bool isResponseValid = SecurityTokenAPI.ValidatePayloadHash(RuntimeSettingsProvider.Instance, responseString, authorizationPayload.ResponseHash);
if (!isResponseValid)
{
OSTrace.Error("Response hash doesn't match the response. Response may have been tampered with.");
}
return(isResponseValid);
}
/// <summary>
/// Executes a command and returns the number of affected rows.
/// This implementation does not use the <code>isApplication</code> flag, and logs exceptions.
/// </summary>
/// <param name="cmd">The command to execute.</param>
/// <returns>The number of rows affected.</returns>
public override int ExecuteNonQuery(IDbCommand cmd)
{
try {
return(cmd.ExecuteNonQuery());
}
catch (DbException e) {
OSTrace.Error("Error executing ExecuteNonQuery (" + e.Message + ") with statement:" + Environment.NewLine + cmd.CommandText);
throw;
}
}
private bool ValidateProducerKey(string requestProducerKey, string eSpaceProducerKey)
{
bool isProducerKeyValid = requestProducerKey == eSpaceProducerKey;
if (!isProducerKeyValid)
{
OSTrace.Error($"Producer Module keys don't match. Expected '{eSpaceProducerKey}' but was '{requestProducerKey}'");
}
return(isProducerKeyValid);
}
public void ClearCache()
{
OSTrace.Debug("StaticEntityRuntime.ClearCache: Clearing cache for " + ObjectKeyUtils.DatabaseValue(EntityKey) + ".");
_recordsMetaByName.Clear();
_recordsMetaByKey.Clear();
foreach (Hashtable recordsById in _recordsByIdByLocale.Values)
{
recordsById.Clear();
}
}
public static string Invoke(string sharePath, string eSpaceName, string ptaName, string action, string[] parameters, out string result, out string exception)
{
AppDomain domain = null;
try {
string partialPath = sharePath + FileSystemUtils.PathSeparator + "partial" + FileSystemUtils.PathSeparator + ptaName;
string partialBinPath = partialPath + FileSystemUtils.PathSeparator + "bin";
string fullBinPath = sharePath + FileSystemUtils.PathSeparator + "full" + FileSystemUtils.PathSeparator + "bin";
if (!Directory.Exists(partialBinPath)) // no run has been done yet
{
Directory.CreateDirectory(partialBinPath);
var dllsToCopy = new string[] {
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_RuntimeCommon)),
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_RuntimePlatform)),
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_Auditing)),
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_DatabaseAbstractionLayer)),
Path.GetFileName(Settings.Get(Settings.Configs.DotNetCompilerService_SMS)),
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_WebWidgets)),
Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_WidgetsRuntimeAPI)),
Path.GetFileName(Settings.Get(Settings.Configs.DotNetCompilerService_SharpZipLib)),
Path.GetFileName(Settings.Get(Settings.Configs.DotNetCompilerService_GemboxSpreadSheet)),
eSpaceName + ".dll",
eSpaceName + "CodeBehind.dll",
};
foreach (var dll in dllsToCopy)
{
File.Copy(fullBinPath + FileSystemUtils.PathSeparator + dll,
partialBinPath + FileSystemUtils.PathSeparator + dll);
}
}
string runtimePlatformFile = partialBinPath + FileSystemUtils.PathSeparator + Path.GetFileName(Settings.Get(Settings.Configs.CompilerService_RuntimePlatform));
var info = new AppDomainSetup();
info.ApplicationBase = partialPath;
domain = AppDomain.CreateDomain("Test", null, info);
var testActionCaller = (TestActionCaller)domain.CreateInstanceFromAndUnwrap(runtimePlatformFile, typeof(TestActionCaller).FullName);
return(testActionCaller.InnerInvoke(fullBinPath, eSpaceName, ptaName, action, parameters, out result, out exception));
} catch (Exception e) {
exception = e.Message;
result = string.Empty;
return("Internal Error");
} finally {
if (domain != null)
{
try {
AppDomain.Unload(domain);
} catch (CannotUnloadAppDomainException ex) {
OSTrace.Error("Unloading Domain", ex);
}
ForceCleanup();
}
}
}
private static void Execute(Action <T> invocation)
{
try {
GetImplementations().Apply(invocation);
} catch (ExtensibilityException e) {
throw e;
} catch (Exception e) {
OSTrace.Error("Executing Extension Point action", e);
throw new ExtensibilityException(e);
}
}
public static IScreenControllerProxy TryGetControllerProxy(Type controllerType)
{
if (controllerType != null && (typeof(ScreenServicesApiController)).IsAssignableFrom(controllerType))
{
try {
return((IScreenControllerProxy)controllerType.GetField("ProxyInstance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public).GetValue(null));
} catch (Exception ex) {
OSTrace.Error("Unable to load controller proxy for " + controllerType.FullName, ex);
}
}
return(null);
}
/// <summary>
/// Releases a transaction to the pool.
/// If the transaction is poolable, it is released and put back into the pool, otherwise it is removed.
/// Throws an <see cref="InvalidTransactionReleaseException"/> if the transaction is not releasable.
/// </summary>
/// <exception cref="InvalidTransactionReleaseException">Occurs if the transaction is not releasable.</exception>
/// <param name="trans">Transaction to be released.</param>
public virtual void ReleaseTransaction(IDbTransaction trans)
{
if (trans == null)
{
return;
}
TransactionInfo transInfo = (TransactionInfo)TransactionPool[trans];
if (transInfo != null)
{
if (!transInfo.IsReleasable)
{
throw (new InvalidTransactionReleaseException("Cannot release a transaction that was created with \"GetCommitableTransaction\". Use commit or rollback"));
}
#if DEBUG_DBCONNECTIONPOOLING
OSTrace.Info("DBConnectionPooling[TID=" + transInfo.Transaction.GetHashCode() + "] - returned to pool");
OSTrace.Error(new StackTrace().ToString());
#endif
if (transInfo.IsPoolable)
{
transInfo.Release();
}
else
{
TransactionPool.Remove(trans);
}
}
else
{
try {
if (RequestTransactionInfo != null && trans == RequestTransactionInfo.Transaction)
{
//when releasing the request transaction make sure the connection is ok
if (trans.Connection != null && trans.Connection.State != ConnectionState.Open)
{
LogException(new InvalidTransactionException("Request transaction not open on release."), new StackTrace(), "Request Transaction discarded due to connection not being in a correct state.");
//clear and try to dispose connection
lock (this) {
RequestTransactionInfo = null;
}
trans.Connection.Dispose();
}
else
{
RequestTransactionInfo.MarkChange();
}
}
} catch {
//this is a best effort
}
}
}
public static string DecryptStringForUpgrade(string text)
{
if (text != null)
{
try {
return(SecureConfidentialInformationEncryption.DecryptForUpgrade(text));
} catch (Exception e) {
//probably not encrypted
OSTrace.Error("Decrypting for upgrade", e);
}
}
return(text);
}
public override IDataReader ExecuteReader(IDbCommand cmd)
{
try {
var reader = (OracleDataReader)cmd.ExecuteReader();
if (reader.HasRows)
{
SetDataReaderFetchSize(reader);
}
return(new OracleDataReaderWrapper(reader, this));
} catch (DbException e) {
OSTrace.Error("Error executing ExecuteReader (" + e.Message + ") with statement:" + Environment.NewLine + cmd.CommandText);
throw;
}
}
private void InnerOnChange(PubSubMessage message)
{
lock (this) {
if (!monitorDisposed)
{
this.filter.UnregisterForTopics(this.InnerOnChange, topics);
try {
base.OnChanged(message);
} catch (Exception ex) {
OSTrace.Error($"Error notifing PubSubMonitor change for topic: {UniqueId}. Possible due to Application Unload.", ex);
}
}
}
}
private static bool changeVdirPath(DirectoryEntry espaceDir, string espaceName, string path, string rootPath)
{
try {
if (IsEspacePath(espaceName, espaceDir.Properties["Path"][0].ToString(), rootPath) && espaceDir.Properties["Path"][0].ToString() != path)
{
espaceDir.Properties["Path"][0] = path;
OSDirectoryEntry.CommitChanges(espaceDir);
return(true);
}
} catch (Exception e) {
OSTrace.Error("Changing vdir", e);
}
return(false);
}
private string GetTextResource(string espaceName, string resourceName, bool enableWarnings)
{
var resourceBinary = RuntimePlatformUtils.TryGetResourceBinary(resourceName, espaceName);
if (resourceBinary != null && resourceBinary.Length > 0)
{
return(Encoding.UTF8.GetStringWithoutBOM(resourceBinary));
}
if (enableWarnings)
{
OSTrace.Warning("Could not get " + resourceName + " file for '{0}'.", espaceName);
}
return(null);
}
private bool ValidateConsumerAndProducerKeys(string consumerKey, string producerKey)
{
bool consumerKeysAreValid = ObjectKey.Parse(consumerKey) == ConsumerModuleKey;
bool producerKeysAreValid = ObjectKey.Parse(producerKey) == ProducerModuleKey;
if (!consumerKeysAreValid)
{
OSTrace.Error($"Consumer Module keys don't match. Expected '{ObjectKeyUtils.DatabaseValue(ConsumerModuleKey)}' but was '{consumerKey}'");
}
if (!producerKeysAreValid)
{
OSTrace.Error($"Producer Module keys don't match. Expected '{ObjectKeyUtils.DatabaseValue(ProducerModuleKey)}' but was '{producerKey}'");
}
return(producerKeysAreValid && consumerKeysAreValid);
}
