private void callback(IAsyncResult ar)
{
try
{
sck.EndReceive(ar);
var buf = new byte[8192];
var rec = sck.Receive(buf, buf.Length, 0);
if (rec < buf.Length)
{
Array.Resize(ref buf, rec);
}
Received?.Invoke(this, buf);
sck.BeginReceive(new byte[] { 0 }, 0, 0, 0, callback, null);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Close();
Disconnected?.Invoke(this);
}
}
private void OnReceive(HostMask prefix, string command, string[] args)
{
_logger.Log(LogLevel.Debug, _plugin.Name, "OnReceive - {0}, {1}, {2}", prefix.Mask, command, args);
if (Received != null)
{
IrcEventArgs e = new IrcEventArgs(prefix, command, args);
Received.Invoke(this, e);
if (e.Handled)
{
return;
}
}
switch (command)
{
case "NICK": OnNick(prefix, args); break;
case "PING": OnPing(args); break;
case "001": OnWelcome(args); break;
case "002": OnYourHost(args); break;
case "003": OnCreated(args); break;
case "004": OnMyInfo(args); break;
}
}
private void OnReceive(Packet pk, IPEndPoint remote)
{
var e = new ReceivedEventArgs(pk);
e.UserState = remote;
LastTime = DateTime.Now;
//if (StatReceive != null) StatReceive.Increment(e.Length);
if (Log.Enable && LogReceive)
{
WriteLog("Recv [{0}]: {1}", e.Length, e.ToHex(32, null));
}
Received?.Invoke(this, e);
if (Packet != null && e.Packet != null && MessageReceived != null)
{
var msg = Packet.LoadMessage(e.Packet);
var me = new MessageEventArgs
{
Packet = e.Packet,
UserState = e.UserState,
Message = msg
};
MessageReceived(this, me);
}
}
private async void ListenForMessages(WebSocket socket)
{
TOP:
try
{
if (!socket.IsConnected)
{
return;
}
var message = await socket.ReadMessageAsync(_tokenSource.Token);
if (message != null)
{
using (var ms = new MemoryStream()) // length was throwing an exception
{
message.CopyTo(ms);
var segment = new ArraySegment <byte>(ms.GetBuffer(), 0, (int)ms.Length);
var args = new DataReceivedArgs {
Data = segment, SessionID = socket
};
Received.Invoke(this, args);
}
}
goto TOP;
}
catch (TaskCanceledException) { }
catch (Exception)
{
goto TOP;
}
}
private async Task ReceiveLoopAsync(CancellationToken token)
{
try
{
while (!token.IsCancellationRequested)
{
while (await _receivedMessages.In.WaitToReadAsync(token))
{
while (_receivedMessages.In.TryRead(out var message))
{
await Received?.Invoke(message);
}
}
}
Closed?.Invoke(null);
}
catch (OperationCanceledException)
{
// Do nothing, we were just asked to shut down.
Closed?.Invoke(null);
}
catch (Exception ex)
{
Closed?.Invoke(ex);
}
}
public void OnReceived(string msg)
{
if (this.bConnect)
{
Received?.Invoke(this, msg);
}
}
private void ReceivedCallback(IAsyncResult ar)
{
try
{
socket.EndReceive(ar);
byte[] buffer = new byte[1024];
int receive = socket.Receive(buffer, buffer.Length, 0);
if (receive < buffer.Length)
{
Array.Resize(ref buffer, receive);
}
Received?.Invoke(this, buffer);
socket.BeginReceive(new byte[] { 0 }, 0, 0, 0, ReceivedCallback, null);
}
catch (Exception e)
{
Console.WriteLine("Client connection error: " + e.Message);
Close();
Disconnected?.Invoke(this);
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try {
// Retrieve the state object and the client socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Client = state.workSocket;
// Read data from the remote device.
int bytesRead = Client.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
}
if (bytesRead < state.BufferSize)
{
// Get the rest of the data.
Client.BeginReceive(state.buffer, 0, state.BufferSize, 0,
ReceiveCallback, state);
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length >= state.BufferSize)
{
Received?.Invoke(this, state.sb.ToString());
}
}
} catch (Exception e) {
ErrorAccrued?.Invoke(this, new ErrorEventArgs(e));
}
}
public void OnReceived(byte[] data)
{
if (Received != null)
{
Received.Invoke(data);
}
}
public void SubscribeCommands <TMessage>(IContainer container)
{
var receiverType = ResolveReceiverType <TMessage>(container);
var topic = typeof(TMessage).Name;
var routingKey = $"{Namespace}.{topic}";
var channel = CommandQueueDeclare(routingKey);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (o, ea) =>
{
var json = ea.Body.ToContent();
Received?.Invoke(this, new ReceivedEventArgs
{
Topic = topic,
HandledBy = receiverType,
Message = json
});
Handle(container, json.ToObject <TMessage>());
Channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
};
channel.BasicConsume(queue: routingKey,
noAck: false,
consumer: consumer);
}
internal virtual void MessageReceived(MessageResponse response)
{
foreach (JToken message in response.Messages)
{
Received?.Invoke(message.ToObject <string>());
}
}
public void SubscribeEvents <TMessage>(IContainer container)
{
var receiverType = ResolveReceiverType <TMessage>(container);
var topic = typeof(TMessage).Name;
var queueName = Channel.QueueDeclare().QueueName;
Channel.QueueBind(queue: queueName,
exchange: Namespace,
routingKey: topic);
var consumer = new EventingBasicConsumer(Channel);
consumer.Received += (o, e) =>
{
var json = e.Body.ToContent();
Received?.Invoke(this, new ReceivedEventArgs
{
Topic = topic,
HandledBy = receiverType,
Message = json
});
Handle(container, json.ToObject <TMessage>());
};
Channel.BasicConsume(queue: queueName,
noAck: false,
consumer: consumer);
}
public SerialPortDownloader(SerialPortHelper portHelper)
{
_portHelper = portHelper;
_portHelper.DataReceived += (sender, e) =>
{
var port = sender as SerialPort;
if (port == null)
{
return;
}
var readBytes = new List <byte>();
lock (_buffer)
{
while (port.BytesToRead > 0)
{
readBytes.Add((byte)port.ReadByte());
}
_buffer.AddRange(readBytes);
}
var package = DecodePackage();
Received?.Invoke(new DownloadSenderReceivedArgs
{
ReceiveContent = readBytes.ToArray(),
Package = package
});
};
}
private void ErrorMessage(Exception ex)
{
WriteLog(ex);
FormCollection frms = Application.OpenForms;
for (int i = 0; i < frms.Count; i++)
{
if (frms[i] == null)
{
i++;
continue;
}
if (frms[i] is PopMain)
{
PopMain pop = (PopMain)frms[i];
// 해당 POP의 라인아이디와 같은 경우
if (pop.WorkerInfo.LineID == LineID)
{
ReceiveEventArgs e = new ReceiveEventArgs();
e.Message = string.Join("오류", ex.Message);
e.LineID = LineID;
e.IsCompleted = false;
if (!pop.IsDisposed)
{
if (Received != null)
{
Received.Invoke(this, e);
}
}
}
}
}
}
private async Task ReceiveLoop(WebSocket webSocket, CancellationToken cancellationToken)
{
var buffer = new byte[MaxMessageSize];
while (true)
{
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), cancellationToken);
if (result == null)
{
break;
}
if (result.MessageType == WebSocketMessageType.Close)
{
break;
}
var data = await ReadFrames(result, webSocket, buffer);
if (data.Count == 0)
{
break;
}
try
{
Received?.Invoke(data);
}
catch (Exception e)
{
ReceivedError?.Invoke(e);
}
}
}
public override void HandleBasicDeliver(
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body)
{
base.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
if (Received == null)
{
return;
}
try
{
var receivedMessage = ParseMessage(properties, body);
Received?.Invoke(
this,
new MottattMeldingArgs(receivedMessage, new SvarSender(_sendHandler, receivedMessage, () => Model.BasicAck(deliveryTag, false))));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public async Task ReceiveAsync()
{
_cts = new CancellationTokenSource();
var w = new ClientWebSocket();
_ws = w;
await w.ConnectAsync(new Uri(_url), _cts.Token);
Opened?.Invoke(this, EventArgs.Empty);
while (true)
{
WebSocketReceiveResult result;
try
{
result = await w.ReceiveAsync(new ArraySegment <byte>(buf), _cts.Token);
}
catch (OperationCanceledException)
{
break;
}
if (IsClosing(result.CloseStatus))
{
break;
}
if (result.MessageType == WebSocketMessageType.Text && result.EndOfMessage)
{
var s = Encoding.UTF8.GetString(buf, 0, result.Count);
Received?.Invoke(this, s);
}
}
_cts = null;
}
private void Receive(IAsyncResult AR)
{
Socket serverSocket = (Socket)AR.AsyncState;
int received;
try
{
received = serverSocket.EndReceive(AR);
byte[] recBuf = new byte[received];
Array.Copy(buffer, recBuf, received);
string data = Encoding.ASCII.GetString(recBuf);
Received?.Invoke(data);
socket.BeginReceive(buffer, 0, BUFFER_SIZE, SocketFlags.None, Receive, socket);
}
catch (Exception)
{
serverSocket.Close();
Log?.Invoke("Client disconnected");
return;
}
}
private void OnReceived(IAsyncResult ar)
{
try
{
int bytesRead = socket.EndReceive(ar);
if (bytesRead > 0)
{
if (enableMultiBytes)
{
queue.Write(buffer, 0, bytesRead);
Array.Clear(buffer, 0, bytesRead);
GetPacket();
}
else
{
byte[] data = new byte[bytesRead];
Buffer.BlockCopy(buffer, 0, data, 0, bytesRead);
Array.Clear(buffer, 0, bytesRead);
socket.BeginReceive(buffer, 0, buffersize, 0, new AsyncCallback(OnReceived), null);
Received?.Invoke(this, bytesRead, data);
}
}
else
{
Close();
}
}
catch (Exception e)
{
if (e is Win32Exception w && w.ErrorCode == 10054)
{
Disconnected?.Invoke(this);
}
/* ----------------------------------------------------------------- */
///
/// RssSubscriber
///
/// <summary>
/// オブジェクトを初期化します。
/// </summary>
///
/// <param name="context">同期用オブジェクト</param>
///
/* ----------------------------------------------------------------- */
public RssSubscriber(SynchronizationContext context)
{
_dispose = new OnceAction <bool>(Dispose);
_context = context;
_tree = new BindableCollection <IRssEntry> {
Context = context
};
_tree.CollectionChanged += (s, e) =>
{
AutoSaveCore();
CollectionChanged?.Invoke(this, e);
};
_monitors[0] = new RssMonitor {
Interval = TimeSpan.FromHours(1)
};
_monitors[0].Subscribe(e => Received?.Invoke(this, ValueEventArgs.Create(e)));
_monitors[1] = new RssMonitor {
Interval = TimeSpan.FromHours(24)
};
_monitors[1].Subscribe(e => Received?.Invoke(this, ValueEventArgs.Create(e)));
_monitors[2] = new RssMonitor(); // for RssCheckFrequency.None
_monitors[2].Subscribe(e => Received?.Invoke(this, ValueEventArgs.Create(e)));
_autosaver.AutoReset = false;
_autosaver.Interval = 1000.0;
_autosaver.Elapsed += WhenAutoSaved;
}
///<summary>
/// Invoked when a delivery arrives for the consumer.
/// </summary>
/// <remarks>
/// Handlers must copy or fully use delivery body before returning.
/// Accessing the body at a later point is unsafe as its memory can
/// be already released.
/// </remarks>
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, ReadOnlyMemory <byte> body)
{
base.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
Received?.Invoke(
this,
new BasicDeliverEventArgs(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body));
}
private void HandleReceivedLetter(ILetter receivedLetter, AckState ackState)
{
switch (receivedLetter.Type)
{
case LetterType.Initialize:
RemoteNodeId = new Guid(receivedLetter.Parts[0]);
HandleInitialize();
break;
case LetterType.Shutdown:
_remoteShutdownRequested = true;
ChannelDisconnecting?.Invoke(this, ShutdownReason.Remote);
break;
case LetterType.User:
Received?.Invoke(receivedLetter, CreateReceivedEventArgs(ackState));
break;
case LetterType.Batch:
for (var i = 0; i < receivedLetter.Parts.Length; i++)
{
var batchedLetter = _letterDeserializer.Deserialize(receivedLetter.Parts[i]);
Received?.Invoke(batchedLetter, CreateReceivedEventArgs(ackState));
}
break;
}
}
private void OnReceive(HostMask prefix, string command, string[] args)
{
if (Received != null)
{
IrcEventArgs e = new IrcEventArgs(prefix, command, args);
Received.Invoke(this, e);
if (e.Handled)
{
return;
}
}
switch (command)
{
case "NICK": OnNick(prefix, args); break;
case "PING": OnPing(args); break;
case "001": OnWelcome(args); break;
case "002": OnYourHost(args); break;
case "003": OnCreated(args); break;
case "004": OnMyInfo(args); break;
}
}
internal override void OnReceivedEvent(Parcel parcel)
{
string param1 = parcel.ReadString();
Bundle param2 = parcel.ReadBundle();
Received?.Invoke(param1, param2);
}
private void StartReceive()
{
Task.Run(async() =>
{
while (_udpClient != null)
{
try
{
UdpReceiveResult res = await _udpClient.ReceiveAsync();
Transmission msg = new Transmission(res.Buffer, Transmission.EType.Received);
msg.Origin = res.RemoteEndPoint;
msg.Destination = _udpClient.Client.LocalEndPoint as IPEndPoint;
Received?.Invoke(this, new ReceivedEventArgs(msg));
}
catch (SocketException ex)
{
// Ignore this error, triggered after sending
// a packet to an unreachable port. UDP is not
// reliable anyway, this can safetly be ignored.
if (ex.ErrorCode != 10054)
{
Leave();
break;
}
}
catch (Exception)
{
Leave();
break; // end receive;
}
}
});
}
/// <inheritdoc cref="ISocketAdapter.Connect"/>
public void Connect(Uri uri, int timeout)
{
// TODO will need to use window.setTimeout to implement timeouts on DOM WebSocket.
if (Ref > -1)
{
ReceivedError?.Invoke(new SocketException((int)SocketError.IsConnected));
return;
}
_uri = uri;
IsConnecting = true;
Action open = () =>
{
IsConnected = true;
IsConnecting = false;
Connected?.Invoke();
};
Action <int, string> close = (code, reason) =>
{
IsConnected = false;
IsConnecting = false;
Ref = -1;
Closed?.Invoke();
};
Action <string> error = reason =>
{
IsConnected = false;
Ref = -1;
ReceivedError?.Invoke(new Exception(reason));
};
Action <string> handler = message => { Received?.Invoke(new ArraySegment <byte>(Encoding.UTF8.GetBytes(message))); };
Ref = UnityWebGLSocketBridge.Instance.CreateSocket(uri.AbsoluteUri, open, close, error, handler);
}
internal async void StartAsync()
{
lock (_lockObject)
{
_udpClient = new UdpClient(_port);
_udpTokenSource?.Cancel();
_udpTokenSource = new CancellationTokenSource();
}
var token = _udpTokenSource.Token;
while (!token.IsCancellationRequested)
{
var receivedResult = _udpClient != null
? await _udpClient.ReceiveAsync().ConfigureAwait(false)
: default(UdpReceiveResult);
var bytes = receivedResult.Buffer;
if (!token.IsCancellationRequested &&
bytes != null &&
bytes.Any())
{
var message = Encoding.ASCII.GetString(bytes);
Received?.Invoke(message);
}
}
}
private void ConnectDisconnect()
{
if (_port != null && _port.IsOpen)
{
_port.Close();
_port.Dispose();
_nmea.Dispose();
_port = null;
_nmea = null;
ButtonText = "Connect";
StatusText = "Not Connected.";
}
else
{
try
{
_port = new SerialPort(Port, Baud);
_port.Open();
_nmea = new StreamDevice(_port.BaseStream);
_nmea.OpenAsync().Wait();
_nmea.MessageReceived += (sender, args) => { Received?.Invoke(sender, args); };
ButtonText = "Disconnect";
StatusText = $"Connected to {Port}";
}
catch (Exception e)
{
StatusText = $"Not connected: {e.GetType()}";
_port = null;
_nmea = null;
}
}
}
private void EndOrContinueRead(IAsyncResult ar)
{
ReadIOState state = ar.AsyncState as ReadIOState;
// Get the number of bytes read and advance position by the same amount
try
{
int bytesRead = networkStream.EndRead(ar);
if (bytesRead > 0)
{
state.AdvancePosition(bytesRead);
}
}
catch (Exception ex)
{
Received.Invoke(this, new ReceivedEventArgs(ex, this, state.Data));
}
if (state.Remaining > 0)
{
Read(state);
}
else if (state.LengthRead)
{
int length = BitConverter.ToInt32(state.Data, 0);
Read(new ReadIOState(length, true, false));
}
else
{
Received?.Invoke(this, new ReceivedEventArgs(this, state.Data));
Read(new ReadIOState(4, false, true));
}
}
private async Task ReceiveMessage()
{
var result = _innerConsumer.Consume(_cancellationTokenSource.Token);
if (result == null)
{
return;
}
if (result.IsPartitionEOF)
{
_logger.LogInformation("Partition EOF reached: {topic} {partition} @{offset}", result.Topic,
result.Partition,
result.Offset);
return;
}
_consumedAtLeastOnce = true;
_logger.LogTrace("Consuming message: {topic} {partition} @{offset}", result.Topic, result.Partition,
result.Offset);
if (Received != null)
{
await Received.Invoke(result.Message, result.TopicPartitionOffset);
}
}
