private void OnDatabaseChanged(object sender, DatabaseChangeEventArgs e)
{
if (_willUpdate)
{
return;
}
var updateInterval = _updateInterval * 2;
foreach (var change in e.Changes)
{
if (change.SourceUrl == null)
{
updateInterval /= 2;
break;
}
}
_willUpdate = true;
var updateDelay = ((_lastUpdatedAt + TimeSpan.FromSeconds(updateInterval)) - DateTime.Now).TotalSeconds;
updateDelay = Math.Max(0, Math.Min(_updateInterval, updateDelay));
Log.To.Query.I(TAG, "{0} will update after {1} sec...", this, updateDelay);
Task.Delay(TimeSpan.FromSeconds(updateDelay)).ContinueWith(t =>
{
if (_willUpdate)
{
Update();
}
});
}
private void OnChanged(Object sender, DatabaseChangeEventArgs args)
{
var changes = args.Changes;
foreach (DocumentChange change in changes)
{
// Skip expired documents
if (change.IsExpiration)
{
return;
}
// Skip revisions that originally came from the database I'm syncing to:
var source = change.SourceUrl;
if (source != null && source.Equals(RemoteUrl))
{
return;
}
var rev = change.AddedRevision;
if (LocalDatabase.RunFilter(_filter, FilterParams, rev))
{
Log.To.Sync.V(TAG, "{0} queuing {1} {2}", this, LocalDatabase.GetSequence(rev), rev);
AddToInbox(rev);
}
}
}
private void OnDatabaseChanged(object sender, DatabaseChangeEventArgs e)
{
if (_willUpdate)
{
return;
}
var updateInterval = _updateInterval * 2;
foreach (var change in e.Changes)
{
if (change.SourceUrl == null)
{
updateInterval /= 2;
break;
}
}
_willUpdate = true;
Log.D(TAG, "Will update after {0} sec...", updateInterval);
Task.Delay(TimeSpan.FromSeconds(updateInterval)).ContinueWith(t =>
{
if (_willUpdate)
{
Update();
}
});
}
private void Db_Changed(object sender, DatabaseChangeEventArgs e)
{
foreach (var change in e.Changes)
{
DatabaseChanged(this, new DatabaseChangedEventArgs(change.DocumentId));
}
}
// Processes a change in the subscribed database
private void DatabaseChanged(object sender, DatabaseChangeEventArgs args)
{
if (ChangesFeedMode == ChangesFeedMode.LongPoll)
{
// Only send changes if it is the first VALID time (i.e. has at least one change
// and hasn't started another write yet)
var changes = Db.ChangesSince(_since, _options, ChangesFilter, FilterParams);
if (changes.Count > 0 && Interlocked.CompareExchange(ref _filled, 1, 0) == 0)
{
WriteChanges(changes);
}
return;
}
else if (Interlocked.CompareExchange(ref _filled, 1, 0) == 0)
{
// Backfill potentially missed revisions between the check for subscription need
// and actual subscription
WriteChanges(Db.ChangesSince(_since, _options, ChangesFilter, FilterParams));
return;
}
var changesToSend = new RevisionList();
foreach (var change in args.Changes)
{
var rev = change.AddedRevision;
var winningRev = change.WinningRevisionId;
if (!ChangesIncludeConflicts)
{
if (winningRev == null)
{
continue; // this change doesn't affect the winning rev ID, no need to send it
}
if (rev.Equals(winningRev))
{
// This rev made a _different_ rev current, so substitute that one.
// We need to emit the current sequence # in the feed, so put it in the rev.
// This isn't correct internally (this is an old rev so it has an older sequence)
// but consumers of the _changes feed don't care about the internal state.
if (ChangesIncludeDocs)
{
Db.LoadRevisionBody(rev);
}
}
}
if (!Db.RunFilter(ChangesFilter, FilterParams, rev))
{
continue;
}
changesToSend.Add(rev);
}
WriteChanges(changesToSend);
}
private void Cb2_Changed(object sender, DatabaseChangeEventArgs e)
{
var cb2 = Manager.SharedInstance.GetDatabase("cb2");
var docs = e.Changes
.Select(id => cb2.GetDocument(id.DocumentId))
.ToList();
Debugger.Break();
}
// Processes a change in the subscribed database
private void DatabaseChanged(object sender, DatabaseChangeEventArgs args)
{
foreach (var change in args.Changes)
{
var rev = change.AddedRevision;
var winningRev = change.WinningRevision;
if (!ChangesIncludeConflicts)
{
if (winningRev == null)
{
continue; // this change doesn't affect the winning rev ID, no need to send it
}
if (rev.Equals(winningRev))
{
// This rev made a _different_ rev current, so substitute that one.
// We need to emit the current sequence # in the feed, so put it in the rev.
// This isn't correct internally (this is an old rev so it has an older sequence)
// but consumers of the _changes feed don't care about the internal state.
if (ChangesIncludeDocs)
{
_db.LoadRevisionBody(rev, DocumentContentOptions.None);
}
}
}
if (!_db.RunFilter(ChangesFilter, null, rev))
{
continue;
}
if (ChangesFeedMode == ChangesFeedMode.LongPoll)
{
_changes.Add(rev);
}
else
{
Log.D(TAG, "Sending continuous change chunk");
var written = Response.SendContinuousLine(DatabaseMethods.ChangesDictForRev(rev, this), ChangesFeedMode);
if (!written)
{
Terminate();
}
}
}
if (ChangesFeedMode == ChangesFeedMode.LongPoll && _changes.Count > 0)
{
var body = new Body(DatabaseMethods.ResponseBodyForChanges(_changes, 0, this));
Response.WriteData(body.AsJson(), true);
CouchbaseLiteRouter.ResponseFinished(this);
}
}
// Processes a change in the subscribed database
private void DatabaseChanged(object sender, DatabaseChangeEventArgs args)
{
if (!_filled)
{
_filled = true;
WriteChanges(Db.ChangesSince(_since, _options, ChangesFilter, FilterParams));
return;
}
var changesToSend = new RevisionList();
foreach (var change in args.Changes)
{
var rev = change.AddedRevision;
var winningRev = change.WinningRevisionId;
if (!ChangesIncludeConflicts)
{
if (winningRev == null)
{
continue; // this change doesn't affect the winning rev ID, no need to send it
}
if (rev.Equals(winningRev))
{
// This rev made a _different_ rev current, so substitute that one.
// We need to emit the current sequence # in the feed, so put it in the rev.
// This isn't correct internally (this is an old rev so it has an older sequence)
// but consumers of the _changes feed don't care about the internal state.
if (ChangesIncludeDocs)
{
Db.LoadRevisionBody(rev);
}
}
}
if (!Db.RunFilter(ChangesFilter, FilterParams, rev))
{
continue;
}
changesToSend.Add(rev);
}
WriteChanges(changesToSend);
}
private void OnChanged(Object sender, DatabaseChangeEventArgs args)
{
var changes = args.Changes;
foreach (DocumentChange change in changes)
{
// Skip revisions that originally came from the database I'm syncing to:
var source = change.SourceUrl;
if (source != null && source.Equals(RemoteUrl))
{
return;
}
var rev = change.AddedRevision;
if (LocalDatabase.RunFilter(_filter, FilterParams, rev))
{
AddToInbox(rev);
}
}
}
internal void OnChanged(Object sender, DatabaseChangeEventArgs args)
{
var changes = args.Changes;
foreach (DocumentChange change in changes)
{
// Skip revisions that originally came from the database I'm syncing to:
var source = change.SourceUrl;
if (source != null && source.Equals(RemoteUrl))
{
return;
}
var rev = change.AddedRevision;
IDictionary <String, Object> paramsFixMe = null;
// TODO: these should not be null
if (LocalDatabase.RunFilter(filter, paramsFixMe, rev))
{
AddToInbox(rev);
}
}
}
private void MonitorModeratorStatus(object sender, DatabaseChangeEventArgs e)
{
if (_username == null)
{
return;
}
foreach (var change in e.Changes)
{
if (change.SourceUrl == null)
{
continue;
}
var moderatorDocId = $"moderator.{_username}";
if (change.DocumentId == moderatorDocId)
{
ModeratorStatusGained?.Invoke(this, null);
_username = null;
_db.Changed -= MonitorModeratorStatus;
}
}
}
public void DatabaseChanged(ReplicationDriverContext context, DatabaseChangeEventArgs eventArgs)
{
}
// Processes a change in the subscribed database
private void DatabaseChanged(object sender, DatabaseChangeEventArgs args)
{
foreach (var change in args.Changes) {
var rev = change.AddedRevision;
var winningRev = change.WinningRevisionId;
if (!ChangesIncludeConflicts) {
if (winningRev == null) {
continue; // this change doesn't affect the winning rev ID, no need to send it
}
if (rev.Equals(winningRev)) {
// This rev made a _different_ rev current, so substitute that one.
// We need to emit the current sequence # in the feed, so put it in the rev.
// This isn't correct internally (this is an old rev so it has an older sequence)
// but consumers of the _changes feed don't care about the internal state.
if (ChangesIncludeDocs) {
Db.LoadRevisionBody(rev);
}
}
}
if (!Db.RunFilter(ChangesFilter, FilterParams, rev)) {
continue;
}
if (ChangesFeedMode == ChangesFeedMode.LongPoll) {
_changes.Add(rev);
} else {
var written = Response.SendContinuousLine(DatabaseMethods.ChangesDictForRev(rev, this), ChangesFeedMode);
if (!written) {
Terminate();
}
}
}
if (ChangesFeedMode == ChangesFeedMode.LongPoll && _changes.Count > 0) {
var body = new Body(DatabaseMethods.ResponseBodyForChanges(_changes, 0, this));
Response.WriteData(body.AsJson(), true);
Terminate ();
}
}
private void OnDatabaseChanged(object sender, DatabaseChangeEventArgs e)
{
Log.D(Tag, "OnDatabaseChanged() called");
Update();
}
/// <summary>
/// Relays database changed events received from the underlying database.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The event arguments.</param>
private void OnDatabaseChanged(object sender, DatabaseChangeEventArgs args)
{
Changed?.Invoke(this, args);
}
private void Cb1_Changed(object sender, DatabaseChangeEventArgs e)
{
}
private void Db_Changed(object sender, DatabaseChangeEventArgs e)
{
Event = GetDocument("1");
adapt.UpdateGuestList(Event.Guests);
}
