public void OnErrorRaised(string message, string code = null, string file = null, int lineNumber = -1, int columnNumber = -1, int endLineNumber = -1, int endColumnNumber = -1, string helpKeyword = null, string senderName = null)
{
BuildErrorEventArgs args = new BuildErrorEventArgs(null, code, file, lineNumber, columnNumber, endLineNumber, endColumnNumber, message, helpKeyword, senderName);
ErrorRaised?.Invoke(this, args);
OnAnyEventRaised(args);
}
/// <summary>
/// プロパティアイテムの値が変更された
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">PropertyChangedEventArgs</param>
protected virtual void OwnedPropertyChanged(object sender, PropertyChangedEventArgs e)
{
var property = sender as PropertyItemBase;
if (property != null)
{
if (e.PropertyName == "Value")
{
RaisePropertyChanged(property.Name);
}
// モデルに変更を通知する
if (e.PropertyName == "IsChanged" && (IsChangedFilter?.Invoke(property) ?? true))
{
RaisePropertyChanged(e.PropertyName);
}
// モデルにエラーを通知する
if (e.PropertyName == "HasError" && (HasErrorFilter?.Invoke(property) ?? true))
{
RaisePropertyChanged(e.PropertyName);
if (property.HasError)
{
ErrorRaised?.Invoke(this, new PropertyItemEventArgs(property));
}
else
{
ErrorCleard?.Invoke(this, new PropertyItemEventArgs(property));
}
}
}
}
private void Run()
{
while (!isTerminal)
{
if (this.msgQueue.IsEmpty)
{
Thread.Sleep(5);
}
else
{
HostarLogBean bean = null;
this.msgQueue.TryDequeue(out bean);
if (bean != null)
{
string log = bean.Message;
if (bean.Module == 0)
{
log = "[前模组]-" + bean.Message;
}
else if (bean.Module == 1)
{
log = "[后模组]-" + bean.Message;
}
switch (bean.LogLevel)
{
case MsgLevel.Debug:
basicLog?.Debug(log);
break;
case MsgLevel.Info:
basicLog?.Info(log);
InfoRaised?.Invoke(bean);
break;
case MsgLevel.Warn:
basicLog?.Warn(log);
ErrorRaised?.Invoke(bean);
break;
case MsgLevel.Error:
errLog?.Error(log);
ErrorRaised?.Invoke(bean);
break;
case MsgLevel.Fatal:
errLog?.Fatal(log);
ErrorRaised?.Invoke(bean);
break;
default:
break;
}
}
}
}
}
/// <summary>
/// Raise one of the events that is appropriate for the type of the BuildEventArgs
/// </summary>
public void Dispatch(BuildEventArgs buildEvent)
{
if (buildEvent is BuildMessageEventArgs)
{
MessageRaised?.Invoke(null, (BuildMessageEventArgs)buildEvent);
}
else if (buildEvent is TaskStartedEventArgs)
{
TaskStarted?.Invoke(null, (TaskStartedEventArgs)buildEvent);
}
else if (buildEvent is TaskFinishedEventArgs)
{
TaskFinished?.Invoke(null, (TaskFinishedEventArgs)buildEvent);
}
else if (buildEvent is TargetStartedEventArgs)
{
TargetStarted?.Invoke(null, (TargetStartedEventArgs)buildEvent);
}
else if (buildEvent is TargetFinishedEventArgs)
{
TargetFinished?.Invoke(null, (TargetFinishedEventArgs)buildEvent);
}
else if (buildEvent is ProjectStartedEventArgs)
{
ProjectStarted?.Invoke(null, (ProjectStartedEventArgs)buildEvent);
}
else if (buildEvent is ProjectFinishedEventArgs)
{
ProjectFinished?.Invoke(null, (ProjectFinishedEventArgs)buildEvent);
}
else if (buildEvent is BuildStartedEventArgs)
{
BuildStarted?.Invoke(null, (BuildStartedEventArgs)buildEvent);
}
else if (buildEvent is BuildFinishedEventArgs)
{
BuildFinished?.Invoke(null, (BuildFinishedEventArgs)buildEvent);
}
else if (buildEvent is CustomBuildEventArgs)
{
CustomEventRaised?.Invoke(null, (CustomBuildEventArgs)buildEvent);
}
else if (buildEvent is BuildStatusEventArgs)
{
StatusEventRaised?.Invoke(null, (BuildStatusEventArgs)buildEvent);
}
else if (buildEvent is BuildWarningEventArgs)
{
WarningRaised?.Invoke(null, (BuildWarningEventArgs)buildEvent);
}
else if (buildEvent is BuildErrorEventArgs)
{
ErrorRaised?.Invoke(null, (BuildErrorEventArgs)buildEvent);
}
AnyEventRaised?.Invoke(null, buildEvent);
}
/// <summary>
/// Force raise of event 'ServicErrorRaised'
/// </summary>
/// <param name="error">Raised error</param>
/// <param name="context">Context of error</param>
protected bool RaiseServiceErrorRaised(Exception error, string context)
{
//Dichiaro l'argormento dell'evento
ServiceErrorRaisedEventArgs arguments = new ServiceErrorRaisedEventArgs(error, context);
//Se il gestore è stato collegatio
ErrorRaised?.Invoke(this, arguments);
//Ritorno il flag di handled dell'evento
return(arguments.MarkAsHandled);
}
private void SendDhcpMessage(string dest, DhcpMessgeType msgType, DhcpData data, OwnedIpAddress newClient)
{
try
{
var dataToSend = data.BuildSendData(msgType, newClient.Ip);
udpListener.SendData(dest, dataToSend);
}
catch (Exception e)
{
ErrorRaised?.Invoke(this, new ErrorMessageEventArgs {
Message = e.Message
});
}
}
// function to start the DHCP server
// port 67 to receive, 68 to send
public void Start()
{
try
{ // start the DHCP server
// assign the event handlers
udpListener = new UdpListener(67, 68, _settings.ServerIp.ToString());
udpListener.Received += UdpListener_Received;
}
catch (Exception e)
{
ErrorRaised?.Invoke(this, new ErrorMessageEventArgs {
Message = e.Message
});
throw e;
}
}
protected virtual void RaiseError(
Exception e = null,
string errorMessage = null,
SyncErrorEventArgs.ErrorSeverity errorSeverity = SyncErrorEventArgs.ErrorSeverity.Minor)
{
SyncErrorEventArgs args = new SyncErrorEventArgs()
{
Exception = e,
Severity = errorSeverity,
ErrorMessage = errorMessage,
TimeStamp = DateTime.Now,
TypeOfElement = GetType()
};
ErrorRaised?.Invoke(this, args);
}
void Start()
{
InitializePacketObservables();
var bandwidthInterval = TimeSpan.FromMilliseconds(100);
Observable.Interval(bandwidthInterval).Subscribe(_ =>
{
var ts = TimeUtils.NowTimestamp - 1000;
bandwidth.Flush(ts);
_receivedBytes.SetValueAndForceNotify(bandwidth.GetReceivedBytesPerSeconds(ts));
_sentBytes.SetValueAndForceNotify(bandwidth.GetSentBytesPerSecond(ts));
}).AddTo(this);
var heartbeatInterval = TimeSpan.FromSeconds(Config.HeartbeatInterval);
Observable.Interval(heartbeatInterval).SkipUntil(ReadyObservable).Subscribe(_ =>
{
SendImmediate(new HeartbeatPacket());
}).AddTo(this);
var flushInterval = TimeSpan.FromMilliseconds(300);
Observable.Interval(flushInterval).SkipUntil(ReadyObservable).Subscribe(_ => Flush()).AddTo(this);
ErrorRaised.Subscribe(msg =>
{
Debug.LogError($"Error: " + ws.error);
if (loop != null)
{
loop.Dispose();
loop = null;
}
// dont destory on load로 등록된 네트워크 관련 객체 삭제
// 네트워크 접속 실패시 처음부터 재시작하는게 목적
// TOOD 최초 접속 에러와 게임 도중 접속 에러를 분리하기
Destroy(PingChecker.Instance.gameObject);
Destroy(ConnectionManager.Instance.gameObject);
SceneManager.LoadScene(initialScene, LoadSceneMode.Single);
}).AddTo(this);
loop = Observable.FromCoroutine(BeginLoop).Subscribe();
}
private async Task PingLoopAsync(SocketSession session, CancellationToken cancellationToken = default)
{
try
{
while (!cancellationToken.IsCancellationRequested && this.IsConnected)
{
await Task.Delay(session.PingInterval, cancellationToken).ConfigureAwait(false);
if (!cancellationToken.IsCancellationRequested && this.IsConnected)
{
await SendInternalAsync(_pingMessage, null, cancellationToken).ConfigureAwait(false);
}
}
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
ErrorRaised?.Invoke(this, new UnhandledExceptionEventArgs(ex, true));
}
}
public void UdpListener_Received(byte[] data, IPEndPoint endPoint)
{
try
{
var dhcpData = new DhcpData(data)
{
RelatedServer = this
};
var msgType = dhcpData.GetCurrentMessageType();
var client = dhcpData.GetClientInfo();
switch (msgType)
{
case DhcpMessgeType.DHCP_DISCOVER:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPDISCOVER received."
});
Discovered?.Invoke(client);
var newIp = ownedIpAddressPool.Find(x => (x.AuthorizedClientMac == client.MacAddress) || (x.IsAllocated == false && x.AuthorizedClientMac == null));
if (newIp.Ip == null)
{
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "No ip is available to allocate."
});
return;
}
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPOFFER sent."
});
// MUST be unicast over raw socket (unimplemented)
// broadcast used
SendDhcpMessage(DhcpMessgeType.DHCP_OFFER, dhcpData, newIp);
break;
case DhcpMessgeType.DHCP_REQUEST:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPREQUEST received."
});
Requested?.Invoke(client);
switch (GetDhcpRequestType(client, endPoint))
{
// respond to client which has responded to DHCPOFFER message from this server
case DhcpRequestType.Selecting:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during SELECTING state."
});
if (_settings.ServerIp.Equals(client.ServerAddress))
{
var allocatedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.RequestAddress));
if (allocatedIp.Ip != null && !allocatedIp.IsAllocated)
{
allocatedIp.IsAllocated = true;
allocatedIp.AuthorizedClientMac = client.MacAddress;
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, allocatedIp);
}
}
break;
case DhcpRequestType.InitReboot:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during INIT-REBOOT state."
});
if (!client.RelayAgentAddress.Equals(IPAddress.Any))
{
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Relay agent is not supported in this version."
});
}
var rebootIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.RequestAddress));
if (rebootIp.Ip != null && rebootIp.AuthorizedClientMac == client.MacAddress)
{
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, rebootIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
case DhcpRequestType.ReNewing:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during RENEWING state."
});
var reNewIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (reNewIp.Ip != null && reNewIp.AuthorizedClientMac == client.MacAddress)
{
// unicast
SendDhcpMessage(client.ClientAddress.ToString(), DhcpMessgeType.DHCP_ACK, dhcpData, reNewIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
case DhcpRequestType.ReBinding:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "Response to DHCPREQUEST generated during REBINDING state."
});
var reBindIp = ownedIpAddressPool.Find(x => x.IsAllocated == false);
if (reBindIp.Ip != null)
{
reBindIp.IsAllocated = true;
reBindIp.AuthorizedClientMac = client.MacAddress;
// broadcast
SendDhcpMessage(DhcpMessgeType.DHCP_ACK, dhcpData, reBindIp);
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPACK sent."
});
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case DhcpMessgeType.DHCP_DECLINE:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPDECLINE received."
});
var declinedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (declinedIp.Ip != null)
{
ownedIpAddressPool.Remove(declinedIp);
}
break;
case DhcpMessgeType.DHCP_RELEASE:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPRELESE received."
});
var releasedIp = ownedIpAddressPool.Find(x => x.Ip.Equals(client.ClientAddress));
if (releasedIp.Ip != null)
{
releasedIp.IsAllocated = false;
}
break;
case DhcpMessgeType.DHCP_INFORM:
MessageRaised?.Invoke(this, new MessageEventArgs {
Message = "DHCPINFORM received."
});
// unicast
SendDhcpMessage(client.ClientAddress.ToString(), DhcpMessgeType.DHCP_ACK, dhcpData, null);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception e)
{
ErrorRaised?.Invoke(this, new ErrorMessageEventArgs {
Message = e.Message
});
Terminate();
throw e;
}
}
/// <summary>
/// Event invocator for the <see cref="ErrorRaised"/> event
/// </summary>
protected virtual void OnErrorRaised(Exception error)
{
ErrorRaised?.Invoke(this, new ObjectStoreErrorRaisedEventArgs(error));
}
private void OnErrorRaised(string error)
{
ErrorRaised?.Invoke(this, new StringEventArgs(error));
}
private void EventSourceOnErrorRaised(object sender, BuildErrorEventArgs e)
{
ErrorRaised?.Invoke(sender, e);
}
protected virtual void OnErrorRaised(OnErrorExceptionEventArgs e)
{
ErrorRaised?.Invoke(this, e);
}
protected virtual void RaiseReadError(Exception e, string message = null)
{
ErrorRaised?.Invoke(this, new SyncErrorEventArgs());
}
#pragma warning restore 0067
public void LogErrorEvent(BuildErrorEventArgs args)
{
ErrorRaised?.Invoke(this, args);
AnyEventRaised?.Invoke(this, args);
}
private async Task ConnectionLoopAsync()
{
Exception closeException = null;
try
{
_lastMessageID = 7;
_connectionCts = new CancellationTokenSource();
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[1024]);
while (_connectionCts?.Token.IsCancellationRequested != true)
{
// read from stream
SocketReceiveResult receivedMessage = await ReceiveAsync(buffer, _connectionCts.Token).ConfigureAwait(false);
if (!IsAnythingReceived(receivedMessage))
{
continue;
}
// parse the message
if (receivedMessage.MessageType == WebSocketMessageType.Text)
{
SocketMessage msg = SocketMessage.Parse(this.MessageEncoding.GetString(receivedMessage.ContentBytes));
// if message is binary, read them from stream as well
List <byte[]> binaryMessages = new List <byte[]>(msg.BinaryMessagesCount);
for (int i = 0; i < msg.BinaryMessagesCount; i++)
{
SocketReceiveResult receivedBinaryMessage = await ReceiveAsync(buffer, _connectionCts.Token).ConfigureAwait(false);
if (!IsAnythingReceived(receivedBinaryMessage))
{
continue;
}
if (receivedBinaryMessage.MessageType == WebSocketMessageType.Text)
{
throw new InvalidDataException("Received a text message while a binary message was expected");
}
binaryMessages.Add(receivedBinaryMessage.ContentBytes);
}
// raise event
OnTextMessageReceived(msg, binaryMessages);
}
else
{
throw new InvalidDataException("Received a binary message while a text message was expected");
}
}
}
catch (Exception ex)
{
closeException = ex;
// ignore premature close and task cancellations
// these should be treated as normal close event, not an error
if (!IsClosedPrematurelyException(ex) && !(ex is OperationCanceledException))
{
ErrorRaised?.Invoke(this, new UnhandledExceptionEventArgs(ex, true));
}
}
finally
{
// craft closed event, keeping the exception in mind
WebSocketCloseStatus status = _websocketClient?.CloseStatus ?? // websocketclient reported status has priority
(IsClosedPrematurelyException(closeException) ? WebSocketCloseStatus.ProtocolError : // if premature close, report as protocol error
(closeException is OperationCanceledException) ? WebSocketCloseStatus.NormalClosure : // if operation canceled, report as normal closure
WebSocketCloseStatus.Empty); // otherwise report unknown status
string message = _websocketClient?.CloseStatusDescription ?? closeException?.Message;
// clear cancels and nulls cts, so IsConnected will start returning false
this.Clear();
Disconnected?.Invoke(this, new SocketClosedEventArgs(status, message, closeException));
}
}
