/// <summary>Constructs a shard key using given object.</summary> /// <param name="value">Input object.</param> public ShardKey(object value) { ExceptionUtils.DisallowNullArgument(value, "value"); // We can't detect the type if value is null. if (DBNull.Value.Equals(value)) { throw new ArgumentNullException("value"); } ShardKey shardKey = value as ShardKey; if (shardKey != null) { _keyType = shardKey._keyType; _value = shardKey._value; } else { _keyType = ShardKey.DetectShardKeyType(value); _value = ShardKey.Normalize(_keyType, value); } _hashCode = this.CalculateHashCode(); }
public int CompareTo(ShardRange other) { ExceptionUtils.DisallowNullArgument(other, "other"); if (this.Low < other.Low) { return(-1); } if (this.High > other.High) { return(1); } if (this.Low == other.Low) { if (this.High == other.High) { return(0); } else { return(-1); } } else { Debug.Assert(this.Low > other.Low); Debug.Assert(this.High <= other.High); return(1); } }
/// <summary> /// Arguments used to create a point mapping. /// </summary> /// <param name="point">Point value being mapped.</param> /// <param name="shard">Shard used as the mapping target.</param> /// <param name="status">Status of the mapping.</param> public PointMappingCreationInfo(TKey point, Shard shard, MappingStatus status) { ExceptionUtils.DisallowNullArgument(shard, "shard"); this.Value = point; this.Shard = shard; this.Status = status; this.Key = new ShardKey(ShardKey.ShardKeyTypeFromType(typeof(TKey)), point); }
/// <summary> /// Creates an instance of <see cref="SqlConnectionInfo"/>. /// </summary> /// <param name="connectionString">The connection string.</param> /// <param name="secureCredential">The secure SQL credential.</param> internal SqlConnectionInfo( string connectionString, SqlCredential secureCredential) { ExceptionUtils.DisallowNullArgument(connectionString, "connectionString"); this.ConnectionString = connectionString; this.Credential = secureCredential; }
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)); } }
internal async Task <SqlConnection> OpenConnectionAsync( IShardProvider shardProvider, string connectionString, SqlCredential secureCredential, ConnectionOptions options = ConnectionOptions.Validate) { Debug.Assert(shardProvider != null, "Expecting IShardProvider."); ExceptionUtils.DisallowNullArgument(connectionString, "connectionString"); string connectionStringFinal = this.ValidateAndPrepareConnectionString( shardProvider, connectionString, secureCredential); ExceptionUtils.EnsureShardBelongsToShardMap( this.Manager, this, shardProvider.ShardInfo, "OpenConnectionAsync", "Shard"); IUserStoreConnection conn = this.Manager.StoreConnectionFactory.GetUserConnection(connectionStringFinal, secureCredential); Tracer.TraceInfo( TraceSourceConstants.ComponentNames.ShardMap, "OpenConnectionAsync", "Start; Shard: {0}; Options: {1}; ConnectionString: {2}", shardProvider.ShardInfo.Location, options, connectionStringFinal); using (ConditionalDisposable <IUserStoreConnection> cd = new ConditionalDisposable <IUserStoreConnection>(conn)) { Stopwatch stopwatch = Stopwatch.StartNew(); await conn.OpenAsync().ConfigureAwait(false); stopwatch.Stop(); // If validation is requested. if ((options & ConnectionOptions.Validate) == ConnectionOptions.Validate) { await shardProvider.ValidateAsync(this.StoreShardMap, conn.Connection).ConfigureAwait(false); } cd.DoNotDispose = true; Tracer.TraceInfo( TraceSourceConstants.ComponentNames.ShardMap, "OpenConnectionAsync", "Complete; Shard: {0}; Options: {1}; Open Duration: {2}", shardProvider.ShardInfo.Location, options, stopwatch.Elapsed); } return(conn.Connection); }
/// <summary> /// Instantiates the object that holds the credentials for accessing SQL Servers /// containing the shard map manager data. /// </summary> /// <param name="connectionString"> /// Connection string for shard map manager data source. /// </param> /// <param name="secureCredential"> /// Secure credential for shard map manager data source. /// </param> public SqlShardMapManagerCredentials(string connectionString, SqlCredential secureCredential) { ExceptionUtils.DisallowNullArgument(connectionString, "connectionString"); this._secureCredential = secureCredential; // Devnote: If connection string specifies Active Directory authentication and runtime is not // .NET 4.6 or higher, then below call will throw. SqlConnectionStringBuilder connectionStringBuilder = new SqlConnectionStringBuilder(connectionString); #region GSM Validation // DataSource must be set. if (string.IsNullOrEmpty(connectionStringBuilder.DataSource)) { throw new ArgumentException( StringUtils.FormatInvariant( Errors._SqlShardMapManagerCredentials_ConnectionStringPropertyRequired, "DataSource"), "connectionString"); } // InitialCatalog must be set. if (string.IsNullOrEmpty(connectionStringBuilder.InitialCatalog)) { throw new ArgumentException( StringUtils.FormatInvariant( Errors._SqlShardMapManagerCredentials_ConnectionStringPropertyRequired, "Initial Catalog"), "connectionString"); } // Ensure credentials are specified for GSM connectivity. SqlShardMapManagerCredentials.EnsureCredentials( connectionStringBuilder, "connectionString", this._secureCredential); #endregion GSM Validation // Copy the input connection strings. _connectionStringShardMapManager = new SqlConnectionStringBuilder(connectionStringBuilder.ConnectionString); _connectionStringShardMapManager.ApplicationName = ApplicationNameHelper.AddApplicationNameSuffix( _connectionStringShardMapManager.ApplicationName, GlobalConstants.ShardMapManagerInternalConnectionSuffixGlobal); _connectionStringShard = new SqlConnectionStringBuilder(connectionStringBuilder.ConnectionString); _connectionStringShard.Remove("Data Source"); _connectionStringShard.Remove("Initial Catalog"); _connectionStringShard.ApplicationName = ApplicationNameHelper.AddApplicationNameSuffix( _connectionStringShard.ApplicationName, GlobalConstants.ShardMapManagerInternalConnectionSuffixLocal); }
/// <summary> /// Creates an instance of <see cref="SqlConnectionInfo"/>. /// </summary> /// <param name="connectionString">The connection string.</param> /// <param name="secureCredential">The secure SQL credential.</param> /// <param name="accessTokenFactory">A function that returns an access token.</param> internal SqlConnectionInfo( string connectionString, SqlCredential secureCredential = null, Func <string> accessTokenFactory = null) { ExceptionUtils.DisallowNullArgument(connectionString, "connectionString"); this.ConnectionString = connectionString; this.Credential = secureCredential; this.AccessTokenFactory = accessTokenFactory; }
/// <summary> /// Validates the input shard map. This includes: /// * Ensuring that shard map belongs to this instance of shard map manager. /// </summary> /// <param name="shardMap">Input shard map.</param> private void ValidateShardMap(ShardMap shardMap) { ExceptionUtils.DisallowNullArgument(shardMap, "shardMap"); if (shardMap.Manager != this) { throw new InvalidOperationException( StringUtils.FormatInvariant( Errors._ShardMapManager_DifferentShardMapManager, shardMap.Name, this.Credentials.ShardMapManagerLocation)); } }
/// <summary>Returns the intersection of two ranges.</summary> /// <param name="range">Range to intersect with.</param> /// <returns> /// The intersection of the current range and the specified range, null if ranges dont intersect. /// </returns> internal ShardRange Intersect(ShardRange range) { ExceptionUtils.DisallowNullArgument(range, "range"); ShardKey intersectLow = ShardKey.Max(Low, range.Low); ShardKey intersectHigh = ShardKey.Min(High, range.High); if (intersectLow >= intersectHigh) { return(null); } return(new ShardRange(intersectLow, intersectHigh)); }
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)); } }
public static ShardKeyType DetectShardKeyType(object value) { ExceptionUtils.DisallowNullArgument(value, "value"); ShardKeyType keyType; if (!ShardKey.s_typeToShardKeyType.Value.TryGetValue(value.GetType(), out keyType)) { throw new ArgumentException( StringUtils.FormatInvariant( Errors._ShardKey_UnsupportedValue, value.GetType()), "value"); } return(keyType); }
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>Constructs a shard range from low boundary (inclusive) to high high boundary (exclusive)</summary> /// <param name="low">Low boundary (inclusive)</param> /// <param name="high">High boundary (exclusive)</param> public ShardRange(ShardKey low, ShardKey high) { ExceptionUtils.DisallowNullArgument(low, "low"); ExceptionUtils.DisallowNullArgument(high, "high"); if (low >= high) { throw new ArgumentOutOfRangeException( "low", low, string.Format( Errors._ShardRange_LowGreaterThanOrEqualToHigh, low, high)); } this.Low = low; this.High = high; this.KeyType = Low.KeyType; _hashCode = this.CalculateHashCode(); }