public void Open()
{
_server.Connect(_url, new ConnectData(new System.Net.NetworkCredential()));
var groupState = new SubscriptionState
{
Name = "Groups",
UpdateRate = 50,
Active = true
};
_group = (Subscription)_server.CreateSubscription(groupState);
_group.DataChanged += _group_DataChanged;
}
/// <summary>
/// Initializes the object with default values.
/// </summary>
public Subscription(Cache cache, Server server, SubscriptionState state)
{
if (server == null) throw new ArgumentNullException("server");
if (state == null) throw new ArgumentNullException("state");
m_cache = cache;
m_server = server;
m_state = new SubscriptionState();
m_state.Active = false;
// set the initial state.
ModifyState((int)StateMask.All, state);
}
/// <summary>
/// Initializes a new instance of the RosterItem class.
/// </summary>
/// <param name="jid">The JID of the user this item will be associated
/// with.</param>
/// <param name="name">The nickname with which to associate the JID.</param>
/// <param name="state">One of the values from the SubscriptionState
/// enumeration.</param>
/// <param name="pending">True if the user has requested subscription but
/// has not received the contact's response.</param>
/// <param name="groups">An enumerable collection of groups to categorize
/// this item in.</param>
/// <exception cref="ArgumentNullException">The jid parameter is null.</exception>
internal RosterItem(Jid jid, string name, SubscriptionState state,
bool pending, IEnumerable<string> groups) {
jid.ThrowIfNull("jid");
Jid = jid;
Name = name;
if (groups != null) {
foreach (string s in groups) {
if (String.IsNullOrEmpty(s))
continue;
this.groups.Add(s);
}
}
SubscriptionState = state;
Pending = pending;
}
public OpcClient (OpcSection opcSection, string tagGroup, EventLoggerAccess logger)
{
_logger = logger;
_OpcSection = opcSection;
_TagGroup = tagGroup;
_GroupReadState = new SubscriptionState();
_GroupReadState.Name = _OpcSection.Server.TagGroup.GetElement(_TagGroup).Name + " Read";
_GroupReadState.UpdateRate = _OpcSection.Server.TagGroup.GetElement(_TagGroup).UpdateRate;
_GroupReadState.Active = true;
_GroupWriteState = new SubscriptionState();
_GroupWriteState.Name = _OpcSection.Server.TagGroup.GetElement(_TagGroup).Name + " Write";
_GroupWriteState.Active = false;
_Items = new Item[_OpcSection.Server.TagGroup.GetElement(_TagGroup).Tags.Count];
}
public async Task Try()
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
BlittableJsonReaderObject json = await context.ReadForMemoryAsync(RequestBodyStream(), null);
SubscriptionTryout tryout = JsonDeserializationServer.SubscriptionTryout(json);
SubscriptionConnection.ParsedSubscription sub = SubscriptionConnection.ParseSubscriptionQuery(tryout.Query);
SubscriptionPatchDocument patch = null;
if (string.IsNullOrEmpty(sub.Script) == false)
{
patch = new SubscriptionPatchDocument(sub.Script, sub.Functions);
}
if (sub.Collection == null)
{
throw new ArgumentException("Collection must be specified");
}
const int maxPageSize = 1024;
var pageSize = GetIntValueQueryString("pageSize") ?? 1;
if (pageSize > maxPageSize)
{
throw new ArgumentException($"Cannot gather more than {maxPageSize} results during tryouts, but requested number was {pageSize}.");
}
var state = new SubscriptionState
{
ChangeVectorForNextBatchStartingPoint = tryout.ChangeVector,
Query = tryout.Query
};
var fetcher = new SubscriptionDocumentsFetcher(Database, int.MaxValue, -0x42,
new IPEndPoint(HttpContext.Connection.RemoteIpAddress, HttpContext.Connection.RemotePort), sub.Collection, sub.Revisions, state, patch);
var includeCmd = new IncludeDocumentsCommand(Database.DocumentsStorage, context, sub.Includes, isProjection: patch != null);
if (Enum.TryParse(
tryout.ChangeVector,
out Constants.Documents.SubscriptionChangeVectorSpecialStates changeVectorSpecialValue))
{
switch (changeVectorSpecialValue)
{
case Constants.Documents.SubscriptionChangeVectorSpecialStates.BeginningOfTime:
case Constants.Documents.SubscriptionChangeVectorSpecialStates.DoNotChange:
state.ChangeVectorForNextBatchStartingPoint = null;
break;
case Constants.Documents.SubscriptionChangeVectorSpecialStates.LastDocument:
using (context.OpenReadTransaction())
{
state.ChangeVectorForNextBatchStartingPoint = Database.DocumentsStorage.GetLastDocumentChangeVector(context.Transaction.InnerTransaction, context, sub.Collection);
}
break;
}
}
else
{
state.ChangeVectorForNextBatchStartingPoint = tryout.ChangeVector;
}
var changeVector = state.ChangeVectorForNextBatchStartingPoint.ToChangeVector();
var cv = changeVector.FirstOrDefault(x => x.DbId == Database.DbBase64Id);
var sp = Stopwatch.StartNew();
var timeLimit = TimeSpan.FromSeconds(GetIntValueQueryString("timeLimit", false) ?? 15);
var startEtag = cv.Etag;
using (var writer = new BlittableJsonTextWriter(context, ResponseBodyStream()))
using (context.OpenReadTransaction())
{
writer.WriteStartObject();
writer.WritePropertyName("Results");
writer.WriteStartArray();
var numberOfDocs = 0;
while (numberOfDocs == 0 && sp.Elapsed < timeLimit)
{
var first = true;
var lastEtag = startEtag;
foreach (var itemDetails in fetcher.GetDataToSend(context, includeCmd, startEtag))
{
if (itemDetails.Doc.Data != null)
{
using (itemDetails.Doc.Data)
{
includeCmd.Gather(itemDetails.Doc);
if (first == false)
{
writer.WriteComma();
}
if (itemDetails.Exception == null)
{
writer.WriteDocument(context, itemDetails.Doc, metadataOnly: false);
}
else
{
var documentWithException = new DocumentWithException
{
Exception = itemDetails.Exception.ToString(),
ChangeVector = itemDetails.Doc.ChangeVector,
Id = itemDetails.Doc.Id,
DocumentData = itemDetails.Doc.Data
};
writer.WriteObject(context.ReadObject(documentWithException.ToJson(), ""));
}
first = false;
if (++numberOfDocs >= pageSize)
{
break;
}
}
}
if (sp.Elapsed >= timeLimit)
{
break;
}
lastEtag = itemDetails.Doc.Etag;
}
if (startEtag == lastEtag)
{
break;
}
startEtag = lastEtag;
}
writer.WriteEndArray();
writer.WriteComma();
writer.WritePropertyName("Includes");
var includes = new List <Document>();
includeCmd.Fill(includes);
writer.WriteIncludes(context, includes);
writer.WriteEndObject();
}
}
}
protected abstract ClientMessage CreateUnsubscribeRequest(Guid subscriptionId, SubscriptionState <CollectionItemEventHandlers <T> > state);
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Subscription = new SubscriptionState();
await Subscription.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Events = new List <SquareEvent>();
TList _list345 = await iprot.ReadListBeginAsync(cancellationToken);
for (int _i346 = 0; _i346 < _list345.Count; ++_i346)
{
SquareEvent _elem347;
_elem347 = new SquareEvent();
await _elem347.ReadAsync(iprot, cancellationToken);
Events.Add(_elem347);
}
await iprot.ReadListEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
SyncToken = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.String)
{
ContinuationToken = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public Subscription(Jid jid, string node, SubscriptionState subType)
: this(jid, node)
{
this.SubscriptionState = subType;
}
public Subscription(Jid jid, string node, string subId, SubscriptionState subType) : this(jid, node, subId)
{
SubscriptionState = subType;
}
public override string GetItemId() => SubscriptionState.GenerateSubscriptionItemKeyName(DatabaseName, SubscriptionName);
/*
* Upon receiving the subscribers list, the node owner MAY modify subscription states.
* The owner MUST send only modified subscription states (i.e., a "delta"), not the complete list.
* (Note: If the 'subscription' attribute is not specified in a modification request, then the value
* MUST NOT be changed.)
*
* Example 163. Owner modifies subscriptions
*
* <iq type='set'
* from='[email protected]/elsinore'
* to='pubsub.shakespeare.lit'
* id='subman3'>
* <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
* <subscribers node='blogs/princely_musings'>
* <subscriber jid='*****@*****.**' subscription='none'/>
* </subscribers>
* </pubsub>
* </iq>
*
*/
public void OwnerModifySubscriptionState(Jid to, string node, Jid subscriber, SubscriptionState state)
{
OwnerModifySubscriptionState(to, null, node, subscriber, state, null, null);
}
public Subscription(Jid jid, string node, SubscriptionState subType) : this(jid, node)
{
SubscriptionState = subType;
}
public IEnumerable <SubscriptionGeneralDataAndStats> GetAllSubscriptions(TransactionOperationContext serverStoreContext, bool history, int start, int take)
{
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(serverStoreContext, SubscriptionState.SubscriptionPrefix(_db.Name)))
{
if (start > 0)
{
start--;
continue;
}
if (take-- <= 0)
{
yield break;
}
var subscriptionState = JsonDeserializationClient.SubscriptionState(keyValue.Value);
var subscriptionGeneralData = new SubscriptionGeneralDataAndStats(subscriptionState);
GetSubscriptionInternal(subscriptionGeneralData, history);
yield return(subscriptionGeneralData);
}
}
public void HandleDatabaseRecordChange(DatabaseRecord databaseRecord)
{
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
foreach (var subscriptionStateKvp in _subscriptionConnectionStates)
{
var subscriptionName = subscriptionStateKvp.Value.Connection?.Options?.SubscriptionName;
if (subscriptionName == null)
{
continue;
}
var subscriptionBlittable = _serverStore.Cluster.Read(context, SubscriptionState.GenerateSubscriptionItemKeyName(databaseRecord.DatabaseName, subscriptionName));
if (subscriptionBlittable == null)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionDoesNotExistException($"The subscription {subscriptionName} had been deleted"));
continue;
}
var subscriptionState = JsonDeserializationClient.SubscriptionState(subscriptionBlittable);
if (subscriptionState.Disabled)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionClosedException($"The subscription {subscriptionName} is disabled and cannot be used until enabled"));
continue;
}
SubscriptionConnection connection = subscriptionStateKvp.Value.Connection;
if (connection != null && subscriptionState.Query != connection.SubscriptionState.Query)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionClosedException($"The subscription {subscriptionName} query has been modified, connection must be restarted", canReconnect: true));
continue;
}
var whoseTaskIsIt = _db.WhoseTaskIsIt(databaseRecord.Topology, subscriptionState, subscriptionState);
if (whoseTaskIsIt != _serverStore.NodeTag)
{
DropSubscriptionConnection(subscriptionStateKvp.Key,
new SubscriptionDoesNotBelongToNodeException("Subscription operation was stopped, because it's now under different server's responsibility"));
}
}
}
}
/*
Upon receiving the subscribers list, the node owner MAY modify subscription states.
The owner MUST send only modified subscription states (i.e., a "delta"), not the complete list.
(Note: If the 'subscription' attribute is not specified in a modification request, then the value
MUST NOT be changed.)
Example 163. Owner modifies subscriptions
<iq type='set'
from='[email protected]/elsinore'
to='pubsub.shakespeare.lit'
id='subman3'>
<pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
<subscribers node='blogs/princely_musings'>
<subscriber jid='*****@*****.**' subscription='none'/>
</subscribers>
</pubsub>
</iq>
*/
public void OwnerModifySubscriptionState(Jid to, string node, Jid subscriber, SubscriptionState state)
{
OwnerModifySubscriptionState(to, null, node, subscriber, state, null, null);
}
public Subscriber(Jid jid, SubscriptionState sub)
: this()
{
this.Jid = jid;
this.SubscriptionState = sub;
}
public void OwnerModifySubscriptionState(Jid to, Jid from, string node, Jid subscriber, SubscriptionState state, IqCB cb, object cbArgs)
{
owner.PubSubIq pubsubIq = new owner.PubSubIq(IqType.set, to);
if (from != null)
pubsubIq.From = from;
owner.Subscribers subs = new owner.Subscribers(node);
subs.AddSubscriber(new owner.Subscriber(subscriber, state));
pubsubIq.PubSub.Subscribers = subs;
if (cb == null)
m_connection.Send(pubsubIq);
else
m_connection.IqGrabber.SendIq(pubsubIq, cb, cbArgs);
}
public Subscription(Jid jid, string node, string subId, SubscriptionState subType) : this(jid, node, subId)
{
this.SubscriptionState = subType;
}
public void OwnerModifySubscriptionState(Jid to, string node, Jid subscriber, SubscriptionState state, IqCB cb, object cbArgs)
{
OwnerModifySubscriptionState(to, null, node, subscriber, state, cb, cbArgs);
}
public void HandleDatabaseValueChange(DatabaseRecord databaseRecord)
{
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
foreach (var subscriptionStateKvp in _subscriptionConnectionStates)
{
var subscriptionName = subscriptionStateKvp.Value.Connection?.Options?.SubscriptionName;
if (subscriptionName == null)
{
continue;
}
var subscriptionBlittable = _serverStore.Cluster.Read(context, SubscriptionState.GenerateSubscriptionItemKeyName(databaseRecord.DatabaseName, subscriptionName));
if (subscriptionBlittable == null)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionDoesNotExistException($"The subscription {subscriptionName} had been deleted"));
continue;
}
var subscriptionState = JsonDeserializationClient.SubscriptionState(subscriptionBlittable);
if (subscriptionState.Disabled)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionClosedException($"The subscription {subscriptionName} is disabled and cannot be used until enabled"));
continue;
}
if (subscriptionState.Query != subscriptionStateKvp.Value.Connection.SubscriptionState.Query)
{
DropSubscriptionConnection(subscriptionStateKvp.Key, new SubscriptionClosedException($"The subscription {subscriptionName} query has been modified, connection must be restarted"));
}
if (databaseRecord.Topology.WhoseTaskIsIt(subscriptionState, _serverStore.IsPassive()) != _serverStore.NodeTag)
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Disconnected subscription with id {subscriptionStateKvp.Key}, because it was is no longer managed by this node ({_serverStore.NodeTag})");
}
RedirectSubscriptionConnection(subscriptionStateKvp.Key, "Subscription operation was stopped, because it's now under different server's responsibility");
}
}
}
}
public void OwnerModifySubscriptionState(Jid to, Jid from, string node, Jid subscriber, SubscriptionState state, IqCB cb)
{
OwnerModifySubscriptionState(to, from, node, subscriber, state, cb, null);
}
public virtual IDisposable Subscribe(ISubscriber subscriber, string cursor, Func<MessageResult, object, Task<bool>> callback, int maxMessages, object state)
{
if (subscriber == null)
{
throw new ArgumentNullException("subscriber");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
Subscription subscription = CreateSubscription(subscriber, cursor, callback, maxMessages, state);
// Set the subscription for this subscriber
subscriber.Subscription = subscription;
var topics = new HashSet<Topic>();
foreach (var key in subscriber.EventKeys)
{
// Create or retrieve topic and set it as HasSubscriptions
Topic topic = SubscribeTopic(key);
// Set the subscription for this topic
subscription.SetEventTopic(key, topic);
topics.Add(topic);
}
subscriber.EventKeyAdded += _addEvent;
subscriber.EventKeyRemoved += _removeEvent;
subscriber.WriteCursor = subscription.WriteCursor;
var subscriptionState = new SubscriptionState(subscriber);
var disposable = new DisposableAction(_disposeSubscription, subscriptionState);
// When the subscription itself is disposed then dispose it
subscription.Disposable = disposable;
// Add the subscription when it's all set and can be scheduled
// for work. It's important to do this after everything is wired up for the
// subscription so that publishes can schedule work at the right time.
foreach (var topic in topics)
{
topic.AddSubscription(subscription);
}
subscriptionState.Initialized.Set();
// If there's a cursor then schedule work for this subscription
if (!String.IsNullOrEmpty(cursor))
{
_broker.Schedule(subscription);
}
return disposable;
}
public void OwnerModifySubscriptionState(Jid to, Jid from, string node, Jid subscriber, SubscriptionState state, IqCB cb, object cbArgs)
{
owner.PubSubIq pubsubIq = new owner.PubSubIq(IqType.set, to);
if (from != null)
{
pubsubIq.From = from;
}
owner.Subscribers subs = new owner.Subscribers(node);
subs.AddSubscriber(new owner.Subscriber(subscriber, state));
pubsubIq.PubSub.Subscribers = subs;
if (cb == null)
{
m_connection.Send(pubsubIq);
}
else
{
m_connection.IqGrabber.SendIq(pubsubIq, cb, cbArgs);
}
}
public void OwnerModifySubscriptionState(Jid to, Jid from, string node, Jid subscriber, SubscriptionState state, IqCB cb)
{
OwnerModifySubscriptionState(to, from, node, subscriber, state, cb, null);
}
public Task GetOngoingTaskInfo()
{
if (ResourceNameValidator.IsValidResourceName(Database.Name, ServerStore.Configuration.Core.DataDirectory.FullPath, out string errorMessage) == false)
{
throw new BadRequestException(errorMessage);
}
var key = GetLongQueryString("key");
var typeStr = GetQueryStringValueAndAssertIfSingleAndNotEmpty("type");
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
using (context.OpenReadTransaction())
{
var clusterTopology = ServerStore.GetClusterTopology(context);
var record = ServerStore.Cluster.ReadDatabase(context, Database.Name);
var dbTopology = record?.Topology;
if (Enum.TryParse <OngoingTaskType>(typeStr, true, out var type) == false)
{
throw new ArgumentException($"Unknown task type: {type}", "type");
}
string tag;
switch (type)
{
case OngoingTaskType.Replication:
var watcher = record?.ExternalReplication.Find(x => x.TaskId == key);
if (watcher == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
tag = dbTopology?.WhoseTaskIsIt(watcher, ServerStore.IsPassive());
var replicationTaskInfo = new OngoingTaskReplication
{
TaskId = watcher.TaskId,
TaskName = watcher.Name,
ResponsibleNode = new NodeId
{
NodeTag = tag,
NodeUrl = clusterTopology.GetUrlFromTag(tag)
},
DestinationDatabase = watcher.Database,
TaskState = watcher.Disabled ? OngoingTaskState.Disabled : OngoingTaskState.Enabled,
DestinationUrl = watcher.Url
};
WriteResult(context, replicationTaskInfo);
break;
case OngoingTaskType.Backup:
var backupConfiguration = record?.PeriodicBackups?.Find(x => x.TaskId == key);
if (backupConfiguration == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
tag = dbTopology?.WhoseTaskIsIt(backupConfiguration, ServerStore.IsPassive());
var backupDestinations = GetBackupDestinations(backupConfiguration);
var backupStatus = Database.PeriodicBackupRunner.GetBackupStatus(key);
var nextBackup = Database.PeriodicBackupRunner.GetNextBackupDetails(record, backupConfiguration, backupStatus);
var backupTaskInfo = new OngoingTaskBackup
{
TaskId = backupConfiguration.TaskId,
BackupType = backupConfiguration.BackupType,
TaskName = backupConfiguration.Name,
TaskState = backupConfiguration.Disabled ? OngoingTaskState.Disabled : OngoingTaskState.Enabled,
ResponsibleNode = new NodeId
{
NodeTag = tag,
NodeUrl = clusterTopology.GetUrlFromTag(tag)
},
BackupDestinations = backupDestinations,
LastFullBackup = backupStatus.LastFullBackup,
LastIncrementalBackup = backupStatus.LastIncrementalBackup,
NextBackup = nextBackup
};
WriteResult(context, backupTaskInfo);
break;
case OngoingTaskType.SqlEtl:
var sqlEtl = record?.SqlEtls?.Find(x => x.TaskId == key);
if (sqlEtl == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
WriteResult(context, new OngoingTaskSqlEtl
{
TaskId = sqlEtl.TaskId,
TaskName = sqlEtl.Name,
Configuration = sqlEtl
});
break;
case OngoingTaskType.RavenEtl:
var ravenEtl = record?.RavenEtls?.Find(x => x.TaskId == key);
if (ravenEtl == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
WriteResult(context, new OngoingTaskRavenEtl
{
TaskId = ravenEtl.TaskId,
TaskName = ravenEtl.Name,
Configuration = ravenEtl
});
break;
case OngoingTaskType.Subscription:
var nameKey = GetQueryStringValueAndAssertIfSingleAndNotEmpty("taskName");
var itemKey = SubscriptionState.GenerateSubscriptionItemKeyName(record.DatabaseName, nameKey);
var doc = ServerStore.Cluster.Read(context, itemKey);
if (doc == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
var subscriptionState = JsonDeserializationClient.SubscriptionState(doc);
tag = dbTopology?.WhoseTaskIsIt(subscriptionState, ServerStore.IsPassive());
var subscriptionStateInfo = new SubscriptionStateWithNodeDetails
{
Query = subscriptionState.Query,
ChangeVectorForNextBatchStartingPoint = subscriptionState.ChangeVectorForNextBatchStartingPoint,
SubscriptionId = subscriptionState.SubscriptionId,
SubscriptionName = subscriptionState.SubscriptionName,
LastTimeServerMadeProgressWithDocuments = subscriptionState.LastTimeServerMadeProgressWithDocuments,
Disabled = subscriptionState.Disabled,
LastClientConnectionTime = subscriptionState.LastClientConnectionTime,
ResponsibleNode = new NodeId
{
NodeTag = tag,
NodeUrl = clusterTopology.GetUrlFromTag(tag)
}
};
// Todo: here we'll need to talk with the running node? TaskConnectionStatus = subscriptionState.Disabled ? OngoingTaskConnectionStatus.NotActive : OngoingTaskConnectionStatus.Active,
WriteResult(context, subscriptionStateInfo.ToJson());
break;
default:
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
}
}
}
return(Task.CompletedTask);
}
public async Task SubscripitonDeletionFromCluster()
{
const int nodesAmount = 5;
var leader = await this.CreateRaftClusterAndGetLeader(nodesAmount);
var defaultDatabase = "ContinueFromThePointIStopped";
await CreateDatabaseInCluster(defaultDatabase, nodesAmount, leader.WebUrl).ConfigureAwait(false);
using (var store = new DocumentStore
{
Urls = new[] { leader.WebUrl },
Database = defaultDatabase
}.Initialize())
{
var usersCount = new List <User>();
var reachedMaxDocCountMre = new AsyncManualResetEvent();
var subscriptionId = await store.Subscriptions.CreateAsync <User>();
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User
{
Name = "Peter"
});
await session.SaveChangesAsync();
}
var subscription = store.Subscriptions.GetSubscriptionWorker <User>(new SubscriptionWorkerOptions(subscriptionId)
{
TimeToWaitBeforeConnectionRetry = TimeSpan.FromSeconds(5)
});
subscription.AfterAcknowledgment += b => { reachedMaxDocCountMre.Set(); return(Task.CompletedTask); };
GC.KeepAlive(subscription.Run(x => { }));
await reachedMaxDocCountMre.WaitAsync();
foreach (var ravenServer in Servers)
{
using (ravenServer.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
Assert.NotNull(ravenServer.ServerStore.Cluster.Read(context, SubscriptionState.GenerateSubscriptionItemKeyName(defaultDatabase, subscriptionId.ToString())));
}
}
await subscription.DisposeAsync();
var deleteResult = store.Maintenance.Server.Send(new DeleteDatabasesOperation(defaultDatabase, hardDelete: true));
foreach (var ravenServer in Servers)
{
await ravenServer.ServerStore.WaitForCommitIndexChange(RachisConsensus.CommitIndexModification.GreaterOrEqual, deleteResult.RaftCommandIndex + nodesAmount).WaitWithTimeout(TimeSpan.FromSeconds(60));
}
Thread.Sleep(2000);
foreach (var ravenServer in Servers)
{
using (ravenServer.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
Assert.Null(ravenServer.ServerStore.Cluster.Read(context, SubscriptionState.GenerateSubscriptionItemKeyName(defaultDatabase, subscriptionId.ToString())));
}
}
}
}
private static IEnumerable <OngoingTask> CollectSubscriptionTasks(TransactionOperationContext context, DatabaseRecord databaseRecord, ClusterTopology clusterTopology, ServerStore store)
{
foreach (var keyValue in ClusterStateMachine.ReadValuesStartingWith(context, SubscriptionState.SubscriptionPrefix(databaseRecord.DatabaseName)))
{
var subscriptionState = JsonDeserializationClient.SubscriptionState(keyValue.Value);
var tag = databaseRecord.Topology.WhoseTaskIsIt(subscriptionState, store.IsPassive());
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 Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Subscription = new SubscriptionState();
Subscription.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List)
{
{
Events = new List <SquareEvent>();
TList _list349 = iprot.ReadListBegin();
for (int _i350 = 0; _i350 < _list349.Count; ++_i350)
{
SquareEvent _elem351;
_elem351 = new SquareEvent();
_elem351.Read(iprot);
Events.Add(_elem351);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
SyncToken = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
ContinuationToken = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
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 async Task Try()
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
var json = await context.ReadForMemoryAsync(RequestBodyStream(), null);
var tryout = JsonDeserializationServer.SubscriptionTryout(json);
var(collection, (script, functions), revisions) = SubscriptionConnection.ParseSubscriptionQuery(tryout.Query);
SubscriptionPatchDocument patch = null;
if (string.IsNullOrEmpty(script) == false)
{
patch = new SubscriptionPatchDocument(script, functions);
}
if (collection == null)
{
throw new ArgumentException("Collection must be specified");
}
var pageSize = GetIntValueQueryString("pageSize") ?? 1;
var fetcher = new SubscriptionDocumentsFetcher(Database, pageSize, -0x42,
new IPEndPoint(HttpContext.Connection.RemoteIpAddress, HttpContext.Connection.RemotePort));
var state = new SubscriptionState
{
ChangeVectorForNextBatchStartingPoint = tryout.ChangeVector,
Query = tryout.Query
};
if (Enum.TryParse(
tryout.ChangeVector,
out Constants.Documents.SubscriptionChangeVectorSpecialStates changeVectorSpecialValue))
{
switch (changeVectorSpecialValue)
{
case Constants.Documents.SubscriptionChangeVectorSpecialStates.BeginningOfTime:
case Constants.Documents.SubscriptionChangeVectorSpecialStates.DoNotChange:
state.ChangeVectorForNextBatchStartingPoint = null;
break;
case Constants.Documents.SubscriptionChangeVectorSpecialStates.LastDocument:
state.ChangeVectorForNextBatchStartingPoint = Database.DocumentsStorage.GetLastDocumentChangeVector(context, collection);
break;
}
}
using (var writer = new BlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WritePropertyName("Results");
writer.WriteStartArray();
using (context.OpenReadTransaction())
{
var first = true;
foreach (var itemDetails in fetcher.GetDataToSend(context, collection, revisions, state, patch, 0))
{
if (itemDetails.Doc.Data == null)
{
continue;
}
if (first == false)
{
writer.WriteComma();
}
if (itemDetails.Exception == null)
{
writer.WriteDocument(context, itemDetails.Doc, metadataOnly: false);
}
else
{
var docWithExcepton = new DocumentWithException
{
Exception = itemDetails.Exception.ToString(),
ChangeVector = itemDetails.Doc.ChangeVector,
Id = itemDetails.Doc.Id,
DocumentData = itemDetails.Doc.Data
};
writer.WriteObject(context.ReadObject(docWithExcepton.ToJson(), ""));
}
first = false;
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
}
}
public override void AddContexMenuItems(ref string CurrentGroup, ContextMenu Menu)
{
base.AddContexMenuItems(ref CurrentGroup, Menu);
XmppAccountNode XmppAccountNode = this.XmppAccountNode;
if (XmppAccountNode != null && XmppAccountNode.IsOnline)
{
SubscriptionState SubscriptionState = this.SubscriptionState;
MenuItem MenuItem;
string s;
if (SubscriptionState == SubscriptionState.None || SubscriptionState == SubscriptionState.From)
{
CurrentGroup = "Subscriptions";
if (SubscriptionState == SubscriptionState.None)
{
s = "../Graphics/To.png";
}
else
{
s = "../Graphics/Both.png";
}
Menu.Items.Add(MenuItem = new MenuItem()
{
Header = "_Subscribe to",
IsEnabled = true,
Icon = new Image()
{
Source = new BitmapImage(new Uri(s, UriKind.Relative)),
Width = 16,
Height = 16
}
});
MenuItem.Click += Subscribe_Click;
}
if (SubscriptionState == SubscriptionState.To || SubscriptionState == SubscriptionState.Both)
{
CurrentGroup = "Subscriptions";
if (SubscriptionState == SubscriptionState.To)
{
s = "../Graphics/None.png";
}
else
{
s = "../Graphics/From.png";
}
Menu.Items.Add(MenuItem = new MenuItem()
{
Header = "_Unsubscribe from",
IsEnabled = true,
Icon = new Image()
{
Source = new BitmapImage(new Uri(s, UriKind.Relative)),
Width = 16,
Height = 16
}
});
MenuItem.Click += Unsubscribe_Click;
}
}
}
protected abstract bool ReadUnsubscribeResponse(ClientMessage unsubscribeResponseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state);
public async Task InitAsync()
{
await ParseSubscriptionOptionsAsync();
if (_logger.IsInfoEnabled)
{
_logger.Info(
$"Subscription connection for subscription ID: {SubscriptionId} received from {TcpConnection.TcpClient.Client.RemoteEndPoint}");
}
// first, validate details and make sure subscription exists
SubscriptionState = await TcpConnection.DocumentDatabase.SubscriptionStorage.AssertSubscriptionConnectionDetails(SubscriptionId, _options.SubscriptionName);
_connectionState = TcpConnection.DocumentDatabase.SubscriptionStorage.OpenSubscription(this);
var timeout = TimeSpan.FromMilliseconds(16);
bool shouldRetry = false;
do
{
try
{
DisposeOnDisconnect = await _connectionState.RegisterSubscriptionConnection(this, timeout);
shouldRetry = false;
}
catch (TimeoutException)
{
if (timeout == TimeSpan.Zero && _logger.IsInfoEnabled)
{
_logger.Info(
$"Subscription Id {SubscriptionId} from IP {TcpConnection.TcpClient.Client.RemoteEndPoint} starts to wait until previous connection from {_connectionState.Connection?.TcpConnection.TcpClient.Client.RemoteEndPoint} is released");
}
timeout = TimeSpan.FromMilliseconds(Math.Max(250, (long)_options.TimeToWaitBeforeConnectionRetry.TotalMilliseconds / 2));
await SendHeartBeat();
shouldRetry = true;
}
} while (shouldRetry);
// refresh subscription data (change vector may have been updated, because in the meanwhile, another subscription could have just completed a batch)
SubscriptionState = await TcpConnection.DocumentDatabase.SubscriptionStorage.AssertSubscriptionConnectionDetails(SubscriptionId, _options.SubscriptionName);
(Collection, (Script, Functions), Revisions) = ParseSubscriptionQuery(SubscriptionState.Query);
try
{
await SendNoopAck();
await WriteJsonAsync(new DynamicJsonValue
{
[nameof(SubscriptionConnectionServerMessage.Type)] = nameof(SubscriptionConnectionServerMessage.MessageType.ConnectionStatus),
[nameof(SubscriptionConnectionServerMessage.Status)] = nameof(SubscriptionConnectionServerMessage.ConnectionStatus.Accepted)
});
Stats.ConnectedAt = DateTime.UtcNow;
await TcpConnection.DocumentDatabase.SubscriptionStorage.UpdateClientConnectionTime(SubscriptionState.SubscriptionId,
SubscriptionState.SubscriptionName, SubscriptionState.MentorNode);
}
catch
{
DisposeOnDisconnect.Dispose();
}
}
protected abstract Guid ReadSubscribeResponse(ClientMessage responseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state);
protected override ClientMessage CreateUnsubscribeRequest(Guid subscriptionId, SubscriptionState <CollectionItemEventHandlers <T> > state) => ListRemoveListenerCodec.EncodeRequest(Name, subscriptionId);
public Subscriber(Jid jid, SubscriptionState sub) : this()
{
this.Jid = jid;
this.SubscriptionState = sub;
}
protected override Guid ReadSubscribeResponse(ClientMessage responseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state) => ListAddListenerCodec.DecodeResponse(responseMessage).Response;
public Subscription(Jid jid, SubscriptionState subType) : this(jid)
{
SubscriptionState = subType;
}
private void releaseLastMessage(SubscriptionState subState)
{
if (subState.lastSentMessage != null)
{
subState.lastSentMessage.Close();
subState.lastSentMessage = null;
}
}
/// <summary>
/// Initializes a new instance of the PrivacyRule class.
/// </summary>
/// <param name="state">The subscription state the privacy rule applies
/// to.</param>
/// <param name="allow">True to block entities affected by this rule; Otherwise
/// false.</param>
/// <param name="order">The order of the privacy rule.</param>
/// <param name="granularity">Specifies which kinds of stanzas are to be
/// blocked.</param>
public SubscriptionPrivacyRule(SubscriptionState state, bool allow, uint order,
PrivacyGranularity granularity = 0)
: base(allow, order, granularity)
{
SubscriptionState = state;
}
protected Task SubscribeAsync(RpcRequest rpcRequest)
{
if (SubscriptionState != SubscriptionState.Idle)
{
throw new Exception("Invalid state to start subscription, current state: " + SubscriptionState.ToString());
}
SubscribeRequestId = rpcRequest.Id;
this.SubscriptionState = SubscriptionState.Subscribing;
return(StreamingClient.SendRequestAsync(rpcRequest, this));
}
public Subscription(Jid jid, SubscriptionState subType) : this(jid)
{
SubscriptionState = subType;
}
public Task UnsubscribeAsync()
{
if (SubscriptionState != SubscriptionState.Subscribed && SubscriptionState != SubscriptionState.Unsubscribed) //allow retrying? what happens when it returns false the unsubscription
{
throw new Exception("Invalid state to unsubscribe, current state: " + SubscriptionState.ToString());
}
UnsubscribeRequestId = Guid.NewGuid().ToString();
var request = UnsubscribeSubscriptionRpcRequestBuilder.BuildRequest(SubscriptionId, UnsubscribeRequestId);
this.SubscriptionState = SubscriptionState.Unsubscribing;
return(StreamingClient.SendRequestAsync(request, this));
}
protected override bool ReadUnsubscribeResponse(ClientMessage unsubscribeResponseMessage, SubscriptionState <CollectionItemEventHandlers <T> > state) => ListRemoveListenerCodec.DecodeResponse(unsubscribeResponseMessage).Response;
public void OwnerModifySubscriptionState(Jid to, string node, Jid subscriber, SubscriptionState state, IqCB cb, object cbArgs)
{
OwnerModifySubscriptionState(to, null, node, subscriber, state, cb, cbArgs);
}
