private EchoServer(Aeron in_aeron, IPEndPoint in_local_address)
{
this.aeron = in_aeron ?? throw new ArgumentNullException(nameof(in_aeron));
this.local_address = in_local_address ?? throw new ArgumentNullException(nameof(in_local_address));
this.clients = new Dictionary <int, ServerClient>(32);
}
public static void Main()
{
const string channel = "aeron:ipc";
const int streamId = 42;
var buffer = new UnsafeBuffer(new byte[256]);
var handler = HandlerHelper.ToFragmentHandler(PrintMessage);
try
{
using (var aeron = Aeron.Connect())
using (var publisher = aeron.AddPublication(channel, streamId))
using (var subscriber = aeron.AddSubscription(channel, streamId))
{
var message = buffer.PutStringWithoutLengthUtf8(0, "Hello World!");
publisher.Offer(buffer, 0, message);
Console.WriteLine("Message sent...");
while (subscriber.Poll(handler, 1) == 0)
{
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
public static void Main()
{
var ctx = new Aeron.Context()
.AvailableImageHandler(SamplesUtil.PrintAvailableImage)
.UnavailableImageHandler(SamplesUtil.PrintUnavailableImage);
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
Console.WriteLine("Subscribing Ping at " + PingChannel + " on stream Id " + PingStreamID);
Console.WriteLine("Publishing Pong at " + PongChannel + " on stream Id " + PongStreamID);
var running = new AtomicBoolean(true);
Console.CancelKeyPress += (_, e) => running.Set(false);
using (var aeron = Aeron.Connect(ctx))
using (var pongPublication = aeron.AddPublication(PongChannel, PongStreamID))
using (var pingSubscription = aeron.AddSubscription(PingChannel, PingStreamID))
{
FragmentHandler dataHandler = (buffer, offset, length, header) => PingHandler(pongPublication, buffer, offset, length);
while (running.Get())
{
idleStrategy.Idle(pingSubscription.Poll(dataHandler, FrameCountLimit));
}
Console.WriteLine("Shutting down...");
}
}
public static void Main()
{
Console.WriteLine("Subscribing to " + Channel + " on stream Id " + StreamID);
var ctx = new Aeron.Context()
.AvailableImageHandler(SamplesUtil.PrintUnavailableImage)
.UnavailableImageHandler(SamplesUtil.PrintUnavailableImage);
var reporter = new RateReporter(1000, SamplesUtil.PrintRate);
var fragmentAssembler = new FragmentAssembler(SamplesUtil.RateReporterHandler(reporter));
var running = new AtomicBoolean(true);
var t = new Thread(subscription => SamplesUtil.SubscriberLoop(fragmentAssembler.OnFragment, FragmentCountLimit, running)((Subscription)subscription));
var report = new Thread(reporter.Run);
using (var aeron = Aeron.Connect(ctx))
using (var subscription = aeron.AddSubscription(Channel, StreamID))
{
t.Start(subscription);
report.Start();
Console.ReadLine();
Console.WriteLine("Shutting down...");
running.Set(false);
reporter.Halt();
t.Join();
report.Join();
}
}
/// <summary>
/// Creates a new Aeron source with the specified parameters.
/// </summary>
/// <param name="aeron">the Aeron connection to use</param>
/// <param name="stream">the Aeron stream ID to use</param>
/// <param name="channel">the Aeron channel to use</param>
/// <param name="bufferSize">the data buffer size to use (in bytes)</param>
public Source(Aeron aeron, int stream, string channel, int bufferSize)
{
_stream = stream;
_channel = channel;
_buffer = new UnsafeBuffer(BufferUtil.AllocateDirectAligned(bufferSize, BitUtil.CACHE_LINE_LENGTH));
_publication = aeron.AddPublication(_channel, _stream);
}
public HelloWorldSender(
Aeron in_aeron,
IPEndPoint in_remote_address)
{
this.aeron = in_aeron ?? throw new ArgumentNullException(nameof(in_aeron));
this.remote_address = in_remote_address ?? throw new ArgumentNullException(nameof(in_remote_address));
}
public ServerClient(int session, Image in_image, Aeron in_aeron)
{
this.session = session;
this.image = in_image ?? throw new ArgumentNullException(nameof(in_image));
this.aeron = in_aeron ?? throw new ArgumentNullException(nameof(in_aeron));
this.state = State.INITIAL;
this.buffer = new UnsafeBuffer(BufferUtil.AllocateDirectAligned(2048, 16));
}
/// <summary>
/// Creates a new Aeron source using UDP with the specified parameters.
/// </summary>
/// <param name="aeron">the Aeron connection to use</param>
/// <param name="stream">the Aeron stream ID to use</param>
/// <param name="address">the UDP address to use</param>
/// <param name="port">the UDP port to use</param>
/// <param name="interface">the local interface to bind to</param>
/// <param name="bufferSize">the data buffer size to use (in bytes)</param>
public Source(Aeron aeron, int stream, string address, int port, string @interface, int bufferSize)
: this(
aeron,
stream,
string.Format("aeron:udp?endpoint={0}:{1}|interface={2}", address, port, @interface),
bufferSize
)
{
}
/// <summary>
/// Creates a new Aeron source using UDP with the specified parameters.
/// </summary>
/// <param name="aeron">the Aeron connection to use</param>
/// <param name="stream">the Aeron stream ID to use</param>
/// <param name="address">the UDP address to use</param>
/// <param name="port">the UDP port to use</param>
/// <param name="bufferSize">the data buffer size to use (in bytes)</param>
public Source(Aeron aeron, int stream, string address, int port, int bufferSize)
: this(
aeron,
stream,
string.Format("aeron:udp?endpoint={0}:{1}", address, port),
bufferSize
)
{
}
public EchoClient(
Aeron in_aeron,
IPEndPoint in_local_address,
IPEndPoint in_remote_address)
{
this.aeron = in_aeron ?? throw new ArgumentNullException(nameof(in_aeron));
this.local_address = in_local_address ?? throw new ArgumentNullException(nameof(in_local_address));
this.remote_address = in_remote_address ?? throw new ArgumentNullException(nameof(in_remote_address));
}
public static async Task Main(string[] args)
{
var listenPort = ushort.Parse(args[0]);
var servicePort = ushort.Parse(args[1]);
var seeds = args.Skip(2).Select(Utils.IPEndPointFromString).ToArray();
var logger = Utils.CreateLogger <Program>();
var gossiper = await StartGossiper(listenPort, servicePort, seeds, logger);
const int fragmentLimitCount = 10;
string channel = "aeron:udp?endpoint=localhost:" + servicePort;
// A unique identifier for a stream within a channel. Stream ID 0 is reserved
// for internal use and should not be used by applications.
const int streamId = 10;
Console.WriteLine("Subscribing to " + channel + " on stream Id " + streamId);
// dataHandler method is called for every new datagram received
var fragmentHandler = HandlerHelper.ToFragmentHandler((buffer, offset, length, header) =>
{
var data = new byte[length];
buffer.GetBytes(offset, data);
Console.WriteLine($"Received message ({Encoding.UTF8.GetString(data)}) to stream {streamId:D} from session {header.SessionId:x} term id {header.TermId:x} term offset {header.TermOffset:D} ({length:D}@{offset:D})");
});
// Create a context, needed for client connection to media driver
// A separate media driver process need to run prior to running this application
var ctx = new Aeron.Context();
// Create an Aeron instance with client-provided context configuration, connect to the
// media driver, and add a subscription for the given channel and stream using the supplied
// dataHandler method, which will be called with new messages as they are received.
// The Aeron and Subscription classes implement AutoCloseable, and will automatically
// clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(ctx))
using (var subscription = aeron.AddSubscription(channel, streamId))
{
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
// Try to read the data from subscriber
while (true)
{
// poll delivers messages to the dataHandler as they arrive
// and returns number of fragments read, or 0
// if no data is available.
var fragmentsRead = subscription.Poll(fragmentHandler, fragmentLimitCount);
// Give the IdleStrategy a chance to spin/yield/sleep to reduce CPU
// use if no messages were received.
idleStrategy.Idle(fragmentsRead);
}
}
}
static void Run(Options options)
{
var fragmentCount = 0L;
try
{
using var aeron = Aeron.Connect();
Console.WriteLine($"Connected to Aeron {aeron.ClientId.ToString()}");
using var subscription = aeron.AddSubscription(options.Channel, options.StreamId);
using var cts = new CancellationTokenSource();
var messageDecoder = new MessageDecoder();
var messageReceiver = new MessageReceiver(subscription, messageDecoder, OnDataValue);
var ct = cts.Token;
var pollingTask = Task.Run(async() =>
{
while (!ct.IsCancellationRequested)
{
var fragmentsProcessed = messageReceiver.Poll();
if (fragmentsProcessed == 0)
{
await Task.Delay(TimeSpan.FromMilliseconds(10), ct);
}
else
{
fragmentCount += fragmentsProcessed;
}
}
}, ct);
Console.CancelKeyPress += (o, args) =>
{
args.Cancel = true;
Console.Out.WriteLine("Cancel key event intercepted");
cts.Cancel();
};
pollingTask.GetAwaiter().GetResult();
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
Console.WriteLine($"Unhandled Exception: {e}");
}
finally
{
Console.Out.WriteLine($"Received {fragmentCount} fragments");
Console.WriteLine("Subscriber finished");
}
}
public IServiceClient CreateServiceClient(IPEndPoint serviceEndPoint)
{
string channel = "aeron:udp?endpoint=" + serviceEndPoint.ToString();
var ctx = new Aeron.Context();
var aeron = Aeron.Connect(ctx);
var publication = aeron.AddPublication(channel, 10);
return(new AeronServiceClient
{
ServiceEndPoint = serviceEndPoint,
Publication = publication
});
}
/// <summary>
/// Creates a new Aeron target with the specified parameters.
/// </summary>
/// <param name="aeron">the Aeron connection to use</param>
/// <param name="stream">the Aeron stream ID to use</param>
/// <param name="channel">the Aeron channel to use</param>
/// <param name="idleStrategy">the Aeron idle strategy to use</param>
/// <param name="fragmentLimit">the number of message fragments to process per poll operation</param>
public Target(
Aeron aeron,
int stream,
string channel,
IIdleStrategy idleStrategy,
int fragmentLimit
)
{
_stream = stream;
_channel = channel;
_subscription = aeron.AddSubscription(_channel, _stream);
_idleStrategy = idleStrategy;
_fragmentLimit = fragmentLimit;
}
public static void Main()
{
var ctx = new Aeron.Context()
.AvailableImageHandler(AvailablePongImageHandler);
var fragmentAssembler = new FragmentAssembler(HandlerHelper.ToFragmentHandler(PongHandler));
Console.WriteLine("Publishing Ping at " + PingChannel + " on stream Id " + PingStreamID);
Console.WriteLine("Subscribing Pong at " + PongChannel + " on stream Id " + PongStreamID);
Console.WriteLine("Message length of " + MessageLength + " bytes");
using (var aeron = Aeron.Connect(ctx))
{
Console.WriteLine("Warming up... " + WarmupNumberOfIterations + " iterations of " + WarmupNumberOfMessages + " messages");
using (var publication = aeron.AddPublication(PingChannel, PingStreamID))
using (var subscription = aeron.AddSubscription(PongChannel, PongStreamID))
using (var byteBuffer = BufferUtil.AllocateDirectAligned(MessageLength, BitUtil.CACHE_LINE_LENGTH))
using (var atomicBuffer = new UnsafeBuffer(byteBuffer))
{
Latch.Wait();
for (var i = 0; i < WarmupNumberOfIterations; i++)
{
RoundTripMessages(atomicBuffer, fragmentAssembler, publication, subscription, WarmupNumberOfMessages);
}
Thread.Sleep(100);
do
{
Histogram.Reset();
Console.WriteLine("Pinging " + NumberOfMessages + " messages");
RoundTripMessages(atomicBuffer, fragmentAssembler, publication, subscription, NumberOfMessages);
Console.WriteLine("Histogram of RTT latencies in microseconds.");
Histogram.OutputPercentileDistribution(Console.Out, outputValueUnitScalingRatio: 1000);
} while (Console.Read() == 'y');
}
}
}
private void Run()
{
const int OneKb = 1024;
const int OneMb = OneKb * 1024;
var testStreamId = 99;
var channel = "aeron:ipc";
var maxMsgLength = OneMb;
// Maximum number of message fragments to receive during a single 'poll' operation
const int fragmentLimitCount = 10;
Console.WriteLine("Subscribing to " + channel + " on stream Id " + testStreamId);
// Create a context, needed for client connection to media driver
// A separate media driver process need to run prior to running this application
// Create an Aeron instance with client-provided context configuration, connect to the
// media driver, and add a subscription for the given channel and stream using the supplied
// dataHandler method, which will be called with new messages as they are received.
// The Aeron and Subscription classes implement AutoCloseable, and will automatically
// clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(new Aeron.Context()))
using (var subscription = aeron.AddSubscription(channel, testStreamId))
{
IIdleStrategy idleStrategy = new SpinWaitIdleStrategy();
// Try to read the data from subscriber
while (_stopping.Get())
{
// poll delivers messages to the dataHandler as they arrive
// and returns number of fragments read, or 0
// if no data is available.
var fragmentsRead = subscription.Poll(new FragmentAssembler((buffer, offset, length, header) => {}), fragmentLimitCount);
// Give the IdleStrategy a chance to spin/yield/sleep to reduce CPU
// use if no messages were received.
idleStrategy.Idle(fragmentsRead);
}
}
}
public BasicAeronSpec()
{
BasicConfigurator.Configure();
_testDataSent = 0;
_testDataReceived = 0;
_testDataHandler = (data, length) => { _testDataReceived += length; };
const string channel = "aeron:ipc";
const int stream = 42;
_aeron = Aeron.Connect(Defaults.GetNewSystemContext());
_source = new Source(_aeron, stream, channel, Defaults.BufferSize);
_target = new Target(_aeron, stream, channel, Defaults.IdleStrategy, Defaults.FragmentLimit);
_testByteArraySize = 1000;
_rnd = new Random();
}
public static EchoServer Create(DirectoryInfo media_directory, IPEndPoint local_address)
{
string directory = media_directory is not null && media_directory.Exists ? media_directory.FullName : throw new DirectoryNotFoundException();
var aeron_context = new Aeron.Context().AeronDirectoryName(directory);
Aeron aeron = null;
try
{
aeron = Aeron.Connect(aeron_context);
}
catch
{
aeron?.Dispose();
throw;
}
return(new EchoServer(aeron, local_address));
}
public static void Main()
{
ComputerSpecifications.Dump();
var running = new AtomicBoolean(true);
using (var aeron = Aeron.Connect())
using (var publication = aeron.AddExclusivePublication(Channel, StreamID))
using (var subscription = aeron.AddSubscription(Channel, StreamID))
{
var subscriber = new Subscriber(running, subscription);
var subscriberThread = new Thread(subscriber.Run)
{
Name = "subscriber"
};
var publisherThread = new Thread(new Publisher(running, publication).Run)
{
Name = "publisher"
};
var rateReporterThread = new Thread(new RateReporter(running, subscriber).Run)
{
Name = "rate-reporter"
};
rateReporterThread.Start();
subscriberThread.Start();
publisherThread.Start();
Console.WriteLine("Press any key to stop...");
Console.Read();
running.Set(false);
subscriberThread.Join();
publisherThread.Join();
rateReporterThread.Join();
}
}
public static void Main()
{
// Maximum number of message fragments to receive during a single 'poll' operation
const int fragmentLimitCount = 10;
// The channel (an endpoint identifier) to receive messages from
const string channel = "aeron:udp?endpoint=localhost:40123";
// A unique identifier for a stream within a channel. Stream ID 0 is reserved
// for internal use and should not be used by applications.
const int streamId = 10;
Console.WriteLine("Subscribing to " + channel + " on stream Id " + streamId);
var running = new AtomicBoolean(true);
// Register a SIGINT handler for graceful shutdown.
Console.CancelKeyPress += (s, e) => running.Set(false);
// dataHandler method is called for every new datagram received
FragmentHandler fragmentHandler = (buffer, offset, length, header) =>
{
var data = new byte[length];
buffer.GetBytes(offset, data);
Console.WriteLine($"Received message ({Encoding.UTF8.GetString(data)}) to stream {streamId:D} from session {header.SessionId:x} term id {header.TermId:x} term offset {header.TermOffset:D} ({length:D}@{offset:D})");
// Received the intended message, time to exit the program
running.Set(false);
};
// Create a context, needed for client connection to media driver
// A separate media driver process need to run prior to running this application
var ctx = new Aeron.Context();
// Create an Aeron instance with client-provided context configuration, connect to the
// media driver, and add a subscription for the given channel and stream using the supplied
// dataHandler method, which will be called with new messages as they are received.
// The Aeron and Subscription classes implement AutoCloseable, and will automatically
// clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(ctx))
using (var subscription = aeron.AddSubscription(channel, streamId))
{
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
// Try to read the data from subscriber
while (running.Get())
{
// poll delivers messages to the dataHandler as they arrive
// and returns number of fragments read, or 0
// if no data is available.
var fragmentsRead = subscription.Poll(fragmentHandler, fragmentLimitCount);
// Give the IdleStrategy a chance to spin/yield/sleep to reduce CPU
// use if no messages were received.
idleStrategy.Idle(fragmentsRead);
}
Console.WriteLine("Press any key...");
Console.ReadLine();
}
}
public void SetUp()
{
MockClientErrorHandler = A.Fake <ErrorHandler>(options => options.Wrapping(throwable =>
{
if (!SuppressPrintError)
{
Console.WriteLine(throwable.ToString());
Console.Write(throwable.StackTrace);
}
}));
PublicationReady = new PublicationBuffersReadyFlyweight();
SubscriptionReady = new SubscriptionReadyFlyweight();
OperationSuccess = new OperationSucceededFlyweight();
ErrorResponse = new ErrorResponseFlyweight();
ClientTimeout = new ClientTimeoutFlyweight();
PublicationReadyBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
SubscriptionReadyBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
OperationSuccessBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
ErrorMessageBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
ClientTimeoutBuffer = new UnsafeBuffer(new byte[SEND_BUFFER_CAPACITY]);
CounterValuesBuffer = new UnsafeBuffer(new byte[COUNTER_BUFFER_LENGTH]);
MockToClientReceiver = A.Fake <CopyBroadcastReceiver>();
MockAvailableImageHandler = A.Fake <AvailableImageHandler>();
MockUnavailableImageHandler = A.Fake <UnavailableImageHandler>();
MockCloseHandler = A.Fake <Action>();
LogBuffersFactory = A.Fake <ILogBuffersFactory>();
DriverProxy = A.Fake <DriverProxy>();
MockAeron = A.Fake <Aeron>();
A.CallTo(() => mockClientLock.TryLock()).Returns(true);
A.CallTo(() => DriverProxy.AddPublication(CHANNEL, STREAM_ID_1)).Returns(CORRELATION_ID);
A.CallTo(() => DriverProxy.AddPublication(CHANNEL, STREAM_ID_2)).Returns(CORRELATION_ID_2);
A.CallTo(() => DriverProxy.RemovePublication(CORRELATION_ID)).Returns(CLOSE_CORRELATION_ID);
A.CallTo(() => DriverProxy.AddSubscription(A <string> ._, A <int> ._)).Returns(CORRELATION_ID);
A.CallTo(() => DriverProxy.RemoveSubscription(CORRELATION_ID)).Returns(CLOSE_CORRELATION_ID);
Aeron.Context ctx = new Aeron.Context()
.ClientLock(mockClientLock)
.EpochClock(EpochClock)
.NanoClock(NanoClock)
.ToClientBuffer(MockToClientReceiver)
.DriverProxy(DriverProxy)
.LogBuffersFactory(LogBuffersFactory)
.ErrorHandler(MockClientErrorHandler)
.AvailableImageHandler(MockAvailableImageHandler)
.UnavailableImageHandler(MockUnavailableImageHandler)
.CloseHandler(MockCloseHandler)
.KeepAliveIntervalNs(KEEP_ALIVE_INTERVAL)
.DriverTimeoutMs(AWAIT_TIMEOUT)
.InterServiceTimeoutNs(INTER_SERVICE_TIMEOUT_MS * 1000000)
.CountersValuesBuffer(CounterValuesBuffer);
Conductor = new ClientConductor(ctx, MockAeron);
PublicationReady.Wrap(PublicationReadyBuffer, 0);
SubscriptionReady.Wrap(SubscriptionReadyBuffer, 0);
OperationSuccess.Wrap(OperationSuccessBuffer, 0);
ErrorResponse.Wrap(ErrorMessageBuffer, 0);
ClientTimeout.Wrap(ClientTimeoutBuffer, 0);
PublicationReady.CorrelationId(CORRELATION_ID);
PublicationReady.RegistrationId(CORRELATION_ID);
PublicationReady.SessionId(SESSION_ID_1);
PublicationReady.StreamId(STREAM_ID_1);
PublicationReady.LogFileName(SESSION_ID_1 + "-log");
OperationSuccess.CorrelationId(CLOSE_CORRELATION_ID);
var termBuffersSession1 = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
var termBuffersSession2 = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
termBuffersSession1[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
termBuffersSession2[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
}
UnsafeBuffer logMetaDataSession1 = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
UnsafeBuffer logMetaDataSession2 = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
IMutableDirectBuffer header1 = DataHeaderFlyweight.CreateDefaultHeader(SESSION_ID_1, STREAM_ID_1, 0);
IMutableDirectBuffer header2 = DataHeaderFlyweight.CreateDefaultHeader(SESSION_ID_2, STREAM_ID_2, 0);
LogBufferDescriptor.StoreDefaultFrameHeader(logMetaDataSession1, header1);
LogBufferDescriptor.StoreDefaultFrameHeader(logMetaDataSession2, header2);
var logBuffersSession1 = A.Fake <LogBuffers>();
var logBuffersSession2 = A.Fake <LogBuffers>();
A.CallTo(() => LogBuffersFactory.Map(SESSION_ID_1 + "-log")).Returns(logBuffersSession1);
A.CallTo(() => LogBuffersFactory.Map(SESSION_ID_2 + "-log")).Returns(logBuffersSession2);
A.CallTo(() => logBuffersSession1.DuplicateTermBuffers()).Returns(termBuffersSession1);
A.CallTo(() => logBuffersSession2.DuplicateTermBuffers()).Returns(termBuffersSession2);
A.CallTo(() => logBuffersSession1.MetaDataBuffer()).Returns(logMetaDataSession1);
A.CallTo(() => logBuffersSession2.MetaDataBuffer()).Returns(logMetaDataSession2);
A.CallTo(() => logBuffersSession1.TermLength()).Returns(TERM_BUFFER_LENGTH);
A.CallTo(() => logBuffersSession2.TermLength()).Returns(TERM_BUFFER_LENGTH);
}
public SubscriptionCollection(Aeron aeron)
{
_aeron = aeron;
}
public AeronSubscription(string channel, int streamId, Aeron aeron)
: this(aeron.AddSubscription(channel, streamId))
{
}
public static void Main()
{
ComputerSpecifications.Dump();
var reporter = new RateReporter(1000, PrintRate);
var rateReporterHandler = SamplesUtil.RateReporterHandler(reporter);
var context = new Aeron.Context();
var running = new AtomicBoolean(true);
var reportThread = new Thread(reporter.Run);
var subscribeThread = new Thread(subscription => SamplesUtil.SubscriberLoop(rateReporterHandler, FragmentCountLimit, running)((Subscription)subscription));
using (var aeron = Aeron.Connect(context))
using (var publication = aeron.AddPublication(Channel, StreamID))
using (var subscription = aeron.AddSubscription(Channel, StreamID))
using (var byteBuffer = BufferUtil.AllocateDirectAligned(MessageLength, BitUtil.CACHE_LINE_LENGTH))
using (var buffer = new UnsafeBuffer(byteBuffer))
{
reportThread.Start();
subscribeThread.Start(subscription);
do
{
Console.WriteLine("Streaming {0:G} messages of size {1:G} bytes to {2} on stream Id {3}", NumberOfMessages, MessageLength, Channel, StreamID);
_printingActive = true;
long backPressureCount = 0;
for (long i = 0; i < NumberOfMessages; i++)
{
buffer.PutLong(0, i);
OfferIdleStrategy.Reset();
while (publication.Offer(buffer, 0, buffer.Capacity) < 0)
{
OfferIdleStrategy.Idle();
backPressureCount++;
}
}
Console.WriteLine("Done streaming. backPressureRatio=" + (double)backPressureCount / NumberOfMessages);
if (0 < LingerTimeoutMs)
{
Console.WriteLine("Lingering for " + LingerTimeoutMs + " milliseconds...");
Thread.Sleep((int)LingerTimeoutMs);
}
_printingActive = false;
} while (Console.ReadLine() != "x");
reporter.Halt();
running.Set(false);
if (!subscribeThread.Join(5000))
{
Console.WriteLine("Warning: not all tasks completed promptly");
}
}
}
static void Run(Options options)
{
var senderId = 1;
Console.Out.WriteLine($"Sending messages periodically every {options.SenderPeriod}");
var counter = 0;
try
{
Console.WriteLine("Publisher started");
using var aeron = Aeron.Connect();
Console.WriteLine($"Connected to Aeron {aeron.ClientId.ToString()}");
using var publication = aeron.AddPublication(options.Channel, options.StreamId);
var encoder = new MessageEncoder(senderId);
var sender = new MessageSender(publication, encoder);
using var cts = new CancellationTokenSource();
var ct = cts.Token;
var offerTask = Task.Run(async() =>
{
while (!ct.IsCancellationRequested)
{
var sendResult = sender.Send();
if (sendResult >= 0)
{
++counter;
}
else
{
switch (sendResult)
{
case Publication.NOT_CONNECTED:
Console.Out.WriteLine("Send failed: no one connected");
break;
case Publication.BACK_PRESSURED:
Console.Out.WriteLine("Send failed: back pressured");
break;
default:
Console.Out.WriteLine($"Send failed: error code -> {sendResult}");
break;
}
}
// Wait for the sender period before trying again.
await Task.Delay(options.SenderPeriod, ct);
}
}, ct);
Console.CancelKeyPress += (o, args) =>
{
args.Cancel = true;
Console.Out.WriteLine("Cancel key event intercepted");
cts.Cancel();
};
offerTask.GetAwaiter().GetResult();
}
catch (OperationCanceledException)
{
Console.Out.WriteLine("Main loop cancelled.");
// we were terminated - ignore this.
}
catch (Exception e)
{
Console.WriteLine($"Unhandled Exception: {e}");
}
finally
{
Console.Out.WriteLine($"Sent {counter} messages");
Console.WriteLine("Publisher finished");
}
}
public static void Main()
{
// Allocate enough buffer size to hold maximum message length
// The UnsafeBuffer class is part of the Agrona library and is used for efficient buffer management
var buffer = new UnsafeBuffer(BufferUtil.AllocateDirectAligned(512, BitUtil.CACHE_LINE_LENGTH));
// The channel (an endpoint identifier) to send the message to
const string channel = "aeron:udp?endpoint=localhost:40123";
// A unique identifier for a stream within a channel. Stream ID 0 is reserved
// for internal use and should not be used by applications.
const int streamId = 10;
Console.WriteLine("Publishing to " + channel + " on stream Id " + streamId);
// Create a context, needed for client connection to media driver
// A separate media driver process needs to be running prior to starting this application
var ctx = new Aeron.Context();
// Create an Aeron instance with client-provided context configuration and connect to the
// media driver, and create a Publication. The Aeron and Publication classes implement
// AutoCloseable, and will automatically clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(ctx))
using (var publication = aeron.AddPublication(channel, streamId))
{
Thread.Sleep(100);
const string message = "Hello World! ";
var messageBytes = Encoding.UTF8.GetBytes(message);
buffer.PutBytes(0, messageBytes);
// Try to publish the buffer. 'offer' is a non-blocking call.
// If it returns less than 0, the message was not sent, and the offer should be retried.
var result = publication.Offer(buffer, 0, messageBytes.Length);
if (result < 0L)
{
switch (result)
{
case Publication.BACK_PRESSURED:
Console.WriteLine(" Offer failed due to back pressure");
break;
case Publication.NOT_CONNECTED:
Console.WriteLine(" Offer failed because publisher is not connected to subscriber");
break;
case Publication.ADMIN_ACTION:
Console.WriteLine("Offer failed because of an administration action in the system");
break;
case Publication.CLOSED:
Console.WriteLine("Offer failed publication is closed");
break;
default:
Console.WriteLine(" Offer failed due to unknown reason");
break;
}
}
else
{
Console.WriteLine(" yay !!");
}
Console.WriteLine("Done sending.");
Console.WriteLine("Press any key...");
Console.ReadLine();
}
}
public static void Main()
{
if (MessageLength < BitUtil.SIZE_OF_LONG)
{
throw new ArgumentException($"Message length must be at least {BitUtil.SIZE_OF_LONG:D} bytes");
}
ComputerSpecifications.Dump();
var context = new Aeron.Context();
var reporter = new RateReporter(1000, PrintRate);
_reporterThread = new Thread(_ => reporter.Run());
_reporterThread.Start();
// Connect to media driver and add publication to send messages on the configured channel and stream ID.
// The Aeron and Publication classes implement AutoCloseable, and will automatically
// clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(context))
using (var publication = aeron.AddPublication(Channel, StreamID))
using (var byteBuffer = BufferUtil.AllocateDirectAligned(MessageLength, BitUtil.CACHE_LINE_LENGTH))
using (var buffer = new UnsafeBuffer(byteBuffer))
{
do
{
_printingActive = true;
Console.WriteLine($"Streaming {NumberOfMessages} messages of {(RandomMessageLength ? " random" : "")} size {MessageLength} bytes to {Channel} on stream Id {StreamID}");
long backPressureCount = 0;
for (long i = 0; i < NumberOfMessages; i++)
{
var length = LengthGenerator.AsInt;
buffer.PutLong(0, i);
OfferIdleStrategy.Reset();
while (publication.Offer(buffer, 0, length) < 0L)
{
// The offer failed, which is usually due to the publication
// being temporarily blocked. Retry the offer after a short
// spin/yield/sleep, depending on the chosen IdleStrategy.
backPressureCount++;
OfferIdleStrategy.Idle();
}
reporter.OnMessage(1, length);
}
Console.WriteLine("Done streaming. Back pressure ratio " + (double)backPressureCount / NumberOfMessages);
if (0 < LingerTimeoutMs)
{
Console.WriteLine("Lingering for " + LingerTimeoutMs + " milliseconds...");
Thread.Sleep((int)LingerTimeoutMs);
}
_printingActive = false;
Console.WriteLine("Execute again?");
} while (Console.ReadLine() == "y");
}
reporter.Halt();
_reporterThread.Join();
}
