public HermesProducer(
IChannelWriter channelWriter,
IMessageAdapter messageAdapter)
{
_channelWriter = channelWriter;
_messageAdapter = messageAdapter;
}
public virtual void SerializeObjects()
{
string name = "test-SerializeObjects" + Salt;
Queue <string> rq = new Queue <string>(new string[] { "aaa", "aab", "abb", "bbb", "bbc", "bcc", "ccc" });
Queue <string> wq = new Queue <string>(new string[] { "aaa", "aab", "abb", "bbb", "bbc", "bcc", "ccc" });
AbstractChannelsFactory fc = new RabbitMQChannelsFactory();
Task tr = Task.Factory.StartNew(() => {
using (IChannelReader <SerializeObjectsData> ch = fc.GetSubscribableChannel <SerializeObjectsData>(name).Subscribe())
{
foreach (SerializeObjectsData item in ch.Enumerate())
{
Assert.AreEqual(item.OpId, rq.Dequeue());
}
Assert.IsTrue(ch.Drained);
}
});
Task tw = Task.Factory.StartNew(() => {
using (IChannelWriter <SerializeObjectsData> ch = fc.GetSubscribableChannel <SerializeObjectsData>(name))
{
while (wq.Count > 0)
{
ch.Write(new SerializeObjectsData()
{
OpId = wq.Dequeue(), Status = "test", Message = "/messaggio/lungo/con/sbarre"
});
}
ch.Close();
}
});
Task.WaitAll(tr, tw);
}
public static IChannelWriter <T> WriteSelectWith <T>(this IChannelWriter <T> ext, int timeoutMillis, params IChannelWriter <T>[] channels)
{
List <IChannelWriter <T> > tmp = new List <IChannelWriter <T> >(channels);
tmp.Add(ext);
return(ChannelWriterSync.Select <T>(timeoutMillis, tmp.ToArray()));
}
public static IEnumerable <IChannelWriter <T> > WriteBarrierWith <T>(this IChannelWriter <T> ext, int timeoutMillis, params IChannelWriter <T>[] channels)
{
List <IChannelWriter <T> > tmp = new List <IChannelWriter <T> >(channels);
tmp.Add(ext);
return(ChannelWriterSync.Barrier <T>(timeoutMillis, tmp.ToArray()));
}
protected override void RemoteCall(IJobExecutionContext context)
{
using (ILoggingOperation log = _logger.NormalOperation())
{
log.Wrap(() =>
{
RabbitMQChannelsFactory factory = new RabbitMQChannelsFactory();
IChannelWriter <object> ch = null;
if (Broadcast)
{
ch = factory.GetSubscribableChannel <object>(ChannelName);
}
else
{
ch = factory.GetChannel <object>(ChannelName);
}
using (ch)
{
ch.Write(Message);
}
});
}
}
internal PersistentChannelWriter(IChannelWriter <T> writer, bool singleWriter, long initialSize)
{
writeLock = singleWriter ? default : AsyncLock.Exclusive();
this.writer = writer;
fileOptions = new FileCreationOptions(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read, FileOptions.Asynchronous | FileOptions.WriteThrough, initialSize);
cursor = new ChannelCursor(writer.Location, StateFileName);
}
/// <summary>
/// Tries to propagate completion from the reader to the writer.
/// </summary>
/// <typeparam name="T">The type of the items in the reader and writer.</typeparam>
/// <param name="reader">The reader.</param>
/// <param name="writer">The writer.</param>
/// <param name="passthroughError"><see langword="true"/> - passthrough error, <see langword="false"/> - mute error.</param>
/// <returns>true, if completion was propagated, false otherwise.</returns>
public static bool TryPropagateCompletion <T>(
this IChannelReader <T> reader,
IChannelWriter <T> writer,
bool passthroughError = true)
{
VxArgs.NotNull(reader, nameof(reader));
VxArgs.NotNull(writer, nameof(writer));
if (reader.Completion.IsCompleted)
{
Exception error = null;
try
{
reader.Completion.GetAwaiter().GetResult();
}
catch (Exception ex)
{
if (passthroughError)
{
error = ex;
}
}
return(writer.TryComplete(error));
}
return(false);
}
public static AbstractShovelThread <S, D> ShovelFrom <S, D>(this IChannelWriter <D> ext, IChannelReader <S> source, Func <S, D> transform, TimeSpan lifeTime, bool closeOnDrain)
{
AbstractShovelThread <S, D> th = new FuncShovelThread <S, D>(transform, source, ext, lifeTime, closeOnDrain);
th.Start();
return(th);
}
internal static void RemoveNamedWriter <T>(string name, IChannelWriter <T> writer)
{
if (_namedChannels.ContainsKey(name))
{
RemoveWriter <T>(writer);
_namedChannels[name].Item2.Remove(writer);
if (_namedChannels[name].Item1.Count == 0 && _namedChannels[name].Item2.Count == 0)
{
_namedChannels.Remove(name);
}
}
}
public AbstractShovelThread(IChannelReader <S> source, IChannelWriter <D> destination, TimeSpan lifeTime, bool closeOnDrain)
: base(source, lifeTime)
{
if (destination == null)
{
throw new ArgumentNullException("'destination' cannot be null.");
}
_destination = destination;
_closeOnDrain = closeOnDrain;
_th = new Thread(Run);
StoppedEvent += ChannelDrainedHandling;
}
internal static Queue <T> AddWriter <T>(IChannelWriter <T> writer, Queue <T> queue)
{
if (_writers.ContainsKey(writer))
{
if (_writers[writer] != queue)
{
throw new InvalidOperationException("Impossible to associate a different queue to the already created channel end.");
}
return((Queue <T>)_writers[writer]);
}
else
{
Queue <T> qu = queue == null ? new Queue <T>() : queue;
_writers.Add(writer, qu);
return(qu);
}
}
internal static Queue <T> AddNamedWriter <T>(string name, IChannelWriter <T> writer, Queue <T> queue)
{
queue = AddWriter <T>(writer, queue);
if (!_namedChannels.ContainsKey(name))
{
_namedChannels.Add(name, new Tuple <List <object>, List <object> >(null, null));
}
if (_namedChannels[name].Item2.Contains(writer))
{
throw new Exception("Cannot attach mutiple times the same channel");
}
else
{
_namedChannels[name].Item2.Add(writer);
}
return(queue);
}
public FuncShovelThread(Func <S, D> transform, IChannelReader <S> source, IChannelWriter <D> destination, TimeSpan lifeTime, bool closeOnDrain)
: base(source, destination, lifeTime, closeOnDrain)
{
_func = transform;
}
public DuplexHermesChannel(string channelName, NetworkStream networkStream)
{
_inputChannel = new InputHermesChannel($"input_{channelName}", networkStream);
_outputChannel = new OutputHermesChannel($"output_{channelName}", networkStream);
Name = channelName;
}
public InnerWriterHandler(ChannelWriterMultiplexer <T> owner, IChannelWriter <T> innerWriter)
{
InnerWriter = innerWriter;
_owner = owner;
}
public AbstractChannelInputAdapter(IChannelWriter <D> channel)
{
_channel = channel;
}
/// <summary>
/// Performs copy processing from the reader to the writer.
/// </summary>
/// <typeparam name="T">The type of the items to copy.</typeparam>
/// <param name="reader">The source.</param>
/// <param name="writer">The target.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Async execution TPL task.</returns>
public static async Task Copy <T>(
this IChannelReader <T> reader,
IChannelWriter <T> writer,
CancellationToken cancellationToken = default,
ChannelCompletionPassthroughProc producerCompletionPassthroughProc = null,
ChannelCompletionPassthroughProc consumerCompletionPassthroughProc = null,
Func <T, ValueTask> handleLostItemsProc = null)
{
VxArgs.NotNull(reader, nameof(reader));
VxArgs.NotNull(writer, nameof(writer));
CancellationToken readCancellationToken = cancellationToken;
if (producerCompletionPassthroughProc == null)
{
producerCompletionPassthroughProc = (error, isFromChannel) =>
{
writer.TryComplete(error);
return(new ValueTask());
};
}
if (consumerCompletionPassthroughProc == null)
{
consumerCompletionPassthroughProc = (error, isFromChannel) =>
{
reader.TryComplete(error);
return(new ValueTask());
};
}
Exception handlersError = null;
try
{
while (true)
{
T item;
try
{
if (!reader.TryRead(out item))
{
if (!await reader.WaitToReadAsync(readCancellationToken))
{
Exception error = null;
try
{
await reader.Completion;
}
catch (Exception ex)
{
error = ex;
}
finally
{
try
{
await producerCompletionPassthroughProc(error);
}
catch (Exception ex)
{
handlersError = ex;
}
}
return;
}
else
{
continue;
}
}
}
catch (Exception error)
{
try
{
await producerCompletionPassthroughProc(error, false);
}
catch (Exception ex)
{
handlersError = ex;
}
return;
}
// Trying to write, until target closed, or cancellation raised.
while (true)
{
try
{
if (writer.TryWrite(item))
{
break;
}
if (!await writer.WaitToWriteAsync(readCancellationToken))
{
if (handleLostItemsProc != null)
{
try
{
await handleLostItemsProc(item);
}
catch (Exception ex)
{
handlersError = ex;
}
}
Exception error = null;
try
{
await writer.Completion;
}
catch (Exception ex)
{
error = ex;
}
finally
{
try
{
await consumerCompletionPassthroughProc(error);
}
catch (Exception ex)
{
handlersError = ex;
}
}
return;
}
}
catch (Exception error)
{
try
{
if (handleLostItemsProc != null)
{
try
{
await handleLostItemsProc(item);
}
catch (Exception ex)
{
handlersError = ex;
}
}
}
finally
{
try
{
await consumerCompletionPassthroughProc(error, false);
}
catch (Exception ex)
{
handlersError = ex;
}
}
return;
}
}
}
}
finally
{
if (handlersError != null)
{
throw handlersError;
}
}
}
public static IChannelWriter <S> AdaptedInput <S, D>(this IChannelWriter <D> ext, Func <S, D> transform)
{
return(new FuncChannelInputAdapter <S, D>(ext, transform));
}
public static IChannel <T> Compose <T>(this IChannelReader <T> ext, IChannelWriter <T> source)
{
return(new CompositeChannel <T>(source, ext));
}
internal static void RemoveWriter <T>(IChannelWriter <T> writer)
{
_writers.Remove(writer);
}
public CompositeChannel(IChannelWriter <T> source, IChannelReader <T> destiantion)
{
_source = source;
_destiantion = destiantion;
}
public static IChannel <T> Compose <T>(this IChannelWriter <T> ext, IChannelReader <T> destination)
{
return(new CompositeChannel <T>(ext, destination));
}
public FuncChannelInputAdapter(IChannelWriter <D> channel, Func <S, D> transform)
: base(channel)
{
_func = transform;
}
/// <summary>
/// Initializes a new instance of the <see cref="WriterProxyWithDropOnErrors{T}"/> class.
/// </summary>
/// <param name="innerWriter">The inner writer.</param>
/// <param name="dropItemAction">The drop action.</param>
public WriterProxyWithDropOnErrors(IChannelWriter <T> innerWriter, Action <T> dropItemAction = null)
{
_innerWriter = innerWriter;
_dropItemAction = dropItemAction;
Completion = new ValueTask(_writeCompletionTcs.Task);
}
