public void Write(T value, int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
try
{
if (!Monitor.TryEnter(_channel, timeout))
{
throw new TimeoutException("Timeout locking queue.");
}
if (Closed)
{
throw new ChannelClosedException("Impossible to send on a colsed channel.");
}
IBasicProperties prop = _channel.CreateBasicProperties();
prop.ContentEncoding = "utf-8";
prop.ContentType = "application/json";
prop.Persistent = true;
prop.Headers = new Dictionary <string, object>();
prop.Headers.Add(ChannelsRabbitMQManager.Ask().HeadersNameWriterClosed, false);
prop.Headers.Add(ChannelsRabbitMQManager.Ask().HeadersNameWriterMessageType, typeof(T).AssemblyQualifiedName);
byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(value));
_channel.BasicPublish(ChannelsRabbitMQManager.Ask().SubscribableChannelCollectorExchange, $"{Name}.{SHA1HashStringForUTF8String(typeof(T).FullName)}", prop, data);
}
finally
{
Monitor.Exit(_channel);
}
}
}
public void Write(T value, int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
try
{
if (!Monitor.TryEnter(_subscribers, timeout))
{
throw new TimeoutException("Timeout locking queue.");
}
if (_closed)
{
throw new ChannelClosedException("Write end closed. Impossible to write.");
}
foreach (IChannelWriter <T> item in _subscribers.WriteBarrierWith(timeout))
{
if (!item.Closed)
{
item.Write(value, timeout);
}
}
}
finally
{
Monitor.Exit(_subscribers);
}
}
}
public IAbortableOperation <T> Consume(int timeoutMillis)
{
try
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
if (!Monitor.TryEnter(_buffer, timeout))
{
throw new TimeoutException("Timeout locking queue.");
}
while (_buffer.Count == 0)
{
if (Drained)
{
throw new ChannelDrainedException("Impossible to read other data, channel drained.");
}
_waitReadable.Reset();
if (!Monitor.Wait(_buffer, timeout))
{
throw new TimeoutException("Timeout waiting readable state.");
}
}
return(new AbortableOperationImpl <T>(_buffer.Peek(),
() =>
{
_buffer.Dequeue();
Monitor.PulseAll(_buffer);
_waitWriteable.Set();
if (_buffer.Count == 0)
{
_waitReadable.Reset();
}
Monitor.Exit(_buffer);
},
() =>
{
Monitor.Exit(_buffer);
}));
}
}
catch (Exception e)
{
if (Monitor.IsEntered(_buffer))
{
Monitor.Exit(_buffer);
}
throw e;
}
}
public void RunComponents()
{
TimeoutManager.Start(this);
CallbackBufferBlock.Start("CallbackBufferBlock", action =>
{
if (action.CompletedCallback != null)
{
action.CompletedCallback(action);
}
});
ActionCaseConsumer.Start("ActionCaseConsumer", HandleActionCaseInner);
}
public IAbortableOperation <T> Consume(int timeoutMillis)
{
try
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
if (!Monitor.TryEnter(_channel, timeout))
{
throw new TimeoutException("Timeout locking queue.");
}
while (_queue == null)
{
if (Drained)
{
throw new ChannelDrainedException("Impossible to read other data, channel drained.");
}
_waitReadable.Reset();
if (!Monitor.Wait(_channel, timeout))
{
throw new TimeoutException("Timeout waiting readable state.");
}
}
T temp = JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(_queue.Body));
return(new AbortableOperationImpl <T>(temp,
() =>
{
_channel.BasicAck(_queue.DeliveryTag, false);
_queue = null;
_waitReadable.Reset();
Monitor.Exit(_channel);
},
() =>
{
_channel.BasicNack(_queue.DeliveryTag, false, true);
_queue = null;
_waitReadable.Reset();
Monitor.Exit(_channel);
}));
}
}
catch (Exception e)
{
if (Monitor.IsEntered(_channel))
{
Monitor.Exit(_channel);
}
throw e;
}
}
public IAbortableOperation <T> Consume(int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
IAbortableOperation <T> rd = _source.Consume(timeout);
_destiantion.Write(Pipe(rd.Value), timeout);
IAbortableOperation <T> wr = _destiantion.Consume(timeout);
return(new AbortableOperationImpl <T>(wr.Value, () => { rd.Commit(); wr.Commit(); }, () => { wr.Abort(); rd.Abort(); }));
}
}
public void Consume(Action <T> action, int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
_source.Consume(t =>
{
T temp = Pipe(t);
_destiantion.Write(temp, timeout);
}, timeout);
_destiantion.Consume(action, timeout);
}
}
public T Read(int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
T temp;
_source.Consume(t =>
{
temp = Pipe(t);
_destiantion.Write(temp, timeout);
}, timeout);
return(_destiantion.Read(timeout));
}
}
public static IEnumerable <IChannelWriter <T> > Barrier <T>(int timeoutMillis, params IChannelWriter <T>[] channels)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
if (channels.Length > 0)
{
foreach (WaitHandle item in channels.Select(p => p.WaitWriteable))
{
if (!item.WaitOne(timeout))
{
return(null);
}
}
}
return(channels);
}
}
public void Write(T value, int timeoutMillis)
{
using (TimeoutManager timeout = TimeoutManager.Start(timeoutMillis))
{
try
{
if (!Monitor.TryEnter(_buffer, timeout))
{
throw new TimeoutException("Timeout locking queue.");
}
if (Closed)
{
throw new ChannelClosedException("Impossible to send on a colsed channel.");
}
while (_buffer.Count == _bufferSize)
{
_waitWriteable.Reset();
if (!Monitor.Wait(_buffer, timeout))
{
throw new TimeoutException("Timeout waiting writeable state.");
}
}
_buffer.Enqueue(value);
Monitor.PulseAll(_buffer);
_waitReadable.Set();
if (_buffer.Count == _bufferSize)
{
_waitWriteable.Reset();
}
}
finally
{
Monitor.Exit(_buffer);
}
}
}