public virtual void Close(string Reason, bool Retry = true)
{
if (isClosed)
{
return;
}
isClosed = true;
if ((Socket != null) && (Socket.Connected))
{
// Write("Close socket: " + Reason);
try
{
Send(new sMsg("logout", Reason));
}
catch { }
Socket.Close(Reason, false);
Socket = null;
}
Raise_Closed(new CloseArgs(Reason, Retry));
}
private SocketArgs Connect(Socket Socket, Peer Peer, bool isSecure, bool isLocal)
{
SocketInterface sI = Sockets.Create(Socket, Peer, isSecure, isLocal);
sI.Init();
return(new SocketArgs(sI));
}
public void Start(SocketInterface tSocket)
{
this.Socket = tSocket;
this.Socket.Closed += Raw_Closed;
this.Socket.Received += Raw_Received;
this.Socket.Connection += Raw_Connected;
this.Socket.Init();
}
private void Completed(object sender, SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Close(e.SocketError.ToString(), true);
return;
}
SocketInterface tSocket = e.UserToken as SocketInterface;
Start(tSocket);
}
public RemoteOperationMaster(MESSAGE_FRAME_TYPE_T frameType, MESSAGE_DATA_CODE_T dataCode, bool dedicationR, SocketInterface sc, ref DESTINATION_ADDRESS_T destination, int sendBufferSize = 4096, int receiveBufferSize = 4096, object sync = null)
{
__socket = sc;
__frame_type = frameType;
__data_code = dataCode;
__destination = destination;
__send_byte_array = new byte[sendBufferSize];
__receive_byte_array = new byte[receiveBufferSize];
__sync_object = sync ?? new object();
switch (frameType, dataCode, dedicationR)
{
public async Task <DATA_SYNCHRONIZER_STATE_T> Stop()
{
__sync_operation_access_lock.Wait();
try
{
switch (State)
{
case DATA_SYNCHRONIZER_STATE_T.READY:
//throw new InvalidOperationException("The data synchronization thread has not started yet.");
return(DATA_SYNCHRONIZER_STATE_T.READY);
case DATA_SYNCHRONIZER_STATE_T.CONNECTED:
__stop_event.Set();
break;
case DATA_SYNCHRONIZER_STATE_T.EXCEPTION:
__stop_event.Reset();
break;
}
if (__data_sync_thread != null)
{
await Task.Run(() => __data_sync_thread.Join());
__data_sync_thread = null;
}
if (__io != null)
{
__io.Dispose();
__io = null;
}
State = DATA_SYNCHRONIZER_STATE_T.READY;
return(DATA_SYNCHRONIZER_STATE_T.READY);
}
finally
{
__sync_operation_access_lock.Release();
}
}
public void Start()
{
log.Info("Starting WebService from " + this.Name + "... ");
this.TagsWebService.Start();
log.Info("WebService from project " + this.Name + " is started. ");
log.Info("Starting TCP/IP interface... ");
//RegisterSocketInterface();
SocketInterface.Start(this);
log.Info("TCP/IP interface is started. ");
foreach (DataSource ds in this.Datasources)
{
log.Info("Starting DataSource " + ds.Name + "... ");
ds.Open();
log.Info("DataSource " + ds.Name + " is started. ");
}
}
private async void StartSteamServer(CancellationTokenSource source)
{
var token = source.Token;
void InitializeSteamServer()
{
const int GAME_PORT = 30001;
const int APP_ID = 480;
const int QUERY_PORT = GAME_PORT + 1;
Console.WriteLine($"########### STARTING STEAM SREVER ##################");
SteamServerInit serverInit = new SteamServerInit("TestInitSteamServer", "TestInitSteamServer TEST")
{
GamePort = GAME_PORT,
Secure = true,
QueryPort = QUERY_PORT,
VersionString = "0.0.0.1"
};
try
{
//SteamServer.DedicatedServer = true;
SteamServer.OnCallbackException += OnCallbackException;
SteamServer.OnSteamServerConnectFailure += OnSteamServerConnectFailure;
SteamServer.OnSteamServersConnected += OnSteamServersConnected;
SteamServer.OnSteamServersDisconnected += OnSteamServersDisconnected;
SteamServer.OnValidateAuthTicketResponse += OnValidateAuthTicketResponse;
SteamServer.Init(APP_ID, serverInit);
SteamServer.DedicatedServer = true;
SteamServer.LogOnAnonymous();
SocketInterface socket = SteamNetworkingSockets.CreateNormalSocket <SocketInterface>(NetAddress.AnyIp(GAME_PORT));
}
catch (System.Exception e)
{
Console.WriteLine($"#### SteamServer e:{e.Message}\n:{e.StackTrace}");
// Couldn't init for some reason (dll errors, blocked ports)
SteamServer.Shutdown();
}
Console.WriteLine($"#### SteamServer IsValid:{SteamServer.IsValid} IsLogedOn:{SteamServer.LoggedOn}");
}
void UpdateSteamServerCallbacks()
{
const long UPDATE_INTERVAL_IN_MS = 1000;
long lastTimeInMs = long.MinValue;
long currentTimeInMs;
try
{
while (true)
{
token.ThrowIfCancellationRequested();
if (lastTimeInMs + UPDATE_INTERVAL_IN_MS < (currentTimeInMs = DateTime.UtcNow.ToTotalMillisUTC()))
{
lastTimeInMs = currentTimeInMs;
Console.WriteLine($"\tSteamServer Updating {lastTimeInMs}");
SteamServer.RunCallbacks();
}
}
}
finally
{
SteamServer.Shutdown();
Console.WriteLine($"#### SteamServer Shutdown");
}
}
await Task.Run(() => InitializeSteamServer());
await Task.Factory.StartNew((x) => UpdateSteamServerCallbacks(), token, TaskCreationOptions.LongRunning);
}
public SocketArgs(SocketInterface Socket)
{
this.Socket = Socket;
}
public PacketPool(SocketInterface s)
{
socket = s;
}
private async void CommunicationTest_Click(object sender, RoutedEventArgs e)
{
if (__property_error_counter != 0)
{
HandyControl.Controls.MessageBox.Show(this, "At least one user input field is invalid.", "Error Message", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
var property = DataContext as TargetPropertyDataModel;
SocketInterface com = null;
IsEnabled = false;
_BusyIndicator.Visibility = Visibility.Visible;
try
{
DESTINATION_ADDRESS_T destination = new DESTINATION_ADDRESS_T(
property.NetworkNumber, property.StationNumber, property.ModuleIONumber,
property.MultidropNumber, property.ExtensionStationNumber);
if (property.UDPTransportLayer == true)
{
com = new UDP(new System.Net.IPEndPoint(property.SourceIPv4, property.SourcePort),
new System.Net.IPEndPoint(property.DestinationIPv4, property.DestinationPort),
property.ReceiveBufferSize, property.SendTimeoutValue, property.ReceiveTimeoutValue);
}
else
{
com = new TCP(new System.Net.IPEndPoint(property.SourceIPv4, 0),
new System.Net.IPEndPoint(property.DestinationIPv4, property.DestinationPort),
property.SendTimeoutValue, property.ReceiveTimeoutValue);
//__tcp.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, new LingerOption(true, 0));
await Task.Run(() => (com as TCP).Connect());
}
var master = new RemoteOperationMaster(property.FrameType, property.DataCode, property.R_DedicatedMessageFormat, com, ref destination,
property.SendBufferSize, property.ReceiveBufferSize, null);
(ushort end, string name, ushort code) = await master.ReadTypeNameAsync(property.MonitoringTimer);
if (end == (ushort)RESPONSE_MESSAGE_ENDCODE_T.NO_ERROR)
{
HandyControl.Controls.MessageBox.Show(this, $"Communication success, the destination device is { name.Trim()} (0x{code:X4}).", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
HandyControl.Controls.MessageBox.Show(this, $"The destination device returns end code 0x{end:X4}.", "Warning Message", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
catch (SLMPException ex)
{
HandyControl.Controls.MessageBox.Show(this, "At least one unexpected error occured while doing communication test.\n" + ex.Message, "Error Message", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
_BusyIndicator.Visibility = Visibility.Hidden;
IsEnabled = true;
if (com != null)
{
com.Dispose();
}
com = null;
}
}
}
public async Task <DATA_SYNCHRONIZER_STATE_T> Startup(TargetPropertyDataModel target)
{
__sync_operation_access_lock.Wait();
try
{
switch (State)
{
case DATA_SYNCHRONIZER_STATE_T.CONNECTED:
//throw new InvalidOperationException("The data synchronization thread is still running.");
return(DATA_SYNCHRONIZER_STATE_T.CONNECTED);
case DATA_SYNCHRONIZER_STATE_T.EXCEPTION:
if (__data_sync_thread != null)
{
__data_sync_thread.Join();
__data_sync_thread = null;
}
break;
case DATA_SYNCHRONIZER_STATE_T.READY:
break;
}
__stop_event.Reset();
if (target.UDPTransportLayer)
{
__io = new UDP(new System.Net.IPEndPoint(target.SourceIPv4, target.SourcePort),
new System.Net.IPEndPoint(target.DestinationIPv4, target.DestinationPort),
target.ReceiveBufferSize, target.SendTimeoutValue, target.ReceiveTimeoutValue);
}
else
{
__io = new TCP(new System.Net.IPEndPoint(target.SourceIPv4, 0),
new System.Net.IPEndPoint(target.DestinationIPv4, target.DestinationPort),
target.SendTimeoutValue, target.ReceiveTimeoutValue);
}
DESTINATION_ADDRESS_T destination = new DESTINATION_ADDRESS_T(target.NetworkNumber, target.StationNumber, target.ModuleIONumber, target.MultidropNumber, target.ExtensionStationNumber);
DeviceAccessMaster master = new DeviceAccessMaster(target.FrameType, target.DataCode, target.R_DedicatedMessageFormat, __io,
ref destination, target.SendBufferSize, target.ReceiveBufferSize);
if (__io is TCP)
{
State = DATA_SYNCHRONIZER_STATE_T.CONNECTING;
await Task.Run(() => (__io as TCP).Connect());
}
__heartbeat_counter = 0;
__data_sync_thread = new Thread(new ParameterizedThreadStart(__data_sync_routine));
__data_sync_thread.Start(Tuple.Create(master, (ushort)(target.MonitoringTimer / 250), target.PollingInterval));
State = DATA_SYNCHRONIZER_STATE_T.CONNECTED;
ExceptionMessage = "";
return(DATA_SYNCHRONIZER_STATE_T.CONNECTED);
}
catch (SLMPException ex)
{
State = DATA_SYNCHRONIZER_STATE_T.EXCEPTION;
ExceptionMessage = ex.Message;
return(DATA_SYNCHRONIZER_STATE_T.EXCEPTION);
}
finally
{
__sync_operation_access_lock.Release();
}
}
