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();
}
public void CreateListShardMapDuplicate()
{
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);
bool creationFailed = false;
try
{
ListShardMap <int> lsm = smm.CreateListShardMap <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 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);
}
// 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 CreateListShardMapDefault()
{
CountingCacheStore cacheStore =
new CountingCacheStore(
new CacheStore());
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ListShardMap <int> lsm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(lsm);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, smLookup.Name);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
}
public void CreateListShardMapAbortGSM()
{
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StubStoreOperationFactory()
{
CallBase = true,
CreateAddShardMapGlobalOperationShardMapManagerStringIStoreShardMap =
(_smm, _opname, _ssm) => new NTimeFailingAddShardMapGlobalOperation(10, _smm, _opname, _ssm)
},
new CacheStore(),
ShardMapManagerLoadPolicy.Lazy,
new RetryPolicy(1, TimeSpan.Zero, TimeSpan.Zero, TimeSpan.Zero), RetryBehavior.DefaultRetryBehavior);
bool storeOperationFailed = false;
try
{
ListShardMap <int> lsm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(lsm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, lsm.Name);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMapManager, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.StorageOperationFailure, sme.ErrorCode);
storeOperationFailed = true;
}
Assert.IsTrue(storeOperationFailed);
}
public void AddListShardMapNoCacheUpdate()
{
// Create a cache store that always misses.
CountingCacheStore cacheStore =
new CountingCacheStore(
new StubCacheStore()
{
CallBase = true,
LookupMappingByKeyIStoreShardMapShardKey = (ssm, sk) => null,
LookupShardMapByNameString = (n) => null
});
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
Assert.AreEqual(1, cacheStore.AddShardMapCount);
cacheStore.ResetCounters();
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.AddShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapMissCount);
}
/// <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 RemoveListShardMapNoCacheUpdate()
{
// Counting store that does not perform deletions of shard maps.
CountingCacheStore cacheStore =
new CountingCacheStore(
new StubCacheStore()
{
CallBase = true,
DeleteShardMapIStoreShardMap = (csm) => { }
}
);
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
smm.DeleteShardMap(sm);
Assert.AreEqual(1, cacheStore.DeleteShardMapCount);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
}
// 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 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 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);
}
/// <summary>
/// Creates a new List Shard Map with the specified name, or gets the List Shard Map if it already exists.
/// </summary>
public ListShardMap <T> CreateOrGetListShardMap <T>(ShardMapManager shardMapManager, string shardMapName)
{
ListShardMap <T> shardMap;
var shardMapExists = shardMapManager.TryGetListShardMap(shardMapName, out shardMap);
if (!shardMapExists)
{
shardMap = shardMapManager.CreateListShardMap <T>(shardMapName);
}
return(shardMap);
}
private void VerifyGlobalStore(ShardMapManager smm, Version targetVersion)
{
// Verify upgrade
Assert.AreEqual(
targetVersion,
GetGlobalStoreVersion());
string shardMapName = string.Format("MyShardMap_{0}", Guid.NewGuid());
if (targetVersion != null && targetVersion < new Version(1, 1))
{
ShardManagementException sme = AssertExtensions.AssertThrows <ShardManagementException>(
() => smm.CreateListShardMap <int>(shardMapName));
Assert.AreEqual(ShardManagementErrorCode.GlobalStoreVersionMismatch, sme.ErrorCode);
}
else
{
// Below call should succeed as latest supported major version of library matches major version of deployed store.
ShardMap sm = smm.CreateListShardMap <int>(shardMapName);
Assert.IsNotNull(sm);
}
}
internal static ShardMap CreateAndGetTestShardMap()
{
ShardMap sm;
ShardMapManagerFactory.CreateSqlShardMapManager(MultiShardTestUtils.ShardMapManagerConnectionString, ShardMapManagerCreateMode.ReplaceExisting);
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(MultiShardTestUtils.ShardMapManagerConnectionString, ShardMapManagerLoadPolicy.Lazy);
sm = smm.CreateListShardMap <int>(s_testShardMapName);
for (int i = 0; i < s_testDatabaseNames.Count; i++)
{
sm.CreateShard(GetTestShard(s_testDatabaseNames[i]));
}
return(sm);
}
private static ListShardMap <T> GetOrCreateListShardMap <T>(ShardMapManager shardMapManager, string shardMapName)
{
ListShardMap <T> map;
if (shardMapManager.TryGetListShardMap(shardMapName, out map))
{
// Shard map already exists
Console.WriteLine("Shard map {0} already exists", shardMapName);
return(map);
}
// Initialize shard map
Console.WriteLine("Creating shard map {0}", shardMapName);
return(shardMapManager.CreateListShardMap <T>(shardMapName));
}
public void DeleteShardMapNonExisting()
{
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);
smm.DeleteShardMap(sm);
smm.DeleteShardMap(sm);
}
public void GetDistinctLocations()
{
// Get shard map manager and 2 shard maps.
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Upgrade GSM to latest version
smm.UpgradeGlobalStore();
// create shard maps
foreach (string name in ShardMapManagerUpgradeTests.s_shardMapNames)
{
ShardMap sm = smm.CreateListShardMap <int>(name);
Assert.IsNotNull(sm);
}
ShardMap sm1 = smm.GetShardMap(ShardMapManagerUpgradeTests.s_shardMapNames[0]);
Assert.IsNotNull(sm1);
ShardMap sm2 = smm.GetShardMap(ShardMapManagerUpgradeTests.s_shardMapNames[1]);
Assert.IsNotNull(sm2);
// Add shards to the shard maps.
ShardLocation sl1 = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapManagerUpgradeTests.s_shardedDBs[0]);
ShardLocation sl2 = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapManagerUpgradeTests.s_shardedDBs[1]);
ShardLocation sl3 = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapManagerUpgradeTests.s_shardedDBs[2]);
Shard s1 = sm1.CreateShard(sl1);
Shard s2 = sm1.CreateShard(sl2);
Shard s3 = sm1.CreateShard(sl3);
Shard s4 = sm2.CreateShard(sl2);
Shard s5 = sm2.CreateShard(sl3);
int count = 0;
foreach (ShardLocation sl in smm.GetDistinctShardLocations())
{
count++;
}
Assert.AreEqual(3, count);
}
// 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)
{
string smmserver = Sharding.server;
string smmconnstr = Sharding.connectionString;
string smmdatabase = Sharding.shardmapmgrdb;
// Connection string with administrative credentials for the root database
SqlConnectionStringBuilder connStrBldr = new SqlConnectionStringBuilder(smmconnstr);
connStrBldr.DataSource = smmserver;
connStrBldr.InitialCatalog = smmdatabase;
connstring = smmconnstr;
// 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 <Guid> sm;
if (!ShardMapManager.TryGetListShardMap <Guid>(sharmapName, out sm))
{
this.ShardMap = ShardMapManager.CreateListShardMap <Guid>(sharmapName);
}
else
{
this.ShardMap = sm;
}
initDd("shard0");
initDd("shard1");
//initDd("shard2");
//initDd("shard3");
//initDd("shard4");
}
/// <summary>
/// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
/// </summary>
public static ListShardMap <T> CreateOrGetRangeShardMap <T>(ShardMapManager shardMapManager, string shardMapName)
{
// Try to get a reference to the Shard Map.
//RangeShardMap<T> shardMap;
ListShardMap <T> shardMap;
bool shardMapExists = shardMapManager.TryGetListShardMap(shardMapName, out shardMap);
if (shardMapExists)
{
ConsoleUtils.WriteInfo("Shard Map {0} already exists", shardMap.Name);
}
else
{
shardMap = shardMapManager.CreateListShardMap <T>(shardMapName);
// The Shard Map does not exist, so create it
// shardMap = shardMapManager.CreateRangeShardMap<T>(shardMapName);
ConsoleUtils.WriteInfo("Created Shard Map {0}", shardMap.Name);
}
return(shardMap);
}
public void DeleteListShardMap()
{
CountingCacheStore cacheStore =
new CountingCacheStore(
new CacheStore());
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy,
RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
smm.DeleteShardMap(sm);
Assert.AreEqual(1, cacheStore.DeleteShardMapCount);
cacheStore.ResetCounters();
// Verify that shard map is removed from cache.
ShardMap smLookupFailure = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNull(smLookupFailure);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapMissCount);
}
public Sharding(string shardManagerDatabase, string connectionString)
{
ShardMapManager shardMapManager;
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(connectionString, ShardMapManagerLoadPolicy.Lazy, out shardMapManager))
{
this.ShardMapManager = ShardMapManagerFactory.CreateSqlShardMapManager(connectionString);
}
else
{
this.ShardMapManager = shardMapManager;
}
ListShardMap <byte[]> shardMap;
if (!ShardMapManager.TryGetListShardMap(shardManagerDatabase, out shardMap))
{
this.ShardMap = ShardMapManager.CreateListShardMap <byte[]>(shardManagerDatabase);
}
else
{
this.ShardMap = shardMap;
}
}
public static void ShardMapManagerLoadTestsInitialize(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 < ShardMapManagerLoadTests.s_shardedDBs.Length; i++)
{
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.CreateDatabaseQuery, ShardMapManagerLoadTests.s_shardedDBs[i]),
conn))
{
cmd.ExecuteNonQuery();
}
}
// cleanup for deadlock monitoring
foreach (string q in s_deadlockDetectionCleanupQueries)
{
using (SqlCommand cmd = new SqlCommand(q, conn))
{
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException)
{
}
}
}
// setup for deadlock monitoring
foreach (string q in s_deadlockDetectionSetupQueries)
{
using (SqlCommand cmd = new SqlCommand(q, conn))
{
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException)
{
}
}
}
}
// Create shard map manager.
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
// Create list shard map.
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ListShardMap <int> lsm = smm.CreateListShardMap <int>(ShardMapManagerLoadTests.s_listShardMapName);
Assert.IsNotNull(lsm);
// Create range shard map.
RangeShardMap <int> rsm = smm.CreateRangeShardMap <int>(ShardMapManagerLoadTests.s_rangeShardMapName);
Assert.IsNotNull(rsm);
// Add 'InitialShardCount' shards to list and range shard map.
for (int i = 0; i < ShardMapManagerLoadTests.InitialShardCount; i++)
{
ShardCreationInfo si = new ShardCreationInfo(
new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, ShardMapManagerLoadTests.s_shardedDBs[i]),
ShardStatus.Online);
Shard sList = lsm.CreateShard(si);
Assert.IsNotNull(sList);
Shard sRange = rsm.CreateShard(si);
Assert.IsNotNull(sRange);
}
// Initialize retry policy
s_retryPolicy = new RetryPolicy <SqlAzureTransientErrorDetectionStrategy>(
new ExponentialBackoff(5, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(100)));
}
private bool RefreshShardListMap(List <Tuple <long, string> > ListMappings = null)
{
try
{
string shardServer1 = WingtipTicketApp.Config.PrimaryDatabaseServer;
string shardServer2 = WingtipTicketApp.Config.ShardDatabaseServer;
string ticketsDbName = WingtipTicketApp.Config.TicketsDbName;
Shard shard1 = null, shard2 = null;
PointMapping <long> lmpg;
// check if shard map manager exists and if not, create it (Idempotent / tolerant of re-execute)
if (!ShardMapManager.TryGetListShardMap(mapManagerName, out lsm))
{
lsm = ShardMapManager.CreateListShardMap <long>(mapManagerName);
}
try
{
// check if shard exists and if not, create it (Idempotent / tolerant of re-execute)
if (!lsm.TryGetShard(new ShardLocation(shardServer1, ticketsDbName), out shard1))
{
shard1 = lsm.CreateShard(new ShardLocation(shardServer1, ticketsDbName));
}
}
catch // sometimes, it may throw an error stating that a concurrent user recently changed some settings.
//This is a retry logic to cover this scenario.
{
Thread.Sleep(500);
// check if shard map manager exists and if not, create it (Idempotent / tolerant of re-execute)
if (!ShardMapManager.TryGetListShardMap(mapManagerName, out lsm))
{
lsm = ShardMapManager.CreateListShardMap <long>(mapManagerName);
}
// check if shard exists and if not, create it (Idempotent / tolerant of re-execute)
if (!lsm.TryGetShard(new ShardLocation(shardServer1, ticketsDbName), out shard1))
{
shard1 = lsm.CreateShard(new ShardLocation(shardServer1, ticketsDbName));
}
}
if (!lsm.TryGetShard(new ShardLocation(shardServer2, ticketsDbName), out shard2))
{
shard2 = lsm.CreateShard(new ShardLocation(shardServer2, ticketsDbName));
}
// Check if mapping exists and if not, create it (Idempotent / tolerant of re-execute)
if (ListMappings != null)
{
foreach (Tuple <long, string> mapping in ListMappings)
{
if (!lsm.TryGetMappingForKey(mapping.Item1, out lmpg))
{
if (mapping.Item2 == shardServer1)
{
lsm.CreatePointMapping(new PointMappingCreationInfo <long>(mapping.Item1, shard1, MappingStatus.Online));
}
else if (mapping.Item2 == shardServer2)
{
lsm.CreatePointMapping(new PointMappingCreationInfo <long>(mapping.Item1, shard2, MappingStatus.Online));
}
}
}
}
return(true);
}
catch { return(false); }
}
public void ConcurrencyScenarioListShardMap()
{
bool operationFailed; // variable to track status of negative test scenarios
// Create 2 SMM objects representing management and client
ShardMapManager smmMgmt = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
ShardMapManager smmClient = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
#region CreateShardMap
// Add a shard map from management SMM.
ShardMap smMgmt = smmMgmt.CreateListShardMap <int>(ShardMapManagerConcurrencyTests.s_shardMapName);
Assert.AreEqual(ShardMapManagerConcurrencyTests.s_shardMapName, smMgmt.Name);
// Lookup shard map from client SMM.
ShardMap smClient = smmClient.GetShardMap(ShardMapManagerConcurrencyTests.s_shardMapName);
Assert.IsNotNull(smClient);
#endregion CreateShardMap
#region ConvertToListShardMap
ListShardMap <int> lsmMgmt = smmMgmt.GetListShardMap <int>(ShardMapManagerConcurrencyTests.s_shardMapName);
Assert.IsNotNull(lsmMgmt);
// look up shard map again, it will
ListShardMap <int> lsmClient = smmClient.GetListShardMap <int>(ShardMapManagerConcurrencyTests.s_shardMapName);
Assert.IsNotNull(lsmClient);
#endregion ConvertToListShardMap
#region DeleteShardMap
// verify that smClient is accessible
IEnumerable <Shard> shardClient = lsmClient.GetShards();
smmMgmt.DeleteShardMap(lsmMgmt);
operationFailed = false;
try
{
// smClient does not exist, below call will fail.
IEnumerable <Shard> sCNew = lsmClient.GetShards();
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMap, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.ShardMapDoesNotExist, sme.ErrorCode);
operationFailed = true;
}
Assert.IsTrue(operationFailed);
#endregion DeleteShardMap
}
public void CreateListShardMapDefault()
{
CountingCacheStore cacheStore =
new CountingCacheStore(
new CacheStore());
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ListShardMap<int> lsm = smm.CreateListShardMap<int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(lsm);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, smLookup.Name);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
}
public void DeleteListShardMap()
{
CountingCacheStore cacheStore =
new CountingCacheStore(
new CacheStore());
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy,
RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap<int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
smm.DeleteShardMap(sm);
Assert.AreEqual(1, cacheStore.DeleteShardMapCount);
cacheStore.ResetCounters();
// Verify that shard map is removed from cache.
ShardMap smLookupFailure = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNull(smLookupFailure);
Assert.AreEqual(1, cacheStore.LookupShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapMissCount);
}
public void RemoveListShardMapAbortGSM()
{
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StubStoreOperationFactory()
{
CallBase = true,
CreateRemoveShardMapGlobalOperationShardMapManagerStringIStoreShardMap =
(_smm, _opname, _ssm) => new NTimeFailingRemoveShardMapGlobalOperation(10, _smm, _opname, _ssm)
},
new CacheStore(),
ShardMapManagerLoadPolicy.Lazy,
new RetryPolicy(1, TimeSpan.Zero, TimeSpan.Zero, TimeSpan.Zero), RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap<int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
bool storeOperationFailed = false;
try
{
smm.DeleteShardMap(sm);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMapManager, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.StorageOperationFailure, sme.ErrorCode);
storeOperationFailed = true;
}
Assert.IsTrue(storeOperationFailed);
// Verify that shard map still exist in store.
ShardMap smNew = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, false);
Assert.IsNotNull(smNew);
}
public void RemoveListShardMapNoCacheUpdate()
{
// Counting store that does not perform deletions of shard maps.
CountingCacheStore cacheStore =
new CountingCacheStore(
new StubCacheStore()
{
CallBase = true,
DeleteShardMapIStoreShardMap = (csm) => { }
}
);
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap<int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
smm.DeleteShardMap(sm);
Assert.AreEqual(1, cacheStore.DeleteShardMapCount);
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.LookupShardMapHitCount);
}
public void AddListShardMapNoCacheUpdate()
{
// Create a cache store that always misses.
CountingCacheStore cacheStore =
new CountingCacheStore(
new StubCacheStore()
{
CallBase = true,
LookupMappingByKeyIStoreShardMapShardKey = (ssm, sk) => null,
LookupShardMapByNameString = (n) => null
});
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
cacheStore,
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy, RetryBehavior.DefaultRetryBehavior);
ShardMap sm = smm.CreateListShardMap<int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(sm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, sm.Name);
Assert.AreEqual(1, cacheStore.AddShardMapCount);
cacheStore.ResetCounters();
ShardMap smLookup = smm.LookupShardMapByName("LookupShardMapByName", ShardMapManagerTests.s_shardMapName, true);
Assert.IsNotNull(smLookup);
Assert.AreEqual(1, cacheStore.AddShardMapCount);
Assert.AreEqual(1, cacheStore.LookupShardMapMissCount);
}
private void VerifyGlobalStore(ShardMapManager smm, Version targetVersion)
{
// Verify upgrade
Assert.AreEqual(
targetVersion,
GetGlobalStoreVersion());
string shardMapName = string.Format("MyShardMap_{0}", Guid.NewGuid());
if (targetVersion != null && targetVersion < new Version(1, 1))
{
ShardManagementException sme = AssertExtensions.AssertThrows<ShardManagementException>(
() => smm.CreateListShardMap<int>(shardMapName));
Assert.AreEqual(ShardManagementErrorCode.GlobalStoreVersionMismatch, sme.ErrorCode);
}
else
{
// Below call should succeed as latest supported major version of library matches major version of deployed store.
ShardMap sm = smm.CreateListShardMap<int>(shardMapName);
Assert.IsNotNull(sm);
}
}
private ListShardMap <int> GetShardMap()
{
return(!ShardMapManager.TryGetListShardMap(CatalogConfig.CatalogDatabase, out ListShardMap <int> shardMap)
? ShardMapManager.CreateListShardMap <int>(CatalogConfig.CatalogDatabase)
: shardMap);
}
public void BasicScenarioDefaultShardMaps()
{
bool success = true;
try
{
#region DeployShardMapManager
// Deploy shard map manager.
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
#endregion DeployShardMapManager
#region GetShardMapManager
// Obtain shard map manager.
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
#endregion GetShardMapManager
#region CreateDefaultShardMap
// Create a single user per-tenant shard map.
ShardMap defaultShardMap = shardMapManager.CreateListShardMap <int>("DefaultShardMap");
#endregion CreateDefaultShardMap
#region CreateShard
for (int i = 0; i < ScenarioTests.s_perTenantDBs.Length; i++)
{
// Create the shard.
defaultShardMap.CreateShard(
new ShardLocation(
Globals.ShardMapManagerTestsDatasourceName,
ScenarioTests.s_perTenantDBs[i]));
}
#endregion CreateShard
#region UpdateShard
// Find the shard by location.
Shard shardToUpdate = defaultShardMap.GetShard(new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, "PerTenantDB1"));
// Perform the actual update. Mark offline.
Shard updatedShard = defaultShardMap.UpdateShard(
shardToUpdate,
new ShardUpdate
{
Status = ShardStatus.Offline
});
// Verify that update succeeded.
Assert.AreEqual(ShardStatus.Offline, updatedShard.Status);
#endregion UpdateShard
#region DeleteShard
// Find the shard by location.
Shard shardToDelete = defaultShardMap.GetShard(new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, "PerTenantDB4"));
defaultShardMap.DeleteShard(shardToDelete);
// Verify that delete succeeded.
Shard deletedShard;
defaultShardMap.TryGetShard(shardToDelete.Location, out deletedShard);
Assert.IsNull(deletedShard);
// Now add the shard back for further tests.
// Create the shard.
defaultShardMap.CreateShard(shardToDelete.Location);
#endregion DeleteShard
#region OpenConnection without Validation
// Find the shard by location.
Shard shardForConnection = defaultShardMap.GetShard(new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, "PerTenantDB1"));
using (SqlConnection conn = shardForConnection.OpenConnection(
Globals.ShardUserConnectionString,
ConnectionOptions.None)) // validate = false
{
}
#endregion OpenConnection without Validation
#region OpenConnection with Validation
// Use the stale state of "shardToUpdate" shard & see if validation works.
bool validationFailed = false;
try
{
using (SqlConnection conn = shardToDelete.OpenConnection(
Globals.ShardUserConnectionString,
ConnectionOptions.Validate)) // validate = true
{
}
}
catch (ShardManagementException smme)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.ShardDoesNotExist);
}
Assert.AreEqual(validationFailed, true);
#endregion OpenConnection with Validation
#region OpenConnectionAsync without Validation
// Find the shard by location.
shardForConnection = defaultShardMap.GetShard(new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, "PerTenantDB1"));
using (SqlConnection conn = shardForConnection.OpenConnectionAsync(
Globals.ShardUserConnectionString,
ConnectionOptions.None).Result) // validate = false
{
}
#endregion OpenConnectionAsync without Validation
#region OpenConnectionAsync with Validation
// Use the stale state of "shardToUpdate" shard & see if validation works.
validationFailed = false;
try
{
using (SqlConnection conn = shardToDelete.OpenConnectionAsync(
Globals.ShardUserConnectionString,
ConnectionOptions.Validate).Result) // validate = true
{
}
}
catch (AggregateException ex)
{
ShardManagementException smme = ex.InnerException as ShardManagementException;
if (smme != null)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.ShardDoesNotExist);
}
}
Assert.AreEqual(validationFailed, true);
#endregion OpenConnectionAsync with Validation
#if FUTUREWORK
#region GetAllOnlineShards
// Get all online shards.
foreach (Shard s in defaultShardMap.GetShards(Int32.MaxValue, 1))
{
Trace.WriteLine(s.Location);
}
#endregion GetAllOnlineShards
#endif
}
catch (ShardManagementException smme)
{
success = false;
Trace.WriteLine(String.Format("Error Category: {0}", smme.ErrorCategory));
Trace.WriteLine(String.Format("Error Code : {0}", smme.ErrorCode));
Trace.WriteLine(String.Format("Error Message : {0}", smme.Message));
if (smme.InnerException != null)
{
Trace.WriteLine(String.Format("Storage Error Message : {0}", smme.InnerException.Message));
if (smme.InnerException.InnerException != null)
{
Trace.WriteLine(String.Format("SqlClient Error Message : {0}", smme.InnerException.InnerException.Message));
}
}
}
Assert.IsTrue(success);
}
public void BasicScenarioListShardMaps()
{
bool success = true;
string shardMapName = "PerTenantShardMap";
try
{
#region DeployShardMapManager
// Deploy shard map manager.
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
#endregion DeployShardMapManager
#region GetShardMapManager
// Obtain shard map manager.
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
#endregion GetShardMapManager
#region CreateListShardMap
// Create a single user per-tenant shard map.
ListShardMap <int> perTenantShardMap = shardMapManager.CreateListShardMap <int>(shardMapName);
#endregion CreateListShardMap
#region CreateShardAndPointMapping
for (int i = 0; i < ScenarioTests.s_perTenantDBs.Length; i++)
{
// Create the shard.
Shard s = perTenantShardMap.CreateShard(
new ShardLocation(
Globals.ShardMapManagerTestsDatasourceName,
ScenarioTests.s_perTenantDBs[i]));
// Create the mapping.
PointMapping <int> p = perTenantShardMap.CreatePointMapping(
i + 1,
s);
}
#endregion CreateShardAndPointMapping
#region UpdatePointMapping
// Let's add another point 5 and map it to same shard as 1.
PointMapping <int> mappingForOne = perTenantShardMap.GetMappingForKey(1);
PointMapping <int> mappingForFive = perTenantShardMap.CreatePointMapping(5, mappingForOne.Shard);
Assert.IsTrue(mappingForOne.Shard.Location.Equals(mappingForFive.Shard.Location));
// Move 3 from PerTenantDB3 to PerTenantDB for 5.
PointMapping <int> mappingToUpdate = perTenantShardMap.GetMappingForKey(3);
bool updateFailed = false;
// Try updating that shard in the mapping without taking it offline first.
try
{
perTenantShardMap.UpdateMapping(
mappingToUpdate,
new PointMappingUpdate
{
Shard = mappingForFive.Shard
});
}
catch (ShardManagementException smme)
{
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingIsNotOffline);
updateFailed = true;
}
Assert.IsTrue(updateFailed);
// Perform the actual update.
PointMapping <int> newMappingFor3 = MarkMappingOfflineAndUpdateShard <int>(
perTenantShardMap, mappingToUpdate, mappingForFive.Shard);
// Verify that update succeeded.
Assert.IsTrue(newMappingFor3.Shard.Location.Equals(mappingForFive.Shard.Location));
Assert.IsTrue(newMappingFor3.Status == MappingStatus.Offline);
// Update custom field for the updated mapping.
//PointMapping<int> veryNewMappingFor3 = perTenantShardMap.UpdatePointMapping(
// newMappingFor3,
// new PointMappingUpdate
// {
// Custom = new byte[] { 0x12, 0x34 }
// });
#endregion UpdatePointMapping
#region DeleteMapping
// Find the shard by location.
PointMapping <int> mappingToDelete = perTenantShardMap.GetMappingForKey(5);
bool operationFailed = false;
// Try to delete mapping while it is online, the delete should fail.
try
{
perTenantShardMap.DeleteMapping(mappingToDelete);
}
catch (ShardManagementException smme)
{
operationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingIsNotOffline);
}
Trace.Assert(operationFailed);
// The mapping must be taken offline first before it can be deleted.
mappingToDelete = perTenantShardMap.UpdateMapping(
mappingToDelete,
new PointMappingUpdate
{
Status = MappingStatus.Offline,
});
perTenantShardMap.DeleteMapping(mappingToDelete);
// Verify that delete succeeded.
try
{
PointMapping <int> deletedMapping = perTenantShardMap.GetMappingForKey(5);
}
catch (ShardManagementException smme)
{
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingNotFoundForKey);
}
#endregion DeleteMapping
#region OpenConnection without Validation
using (SqlConnection conn = perTenantShardMap.OpenConnectionForKey(
2,
Globals.ShardUserConnectionString,
ConnectionOptions.None))
{
}
#endregion OpenConnection without Validation
#region OpenConnection with Validation
// Use the stale state of "shardToUpdate" shard & see if validation works.
bool validationFailed = false;
try
{
using (SqlConnection conn = perTenantShardMap.OpenConnection(
mappingToDelete,
Globals.ShardUserConnectionString,
ConnectionOptions.Validate))
{
}
}
catch (ShardManagementException smme)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingDoesNotExist);
}
Assert.AreEqual(validationFailed, true);
#endregion OpenConnection with Validation
#region OpenConnection without Validation and Empty Cache
// Obtain a new ShardMapManager instance
ShardMapManager newShardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Get the ShardMap
ListShardMap <int> newPerTenantShardMap = newShardMapManager.GetListShardMap <int>(shardMapName);
using (SqlConnection conn = newPerTenantShardMap.OpenConnectionForKey(
2,
Globals.ShardUserConnectionString,
ConnectionOptions.None))
{
}
#endregion
#region OpenConnection with Validation and Empty Cache
// Use the stale state of "shardToUpdate" shard & see if validation works.
validationFailed = false;
// Obtain a new ShardMapManager instance
newShardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Get the ShardMap
newPerTenantShardMap = newShardMapManager.GetListShardMap <int>(shardMapName);
// Create a new mapping
PointMapping <int> newMappingToDelete = newPerTenantShardMap.CreatePointMapping(6,
newPerTenantShardMap.GetMappingForKey(1).Shard);
// Delete the mapping
newMappingToDelete = newPerTenantShardMap.UpdateMapping(
newMappingToDelete,
new PointMappingUpdate
{
Status = MappingStatus.Offline,
});
newPerTenantShardMap.DeleteMapping(newMappingToDelete);
try
{
using (SqlConnection conn = newPerTenantShardMap.OpenConnection(
newMappingToDelete,
Globals.ShardUserConnectionString,
ConnectionOptions.Validate))
{
}
}
catch (ShardManagementException smme)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingDoesNotExist);
}
Assert.AreEqual(validationFailed, true);
#endregion
#region OpenConnectionAsync without Validation
using (SqlConnection conn = perTenantShardMap.OpenConnectionForKeyAsync(
2,
Globals.ShardUserConnectionString,
ConnectionOptions.None).Result)
{
}
#endregion
#region OpenConnectionAsync with Validation
// Use the stale state of "shardToUpdate" shard & see if validation works.
validationFailed = false;
try
{
using (SqlConnection conn = perTenantShardMap.OpenConnectionAsync(
mappingToDelete,
Globals.ShardUserConnectionString,
ConnectionOptions.Validate).Result)
{
}
}
catch (AggregateException ex)
{
ShardManagementException smme = ex.InnerException as ShardManagementException;
if (smme != null)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingDoesNotExist);
}
}
Assert.AreEqual(validationFailed, true);
#endregion
#region OpenConnectionAsync without Validation and Empty Cache
// Obtain a new ShardMapManager instance
newShardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Get the ShardMap
newPerTenantShardMap = newShardMapManager.GetListShardMap <int>(shardMapName);
using (SqlConnection conn = newPerTenantShardMap.OpenConnectionForKeyAsync(
2,
Globals.ShardUserConnectionString,
ConnectionOptions.None).Result)
{
}
#endregion
#region OpenConnectionAsync with Validation and Empty Cache
// Use the stale state of "shardToUpdate" shard & see if validation works.
validationFailed = false;
// Obtain a new ShardMapManager instance
newShardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
// Get the ShardMap
newPerTenantShardMap = newShardMapManager.GetListShardMap <int>(shardMapName);
// Create a new mapping
newMappingToDelete = newPerTenantShardMap.CreatePointMapping(6,
newPerTenantShardMap.GetMappingForKey(1).Shard);
// Delete the mapping
newMappingToDelete = newPerTenantShardMap.UpdateMapping(
newMappingToDelete,
new PointMappingUpdate
{
Status = MappingStatus.Offline,
});
newPerTenantShardMap.DeleteMapping(newMappingToDelete);
try
{
using (SqlConnection conn = newPerTenantShardMap.OpenConnectionAsync(
newMappingToDelete,
Globals.ShardUserConnectionString,
ConnectionOptions.Validate).Result)
{
}
}
catch (AggregateException ex)
{
ShardManagementException smme = ex.InnerException as ShardManagementException;
if (smme != null)
{
validationFailed = true;
Assert.AreEqual(smme.ErrorCode, ShardManagementErrorCode.MappingDoesNotExist);
}
}
Assert.AreEqual(validationFailed, true);
#endregion
#region LookupPointMapping
// Perform tenant lookup. This will populate the cache.
for (int i = 0; i < ScenarioTests.s_perTenantDBs.Length; i++)
{
PointMapping <int> result = shardMapManager
.GetListShardMap <int>("PerTenantShardMap")
.GetMappingForKey(i + 1);
Trace.WriteLine(result.Shard.Location);
// Since we moved 3 to database 1 earlier.
Assert.IsTrue(result.Shard.Location.Database == ScenarioTests.s_perTenantDBs[i != 2 ? i : 0]);
}
// Perform tenant lookup. This will read from the cache.
for (int i = 0; i < ScenarioTests.s_perTenantDBs.Length; i++)
{
PointMapping <int> result = shardMapManager
.GetListShardMap <int>("PerTenantShardMap")
.GetMappingForKey(i + 1);
Trace.WriteLine(result.Shard.Location);
// Since we moved 3 to database 1 earlier.
Assert.IsTrue(result.Shard.Location.Database == ScenarioTests.s_perTenantDBs[i != 2 ? i : 0]);
}
#endregion LookupPointMapping
}
catch (ShardManagementException smme)
{
success = false;
Trace.WriteLine(String.Format("Error Category: {0}", smme.ErrorCategory));
Trace.WriteLine(String.Format("Error Code : {0}", smme.ErrorCode));
Trace.WriteLine(String.Format("Error Message : {0}", smme.Message));
if (smme.InnerException != null)
{
Trace.WriteLine(String.Format("Storage Error Message : {0}", smme.InnerException.Message));
if (smme.InnerException.InnerException != null)
{
Trace.WriteLine(String.Format("SqlClient Error Message : {0}", smme.InnerException.InnerException.Message));
}
}
}
Assert.IsTrue(success);
}
