public void RunStartSyncEvent()
{
var startSyncEvent = new StartNextSyncEvent(false);
this.AddEvent(startSyncEvent);
this.Run();
}
/// <summary>
/// Handles Config changes if the poll interval has been changed.
/// Resets also the timer if a full sync event has been recognized.
/// </summary>
/// <param name="e">Sync event.</param>
/// <returns><c>false</c> on every event.</returns>
public override bool Handle(ISyncEvent e)
{
RepoConfigChangedEvent config = e as RepoConfigChangedEvent;
if (config != null)
{
double newInterval = config.RepoInfo.PollInterval;
if (newInterval > 0 && this.interval != newInterval)
{
this.interval = newInterval;
this.Stop();
this.timer.Interval = this.interval;
this.Start();
}
return(false);
}
StartNextSyncEvent start = e as StartNextSyncEvent;
if (start != null && start.FullSyncRequested)
{
this.Stop();
this.Start();
}
return(false);
}
private void DelayNextSyncEvent(StartNextSyncEvent startNextSyncEvent)
{
this.syncHasBeenDelayed = true;
if (!this.lastDelayedSyncWasFullSync && startNextSyncEvent.FullSyncRequested == true)
{
this.lastDelayedSyncWasFullSync = true;
}
}
public void HandlesStartNextSyncEventAndReportsOnQueueIfDone()
{
var crawler = this.CreateCrawler();
var startEvent = new StartNextSyncEvent();
Assert.That(crawler.Handle(startEvent), Is.True);
this.queue.Verify(q => q.AddEvent(It.Is <FullSyncCompletedEvent>(e => e.StartEvent.Equals(startEvent))), Times.Once());
this.VerifyThatListenerHasBeenUsed();
}
public void IgnoreDuplicatedContentChangesEventTestDeleted()
{
var queue = new Mock <ISyncEventQueue>();
Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
Mock <ISession> session = MockSessionUtil.GetSessionMockReturning3Changesin2Batches(DotCMIS.Enums.ChangeType.Deleted, true);
var startSyncEvent = new StartNextSyncEvent(false);
var changes = new ContentChanges(session.Object, storage.Object, queue.Object, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(foo => foo.AddEvent(It.IsAny <ContentChangeEvent>()), Times.Exactly(3));
}
public void HandleStartSyncEventOnNoRemoteChange()
{
var startSyncEvent = new StartNextSyncEvent(false);
var session = new Mock <ISession>();
session.SetupSessionDefaultValues();
session.Setup(s => s.Binding.GetRepositoryService().GetRepositoryInfo(this.repoId, null).LatestChangeLogToken).Returns(this.changeLogToken);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns(this.changeLogToken);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsTrue(changes.Handle(startSyncEvent));
}
public void ExecuteCrawlSyncOnNoLocalTokenAvailable()
{
var startSyncEvent = new StartNextSyncEvent(false);
var session = new Mock <ISession>();
session.SetupSessionDefaultValues();
session.Setup(s => s.Binding.GetRepositoryService().GetRepositoryInfo(this.repoId, null).LatestChangeLogToken).Returns(this.changeLogToken);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns((string)null);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(q => q.AddEvent(It.Is <StartNextSyncEvent>(e => e.FullSyncRequested == true)), Times.Once());
}
public void HandleFullSyncCompletedEvent()
{
var startSyncEvent = new StartNextSyncEvent(false);
startSyncEvent.LastTokenOnServer = this.changeLogToken;
var completedEvent = new FullSyncCompletedEvent(startSyncEvent);
var storage = new Mock <IMetaDataStorage>();
storage.SetupProperty(db => db.ChangeLogToken);
var queue = new Mock <ISyncEventQueue>();
var session = new Mock <ISession>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsFalse(changes.Handle(completedEvent));
storage.VerifySet(db => db.ChangeLogToken = this.changeLogToken);
Assert.AreEqual(this.changeLogToken, storage.Object.ChangeLogToken);
}
public void IgnoreCrawlSyncEvent()
{
var start = new StartNextSyncEvent(true);
var repositoryService = new Mock <IRepositoryService>();
repositoryService.Setup(r => r.GetRepositoryInfos(null)).Returns((IList <IRepositoryInfo>)null);
repositoryService.Setup(r => r.GetRepositoryInfo(It.IsAny <string>(), It.IsAny <IExtensionsData>()).LatestChangeLogToken).Returns(this.latestChangeLogToken);
var session = new Mock <ISession>();
session.Setup(s => s.Binding.GetRepositoryService()).Returns(repositoryService.Object);
session.Setup(s => s.RepositoryInfo.Id).Returns(this.repoId);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns(this.changeLogToken);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsFalse(changes.Handle(start));
Assert.IsNull(start.LastTokenOnServer);
}
/// <summary>
/// Handle the specified e.
/// </summary>
/// <param name="e">The event to handle.</param>
/// <returns>true if handled</returns>
public override bool Handle(ISyncEvent e)
{
StartNextSyncEvent syncEvent = e as StartNextSyncEvent;
if (syncEvent != null)
{
if (syncEvent.FullSyncRequested)
{
// Get last change log token on server side.
string lastRemoteChangeLogTokenBeforeFullCrawlSync = this.session.Binding.GetRepositoryService().GetRepositoryInfo(this.session.RepositoryInfo.Id, null).LatestChangeLogToken;
if (this.storage.ChangeLogToken == null)
{
syncEvent.LastTokenOnServer = lastRemoteChangeLogTokenBeforeFullCrawlSync;
}
// Use fallback sync algorithm
return(false);
}
else
{
Logger.Debug("Starting ContentChange Sync");
bool result = this.StartSync();
return(result);
}
}
// The above started full sync is finished.
FullSyncCompletedEvent syncCompleted = e as FullSyncCompletedEvent;
if (syncCompleted != null)
{
string lastTokenOnServer = syncCompleted.StartEvent.LastTokenOnServer;
if (!string.IsNullOrEmpty(lastTokenOnServer))
{
this.storage.ChangeLogToken = lastTokenOnServer;
}
}
return(false);
}
public void GivesCorrectContentChangeEvent()
{
ContentChangeEvent contentChangeEvent = null;
var queue = new Mock <ISyncEventQueue>();
queue.Setup(q => q.AddEvent(It.IsAny <ContentChangeEvent>())).Callback((ISyncEvent f) => {
contentChangeEvent = f as ContentChangeEvent;
});
string id = "myId";
Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
var session = MockSessionUtil.PrepareSessionMockForSingleChange(DotCMIS.Enums.ChangeType.Created, id);
var changes = new ContentChanges(session.Object, storage.Object, queue.Object, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
var startSyncEvent = new StartNextSyncEvent(false);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(foo => foo.AddEvent(It.IsAny <ContentChangeEvent>()), Times.Once());
Assert.That(contentChangeEvent.Type, Is.EqualTo(DotCMIS.Enums.ChangeType.Created));
Assert.That(contentChangeEvent.ObjectId, Is.EqualTo(id));
}
private void Sync()
{
// Get last change log token on server side.
this.session.Binding.GetRepositoryService().GetRepositoryInfos(null); // refresh
string lastTokenOnServer = this.session.Binding.GetRepositoryService().GetRepositoryInfo(this.session.RepositoryInfo.Id, null).LatestChangeLogToken;
// Get last change token that had been saved on client side.
string lastTokenOnClient = this.storage.ChangeLogToken;
if (lastTokenOnClient == null)
{
// Token is null, which means no content change sync has ever happened yet, so just sync everything from remote.
// Force full sync
var fullsyncevent = new StartNextSyncEvent(true);
Queue.AddEvent(fullsyncevent);
return;
}
do
{
// Check which files/folders have changed.
IChangeEvents changes = this.session.GetContentChanges(lastTokenOnClient, this.isPropertyChangesSupported, this.maxNumberOfContentChanges);
// Replicate each change to the local side.
bool first = true;
foreach (IChangeEvent change in changes.ChangeEventList)
{
// ignore first event when lists overlapp
if (first)
{
first = false;
if (this.lastChange != null &&
(this.lastChange.ChangeType == DotCMIS.Enums.ChangeType.Created ||
this.lastChange.ChangeType == DotCMIS.Enums.ChangeType.Deleted))
{
if (change != null && change.ChangeType == this.lastChange.ChangeType && change.ObjectId == this.lastChange.ObjectId)
{
continue;
}
}
}
this.lastChange = change;
Queue.AddEvent(new ContentChangeEvent(change.ChangeType, change.ObjectId));
}
// Save change log token locally.
if (changes.HasMoreItems == true)
{
lastTokenOnClient = changes.LatestChangeLogToken;
}
else
{
lastTokenOnClient = lastTokenOnServer;
}
this.storage.ChangeLogToken = lastTokenOnClient;
// refresh
this.session.Binding.GetRepositoryService().GetRepositoryInfos(null);
lastTokenOnServer = this.session.Binding.GetRepositoryService().GetRepositoryInfo(this.session.RepositoryInfo.Id, null).LatestChangeLogToken;
} while (!lastTokenOnServer.Equals(lastTokenOnClient));
}
public void ConstructorWithTrueParamSetsFullSyncRequestedFlagToTrue()
{
var start = new StartNextSyncEvent(true);
Assert.IsTrue(start.FullSyncRequested);
}
public void ConstructorWithFalseParamSetsFullSyncRequestedFlagToFalse()
{
var start = new StartNextSyncEvent(false);
Assert.IsFalse(start.FullSyncRequested);
}
