public RangeMapping <TKey> MarkMappingOnline(RangeMapping <TKey> mapping, MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(mapping, "mapping");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"MarkMappingOnline", "Start; ");
Stopwatch stopwatch = Stopwatch.StartNew();
RangeMapping <TKey> result = this.rsm.MarkMappingOnline(mapping, mappingLockToken.LockOwnerId);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"MarkMappingOnline", "Complete; Duration: {0}",
stopwatch.Elapsed);
return(result);
}
}
internal Shard UpdateShard(Shard currentShard, ShardUpdate update)
{
ExceptionUtils.DisallowNullArgument(currentShard, "currentShard");
ExceptionUtils.DisallowNullArgument(update, "update");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"UpdateShard",
"Start; Shard: {0}",
currentShard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
Shard shard = _defaultMapper.UpdateShard(currentShard, update);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"UpdateShard",
"Complete; Shard: {0}; Duration: {1}",
currentShard.Location,
stopwatch.Elapsed);
return(shard);
}
}
/// <summary>
/// Tries to obtains a <see cref="RangeShardMap{TKey}"/> given the name.
/// </summary>
/// <typeparam name="TKey">Key type.</typeparam>
/// <param name="shardMapName">Name of shard map.</param>
/// <param name="shardMap">Shard map with the specified name.</param>
/// <returns><c>true</c> if shard map with the specified name was found, <c>false</c> otherwise.</returns>
public bool TryGetRangeShardMap <TKey>(string shardMapName, out RangeShardMap <TKey> shardMap)
{
ShardMapManager.ValidateShardMapName(shardMapName);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceVerbose(
TraceSourceConstants.ComponentNames.ShardMapManager,
"TryGetRangeShardMap",
"Start; ShardMap: {0}",
shardMapName);
shardMap = this.LookupAndConvertShardMapHelper <RangeShardMap <TKey> >(
"TryGetRangeShardMap",
shardMapName,
ShardMapExtensions.AsRangeShardMap <TKey>,
false);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"TryGetRangeShardMap",
"Complete; ShardMap: {0}",
shardMapName);
return(shardMap != null);
}
}
/// <summary>
/// Obtains a <see cref="ListShardMap{TKey}"/> given the name.
/// </summary>
/// <typeparam name="TKey">Key type.</typeparam>
/// <param name="shardMapName">Name of shard map.</param>
/// <returns>Resulting ShardMap.</returns>
public ListShardMap <TKey> GetListShardMap <TKey>(string shardMapName)
{
ShardMapManager.ValidateShardMapName(shardMapName);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceVerbose(
TraceSourceConstants.ComponentNames.ShardMapManager,
"GetListShardMap",
"Start; ShardMap: {0}",
shardMapName);
ListShardMap <TKey> shardMap = this.LookupAndConvertShardMapHelper <ListShardMap <TKey> >(
"GetListShardMap",
shardMapName,
ShardMapExtensions.AsListShardMap <TKey>,
true);
Debug.Assert(shardMap != null);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"GetListShardMap",
"Complete; ShardMap: {0}",
shardMapName);
return(shardMap);
}
}
/// <summary>
/// Obtains a <see cref="ShardMap"/> given the name.
/// </summary>
/// <param name="shardMapName">Name of shard map.</param>
/// <returns>Shardmap with the specificed name.</returns>
public ShardMap GetShardMap(string shardMapName)
{
ShardMapManager.ValidateShardMapName(shardMapName);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceVerbose(
TraceSourceConstants.ComponentNames.ShardMapManager,
"GetShardMap",
"Start; ShardMap: {0}",
shardMapName);
ShardMap shardMap = this.LookupAndConvertShardMapHelper <ShardMap>(
"GetShardMap",
shardMapName,
(sm, t) => sm,
true);
Debug.Assert(shardMap != null);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"GetShardMap",
"Complete; ShardMap: {0}",
shardMapName);
return(shardMap);
}
}
public void DeleteShardMap(ShardMap shardMap)
{
this.ValidateShardMap(shardMap);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"DeleteShardMap",
"Start; ShardMap: {0}",
shardMap.Name);
Stopwatch stopwatch = Stopwatch.StartNew();
this.RemoveShardMapFromStore(shardMap.StoreShardMap);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"DeleteShardMap",
"Complete; ShardMap: {0}; Duration: {1}",
shardMap.Name,
stopwatch.Elapsed);
}
}
/// <summary>
/// Opens a regular <see cref="SqlConnection"/> to the specified shard.
/// </summary>
/// <param name="connectionString">
/// Connection string with credential information such as SQL Server credentials or Integrated Security settings.
/// The hostname of the server and the database name for the shard are obtained from the lookup operation for key.
/// </param>
/// <param name="options">Options for validation operations to perform on opened connection.</param>
/// <remarks>
/// Note that the <see cref="SqlConnection"/> object returned by this call is not protected against transient faults.
/// Callers should follow best practices to protect the connection against transient faults in their application code, e.g., by using the transient fault handling
/// functionality in the Enterprise Library from Microsoft Patterns and Practices team.
/// </remarks>
public SqlConnection OpenConnection(string connectionString, ConnectionOptions options)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(this.ShardMap.OpenConnection(this as IShardProvider, connectionString, options));
}
}
/// <summary>
/// Tries to obtains the shard for the specified location.
/// </summary>
/// <param name="location">Location of the shard.</param>
/// <param name="shard">Shard which has the specified location.</param>
/// <returns><c>true</c> if shard with specified location is found, <c>false</c> otherwise.</returns>
public bool TryGetShard(ShardLocation location, out Shard shard)
{
ExceptionUtils.DisallowNullArgument(location, "location");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"TryGetShard",
"Start; Shard Location: {0} ",
location);
Stopwatch stopwatch = Stopwatch.StartNew();
shard = _defaultMapper.GetShardByLocation(location);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"TryGetShard",
"Complete; Shard Location: {0}; Duration: {1}",
location,
stopwatch.Elapsed);
return(shard != null);
}
}
/// <summary>
/// Asynchronously a regular <see cref="SqlConnection"/> to the specified shard.
/// </summary>
/// <param name="connectionString">
/// Connection string with credential information such as SQL Server credentials or Integrated Security settings.
/// The hostname of the server and the database name for the shard are obtained from the lookup operation for key.
/// </param>
/// <param name="secureCredential">Secure SQL Credential.</param>
/// <param name="options">Options for validation operations to perform on opened connection.</param>
/// <returns>A Task encapsulating an opened SqlConnection</returns>
/// <remarks>
/// Note that the <see cref="SqlConnection"/> object returned by this call is not protected against transient faults.
/// Callers should follow best practices to protect the connection against transient faults in their application code, e.g., by using the transient fault handling
/// functionality in the Enterprise Library from Microsoft Patterns and Practices team.
/// All non-usage errors will be propagated via the returned Task.
/// </remarks>
public Task <SqlConnection> OpenConnectionAsync(string connectionString, SqlCredential secureCredential, ConnectionOptions options)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(this.ShardMap.OpenConnectionAsync(this as IShardProvider, connectionString, secureCredential, options));
}
}
public IReadOnlyList <PointMapping <TKey> > GetMappings(Range <TKey> range, Shard shard)
{
ExceptionUtils.DisallowNullArgument(range, "range");
ExceptionUtils.DisallowNullArgument(shard, "shard");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"GetPointMappings", "Start; Shard: {0}; Range: {1}",
shard.Location, range);
Stopwatch stopwatch = Stopwatch.StartNew();
IReadOnlyList <PointMapping <TKey> > pointMappings = _lsm.GetMappingsForRange(range, shard);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"GetPointMappings", "Complete; Shard: {0}; Duration: {1}",
shard.Location, stopwatch.Elapsed);
return(pointMappings);
}
}
public RangeMapping <TKey> UpdateMapping(RangeMapping <TKey> currentMapping, RangeMappingUpdate update,
MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(currentMapping, "currentMapping");
ExceptionUtils.DisallowNullArgument(update, "update");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"UpdateMapping", "Start; Current mapping shard: {0}",
currentMapping.Shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
RangeMapping <TKey> rangeMapping = this.rsm.Update(currentMapping, update, mappingLockToken.LockOwnerId, MappingOptions.Validate);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"UpdateMapping", "Complete; Current mapping shard: {0}; Duration: {1}",
currentMapping.Shard.Location, stopwatch.Elapsed);
return(rangeMapping);
}
}
public RangeMapping <TKey> MergeMappings(RangeMapping <TKey> left, RangeMapping <TKey> right,
MappingLockToken leftMappingLockToken, MappingLockToken rightMappingLockToken)
{
ExceptionUtils.DisallowNullArgument(left, "left");
ExceptionUtils.DisallowNullArgument(right, "right");
ExceptionUtils.DisallowNullArgument(leftMappingLockToken, "leftMappingLockToken");
ExceptionUtils.DisallowNullArgument(rightMappingLockToken, "rightMappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"SplitMapping", "Start; Left Shard: {0}; Right Shard: {1}",
left.Shard.Location, right.Shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
RangeMapping <TKey> rangeMapping = this.rsm.Merge(left, right, leftMappingLockToken.LockOwnerId, rightMappingLockToken.LockOwnerId);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"SplitMapping", "Complete; Duration: {0}", stopwatch.Elapsed);
return(rangeMapping);
}
}
public IReadOnlyList <RangeMapping <TKey> > GetMappings(Range <TKey> range)
{
ExceptionUtils.DisallowNullArgument(range, "range");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"GetMappings", "Start; Range: {0}",
range);
Stopwatch stopwatch = Stopwatch.StartNew();
IReadOnlyList <RangeMapping <TKey> > rangeMappings = this.rsm.GetMappingsForRange(range, null);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"GetMappings",
"Complete; Range: {0}; Duration: {1}",
range, stopwatch.Elapsed);
return(rangeMappings);
}
}
public PointMapping <TKey> UpdateMapping(PointMapping <TKey> currentMapping, PointMappingUpdate update,
MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(currentMapping, "currentMapping");
ExceptionUtils.DisallowNullArgument(update, "update");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
string mappingKey = BitConverter.ToString(currentMapping.Key.RawValue);
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"UpdatePointMapping", "Start; ShardMap name: {0}; Current Point Mapping: {1}",
this.Name, mappingKey);
Stopwatch stopwatch = Stopwatch.StartNew();
PointMapping <TKey> pointMapping = _lsm.Update(currentMapping, update, mappingLockToken.LockOwnerId);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"UpdatePointMapping", "Complete; ShardMap name: {0}; Current Point Mapping: {1}; Duration: {2}",
this.Name, mappingKey, stopwatch.Elapsed);
return(pointMapping);
}
}
/// <summary>
/// Asynchronously opens a regular <see cref="SqlConnection"/> to the shard
/// to which the specified key value is mapped.
/// </summary>
/// <typeparam name="TKey">Type of the key.</typeparam>
/// <param name="key">Input key value.</param>
/// <param name="connectionString">
/// Connection string with credential information such as SQL Server credentials or Integrated Security settings.
/// The hostname of the server and the database name for the shard are obtained from the lookup operation for key.
/// </param>
/// <param name="options">Options for validation operations to perform on opened connection.</param>
/// <returns>A Task encapsulating an opened SqlConnection.</returns>
/// <remarks>
/// Note that the <see cref="SqlConnection"/> object returned by this call is not protected against transient faults.
/// Callers should follow best practices to protect the connection against transient faults
/// in their application code, e.g., by using the transient fault handling
/// functionality in the Enterprise Library from Microsoft Patterns and Practices team.
/// This call only works if there is a single default mapping.
/// </remarks>
public Task <SqlConnection> OpenConnectionForKeyAsync <TKey>(
TKey key,
string connectionString,
ConnectionOptions options)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
Debug.Assert(this.StoreShardMap.KeyType != ShardKeyType.None);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
IShardMapper <TKey> mapper = this.GetMapper <TKey>();
if (mapper == null)
{
throw new ArgumentException(
StringUtils.FormatInvariant(
Errors._ShardMap_OpenConnectionForKey_KeyTypeNotSupported,
typeof(TKey),
this.StoreShardMap.Name,
ShardKey.TypeFromShardKeyType(this.StoreShardMap.KeyType)),
"key");
}
Debug.Assert(mapper != null);
return(mapper.OpenConnectionForKeyAsync(key, connectionString, options));
}
}
public void LockMapping(PointMapping <TKey> mapping, MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(mapping, "mapping");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
// Generate a lock owner id
Guid lockOwnerId = mappingLockToken.LockOwnerId;
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"Lock", "Start; LockOwnerId: {0}", lockOwnerId);
Stopwatch stopwatch = Stopwatch.StartNew();
_lsm.LockOrUnlockMappings(mapping, lockOwnerId, LockOwnerIdOpType.Lock);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"Lock", "Complete; Duration: {0}; StoreLockOwnerId: {1}",
stopwatch.Elapsed, lockOwnerId);
}
}
/// <summary>
/// Creates and adds a point mapping to ShardMap.
/// </summary>
/// <param name="point">Point for which to create the mapping.</param>
/// <param name="shard">Shard associated with the point mapping.</param>
/// <returns>Newly created mapping.</returns>
public PointMapping <TKey> CreatePointMapping(TKey point, Shard shard)
{
ExceptionUtils.DisallowNullArgument(shard, "shard");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
PointMappingCreationInfo <TKey> args = new PointMappingCreationInfo <TKey>(point, shard, MappingStatus.Online);
string mappingKey = BitConverter.ToString(args.Key.RawValue);
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"CreatePointMapping", "Start; ShardMap name: {0}; Point Mapping: {1}",
this.Name, mappingKey);
Stopwatch stopwatch = Stopwatch.StartNew();
PointMapping <TKey> pointMapping = _lsm.Add(new PointMapping <TKey>(this.Manager, args));
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"CreatePointMapping", "Complete; ShardMap name: {0}; Point Mapping: {1}; Duration: {2}",
this.Name, mappingKey, stopwatch.Elapsed);
return(pointMapping);
}
}
/// <summary>
/// Atomically adds a shard to ShardMap using the specified location.
/// </summary>
/// <param name="location">Location of shard to be added.</param>
/// <returns>A shard attached to this shard map.</returns>
public Shard CreateShard(ShardLocation location)
{
ExceptionUtils.DisallowNullArgument(location, "location");
using (ActivityIdScope activityId = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"CreateShard",
"Start; Shard: {0} ",
location);
Stopwatch stopwatch = Stopwatch.StartNew();
Shard shard = _defaultMapper.Add(
new Shard(
this.Manager,
this,
new ShardCreationInfo(location)));
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"CreateShard",
"Complete; Shard: {0}; Duration: {1}",
location,
stopwatch.Elapsed);
return(shard);
}
}
public void DeleteShard(Shard shard)
{
ExceptionUtils.DisallowNullArgument(shard, "shard");
using (ActivityIdScope activityId = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"DeleteShard",
"Start; Shard: {0} ",
shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
_defaultMapper.Remove(shard);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMap,
"DeleteShard",
"Complete; Shard: {0}; Duration: {1}",
shard.Location,
stopwatch.Elapsed);
}
}
public SqlConnection OpenConnectionForKey(TKey key, string connectionString, ConnectionOptions options)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(_lsm.OpenConnectionForKey(key, connectionString, options));
}
}
public Task <SqlConnection> OpenConnectionForKeyAsync(TKey key, string connectionString, SqlCredential secureCredential, ConnectionOptions options)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(this.rsm.OpenConnectionForKeyAsync(key, connectionString, secureCredential, options));
}
}
/// <summary>
/// Opens a regular <see cref="SqlConnection"/> to the specified shard.
/// </summary>
/// <param name="connectionString">
/// Connection string with credential information such as SQL Server credentials or Integrated Security settings.
/// The hostname of the server and the database name for the shard are obtained from the lookup operation for key.
/// </param>
/// <param name="secureCredential">Secure SQL credential information.</param>
/// <param name="options">Options for validation operations to perform on opened connection.</param>
/// <remarks>
/// Note that the <see cref="SqlConnection"/> object returned by this call is not protected against transient faults.
/// Callers should follow best practices to protect the connection against transient faults in their application code, e.g., by using the transient fault handling
/// functionality in the Enterprise Library from Microsoft Patterns and Practices team.
/// </remarks>
public SqlConnection OpenConnection(string connectionString, SqlCredential secureCredential, ConnectionOptions options)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(this.ShardMap.OpenConnection(
this as IShardProvider,
new SqlConnectionInfo(
connectionString,
secureCredential),
options));
}
}
public Task <SqlConnection> OpenConnectionForKeyAsync(
TKey key,
SqlConnectionInfo connectionInfo,
ConnectionOptions options)
{
ExceptionUtils.DisallowNullArgument(connectionInfo, "connectionInfo");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
return(_lsm.OpenConnectionForKeyAsync(
key,
connectionInfo,
options));
}
}
/// <summary>
/// Creates a list based <see cref="ListShardMap{TKey}"/>.
/// </summary>
/// <typeparam name="TKey">Type of keys.</typeparam>
/// <param name="shardMapName">Name of shard map.</param>
/// <returns>List shard map with the specified name.</returns>
public ListShardMap <TKey> CreateListShardMap <TKey>(string shardMapName)
{
ShardMapManager.ValidateShardMapName(shardMapName);
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
DefaultStoreShardMap dssm = new DefaultStoreShardMap(
Guid.NewGuid(),
shardMapName,
ShardMapType.List,
ShardKey.ShardKeyTypeFromType(typeof(TKey)));
ListShardMap <TKey> listShardMap = new ListShardMap <TKey>(this, dssm);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"CreateListShardMap",
"Start; ShardMap: {0}",
shardMapName);
Stopwatch stopwatch = Stopwatch.StartNew();
this.AddShardMapToStore("CreateListShardMap", dssm);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"CreateListShardMap",
"Added ShardMap to Store; ShardMap: {0} Duration: {1}",
shardMapName,
stopwatch.Elapsed);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManager,
"CreateListShardMap",
"Complete; ShardMap: {0} Duration: {1}",
shardMapName,
stopwatch.Elapsed);
return(listShardMap);
}
}
/// <summary>
/// Looks up the key value and returns the corresponding mapping.
/// </summary>
/// <param name="key">Input key value.</param>
/// <returns>Mapping that contains the key value.</returns>
public RangeMapping <TKey> GetMappingForKey(TKey key)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"GetMapping", "Start; Range Mapping Key Type: {0}", typeof(TKey));
Stopwatch stopwatch = Stopwatch.StartNew();
RangeMapping <TKey> rangeMapping = this.rsm.Lookup(key, false);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"GetMapping", "Complete; Range Mapping Key Type: {0} Duration: {1}",
typeof(TKey), stopwatch.Elapsed);
return(rangeMapping);
}
}
/// <summary>
/// Looks up the key value and returns the corresponding mapping.
/// </summary>
/// <param name="key">Input key value.</param>
/// <param name="lookupOptions">Whether to search in the cache and/or store.</param>
/// <returns>Mapping that contains the key value.</returns>
public PointMapping <TKey> GetMappingForKey(TKey key, LookupOptions lookupOptions)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"LookupPointMapping", "Start; ShardMap name: {0}; Point Mapping Key Type: {1}; Lookup Options: {2}",
this.Name, typeof(TKey), lookupOptions);
Stopwatch stopwatch = Stopwatch.StartNew();
PointMapping <TKey> pointMapping = _lsm.Lookup(key, lookupOptions);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"LookupPointMapping", "Complete; ShardMap name: {0}; Point Mapping Key Type: {1}; Lookup Options: {2}; Duration: {3}",
this.Name, typeof(TKey), lookupOptions, stopwatch.Elapsed);
return(pointMapping);
}
}
public void DeleteMapping(RangeMapping <TKey> mapping, MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(mapping, "mapping");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"DeleteMapping", "Start; Shard: {0}", mapping.Shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
this.rsm.Remove(mapping, mappingLockToken.LockOwnerId);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"DeleteMapping", "Complete; Shard: {0}; Duration: {1}",
mapping.Shard.Location, stopwatch.Elapsed);
}
}
/// <summary>
/// Tries to looks up the key value and place the corresponding mapping in <paramref name="pointMapping"/>.
/// </summary>
/// <param name="key">Input key value.</param>
/// <param name="pointMapping">Mapping that contains the key value.</param>
/// <returns><c>true</c> if mapping is found, <c>false</c> otherwise.</returns>
public bool TryGetMappingForKey(TKey key, out PointMapping <TKey> pointMapping)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"TryLookupPointMapping", "Start; ShardMap name: {0}; Point Mapping Key Type: {1}",
this.Name, typeof(TKey));
Stopwatch stopwatch = Stopwatch.StartNew();
bool result = _lsm.TryLookup(key, false, out pointMapping);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.ListShardMap,
"TryLookupPointMapping", "Complete; ShardMap name: {0}; Point Mapping Key Type: {1}; Duration: {2}",
this.Name, typeof(TKey), stopwatch.Elapsed);
return(result);
}
}
internal static ShardMapManager GetSqlShardMapManager(
string connectionString,
SqlCredential secureCredential,
ShardMapManagerLoadPolicy loadPolicy,
RetryBehavior retryBehavior,
EventHandler <RetryingEventArgs> retryEventHandler)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
ExceptionUtils.DisallowNullArgument(retryBehavior, "retryBehavior");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"GetSqlShardMapManager",
"Start; ");
Stopwatch stopwatch = Stopwatch.StartNew();
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
secureCredential,
loadPolicy,
retryBehavior,
retryEventHandler,
true);
stopwatch.Stop();
Debug.Assert(shardMapManager != null);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"GetSqlShardMapManager",
"Complete; Duration: {0}",
stopwatch.Elapsed);
return(shardMapManager);
}
}
public IReadOnlyList <PointMapping <TKey> > GetMappings()
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"GetPointMappings", "Start;");
Stopwatch stopwatch = Stopwatch.StartNew();
IReadOnlyList <PointMapping <TKey> > pointMappings = _lsm.GetMappingsForRange(null, null);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ListShardMap,
"GetPointMappings", "Complete; Duration: {0}",
stopwatch.Elapsed);
return(pointMappings);
}
}
private static ShardMapManager CreateSqlShardMapManagerImpl(
string connectionString,
ShardMapManagerCreateMode createMode,
RetryBehavior retryBehavior,
EventHandler<RetryingEventArgs> retryEventHandler,
Version targetVersion)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
ExceptionUtils.DisallowNullArgument(retryBehavior, "retryBehavior");
if (createMode != ShardMapManagerCreateMode.KeepExisting &&
createMode != ShardMapManagerCreateMode.ReplaceExisting)
{
throw new ArgumentException(
StringUtils.FormatInvariant(
Errors._General_InvalidArgumentValue,
createMode,
"createMode"),
"createMode");
}
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
DateTime getStartTime = DateTime.UtcNow;
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"CreateSqlShardMapManager",
"Start; ");
SqlShardMapManagerCredentials credentials = new SqlShardMapManagerCredentials(connectionString);
TransientFaultHandling.RetryPolicy retryPolicy = new TransientFaultHandling.RetryPolicy(
new ShardManagementTransientErrorDetectionStrategy(retryBehavior),
RetryPolicy.DefaultRetryPolicy.GetRetryStrategy());
EventHandler<TransientFaultHandling.RetryingEventArgs> handler = (sender, args) =>
{
if (retryEventHandler != null)
{
retryEventHandler(sender, new RetryingEventArgs(args));
}
};
try
{
retryPolicy.Retrying += handler;
// specifying targetVersion as GlobalConstants.GsmVersionClient to deploy latest store by default.
using (IStoreOperationGlobal op = new StoreOperationFactory().CreateCreateShardMapManagerGlobalOperation(
credentials,
retryPolicy,
"CreateSqlShardMapManager",
createMode,
targetVersion))
{
op.Do();
}
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"CreateSqlShardMapManager",
"Complete; Duration: {0}",
DateTime.UtcNow - getStartTime);
}
finally
{
retryPolicy.Retrying -= handler;
}
return new ShardMapManager(
credentials,
new SqlStoreConnectionFactory(),
new StoreOperationFactory(),
new CacheStore(),
ShardMapManagerLoadPolicy.Lazy,
RetryPolicy.DefaultRetryPolicy,
retryBehavior,
retryEventHandler);
}
}
public static bool TryGetSqlShardMapManager(
string connectionString,
ShardMapManagerLoadPolicy loadPolicy,
RetryBehavior retryBehavior,
out ShardMapManager shardMapManager)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
ExceptionUtils.DisallowNullArgument(retryBehavior, "retryBehavior");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
DateTime getStartTime = DateTime.UtcNow;
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"TryGetSqlShardMapManager",
"Start; ");
shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
loadPolicy,
retryBehavior,
null,
false);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"TryGetSqlShardMapManager",
"Complete; Duration: {0}",
DateTime.UtcNow - getStartTime);
return shardMapManager != null;
}
}
internal static ShardMapManager GetSqlShardMapManager(
string connectionString,
ShardMapManagerLoadPolicy loadPolicy,
RetryBehavior retryBehavior,
EventHandler<RetryingEventArgs> retryEventHandler)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
ExceptionUtils.DisallowNullArgument(retryBehavior, "retryBehavior");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
DateTime getStartTime = DateTime.UtcNow;
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"GetSqlShardMapManager",
"Start; ");
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
loadPolicy,
retryBehavior,
retryEventHandler,
true);
Debug.Assert(shardMapManager != null);
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"GetSqlShardMapManager",
"Complete; Duration: {0}",
DateTime.UtcNow - getStartTime);
return shardMapManager;
}
}
internal static bool TryGetSqlShardMapManager(
string connectionString,
ShardMapManagerLoadPolicy loadPolicy,
RetryBehavior retryBehavior,
EventHandler<RetryingEventArgs> retryEventHandler,
out ShardMapManager shardMapManager)
{
ExceptionUtils.DisallowNullArgument(connectionString, "connectionString");
ExceptionUtils.DisallowNullArgument(retryBehavior, "retryBehavior");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"TryGetSqlShardMapManager",
"Start; ");
Stopwatch stopwatch = Stopwatch.StartNew();
shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
connectionString,
loadPolicy,
retryBehavior,
retryEventHandler,
false);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.ShardMapManagerFactory,
"TryGetSqlShardMapManager",
"Complete; Duration: {0}",
stopwatch.Elapsed);
return shardMapManager != null;
}
}
