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 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 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);
}
}
/// <summary>
/// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
/// </summary>
private static RangeShardMap <int> CreateOrGetRangeShardMap(ShardMapManager shardMapManager, string shardMapName)
{
// Try to get a reference to the Shard Map.
RangeShardMap <int> shardMap;
bool shardMapExists = shardMapManager.TryGetRangeShardMap(shardMapName, out shardMap);
if (!shardMapExists)
{
shardMap = shardMapManager.CreateRangeShardMap <int>(shardMapName);
SchemaInfo schemaInfo = new SchemaInfo();
schemaInfo.Add(new ShardedTableInfo("Votes", "Captain"));
shardMapManager.GetSchemaInfoCollection().Add(shardMapName, schemaInfo);
for (int i = 0; i < 4; i++)
{
int low = i * 25;
int high = low + 24;
CreateShard(shardMap, new Range <int>(low, high));
}
}
return(shardMap);
}
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 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);
}
/// <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 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 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);
}
}
/// <summary>
/// Constructs request for obtaining all the shard maps and shards from an LSM.
/// </summary>
/// <param name="operationName">Operation name.</param>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="location">Location of the LSM.</param>
internal CheckShardLocalOperation(
string operationName,
ShardMapManager shardMapManager,
ShardLocation location) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, location, operationName)
{
}
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 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);
}
}
/// <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 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);
}
}
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 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 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>
/// Converts IStoreShardMap to ShardMap.
/// </summary>
/// <param name="manager">Reference to shard map manager.</param>
/// <param name="ssm">Storage representation for ShardMap.</param>
/// <returns>ShardMap object corresponding to storange representation.</returns>
internal static ShardMap CreateShardMapFromStoreShardMap(
ShardMapManager manager,
IStoreShardMap ssm)
{
switch (ssm.MapType)
{
case ShardMapType.List:
// Create ListShardMap<TKey>
return (ShardMap)Activator.CreateInstance(
typeof(ListShardMap<>).MakeGenericType(
ShardKey.TypeFromShardKeyType(ssm.KeyType)),
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new object[] { manager, ssm },
CultureInfo.InvariantCulture);
default:
Debug.Assert(ssm.MapType == ShardMapType.Range);
// Create RangeShardMap<TKey>
return (ShardMap)Activator.CreateInstance(
typeof(RangeShardMap<>).MakeGenericType(
ShardKey.TypeFromShardKeyType(ssm.KeyType)),
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new object[] { manager, ssm },
CultureInfo.InvariantCulture);
}
}
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);
}
public void CreateRangeShardMapDefault()
{
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);
RangeShardMap <int> rsm = smm.CreateRangeShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(rsm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, rsm.Name);
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 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);
}
public void CreateRangeShardMapAbortGSM()
{
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
{
RangeShardMap <int> rsm = smm.CreateRangeShardMap <int>(ShardMapManagerTests.s_shardMapName);
Assert.IsNotNull(rsm);
Assert.AreEqual(ShardMapManagerTests.s_shardMapName, rsm.Name);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ShardMapManager, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.StorageOperationFailure, sme.ErrorCode);
storeOperationFailed = true;
}
Assert.IsTrue(storeOperationFailed);
}
// 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;
}
}
/// <summary>
/// Constructs request to get shard with specific location for given shard map from GSM.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationName">Operation name, useful for diagnostics.</param>
/// <param name="shardMap">Shard map for which shard is being requested.</param>
/// <param name="location">Location of shard being searched.</param>
internal FindShardByLocationGlobalOperation(ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap, ShardLocation location) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_shardMapManager = shardMapManager;
_shardMap = shardMap;
_location = location;
}
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);
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="shardMap">Shard map for which to add shard.</param>
/// <param name="shard">Shard to add.</param>
protected internal AddShardOperation(
ShardMapManager shardMapManager,
IStoreShardMap shardMap,
IStoreShard shard) :
this(shardMapManager, Guid.NewGuid(), StoreOperationState.UndoBegin, shardMap, shard)
{
}
// 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 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);
}
}
/// <summary>
/// Constructs request for obtaining mapping from GSM based on given key.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="operationName">Operation being executed.</param>
/// <param name="shardMap">Local shard map.</param>
/// <param name="mapping">Mapping whose Id will be used.</param>
/// <param name="errorCategory">Error category.</param>
internal FindMappingByIdGlobalOperation(ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap, IStoreMapping mapping, ShardManagementErrorCategory errorCategory) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_manager = shardMapManager;
_shardMap = shardMap;
_mapping = mapping;
_errorCategory = errorCategory;
}
/// <summary>
/// Constructs an instance of the recovery manager for given shard map manager.
/// </summary>
/// <param name="shardMapManager">Shard map manager being recovered.</param>
internal RecoveryManager(ShardMapManager shardMapManager)
{
Debug.Assert(shardMapManager != null);
this.Manager = shardMapManager;
this.Inconsistencies = new Dictionary <RecoveryToken, IDictionary <ShardRange, MappingDifference> >();
this.StoreShardMaps = new Dictionary <RecoveryToken, Tuple <IStoreShardMap, IStoreShard> >();
this.Locations = new Dictionary <RecoveryToken, ShardLocation>();
}
/// <summary>
/// Constructs request for replacing the GSM mappings for given shard map with the input mappings.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="operationName">Operation name.</param>
/// <param name="shardMap">GSM Shard map.</param>
/// <param name="shard">GSM Shard.</param>
/// <param name="mappingsToRemove">Optional list of mappings to remove.</param>
/// <param name="mappingsToAdd">List of mappings to add.</param>
internal ReplaceMappingsGlobalOperation(ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap, IStoreShard shard, IEnumerable<IStoreMapping> mappingsToRemove, IEnumerable<IStoreMapping> mappingsToAdd) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_shardMap = shardMap;
_shard = shard;
_mappingsToRemove = mappingsToRemove;
_mappingsToAdd = mappingsToAdd;
}
/// <summary>
/// Constructs an instance of the recovery manager for given shard map manager.
/// </summary>
/// <param name="shardMapManager">Shard map manager being recovered.</param>
internal RecoveryManager(ShardMapManager shardMapManager)
{
Debug.Assert(shardMapManager != null);
this.Manager = shardMapManager;
this.Inconsistencies = new Dictionary<RecoveryToken, IDictionary<ShardRange, MappingDifference>>();
this.StoreShardMaps = new Dictionary<RecoveryToken, Tuple<IStoreShardMap, IStoreShard>>();
this.Locations = new Dictionary<RecoveryToken, ShardLocation>();
}
/// <summary>
/// Constructs request to upgrade store hosting GSM.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationName">Operation name, useful for diagnostics.</param>
/// <param name="targetVersion">Target version to upgrade.</param>
internal UpgradeStoreGlobalOperation(
ShardMapManager shardMapManager,
string operationName,
Version targetVersion) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_targetVersion = targetVersion;
}
internal NTimeFailingRemoveShardMapGlobalOperation(
int failureCountMax,
ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap) :
base(shardMapManager, operationName, shardMap)
{
_failureCountMax = failureCountMax;
_currentFailureCount = 0;
}
public void DateDeletePointMappingDefault()
{
CountingCacheStore countingCache = new CountingCacheStore(new CacheStore());
ShardMapManager smm = new ShardMapManager(
new SqlShardMapManagerCredentials(Globals.ShardMapManagerConnectionString),
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
countingCache,
ShardMapManagerLoadPolicy.Lazy,
new RetryPolicy(1, TimeSpan.Zero, TimeSpan.Zero, TimeSpan.Zero),
RetryBehavior.DefaultRetryBehavior);
ListShardMap <DateTime> lsm = smm.GetListShardMap <DateTime>(DateTimeShardMapperTests.s_listShardMapName);
Assert.IsNotNull(lsm);
ShardLocation sl = new ShardLocation(Globals.ShardMapManagerTestsDatasourceName, DateTimeShardMapperTests.s_shardedDBs[0]);
Shard s = lsm.CreateShard(sl);
Assert.IsNotNull(s);
DateTime val = DateTime.Now;
PointMapping <DateTime> p1 = lsm.CreatePointMapping(val, s);
PointMapping <DateTime> p2 = lsm.GetMappingForKey(val);
Assert.IsNotNull(p2);
Assert.AreEqual(0, countingCache.LookupMappingHitCount);
// The mapping must be made offline first before it can be deleted.
PointMappingUpdate ru = new PointMappingUpdate();
ru.Status = MappingStatus.Offline;
PointMapping <DateTime> mappingToDelete = lsm.UpdateMapping(p1, ru);
lsm.DeleteMapping(mappingToDelete);
// Try to get from store. Because the mapping is missing from the store, we will try to
// invalidate the cache, but since it is also missing from cache there will be an cache miss.
bool lookupFailed = false;
try
{
PointMapping <DateTime> pLookup = lsm.GetMappingForKey(val);
}
catch (ShardManagementException sme)
{
Assert.AreEqual(ShardManagementErrorCategory.ListShardMap, sme.ErrorCategory);
Assert.AreEqual(ShardManagementErrorCode.MappingNotFoundForKey, sme.ErrorCode);
lookupFailed = true;
}
Assert.IsTrue(lookupFailed);
Assert.AreEqual(1, countingCache.LookupMappingMissCount);
}
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);
}
/// <summary>
/// Constructs request to get all shards for given shard map from GSM.
/// </summary>
/// <param name="operationName">Operation name, useful for diagnostics.</param>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="shardMap">Shard map for which shards are being requested.</param>
internal GetShardsGlobalOperation(
string operationName,
ShardMapManager shardMapManager,
IStoreShardMap shardMap) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_shardMapManager = shardMapManager;
_shardMap = shardMap;
}
private bool CreateShardMapManager()
{
try
{
ShardMapManager = ShardMapManagerFactory.CreateSqlShardMapManager(connectionString);
return true;
}
catch { ShardMapManager = null; return false; }
}
public HorizontalShard(string _mapManagerServer, string _userID, string _password, string _mapManagerName, string _secondaryDR)
{
connectionString = string.Format("Data Source={0};Initial Catalog={3};Integrated Security=False;User ID={1};Password={2};Encrypt=True",
_mapManagerServer, _userID, _password, _mapManagerName);
shardConnectionString = string.Format("Integrated Security=False;User ID={0};Password={1};Encrypt=True", _userID, _password);
mapManagerName = _mapManagerName;
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(connectionString, ShardMapManagerLoadPolicy.Lazy, out ShardMapManager))
ShardMapManager = null;
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationId">Operation id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="shardMap">Shard map for which to add shard.</param>
/// <param name="shard">Shard to add.</param>
internal AddShardOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
IStoreShardMap shardMap,
IStoreShard shard) :
base(shardMapManager, operationId, undoStartState, StoreOperationCode.AddShard, default(Guid), default(Guid))
{
_shardMap = shardMap;
_shard = shard;
}
/// <summary>
/// Constructs request for obtaining all the mappings from GSM based on given shard and mappings.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="operationName">Operation being executed.</param>
/// <param name="shardMap">Local shard map.</param>
/// <param name="shard">Local shard.</param>
/// <param name="range">Optional range to get mappings from.</param>
/// <param name="errorCategory">Error category.</param>
/// <param name="cacheResults">Whether to cache the results of the operation.</param>
/// <param name="ignoreFailure">Ignore shard map not found error.</param>
internal GetMappingsByRangeGlobalOperation(ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap, IStoreShard shard, ShardRange range, ShardManagementErrorCategory errorCategory, bool cacheResults, bool ignoreFailure) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_manager = shardMapManager;
_shardMap = shardMap;
_shard = shard;
_range = range;
_errorCategory = errorCategory;
_cacheResults = cacheResults;
_ignoreFailure = ignoreFailure;
}
/// <summary>
/// Constructs request to lock or unlock given mappings in GSM.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationName">Operation name, useful for diagnostics.</param>
/// <param name="shardMap">Shard map to add.</param>
/// <param name="mapping">Mapping to lock or unlock. Null means all mappings.</param>
/// <param name="lockOwnerId">Lock owner.</param>
/// <param name="lockOpType">Lock operation type.</param>
/// <param name="errorCategory">Error category.</param>
internal LockOrUnLockMappingsGlobalOperation(ShardMapManager shardMapManager, string operationName, IStoreShardMap shardMap, IStoreMapping mapping, Guid lockOwnerId, LockOwnerIdOpType lockOpType, ShardManagementErrorCategory errorCategory) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_shardMapManager = shardMapManager;
_shardMap = shardMap;
_mapping = mapping;
_lockOwnerId = lockOwnerId;
_lockOpType = lockOpType;
_errorCategory = errorCategory;
Debug.Assert(mapping != null || (lockOpType == LockOwnerIdOpType.UnlockAllMappingsForId || lockOpType == LockOwnerIdOpType.UnlockAllMappings));
}
/// <summary>
/// Constructs request for Detaching the given shard and mapping information to the GSM database.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationName">Operation name.</param>
/// <param name="location">Location to be detached.</param>
/// <param name="shardMapName">Shard map from which shard is being detached.</param>
/// <returns>The store operation.</returns>
public virtual IStoreOperationGlobal CreateDetachShardGlobalOperation(
ShardMapManager shardMapManager,
string operationName,
ShardLocation location,
string shardMapName)
{
return new DetachShardGlobalOperation(
shardMapManager,
operationName,
location,
shardMapName);
}
/// <summary>
/// Constructs request for replacing the LSM mappings for given shard map with the input mappings.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="location">Location of the LSM.</param>
/// <param name="operationName">Operation name.</param>
/// <param name="shardMap">Local shard map.</param>
/// <param name="shard">Local shard.</param>
/// <param name="rangesToRemove">Optional list of ranges to minimize amount of deletions.</param>
/// <param name="mappingsToAdd">List of mappings to add.</param>
internal ReplaceMappingsLocalOperation(
ShardMapManager shardMapManager,
ShardLocation location,
string operationName,
IStoreShardMap shardMap,
IStoreShard shard,
IEnumerable<ShardRange> rangesToRemove,
IEnumerable<IStoreMapping> mappingsToAdd) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, location, operationName)
{
_shardMap = shardMap;
_shard = shard;
_rangesToRemove = rangesToRemove;
_mappingsToAdd = mappingsToAdd;
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map for which to add mapping.</param>
/// <param name="mapping">Mapping to add.</param>
protected internal AddMappingOperation(
ShardMapManager shardMapManager,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
IStoreMapping mapping) :
this(
shardMapManager,
Guid.NewGuid(),
StoreOperationState.UndoBegin,
operationCode,
shardMap,
mapping,
default(Guid))
{
}
/// <summary>
/// Constructs request for obtaining all the shard maps and shards from an LSM.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="location">Location of the LSM.</param>
/// <param name="operationName">Operation name.</param>
/// <param name="shardMap">Local shard map.</param>
/// <param name="shard">Local shard.</param>
/// <param name="range">Optional range to get mappings from.</param>
/// <param name="ignoreFailure">Ignore shard map not found error.</param>
internal GetMappingsByRangeLocalOperation(
ShardMapManager shardMapManager,
ShardLocation location,
string operationName,
IStoreShardMap shardMap,
IStoreShard shard,
ShardRange range,
bool ignoreFailure) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, location, operationName)
{
Debug.Assert(shard != null);
_shardMap = shardMap;
_shard = shard;
_range = range;
_ignoreFailure = ignoreFailure;
}
/// <summary>
/// Creates request to replace mappings within shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map for which to update mapping.</param>
/// <param name="mappingsSource">Original mappings.</param>
/// <param name="mappingsTarget">Target mappings mapping.</param>
protected internal ReplaceMappingsOperation(
ShardMapManager shardMapManager,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
Tuple<IStoreMapping, Guid>[] mappingsSource,
Tuple<IStoreMapping, Guid>[] mappingsTarget) :
this(
shardMapManager,
Guid.NewGuid(),
StoreOperationState.UndoBegin,
operationCode,
shardMap,
mappingsSource,
mappingsTarget,
default(Guid))
{
}
/// <summary>
/// Constructs an instance of StoreOperation.
/// </summary>
/// <param name="shardMapManager">ShardMapManager object.</param>
/// <param name="operationId">Operation Id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="opCode">Operation code.</param>
/// <param name="originalShardVersionRemoves">Original shard version for removes.</param>
/// <param name="originalShardVersionAdds">Original shard version for adds.</param>
protected StoreOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
StoreOperationCode opCode,
Guid originalShardVersionRemoves,
Guid originalShardVersionAdds
)
{
this.Id = operationId;
this.OperationCode = opCode;
this.Manager = shardMapManager;
this.UndoStartState = undoStartState;
_operationState = StoreOperationState.DoBegin;
_maxDoState = StoreOperationState.DoBegin;
this.OriginalShardVersionRemoves = originalShardVersionRemoves;
this.OriginalShardVersionAdds = originalShardVersionAdds;
}
/// <summary>
/// Constructs request for obtaining mapping from GSM based on given key.
/// </summary>
/// <param name="shardMapManager">Shard map manager.</param>
/// <param name="operationName">Operation being executed.</param>
/// <param name="shardMap">Local shard map.</param>
/// <param name="key">Key for lookup operation.</param>
/// <param name="policy">Policy for cache update.</param>
/// <param name="errorCategory">Error category.</param>
/// <param name="cacheResults">Whether to cache the results of the operation.</param>
/// <param name="ignoreFailure">Ignore shard map not found error.</param>
protected internal FindMappingByKeyGlobalOperation(
ShardMapManager shardMapManager,
string operationName,
IStoreShardMap shardMap,
ShardKey key,
CacheStoreMappingUpdatePolicy policy,
ShardManagementErrorCategory errorCategory,
bool cacheResults,
bool ignoreFailure) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
_manager = shardMapManager;
_shardMap = shardMap;
_key = key;
_policy = policy;
_errorCategory = errorCategory;
_cacheResults = cacheResults;
_ignoreFailure = ignoreFailure;
}
/// <summary>
/// Creates request to update shard in given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationId">Operation id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="shardMap">Shard map for which to remove shard.</param>
/// <param name="shardOld">Shard to update.</param>
/// <param name="shardNew">Updated shard.</param>
internal UpdateShardOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
IStoreShardMap shardMap,
IStoreShard shardOld,
IStoreShard shardNew) :
base(
shardMapManager,
operationId,
undoStartState,
StoreOperationCode.UpdateShard,
default(Guid),
default(Guid))
{
_shardMap = shardMap;
_shardOld = shardOld;
_shardNew = shardNew;
}
/// <summary>
/// Creates request to replace mappings within shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationId">Operation id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map for which to update mapping.</param>
/// <param name="mappingsSource">Original mappings.</param>
/// <param name="mappingsTarget">Target mappings mapping.</param>
/// <param name="originalShardVersionAdds">Original shard version on source.</param>
internal ReplaceMappingsOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
Tuple<IStoreMapping, Guid>[] mappingsSource,
Tuple<IStoreMapping, Guid>[] mappingsTarget,
Guid originalShardVersionAdds) :
base(
shardMapManager,
operationId,
undoStartState,
operationCode,
originalShardVersionAdds,
originalShardVersionAdds)
{
_shardMap = shardMap;
_mappingsSource = mappingsSource;
_mappingsTarget = mappingsTarget;
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationId">Operation id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map for which to add mapping.</param>
/// <param name="mapping">Mapping to add.</param>
/// <param name="originalShardVersionAdds">Original shard version.</param>
internal AddMappingOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
IStoreMapping mapping,
Guid originalShardVersionAdds) :
base(
shardMapManager,
operationId,
undoStartState,
operationCode,
default(Guid),
originalShardVersionAdds)
{
_shardMap = shardMap;
_mapping = mapping;
_errorCategory = operationCode == StoreOperationCode.AddRangeMapping ?
ShardManagementErrorCategory.RangeShardMap :
ShardManagementErrorCategory.ListShardMap;
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map for which to update mapping.</param>
/// <param name="mappingSource">Mapping to update.</param>
/// <param name="mappingTarget">Updated mapping.</param>
/// <param name="patternForKill">Pattern for kill commands.</param>
/// <param name="lockOwnerId">Id of lock owner.</param>
protected internal UpdateMappingOperation(
ShardMapManager shardMapManager,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
IStoreMapping mappingSource,
IStoreMapping mappingTarget,
string patternForKill,
Guid lockOwnerId) :
this(
shardMapManager,
Guid.NewGuid(),
StoreOperationState.UndoBegin,
operationCode,
shardMap,
mappingSource,
mappingTarget,
patternForKill,
lockOwnerId,
default(Guid),
default(Guid))
{
}
/// <summary>
/// Creates request to add shard to given shard map.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationId">Operation id.</param>
/// <param name="undoStartState">State from which Undo operation starts.</param>
/// <param name="operationCode">Store operation code.</param>
/// <param name="shardMap">Shard map from which to remove mapping.</param>
/// <param name="mapping">Mapping to add.</param>
/// <param name="lockOwnerId">Id of lock owner.</param>
/// <param name="originalShardVersionRemoves">Original shard version.</param>
internal RemoveMappingOperation(
ShardMapManager shardMapManager,
Guid operationId,
StoreOperationState undoStartState,
StoreOperationCode operationCode,
IStoreShardMap shardMap,
IStoreMapping mapping,
Guid lockOwnerId,
Guid originalShardVersionRemoves) :
base(
shardMapManager,
operationId,
undoStartState,
operationCode,
originalShardVersionRemoves,
default(Guid))
{
_shardMap = shardMap;
_mapping = mapping;
_lockOwnerId = lockOwnerId;
_errorCategory = operationCode == StoreOperationCode.RemoveRangeMapping ?
ShardManagementErrorCategory.RangeShardMap :
ShardManagementErrorCategory.ListShardMap;
}
/// <summary>
/// Main program loop.
/// </summary>
private static void MenuLoop()
{
// Get the shard map manager, if it already exists.
// It is recommended that you keep only one shard map manager instance in
// memory per AppDomain so that the mapping cache is not duplicated.
s_shardMapManager = ShardManagementUtils.TryGetShardMapManager(
Configuration.ShardMapManagerServerName,
Configuration.ShardMapManagerDatabaseName);
// Loop until the user chose "Exit".
bool continueLoop;
do
{
PrintShardMapState();
Console.WriteLine();
PrintMenu();
Console.WriteLine();
continueLoop = GetMenuChoiceAndExecute();
Console.WriteLine();
}
while (continueLoop);
}
/// <summary>
/// Constructs a request to get all schema info objects from GSM.
/// </summary>
/// <param name="shardMapManager">Shard map manager object.</param>
/// <param name="operationName">Operation name, useful for diagnostics.</param>
internal GetShardingSchemaInfosGlobalOperation(ShardMapManager shardMapManager, string operationName) :
base(shardMapManager.Credentials, shardMapManager.RetryPolicy, operationName)
{
}
internal AddShardOperationFailAfterLocalSource(
ShardMapManager shardMapManager,
IStoreShardMap shardMap,
IStoreShard shard)
: base(shardMapManager,
shardMap,
shard)
{
}
internal AddShardOperationFailAfterGlobalPreLocal(
ShardMapManager shardMapManager,
IStoreShardMap shardMap,
IStoreShard shard)
: base(shardMapManager,
shardMap,
shard)
{
}
