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);
}
}
/// <summary>
/// Removes a range mapping.
/// </summary>
/// <param name="mapping">Mapping being removed.</param>
/// <param name="lockOwnerId">Lock owner id of this mapping</param>
public void Remove(RangeMapping <TKey> mapping, Guid lockOwnerId)
{
this.Remove <RangeMapping <TKey> >(
mapping,
(smm, sm, ssm) => new RangeMapping <TKey>(smm, sm, ssm),
lockOwnerId);
}
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);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"UpdateMapping", "Complete; Current mapping shard: {0}; Duration: {1}",
currentMapping.Shard.Location, stopwatch.Elapsed);
return(rangeMapping);
}
}
public void LockMapping(RangeMapping <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.RangeShardMap,
"Lock", "Start; LockOwnerId: {0}", lockOwnerId);
Stopwatch stopwatch = Stopwatch.StartNew();
this.rsm.LockOrUnlockMappings(mapping, lockOwnerId, LockOwnerIdOpType.Lock);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"Lock", "Complete; Duration: {0}; StoreLockOwnerId: {1}",
stopwatch.Elapsed, lockOwnerId);
}
}
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 void LockOrUnlockMappings(RangeMapping <TKey> mapping, Guid lockOwnerId, LockOwnerIdOpType lockOwnerIdOpType)
{
this.LockOrUnlockMappings <RangeMapping <TKey> >(
mapping,
lockOwnerId,
lockOwnerIdOpType,
ShardManagementErrorCategory.RangeShardMap);
}
/// <summary>
/// Allows for update to a range mapping with the updates provided in
/// the <paramref name="update"/> parameter.
/// </summary>
/// <param name="currentMapping">Mapping being updated.</param>
/// <param name="update">Updated properties of the Shard.</param>
/// <param name="lockOwnerId">Lock owner id of this mapping</param>
/// <returns>New instance of mapping with updated information.</returns>
internal RangeMapping <TKey> Update(RangeMapping <TKey> currentMapping, RangeMappingUpdate update, Guid lockOwnerId)
{
return(this.Update <RangeMapping <TKey>, RangeMappingUpdate, MappingStatus>(
currentMapping,
update,
(smm, sm, ssm) => new RangeMapping <TKey>(smm, sm, ssm),
rms => (int)rms,
i => (MappingStatus)i,
lockOwnerId));
}
/// <summary>
/// Tries to looks up the key value and returns the corresponding mapping.
/// </summary>
/// <param name="key">Input key value.</param>
/// <param name="useCache">Whether to use cache for lookups.</param>
/// <param name="mapping">Mapping that contains the key value.</param>
/// <returns><c>true</c> if mapping is found, <c>false</c> otherwise.</returns>
public bool TryLookup(TKey key, bool useCache, out RangeMapping <TKey> mapping)
{
RangeMapping <TKey> p = this.Lookup <RangeMapping <TKey>, TKey>(
key,
useCache,
(smm, sm, ssm) => new RangeMapping <TKey>(smm, sm, ssm),
ShardManagementErrorCategory.RangeShardMap);
mapping = p;
return(p != null);
}
/// <summary>
/// Marks the given mapping offline.
/// </summary>
/// <param name="mapping">Input range mapping.</param>
/// <param name="lockOwnerId">Lock owner id of this mapping</param>
/// <returns>An offline mapping.</returns>
public RangeMapping <TKey> MarkMappingOffline(RangeMapping <TKey> mapping, Guid lockOwnerId)
{
return(BaseShardMapper.SetStatus <RangeMapping <TKey>, RangeMappingUpdate, MappingStatus>(
mapping,
mapping.Status,
s => MappingStatus.Offline,
s => new RangeMappingUpdate()
{
Status = s
},
this.Update,
lockOwnerId));
}
/// <summary>
/// Determines whether the specified object is equal to the current object.
/// </summary>
/// <param name="obj">The object to compare with the current object.</param>
/// <returns>True if the specified object is equal to the current object; otherwise, false.</returns>
public override bool Equals(object obj)
{
RangeMapping <TKey> other = obj as RangeMapping <TKey>;
if (other == null)
{
return(false);
}
if (this.Id.Equals(other.Id))
{
Debug.Assert(this.Range.Equals(other.Range));
return(true);
}
return(false);
}
/// <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="useCache">Whether to use cache for lookups.</param>
/// <returns>Mapping that contains the key value.</returns>
public RangeMapping <TKey> Lookup(TKey key, bool useCache)
{
RangeMapping <TKey> p = this.Lookup <RangeMapping <TKey>, TKey>(
key,
useCache,
(smm, sm, ssm) => new RangeMapping <TKey>(smm, sm, ssm),
ShardManagementErrorCategory.RangeShardMap);
if (p == null)
{
throw new ShardManagementException(
ShardManagementErrorCategory.RangeShardMap,
ShardManagementErrorCode.MappingNotFoundForKey,
Errors._Store_ShardMapper_MappingNotFoundForKeyGlobal,
this.ShardMap.Name,
StoreOperationRequestBuilder.SpFindShardMappingByKeyGlobal,
"Lookup");
}
return(p);
}
/// <summary>
/// Tries to looks up the key value and place the corresponding mapping in <paramref name="rangeMapping"/>.
/// </summary>
/// <param name="key">Input key value.</param>
/// <param name="rangeMapping">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 RangeMapping <TKey> rangeMapping)
{
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"TryLookupRangeMapping", "Start; ShardMap name: {0}; Range Mapping Key Type: {1}",
this.Name, typeof(TKey));
Stopwatch stopwatch = Stopwatch.StartNew();
bool result = this.rsm.TryLookup(key, false, out rangeMapping);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"TryLookupRangeMapping", "Complete; ShardMap name: {0}; Range Mapping Key Type: {1}; Duration: {2}",
this.Name, typeof(TKey), stopwatch.Elapsed);
return(result);
}
}
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);
}
}
public RangeMapping <TKey> CreateRangeMapping(RangeMappingCreationInfo <TKey> creationInfo)
{
ExceptionUtils.DisallowNullArgument(creationInfo, "args");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"CreateRangeMapping", "Start; Shard: {0}", creationInfo.Shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
RangeMapping <TKey> rangeMapping = this.rsm.Add(new RangeMapping <TKey>(this.Manager, creationInfo));
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"CreateRangeMapping", "Complete; Shard: {0}; Duration: {1}",
creationInfo.Shard.Location, stopwatch.Elapsed);
return(rangeMapping);
}
}
/// <summary>
/// Gets the lock owner id of the specified mapping.
/// </summary>
/// <param name="mapping">Input range mapping.</param>
/// <returns>An instance of <see cref="MappingLockToken"/></returns>
public MappingLockToken GetMappingLockOwner(RangeMapping <TKey> mapping)
{
ExceptionUtils.DisallowNullArgument(mapping, "mapping");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"LookupLockOwner", "Start");
Stopwatch stopwatch = Stopwatch.StartNew();
Guid storeLockOwnerId = this.rsm.GetLockOwnerForMapping(mapping);
stopwatch.Stop();
Tracer.TraceInfo(
TraceSourceConstants.ComponentNames.RangeShardMap,
"LookupLockOwner", "Complete; Duration: {0}; StoreLockOwnerId: {1}",
stopwatch.Elapsed, storeLockOwnerId);
return(new MappingLockToken(storeLockOwnerId));
}
}
public IReadOnlyList <RangeMapping <TKey> > SplitMapping(RangeMapping <TKey> existingMapping, TKey splitAt,
MappingLockToken mappingLockToken)
{
ExceptionUtils.DisallowNullArgument(existingMapping, "existingMapping");
ExceptionUtils.DisallowNullArgument(mappingLockToken, "mappingLockToken");
using (ActivityIdScope activityIdScope = new ActivityIdScope(Guid.NewGuid()))
{
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"SplitMapping", "Start; Shard: {0}", existingMapping.Shard.Location);
Stopwatch stopwatch = Stopwatch.StartNew();
IReadOnlyList <RangeMapping <TKey> > rangeMapping = this.rsm.Split(existingMapping, splitAt, mappingLockToken.LockOwnerId);
stopwatch.Stop();
Tracer.TraceInfo(TraceSourceConstants.ComponentNames.RangeShardMap,
"SplitMapping", "Complete; Shard: {0}; Duration: {1}",
existingMapping.Shard.Location, stopwatch.Elapsed);
return(rangeMapping);
}
}
public RangeMapping <TKey> MergeMappings(RangeMapping <TKey> left, RangeMapping <TKey> right)
{
return(this.MergeMappings(left, right, MappingLockToken.NoLock, MappingLockToken.NoLock));
}
/// <summary>
/// Marks the specified mapping online.
/// </summary>
/// <param name="mapping">Input range mapping.</param>
/// <returns>An online mapping.</returns>
public RangeMapping <TKey> MarkMappingOnline(RangeMapping <TKey> mapping)
{
return(this.MarkMappingOnline(mapping, MappingLockToken.NoLock));
}
/// <summary>
/// Gets the lock owner of a mapping.
/// </summary>
/// <param name="mapping">The mapping</param>
/// <returns>Lock owner for the mapping.</returns>
internal Guid GetLockOwnerForMapping(RangeMapping <TKey> mapping)
{
return(this.GetLockOwnerForMapping <RangeMapping <TKey> >(mapping, ShardManagementErrorCategory.RangeShardMap));
}
internal RangeMapping <TKey> Merge(RangeMapping <TKey> left, RangeMapping <TKey> right, Guid leftLockOwnerId, Guid rightLockOwnerId)
{
this.EnsureMappingBelongsToShardMap <RangeMapping <TKey> >(left, "Merge", "left");
this.EnsureMappingBelongsToShardMap <RangeMapping <TKey> >(right, "Merge", "right");
if (!left.Shard.Location.Equals(right.Shard.Location))
{
throw new ArgumentException(
StringUtils.FormatInvariant(
Errors._ShardMapping_MergeDifferentShards,
this.ShardMap.Name,
left.Shard.Location,
right.Shard.Location),
"left");
}
if (left.Range.Intersects(right.Range) || left.Range.High != right.Range.Low)
{
throw new ArgumentOutOfRangeException(
"left",
Errors._ShardMapping_MergeNotAdjacent);
}
if (left.Status != right.Status)
{
throw new ArgumentException(
StringUtils.FormatInvariant(
Errors._ShardMapping_DifferentStatus,
this.ShardMap.Name),
"left");
}
IStoreShard newShard = new DefaultStoreShard(
left.Shard.StoreShard.Id,
Guid.NewGuid(),
left.Shard.StoreShard.ShardMapId,
left.Shard.StoreShard.Location,
left.Shard.StoreShard.Status);
IStoreMapping mappingToRemoveLeft = new DefaultStoreMapping(
left.StoreMapping.Id,
left.StoreMapping.ShardMapId,
newShard,
left.StoreMapping.MinValue,
left.StoreMapping.MaxValue,
left.StoreMapping.Status,
left.StoreMapping.LockOwnerId);
IStoreMapping mappingToRemoveRight = new DefaultStoreMapping(
right.StoreMapping.Id,
right.StoreMapping.ShardMapId,
newShard,
right.StoreMapping.MinValue,
right.StoreMapping.MaxValue,
right.StoreMapping.Status,
right.StoreMapping.LockOwnerId);
IStoreMapping mappingToAdd = new DefaultStoreMapping(
Guid.NewGuid(),
newShard.ShardMapId,
newShard,
left.Range.Low.RawValue,
right.Range.High.RawValue,
(int)left.Status,
leftLockOwnerId);
using (IStoreOperation op = this.Manager.StoreOperationFactory.CreateReplaceMappingsOperation(
this.Manager,
StoreOperationCode.MergeMappings,
this.ShardMap.StoreShardMap,
new[]
{
new Tuple <IStoreMapping, Guid> (mappingToRemoveLeft, leftLockOwnerId),
new Tuple <IStoreMapping, Guid> (mappingToRemoveRight, rightLockOwnerId)
},
new[]
{
new Tuple <IStoreMapping, Guid>(mappingToAdd, leftLockOwnerId)
}))
{
op.Do();
}
return(new RangeMapping <TKey>(this.Manager, this.ShardMap, mappingToAdd));
}
/// <summary>
/// Splits the given mapping into 2 at the given key. The new mappings point to the same shard
/// as the existing mapping.
/// </summary>
/// <param name="existingMapping">Given existing mapping.</param>
/// <param name="splitAt">Split point.</param>
/// <param name="lockOwnerId">Lock owner id of this mapping</param>
/// <returns>Read-only collection of 2 new mappings thus created.</returns>
internal IReadOnlyList <RangeMapping <TKey> > Split(RangeMapping <TKey> existingMapping, TKey splitAt, Guid lockOwnerId)
{
this.EnsureMappingBelongsToShardMap <RangeMapping <TKey> >(
existingMapping,
"Split",
"existingMapping");
ShardKey shardKey = new ShardKey(ShardKey.ShardKeyTypeFromType(typeof(TKey)), splitAt);
if (!existingMapping.Range.Contains(shardKey) ||
existingMapping.Range.Low == shardKey ||
existingMapping.Range.High == shardKey)
{
throw new ArgumentOutOfRangeException(
"splitAt",
Errors._ShardMapping_SplitPointOutOfRange);
}
IStoreShard newShard = new DefaultStoreShard(
existingMapping.Shard.StoreShard.Id,
Guid.NewGuid(),
existingMapping.ShardMapId,
existingMapping.Shard.StoreShard.Location,
existingMapping.Shard.StoreShard.Status);
IStoreMapping mappingToRemove = new DefaultStoreMapping(
existingMapping.StoreMapping.Id,
existingMapping.StoreMapping.ShardMapId,
newShard,
existingMapping.StoreMapping.MinValue,
existingMapping.StoreMapping.MaxValue,
existingMapping.StoreMapping.Status,
existingMapping.StoreMapping.LockOwnerId);
IStoreMapping[] mappingsToAdd = new IStoreMapping[2]
{
new DefaultStoreMapping(
Guid.NewGuid(),
newShard.ShardMapId,
newShard,
existingMapping.Range.Low.RawValue,
shardKey.RawValue,
(int)existingMapping.Status,
lockOwnerId),
new DefaultStoreMapping(
Guid.NewGuid(),
newShard.ShardMapId,
newShard,
shardKey.RawValue,
existingMapping.Range.High.RawValue,
(int)existingMapping.Status,
lockOwnerId)
};
using (IStoreOperation op = this.Manager.StoreOperationFactory.CreateReplaceMappingsOperation(
this.Manager,
StoreOperationCode.SplitMapping,
this.ShardMap.StoreShardMap,
new[] { new Tuple <IStoreMapping, Guid>(mappingToRemove, lockOwnerId) },
mappingsToAdd.Select(mappingToAdd => new Tuple <IStoreMapping, Guid>(mappingToAdd, lockOwnerId)).ToArray()))
{
op.Do();
}
return(mappingsToAdd
.Select(m => new RangeMapping <TKey>(this.Manager, this.ShardMap, m))
.ToList()
.AsReadOnly());
}
public RangeMapping <TKey> UpdateMapping(RangeMapping <TKey> currentMapping, RangeMappingUpdate update)
{
return(this.UpdateMapping(currentMapping, update, MappingLockToken.NoLock));
}
public IReadOnlyList <RangeMapping <TKey> > SplitMapping(RangeMapping <TKey> existingMapping, TKey splitAt)
{
return(this.SplitMapping(existingMapping, splitAt, MappingLockToken.NoLock));
}
/// <summary>
/// Adds a range mapping.
/// </summary>
/// <param name="mapping">Mapping being added.</param>
/// <returns>The added mapping object.</returns>
public RangeMapping <TKey> Add(RangeMapping <TKey> mapping)
{
return(this.Add <RangeMapping <TKey> >(
mapping,
(smm, sm, ssm) => new RangeMapping <TKey>(smm, sm, ssm)));
}
public void DeleteMapping(RangeMapping <TKey> mapping)
{
this.DeleteMapping(mapping, MappingLockToken.NoLock);
}