public sealed override int WriteToBufferSize(uint revision)
{
if (DeltaEncoding)
{
int count = NetBuffer.SizeofVWidth((ushort)Elements.Count);
int elementHeaderCount = 0;
ushort changeCount = 0;
for (int i = 0; i < Elements.Count; i++)
{
Synchroniser element = Elements[i];
if (element.ContainsRevision(revision))
{
changeCount += 1;
elementHeaderCount += NetBuffer.SizeofVWidth((ushort)i);
count += element.WriteToBufferSize(revision);
}
}
count += NetBuffer.SizeofVWidth(changeCount);
if (changeCount != Elements.Count)
{
count += elementHeaderCount;
}
return(count);
}
else
{
return(WriteToBufferSize());
}
}
/// <summary>
/// Create a new instance of the TrensmitUpdateItem class, wrapping this state.
/// </summary>
/// <param name="synchroniser">The synchroniser I will call to perform this action.</param>
/// <param name="state">The sync state on which this action should be performed.</param>
public TransmitUpdateAction(Synchroniser <OutlookItemType, SyncStateType> synchroniser, SyncStateType state) : base(1)
{
state.SetQueued();
this.synchroniser = synchroniser;
this.state = state;
MeetingSyncState meeting = state as MeetingSyncState;
if (meeting != null)
{
ILogger log = Globals.ThisAddIn.Log;
try
{
switch (meeting.OutlookItem.MeetingStatus)
{
case Outlook.OlMeetingStatus.olMeetingCanceled:
log.Info($"TransmitUpdateAction: registered meeting {state.Description} cancelled");
break;
case Microsoft.Office.Interop.Outlook.OlMeetingStatus.olMeetingReceivedAndCanceled:
log.Info($"TransmitUpdateAction: registered meeting {state.Description} received and cancelled");
break;
}
}
catch (COMException comx)
{
ErrorHandler.Handle($"Possibly-deleted item while trying to transmit update? HResult = {comx.HResult}", comx);
}
}
}
public void CacheDeltasBetween_Should_Complete_When_LatestKnownDelta_Is_Found()
{
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader, _deltaIndexService,
_mapperProvider, _userOutput, Substitute.For <ILogger>());
var chainSize = 7;
var chain = BuildChainedDeltas(chainSize);
SetCacheExpectations(chain);
var hashes = chain.Keys.ToArray();
var latestHashIndex = 3;
_userOutput.WriteLine($"Caching deltas between {hashes[latestHashIndex]} and {hashes.Last()}");
var cachedHashes = sync.CacheDeltasBetween(hashes[latestHashIndex],
hashes.Last(), _cancellationToken).ToList();
var expectedResultLength = chainSize - latestHashIndex + 1;
cachedHashes.Count.Should().Be(expectedResultLength);
OutputCachedHashes(cachedHashes);
cachedHashes.Should().BeEquivalentTo(hashes.TakeLast(expectedResultLength));
hashes.TakeLast(expectedResultLength - 1).Reverse().ToList().ForEach(h =>
{
_deltaCache.Received(1).TryGetOrAddConfirmedDelta(h,
out Arg.Any <Delta>(), _cancellationToken);
});
}
public void CacheDeltasBetween_Should_Stop_When_One_Of_Deltas_Is_Missing()
{
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader, _deltaIndexService,
_mapperProvider, _userOutput, Substitute.For <ILogger>());
var chainSize = 5;
var chain = BuildChainedDeltas(chainSize);
SetCacheExpectations(chain);
var hashes = chain.Keys.ToArray();
var brokenChainIndex = 2;
_deltaCache.TryGetOrAddConfirmedDelta(hashes[brokenChainIndex], out Arg.Any <Delta>())
.Returns(false);
_userOutput.WriteLine($"chain is broken for {hashes[brokenChainIndex]}, it cannot be found on Dfs.");
var cachedHashes = sync.CacheDeltasBetween(hashes.First(),
hashes.Last(), _cancellationToken).ToList();
OutputCachedHashes(cachedHashes);
cachedHashes.Count.Should().Be(chainSize - brokenChainIndex);
hashes.TakeLast(chainSize - brokenChainIndex + 1).ToList().ForEach(h =>
{
_deltaCache.Received(1).TryGetOrAddConfirmedDelta(h,
out Arg.Any <Delta>(), _cancellationToken);
});
}
/// <summary>
/// Create a new instance of the TrensmitUpdateItem class, wrapping this state.
/// </summary>
/// <param name="synchroniser">The synchroniser I will call to perform this action.</param>
/// <param name="state">The sync state on which this action should be performed.</param>
public TransmitUpdateAction(Synchroniser <OutlookItemType> synchroniser, SyncState <OutlookItemType> state) : base(1)
{
state.SetQueued();
this.synchroniser = synchroniser;
this.state = state;
SyncState <Outlook.AppointmentItem> meeting = state as SyncState <Outlook.AppointmentItem>;
if (meeting != null)
{
ILogger log = Globals.ThisAddIn.Log;
try
{
switch (meeting.OutlookItem.MeetingStatus)
{
case Outlook.OlMeetingStatus.olMeetingCanceled:
log.Info($"TransmitUpdateAction: registered meeting {state.Description} cancelled");
break;
case Microsoft.Office.Interop.Outlook.OlMeetingStatus.olMeetingReceivedAndCanceled:
log.Info($"TransmitUpdateAction: registered meeting {state.Description} received and cancelled");
break;
}
}
catch (COMException comx)
{
log.Error($"Item missing? HResult = {comx.HResult}", comx);
}
}
}
public P06_DetailsReviewPage ClickContinue()
{
Synchroniser.ElementClickable(btn_Continue);
//Synchroniser.ElementContainsAnyText(txt_AcNumber);
Synchroniser.ElementContainsAnyText(txt_TotalDue, "£");
return(PageInitialiser.DetailsReviewPage);
}
public void SelectToCountry(string toCountry)
{
Synchroniser.ElementVisible("#FromInpSel");
var textToSelect = new SelectElement(sel_FromCountry);
textToSelect.SelectByText(toCountry);
}
/// <summary>
/// Stop this synchroniser if it is active and is configured to be inactive.
/// </summary>
/// <param name="synchroniser">The synchroniser to stop.</param>
private void StopSynchroniserIfUnconfigured(Synchroniser synchroniser)
{
if (synchroniser != null &&
synchroniser.Direction == SyncDirection.Direction.Neither &&
synchroniser.IsActive)
{
synchroniser.Stop();
}
}
public sealed override void ReadFromBuffer(NetBuffer buffer, SyncContext context)
{
ReferencesPending = false;
ushort elementCount = buffer.ReadVWidth();
if (DeltaEncoding)
{
if (context.Revision > Revision)
{
Revision = context.Revision;
if (elementCount != Elements.Count)
{
SetElementLength(elementCount);
Synchronised = false;
}
}
int changeCount = buffer.ReadVWidth();
// If the change count is 0, then we want to default to the read all behavior of non delta lists.
bool skipHeader = changeCount == elementCount;
for (int i = 0; i < changeCount; i++)
{
int index = skipHeader ? i : buffer.ReadVWidth();
if (index < Elements.Count)
{
Synchroniser element = Elements[index];
element.ReadFromBuffer(buffer, context);
ReferencesPending |= element.ReferencesPending;
Synchronised &= element.Synchronised;
}
else
{
// Elements will be out of range if an out of date revision arrives after after the list is shrunk
ElementFactory.SkipFromBuffer(buffer);
}
}
}
else
{
Revision = context.Revision;
if (elementCount != Elements.Count)
{
SetElementLength(elementCount);
Synchronised = false;
}
foreach (Synchroniser element in Elements)
{
element.ReadFromBuffer(buffer, context);
ReferencesPending |= element.ReferencesPending;
Synchronised &= element.Synchronised;
}
}
}
public void EnterAmountToSend(string amountToSend)
{
//Synchroniser.ElementVisible("#TransferAmount");
Synchroniser.ExplicitWait(By.CssSelector("#TransferAmount"));
//for the object above 'amountForSending'
amountForSending = amountToSend;
inp_AmountToSend.SendKeys(amountToSend);
getToCountry();
}
/// <summary>
/// Start this synchronisation process, if it is configured to run,
/// provided it is not already running.
/// </summary>
/// <param name="synchroniser">The synchroniser to start.</param>
private void StartSynchroniserIfConfigured(Synchroniser synchroniser)
{
if (synchroniser != null &&
synchroniser.Direction != SyncDirection.Direction.Neither &&
!synchroniser.IsActive)
{
DoOrLogError(() =>
synchroniser.Start(),
catalogue.GetString("Starting {0}", new object[] { synchroniser.GetType().Name }));
}
}
public TransmitNewAction(Synchroniser <OutlookItemType, SyncStateType> synchroniser, SyncStateType state) : base(1)
{
/* step the state transition engine forward to queued */
if (state.TxState == TransmissionState.NewFromOutlook)
{
state.SetPending();
state.SetQueued();
}
this.syncState = state;
this.synchroniser = synchroniser;
}
public void Initialise()
{
if (!isInitialised)
{
if ((Synchronism)Blackboard.Global[Literals.StringLiterals.Blackboard.Synchroniser].Value != null)
{
isInitialised = true;
synchroniser = ((Synchronism)Blackboard.Global[Literals.StringLiterals.Blackboard.Synchroniser].Value).synchronisers[synchronisation];
synchroniser.RegisterCallback(this, Callback);
}
}
}
static void Main(string[] args)
{
log4net.Config.BasicConfigurator.Configure();
_logger = log4net.LogManager.GetLogger(typeof(TemplateSyncTool));
var arguments = ParseArguments(args);
if (arguments != null)
{
var sync = new Synchroniser();
sync.Synchronize(_logger, arguments);
}
}
public async Task Sync_Can_Complete()
{
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader, _deltaIndexService,
_mapperProvider, _userOutput, Substitute.For <ILogger>());
sync.SyncCompleted.Subscribe(x => { _manualResetEventSlim.Set(); });
await sync.StartAsync(CancellationToken.None);
_manualResetEventSlim.Wait();
sync.CurrentHighestDeltaIndexStored.Should().Be((ulong)_syncTestHeight);
}
public async Task StartAsync_Should_Start_Sync()
{
_deltaHeightWatcher = Substitute.For <IDeltaHeightWatcher>();
_deltaHeightWatcher.GetHighestDeltaIndexAsync().Returns(new DeltaIndex {
Cid = ByteString.Empty, Height = 10000
});
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader,
_deltaIndexService, _mapperProvider, _userOutput, Substitute.For <ILogger>());
await sync.StartAsync(CancellationToken.None);
sync.State.IsRunning.Should().BeTrue();
}
public async Task Sync_Can_Update_State()
{
_syncTestHeight = 10;
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader, _deltaIndexService,
_mapperProvider, _userOutput, Substitute.For <ILogger>(), _syncTestHeight);
sync.SyncCompleted.Subscribe(x => { _manualResetEventSlim.Set(); });
await sync.StartAsync(CancellationToken.None);
_manualResetEventSlim.Wait();
_deltaHashProvider.Received(_syncTestHeight).TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>());
}
public SyncWaitDialog(Synchroniser <Outlook.AppointmentItem> synchroniser, SyncState <Outlook.AppointmentItem> state, string crmType, ILogger log)
{
this.syncState = state;
this.synchroniser = synchroniser;
this.crmType = crmType;
this.log = log;
this.InitializeComponent();
this.synchronisingMessageLabel.Text = $"Please wait: synchronising meeting '{state.OutlookItem.Subject}' with CRM";
fred.RunWorkerCompleted += fred_Completed;
fred.DoWork += fred_DoWork;
fred.RunWorkerAsync();
}
public async Task StopAsync_Should_Log_If_Not_Running_Sync()
{
_deltaHeightWatcher = Substitute.For <IDeltaHeightWatcher>();
_deltaHeightWatcher.GetHighestDeltaIndexAsync().Returns(new DeltaIndex {
Cid = ByteString.Empty, Height = 10000
});
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader,
_deltaIndexService, _mapperProvider, _userOutput, Substitute.For <ILogger>());
await sync.StopAsync(CancellationToken.None);
_userOutput.Received(1).WriteLine("Sync is not currently running.");
sync.State.IsRunning.Should().BeFalse();
}
public async Task Can_Restore_DeltaIndex()
{
const int sampleCurrentDeltaHeight = 100;
var cid = _hashProvider.ComputeUtf8MultiHash(sampleCurrentDeltaHeight.ToString()).ToCid();
_deltaIndexService.Add(new DeltaIndexDao {
Cid = cid, Height = sampleCurrentDeltaHeight
});
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, Substitute.For <IDeltaHeightWatcher>(), _deltaHashProvider, _deltaDfsReader,
_deltaIndexService, _mapperProvider, _userOutput, Substitute.For <ILogger>());
await sync.StartAsync(CancellationToken.None);
sync.CurrentHighestDeltaIndexStored.Should().Be(sampleCurrentDeltaHeight);
}
public async Task Sync_Can_Add_DeltaIndexRange_To_Repository()
{
_syncTestHeight = 10;
var expectedData = GenerateSampleData(0, _syncTestHeight, _syncTestHeight);
var sync = new Synchroniser(new SyncState(), _peerSyncManager, _deltaCache, _deltaHeightWatcher, _deltaHashProvider, _deltaDfsReader, _deltaIndexService,
_mapperProvider, _userOutput, Substitute.For <ILogger>(), _syncTestHeight);
sync.SyncCompleted.Subscribe(x => { _manualResetEventSlim.Set(); });
await sync.StartAsync(CancellationToken.None);
_manualResetEventSlim.Wait();
var range = _deltaIndexService.GetRange(0, (ulong)_syncTestHeight).Select(x => DeltaIndexDao.ToProtoBuff <DeltaIndex>(x, _mapperProvider));
range.Should().BeEquivalentTo(expectedData.DeltaIndex);
}
public sealed override void ReadFromBuffer(NetBuffer buffer, SyncContext context)
{
if (context.Revision > Revision)
{
Revision = context.Revision;
}
int updated = buffer.ReadByte();
bool skipHeaders = updated == Fields.Length;
for (int i = 0; i < updated; i++)
{
int index = (skipHeaders) ? i : buffer.ReadByte();
Synchroniser field = Fields[index];
field.ReadFromBuffer(buffer, context);
Synchronised &= field.Synchronised;
ReferencesPending |= field.ReferencesPending;
}
}
public void Open()
{
Synchroniser.NewSync(2);
Synchroniser.OnActionsReady += CheckBuyBtns;
//Synchroniser.OnActionsReady += () => gameObject.SetActive(true);
gameObject.SetActive(true);
LoginManager.Instance.GetUserInfoAsync(() => Synchroniser.SetReady(0));
ShopManager.Instance.GetShopItemsAsync(() => Synchroniser.SetReady(1));
if (LoginManager.LocalUser)
{
BonusesTgl.isOn = true;
}
else
{
CardsTgl.isOn = true;
}
CardsTgl.interactable = !LoginManager.LocalUser;
CasesTgl.interactable = !LoginManager.LocalUser;
}
public P01_HomePage ClickContinue()
{
Synchroniser.ElementClickable(btn_continue);
Synchroniser.ExplicitWait(By.XPath("//div[contains(text(), ':')]"));
return(PageInitialiser.HomePage);
}
/// <summary>
/// Create a new instance of the TrensmitUpdateItem class, wrapping this state.
/// </summary>
/// <param name="synchroniser">The synchroniser I will call to perform this action.</param>
/// <param name="state">The sync state on which this action should be performed.</param>
public TransmitUpdateAction(Synchroniser <OutlookItemType> synchroniser, SyncState <OutlookItemType> state) : base(1)
{
state.SetQueued();
this.synchroniser = synchroniser;
this.state = state;
}
public string GetToCountry()
{
Synchroniser.ElementContainsAnyText(txt_ToCountry);
return(txt_ToCountry.Text);
}
public P02_LoginPage ClickContinue()
{
Synchroniser.ExplicitWait(By.XPath("//a[text() = 'Having problems signing in? ']"));
return(PageInitialiser.LoginPage);
}
public void SelectRecepient(string recepient)
{
Synchroniser.ExplicitWait(By.XPath("//*[text() = '" + recepient + "']//preceding::td[1]"));
PrePostTest.sWebDriver.FindElement(By.XPath("//*[text() = '" + recepient + "']//preceding::td[1]")).Click();
}
public P04_ScenarioAPage GoToScenarioA()
{
Synchroniser.ElementClickable(btn_ScenarioAArrow);
return(PageInitialiser.ScenarioAPage);
}
public TransmitNewAction(Synchroniser <OutlookItemType> synchroniser, SyncState <OutlookItemType> state, string crmType) : base(1)
{
this.syncState = state;
this.crmType = crmType;
this.synchroniser = synchroniser;
}
