private void Write()
{
try
{
using (FileStream _fileCompressed = new FileStream(path: DestinationFile + ".gz", mode: FileMode.Append))
{
while (!Cancelled)
{
ByteBlock _block = QueueWriter.Dequeue();
if (_block == null)
{
return;
}
BitConverter.GetBytes(value: _block.Buffer.Length).CopyTo(array: _block.Buffer, index: 4);
_fileCompressed.Write(array: _block.Buffer, offset: 0, count: _block.Buffer.Length);
}
}
}
catch (Exception ex)
{
Console.WriteLine(value: ex.Message);
Cancelled = true;
}
}
private static void LastDataInsert(CancellationToken token, QueueWriter writer)
{
token.Register(() =>
{
writer.WriteToDbAsync(true).GetAwaiter().GetResult();
});
}
private void Compress(object i)
{
try
{
while (!Cancelled)
{
ByteBlock _block = QueueReader.Dequeue();
if (_block == null)
{
return;
}
using (MemoryStream _memoryStream = new MemoryStream())
{
using (GZipStream cs = new GZipStream(_memoryStream, CompressionMode.Compress))
{
cs.Write(_block.Buffer, 0, _block.Buffer.Length);
}
byte[] compressedData = _memoryStream.ToArray();
ByteBlock _out = new ByteBlock(_block.ID, compressedData);
QueueWriter.EnqueueForWriting(_out);
}
WaitHandle doneEvent = DoneEvents[(int)i];
doneEvent.Dispose();
}
}
catch (Exception ex)
{
Console.WriteLine("Ошибка в номере потока {0}. \n описание ошибки: {1}", i, ex.Message);
Cancelled = true;
}
}
public async Task cache_many_requests()
{
using (var inputWriter = new QueueWriter(cacheInputFormatName))
using (var rr = new RequestReply(cacheInputFormatName, replyFormatName, postman))
{
var cachedMsg = new Message {
Label = "some.value.1", AppSpecific = 1
};
await inputWriter.DeliverAsync(cachedMsg, postman, QueueTransaction.None);
var cachedMsg2 = new Message {
Label = "some.value.2", AppSpecific = 2
};
await inputWriter.DeliverAsync(cachedMsg2, postman, QueueTransaction.None);
var sw = new Stopwatch();
for (int j = 0; j < 5; j++)
{
for (int i = 1; i <= 2; i++)
{
sw.Restart();
var request = new Message {
Label = "cache.some.value." + i
};
var reply = await rr.SendRequestAsync(request);
Console.WriteLine($"took {sw.Elapsed.TotalMilliseconds:N1}MS");
Assert.AreEqual("some.value." + i, reply.Label, "Label");
Assert.AreEqual(i, reply.AppSpecific, "AppSpecific");
}
}
}
}
public void Setup()
{
inputQueueFormatName = Queues.TryCreate(inputQueuePath, QueueTransactional.None);
adminQueueFormatName = Queues.TryCreate(adminQueuePath, QueueTransactional.None);
outputQueueFormatName1 = Queues.TryCreate(outputQueuePath1, QueueTransactional.None);
outputQueueFormatName2 = Queues.TryCreate(outputQueuePath2, QueueTransactional.None);
deadQueueFormatName = $"{inputQueueFormatName };Poison";
Queues.Purge(inputQueueFormatName);
Queues.Purge(adminQueueFormatName);
input = new QueueWriter(inputQueueFormatName);
dead = new QueueReader(deadQueueFormatName);
dead.Purge();
outRead1 = new QueueReader(outputQueueFormatName1);
outRead1.Purge();
outRead2 = new QueueReader(outputQueueFormatName2);
outRead2.Purge();
outSend1 = new QueueWriter(outputQueueFormatName1);
outSend2 = new QueueWriter(outputQueueFormatName2);
sender = new Postman(adminQueueFormatName);
}
public override void Write(object destinationFile)
{
try
{
using (FileStream _file = new FileStream((string)destinationFile, FileMode.Append))
{
while (true && !_cancelled)
{
ByteBlock _block = QueueWriter.Dequeue();
if (_block == null)
{
_workComplited = true;
_writerEvent.Set();
return;
}
_file.Write(_block.Buffer, 0, _block.Buffer.Length);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
_cancelled = true;
_workComplited = true;
}
}
public static void Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false)
.Build();
var rpcConfig = configuration.GetSection("RpcConfig").Get <RpcConfig>();
rpcClient = new WalletRpcClient(rpcConfig.Port, rpcConfig.User, rpcConfig.Password, rpcConfig.Passphrase);
optionsBuilder = new DbContextOptionsBuilder <DataContext>();
optionsBuilder.UseSqlServer(configuration.GetConnectionString("Database"));
serviceBusConnectionString = configuration.GetConnectionString("ServiceBusConnectionString");
sendCoinsQueueName = configuration.GetConnectionString("SendCoinsQueueName");
contractAddress = configuration.GetValue <string>("ContractAddress");
network = configuration.GetValue <string>("Network");
nrOfCoins = configuration.GetValue <decimal>("NrOfCoins");
sleepTime = configuration.GetValue <int>("SleepTime");
sendCoinsQueueWriter = new QueueWriter <SendCoinsMessage>(serviceBusConnectionString, sendCoinsQueueName);
dataManager = new DataManager(() => new DataContext(optionsBuilder.Options));
MainAsync().GetAwaiter().GetResult();
}
private void AddWriters(Node node, NodeReader reader, BufferTree tree, QueueIndex queue)
{
if (node.Index.Count > 0)
{
FieldWriter writer = new FieldWriter(node)
{
BufferIndex = node.Index.ToArray(),
NamePart = this.GetNamePart(node, queue, tree),
Queue = queue,
};
reader.Writers.Add(writer);
tree.Fields.Add(writer);
if (queue != null && queue.Type == RelationQueueType.Cached)
{
CacheWriter cacheWriter = new CacheWriter(node)
{
BufferIndex = writer.BufferIndex.First(),
CacheIndex = queue.Cache.Count,
Queue = queue,
};
queue.Cache.Add(cacheWriter);
}
}
if (node.Item != null || node.Metadata.HasFlag(RelationMetadataFlags.List | RelationMetadataFlags.Recursive))
{
QueueIndex prevQueue = tree.Queues.LastOrDefault()?.Index;
QueueIndex nextQueue = this.CreateIndex(node, tree);
QueueWriter writer = new QueueWriter(node)
{
NamePart = this.GetNamePart(node.Item ?? node, queue, tree),
Queue = queue,
Next = nextQueue,
};
if ((node.Item ?? node).Metadata.HasFlag(RelationMetadataFlags.Recursive))
{
nextQueue.Type = RelationQueueType.Recursive;
}
else if (prevQueue != null && !prevQueue.List.Identity.Equals(nextQueue.List.Owner.Parent?.Identity))
{
nextQueue.Type = RelationQueueType.Cached;
}
else if (prevQueue != null && prevQueue.Type == RelationQueueType.Cached)
{
nextQueue.Type = RelationQueueType.Cached;
}
reader.Writers.Add(writer);
if (node.Item != null)
{
this.CreateQueue(node.Item, tree, nextQueue);
}
}
}
public async Task CreateQueueWriter(PlayerType playerType, QueueData queueData = null)
{
if (StaticResources.user.type == PlayerType.Host)
{
await QueueListner.DisconnectFromQueue();
}
if (QueueWriter != null)
{
await QueueWriter.DisconnectFromQueue();
}
QueueTypes queueTypes = new QueueTypes();
QueueData writerData = queueData;
if (playerType == PlayerType.Guest)
{
string queueName = "Join-" + StaticResources.sessionCode;
writerData = new QueueData();
writerData.queueName = queueName;
writerData.QueueConnectionString = ServiceBusData.ConnectionString;
}
// pass over connection data
QueueWriter = new QueueWriterHandler(writerData);
}
private void Write()
{
try
{
using (FileStream _decompressedFile = new FileStream(SourceFile.Remove(SourceFile.Length - 3), FileMode.Append))
{
while (!Cancelled)
{
ByteBlock _block = QueueWriter.Dequeue();
if (_block == null)
{
return;
}
_decompressedFile.Write(_block.Buffer, 0, _block.Buffer.Length);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Cancelled = true;
}
}
public async Task can_route_multiple_message()
{
var key = Environment.TickCount;
using (var router = new SubQueueRouter(testQueueFormatName, GetSubQueue))
{
await router.StartAsync();
try
{
using (var q = new QueueWriter(testQueueFormatName))
{
q.Write(new Message {
Label = "my.sq", AppSpecific = key
});
q.Write(new Message {
Label = "my.sq", AppSpecific = key + 1
});
}
using (var sq = new QueueReader(testQueueFormatName + ";sq"))
{
var got = sq.Read(Properties.AppSpecific, timeout: TimeSpan.FromMilliseconds(500));
Assert.AreEqual(key, got.AppSpecific);
got = sq.Read(Properties.AppSpecific, timeout: TimeSpan.FromMilliseconds(500));
Assert.AreEqual(key + 1, got.AppSpecific);
}
}
finally
{
await router.StopAsync();
}
}
}
static void Main(string[] args)
{
var eventAggregator = new EventAggregator <Message>();
var projectionHost = new ProjectionHost(eventAggregator);
projectionHost.SetUpProjections();
var inMemQueue = new InMemQueue <Message>();
var reader = new QueueReader <Message>(inMemQueue);
eventAggregator.AttachTo(reader);
var foo = new QueueWriter <Message>(inMemQueue);
reader.Start();
while (true)
{
foo.Handle(new FooMessage());
Thread.Sleep(1000);
}
//var dispatcher = new ByTypeDispatcher();
//dispatcher.Subscribe(new FooHandler());
//dispatcher.Handle(new FooMessage());
}
public async Task can_remove_subscription()
{
using (var requestWriter = new QueueWriter(requestFN))
using (var replyReader = new QueueReader(replyFN))
{
var addReq = new Message {
AppSpecific = (int)PubSubAction.Add, ResponseQueue = replyFN
};
addReq.BodyUTF8("thing.one" + Environment.NewLine + "thing.two");
requestWriter.Write(addReq);
var removeReq = new Message {
AppSpecific = (int)PubSubAction.Remove, ResponseQueue = replyFN
};
removeReq.BodyUTF8("thing.one");
requestWriter.Write(removeReq);
var listReq = new Message {
AppSpecific = (int)PubSubAction.List, ResponseQueue = replyFN
};
requestWriter.Write(listReq);
var got = replyReader.Read(timeout: TimeSpan.FromSeconds(3));
Assert.IsNotNull(got);
Assert.AreEqual("thing.two", got.BodyUTF8());
}
}
async Task OnNewMessage(Message msg)
{
var lookupId = msg.LookupId;
QueueWriter dest = null;
try
{
dest = GetRoute(msg);
await dest.DeliverAsync(msg, Sender, QueueTransaction.None);
var removed = _input.Lookup(Properties.LookupId, lookupId, timeout: TimeSpan.Zero); // remove message from queue
if (removed == null)
{
Console.Error.WriteLine($"WARN: router message to {dest.FormatName} but could not remove message from input queue");
}
}
catch (QueueException ex)
{
//TODO: logging
Console.Error.WriteLine($"WARN {ex.Message} {{{dest?.FormatName}}}");
BadMessageHandler(_input, lookupId, QueueTransaction.None);
}
catch (RouteException ex)
{
//TODO: logging
Console.Error.WriteLine($"WARN {ex.Message} {{{ex.Destination}}}");
BadMessageHandler(_input, ex.LookupId, QueueTransaction.None);
}
}
public void TestInitialize()
{
dataAccess = new Mock <IBusDataAccess>();
counters = new Mock <IPerfCounters>();
serializer = new Mock <ISerializer>();
clock = new Mock <ISystemClock>();
clock.SetupGet(c => c.UtcNow)
.Returns(new DateTime(2022, 2, 23, 10, 49, 32, 33, DateTimeKind.Utc));
dataAccess.Setup(d => d.AddMessage(It.IsAny <QueueMessage>(), It.IsAny <string>()))
.Callback <QueueMessage, string>((msg, qn) =>
{
AddedMessage = msg;
AddedToQueue = qn;
})
.Returns(Task.FromResult <long>(12345));
serializer.Setup(s => s.SerializeHeaders(It.IsAny <Headers>()))
.Callback <Headers>(h => SerializedHeaders = h)
.Returns("SerialziedHeaders");
serializer.Setup(s => s.SerializeMessage(It.IsAny <object>(), It.IsAny <Type>()))
.Returns("SerialziedMessage");
writer = new QueueWriter(dataAccess.Object, counters.Object, serializer.Object, clock.Object);
}
private void Decompress(object i)
{
try
{
while (!Cancelled)
{
ByteBlock _block = QueueReader.Dequeue();
if (_block == null)
{
return;
}
using (MemoryStream ms = new MemoryStream(_block.CompressedBuffer))
{
using (GZipStream _gz = new GZipStream(ms, CompressionMode.Decompress))
{
_gz.Read(_block.Buffer, 0, _block.Buffer.Length);
byte[] decompressedData = _block.Buffer.ToArray();
ByteBlock block = new ByteBlock(_block.ID, decompressedData);
QueueWriter.EnqueueForWriting(block);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error in thread number {0}. \n Error description: {1}", i, ex.Message);
Cancelled = true;
}
}
public void fred()
{
QueueWriter q = null;
Message msg = null;
Postman pm = null;
q.Deliver(msg, pm);
}
private Expression GetNewQueueItemExpression(QueueWriter writer, Expression value)
{
Type itemType = this.GetQueueItemGenericType(writer.Next);
ConstructorInfo ctor = itemType.GetConstructors()[0];
Expression namePart = this.GetFieldNameExpression(writer);
return(Expression.New(ctor, value, namePart, Arguments.Notation));
}
public void Setup()
{
destFormatName = Queues.TryCreate(destQueuePath, QueueTransactional.Transactional);
adminFormatName = Queues.TryCreate(adminQueuePath, QueueTransactional.None);
Queues.Purge(destFormatName);
dest = new QueueWriter(destFormatName);
admin = new QueueReader(adminFormatName);
admin.Purge();
}
public RequestReply(string requestQueueFormantName, string replyQueueFormatName, Postman postman)
{
Contract.Requires(postman != null);
Contract.Requires(requestQueueFormantName != null);
Contract.Requires(replyQueueFormatName != null);
_requestQueue = new QueueWriter(requestQueueFormantName);
_responseQueue = new QueueReader(replyQueueFormatName);
_postman = postman;
}
private Expression GetQueueAddExpression(QueueWriter writer, Expression value)
{
Type queueType = this.GetQueueGenericType(writer.Next);
MethodInfo addMethod = queueType.GetMethod("Enqueue");
Expression queue = this.GetQueueIndexExpression(writer.Next);
Expression queueItem = this.GetNewQueueItemExpression(writer, value);
return(Expression.Call(queue, addMethod, queueItem));
}
/// <summary>
/// Sends a <paramref name="message"/> to the <paramref name="queue"/> and waits for it to be delivered.
/// Waits for responses from all queues when the <paramref name="queue"/> is a multi-element format name.
/// Note that the transaction MUST commit before the acknowledgements are received.
/// </summary>
/// <returns>Task that completes when the message has been delivered</returns>
/// <exception cref="TimeoutException">Thrown if the message does not reach the queue before the <see cref="ReachQueueTimeout"/> has been reached</exception>
/// <exception cref="AcknowledgmentException">Thrown if something bad happens, e.g. message could not be sent, access denied, the queue was purged, etc</exception>
public static Task DeliverAsync(this QueueWriter queue, Message message, Postman postman, QueueTransaction transaction = null)
{
Contract.Requires(queue != null);
Contract.Requires(message != null);
Contract.Requires(postman != null);
Contract.Requires(transaction == null || transaction == QueueTransaction.None || transaction == QueueTransaction.Single);
var t = postman.RequestDelivery(message, queue, transaction);
return(postman.WaitForDeliveryAsync(t));
}
private void Server(int count)
{
using (var requestQ = new QueueReader(requestQueueFormatName))
using (var replyQ = new QueueWriter(replyQueueFormatName))
{
for (int i = 0; i < count; i++)
{
var msg = requestQ.Read(Properties.All, TimeSpan.FromSeconds(0.5));
msg.CorrelationId = msg.Id;
replyQ.Write(msg);
}
}
}
public void Setup()
{
inputQueueFormatName = Queues.TryCreate(inputQueuePath, QueueTransactional.None);
adminQueueFormatName = Queues.TryCreate(adminQueuePath, QueueTransactional.None);
Queues.Purge(inputQueueFormatName);
Queues.Purge(adminQueueFormatName);
inputWriter = new QueueWriter(inputQueueFormatName);
dispatcher = new LabelSubscriber(inputQueueFormatName);
dispatcher.StartAsync().Wait();
postman = new Postman(adminQueueFormatName);
postman.StartAsync().Wait();
}
private async Task PerformWrites(string queueName, int numWrites)
{
ParmCheck.NotNullOrEmpty(nameof(queueName), queueName);
ParmCheck.Positive(nameof(numWrites), numWrites);
var queueWriter = new QueueWriter(_connectionString, queueName);
for (int i = 0; i < numWrites; i++)
{
FishObservation observation = DataGenerator.CreateFishObservation();
string messageId = await queueWriter.Write(observation);
Console.WriteLine($"Message {messageId} sent.");
}
}
/// <summary>
/// Posts a <paramref name="message"/> to the <paramref name="queue"/> with acknowledgement requested to be sent to <see cref="AdminQueueFormatName"/>.
/// </summary>
public Tracking RequestDelivery(Message message, QueueWriter queue, QueueTransaction transaction = null)
{
Contract.Requires(message != null);
Contract.Requires(queue != null);
Contract.Assert(_run != null);
Contract.Assert(_adminQueue != null);
message.AcknowledgmentTypes |= AcknowledgmentTypes.FullReachQueue;
message.TimeToReachQueue = ReachQueueTimeout;
message.AdministrationQueue = _adminQueue.FormatName;
queue.Write(message, transaction);
// acknowledgements for multicast messages get an empty DestinationQueue, so we need to remove it here
var formatName = queue.FormatName.StartsWith("multicast=", StringComparison.OrdinalIgnoreCase)? "" : queue.FormatName;
return(new Tracking(formatName, message.Id, message.LookupId));
}
protected QueueWriter GetRoute(Message msg)
{
QueueWriter r = null;
try
{
r = _route(msg);
if (r == null)
{
throw new NullReferenceException("route");
}
return(r);
}
catch (Exception ex)
{
throw new RouteException("Failed to get route", ex, msg.LookupId);
}
}
public async Task can_route_many()
{
using (var input = new QueueWriter(testQueueFormatName))
using (var out1 = new QueueReader(testQueueFormatName + ";one"))
using (var out2 = new QueueReader(testQueueFormatName + ";two"))
using (var router = new SubQueueRouter(testQueueFormatName, GetSubQueue))
{
out1.Purge();
out2.Purge();
for (int i = 0; i < 1000; i++)
{
input.Write(new Message {
Label = "1", AppSpecific = i
});
input.Write(new Message {
Label = "2", AppSpecific = i
});
}
var sw = new Stopwatch();
sw.Start();
var rtask = router.StartAsync();
try
{
for (int i = 0; i < 1000; i++)
{
var got = out1.Read(Properties.Label | Properties.AppSpecific);
Assert.AreEqual("1", got.Label, "Label");
Assert.AreEqual(i, got.AppSpecific, "AppSpecific");
got = out2.Read(Properties.Label | Properties.AppSpecific);
Assert.AreEqual("2", got.Label, "Label");
Assert.AreEqual(i, got.AppSpecific, "AppSpecific");
}
sw.Stop();
}
finally
{
await router.StopAsync();
}
Console.WriteLine($"Reading 2000 routed messages took {sw.ElapsedMilliseconds:N0} MS");
}
}
public void can_peek_when_opened_with_move_acces()
{
var fn = Queues.TryCreate(".\\private$\\subqtest", QueueTransactional.None);
var sqfn = fn + ";sq";
using (var qWriter = new QueueWriter(fn))
{
qWriter.Write(new Message {
AppSpecific = 234
});
}
using (var qReader = new QueueReader(fn))
using (var subQueue = new SubQueue(sqfn))
{
var msg = qReader.Peek(Properties.LookupId);
Queues.MoveMessage(qReader, subQueue, msg.LookupId);
var got = subQueue.Read();
Assert.AreEqual(234, got.AppSpecific);
}
}
public void CreateQueueWriter(PlayerType playerType, QueueData queueData = null)
{
if (QueueWriter != null)
{
QueueWriter.DisconnectFromQueue();
}
QueueTypes queueTypes = new QueueTypes();
QueueData writerData = queueData;
if (playerType == PlayerType.Guest)
{
string queueName = "Join-" + StaticResources.sessionCode;
writerData = QueueManipulator.CreateNewQueue(queueName);
}
// pass over connection data
QueueWriter = new QueueWriterHandler(writerData);
}
