/// <summary>
/// Initializes a new instance of the <see cref="Sharding" /> class.
/// <para>Bootstrap Elastic Scale by creating a new shard map manager and a shard map on the shard map manager database if necessary.</para>
/// </summary>
/// <param name="catalogDatabase">The catalog database.</param>
/// <param name="connectionString">The connection string.</param>
/// <param name="catalogRepository">The catalog repository.</param>
/// <param name="tenantRepository">The tenant repository.</param>
/// <param name="utilities">The utilities class.</param>
/// <exception cref="System.ApplicationException">Error in sharding initialisation.</exception>
public Sharding(string catalogDatabase, string connectionString, ICatalogRepository catalogRepository, ITenantRepository tenantRepository, IUtilities utilities)
{
try
{
_catalogRepository = catalogRepository;
_tenantRepository = tenantRepository;
_utilities = utilities;
// Deploy shard map manager
// if shard map manager exists, refresh content, else create it, then add content
ShardMapManager smm;
ShardMapManager =
!ShardMapManagerFactory.TryGetSqlShardMapManager(connectionString,
ShardMapManagerLoadPolicy.Lazy, out smm)
? ShardMapManagerFactory.CreateSqlShardMapManager(connectionString)
: smm;
// check if shard map exists and if not, create it
ListShardMap <int> sm;
ShardMap = !ShardMapManager.TryGetListShardMap(catalogDatabase, out sm)
? ShardMapManager.CreateListShardMap <int>(catalogDatabase)
: sm;
}
catch (Exception exception)
{
Trace.TraceError(exception.Message, "Error in sharding initialisation.");
}
}
public void RegisterNewTenantIfNotExists(long tenantId)
{
SqlConnectionStringBuilder smConnectionString = new SqlConnectionStringBuilder(_shardingManagerOptions.ShardMap);
ShardMapManager smm;
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(_shardingManagerOptions.ShardMapManager, ShardMapManagerLoadPolicy.Lazy, out smm))
{
throw new InvalidOperationException("Error accessing shard map manager database");
}
ListShardMap <long> sm;
if (!smm.TryGetListShardMap <long>(ElasticScaleConstants.ListMapName, out sm))
{
throw new InvalidOperationException("Error accessing list shard map of the sharding map manager database");
}
ShardLocation shardLocation = new ShardLocation(smConnectionString.DataSource, smConnectionString.InitialCatalog);
Shard shard;
if (!sm.TryGetShard(shardLocation, out shard))
{
shard = sm.CreateShard(shardLocation);
}
if (!sm.TryGetMappingForKey(tenantId, out _))
{
sm.CreatePointMapping(tenantId, shard);
}
}
public void UpgradeGSM()
{
// Get shard map manager
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
try
{
ShardMap testsm = smm.CreateListShardMap <int>(ShardMapManagerUpgradeTests.s_shardMapNames[0]);
Assert.IsNotNull(testsm);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCode.GlobalStoreVersionMismatch, sme.ErrorCode);
}
// Upgrade to version 1.0: no-op
smm.UpgradeGlobalStore(new Version(1, 0));
// Upgrade to version 1.1
smm.UpgradeGlobalStore(new Version(1, 1));
// Below call should succeed as latest supported major version of library matches major version of deployed store.
ShardMap sm = smm.CreateListShardMap <int>(ShardMapManagerUpgradeTests.s_shardMapNames[0]);
Assert.IsNotNull(sm);
// Upgrade to version 1.2
smm.UpgradeGlobalStore(new Version(1, 2));
// Upgrade to latest version (1.2): no-op
smm.UpgradeGlobalStore();
}
private static void TryAddShardMapManagement <TTenantIdentity>(IServiceCollection services,
string connectionString)
{
services.TryAddSingleton(s =>
{
var shardingConfig = s.GetService <IOptions <ShardingConfiguration> >().Value;
EnsureDbExists(connectionString, shardingConfig.ElasticPool);
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(
connectionString,
ShardMapManagerLoadPolicy.Lazy,
out ShardMapManager shardMapManager))
{
ShardMapManagerFactory.CreateSqlShardMapManager(connectionString);
shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
ShardMapManagerLoadPolicy.Lazy);
}
return(shardMapManager);
});
services.TryAddSingleton(s =>
{
var smm = s.GetService <ShardMapManager>();
var options = s.GetService <IOptions <ShardingConfiguration> >().Value;
string mapName = options.ShardMap;
// check if shardmap exists and if not, create it
if (!smm.TryGetListShardMap(mapName, out ListShardMap <TTenantIdentity> shardMap))
{
return(smm.CreateListShardMap <TTenantIdentity>(mapName));
}
return(shardMap);
});
}
public void LoadTestSplitRangeNoLock()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
RangeShardMap <int> rsm = smm.GetRangeShardMap <int>(ShardMapManagerLoadTests.s_rangeShardMapName);
Assert.IsNotNull(rsm);
RangeMapping <int> r1 = this.GetRandomRangeMapping(rsm, 2);
if (r1 != null)
{
int splitPoint = _r.Next((int)(r1.Range.Low.Value) + 1, (int)(r1.Range.High.Value) - 1);
Debug.WriteLine("Trying to split range mapping for key range ({0} - {1}) at {2}", r1.Range.Low.Value, r1.Range.High.Value, splitPoint);
IReadOnlyList <RangeMapping <int> > rList = rsm.SplitMapping(r1, splitPoint);
Assert.AreEqual(2, rList.Count);
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
private static RangeShardMap <int> GetShardMap() //singleton
{
var shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(ShardMgrConnectionString, ShardMapManagerLoadPolicy.Lazy);
var shardMap = shardMapManager.GetRangeShardMap <int>(ShardMapName);
return(shardMap);
}
public void TestSetSchemaInfoWithSpecialChars()
{
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
SchemaInfoCollection siCollection = shardMapManager.GetSchemaInfoCollection();
SchemaInfo si = new SchemaInfo();
ShardedTableInfo sti = new ShardedTableInfo(NewNameWithSpecialChars(), NewNameWithSpecialChars());
si.Add(sti);
string mdName = String.Format("TestSI_{0}", Guid.NewGuid());
siCollection.Add(mdName, si);
SchemaInfo sdmdRead = siCollection.Get(mdName);
AssertEqual(si, sdmdRead);
}
/// <summary>
/// Tries to get the ShardMapManager that is stored in the specified database.
/// </summary>
public static ShardMapManager TryGetShardMapManager(string shardMapManagerServerName, string shardMapManagerDatabaseName)
{
string shardMapManagerConnectionString =
ShardManagmentConfig.GetConnectionString(
ShardManagmentConfig.ShardMapManagerServerName,
ShardManagmentConfig.ShardMapDatabase);
if (!SqlDatabaseUtils.DatabaseExists(shardMapManagerServerName, shardMapManagerDatabaseName))
{
// Shard Map Manager database has not yet been created
return(null);
}
ShardMapManager shardMapManager;
bool smmExists = ShardMapManagerFactory.TryGetSqlShardMapManager(
shardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy,
out shardMapManager);
if (!smmExists)
{
// Shard Map Manager database exists, but Shard Map Manager has not been created
return(null);
}
return(shardMapManager);
}
public void UpgradeLsm()
{
// Get shard map manager
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// upgrade GSM to latest version.
smm.UpgradeGlobalStore();
VerifyGlobalStore(smm, GlobalConstants.GsmVersionClient);
// deploy LSM initial version.
ShardLocation sl = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, s_shardedDBs[0]);
smm.UpgradeLocalStore(sl, s_initialLsmVersion);
// upgrade to version 1.1
smm.UpgradeLocalStore(sl, new Version(1, 1));
// Library is still at LSM major version 1, so adding shard with LSM 1.0 should succeed.
// Library will see that LSM schema already exists at 'sl' and hence will not deploy LSM again, will just try to add the shard.
// CreateShard will not work with LSM initial version (1.0) as it only has 'StoreVersion' column in ShardMApManagerLocal table, from 1.1 onwards it follows latest schema for version table.
ListShardMap <int> listsm = smm.CreateListShardMap <int>(ShardMapManagerUpgradeTests.s_shardMapNames[0]);
listsm.CreateShard(sl);
// upgrade to version 1.2
smm.UpgradeLocalStore(sl, new Version(1, 2));
// upgrade to latest version (1.2): no-op
smm.UpgradeLocalStore(sl);
}
public void UpgradeGsm()
{
// Get shard map manager
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Sanity check setup: version should be 1.0
VerifyGlobalStore(smm, new Version(1, 0));
// Upgrade to version 1.0: no-op
smm.UpgradeGlobalStore(new Version(1, 0));
VerifyGlobalStore(smm, new Version(1, 0));
// Upgrade to version 1.1
smm.UpgradeGlobalStore(new Version(1, 1));
VerifyGlobalStore(smm, new Version(1, 1));
// Upgrade to version 1.2
smm.UpgradeGlobalStore(new Version(1, 2));
VerifyGlobalStore(smm, new Version(1, 2));
// Upgrade to latest version
smm.UpgradeGlobalStore();
VerifyGlobalStore(smm, GlobalConstants.GsmVersionClient);
}
public void TryGetShardMapManager_Success()
{
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
foreach (ShardMapManagerLoadPolicy loadPolicy in Enum.GetValues(typeof(ShardMapManagerLoadPolicy)))
{
ShardMapManager smm;
bool success;
success = ShardMapManagerFactory.TryGetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
loadPolicy,
out smm);
Assert.IsTrue(success);
Assert.IsNotNull(smm);
success = ShardMapManagerFactory.TryGetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
loadPolicy,
RetryBehavior.DefaultRetryBehavior,
out smm);
Assert.IsTrue(success);
Assert.IsNotNull(smm);
}
}
// Bootstrap Elastic Scale by creating a new shard map manager and a shard map on
// the shard map manager database if necessary.
public ShardingClient(string shardMapManagerServer, string shardMapManagerDb, string shardMapManagerConnString, string shardMapName = "ONETUG_DEMO")
{
// Connection string with administrative credentials for the root database
var connStrBldr = new SqlConnectionStringBuilder(shardMapManagerConnString);
connStrBldr.DataSource = shardMapManagerServer;
connStrBldr.InitialCatalog = shardMapManagerDb;
// Deploy shard map manager.
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(connStrBldr.ConnectionString, ShardMapManagerLoadPolicy.Lazy, out var existingShardMapManager))
{
ShardMapManager = ShardMapManagerFactory.CreateSqlShardMapManager(connStrBldr.ConnectionString);
}
else
{
ShardMapManager = existingShardMapManager;
}
if (!ShardMapManager.TryGetListShardMap <int>(shardMapName, out var existingListShardMap))
{
ShardMap = ShardMapManager.CreateListShardMap <int>(shardMapName);
}
else
{
ShardMap = existingListShardMap;
}
}
public void DeleteShardDuplicate()
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMap sm = smm.GetShardMap(ShardMapTests.s_defaultShardMapName);
Assert.IsNotNull(sm);
ShardLocation sl = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapTests.s_shardedDBs[0]);
Shard sNew = sm.CreateShard(sl);
Assert.IsNotNull(sNew);
sm.DeleteShard(sNew);
Assert.IsNotNull(sNew);
bool removeFailed = false;
try
{
sm.DeleteShard(sNew);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMap, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.ShardDoesNotExist, sme.ErrorCode);
removeFailed = true;
}
Assert.IsTrue(removeFailed);
}
public void LoadTestDeleteRangeMapping()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
RangeShardMap <int> rsm = smm.GetRangeShardMap <int>(ShardMapManagerLoadTests.s_rangeShardMapName);
Assert.IsNotNull(rsm);
RangeMapping <int> r1 = this.GetRandomRangeMapping(rsm);
if (r1 != null)
{
Debug.WriteLine("Trying to delete mapping for range with low value = {0}", r1.Range.Low);
RangeMappingUpdate ru = new RangeMappingUpdate();
ru.Status = MappingStatus.Offline;
RangeMapping <int> mappingToDelete = rsm.UpdateMapping(r1, ru);
rsm.DeleteMapping(mappingToDelete);
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
public void LoadTestMarkAllShardsAsOnlineInListShardMap()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ListShardMap <int> lsm = smm.GetListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName);
Assert.IsNotNull(lsm);
foreach (Shard s in lsm.GetShards())
{
if (s.Status == ShardStatus.Offline)
{
lsm.UpdateShard(s,
new ShardUpdate
{
Status = ShardStatus.Online
});
}
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
public void LoadTestDeletePointMapping()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ListShardMap <int> lsm = smm.GetListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName);
Assert.IsNotNull(lsm);
PointMapping <int> p1 = this.GetRandomPointMapping(lsm);
if (p1 != null)
{
Debug.WriteLine("Trying to delete point mapping for key {0}", p1.Key);
PointMappingUpdate pu = new PointMappingUpdate();
pu.Status = MappingStatus.Offline;
PointMapping <int> mappingToDelete = lsm.UpdateMapping(p1, pu);
lsm.DeleteMapping(mappingToDelete);
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
public void LoadTestPointMappingDDR()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString, ShardMapManagerLoadPolicy.Lazy);
ListShardMap <int> lsm = smm.GetListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName);
Assert.IsNotNull(lsm);
PointMapping <int> p1 = this.GetRandomPointMapping(lsm);
if (p1 != null)
{
Debug.WriteLine("Trying to validate point mapping for key {0}", p1.Key);
// Validate mapping by trying to connect
s_retryPolicy.ExecuteAction(
() => ValidateImpl(
(ShardMap)lsm,
(int)(p1.Key.Value)));
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
// Bootstrap Elastic Scale by creating a new shard map manager and a shard map on
// the shard map manager database if necessary.
public Sharding(string smmserver, string smmdatabase, string smmconnstr)
{
// Connection string with administrative credentials for the root database
SqlConnectionStringBuilder connStrBldr = new SqlConnectionStringBuilder(smmconnstr);
connStrBldr.DataSource = smmserver;
connStrBldr.InitialCatalog = smmdatabase;
// Deploy shard map manager.
ShardMapManager smm;
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(connStrBldr.ConnectionString, ShardMapManagerLoadPolicy.Lazy, out smm))
{
this.ShardMapManager = ShardMapManagerFactory.CreateSqlShardMapManager(connStrBldr.ConnectionString);
}
else
{
this.ShardMapManager = smm;
}
ListShardMap <int> sm;
if (!ShardMapManager.TryGetListShardMap <int>("ElasticScaleWithEF", out sm))
{
this.ShardMap = ShardMapManager.CreateListShardMap <int>("ElasticScaleWithEF");
}
else
{
this.ShardMap = sm;
}
}
public static void ShardMapManagerFactoryTestsInitialize(TestContext testContext)
{
// Clear all connection pools.
SqlConnection.ClearAllPools();
using (SqlConnection conn = new SqlConnection(Globals.ShardMapManagerTestConnectionString))
{
conn.Open();
// Create ShardMapManager database
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.CreateDatabaseQuery, Globals.ShardMapManagerDatabaseName),
conn))
{
cmd.ExecuteNonQuery();
}
// Testing TryGetSqlShardMapManager failure case here instead of in TryGetShardMapManager_Fail()
// There is no method to cleanup GSM objects, so if some other test runs in lab before
// TryGetShardMapManager_Fail, then this call will actually suceed as it will find earlier SMM structures.
// Calling it just after creating database makes sure that GSM does not exist.
// Other options were to recreate SMM database in tests (this will increase test duration) or
// delete storage structures (t-sql delete) in the test which is not very clean solution.
ShardMapManager smm = null;
bool lookupSmm = ShardMapManagerFactory.TryGetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Eager,
RetryBehavior.DefaultRetryBehavior,
out smm);
Assert.IsFalse(lookupSmm);
}
}
public void GetShardMapsDefault()
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMap sm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
IEnumerable <ShardMap> shardmaps = smm.GetShardMaps();
int count = 0;
using (IEnumerator <ShardMap> mEnum = shardmaps.GetEnumerator())
{
while (mEnum.MoveNext())
{
count++;
}
}
Assert.AreEqual(1, count);
}
public void CreateRangeShardMapDuplicate()
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMap sm = smm.CreateRangeShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
bool creationFailed = false;
try
{
RangeShardMap <int> rsm = smm.CreateRangeShardMap <int>(ShardMapManagerTests.s_shardMapName);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMapManager, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.ShardMapAlreadyExists, sme.ErrorCode);
creationFailed = true;
}
Assert.IsTrue(creationFailed);
}
/// <summary>
/// Initializes a new instance of the <see cref="Sharding" /> class.
/// <para>Bootstrap Elastic Scale by creating a new shard map manager and a shard map on the shard map manager database if necessary.</para>
/// </summary>
/// <param name="catalogConfig">The catalog configuration.</param>
/// <param name="databaseConfig">The database configuration.</param>
/// <param name="tenantsRepository">The tenants repository.</param>
/// <param name="helper">The helper.</param>
public Sharding(CatalogConfig catalogConfig, DatabaseConfig databaseConfig, ITenantsRepository tenantsRepository, IHelper helper)
{
try
{
_tenantsRepository = tenantsRepository;
_helper = helper;
var smmconnstr = _helper.GetSqlConnectionString(databaseConfig, catalogConfig);
// Deploy shard map manager
// if shard map manager exists, refresh content, else create it, then add content
ShardMapManager smm;
ShardMapManager =
!ShardMapManagerFactory.TryGetSqlShardMapManager(smmconnstr,
ShardMapManagerLoadPolicy.Lazy, out smm)
? ShardMapManagerFactory.CreateSqlShardMapManager(smmconnstr)
: smm;
// check if shard map exists and if not, create it
ListShardMap <int> sm;
ShardMap = !ShardMapManager.TryGetListShardMap(catalogConfig.CatalogDatabase, out sm)
? ShardMapManager.CreateListShardMap <int>(catalogConfig.CatalogDatabase)
: sm;
}
catch (Exception ex)
{
// _logger.LogError(0, ex, "Error in sharding initialisation.");
throw new ApplicationException("Error in sharding initialisation.");
}
}
public void LoadTestRangeMappingDDR()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
RangeShardMap <int> rsm = smm.GetRangeShardMap <int>(ShardMapManagerLoadTests.s_rangeShardMapName);
Assert.IsNotNull(rsm);
RangeMapping <int> r1 = this.GetRandomRangeMapping(rsm);
if (r1 != null)
{
int keyToValidate = _r.Next((int)(r1.Range.Low.Value), (int)(r1.Range.High.Value));
Debug.WriteLine("Trying to validate mapping for key {0}", keyToValidate);
// Validate mapping by trying to connect
s_retryPolicy.ExecuteAction(
() => ValidateImpl(
(ShardMap)rsm,
keyToValidate));
}
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
public void CreateShardDefault()
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMap sm = smm.GetShardMap(ShardMapTests.s_defaultShardMapName);
Assert.IsNotNull(sm);
ShardLocation sl = new ShardLocation(
Globals.ShardMapManagerTestsDatasourceName,
ShardMapTests.s_shardedDBs[0],
SqlProtocol.Tcp,
1433);
Shard sNew = sm.CreateShard(sl);
Assert.IsNotNull(sNew);
// Validate that the shard location is round-tripped correctly
Assert.AreEqual(sl, sNew.Location);
Assert.AreEqual(sl, sm.GetShard(sl).Location);
// Validate that we can connect to the shard
using (SqlConnection conn = sNew.OpenConnection(
Globals.ShardUserConnectionString,
ConnectionOptions.Validate))
{
}
}
public SqlDataManager(
Logger logger,
GrainStateMap grainStateMap,
string connectionString,
string shardCredentials,
string mapName,
BatchingOptions batchingOptions = null)
{
Logger = logger;
Guard.NotNullOrEmpty(connectionString, "conectionString");
Guard.NotNullOrEmpty(shardCredentials, "shardCredentials");
Guard.NotNullOrEmpty(mapName, "mapName");
// Try to get a reference to the Shard Map Manager via the Shard Map Manager database.
// If it doesn't already exist, then fail
var shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(connectionString, ShardMapManagerLoadPolicy.Lazy);
var shardMap = (RangeShardMap <int>)shardMapManager.GetShardMap(mapName);
var shardBatchers = new ConcurrentDictionary <Range <int>, ShardBatcher>();
foreach (var rangeMapping in shardMap.GetMappings())
{
Range <int> range = rangeMapping.Value;
shardBatchers.TryAdd(range, new ShardBatcher(logger, grainStateMap, rangeMapping.Shard, shardCredentials, batchingOptions));
}
_shardBatchers = shardBatchers;
_shardMap = shardMap;
}
public static void ShardMapperTestsInitialize(TestContext testContext)
{
// Clear all connection pools.
SqlConnection.ClearAllPools();
using (SqlConnection conn = new SqlConnection(Globals.ShardMapManagerTestConnectionString))
{
conn.Open();
// Create ShardMapManager database
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.CreateDatabaseQuery, Globals.ShardMapManagerDatabaseName),
conn))
{
cmd.ExecuteNonQuery();
}
// Create shard databases
for (int i = 0; i < DateTimeShardMapperTests.s_shardedDBs.Length; i++)
{
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.DropDatabaseQuery, DateTimeShardMapperTests.s_shardedDBs[i]),
conn))
{
cmd.ExecuteNonQuery();
}
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.CreateDatabaseQuery, DateTimeShardMapperTests.s_shardedDBs[i]),
conn))
{
cmd.ExecuteNonQuery();
}
}
}
// Create shard map manager.
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
// Create list shard map.
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ListShardMap <DateTime> lsm = smm.CreateListShardMap <DateTime>(DateTimeShardMapperTests.s_listShardMapName);
Assert.IsNotNull(lsm);
Assert.AreEqual(DateTimeShardMapperTests.s_listShardMapName, lsm.Name);
// Create range shard map.
RangeShardMap <DateTime> rsm = smm.CreateRangeShardMap <DateTime>(DateTimeShardMapperTests.s_rangeShardMapName);
Assert.IsNotNull(rsm);
Assert.AreEqual(DateTimeShardMapperTests.s_rangeShardMapName, rsm.Name);
}
public void LoadTestRemoveShardFromListShardMap()
{
try
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ListShardMap <int> lsm = smm.GetListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName);
Assert.IsNotNull(lsm);
List <Shard> existingShards = lsm.GetShards().ToList();
if (existingShards.Count == 0)
{
return;
}
// If there is already a shard marked as offline, chose that one to delete.
// This can happend if earlier remove operation was terminated for some reason - ex. killing connections.
Shard offlineShard = existingShards.Find(e => e.Status == ShardStatus.Offline);
if (offlineShard == null)
{
offlineShard = existingShards[_r.Next(existingShards.Count)];
// First mark shard as offline so that other test threads will not add new mappings to it.
offlineShard = lsm.UpdateShard(offlineShard,
new ShardUpdate
{
Status = ShardStatus.Offline
});
}
Debug.WriteLine("Trying to remove shard at location {0}", offlineShard.Location);
PointMappingUpdate pu = new PointMappingUpdate();
pu.Status = MappingStatus.Offline;
// Remove all mappings from this shard for given shard map.
foreach (PointMapping <int> p in lsm.GetMappings(offlineShard))
{
PointMapping <int> mappingToDelete = lsm.UpdateMapping(p, pu);
lsm.DeleteMapping(mappingToDelete);
}
// Shard object is changed as mappings are removed, get it again.
Shard deleteShard = lsm.GetShard(offlineShard.Location);
// now remove shard.
lsm.DeleteShard(deleteShard);
Debug.WriteLine("Removed shard at location {0} from shard map {1}", deleteShard.Location, lsm);
}
catch (ShardManagementException sme)
{
Debug.WriteLine("Exception caught: {0}", sme.Message);
}
}
private ShardMapManager GetShardMapManager()
{
var catalogDbConnectionString = GetConnectionStingWithCredentials();
return(!ShardMapManagerFactory.TryGetSqlShardMapManager(catalogDbConnectionString, ShardMapManagerLoadPolicy.Lazy, out ShardMapManager shardMapManager)
? ShardMapManagerFactory.CreateSqlShardMapManager(catalogDbConnectionString)
: shardMapManager);
}
public static void CreateRangeShardMap <TKey>(string connectionString, string mapName)
{
var shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
ShardMapManagerLoadPolicy.Lazy);
shardMapManager.CreateRangeShardMap <TKey>(mapName);
}
public void ValidateShard()
{
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMap sm = smm.GetShardMap(ShardMapTests.s_defaultShardMapName);
Assert.IsNotNull(sm);
ShardLocation sl = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapTests.s_shardedDBs[0]);
Shard sNew = sm.CreateShard(new ShardCreationInfo(sl, ShardStatus.Online));
ShardUpdate su = new ShardUpdate();
su.Status = ShardStatus.Offline;
Shard sUpdated = sm.UpdateShard(sNew, su);
Assert.IsNotNull(sUpdated);
bool validationFailed = false;
try
{
using (SqlConnection conn = sNew.OpenConnection(
Globals.ShardUserConnectionString,
ConnectionOptions.Validate))
{
}
}
catch (ShardManagementException sme)
{
validationFailed = true;
Assert.AreEqual(ShardManagementErrorCategory.Validation, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.ShardVersionMismatch, sme.ErrorCode);
}
Assert.IsTrue(validationFailed);
validationFailed = false;
try
{
using (SqlConnection conn = sUpdated.OpenConnection(
Globals.ShardUserConnectionString,
ConnectionOptions.Validate))
{
}
}
catch (ShardManagementException)
{
validationFailed = true;
}
Assert.IsFalse(validationFailed);
}
