/// <summary>
/// Register tenant shard
/// </summary>
/// <param name="tenantServerConfig">The tenant server configuration.</param>
/// <param name="databaseConfig">The database configuration.</param>
/// <param name="catalogConfig">The catalog configuration.</param>
/// <param name="resetEventDate">If set to true, the events dates for all tenants will be reset </param>
public void RegisterTenantShard(TenantServerConfig tenantServerConfig, DatabaseConfig databaseConfig, CatalogConfig catalogConfig, bool resetEventDate)
{
//get all database in devtenantserver
var tenants = GetAllTenantNames(tenantServerConfig, databaseConfig);
var connectionString = GetBasicSqlConnectionString(databaseConfig);
foreach (var tenant in tenants)
{
var tenantId = GetTenantKey(tenant);
if (Sharding.RegisterNewShard(tenant, tenantId, tenantServerConfig, databaseConfig, catalogConfig))
{
// resets all tenants' event dates
if (resetEventDate)
{
#region EF6
//use EF6 since execution of Stored Procedure in EF Core for anonymous return type is not supported yet
using (var context = new TenantContext(Sharding.ShardMap, tenantId, connectionString))
{
context.Database.ExecuteSqlCommand("sp_ResetEventDates");
}
#endregion
#region EF core
//https://github.com/aspnet/EntityFramework/issues/7032
//using (var context = new TenantDbContext(Sharding.ShardMap, tenantId, connectionString))
//{
// context.Database.ExecuteSqlCommand("sp_ResetEventDates");
//}
#endregion
}
}
}
}
/// <summary>
/// Register tenant shard
/// </summary>
/// <param name="tenantServerConfig">The tenant server configuration.</param>
/// <param name="databaseConfig">The database configuration.</param>
/// <param name="catalogConfig">The catalog configuration.</param>
/// <param name="resetEventDate">If set to true, the events dates for all tenants will be reset </param>
public static void RegisterAllTenantShard(string tenantServer)
{
var tenants = GetAllTenantNames();
foreach (var tenant in tenants)
{
var tenantId = GetTenantKey(tenant.TenantName);
var result = Sharding.RegisterNewShard(tenantId, tenant.TenantName, tenantServer);
}
}
public async void RegisterShardTest()
{
_databaseConfig = new DatabaseConfig
{
SqlProtocol = SqlProtocol.Default
};
var sharding = new Sharding(_catalogConfig.CatalogDatabase, _connectionString, _mockCatalogRepo.Object, _mockTenantRepo.Object, _mockUtilities.Object);
var result = await Sharding.RegisterNewShard("TestTenant", 397858529, "localhost", _databaseConfig.DatabaseServerPort, _catalogConfig.ServicePlan);
Assert.IsTrue(result);
}
public async void RegisterShardTest()
{
_databaseConfig = new DatabaseConfig
{
SqlProtocol = SqlProtocol.Default
};
var sharding = new Sharding(_catalogConfig.CatalogDatabase, _connectionString, _mockCatalogRepo, _mockTenantRepo, _mockUtilities.Object);
var result = await Sharding.RegisterNewShard("TestTenant", 1, TestServer, 1433, _catalogConfig.ServicePlan);
Assert.True(result);
}
public void RegisterShardTest()
{
TenantServerConfig tenantServerConfig = new TenantServerConfig
{
TenantServer = "localhost"
};
_databaseConfig = new DatabaseConfig
{
SqlProtocol = SqlProtocol.Default
};
_mockHelper.Setup(helper => helper.GetSqlConnectionString(_databaseConfig, _catalogConfig)).Returns(ShardMapManagerConnString);
var sharding = new Sharding(_catalogConfig, _databaseConfig, _mockTenantsRepo.Object, _mockHelper.Object);
var result = Sharding.RegisterNewShard("TestTenant", 397858529, tenantServerConfig, _databaseConfig, _catalogConfig);
Assert.IsTrue(result);
}
public async Task RegisterShardTest()
{
_databaseConfig = new DatabaseConfig
{
SqlProtocol = SqlProtocol.Default
};
var sharding = new Sharding(_catalogConfig.CatalogDatabase, _connectionString, _mockCatalogRepo, _mockTenantRepo, _mockUtilities.Object);
Assert.IsNotNull(sharding);
var shard = Sharding.CreateNewShard("Test Tenant 1", TestServer, _databaseConfig.DatabaseServerPort, _catalogConfig.ServicePlan);
Assert.IsNotNull(shard);
var result = await Sharding.RegisterNewShard(1032943028, _catalogConfig.ServicePlan, shard);
Assert.IsTrue(result);
}
public async Task RegisterAsync(ShardingRequestModel request, ILogger log)
{
var connectionBuilder = new SqlConnectionStringBuilder()
{
DataSource = _configuration["Sharding:MapManagerServer"],
InitialCatalog = "Tenant",
UserID = _configuration["Sharding:MapManagerId"],
Password = _configuration["Sharding:MapManagerPassword"],
ApplicationIntent = ApplicationIntent.ReadOnly,
ApplicationName = "idp-function"
};
var tenantConnection = new SqlConnection(connectionBuilder.ConnectionString);
var query = "select * from shardings with(nolock) where 1 = 1";
if (!string.IsNullOrEmpty(request.DatabaseName))
{
query += " and DatabaseName = @DatabaseName";
}
if (!string.IsNullOrEmpty(request.EnvironmentName))
{
query += " and EnvironmentName = @EnvironmentName";
}
if (!string.IsNullOrEmpty(request.ServiceName))
{
query += " and ServiceName = @ServiceName";
}
await tenantConnection.OpenAsync();
var shardings = await tenantConnection.QueryAsync <ShardingModel>(query, request, commandTimeout : 500);
await tenantConnection.CloseAsync();
foreach (var sharding in shardings)
{
ShardLocation shardLocation = new ShardLocation(sharding.ServerName, sharding.DatabaseName, SqlProtocol.Tcp, 1433);
RecoveryManager rm = _shardingProvider.ShardMapManager.GetRecoveryManager();
rm.DetachShard(shardLocation);
var key = $"{sharding.TenantId}_{sharding.ServiceName}_{sharding.EnvironmentName}".Replace("__", "_").ToLower();
log?.LogInformation($"Register {key}");
_shardingProvider.RegisterNewShard(Encoding.UTF8.GetBytes(key), sharding.ServerName, sharding.DatabaseName);
}
}
/// <summary>
/// Register tenant shard
/// </summary>
/// <param name="tenantServerConfig">The tenant server configuration.</param>
/// <param name="databaseConfig">The database configuration.</param>
/// <param name="catalogConfig">The catalog configuration.</param>
/// <param name="resetEventDate">If set to true, the events dates for all tenants will be reset </param>
public static void RegisterTenantShard(string tenantServer, string tenantName)
{
var tenantId = GetTenantKey(tenantName);
var result = Sharding.RegisterNewShard(tenantId, tenantName, tenantServer, true);
}
public async Task <IActionResult> Post([FromBody] CreateTeamModel model)
{
//TODO: Implement Detailed Error Checking
if (ModelState.IsValid)
{
try
{
//TenantServerConfig tenantServerConfig, DatabaseConfig databaseConfig, CatalogConfig catalogConfig
var databaseConfig = new DatabaseConfig
{
DatabasePassword = _configuration["DatabaseOptions:DatabasePassword"],
DatabaseUser = _configuration["DatabaseOptions:DatabaseUser"],
DatabaseServerPort = Int32.Parse(_configuration["DatabaseOptions:DatabaseServerPort"]),
SqlProtocol = SqlProtocol.Tcp,
ConnectionTimeOut = Int32.Parse(_configuration["DatabaseOptions:ConnectionTimeOut"]),
};
var catalogConfig = new CatalogConfig
{
ServicePlan = _configuration["DatabaseOptions:ServicePlan"],
CatalogDatabase = _configuration["DatabaseOptions:CatalogDatabase"],
CatalogServer = _configuration["DatabaseOptions:CatalogServer"], // + ".database.windows.net"
};
var tenantServerConfig = new TenantServerConfig
{
TenantServer = _configuration["DatabaseOptions:CatalogServer"],// + ".database.windows.net",
TenantDatabase = _configuration["DatabaseOptions:TenantDatabase"],
};
var team = new Team
{
Id = _utilities.GetTenantKey(model.TenantName),
Name = model.TenantName,
LogoLink = model.TenantLogoLink,
};
//Create Shard, Add Team and Register Tenant against shard
var shard = Sharding.CreateNewShard(tenantServerConfig.TenantDatabase, tenantServerConfig.TenantServer, databaseConfig.DatabaseServerPort, null);
await _tenantRepository.AddTeam(team);
var x = await Sharding.RegisterNewShard(team.Id, "", shard);
//Add first user to team. Team Owner!
var applicationUser = await _userService.GetApplicationUserAsync();
var user = new User {
ApplicationUserId = applicationUser.Id, Email = applicationUser.Email, UserRole = Role.SuperAdministrator
};
await _tenantRepository.AddUserToTeam(user, team.Id);
return(Ok(new { team_id = team.Id, team_name = team.Name }));
}
catch (Exception ex)
{
//TODO: Log Error
return(BadRequest(new { Error = ex.Message }));
}
}
return(BadRequest(ModelState));
}
