public Task <BsonValue> RunScriptAsync(string command, CancellationToken cancellationToken)
{
var script = new BsonJavaScript(command);
var operation = new EvalOperation(_database.DatabaseNamespace, script, null);
var writeBinding = new WritableServerBinding(_client.Cluster, NoCoreSession.NewHandle());
return(operation.ExecuteAsync(writeBinding, CancellationToken.None));
}
private async static Task ClearData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster))
{
var commandOp = new DropDatabaseOperation(__collection.DatabaseNamespace, __messageEncoderSettings);
await commandOp.ExecuteAsync(binding, CancellationToken.None);
}
}
private void ClearData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster, NoCoreSession.NewHandle()))
{
var commandOp = new DropDatabaseOperation(_collection.DatabaseNamespace, _messageEncoderSettings);
commandOp.Execute(binding, CancellationToken.None);
}
}
// public methods
/// <inheritdoc/>
public sealed override async Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default(CancellationToken))
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings);
using (var binding = new WritableServerBinding(_cluster))
{
await _operationExecutor.ExecuteWriteOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
}
}
// public methods
/// <inheritdoc/>
public sealed override void DropDatabase(string name, CancellationToken cancellationToken = default(CancellationToken))
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings);
using (var binding = new WritableServerBinding(_cluster))
{
_operationExecutor.ExecuteWriteOperation(binding, operation, cancellationToken);
}
}
private void InsertData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster, NoCoreSession.NewHandle()))
{
for (int i = 0; i < 100; i++)
{
Insert(binding, new BsonDocument("i", i));
}
}
}
private async Task InsertData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster))
{
for (int i = 0; i < 100; i++)
{
await Insert(binding, new BsonDocument("i", i));
}
}
}
protected async Task <BsonValue> EvalAsync(string javascript)
{
var function = new BsonJavaScript(javascript);
var op = new EvalOperation(this._database.DatabaseNamespace, function, null);
using (var writeBinding = new WritableServerBinding(this._client.Cluster, new CoreSessionHandle(NoCoreSession.Instance)))
{
return(await op.ExecuteAsync(writeBinding, CancellationToken.None));
}
}
private void DropView(CollectionNamespace viewNamespace)
{
var operation = new DropCollectionOperation(viewNamespace, CoreTestConfiguration.MessageEncoderSettings);
using (var session = CoreTestConfiguration.StartSession(_cluster))
using (var binding = new WritableServerBinding(_cluster, session.Fork()))
using (var bindingHandle = new ReadWriteBindingHandle(binding))
{
operation.Execute(bindingHandle, CancellationToken.None);
}
}
/// <summary>
/// Evaluates the specified javascript within a MongoDb database.
/// </summary>
/// <param name="database">MongoDb Database to execute the javascript.</param>
/// <param name="javascript">Javascript to execute.</param>
/// <param name="args">Optional arguments that can be provided to the javascript function to execute.</param>
/// <returns>A <see cref="BsonValue" /> result.</returns>
public static BsonValue Eval(this IMongoDatabase database, string javascript, IEnumerable <BsonValue> args = null)
{
var op = GetEvalOperation(database, javascript, args);
using (var sessionHandle = new CoreSessionHandle(NoCoreSession.Instance))
{
using (var writeBinding = new WritableServerBinding(database.Client.Cluster, sessionHandle))
{
return(op.Execute(writeBinding, CancellationToken.None));
}
}
}
private void DropDatabase()
{
var operation = new DropDatabaseOperation(
new DatabaseNamespace(__databaseName),
new MessageEncoderSettings());
using (var binding = new WritableServerBinding(__cluster))
{
operation.ExecuteAsync(binding, TimeSpan.FromSeconds(10), CancellationToken.None)
.GetAwaiter()
.GetResult();
}
}
public async Task <BsonValue> ExecuteScriptAsync(string javascript)
{
var function = new BsonJavaScript(javascript);
EvalOperation op = new EvalOperation(database.DatabaseNamespace, function, new MessageEncoderSettings {
});
using (var writeBinding = new WritableServerBinding(database.Client.Cluster, new CoreSessionHandle(NoCoreSession.Instance)))
{
var result = await op.ExecuteAsync(writeBinding, CancellationToken.None);
return(result);
}
}
/// <summary>
/// Evaluates the specified javascript within a MongoDb database
/// </summary>
/// <param name="database">MongoDb Database to execute the javascript</param>
/// <param name="javascript">Javascript to execute</param>
/// <param name="args">Optional arguments that can be provided to the javascript function to execute</param>
/// <returns>A <see cref="BsonValue" /> result</returns>
public static BsonValue Eval(this IMongoDatabase database, string javascript, IEnumerable <BsonValue> args = null)
{
var client = database.Client as MongoClient;
if (client == null)
{
throw new ArgumentException("Client is not a MongoClient");
}
var op = GetEvalOperation(database, javascript, args);
using (var writeBinding = new WritableServerBinding(client.Cluster, new CoreSessionHandle(NoCoreSession.Instance)))
{
return(op.Execute(writeBinding, CancellationToken.None));
}
}
/// <summary>
///
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public async Task <BsonValue> EvalAsync(string text)
{
var client = _database as MongoClient;
if (client == null)
{
throw new ArgumentException("Client is not a MongoClient");
}
var function = new BsonJavaScript(text);
var op = new EvalOperation(_database.DatabaseNamespace, function, null);
using (var writeBinding = new WritableServerBinding(client.Cluster, new CoreSessionHandle(NoCoreSession.Instance)))
{
return(await op.ExecuteAsync(writeBinding, CancellationToken.None));
}
}
public IActionResult RunScript(string query)
{
if (string.IsNullOrEmpty(query))
return Json(new { Result = false, Message = "Empty query!" });
try
{
var bscript = new BsonJavaScript(query);
var operation = new EvalOperation(_mongoDBContext.Database().DatabaseNamespace, bscript, null);
var writeBinding = new WritableServerBinding(_mongoDBContext.Database().Client.Cluster, NoCoreSession.NewHandle());
var result = operation.Execute(writeBinding, CancellationToken.None);
var xx = result["_ns"];
return Json(new { Result = true, Message = result.ToString() });
}
catch (Exception ex)
{
return Json(new { Result = false, Message = ex.Message });
}
}
protected void VerifySessionIdWasSentWhenSupported <TResult>(
Func <WritableServerBinding, CancellationToken, Task <TResult> > executeAsync,
Func <WritableServerBinding, CancellationToken, TResult> execute,
string commandName,
bool async)
{
var eventCapturer = new EventCapturer().Capture <CommandStartedEvent>(e => e.CommandName == commandName);
using (var cluster = CoreTestConfiguration.CreateCluster(b => b.Subscribe(eventCapturer)))
{
using (var session = CoreTestConfiguration.StartSession(cluster))
using (var binding = new WritableServerBinding(cluster, session))
{
var cancellationToken = new CancellationTokenSource().Token;
if (async)
{
executeAsync(binding, cancellationToken).GetAwaiter().GetResult();
}
else
{
execute(binding, cancellationToken);
}
var commandStartedEvent = (CommandStartedEvent)eventCapturer.Next();
var command = commandStartedEvent.Command;
if (session.Id == null)
{
command.Contains("lsid").Should().BeFalse();
}
else
{
command["lsid"].Should().Be(session.Id);
}
session.ReferenceCount().Should().Be(1);
}
}
}
private async Task DoWork(ICluster cluster)
{
var rand = new Random();
using (var binding = new WritableServerBinding(cluster))
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
var i = rand.Next(0, 10000);
IReadOnlyList <BsonDocument> docs;
using (var cursor = await Query(binding, new BsonDocument("i", i)))
{
try
{
if (await cursor.MoveNextAsync(_cancellationTokenSource.Token))
{
docs = cursor.Current.ToList();
}
else
{
docs = null;
}
//Console.Write(".");
}
catch
{
Console.Write("+");
continue;
}
}
if (docs == null || docs.Count == 0)
{
try
{
await Insert(binding, new BsonDocument().Add("i", i));
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
else
{
try
{
var filter = new BsonDocument("_id", docs[0]["_id"]);
var update = new BsonDocument("$set", new BsonDocument("i", i + 1));
await Update(binding, filter, update);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
}
}
}
private async static Task DoWork(ICluster cluster, CancellationToken cancellationToken)
{
var rand = new Random();
using (var binding = new WritableServerBinding(cluster))
while (!cancellationToken.IsCancellationRequested)
{
var i = rand.Next(0, 10000);
IReadOnlyList <BsonDocument> docs;
IAsyncCursor <BsonDocument> enumerator = null;
try
{
enumerator = await Query(binding, new BsonDocument("i", i)).ConfigureAwait(false);
if (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
docs = enumerator.Current.ToList();
}
else
{
docs = null;
}
//Console.Write(".");
}
catch (Exception)
{
Console.Write("+");
continue;
}
finally
{
if (enumerator != null)
{
enumerator.Dispose();
}
}
if (docs == null || docs.Count == 0)
{
try
{
await Insert(binding, new BsonDocument().Add("i", i)).ConfigureAwait(false);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
else
{
try
{
var criteria = new BsonDocument("_id", docs[0]["_id"]);
var update = new BsonDocument("$set", new BsonDocument("i", i + 1));
await Update(binding, criteria, update).ConfigureAwait(false);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
}
}
private IWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session)
{
var binding = new WritableServerBinding(_cluster, session.WrappedCoreSession.Fork());
return(new ReadWriteBindingHandle(binding));
}
private static IReadWriteBindingHandle CreateReadWriteBinding(ICoreSessionHandle session)
{
var binding = new WritableServerBinding(__cluster.Value, session.Fork());
return(new ReadWriteBindingHandle(binding));
}
