private void RecieveCallbackHandler(RecieveUserToken outerToken, SocketError socketError,
IList <ArraySegment <byte> > buffer)
{
if (socketError != SocketError.Success)
{
outerToken.RecieveTaskCompletionSource.SetException(new SocketException((int)socketError));
outerToken.Parent._listener.AcceptAsync(null);
return;
}
switch (outerToken.State)
{
case RecieveState.HeaderRecieving:
//TODO make override for Read method to get IList<ArraySegment<byte>>
TcpMessageHeader header = TcpMessageHeader.Read(buffer[0].Array, buffer[0].Offset);
this._headerReciever.ReleaseCallbackBuffer(buffer);
outerToken.RecievedHeader = header;
outerToken.State = RecieveState.BodyRecieving;
this._bodyReciever.RecieveAsync(outerToken.Socket, header.Size, outerToken, RecieveCallbackHandler);
break;
case RecieveState.BodyRecieving:
TcpMessage message = TcpMessage.CreateMessage(outerToken.RecievedHeader, buffer, this._bodyBufferManager);
outerToken.State = RecieveState.BodyRecieved;
outerToken.RecieveTaskCompletionSource.SetResult(message);
break;
default:
throw new ArgumentOutOfRangeException();
}
outerToken.Parent._listener.AcceptAsync(null);
}
/// <summary>
/// Send broadcast answers to all users
/// </summary>
/// <param name="resp"></param>
public void SendBroadcast(TcpMessage resp)
{
foreach (var User in Users)
{
SendRequest(User.Value.EndPoint, resp.GetBytes());
}
}
private void Message_Received(object sender, MessageReceivedFromServerEventArgs e)
{
TcpMessage msg = JsonConvert.DeserializeObject <TcpMessage>(Encoding.UTF8.GetString(e.Data));
switch (msg.MessageType)
{
case MessageType.Message:
memoEdit1.Invoke((MethodInvoker) delegate
{
memoEdit1.Text += "Server : " + msg.Message + System.Environment.NewLine;
});
break;
case MessageType.LicenseControl:
break;
case MessageType.ServerRejection:
MessageBox.Show(msg.Message);
Application.Exit();
break;
case MessageType.ServerClosed:
MessageBox.Show(msg.Message);
Application.Exit();
break;
}
}
public void sendMessageObject(TcpMessage msg)
{
NetworkStream serverStream = userInfo.getTcpClient().GetStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(serverStream, msg);
}
async void CheckHealthMonitorAlive()
{
bool isHealthMonitorAlive = false;
Task <string?> tcpMsgTask = TcpMessage.Send(string.Empty, (int)HealthMonitorMessageID.Ping, ServerIp.HealthMonitorPublicIp, ServerIp.DefaultHealthMonitorServerPort);
string? tcpMsgResponse = await tcpMsgTask;
Utils.Logger.Debug("CheckHealthMonitorAlive() returned answer: " + tcpMsgResponse ?? string.Empty);
Console.WriteLine($"HealthMonitor Ping return: '{tcpMsgResponse ?? string.Empty}'");
if (tcpMsgTask.Exception != null || String.IsNullOrEmpty(tcpMsgResponse))
{
string errorMsg = $"Error. CheckHealthMonitorAlive() to {ServerIp.HealthMonitorPublicIp}:{ServerIp.DefaultHealthMonitorServerPort}";
Utils.Logger.Error(errorMsg);
}
else
{
isHealthMonitorAlive = tcpMsgResponse.StartsWith("Ping. Healthmonitor UtcNow: ");
}
if (!isHealthMonitorAlive)
{
new Email
{
ToAddresses = Utils.Configuration["Emails:Gyant"],
Subject = "SqCore Warning! : HealthMonitor is NOT Alive.",
Body = $"SqCore Warning! : HealthMonitor is NOT Alive.",
IsBodyHtml = false
}
}
DateTime m_lastSqWebsiteErrorPhoneCallTime = DateTime.MinValue; // don't call if it was made in the last 30 minutes
private void ErrorFromWebsite(TcpClient p_tcpClient, TcpMessage p_message)
{
if (m_persistedState == null || !m_persistedState.IsProcessingSqCoreWebsiteMessagesEnabled)
{
return;
}
if (p_message.ResponseFormat == TcpMessageResponseFormat.String)
{
BinaryWriter bw = new BinaryWriter(p_tcpClient.GetStream());
bw.Write("FromServer: Message received, saved and starting processing: " + p_message.ParamStr);
}
string from = "unknown website";
switch ((HealthMonitorMessageID)p_message.ID)
{
case HealthMonitorMessageID.ReportErrorFromSQLabWebsite:
from = "SqLab";
break;
case HealthMonitorMessageID.SqCoreWebCsError:
from = "SqCore.C#";
break;
case HealthMonitorMessageID.SqCoreWebJsError:
from = "SqCore.Javascript";
break;
}
Utils.Logger.Info("ErrorFromWebsite().");
InformSupervisors(InformSuperVisorsUrgency.Normal_UseTimer, $"SQ HealthMonitor: ERROR. Website: {from}.", $"SQ HealthMonitor:ERROR. Website: {from}. MessageParamStr: { p_message.ParamStr}", string.Empty, ref m_lastSqWebsiteInformSupervisorLock, ref m_lastSqWebsiteErrorEmailTime, ref m_lastSqWebsiteErrorPhoneCallTime);
}
/*
* Start UDP client then continuously
* gather 32 messages for processing at a time (32 messages would equal a full frame of new rgb and depth data if you ignore that a lot get skipped)
*/
private void MessageThreadMethod()
{
receiver = new TcpClient(serverIp, serverOutputPort);//endPoint); //endPoint
sender = new TcpClient(serverIp, serverInputPort);
using (NetworkStream stream = receiver.GetStream())
{
while (runMessageThread)
{
byte[] header = new byte[HEADER_SIZE];
stream.Read(header, 0, HEADER_SIZE);
uint dataLength = BitConverter.ToUInt32(header, 1) - HEADER_SIZE;
byte[] contentData = new byte[dataLength];
int readBytes = 0;
while (readBytes < dataLength)
{
readBytes += stream.Read(contentData, readBytes, (int)dataLength - readBytes);
}
lock (lockObject)
{
newMessage = new TcpMessage((byte)header[0], contentData);
processData = true;
}
}
receiver.Close();
}
}
/// <summary>
/// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler" /> interface.
/// </summary>
/// <param name="context">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
/// <exception cref="System.Exception"></exception>
public void ProcessRequest(HttpContext context)
{
context.Response.AddHeader("Access-Control-Allow-Origin", "*");
context.Response.ContentType = "text/plain";
var url = context.Request.Url;
try
{
var authorization = context.Request.Headers["Authorization"];
JsonReader reader = new JsonTextReader(new StreamReader(context.Request.InputStream));
var obj = JObject.Load(reader);
var pushData = obj.ToObject <PushData>();
var alarmData = pushData.Data;
alarmData.Status = alarmData.Category == "1" ? "Uncleared" : "Cleared";
var message = new TcpMessage <AlarmData>(authorization, TcpMessageType.Alarm, alarmData);
NotifyClient.Instance.SendMsg(message);
context.Response.Write($"success");
}
catch (Exception ex)
{
HWLogger.NotifyRecv.Error(ex, $"Alarm Notification Error.[{url}]");
context.Response.Write($"Alarm Notification Error: { ex }");
}
context.Response.End();
}
/// <summary>Read messages from the server</summary>
public void ClientRead()
{
int numOfBytesRead = 0;
while (true)
{
try
{
numOfBytesRead = client_stream.Read(receive_buffer, 0, TcpConst.BUFFER_SIZE);
}
catch (Exception) { }
if (numOfBytesRead > 0)
{
TcpMessage msg = s.DeserializeByteArray(receive_buffer);
if (msg.type == TcpConst.REPLY)
{
HandleServerReplies(msg);
}
numOfBytesRead = 0;
}
}
}
private void __addItemToQueue(TcpMessage item)
{
lock (__messageQueue)
{
__messageQueue.Enqueue(item);
}
}
private async Task ProccessMessage()
{
TcpMessage requestMessage = await MessageTransport.ReadAsync(this._connectionInfo);
if (requestMessage == null)
{
throw new Exception("Сообщение имеет некорректный формат");
}
Command = requestMessage.Header.Command;
bool isNeedExeLog = ServerCommands.IsNeedExeLog(Command);
Stopwatch stopwatch = null;
if (isNeedExeLog)
{
stopwatch = new Stopwatch();
stopwatch.Start();
}
using (CommandContext commandContext = new CommandContext(this, requestMessage, _bufferManager))
{
this._commandContext = commandContext;
await CommandDispatcher.Instance.ExecuteAsync(commandContext);
this._commandContext = null;
}
if (isNeedExeLog)
{
stopwatch.Stop();
ServerLog.AddFBLog(ExecuteFolder,
string.Format("| {0,8} | {1,8} | {2}", Command, stopwatch.ElapsedMilliseconds, ClientAddress));
}
}
private void sendTcpMessage(TcpClient tcpClient, TcpMessage msg)
{
NetworkStream serverStream = tcpClient.GetStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(serverStream, msg);
}
public void BroadcastTCP(TcpMessage message)
{
foreach (Player client in clients)
{
client.SendTCP(message);
}
}
private void Message_Received(object sender, MessageReceivedFromClientEventArgs e)
{
TcpMessage msg = JsonConvert.DeserializeObject <TcpMessage>(Encoding.UTF8.GetString(e.Data));
Client clientName = clients.FirstOrDefault(c => c.IpAddress == e.IpPort);
switch (msg.MessageType)
{
case MessageType.Message:
memoEdit1.Invoke((MethodInvoker) delegate
{
memoEdit1.Text += clientName.UserName + " : " + msg.Message + System.Environment.NewLine;
});
break;
case MessageType.SendUserName:
var Client = clients.SingleOrDefault(c => c.IpAddress == e.IpPort);
if (Client != null)
{
Client.UserName = msg.Message;
gridView1.RefreshData();
}
break;
}
}
public void onReceivedTCP(TcpMessage message)
{
MsgPack msgpack = new MsgPack();
msgpack.DecodeFromBytes(message.getContent());
StringBuilder builder = new StringBuilder();
builder.Append("[");
builder.Append("c: ");
builder.Append(msgpack.ForcePathObject("c").AsString);
builder.Append(", ");
builder.Append("d: [");
foreach (MsgPack item in msgpack.ForcePathObject("d"))
{
if (item.ValueType != MsgPackType.Array)
{
builder.Append(item.AsString);
builder.Append(", ");
}
else
{
builder.Append("[");
foreach (MsgPack i in item)
{
builder.Append(i.AsString);
builder.Append(", ");
}
builder.Append("]");
}
}
builder.Append("]");
clientLog(builder.ToString());
}
/// <summary>
/// Deletes the specified event data.
/// </summary>
/// <param name="eventData">The event data.</param>
/// <returns>Huawei.SCOM.ESightPlugin.WebServer.Model.ApiResult.</returns>
public static ApiResult Delete(object eventData)
{
var ret = new ApiResult(ConstMgr.ErrorCode.SYS_UNKNOWN_ERR, string.Empty);
try
{
var jsData = JsonUtil.SerializeObject(eventData);
HWLogger.UI.InfoFormat("Deleting eSight, the param is [{0}]", jsData);
var hostIps = eventData.ToString().TrimEnd(',').Split(',');
foreach (var hostIp in hostIps)
{
try
{
// 取消订阅（不再修改eSight的订阅状态）
var eSight = ESightDal.Instance.GetEntityByHostIp(hostIp);
if (eSight == null)
{
throw new Exception("can not find eSight:" + hostIp);
}
UnSubscribeESight(hostIp, eSight.SystemID, true);
// 从文件中删除
ESightDal.Instance.DeleteESightByHostIp(hostIp);
// 告诉服务（删除scom中的服务器）
Task.Run(() =>
{
var message = new TcpMessage <string>(hostIp, TcpMessageType.DeleteESight, "delete a ESight");
NotifyClient.Instance.SendMsg(message);
});
}
catch (Exception ex)
{
HWLogger.UI.Error($"Deleting eSight({hostIp}) error !", ex);
}
}
HWLogger.UI.Info("Deleting eSight successful!");
ret.Code = "0";
ret.Success = true;
ret.Msg = "Deleting eSight successful!";
}
catch (BaseException ex)
{
HWLogger.UI.Error("Deleting eSight failed: ", ex);
ret.Code = $"{ex.ErrorModel}{ex.Code}";
ret.Success = false;
ret.ExceptionMsg = ex.Message;
}
catch (Exception ex)
{
HWLogger.UI.Error("Deleting eSight failed: ", ex);
ret.Code = ConstMgr.ErrorCode.SYS_UNKNOWN_ERR;
ret.Success = false;
ret.ExceptionMsg = ex.InnerException?.Message ?? ex.Message;
}
return(ret);
}
/// <summary>
/// The process request.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <exception cref="Exception">ex
/// </exception>
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
var url = context.Request.Url;
var formData = context.Request.Form;
try
{
// todo 校验header中的OpenId
var subscribeId = context.Request.QueryString["subscribeID"];
var msgType = context.Request.Form["msgType"];
var data = context.Request.Form["data"];
var datas = JsonUtil.DeserializeObject <List <NedeviceData> >(data);
if (!datas.Any())
{
throw new Exception($"The message do not contain \"data\" param .");
}
var alarmData = datas.FirstOrDefault();
if (alarmData == null)
{
throw new Exception($"alarmData is null");
}
HWLogger.NOTIFICATION.Info($"url :{url},msgType{msgType}, data:{JsonUtil.SerializeObject(alarmData)}");
if (string.IsNullOrWhiteSpace(alarmData.DeviceId))
{
throw new Exception($"The message do not contain \"DeviceId\" param.");
}
var eSight = ESightDal.Instance.GetEntityBySubscribeId(subscribeId);
if (eSight == null)
{
HWLogger.NOTIFICATION.Warn($"can not find the eSight,subscribeID:{subscribeId}");
}
else
{
var nedevice = new NotifyModel <NedeviceData>
{
SubscribeId = subscribeId,
MsgType = Convert.ToInt32(msgType),
ResourceURI = context.Request.Form["resourceURI"],
Timestamp = context.Request.Form["timestamp"],
Description = context.Request.Form["description"],
ExtendedData = context.Request.Form["extendedData"],
Data = datas.FirstOrDefault()
};
Task.Run(() =>
{
var message = new TcpMessage <NotifyModel <NedeviceData> >(eSight.HostIP, TcpMessageType.NeDevice, nedevice);
NotifyClient.Instance.SendMsg(message);
});
}
}
catch (Exception ex)
{
HWLogger.NOTIFICATION.Error($"NeDevice Notification Error:{url} formData:{formData}", ex);
context.Response.Write($"NeDevice Notification Error:{ ex } ");
}
context.Response.End();
}
/// <summary>
/// Get the user list from server
/// </summary>
/// <param name="request"></param>
void HUserList(TcpMessage Request)
{
Msg("Get users list");
if (OnUserList != null)
{
OnUserList(ResponseUserList.GetUsers(Request));
}
}
void HTalkOffer(TcpMessage request)
{
Msg(request.From + " offer to talk");
if (OnTalkOffer != null)
{
OnTalkOffer(request.From);
}
}
void HTalkEnd(TcpMessage Request)
{
if (OnTalkEnd != null)
{
OnTalkEnd(Request.From);
}
Msg(Request.From + " is hang up");
}
/// <summary>
/// Server send some custom data
/// </summary>
public void HRequestCustomData(TcpMessage request)
{
Msg("Receive custom data");
if (OnCustomData != null)
{
OnCustomData((CustomData)request.State, request.GetMessageString());
}
}
/// <summary>
/// Text message event
/// </summary>
/// <param name="request"></param>
void HWriteFor(TcpMessage Request)
{
Msg("Get message from " + Request.From);
if (OnChat != null)
{
OnChat(Request.From, Request.GetMessageString());
}
}
internal void ServePingRequest(TcpClient p_tcpClient, TcpMessage p_message)
{
if (p_message.ResponseFormat == TcpMessageResponseFormat.String)
{
string responseStr = "Ping. Healthmonitor UtcNow: " + DateTime.UtcNow.ToString("yyyy-MM-dd'T'HH:mm:ss.fff", CultureInfo.InvariantCulture);
BinaryWriter bw = new BinaryWriter(p_tcpClient.GetStream());
bw.Write(responseStr);
}
}
public static Mock <ITcpService> BuildReceieve(this Mock <ITcpService> mock, int seqNumber, byte[] body)
{
var message = new TcpMessage(seqNumber, body);
var memoryStream = new MemoryStream(message.Encode());
mock.BuildReceieve(() => Task.FromResult((Stream)memoryStream));
return(mock);
}
public async Task <bool> WriteEx(byte[] message, byte[] response)
{
await this._stream.WriteAsync(message, 0, message.Length);
bool result = await TcpMessage.ReadBytes(this._stream, response);
Interlocked.Increment(ref Writes);
return(result);
}
public void sendAnotherUsersMessage(TcpMessage msg, TcpClient tcpClientSender)
{
foreach (TcpClient tcpClient in mapUsers.Values)
{
if (tcpClient.Equals(tcpClientSender))
continue;
sendTcpMessage(tcpClient, msg);
}
}
public void processMessage()
{
TcpMessage message = __getItemFromQueue();
if (message != null)
{
__listener.onReceivedTCP(message);
}
}
/// <summary>
/// User was requested a userlist
/// </summary>
/// <param name="request"></param>
/// <param name="endPoint"></param>
public void HUserList(TcpMessage request)
{
IPEndPoint ep = Users[request.From].EndPoint;
string usr = Users.GetKey(ep);
Users[usr].Update();
SendRequest(ep, new ResponseUserList(Users.Keys).GetBytes());
Msg("User " + usr + " request a user list");
}
private TcpMessage getTcpMessage(TcpClient tcpClient)
{
NetworkStream stream = tcpClient.GetStream();
IFormatter formatter = new BinaryFormatter();
TcpMessage obj = (TcpMessage)formatter.Deserialize(stream);
return(obj);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="message">Owner TcpMessage server message.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>message</b> is null reference.</exception>
public TcpMessageEventArgs(TcpMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
m_Task = message;
}
/// <summary>
/// User request some custom data, e.g. udp server port
/// </summary>
public void HRequestCustomData(TcpMessage Request)
{
CCommon.CustomData cData = (CCommon.CustomData)Request.State;
if (!CustomData.ContainsKey(cData))
{
return;
}
SendRequest(Users[Request.From].EndPoint,
new RequestCustomData(Request.From, cData, CustomData[cData]).GetBytes());
}
private static TcpPackage WrapPong(TcpMessage.PongMessage message)
{
return new TcpPackage(TcpCommand.Pong, message.CorrelationId, message.Payload);
}
private void sendTcpMessage(TcpClient tcpClient, TcpMessage msg)
{
NetworkStream serverStream = tcpClient.GetStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(serverStream, msg);
}
private void sendMsg(TcpMessage msg)
{
if (isServer)
{
socketServer.serverListener.sendAnotherUsersMessage(msg, null);
}
else
{
userChat.sendMessageObject(msg);
}
}
public void printError(TcpMessage msg)
{
printMessageChat("Error login user. Msg:"+msg.getMsg());
}
public void BeginSend(TcpMessage message)
{
byte[] sendData = message.Data;
ClientSocket.BeginSend(sendData, 0, sendData.Length, 0, OnSend, ClientSocket);
}
public void sendMessageObject(TcpMessage msg)
{
NetworkStream serverStream = userInfo.getTcpClient().GetStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(serverStream, msg);
}
private TcpPackage WrapAuthenticated(TcpMessage.Authenticated msg)
{
return new TcpPackage(TcpCommand.Authenticated, msg.CorrelationId, Empty.ByteArray);
}
private TcpPackage WrapNotAuthenticated(TcpMessage.NotAuthenticated msg)
{
return new TcpPackage(TcpCommand.NotAuthenticated, msg.CorrelationId, Helper.UTF8NoBom.GetBytes(msg.Reason ?? string.Empty));
}
public TcpNetworkAction(TcpMessage message)
{
Message = message;
}
