public long FindFreeId(ClusterOperationContext context, long subscriptionId)
{
if (SubscriptionId.HasValue)
{
return(SubscriptionId.Value);
}
bool idTaken;
do
{
idTaken = false;
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(context,
SubscriptionState.SubscriptionPrefix(DatabaseName)))
{
if (keyValue.Value.TryGet(nameof(SubscriptionState.SubscriptionId), out long id) == false)
{
continue;
}
if (id == subscriptionId)
{
subscriptionId--; // we don't care if this end up as a negative value, we need only to be unique
idTaken = true;
break;
}
}
} while (idTaken);
return(subscriptionId);
}
public long GetAllSubscriptionsCount()
{
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
return(ClusterStateMachine.ReadValuesStartingWith(context, SubscriptionState.SubscriptionPrefix(_db.Name))
.Count());
}
}
public IEnumerable <SubscriptionGeneralDataAndStats> GetAllSubscriptions(TransactionOperationContext serverStoreContext, bool history, int start, int take)
{
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(serverStoreContext,
SubscriptionState.SubscriptionPrefix(_db.Name)))
{
var subscriptionState = JsonDeserializationClient.SubscriptionState(keyValue.Value);
var subscriptionGeneralData = new SubscriptionGeneralDataAndStats(subscriptionState);
GetSubscriptionInternal(subscriptionGeneralData, history);
yield return(subscriptionGeneralData);
}
}
public string GetSubscriptionNameById(TransactionOperationContext serverStoreContext, long id)
{
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(serverStoreContext,
SubscriptionState.SubscriptionPrefix(_db.Name)))
{
if (keyValue.Value.TryGet(nameof(SubscriptionState.SubscriptionId), out long _id) == false)
{
continue;
}
if (_id == id)
{
if (keyValue.Value.TryGet(nameof(SubscriptionState.SubscriptionName), out string name))
{
return(name);
}
}
}
return(null);
}
private IEnumerable <OngoingTask> CollectSubscriptionTasks(TransactionOperationContext context, DatabaseRecord databaseRecord, ClusterTopology clusterTopology)
{
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(context, SubscriptionState.SubscriptionPrefix(databaseRecord.DatabaseName)))
{
var subscriptionState = JsonDeserializationClient.SubscriptionState(keyValue.Value);
var tag = databaseRecord.Topology.WhoseTaskIsIt(subscriptionState, ServerStore.Engine.CurrentState);
yield return(new OngoingTaskSubscription
{
// Supply only needed fields for List View
ResponsibleNode = new NodeId
{
NodeTag = tag,
NodeUrl = clusterTopology.GetUrlFromTag(tag)
},
TaskName = subscriptionState.SubscriptionName,
TaskState = subscriptionState.Disabled ? OngoingTaskState.Disabled : OngoingTaskState.Enabled,
TaskId = subscriptionState.SubscriptionId,
Query = subscriptionState.Query
});
}
}
public void RavenDB_13724()
{
var folder = NewDataPath(forceCreateDir: true, prefix: Guid.NewGuid().ToString());
DoNotReuseServer();
var zipPath = new PathSetting("SchemaUpgrade/Issues/SystemVersion/RavenDB_13724.zip");
Assert.True(File.Exists(zipPath.FullPath));
ZipFile.ExtractToDirectory(zipPath.FullPath, folder);
using (var server = GetNewServer(new ServerCreationOptions {
DeletePrevious = false, RunInMemory = false, DataDirectory = folder, RegisterForDisposal = false
}))
using (server.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
var db = server.ServerStore.Cluster.GetDatabaseNames(context).Single();
var ids = new HashSet <long>();
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(context, SubscriptionState.SubscriptionPrefix(db)))
{
var state = JsonDeserializationClient.SubscriptionState(keyValue.Value);
Assert.True(ids.Add(state.SubscriptionId));
}
}
}
public bool Update(UpdateStep step)
{
var ids = new HashSet <long>();
var minimal = long.MaxValue;
const string dbKey = "db/";
var continueAfterCommit = true;
var skip = 0;
while (continueAfterCommit)
{
continueAfterCommit = false;
var fixedItems = 0;
var items = step.WriteTx.OpenTable(ClusterStateMachine.ItemsSchema, ClusterStateMachine.Items);
using (Slice.From(step.WriteTx.Allocator, dbKey, out Slice loweredPrefix))
{
foreach (var result in items.SeekByPrimaryKeyPrefix(loweredPrefix, Slices.Empty, 0))
{
var databaseName = ClusterStateMachine.GetCurrentItemKey(result.Value).Substring(3);
using (Slice.From(step.WriteTx.Allocator, dbKey + databaseName.ToLowerInvariant(), out var key))
{
if (items.VerifyKeyExists(key) == false)
{
continue;
}
}
using (Slice.From(step.WriteTx.Allocator, SubscriptionState.SubscriptionPrefix(databaseName), out var startWith))
using (var ctx = JsonOperationContext.ShortTermSingleUse())
{
foreach (var holder in items.SeekByPrimaryKeyPrefix(startWith, Slices.Empty, skip))
{
skip++;
var reader = holder.Value.Reader;
var ptr = reader.Read(2, out int size);
using (var doc = new BlittableJsonReaderObject(ptr, size, ctx))
{
if (doc.TryGet(nameof(SubscriptionState.SubscriptionId), out long id) == false)
{
continue;
}
if (minimal > id)
{
minimal = id;
}
if (ids.Add(id))
{
continue;
}
minimal--;
ids.Add(minimal);
var subscriptionState = JsonDeserializationClient.SubscriptionState(doc);
subscriptionState.SubscriptionId = minimal;
var subscriptionItemName = SubscriptionState.GenerateSubscriptionItemKeyName(databaseName, subscriptionState.SubscriptionName);
using (Slice.From(step.WriteTx.Allocator, subscriptionItemName, out Slice valueName))
using (Slice.From(step.WriteTx.Allocator, subscriptionItemName.ToLowerInvariant(), out Slice valueNameLowered))
using (var receivedSubscriptionState = ctx.ReadObject(subscriptionState.ToJson(), subscriptionState.SubscriptionName))
{
ClusterStateMachine.UpdateValue(0, items, valueNameLowered, valueName, receivedSubscriptionState);
}
}
fixedItems++;
if (fixedItems < 1024)
{
continue;
}
continueAfterCommit = true;
break;
}
}
if (continueAfterCommit)
{
break;
}
}
}
if (continueAfterCommit)
{
step.Commit(null);
step.RenewTransactions();
}
}
return(true);
}
private static long GetSubscriptionCountOnNode(DocumentDatabase database, DatabaseRecord dbRecord, ServerStore serverStore, TransactionOperationContext context)
{
long taskCountOnNode = 0;
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(context, SubscriptionState.SubscriptionPrefix(database.Name)))
{
var subscriptionState = JsonDeserializationClient.SubscriptionState(keyValue.Value);
var taskTag = database.WhoseTaskIsIt(dbRecord.Topology, subscriptionState, subscriptionState);
if (serverStore.NodeTag == taskTag)
{
taskCountOnNode++;
}
}
return(taskCountOnNode);
}
