/// <summary>
/// 初始化数据库连接
/// </summary>
/// <param name="options"></param>
public static void InitConnection(StagingOptions options)
{
CheckNotNull.NotNull(options, nameof(options));
CheckNotNull.NotEmpty(options.ConnectionMaster, nameof(options.ConnectionMaster));
Options = options;
// 初始化主库连接实例
ConnectionStringConfiguration conn = new ConnectionStringConfiguration()
{
ConnectionString = options.ConnectionMaster,
DbConnection = new Npgsql.NpgsqlConnection(options.ConnectionMaster)
};
InstanceMaster = new MasterExecute(options.Logger, conn);
// 初始化从库连接实例
List <ConnectionStringConfiguration> connList = GetSlaves(options.ConnectionSlaves);
if (connList != null)
{
InstanceSlave = new SlaveExecute(options.Logger, connList);
}
if (options.CacheOptions != null && options.CacheOptions.Cache != null)
{
CacheManager = new CacheManager(options.CacheOptions);
}
}
/// <summary>
/// 启动连接监控
/// </summary>
/// <param name="connectionString"></param>
private void Monitor(ConnectionStringConfiguration connS)
{
ErrorList.Add(connS);
if (timer == null)
{
timer = new Timer(OnTick, this, 10 * 1000, 60 * 1000);
Console.WriteLine("监控服务已启动");
}
}
/// <summary>
/// Instantiate right away.
/// </summary>
private Configuration()
{
var builder = new ConfigurationBuilder()
.AddJsonFile("config.json")
.AddJsonFile("config.local.json", optional: true)
.AddEnvironmentVariables();
configuration = builder.Build();
ConnectionStrings = new ConnectionStringConfiguration(configuration.GetSection("ConnectionStrings"));
Label = new LabelConfiguration(configuration.GetSection("Label"));
Authentication = new AuthenticationConfiguration(configuration.GetSection("Authentication"));
}
private void LoadDataFromConnection(ConnectionStringConfiguration selectedCon)
{
ServerNameTxtB.Text = selectedCon.ServerName;
DatabaseNameTxtB.Text = selectedCon.DatabaseName;
TrustedConnectionCB.Checked = selectedCon.TrustedConnection;
if (TrustedConnectionCB.Checked)
{
userTxtB.Text = selectedCon.UserId;
passwordTxtB.Text = selectedCon.Password;
}
}
// HELPER METHODS SECTION
//---------------------------------------------------------------------
#region Helper methods
// LOAD CONFIGURATIONS SECTION
//-------------------------------------------------
private void LoadConnectionsConfiguration()
{
// RECIPES CONNECTION
//---------------------------------------------
try
{
_recipesConnection = _connectionConfigManager.Get("recipes");
View.RecipesFolderPath = _recipesConnection.ConnectionString;
}
catch (ArgumentNullException ex)
{
_log.Error(ex.ToString());
}
catch (RepositoryLoadException ex)
{
_log.Error(ex.ToString());
}
// REMAINS CONNECTION
//---------------------------------------------
try
{
_remainsConnection = _connectionConfigManager.Get("remains");
View.RemainsFolderPath = _remainsConnection.ConnectionString;
}
catch (ArgumentNullException ex)
{
_log.Error(ex.ToString());
}
catch (RepositoryLoadException ex)
{
_log.Error(ex.ToString());
}
// GUIDES CONNECTION
//---------------------------------------------
try
{
_guidesConfiguration = _guidesConfigurationManager.Get();
View.GuidesFolderPath = _guidesConfiguration.Path;
}
catch (ArgumentNullException ex)
{
_log.Error(ex.ToString());
}
catch (RepositoryLoadException ex)
{
_log.Error(ex.ToString());
}
}
/// <summary>
/// 刷新数据库连接
/// </summary>
/// <param name="connectionMaster"></param>
/// <param name="connectionSlaves"></param>
public static void Refresh(string connectionMaster, string[] connectionSlaves = null)
{
ConnectionStringConfiguration conn = new ConnectionStringConfiguration()
{
ConnectionString = connectionMaster,
DbConnection = new Npgsql.NpgsqlConnection(connectionMaster)
};
InstanceMaster.Pool.Refresh(new List <ConnectionStringConfiguration>()
{
conn
});
List <ConnectionStringConfiguration> connList = GetSlaves(connectionSlaves);
InstanceSlave?.Pool?.Refresh(connList);
}
// HELPER METHODS SECTION
//---------------------------------------------------------------------
#region Helper methods
// LOAD CONFIGURATIONS SECTION
//-------------------------------------------------
private void LoadConnectionsConfiguration()
{
// RECIPES CONNECTION
//---------------------------------------------
try
{
_recipesConnection = _connectionConfigManager.Get("recipes");
var folderPath = ParseFolderPath(_recipesConnection.ConnectionString);
View.RecipesFolderPath = folderPath;
/** Provider =Microsoft.Jet.OLEDB.4.0;
* Data Source=C:\test\converter\recipes\;
* User ID=Admin;
* Password=;
* Extended Properties='dBASE IV';*/
}
catch (ArgumentNullException ex)
{
_log.Error(ex.ToString());
}
catch (RepositoryLoadException ex)
{
_log.Error(ex.ToString());
}
// REMAINS CONNECTION
//---------------------------------------------
try
{
_remainsConnection = _connectionConfigManager.Get("remains");
var folderPath = ParseFolderPath(_remainsConnection.ConnectionString);
View.RemainsFolderPath = folderPath;
}
catch (ArgumentNullException ex)
{
_log.Error(ex.ToString());
}
catch (RepositoryLoadException ex)
{
_log.Error(ex.ToString());
}
}
public static void RegisterIdentityService(IServiceCollection services)
{
#region Identity Context
services.AddDbContext <SocialHeroesContext>(options =>
options.UseSqlServer(ConnectionStringConfiguration.ConnectionString()));
services.AddIdentity <User, Role>()
.AddEntityFrameworkStores <SocialHeroesContext>()
.AddDefaultTokenProviders();
#endregion
#region Identity Settings
services
.Configure <IdentityOptions>(options =>
{
//Lockout
options.Lockout.AllowedForNewUsers = true;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
options.Lockout.MaxFailedAccessAttempts = 5;
//Password
options.Password.RequireDigit = true;
options.Password.RequiredLength = 6;
options.Password.RequiredUniqueChars = 1;
options.Password.RequireLowercase = false;
options.Password.RequireUppercase = false;
options.Password.RequireNonAlphanumeric = false;
//SignIn
options.SignIn.RequireConfirmedEmail = false;
options.SignIn.RequireConfirmedPhoneNumber = false;
//Token
//options.Tokens.AuthenticatorTokenProvider
//options.Tokens.ChangeEmailTokenProvider
//options.Tokens.ChangePhoneNumberTokenProvider
//options.Tokens.EmailConfirmationTokenProvider
//options.Tokens.PasswordResetTokenProvider
//User
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
options.User.RequireUniqueEmail = false;
});
#endregion
}
/// <summary>
/// Creates the connection string.
/// </summary>
/// <param name="externalIdentifier">The external identifier.</param>
/// <param name="connectionStringType">Type of the connection string.</param>
/// <param name="connectionString">The connection string.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public async Task CreateConnectionString(String externalIdentifier, ConnectionStringType connectionStringType, String connectionString, CancellationToken cancellationToken)
{
this.GuardAgainstNoExternalIdentifier(externalIdentifier);
// Find the record in the config repository
using (ConnectionStringConfigurationContext context = this.ContextResolver())
{
ConnectionStringConfiguration configuration = new ConnectionStringConfiguration
{
ExternalIdentifier = externalIdentifier,
ConnectionString = connectionString,
ConnectionStringTypeId = (Int32)connectionStringType
};
await context.AddAsync(configuration, cancellationToken);
await context.SaveChangesAsync(cancellationToken);
}
}
/// <summary>
/// 刷新数据库连接
/// </summary>
/// <param name="connS"></param>
/// <param name="poolSize"></param>
public static void Refresh(string connectionMaster, string[] connectionSlaves = null, int slavesMaxPool = -1)
{
int poolsizeMaster = GetPollSize(connectionMaster);
ConnectionStringConfiguration connS = new ConnectionStringConfiguration()
{
ConnectionString = connectionMaster,
MaxConnection = poolsizeMaster,
DbConnection = new Npgsql.NpgsqlConnection(connectionMaster)
};
InstanceMaster.Pool.Refresh(new List <ConnectionStringConfiguration>()
{
connS
}, connS.MaxConnection);
List <ConnectionStringConfiguration> connList = GetSlaves(connectionSlaves, out int poolsizeSlave);
InstanceSlave?.Pool?.Refresh(connList, poolsizeSlave);
}
/// <summary>
/// 初始化数据库连接
/// </summary>
/// <param name="logger">日志组件</param>
/// <param name="connectionMaster">可读写数据库连接</param>
/// <param name="connectionStringSlave">从库数据库连接</param>
/// <param name="connectionSlaves">从库连接池总大小，如果不指定（默认 -1），如果没有设定 maximum pool size 的值,则从库中读取 maximum pool size 设定的值进行累计</param>
public static void InitConnection(StagingOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(StagingOptions));
}
if (string.IsNullOrEmpty(options.ConnectionMaster))
{
throw new ArgumentNullException("connectionString not null");
}
Options = options;
// 初始化主库连接实例
int poolsizeMaster = GetPollSize(options.ConnectionMaster);
ConnectionStringConfiguration connS = new ConnectionStringConfiguration()
{
ConnectionString = options.ConnectionMaster,
MaxConnection = poolsizeMaster,
DbConnection = new Npgsql.NpgsqlConnection(options.ConnectionMaster)
};
InstanceMaster = new MasterExecute(options.Logger, connS);
// 初始化从库连接实例
List <ConnectionStringConfiguration> connList = GetSlaves(options.ConnectionSlaves, out int poolsizeSlave);
if (options.SlavesMaxPool != -1)
{
poolsizeSlave = options.SlavesMaxPool;
}
if (connList != null)
{
InstanceSlave = new SlaveExecute(options.Logger, connList, poolsizeSlave);
}
if (options.CacheOptions != null && options.CacheOptions.Cache != null)
{
Console.WriteLine("options.CacheOptions.Cache:{0}", options.CacheOptions.Cache == null);
CacheManager = new CacheManager(options.CacheOptions);
}
}
/// <summary>
/// 初始化数据库连接
/// </summary>
/// <param name="logger">日志组件</param>
/// <param name="connectionMaster">可读写数据库连接</param>
/// <param name="connectionStringSlave">从库数据库连接</param>
/// <param name="connectionSlaves">从库连接池总大小，如果不指定（默认 -1），如果没有设定 maximum pool size 的值,则从库中读取 maximum pool size 设定的值进行累计</param>
public static void InitConnection(ILogger logger, string connectionMaster, string[] connectionSlaves = null, int slavesMaxPool = -1)
{
if (string.IsNullOrEmpty(connectionMaster))
{
throw new ArgumentNullException("connectionString not null");
}
// 初始化主库连接实例
int poolsizeMaster = GetPollSize(connectionMaster);
ConnectionStringConfiguration connS = new ConnectionStringConfiguration()
{
ConnectionString = connectionMaster, MaxConnection = poolsizeMaster, DbConnection = new Npgsql.NpgsqlConnection(connectionMaster)
};
instanceMaster = new MasterExecute(logger, connS);
// 初始化从库连接实例
if (connectionSlaves != null && connectionSlaves.Length > 0)
{
int pollsizeSlave = 0;
List <ConnectionStringConfiguration> connList = new List <ConnectionStringConfiguration>();
for (int i = 0; i < connectionSlaves.Length; i++)
{
var item = connectionSlaves[i];
connList.Add(new ConnectionStringConfiguration()
{
ConnectionString = item,
Id = i,
MaxConnection = GetPollSize(item),
DbConnection = new Npgsql.NpgsqlConnection(connectionMaster)
});
pollsizeSlave += connList[i].MaxConnection;
}
if (slavesMaxPool != -1)
{
pollsizeSlave = slavesMaxPool;
}
instanceSlave = new SlaveExecute(logger, connList, pollsizeSlave);
}
}
/// <summary>
/// Gets the connection string.
/// </summary>
/// <param name="externalIdentifier">The external identifier.</param>
/// <param name="connectionStringType">Type of the connection string.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="NotFoundException">No configuration found for Connection String Identifier [{connectionStringIdentifier}] and DataModelType [{dataModelType}]</exception>
public async Task <String> GetConnectionString(String externalIdentifier, ConnectionStringType connectionStringType, CancellationToken cancellationToken)
{
this.GuardAgainstNoExternalIdentifier(externalIdentifier);
// Find the record in the config repository
using (ConnectionStringConfigurationContext context = this.ContextResolver())
{
ConnectionStringConfiguration configuration =
await context.ConnectionStringConfiguration.SingleOrDefaultAsync(c => c.ExternalIdentifier == externalIdentifier &&
c.ConnectionStringTypeId == (Int32)connectionStringType,
cancellationToken);
if (configuration == null)
{
throw new
NotFoundException($"No connection string configuration found for External Identifier [{externalIdentifier}] and Connection String Type [{connectionStringType}]");
}
return(configuration.ConnectionString);
}
}
public ConfigurationForm()
{
connectionData = new ConnectionStringConfiguration();
InitializeComponent();
}
/// <summary>
/// ��̬���ݷ��ʶ���
/// </summary>
/// <param name="csc">���ݿ����á�</param>
/// <returns>���ݷ��ʽӿ�</returns>
public static IDBAccess Instance(ConnectionStringConfiguration csc)
{
if (csc == null)
return null;
EnumDbType dbType = EnumDbType.SqlServer;
try
{
if (!string.IsNullOrEmpty(csc.ProviderName))
dbType = (EnumDbType)Enum.Parse(typeof(EnumDbType), csc.ProviderName);
}
catch (Exception) { }
return Instance(csc.ConnectionString, dbType);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="logger">日志输出对象</param>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="poolSize">连接池大小</param>
public PgExecute(ILogger logger, ConnectionStringConfiguration connectionString) : this(logger, new List <ConnectionStringConfiguration>() { connectionString })
{
}
public MasterExecute(ILogger logger, ConnectionStringConfiguration connectionString) : base(logger, connectionString)
{
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) => optionsBuilder.UseSqlServer(ConnectionStringConfiguration.ConnectionString());
