public App()
: base()
{
messageSent = MessageSent.NONE;
clientMiniCheckers = new MainWindow();
udpHandler = new ClientUDPMessageHandler();
clientMiniCheckers.Show();
WireHandlers();
setupRequestResponseBackgroundThead();
}
/// <summary>
/// Writes a producer request to the server asynchronously.
/// </summary>
/// <param name="request">The request to make.</param>
/// <param name="callback">The code to execute once the message is completely sent.</param>
public void BeginWrite(ProducerRequest request, MessageSent<ProducerRequest> callback)
{
NetworkStream stream = _client.GetStream();
RequestContext<ProducerRequest> ctx = new RequestContext<ProducerRequest>(stream, request);
byte[] data = request.GetBytes();
stream.BeginWrite(
data,
0,
data.Length,
delegate(IAsyncResult asyncResult)
{
RequestContext<ProducerRequest> context = (RequestContext<ProducerRequest>)asyncResult.AsyncState;
if (callback != null)
{
callback(context);
}
context.NetworkStream.EndWrite(asyncResult);
context.NetworkStream.Dispose();
},
ctx);
}
/// <summary>
/// Constructs request and sent it to Kafka server asynchronously
/// </summary>
/// <param name="topic">
/// The topic.
/// </param>
/// <param name="partition">
/// The partition.
/// </param>
/// <param name="messages">
/// The list of messages to sent.
/// </param>
/// <param name="callback">
/// The callback invoked when a request is finished being sent.
/// </param>
public void Send(string topic, int partition, IEnumerable <Message> messages, MessageSent <ProducerRequest> callback)
{
this.EnsuresNotDisposed();
Guard.NotNullNorEmpty(topic, "topic");
Guard.NotNull(messages, "messages");
Guard.Assert <ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize));
this.Send(new ProducerRequest(topic, partition, messages), callback);
}
private void SendErrorMessage(string message)
{
MessageSent?.Invoke(MessageType.Error, message);
}
private void SendInfoMessage(string message)
{
MessageSent?.Invoke(MessageType.Info, message);
}
public SendMsgAction(IWeChatContext context, MessageSent msg, ActionEventListener listener = null) : base(context, listener)
{
_msg = msg;
}
protected virtual void OnMessageSent(long idGroup, int total, int process) => MessageSent?.Invoke(this, new MessageSentEventArgs(idGroup, total, process));
/// <summary>
/// Sends request to Kafka server asynchronously
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback invoked when a request is finished being sent.
/// </param>
public void Send(ProducerRequest request, MessageSent<ProducerRequest> callback)
{
Guard.Assert<ArgumentNullException>(() => request != null);
Guard.Assert<ArgumentNullException>(() => request.MessageSet != null);
Guard.Assert<ArgumentNullException>(() => request.MessageSet.Messages != null);
Guard.Assert<ArgumentException>(
() => request.MessageSet.Messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize));
using (var conn = new KafkaConnection(this.config.Host, this.config.Port))
{
conn.BeginWrite(request, callback);
}
}
private void HandleMenuLogout(object sender, RoutedEventArgs e)
{
messageSent = MessageSent.LOGOUT;
udpHandler.SendRequest(string.Format("LOGOUT,{0}", username));
}
public void RaiseMessageSent(MessageInfo info)
{
MessageSent?.Invoke(info);
}
private static void DoPublishSynchronouslyOnSameThread(TMessage message)
{
if (MessageSent != null)
MessageSent.Invoke(message);
}
public void Handle(MessageSent scheduleSmsForSendingLater)
{
MarkAsComplete();
}
protected virtual void OnMessageSent(System.IO.Stream e)
{
MessageSent?.Invoke(this, e);
}
private void DiscordClientOnMessageSent(object sender, global::Discord.MessageEventArgs e)
{
MessageSent?.Invoke(this, new EventArgs.MessageEventArgs(new DiscordMessage(e.Message), new DiscordServer(e.Server), new DiscordChannel(e.Channel), new DiscordUser(e.User)));
}
private void SendBtn_Click(object sender, EventArgs e)
{
MessageSent?.Invoke(SendTxt.Text);
ReceiveMessage($"({username}) {SendTxt.Text.Trim()}");
SendTxt.Text = "";
}
/// <summary>
///
/// </summary>
/// <param name="info"></param>
/// <returns>true if connection is finished and need to be closed</returns>
private async Task <bool> ProcessLineAsync(string info)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
logger.LogInformation($"Receive: {info}");
if (info.Contains("VRC") && !atc)
{
vrc = true;
atc = true;
await SendAsync($"$DI{ClientCode}:CLIENT:client V1.00:3ef36a24");
logger.LogInformation("Sent VRC Hello");
}
//else if (!this.atc && !this.es)
//{
// this.es = true;
// this.atc = true;
// Console.WriteLine("Sent EuroScope Hello");
//}
if (info.StartsWith("%" + callsign))
{
// %EDDM_TWR:18700:4:100:3:48.35378:11.78609:0
var tokens = info.Split(':');
var freq = int.Parse("1" + tokens[1]);
var alt = int.Parse(tokens[2]);
//var protocol = tokens[3];
//var rating = tokens[4];
var lat = double.Parse(tokens[5], CultureInfo.InvariantCulture);
var lng = double.Parse(tokens[6], CultureInfo.InvariantCulture);
AtcUpdated?.Invoke(this, new AtcUpdatedEventArgs(callsign, freq, alt, lat, lng));
AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs("*", info));
}
if (info.StartsWith($"#DA{callsign}:SERVER"))
{
// #DAEDDM_TWR:SERVER
Disconnect();
return(true);
}
if (info.StartsWith("#AP"))
{
// #APNWA360:SERVER:1363753::1:100:6:Jim Levain KBLI
// #APTHY73Q:SERVER:1349469::1:100:2:Bedran Batkitar LTFM
}
if (info.StartsWith("$AX"))
{
// METAR
var station = info.Substring($"$AX{callsign}:SERVER:METAR:".Length, 4);
await SendMETARAsync(station);
}
if (info.StartsWith("$CQ"))
{
// TODO: Command
// (e.g. $CQHYHY:@94835:BC:HY3088:2677 --- Set squawk)
// (e.g. $CQKAUS_TWR:SERVER:FP:DS-TZZ --- Requesting flight plan)
//$CQCYVR_TWR:@94835:DR:USEP6Q --- Assume a callsign
//#TMCYVR_TWR:FP:USEP6Q --- Release
var tokens = info.Substring("$CQ".Length).Split(new char[] { ':' }, 4);
var sender = tokens[0];
var recipient = tokens[1];
var command = tokens[2];
var data = tokens.Length == 4 ? tokens[3] : null;
if (recipient == "SERVER")
{
switch (command)
{
case "ATC":
await SendAsync($"$CRSERVER:{callsign}:ATC:Y:{data}");
break;
case "CAPS":
await SendAsync($"$CRSERVER:{callsign}:CAPS:ATCINFO=1:SECPOS=1");
break;
case "IP":
var ipep = (IPEndPoint)tcpClient.Client.RemoteEndPoint;
var ipa = ipep.Address;
await SendAsync($"$CRSERVER:{callsign}:IP:{ipa}");
await SendAsync($"$CQSERVER:{callsign}:CAPS");
break;
case "FP":
FlightPlanRequested?.Invoke(this, new FlightPlanRequestedEventArgs(data));
break;
}
}
else
{
// Real Name
// $CQCYVR_TWR:EDDM_GND:RN
// Expect: $CREDDM_GND:WADD_TWR:RN:<Name>Hy:<location>Vancouver FIR 2004/1-1 CZVR 20200404:<rating>3
AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info));
}
}
if (info.StartsWith("$CR"))
{
//$CRCYVR_TWR:CYVR_GND:CAPS:ATCINFO=1:SECPOS=1:MODELDESC=1:ONGOINGCOORD=1
var tokens = info.Split(":");
var recipient = tokens[1];
if (recipient == "SERVER")
{
// Ignore
}
else
{
AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info));
}
}
if (info.StartsWith("$HO") || info.StartsWith("#PC"))
{
// Manual transfer
// $HOCYVR_TWR:CZVR_CTR:NF-OJS
// #PCCYVR_TWR:CZVR_CTR:CCP:ST:NF-OJS:1:::::::::
var tokens = info.Split(":");
var recipient = tokens[1];
if (recipient == "SERVER")
{
// Probably never happen
}
else
{
AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs(recipient, info));
}
}
if (info.StartsWith($"#TM{callsign}:"))
{
// TODO: Message (e.g. #TMHYHY:FP:HY3088 SET 2677)
// #TMEDDM_TWR:@18700:hello all
var tokens = info.Split(new char[] { ':' }, 3);
var to = tokens[1];
var msg = tokens[2];
MessageSent?.Invoke(this, new MessageSentEventArgs(to, msg));
AtcMessageSent?.Invoke(this, new AtcMessageSentEventArgs("*", info));
}
if (this.vrc)
{
if (info.Contains($"$CQ{callsign}:SERVER:ATC:{callsign}") && !this.atc)
{
logger.LogInformation("Send VRC");
await SendAsync($"$CR{ClientCode}:{callsign}:ATC:Y:{callsign}");
this.atc = true;
}
}
else
{
if (info.StartsWith("#AA"))
{
// #AACYVR_TWR:SERVER:HY:NA:123:3:9:1:0:49.19470:-123.18397:100
// #AAEGHQ_ATIS:SERVER:Daniel Button:1343255::4:100
logger.LogInformation("Connected");
var tokens = info.Substring("#AA".Length).Split(":");
callsign = tokens[0];
var to = tokens[1];
var realName = tokens[2];
var certificate = tokens[3];
var password = tokens[4];
var rating = tokens[5];
var lat = tokens.Length > 9 ? double.Parse(tokens[9], CultureInfo.InvariantCulture) : (double?)null;
var lon = tokens.Length > 10 ? double.Parse(tokens[10], CultureInfo.InvariantCulture) : (double?)null;
await SendAsync($"#TM{ClientCode}:{callsign}:Connected to {ClientName}.");
Connected?.Invoke(this, new ConnectedEventArgs(callsign, realName, certificate, rating, lat, lon));
}
}
return(false);
}
/// <summary> /// Raises MessageSent event. /// </summary> /// <param name="message">Received message</param> protected virtual void OnMessageSent(IScsMessage message) => MessageSent?.Invoke(this, new MessageEventArgs(message, DateTime.Now));
private void Poll()
{
var jObject = new JObject();
jObject["chat_token"] = Token;
jObject["usernames"] = JArray.FromObject(AccountData.Users.Where(x => x.Update).Select(x => x.Name).ToArray());
jObject["after"] = LastPollTime + 0.005;
try
{
var response = Requester.PostRequest(Methods.ChatHistory, jObject);
var obj = JsonConvert.DeserializeObject(response) as JObject;
var chatHistory = new ChatHistory();
var chatObject = obj["chats"] as JObject;
foreach (var kvp in chatObject)
{
foreach (JObject msgObject in kvp.Value as JArray)
{
var channel = string.Empty;
if (msgObject["channel"] != null)
{
channel = msgObject["channel"].ToString();
}
if (msgObject["is_join"] != null)
{
var presence = new Presence(
msgObject["id"].ToString(),
double.Parse(msgObject["t"].ToString()),
kvp.Key,
msgObject["from_user"].ToString(),
channel,
bool.Parse(msgObject["is_join"].ToString())
);
chatHistory.Push(presence);
}
else
{
var message = new Message(
msgObject["id"].ToString(),
double.Parse(msgObject["t"].ToString()),
kvp.Key,
msgObject["from_user"].ToString(),
channel,
msgObject["msg"].ToString()
);
chatHistory.Push(message);
}
}
}
if (!chatHistory.IsEmpty)
{
LastPollTime = chatHistory.Last.Timestamp;
}
while (!chatHistory.IsEmpty)
{
var element = chatHistory.Pop();
if (element is Presence)
{
var pres = element as Presence;
var channel = AccountData.FindUser(pres.To).FindChannel(pres.Channel);
if (channel != null)
{
if (!pres.Joined)
{
if (channel.MemberExists(pres.From))
{
channel.Members.Remove(pres.From);
}
}
else
{
if (!channel.MemberExists(pres.From))
{
channel.Members.Add(pres.From);
}
}
}
PresenceReceived?.Invoke(this, new PresenceEventArgs(pres));
continue;
}
else if (element is Message)
{
if (element.From != element.To)
{
if (!RelayedIDs.Contains(element.ID))
{
RelayedIDs.Add(element.ID);
MessageReceived?.Invoke(this, new MessageEventArgs(element as Message));
}
}
else
{
if (!RelayedIDs.Contains(element.ID))
{
RelayedIDs.Add(element.ID);
MessageSent?.Invoke(this, new MessageEventArgs(element as Message));
}
}
if (RelayedIDs.Count > 100)
{
RelayedIDs.Clear();
}
}
}
}
catch (RequestException e)
{
ErrorOccured?.Invoke(this, new ErrorEventArgs(e));
}
}
private void Log(string logText)
{
MessageSent.Invoke(this, new MessageSentEventArgs(MessageType.Log, logText));
}
private void Navigate(INotifier destination)
{
MessageSent.Invoke(this, new MessageSentEventArgs(MessageType.Navigation, destination));
}
/// <summary>
/// Constructs request and sent it to Kafka server asynchronously
/// </summary>
/// <param name="topic">
/// The topic.
/// </param>
/// <param name="partition">
/// The partition.
/// </param>
/// <param name="messages">
/// The list of messages to sent.
/// </param>
/// <param name="callback">
/// The callback invoked when a request is finished being sent.
/// </param>
public void Send(string topic, int partition, IEnumerable<Message> messages, MessageSent<ProducerRequest> callback)
{
this.EnsuresNotDisposed();
Guard.NotNullNorEmpty(topic, "topic");
Guard.NotNull(messages, "messages");
Guard.Assert<ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize));
this.Send(new ProducerRequest(topic, partition, messages), callback);
}
protected void OnMessageSent()
{
MessageSent?.Invoke(this, new ConnectionMessageEventArgs());
}
private void handleEvents(List <DatafeedEvent> datafeedEvents)
{
foreach (DatafeedEvent eventv4 in datafeedEvents)
{
if (eventv4.initiator.user.userId != botClient.getBotUserInfo().id)
{
switch (eventv4.type)
{
case "MESSAGESENT":
MessageSent messageSent = eventv4.payload.messageSent;
if (messageSent.message.stream.streamType.Equals("ROOM"))
{
foreach (RoomListener listener in roomListeners)
{
listener.onRoomMessage(messageSent.message);
}
}
else
{
foreach (IMListener listener in IMListeners)
{
listener.onIMMessage(messageSent.message);
}
}
break;
case "INSTANTMESSAGECREATED":
foreach (IMListener listeners in IMListeners)
{
listeners.onIMCreated(eventv4.payload.instantMessageCreated.stream);
}
break;
case "ROOMCREATED":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomCreated(eventv4.payload.roomCreated);
}
break;
case "ROOMUPDATED":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomUpdated(eventv4.payload.roomUpdated);
}
break;
case "ROOMDEACTIVATED":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomDeactivated(eventv4.payload.roomDeactivated);
}
break;
case "ROOMREACTIVATED":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomReactivated(eventv4.payload.roomReactivated.stream);
}
break;
case "USERJOINEDROOM":
foreach (RoomListener listener in roomListeners)
{
listener.onUserJoinedRoom(eventv4.payload.userJoinedRoom);
}
break;
case "USERLEFTROOM":
foreach (RoomListener listener in roomListeners)
{
listener.onUserLeftRoom(eventv4.payload.userLeftRoom);
}
break;
case "ROOMMEMBERPROMOTEDTOOWNER":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomMemberPromotedToOwner(eventv4.payload.roomMemberPromotedToOwner);
}
break;
case "ROOMMEMBERDEMOTEDFROMOWNER":
foreach (RoomListener listener in roomListeners)
{
listener.onRoomMemberDemotedFromOwner(eventv4.payload.roomMemberDemotedFromOwner);
}
break;
case "CONNECTIONACCEPTED":
foreach (ConnectionListener listener in connectionListeners)
{
listener.onConnectionAccepted(eventv4.payload.connectionAccepted.fromUser);
}
break;
case "CONNECTIONREQUESTED":
foreach (ConnectionListener listener in connectionListeners)
{
listener.onConnectionRequested(eventv4.payload.connectionRequested.toUser);
}
break;
default:
break;
}
}
}
}
private void OnConnectionMessageSent(object source, ConnectionMessageEventArgs e)
{
MessageSent?.Invoke(source, e);
}
void OnMessageSent(string json) => MessageSent?.Invoke(json);
public Task <ActionEvent> SendMsg(MessageSent msg, ActionEventListener listener = null)
{
return(new SendMsgAction(Context, msg)
.ExecuteAsyncAuto());
}
private void SendWarningMessage(string message)
{
MessageSent?.Invoke(MessageType.Warning, message);
}
protected virtual void OnMessageSent(string data)
{
MessageSent?.Invoke(this, data);
}
/// <summary>
/// Writes a producer request to the server asynchronously.
/// </summary>
/// <param name="request">The request to make.</param>
/// <param name="callback">The code to execute once the message is completely sent.</param>
/// <remarks>
/// Do not dispose connection till callback is invoked,
/// otherwise underlying network stream will be closed.
/// </remarks>
public void BeginWrite(ProducerRequest request, MessageSent<ProducerRequest> callback)
{
this.EnsuresNotDisposed();
Guard.NotNull(request, "request");
if (callback == null)
{
this.BeginWrite(request);
return;
}
NetworkStream stream = client.GetStream();
var ctx = new RequestContext<ProducerRequest>(stream, request);
byte[] data = request.RequestBuffer.GetBuffer();
stream.BeginWrite(
data,
0,
data.Length,
delegate(IAsyncResult asyncResult)
{
var context = (RequestContext<ProducerRequest>)asyncResult.AsyncState;
callback(context);
context.NetworkStream.EndWrite(asyncResult);
},
ctx);
}
private void OnMessageSended(IPCMessage message)
{
MessageSent?.Invoke(this, message);
}
/// <summary>
/// Sends a list of messages to Kafka.
/// </summary>
/// <param name="topic">The topic to publish to.</param>
/// <param name="partition">The partition to publish to.</param>
/// <param name="messages">The list of messages to send.</param>
/// <param name="callback">
/// A block of code to execute once the request has been sent to Kafka. This value may
/// be set to null.
/// </param>
public void SendAsync(string topic, int partition, IList <Message> messages, MessageSent <ProducerRequest> callback)
{
SendAsync(new ProducerRequest(topic, partition, messages), callback);
}
public Task <ActionEvent> SendMsg(MessageSent msg, ActionEventListener listener = null)
{
return(GetModule <IChatModule>().SendMsg(msg, listener));
}
protected virtual void OnMessageSent(Tuple <Guid, System.IO.Stream> e)
{
MessageSent?.Invoke(this, e);
}
internal void TransferToBus(IBus bus)
{
var rebusEvents = bus.Advanced.Events;
if (MessageContextEstablished != null)
{
foreach (var listener in MessageContextEstablished.GetInvocationList().Cast <MessageContextEstablishedEventHandler>())
{
rebusEvents.MessageContextEstablished += listener;
}
}
if (MessageSent != null)
{
foreach (var listener in MessageSent.GetInvocationList().Cast <MessageSentEventHandler>())
{
rebusEvents.MessageSent += listener;
}
}
if (BeforeMessage != null)
{
foreach (var listener in BeforeMessage.GetInvocationList().Cast <BeforeMessageEventHandler>())
{
rebusEvents.BeforeMessage += listener;
}
}
if (AfterMessage != null)
{
foreach (var listener in AfterMessage.GetInvocationList().Cast <AfterMessageEventHandler>())
{
rebusEvents.AfterMessage += listener;
}
}
if (BusStarted != null)
{
foreach (var listener in BusStarted.GetInvocationList().Cast <BusStartedEventHandler>())
{
rebusEvents.BusStarted += listener;
}
}
if (BusStopped != null)
{
foreach (var listener in BusStopped.GetInvocationList().Cast <BusStoppedEventHandler>())
{
rebusEvents.BusStopped += listener;
}
}
if (BeforeTransportMessage != null)
{
foreach (var listener in BeforeTransportMessage.GetInvocationList().Cast <BeforeTransportMessageEventHandler>())
{
rebusEvents.BeforeTransportMessage += listener;
}
}
if (AfterTransportMessage != null)
{
foreach (var listener in AfterTransportMessage.GetInvocationList().Cast <AfterTransportMessageEventHandler>())
{
rebusEvents.AfterTransportMessage += listener;
}
}
if (PoisonMessage != null)
{
foreach (var listener in PoisonMessage.GetInvocationList().Cast <PoisonMessageEventHandler>())
{
rebusEvents.PoisonMessage += listener;
}
}
if (UncorrelatedMessage != null)
{
foreach (var listener in UncorrelatedMessage.GetInvocationList().Cast <UncorrelatedMessageEventHandler>())
{
rebusEvents.UncorrelatedMessage += listener;
}
}
foreach (var messageMutator in MessageMutators)
{
rebusEvents.MessageMutators.Add(messageMutator);
}
foreach (var unitOfWorkManager in unitOfWorkManagers)
{
rebusEvents.AddUnitOfWorkManager(unitOfWorkManager);
}
}
protected virtual void OnMessageSent(Message message)
{
MessageSent?.Invoke(this, new MessageEvent(message));
}
public void SendMessage(Message msg)
{
MessageSent?.Invoke(this, msg);
}
private void HandleMenuLogin(object sender, RoutedEventArgs e)
{
username = "";
var dialog = new LoginModal();
dialog.Owner = clientMiniCheckers;
dialog.ShowDialog();
messageSent = MessageSent.LOGIN;
username = dialog.GetUsername();
udpHandler.SendRequest(string.Format("LOGIN,{0},{1}", username, dialog.GetPassword()));
}
/// <summary>
/// Sends a list of messages to Kafka.
/// </summary>
/// <param name="topic">The topic to publish to.</param>
/// <param name="partition">The partition to publish to.</param>
/// <param name="messages">The list of messages to send.</param>
/// <param name="callback">
/// A block of code to execute once the request has been sent to Kafka. This value may
/// be set to null.
/// </param>
public void SendAsync(string topic, int partition, IList<Message> messages, MessageSent<ProducerRequest> callback)
{
SendAsync(new ProducerRequest(topic, partition, messages), callback);
}
private void RequestResponseBackground_Thread()
{
while (true)
{
var response = udpHandler.GetResponse();
var action = "";
if (response.Equals("OKAY") || response.Equals("DONE"))
{
switch (messageSent)
{
case MessageSent.LOGIN:
clientMiniCheckers.UpdateStatus("Logged on as " + username);
clientMiniCheckers.MenuLoginSuccessful();
action = "Login";
break;
case MessageSent.LOGOUT:
clientMiniCheckers.UpdateStatus("Logged out");
clientMiniCheckers.MenuLogoutSuccessful();
username = "";
action = "Logout";
break;
case MessageSent.NONE:
action = "wrong message";
break;
default:
action = "Wrong message";
break;
}
}
else if (response.Equals("ERROR"))
{
switch (messageSent)
{
case MessageSent.LOGIN:
ShowLoginErrorDialog();
action = "Login";
break;
case MessageSent.LOGOUT:
action = "Logout";
break;
case MessageSent.NONE:
action = "wrong message";
break;
default:
action = "Wrong message";
break;
}
}
Debug.WriteLine(action + ": " + response);
messageSent = MessageSent.NONE;
}
}
/// <summary>
/// Send a request to Kafka asynchronously.
/// </summary>
/// <remarks>
/// If the callback is not specified then the method behaves as a fire-and-forget call
/// with the callback being ignored. By the time this callback is executed, the
/// <see cref="RequestContext.NetworkStream"/> will already have been closed given an
/// internal call <see cref="NetworkStream.EndWrite"/>.
/// </remarks>
/// <param name="request">The request to send to Kafka.</param>
/// <param name="callback">
/// A block of code to execute once the request has been sent to Kafka. This value may
/// be set to null.
/// </param>
public void SendAsync(ProducerRequest request, MessageSent<ProducerRequest> callback)
{
if (request.IsValid())
{
KafkaConnection connection = new KafkaConnection(Server, Port);
if (callback == null)
{
// fire and forget
connection.BeginWrite(request.GetBytes());
}
else
{
// execute with callback
connection.BeginWrite(request, callback);
}
}
}
/// <summary>
/// Constructs request and sent it to Kafka server asynchronously
/// </summary>
/// <param name="topic">
/// The topic.
/// </param>
/// <param name="partition">
/// The partition.
/// </param>
/// <param name="messages">
/// The list of messages to sent.
/// </param>
/// <param name="callback">
/// The callback invoked when a request is finished being sent.
/// </param>
public void Send(string topic, int partition, IEnumerable<Message> messages, MessageSent<ProducerRequest> callback)
{
Guard.Assert<ArgumentNullException>(() => !string.IsNullOrEmpty(topic));
Guard.Assert<ArgumentNullException>(() => messages != null);
Guard.Assert<ArgumentException>(() => messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize));
this.Send(new ProducerRequest(topic, partition, messages), callback);
}
/// <summary>
/// Sends request to Kafka server asynchronously
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback invoked when a request is finished being sent.
/// </param>
public void Send(ProducerRequest request, MessageSent<ProducerRequest> callback)
{
this.EnsuresNotDisposed();
Guard.NotNull(request, "request");
Guard.NotNull(request.MessageSet, "request.MessageSet");
Guard.NotNull(request.MessageSet.Messages, "request.MessageSet.Messages");
Guard.Assert<ArgumentException>(
() => request.MessageSet.Messages.All(x => x.PayloadSize <= this.Config.MaxMessageSize));
connection.BeginWrite(request, callback);
}
