public (T Message, Error Error) Receive()
{
var listener = new ReceiveListener <T>();
AddListener(listener);
return(listener.Result());
}
public ReceiveDeliveryRunnable(ReceiveListener listener, ReceivePacket entity, float progress, bool isEnd)
{
this.listener = listener;
this.entity = entity;
this.progress = progress;
this.isEnd = isEnd;
}
public EventDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkPoster += ExecutorDelivery_BlinkPoster;
mSendPoster += ExecutorDelivery_SendPoster;
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
public EventDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkPoster += ExecutorDelivery_BlinkPoster;
mSendPoster += ExecutorDelivery_SendPoster;
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
public void PostReceiveStart(ReceivePacket entity)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
PostQueue(new ReceiveStartDeliveryRunnable(listener, entity));
}
}
public void PostReceiveProgress(ReceivePacket entity, float progress)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
PostQueue(new ReceiveProgressDeliveryRunnable(listener, entity, progress));
}
}
public void PostReceiveStart(ReceivePacket entity)
{
ReceiveListener listener = mReceiveListener;
if (listener != null)
{
PostBlink(new ReceiveDeliveryRunnable(listener, entity, 0, false));
}
}
public void PostReceiveProgress(ReceivePacket entity, float progress)
{
ReceiveListener listener = mReceiveListener;
if (listener != null)
{
PostBlink(new ReceiveDeliveryRunnable(listener, entity, progress, false));
}
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="fileMark">File name mark to clear and create</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
String resourcePath,
String fileMark,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
return NewConnection(socket, DEFAULT_SOCKET_BUFFER_SIZE, resourcePath, fileMark, progressPrecision, receiveListener, blinkListener);
}
public void PostReceiveEnd(ReceivePacket entity, bool isSuccess)
{
ReceiveListener listener = mReceiveListener;
if (listener != null)
{
entity.SetSuccess(isSuccess);
PostBlink(new ReceiveDeliveryRunnable(listener, entity, 0, true));
}
}
public void PostReceiveEnd(ReceivePacket entity, bool isSuccess)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
entity.SetSuccess(isSuccess);
PostQueue(new ReceiveEndDeliveryRunnable(listener, entity));
}
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="fileMark">File name mark to clear and create</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
String resourcePath,
String fileMark,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
return(NewConnection(socket, DEFAULT_SOCKET_BUFFER_SIZE, resourcePath, fileMark, progressPrecision, receiveListener, blinkListener));
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
int socketBufferSize,
String resourcePath,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
return(NewConnection(socket, socketBufferSize, resourcePath, Guid.NewGuid().ToString(), progressPrecision, receiveListener, blinkListener));
}
private void Start()
{
_started = true;
StartCommand.RaiseCanExecuteChanged();
_receiver = new WebSocketReceiver(_uri, _repository.GetRepositoryHash());
var receiveListener = new ReceiveListener(_repository, _receiver);
receiveListener.Start();
}
public void PostReceiveProgress(ReceivePacket entity, float progress)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
PostQueue(() =>
{
listener.OnReceiveProgress(entity, progress);
});
}
}
public void PostReceiveStart(ReceivePacket entity)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
PostQueue(() =>
{
listener.OnReceiveStart(entity.GetPacketType(), entity.GetId());
});
}
}
public void PostReceiveEnd(ReceivePacket entity, bool isSuccess)
{
ReceiveListener listener = mReceiveListener;
if (listener != null && entity != null)
{
entity.SetSuccess(isSuccess);
PostQueue(() =>
{
listener.OnReceiveEnd(entity);
});
}
}
static void Main(string[] args)
{
var repository = new PlanetRepository();
var childRepository = new PlanetRepository();
var collection = new RepositoryObservableCollection <Planet>(childRepository);
/*
* var sendListener = new TestSendListener(repository);
* var receiver = new TestReceiver();
* var receiveListener = new ReceiveListener(childRepository, receiver);
* receiveListener.Start();
* sendListener.Listen(receiver);
*/
childRepository.SubscribeToRowAdded(r => Console.WriteLine("Row Added with Id {0}", r.RowId));
childRepository.SubscribeToRowRemoved(r => Console.WriteLine("Row Removed with Id {0}", r.RowId));
childRepository.SubscribeToCellUpdated(u => Console.WriteLine("Cell" + "Updated {0}:{1}:{2}", u.RowId, u.ColumnId, u));
var mercury = repository.AddRow("Mercury", 57900000, TimeSpan.FromDays(59), 0.38);
var venus = repository.AddRow("Venus", 108160000, TimeSpan.FromDays(243), 0.9);
var earth = repository.AddRow("Earth", 149600000, TimeSpan.FromHours(23) + TimeSpan.FromMinutes(56), 1);
var mars = repository.AddRow("Mars", 141700000, TimeSpan.FromHours(24) + TimeSpan.FromMinutes(37), 0.38);
var jupiter = repository.AddRow("Jupiter", 778369000, TimeSpan.FromHours(9) + TimeSpan.FromMinutes(55), 2.64);
var saturn = repository.AddRow("Saturn", 1427034000, TimeSpan.FromHours(10) + TimeSpan.FromMinutes(39), 1.16);
var uranus = repository.AddRow("Uranus", 2870658186, TimeSpan.FromHours(17) + TimeSpan.FromMinutes(14), 1.11);
var neptune = repository.AddRow("Neptune", 4496976000, TimeSpan.FromHours(16) + TimeSpan.FromMinutes(7), 1.21);
var sendListener = new WebSocketSendListener(repository);
var receiver = new WebSocketReceiver("ws://localhost:8080/planet", childRepository.GetRepositoryHash());
var receiveListener = new ReceiveListener(childRepository, receiver);
receiveListener.Start();
sendListener.Start("ws://0.0.0.0:8080/planet");
Console.ReadKey();
Console.WriteLine(childRepository.ToString());
venus.Set(repository.Gravity, 0.88);
saturn.Set(repository.DistanceFromSun, 1427034111);
repository.RemoveRow(uranus);
var uranus2 = repository.AddRow("Uranus II", 2870658186, TimeSpan.FromHours(17) + TimeSpan.FromMinutes(14), 1.11);
Console.WriteLine();
Console.WriteLine(childRepository.ToString());
Console.ReadKey();
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="socketBufferSize">Socket BufferSize</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="fileMark">File name mark to clear and create</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
int socketBufferSize,
String resourcePath,
String fileMark,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
String path = Path.Combine(resourcePath, DEFAULT_RESOURCE_DIR);
DiskResource resource = new DiskResource(path, fileMark);
BlinkParserImpl parser = new BlinkParserImpl(resource);
AsyncSocketAdapter socketAdapter = new AsyncSocketAdapter(socket, socketBufferSize);
DelegateDelivery delivery = new DelegateDelivery(blinkListener, receiveListener);
return new BlinkConn(socketAdapter, socketAdapter, delivery, delivery, delivery, resource, parser, progressPrecision);
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="socketBufferSize">Socket BufferSize</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="fileMark">File name mark to clear and create</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
int socketBufferSize,
String resourcePath,
String fileMark,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
String path = Path.Combine(resourcePath, DEFAULT_RESOURCE_DIR);
DiskResource resource = new DiskResource(path, fileMark);
BlinkParserImpl parser = new BlinkParserImpl(resource);
AsyncSocketAdapter socketAdapter = new AsyncSocketAdapter(socket, socketBufferSize);
DelegateDelivery delivery = new DelegateDelivery(blinkListener, receiveListener);
return(new BlinkConn(socketAdapter, socketAdapter, delivery, delivery, delivery, resource, parser, progressPrecision));
}
public void Run()
{
if (listener != null)
{
if (progress > 0)
{
listener.OnReceiveProgress(entity, progress);
}
else if (isEnd)
{
listener.OnReceiveEnd(entity);
}
else
{
listener.OnReceiveStart(entity.GetPacketType(), entity.GetId());
}
}
entity = null;
listener = null;
}
public CallBackDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
public void Run()
{
listener.OnReceiveEnd(entity);
entity = null;
listener = null;
}
public ReceiveDeliveryRunnable(ReceiveListener listener, ReceivePacket entity, float progress, bool isEnd)
{
this.listener = listener;
this.entity = entity;
this.progress = progress;
this.isEnd = isEnd;
}
public ReceiveStartDeliveryRunnable(ReceiveListener listener, ReceivePacket entity)
{
this.listener = listener;
this.entity = entity;
}
public ReceiveProgressDeliveryRunnable(ReceiveListener listener, ReceivePacket entity, float progress)
{
this.listener = listener;
this.entity = entity;
this.progress = progress;
}
public void SendThrowIfStartedWithoutReceivers()
{
SetupListener(CorrelationIdState.DoNotUse);
_listener = new ReceiveListener(QueueEndpointProvider, RabbitMqFactory, ChannelConfigurator, ErrorHandler);
_listener.Start("testendpoint");
}
public void Run()
{
listener.OnReceiveStart(entity.GetPacketType(), entity.GetId());
entity = null;
listener = null;
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(Socket socket, ReceiveListener receiveListener, BlinkListener blinkListener)
{
return NewConnection(socket, DEFAULT_SOCKET_BUFFER_SIZE, GetDefaultResourcePath(), Guid.NewGuid().ToString(), DEFAULT_PROGRESS_PRECISION, receiveListener, blinkListener);
}
public DelegateDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(Socket socket, String resourcePath, ReceiveListener receiveListener, BlinkListener blinkListener)
{
return(NewConnection(socket, DEFAULT_SOCKET_BUFFER_SIZE, resourcePath, Guid.NewGuid().ToString(), DEFAULT_PROGRESS_PRECISION, receiveListener, blinkListener));
}
public DelegateDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
public void Cleanup()
{
_listener = null;
}
public void Run()
{
listener.OnReceiveStart(entity.GetPacketType(), entity.GetId());
entity = null;
listener = null;
}
public ReceiveEndDeliveryRunnable(ReceiveListener listener, ReceivePacket entity)
{
this.listener = listener;
this.entity = entity;
}
public void Run()
{
listener.OnReceiveProgress(entity, progress);
entity = null;
listener = null;
}
public ReceiveProgressDeliveryRunnable(ReceiveListener listener, ReceivePacket entity, float progress)
{
this.listener = listener;
this.entity = entity;
this.progress = progress;
}
/// <summary>
/// Destroy the event
/// </summary>
public void Dispose()
{
mBlinkListener = null;
mReceiveListener = null;
mQueue.Clear();
}
/// <summary>
/// Create a Bink connection by socket
/// </summary>
/// <param name="socket">Socket</param>
/// <param name="resourcePath">File Resource Path</param>
/// <param name="progressPrecision">Send and Receive notify progress precision</param>
/// <param name="receiveListener">ReceiveListener</param>
/// <param name="blinkListener">BlinkListener</param>
/// <returns>BlinkConn</returns>
public static BlinkConn NewConnection(
Socket socket,
int socketBufferSize,
String resourcePath,
float progressPrecision,
ReceiveListener receiveListener,
BlinkListener blinkListener)
{
return NewConnection(socket, socketBufferSize, resourcePath, Guid.NewGuid().ToString(), progressPrecision, receiveListener, blinkListener);
}
public void Run()
{
listener.OnReceiveEnd(entity);
entity = null;
listener = null;
}
public ReceiverStub(ReceiveListener listener)
{
_listener = listener;
}
public void Run()
{
listener.OnReceiveProgress(entity, progress);
entity = null;
listener = null;
}
public ReceiverThatThrowsException(ReceiveListener listener)
: base(listener)
{
}
public CallBackDelivery(BlinkListener blinkListener, ReceiveListener receiveListener)
{
mBlinkListener = blinkListener;
mReceiveListener = receiveListener;
}
public void Run()
{
if (listener != null)
{
if (progress > 0)
listener.OnReceiveProgress(entity, progress);
else if (isEnd)
listener.OnReceiveEnd(entity);
else
listener.OnReceiveStart(entity.GetPacketType(), entity.GetId());
}
entity = null;
listener = null;
}
/// <summary>
/// Destroy the event
/// </summary>
public void Dispose()
{
mBlinkListener = null;
mReceiveListener = null;
mQueue.Clear();
}
private void SetupListener(CorrelationIdState correlationIdState, bool rethrowExceptions = false, string routingKey = "")
{
BasicProperties = MockRepository.GenerateStub<IBasicProperties>();
CreateConsumerMock(correlationIdState, routingKey);
SetupQueueEndpointProvider("testendpoint", "vhost", "testqueue");
SetupRabbitMqFactory();
SetupErrorHandler(rethrowExceptions);
_listener = new ReceiveListener(QueueEndpointProvider, RabbitMqFactory, ChannelConfigurator, ErrorHandler);
}
