public MigrateTask(Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration configuration, IKernel kernel, IMigrationDbs dbs, IFeatureToggler featureToggler)
{
_kernel = kernel;
_featureToggler = featureToggler;
if (!configuration.Disabled)
{
string connectionString = EnsureIntegrationDb(db.Value, configuration.CheckExistsAndCreateDatabaseIfNotFound, out _databaseCreated);
var integrationDb = new IntegrationMigrationDb(
configuration.DatabaseServer,
ConnectionString.FromText(connectionString),
typeof(M1_Baseline).Assembly,
typeof(M1_Baseline).Namespace);
MigrationRunner runner = CreateRunner(integrationDb, out _);
long latestVersion = runner.VersionLoader.VersionInfo.Latest();
_disabledFeatures = DisableFeatures(latestVersion);
dbs = dbs.WithIntegrationDb(integrationDb);
}
_dbs = dbs.ToArray();
}
public CleanUpIntegrationDbStep(Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration dbConfiguration, IConfigurationService configuration, IArchiveService archiver)
{
_db = db;
_dbConfiguration = dbConfiguration;
_configuration = configuration;
_archiver = archiver;
}
internal override IRuntimeDatabaseConfiguration ChangeConnectionString(IIntegrationDatabaseConfiguration configuration, string connectionString,
string databaseIdentifier)
{
var config = base.ChangeConnectionString(configuration, connectionString, databaseIdentifier);
config.SetParameter("Schema", databaseIdentifier);
return(config);
}
public string Serialize(IIntegrationDatabaseConfiguration conf, Func <string, string> valueEncrypter)
{
var sb = new StringBuilder();
sb.AppendLine(DatabaseConfigurations.ProviderKeyName + "=" + conf.DatabaseProvider.Key.Serialize());
sb.AppendLine(valueEncrypter(dalSerializer.Serialize(conf)));
return(sb.ToString());
}
public DisabledIfIntegrationDbIsDisabled(IIntegrationDatabaseConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_configuration = configuration;
}
public DbArchiveService(IDbFactory db, IIntegrationDatabaseConfiguration configuration, IRuntimeSettings settings)
{
_db = db;
_configuration = configuration;
if (!int.TryParse(settings[$"{nameof(DbArchiveService)}.DeleteBatchSize"], out _deleteBatchSize))
{
_deleteBatchSize = 20;
}
}
public DbDistributedMutex(IDbFactory db, IIntegrationDatabaseConfiguration configuration, IRuntimeSettings settings, IFeatureToggler featureToggler, IShutdown shutdown)
{
_db = db;
_configuration = configuration;
_featureToggler = featureToggler;
_shutdown = shutdown;
if (!TimeSpan.TryParse(settings[QueryLockIntervalKey], out TimeSpan queryLockInterval))
{
queryLockInterval = TimeSpan.FromSeconds(5);
}
_queryLockInterval = queryLockInterval;
}
public EnterLock(IDbFactory db, IIntegrationDatabaseConfiguration configuration, DistributedMutexContext context, TimeSpan queryLockInterval, CancellationToken cancellationToken)
{
_db = db;
_configuration = configuration;
_newLock = new DbDistributedMutexLock(context.Name)
{
MachineName = Environment.MachineName,
Description = context.Description.MaxLength(255)
};
using (IDbSession session = db.OpenSession())
{
TimeSpan waitTime = context.WaitTime;
int maxRetries = Math.Max((int)Math.Ceiling(waitTime.TotalMilliseconds / queryLockInterval.TotalMilliseconds), 1);
int attempts = 0;
DbDistributedMutexLock currentLock;
while (true)
{
if (TryEnterLock(session, out currentLock))
{
_onCancel = cancellationToken.Register(ReleaseLock);
return;
}
if (currentLock == null)
{
throw new InvalidOperationException($"Cannot obtain lock for '{_newLock.Name}', but current lock is null.");
}
if (++attempts >= maxRetries)
{
break;
}
context.OnWaiting($"{currentLock}. Waiting for {queryLockInterval} (attemt {attempts} of {maxRetries}).");
cancellationToken.WaitHandle.WaitOne(queryLockInterval);
}
throw new DistributedMutexTimeoutException($"Unable to acquire lock '{_newLock.Name}' within wait time ({waitTime}) using {attempts} attempts with a query interval of {queryLockInterval}. {currentLock}");
}
}
public void Deserialize(string serializedForm, IIntegrationDatabaseConfiguration config)
{
try {
var wrapper = new MetaDatabaseConfiguration(config);
var properties = ReadPropertiesFromSerialization(serializedForm);
foreach (var nameValue in properties)
{
var param = wrapper.GetParameter(nameValue.Key);
if (param != null)
{
param.Set(nameValue.Value);
}
}
} catch (Exception e) {
throw new ConfigurationSerializationException(e);
}
}
public static void Fill(IIntegrationDatabaseConfiguration conf, string prefix, ISettingsProvider settingsProvider)
{
var meta = new MetaDatabaseConfiguration(conf);
var @params = meta.AllParameters;
foreach (var setter in @params)
{
if (setter != null && setter.Persist)
{
var setting = new Setting <string>(prefix + setter.Name, null, setter.Encrypt);
string value = settingsProvider.Get(setting);
if (value != null)
{
setter.Set(value);
}
}
}
}
public string Serialize(IIntegrationDatabaseConfiguration config)
{
try {
var wrapper = new MetaDatabaseConfiguration(config);
var parametersToSerialize = wrapper.VisibleParameters.Cast <IParameter>().Where(p => !p.ReadOnly)
.Union(wrapper.Parameters.Where(p => !(p is IUserDefinedParameter)));
var configurationXML = new XDocument(new XElement("DBConfiguration"));
foreach (var paramToSerialize in parametersToSerialize)
{
configurationXML.Root.Add(new XElement(paramToSerialize.Name, paramToSerialize.Get()));
}
return(configurationXML.ToString());
} catch (Exception e) {
throw new ConfigurationSerializationException(e);
}
}
public DeleteDbDistributedMutexLocksCommand(IDbFactory db, IIntegrationDatabaseConfiguration configuration)
{
_db = db;
_configuration = configuration;
}
internal virtual IRuntimeDatabaseConfiguration ChangeConnectionString(IIntegrationDatabaseConfiguration configuration, string connectionString, string databaseIdentifier)
{
configuration.ConnectionStringOverride = connectionString;
return(configuration.RuntimeDatabaseConfiguration);
}
/// <summary>
/// Upgrades the specified connection.
/// </summary>
/// <param name="dbmsName">Name of the DBMS.</param>
/// <param name="connStr">The connection string.</param>
/// <returns>The upgraded database configuration.</returns>
/// <exception cref="ConnectionUpgradeException">Unable to upgrade database connection.</exception>
public IIntegrationDatabaseConfiguration Upgrade(string dbmsName, string connStr)
{
#pragma warning disable 618
connStr = SettingsInternal.DecryptStringForUpgrade(connStr);
#pragma warning restore 618
Dictionary <String, String> providerKeys = new Dictionary <string, string>();
providerKeys.Add("sql server", "SqlServer");
providerKeys.Add("oracle", "Oracle");
bool isSqlServer = dbmsName.ToLower().Equals("sql server");
IDatabaseProvider provider = pluginProvider.GetImplementation(DatabaseProviderKey.Deserialize(providerKeys[dbmsName.ToLower()]));
IIntegrationDatabaseConfiguration dbConfig = provider.CreateEmptyIntegrationDatabaseConfiguration();
MetaDatabaseConfiguration meta = new MetaDatabaseConfiguration(dbConfig);
if (RuntimePlatformUtils.IsJava())
{
string connStringOverride_SID = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(PORT={0})(HOST={1}))(CONNECT_DATA=(SID={2})))";
Regex _datasourceJavaSidRegex = new Regex(@"jdbc:oracle:thin:([^/]*)/([^@]*)@([^:]*):([^:]*):([^:]*)", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
string connStringOverride_ServiceName = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(PORT={0})(HOST={1}))(CONNECT_DATA=(SERVICE_NAME={2})))";
Regex _datasourceJavaServiceNameRegex = new Regex(@"jdbc:oracle:thin:([^/]*)/([^@]*)@([^:]*):([^:]*)/([^:]*)", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
string username, password, tnsDescriptor;
Match _sidMatch, _snMatch;
_sidMatch = _datasourceJavaSidRegex.Match(connStr);
if (_sidMatch.Success)
{
username = _sidMatch.Groups[1].Value;
password = _sidMatch.Groups[2].Value;
tnsDescriptor = String.Format(connStringOverride_SID, _sidMatch.Groups[4].Value, _sidMatch.Groups[3].Value, _sidMatch.Groups[5].Value);
}
else
{
_snMatch = _datasourceJavaServiceNameRegex.Match(connStr);
if (!_snMatch.Success)
{
throw new ConnectionUpgradeException("Unable to upgrade database connection.");
}
username = _snMatch.Groups[1].Value;
password = _snMatch.Groups[2].Value;
tnsDescriptor = String.Format(connStringOverride_ServiceName, _snMatch.Groups[4].Value, _snMatch.Groups[3].Value, _snMatch.Groups[5].Value);
}
meta.GetParameter("Username").Set(username);
meta.GetParameter("Password").Set(password);
dbConfig.AdvancedConfiguration.AdvancedConnectionStringField = tnsDescriptor;
dbConfig.ConnectionStringOverride = String.Empty;
}
else
{
Regex _datasourceRegex = new Regex(@"data source=\s*([^ ;]+)\s*;", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
Regex _portRegex = new Regex(@"port=\s*([^ ;]+)\s*;", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
Regex _catalogRegex = new Regex(@"initial catalog=\s*([^ ;]+)\s*;", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
Regex _userIdRegex = new Regex(@"user id=\s*([^ ;]+)\s*;", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
Regex _passwordRegex = new Regex(@"password=\s*([^ ;]+)\s*;", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
Match userIdMatch, passwordMatch;
bool isAdvanced = false;
List <string> basicKeys = new List <string> {
"data source", "user id", "password"
};
if (isSqlServer)
{
basicKeys.Add("initial catalog");
}
else
{
basicKeys.Add("port");
}
List <string> keysInConnection = connStr.Split(';').ToList <string>();
connStr += connStr.EndsWith(";") ? "" : ";";
foreach (string key in keysInConnection)
{
if (!basicKeys.Contains(key.Substring(0, key.IndexOf("=")).Trim().ToLower()))
{
isAdvanced = true;
break;
}
}
userIdMatch = _userIdRegex.Match(connStr);
meta.GetParameter("Username").Set(userIdMatch.Groups[1].Value.Replace("\"", ""));
passwordMatch = _passwordRegex.Match(connStr);
meta.GetParameter("Password").Set(passwordMatch.Groups[1].Value.Replace("\"", ""));
if (isAdvanced)
{
// In advanced mode the connection string override will hold all keys and values except username and password
dbConfig.AdvancedConfiguration.AdvancedConnectionStringField = connStr;
if (userIdMatch.Success)
{
dbConfig.AdvancedConfiguration.AdvancedConnectionStringField = dbConfig.AdvancedConfiguration.AdvancedConnectionStringField.Replace(userIdMatch.Groups[0].Value, "");
}
if (passwordMatch.Success)
{
dbConfig.AdvancedConfiguration.AdvancedConnectionStringField = dbConfig.AdvancedConfiguration.AdvancedConnectionStringField.Replace(passwordMatch.Groups[0].Value, "");
}
}
else
{
if (isSqlServer)
{
meta.GetParameter("Server").Set(_datasourceRegex.Match(connStr).Groups[1].Value.Replace("\"", ""));
meta.GetParameter("Catalog").Set(_catalogRegex.Match(connStr).Groups[1].Value.Replace("\"", ""));
}
else
{
var dataSrcValues = _datasourceRegex.Match(connStr).Groups[1].Value.Replace("\"", "").Split('/');
var portValue = _portRegex.Match(connStr).Groups[1].Value.Replace("\"", "");
meta.GetParameter("Host").Set(dataSrcValues.IsEmpty() ? "" : dataSrcValues[0]);
meta.GetParameter("Port").Set(portValue.IsNullOrEmpty() || portValue.Equals("0") ? "1521" /*default*/ : portValue);
meta.GetParameter("ServiceName").Set(dataSrcValues.Length < 1 ? "" : dataSrcValues[1]);
}
}
dbConfig.ConnectionStringOverride = String.Empty;
}
return(dbConfig);
}
public ExportIntegrationErrorsStep(Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration configuration, ITaskFactory taskFactory)
{
_db = db;
_configuration = configuration;
_taskFactory = taskFactory;
}
public TaskExecutionDetailsController(Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration configuration)
{
_db = db;
_configuration = configuration;
}
public static void SetParameters(this IIntegrationDatabaseConfiguration conf, Dictionary <string, object> @params)
{
DatabaseConfigurations.Fill(conf, @params);
}
public static string GetParameter(this IIntegrationDatabaseConfiguration conf, string name)
{
return(DatabaseConfigurations.GetParameter(conf, name));
}
public DbLogger(IDbFactory db, IIntegrationDatabaseConfiguration configuration, IFeatureToggler featureToggler)
{
_db = db;
_configuration = configuration;
_featureToggler = featureToggler;
}
public TaskDetailsController(ITaskFactory taskFactory, Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration configuration)
{
_taskFactory = taskFactory;
_db = db;
_configuration = configuration;
}
public DbConfigurationRepository(IDbFactory db, IIntegrationDatabaseConfiguration configuration)
{
_db = db;
_configuration = configuration;
}
public IWindsorInstaller GetInstaller(IKernel kernel, IIntegrationDatabaseConfiguration configuration)
{
return(configuration.Disabled ? _disabled(kernel) : _enabled(kernel));
}
public AdvancedConnectionStringParam(IIntegrationDatabaseConfiguration configuration)
{
this.configuration = configuration;
}
public ErrorsController(Lazy <IDbFactory> db, IIntegrationDatabaseConfiguration configuration)
{
_db = db;
_configuration = configuration;
}
public static void SetParameter(this IIntegrationDatabaseConfiguration conf, string name, string value)
{
DatabaseConfigurations.Fill(conf, new Dictionary <string, object> {
{ name, value }
});
}
public ConnStringTemplateParam(IIntegrationDatabaseConfiguration configuration)
{
this.configuration = configuration;
}
public CleanUpDbDistributedMutexStep(Lazy <IDeleteDbDistributedMutexLocksCommand> deleteCommand, IIntegrationDatabaseConfiguration configuration)
{
_deleteCommand = deleteCommand;
_configuration = configuration;
}
public string Serialize(IIntegrationDatabaseConfiguration conf)
{
return(Serialize(conf, SecureConfidentialInformationEncryption.EncryptMaintainingCompatibility));
}
