private void notify()
{
WaitContext next, ctx = queueStart;
while (ctx != null)
{
if (ctx.exclusive)
{
if (nReaders == 0)
{
nWriters = 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
}
break;
}
else
{
nReaders += 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
}
}
queueStart = ctx;
}
private void wait(LockMode mode)
{
WaitContext ctx;
lock (typeof(PersistentResource))
{
ctx = freeContexts;
if (ctx == null)
{
ctx = new WaitContext();
}
else
{
freeContexts = ctx.next;
}
ctx.next = null;
}
if (queueStart != null)
{
queueEnd = queueEnd.next = ctx;
}
else
{
queueStart = queueEnd = ctx;
}
ctx.mode = mode;
Monitor.Exit(this);
ctx.evt.WaitOne();
lock (typeof(PersistentResource))
{
ctx.next = freeContexts;
freeContexts = ctx;
}
}
public bool IsNewEmailOk()
{
WaitContext.Switch(Search.GetDriver());
bool isOk = Wait.WaitFor(() => Search.FindElements(IsNewEmailOkDiv).Any());
WaitContext.Switch(Search.GetDriver());
return(isOk);
}
void DownloadWhenNeededAndRefresh()
{
using (WaitContext wc = new WaitContext())
{
if (m_source != null)
{
Async.SafeOpen(m_source.Connection);
}
if (m_target != null)
{
Async.SafeOpen(m_target.Connection);
}
if (m_source != null && m_srcModel == null)
{
ReloadSourceModel();
if (m_srcModel != null)
{
m_datasyn.NotifyChangeSourceModel(m_srcModel);
}
}
if (m_target != null && m_dstModel == null)
{
ReloadTargetModel();
if (m_dstModel != null)
{
m_datasyn.NotifyChangeTargetModel(m_dstModel);
}
}
}
if (m_source != null)
{
labSourceServer.Text = m_source.Connection.PhysicalFactory.GetDataSource();
labSourceDb.Text = m_source.DatabaseName ?? "";
}
else
{
labSourceServer.Text = "";
labSourceDb.Text = "";
}
UpdateSourceLeft();
if (m_target != null)
{
labTargetServer.Text = m_target.Connection.PhysicalFactory.GetDataSource();
labTargetDb.Text = m_target.DatabaseName ?? "";
}
else
{
labTargetServer.Text = "";
labTargetDb.Text = "";
}
RefreshData();
}
private void btnAddAll_Click(object sender, EventArgs e)
{
using (WaitContext wc = new WaitContext())
{
foreach (NameWithSchema table in lbxAvailable.Items)
{
m_frame.AddTable(table);
}
RefreshTables();
}
}
private bool ResolveWaitContextUndoAsync(WaitContext waitContext)
{
var spinner = new SpinWait();
bool dequeuedSelf = false;
lock (undoLock) {
WaitContext takenWaitContext;
var maxIterations = waitContexts.Count;
for (var i = 0; i < maxIterations && waitContexts.TryDequeue(out takenWaitContext); i++)
{
if (takenWaitContext == waitContext)
{
dequeuedSelf = true;
break;
}
else
{
waitContexts.Enqueue(takenWaitContext);
}
}
}
if (dequeuedSelf)
{
while (true)
{
var capturedCounter = Interlocked.CompareExchange(ref counter, 0, 0);
if (capturedCounter >= 0)
{
waitContexts.Enqueue(waitContext);
break;
}
else
{
var nextCounter = capturedCounter + 1;
if (Interlocked.CompareExchange(ref counter, nextCounter, capturedCounter) == capturedCounter)
{
return(true);
// var tcs = new TaskCompletionSource<bool>();
// tcs.SetException(e);
// return tcs.Task;
// ExceptionDispatchInfo.Capture(e).Throw();
}
spinner.SpinOnce();
}
}
}
// t = waitContext.Latch.WaitAsync();
return(false);
// return waitContext.Latch.WaitAsync();
}
void DownloadWhenNeededAndRefresh()
{
using (WaitContext wc = new WaitContext())
{
if (m_srcDb != null)
{
Async.SafeOpen(m_srcDb.Connection);
}
if (m_dstDb != null)
{
Async.SafeOpen(m_dstDb.Connection);
}
}
if (m_srcDb != null)
{
if (m_downloadedSrc == null)
{
Controls.ShowProgress(true);
m_srcDb.Connection.BeginInvoke((Action)DoDownloadSource, Async.CreateInvokeCallback(m_invoker, DownloadedSource));
return;
}
}
if (m_dstDb != null)
{
if (m_downloadedDst == null)
{
Controls.ShowProgress(true);
m_dstDb.Connection.BeginInvoke((Action)DoDownloadTarget, Async.CreateInvokeCallback(m_invoker, DownloadedTarget));
return;
}
}
if (m_srcDb != null && m_dstDb != null && m_downloadedSrc != null && m_downloadedDst != null)
{
if (!m_srcFixedDataLoaded && m_srcDb.DatabaseCaps.ExecuteSql && m_dstDb.DatabaseCaps.FixedDataDefiner)
{
Controls.ShowProgress(true);
m_srcDb.Connection.BeginInvoke((Action)DoDownloadSourceData, Async.CreateInvokeCallback(m_invoker, DownloadedSource));
return;
}
if (!m_dstFixedDataLoaded && m_dstDb.DatabaseCaps.ExecuteSql && m_srcDb.DatabaseCaps.FixedDataDefiner)
{
Controls.ShowProgress(true);
m_dstDb.Connection.BeginInvoke((Action)DoDownloadTargetData, Async.CreateInvokeCallback(m_invoker, DownloadedTarget));
return;
}
}
RefreshNotDownload();
}
public static void Release(ref WaitContext context, object result)
{
if (context == null)
{
return;
}
lock (context)
{
context.Result = result;
context.SetFinished(result);
for (int i = 0; i < context.WaitCreateds.Count; i++)
{
context.WaitCreateds[i].Release();
}
context.WaitCreateds.Clear();
}
//context = null;
}
private void notify()
{
WaitContext next, ctx = queueStart;
while (ctx != null)
{
switch (ctx.mode)
{
case LockMode.Exclusive:
if (nWriters == 0 && nUpdaters == 0 && nReaders == 0)
{
nWriters = 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
}
break;
case LockMode.Shared:
if (nWriters == 0)
{
nReaders += 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
continue;
}
break;
case LockMode.Update:
if (nUpdaters == 0 && nWriters == 0)
{
nUpdaters = 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
continue;
}
break;
}
break;
}
queueStart = ctx;
}
public async Task WaitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var spinner = new SpinWait();
while (true)
{
var capturedCounter = Interlocked.CompareExchange(ref counter, 0, 0);
var nextCounter = capturedCounter - 1;
if (Interlocked.CompareExchange(ref counter, nextCounter, capturedCounter) == capturedCounter)
{
if (capturedCounter > 0)
{
return;
}
else
{
var latch = new AsyncLatch();
var waitContext = new WaitContext {
Latch = latch
};
try {
waitContexts.Enqueue(waitContext);
await latch.WaitAsync(cancellationToken).ConfigureAwait(false);
return;
} catch (OperationCanceledException e) {
if (ResolveWaitContextUndoAsync(waitContext))
{
throw;
}
else
{
await waitContext.Latch.WaitAsync(CancellationToken.None).ConfigureAwait(false);
return;
}
// return ResolveWaitContextUndoAsync(waitContext, e);
}
}
}
spinner.SpinOnce();
}
}
private void btnCheckAll_Click(object sender, EventArgs e)
{
using (var wc = new WaitContext())
{
foreach (object item in objectListView1.Objects)
{
var target = item as TargetTableWrapper;
if (target != null && target.SourceTable != null)
{
target.IsChecked = true;
}
}
foreach (var item in m_datasyn.Items)
{
item.IsChecked = true;
}
RefreshData();
}
}
public static async System.Threading.Tasks.Task <WaitContext> Awaitload(WaitContext context)
{
if (context == null || context.IsFinished)
{
return(context);
}
var smp = Thread.ASyncSemaphore.CreateSemaphore(1);
lock (context)
{
context.WaitCreateds.Add(smp);
}
await smp.Await();
lock (context)
{
context.WaitCreateds.Remove(smp);
}
return(context);
}
private void wait(bool exclusive)
{
WaitContext ctx;
lock (typeof(PersistentResource))
{
ctx = freeContexts;
if (ctx == null)
{
ctx = new WaitContext();
}
else
{
freeContexts = ctx.next;
}
ctx.next = null;
}
if (queueStart != null)
{
queueEnd = queueEnd.next = ctx;
}
else
{
queueStart = queueEnd = ctx;
}
ctx.exclusive = exclusive;
Monitor.Exit(this);
ctx.evt.WaitOne();
lock (typeof(PersistentResource))
{
ctx.next = freeContexts;
freeContexts = ctx;
}
}
private void notify()
{
WaitContext next, ctx = queueStart;
while (ctx != null)
{
switch (ctx.mode)
{
case LockMode.Exclusive:
if (nWriters == 0 && nUpdaters == 0 && nReaders == 0)
{
nWriters = 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
}
break;
case LockMode.Shared:
if (nWriters == 0)
{
nReaders += 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
continue;
}
break;
case LockMode.Update:
if (nUpdaters == 0 && nWriters == 0)
{
nUpdaters = 1;
next = ctx.next;
ctx.evt.Set();
ctx = next;
continue;
}
break;
}
break;
}
queueStart = ctx;
}
protected PageObjectBase(ISearchContext search)
{
Search = search;
WaitContext = new WaitContext(Search.GetDriver(), WaitStrategy.Implicit);
}
public Waiting(TestOperationStatus previous, WaitContext waitContext)
{
AssertNotStarted(previous);
this.WaitContext = waitContext;
}
