protected async override Task <StringBuilder> DoWorkOracle(SqlTester data, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
if (data._initialSleep.HasValue)
{
await Task.Delay(data._initialSleep.Value);
}
using (var conn = new OracleConnection(ConfigurationManager.ConnectionStrings["OracleDbContext"].ConnectionString))
{
await conn.OpenAsync(token);
var sb = new StringBuilder(1000);
using (var cmd = new OracleCommand(data._sqlQuery, conn))
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
cmd.Prepare();
cmd.CommandType = CommandType.Text;
using (var rdr = await cmd.ExecuteReaderAsync(token))
{
ProcessReader(rdr, sb);
return(sb);
}
}
}
}
async Task <StringBuilder> DoWorkEntitiesGroupedView(SqlTester data, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
if (data._initialSleep.HasValue)
{
await Task.Delay(data._initialSleep.Value);
}
using (testEntities context = new testEntities())
{
var query = (from e in context.GetDomains(data._maxCount)
select e);
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
var sb = new StringBuilder(1000);
foreach (var rdr in query.AsParallel())
{
sb.Append(rdr.domain).Append(" | ")
.Append(rdr.cnt).Append(" | ")
.Append(rdr.now)
.AppendLine();
}
return(sb);
}
}
protected async override Task <StringBuilder> DoWorkEntities(SqlTester data, CancellationToken token)
{
switch (TestType)
{
case TestTypeEnum.GROUPEDVIEW:
return(await DoWorkEntitiesGroupedView(data, token));
case TestTypeEnum.SEARCHER:
return(await DoWorkEntitiesSearcher(data, token));
default:
throw new NotSupportedException("bad test type");
}
}
async Task <StringBuilder> DoWorkEntitiesSearcher(SqlTester data, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
if (data._initialSleep.HasValue)
{
await Task.Delay(data._initialSleep.Value);
}
using (testEntities context = new testEntities())
{
var query = (from acc in context.accounts
where acc.clear_passwd.Contains(data._keyword2Search)
select new
{
user_name = acc.user_name,
clear_passwd = acc.clear_passwd,
user_id = acc.user_id,
now = DateTime.Now
});
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
var sb = new StringBuilder(1000);
foreach (var rdr in query.AsParallel())
{
sb.Append(rdr.user_name).Append(" | ")
.Append(rdr.clear_passwd).Append(" | ")
.Append(rdr.user_id).Append(" | ")
.Append(rdr.now)
.AppendLine();
}
return(sb);
}
}
async Task <StringBuilder> DoWorkAsync(SqlTester data, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
var task = Task.Run(() =>
{
Dispatcher.Invoke(() =>
{
OutputResultControl.AppendText("...working with...." + data.DataBaseType.ToString() + Environment.NewLine);
});
if (token.IsCancellationRequested)
{
return(Task.FromResult(new StringBuilder("cancelled")));
}
return(data.Execute(token));
});
return(await task);
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
if (((Button)sender).Content.ToString() == "Cancel")
{
GetCanellationtokenForButton((Button)sender).Cancel();
return;
}
var prev = ((Button)sender).Content;
try
{
OutputResultControl.Text = "starting multipple concurrency test" + Environment.NewLine;
var db_type = SelectedDBaseType;
var tst_type = TestType;
((Button)sender).Content = "Cancel";
int concurrentyCount = ConcurrencyCount.GetValueOrDefault(1);
await Task.Factory.StartNew(() =>
{
try
{
ParallelOptions po = new ParallelOptions();
CancellationToken token = default;
Dispatcher.Invoke(() =>
{
token = GetCanellationtokenForButton((Button)sender).Token;
po.CancellationToken = token;
});
Parallel.For(0, concurrentyCount, po, async(i, pls) =>
{
try
{
var data = new SqlTester(db_type, tst_type);
Dispatcher.Invoke(() =>
{
OutputResultControl.AppendText("starting test #" + i + " with " + data.DataBaseType.ToString() +
Environment.NewLine);
});
var result = await data.Execute(token);
// Display the result. All is ok
Dispatcher.Invoke(() =>
{
OutputResultControl.Text = result.ToString();
});
}
catch (OperationCanceledException)
{
pls.Stop();
Dispatcher.Invoke(() =>
{
OutputResultControl.Text = "cancelled";
});
return;
}
catch (Exception ex)
{
//Show error
Dispatcher.Invoke(() =>
{
OutputResultControl.Text = "Error: " + ex.Message;
});
}
});
}
catch (OperationCanceledException)
{
Dispatcher.Invoke(() =>
{
OutputResultControl.Text = "cancelled";
});
}
finally
{
//All sub-task ended. Notify UI
Dispatcher.Invoke(() =>
{
((Button)sender).Content = prev;
var cts = GetCanellationtokenForButton((Button)sender);
if (cts.IsCancellationRequested)
{
cts.Dispose();
_cancellationTokenSource.Remove(((Button)sender).Name);
}
});
}
});
}
catch (Exception ex)
{
//Show error
OutputResultControl.Text = "Error: " + ex.Message;
}
}
protected abstract Task <StringBuilder> DoWorkOracle(SqlTester data, CancellationToken token);
protected override async Task <StringBuilder> DoWorkPostgres(SqlTester data, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
if (data._initialSleep.HasValue)
{
await Task.Delay(data._initialSleep.Value);
}
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
//string clientCertPath = @"PostgresqlClientCert\postgresql.pfx";
using (var conn = new NpgsqlConnection(ConfigurationManager.ConnectionStrings["Postgres"].ConnectionString))
{
conn.ProvideClientCertificatesCallback = MyProvideClientCertificatesCallback;
await conn.OpenAsync(token);
var sb = new StringBuilder(1000);
using (var cmd = new NpgsqlCommand(data._sqlQuery, conn))
{
cmd.Prepare();
cmd.CommandType = System.Data.CommandType.Text;
if (token.IsCancellationRequested)
{
return(new StringBuilder("cancelled"));
}
using (var rdr = await cmd.ExecuteReaderAsync(token))
{
ProcessReader(rdr, sb);
return(sb);
}
}
}
void MyProvideClientCertificatesCallback(X509CertificateCollection clientCerts)
{
using (X509Store store = new X509Store(StoreLocation.CurrentUser))
{
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
var currentCerts = store.Certificates;
currentCerts = currentCerts.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
currentCerts = currentCerts.Find(X509FindType.FindByIssuerName, "theBrain.ca", false);
currentCerts = currentCerts.Find(X509FindType.FindBySubjectName, Environment.MachineName, false);
if (currentCerts != null && currentCerts.Count > 0)
{
var cert = currentCerts[0];
clientCerts.Add(cert);
}
}
}
}
