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; } }