/// <summary>
/// ImageServiceSrv constructor.
/// </summary>
/// <param name="port">port num</param>
/// <param name="logging">ILoggingService obj</param>
/// <param name="ch">IClientHandler obj</param>
public ImageServiceSrv(int port, ILoggingService logging, IClientHandler ch)
{
this.Port = port;
this.Logging = logging;
this.Ch = ch;
ClientHandler.Mutex = m_mutex;
}
private void OnLoginPress(object sender, RoutedEventArgs e)
{
//purposely using variable capturing here
string loginName = this.localName.Text;
this.Name = loginName;
//get sending task off the GUI thread
Task.Run(() =>
{
try
{
IResponseManager responseManager = this.services.ResponseManager;
responseManager.Start();
IMessageHandler messageHandler = this.services.MessageHandler;
IMessage request = messageHandler.GetMessage(loginName, "server", loginName,
MessageCommand.LoginRequest);
IClientHandler clientHandler = this.services.ClientHandler;
clientHandler.SendMessage(request);
}
catch (Exception exception)
{
this.services.ChatLog.LogMessage(string.Format("Unable to send log in : {0}", exception.Message));
}
});
}
/// <summary>
/// Represents a TCP server channel.
/// </summary>
/// <param name="port">The server's port.</param>
/// <param name="loggingService">The logging service.</param>
/// <param name="clientHandler">The client handler.</param>
public TcpServerChannel(int port, ILoggingService loggingService, IClientHandler clientHandler)
{
this.port = port;
this.clientHandler = clientHandler;
this.loggingService = loggingService;
writeLock = clientHandler.getLock();
}
private void OnUpdateNamePress(object sender, RoutedEventArgs e)
{
//purposely using variable capturing here
string newName = this.localName.Text;
string oldName = this.Name;
this.Name = newName;
//get sending task off the GUI thread
Task.Run(() =>
{
try
{
IMessageHandler messageHandler = this.services.MessageHandler;
IMessage request = messageHandler.GetMessage(oldName, "server", newName, MessageCommand.UpdateName);
IClientHandler clientHandler = this.services.ClientHandler;
clientHandler.SendMessage(request);
}
catch (Exception exception)
{
this.services.ChatLog.LogMessage(string.Format("Unable to send name update : {0}", exception.Message));
}
});
}
public TcpServerChannel(int port, IClientHandler ch, ILoggingService logger)
{
this.port = port;
this.ch = ch;
this.logger = logger;
clients = new List <TcpClient>();
}
/// <summary>
/// Constructor for ImageServer class
/// </summary>
/// <param name="logging">the logging service that will be connected to the image service</param>
/// <param name="port">the port of the tcp server the constructor creates</param>
public ImageServer(ILoggingService logging, int port)
{
m_logging = logging;
IImageServiceModal modal = new ImageServiceModal();
m_controller = new ImageController(modal);
m_clientHandler = new ClientHandler(m_controller);
m_TCPServer = new TcpServerChannel(port, m_clientHandler);
m_handlerManager = HandlerManager.Instance;
m_handlerManager.Logging = m_logging;
m_handlerManager.Controller = m_controller;
m_handlerManager.CommandRecieved += delegate(object sender, CommandRecievedEventArgs e)
{
switch (e.CommandID)
{
case (int)CommandEnum.RemoveHandler:
CommandMessage message = new CommandMessage
{
Status = true,
Type = CommandEnum.RemoveHandler,
Message = @"Removed handler " + e.RequestDirPath,
Handlers = new string[] { e.RequestDirPath }
};
m_logging.Log(message.Message, LogMessageTypeEnum.INFO);
m_TCPServer.SendMessage(message.ToJSONString(), ServerMessageTypeEnum.CloseHandlerMessage);
break;
default:
break;
}
};
m_logStorage = LogStorage.Instance;
m_logging.MessageRecieved += m_logStorage.AddLog;
}
private void OnSendMessagePress(object sender, RoutedEventArgs e)
{
//Capture message text
string message = this.messageText.Text;
string messageSender = this.Name;
//send message
Task.Run(() =>
{
try
{
IMessageHandler messageHandler = this.services.MessageHandler;
IMessage request = messageHandler.GetMessage(messageSender, "server", message,
MessageCommand.ChatMessage);
IClientHandler clientHandler = this.services.ClientHandler;
clientHandler.SendMessage(request);
}
catch (Exception exception)
{
this.services.ChatLog.LogMessage(string.Format("Unable to send message : {0}", exception.Message));
}
});
//Clear message text from box
this.messageText.Clear();
}
public ISServer(int port, ILoggingService logging, IClientHandler ch)
{
this.port = port;
this.Logging = logging;
this.ch = ch;
ClientHandler.Mutex = m_mutex;
}
private void HandleReceived_Client(NecClient client, NecPacket packet)
{
if (!_clientHandlers.ContainsKey(packet.id))
{
_Logger.LogUnknownIncomingPacket(client, packet, _serverType);
return;
}
IClientHandler clientHandler = _clientHandlers[packet.id];
if (clientHandler.expectedSize != NO_EXPECTED_SIZE && packet.data.Size < clientHandler.expectedSize)
{
_Logger.Error(client,
$"[{_serverType}] Ignoring Packed (Id:{packet.id}) is smaller ({packet.data.Size}) than expected ({clientHandler.expectedSize})");
return;
}
_Logger.LogIncomingPacket(client, packet, _serverType);
packet.data.SetPositionStart();
try
{
clientHandler.Handle(client, packet);
}
catch (Exception ex)
{
_Logger.Exception(client, ex);
}
}
/// <summary>
/// getting the settings from the app config and Initializing the service
/// </summary>
/// <param name="args">arguments</param>
public ImageService(string[] args)
{
InitializeComponent();
string handler = ConfigurationManager.AppSettings.Get("Handler");
string outputDir = ConfigurationManager.AppSettings.Get("OutputDir");
string thumbnailSize = ConfigurationManager.AppSettings.Get("ThumbnailSize");
string eventSourceName = ConfigurationManager.AppSettings.Get("SourceName");
string logName = ConfigurationManager.AppSettings.Get("LogName");
eventLog1 = new System.Diagnostics.EventLog();
if (!System.Diagnostics.EventLog.SourceExists(eventSourceName))
{
System.Diagnostics.EventLog.CreateEventSource(eventSourceName, logName);
}
eventLog1.Source = eventSourceName;
eventLog1.Log = logName;
logging = new LoggingService();
logging.MessageRecieved += OnMsg;
modal = new ImageServiceModal(outputDir, int.Parse(thumbnailSize));
controller = new ImageController(modal, logging);
imageServer = new ImageServer(controller, logging, handler);
//clientHandler = new HandleGuiClient(controller, logging, imageServer);
clientHandler = new HandleAndroidClient(controller, logging, imageServer);
serverChannel = new TcpServerChannel(8000, logging, clientHandler);
clientHandler.NotifyClients += serverChannel.NotifyClients;
}
/// <summary>
/// Removes client handler
/// </summary>
public void RemoveClientHandler(IClientHandler handler)
{
List <IClientHandler> list = _clientHandlers.ToList();
list.Remove(handler);
_clientHandlers = list.ToArray();
}
public NetworkServer(int i_Port, IImageController i_Controller, ILoggingService i_Logger)
{
m_Port = i_Port;
m_Logger = i_Logger;
m_Controller = i_Controller;
m_ClientHandler = new ClientHandler();
}
private void HandleReceived_Client(MhfClient client, MhfPacket packet)
{
if (!_clientHandlers.ContainsKey(packet.Id))
{
//_logger.LogUnknownIncomingPacket(client, packet);
return;
}
IClientHandler clientHandler = _clientHandlers[packet.Id];
if (clientHandler.ExpectedSize != NoExpectedSize && packet.Data.Size < clientHandler.ExpectedSize)
{
_logger.Error(client,
$"Ignoring Packed (Id:{packet.Id}) is smaller ({packet.Data.Size}) than expected ({clientHandler.ExpectedSize})");
return;
}
// _logger.LogIncomingPacket(client, packet);
packet.Data.SetPositionStart();
try
{
clientHandler.Handle(client, packet);
}
catch (Exception ex)
{
_logger.Exception(client, ex);
}
}
public IServerMsg.EnterRoomResponse <byte[]> EnterRoom(IClientHandler client, string?password, byte[]?status)
{
if (Password is string p && p != password)
{
return(IServerMsg.EnterRoomResponse.InvalidPassword);
}
if (Info.MaxNumberOfPlayers == _clients.Count)
{
return(IServerMsg.EnterRoomResponse.NumberOfPlayersLimitation);
}
if (!_roomConfig.EnterWhenPlayingAllowed && RoomStatus == RoomStatus.Playing)
{
return(IServerMsg.EnterRoomResponse.InvalidRoomStatus);
}
if (_clients.Contains(client))
{
return(IServerMsg.EnterRoomResponse.AlreadyEntered);
}
var ownerId = EnterRoomWithoutCheck(client, status);
WriteInfo($"Room({Id}): client({client.Id}) entered.");
return(IServerMsg.EnterRoomResponse.Success(ownerId, _playersStatuses, Info.Message));
}
public Info()
{
ep = new IPEndPoint(IPAddress.Parse(_settings.FlightServerIP), _settings.FlightInfoPort);
_settings = ApplicationSettingsModel.Instance;
_stop = false;
ch = new ClientHandler();
}
public async Task <GenericCommandResult <ClientEntity> > Repprove([FromServices] IClientHandler handler,
[FromBody] RepproveClientCommand command)
{
var result = (GenericCommandResult <ClientEntity>) await handler.HandleAsync(command);
return(result);
}
/// <summary>
/// Starts this instance.
/// </summary>
public void Start()
{
listener.Start();
Console.WriteLine("Waiting for conections...");
Task task = new Task(() =>
{
IClientHandler ch;
while (true)
{
try
{
TcpClient client = listener.AcceptTcpClient();
ch = new ClientHandler(client);
clients.Add(ch);
ch.DataReceived += MoveToServer;
ch.Start();
}
catch (SocketException)
{
break;
}
}
});
task.Start();
}
private List <TcpClient> clientsList; //list of all connected clients.
/*constructor for server communication.
* param name=port1, the port we listen to.
* param name=clientHandler, variable of the class that handles all gui service.
*/
public TCPServer(int port1, IClientHandler clientHandler1)
{
this.port = port1;
this.clientHandler = clientHandler1;
this.clientsList = new List <TcpClient>();
Start();
}
public void AddHandler(IClientHandler clientHandler, bool overwrite = false)
{
if (overwrite)
{
if (_clientHandlers.ContainsKey(clientHandler.Id))
{
_clientHandlers[clientHandler.Id] = clientHandler;
}
else
{
_clientHandlers.Add(clientHandler.Id, clientHandler);
}
return;
}
if (_clientHandlers.ContainsKey(clientHandler.Id))
{
_logger.Error($"ClientHandlerId: {clientHandler.Id} already exists");
}
else
{
_clientHandlers.Add(clientHandler.Id, clientHandler);
}
}
/// <summary>
/// Adds client handler
/// </summary>
public void AddClientHandler(IClientHandler handler)
{
List <IClientHandler> list = _clientHandlers.ToList();
list.Add(handler);
_clientHandlers = list.ToArray();
}
public void Start(string ip, int port, IClientHandler clientHandler)
{
//Initialize connection settings.
IPEndPoint ep = new
IPEndPoint(IPAddress.Parse(ip), port);
listener = new TcpListener(ep);
//Start listening for connections.
listener.Start();
Console.WriteLine("Waiting for connections...");
//The server task.
this.ServerTask = new Task(() =>
{
while (true)
{
try
{
//Accept new connection.
TcpClient client = listener.AcceptTcpClient();
Console.WriteLine("Got new connection");
clientHandler.HandleClient(client);
}
catch (SocketException)
{
break;
}
}
Console.WriteLine("Server stopped");
});
this.ServerTask.Start();
}
public void Start()
{
//create socket to server
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
listener = new TcpListener(ep);
listener.Start();
/*
* wait to clients
*/
Task task = new Task(() =>
{
while (true)
{
try
{
TcpClient client = listener.AcceptTcpClient();
Console.WriteLine("Got new connection");
//perform the task
this.ch = new ClientHandler(client);
ch.HandleClient(client, this.controller);
}
catch (SocketException)
{
break;
}
}
Console.WriteLine("Server stopped");
Console.ReadKey();
}); task.Start();
}
/// <summary>
/// OnClientClose is summoned by the ClientClose event.
/// The method gets the ClientHandler out from the SendAll event handlers list,
/// and gets the ExecuteCommand out from the ClientHandler's NewMessage event handlers list.
/// </summary>
/// <param name="sender">the ClientHandler that closed</param>
public void OnClientClose(object sender, EventArgs args)
{
m_logging.Log("Client closed", MessageTypeEnum.INFO);
IClientHandler ch = (IClientHandler)sender;
CloseAll -= ch.OnCloseAll;
ch.NewMessage -= GetPhoto;
}
public TcpServer(int port, IClientHandler ch, ILoggingService m_logging)
{
this.port = port;
this.ch = ch;
this.clients = new List <TcpClient>();
this.mux = new Mutex();
m_logging.MessageRecieved += SpreadLogEntry;
}
public TcpServerChannel()
{
string ip = ConfigurationManager.AppSettings["Ip"];
string port = ConfigurationManager.AppSettings["Port"];
server = new TcpListener(IPAddress.Any, Int32.Parse(port));
clientHandler = new ClientHandler();
}
/// <summary>
/// new
/// </summary>
/// <param name="protocol"></param>
public BaseSocketClient(IPAddress remote, int port, IClientHandler handler)
: this(new DefaultBinaryProtocol(), 8192, 8192, 3000, 3000)
{
if (handler == null) throw new ArgumentNullException("handler");
this._handler = handler;
this._remote = remote;
this._port = port;
}
/// <summary>
/// Removes the handler from list.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void RemoveHandlerFromList(object sender, EventArgs e)
{
IClientHandler handlerToRemove = (IClientHandler)sender;
m_mutex.WaitOne();
this.ch.Remove(handlerToRemove);
m_mutex.ReleaseMutex();
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="logging"></param>
/// <param name="handler"></param>
/// <param name="port"></param>
public ServiceServer(ILoggingService logging, IClientHandler handler, int port)
{
this.Logging = logging;
this.PortNumber = port;
this.Handler = handler;
clientList = new List <TcpClient>();
ClientHandler.MutexLock = serverMutex;
}
public ISServer(int port, ILoggingService logging, IClientHandler ch)
{
this.port = port;
this.Logging = logging;
this.ch = ch;
ClientHandler.Mutex = m_mutex;
debug = new Debug_program();
}
public StateService(IFarmContext context, IDateTime dateTime, ISettingsService settingsService, IFarmBuilder farmBuilder, IClientHandler clientHandler)
{
_context = context;
_dateTime = dateTime;
_settingsService = settingsService;
_farmBuilder = farmBuilder;
_clientHandler = clientHandler;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="imageServer"></param>
/// <param name="imageController"></param>
/// <param name="logging"></param>
/// <param name="port"></param>
public MobileServer(ImageServer imageServer, IImageController imageController, ILoggingService logging, int port)
{
this.m_port = port;
this.m_logging = logging;
this.m_controller = imageController;
this.m_imageServer = imageServer;
this.m_ch = new ClientHandleForMobile(this.m_logging);
}
public Client(string hostname, int port, IClientHandler handler)
{
this.handler = handler;
this.tcpClient = new TcpClient();
this.tcpClient.Connect(hostname, port);
this.networkStream = this.tcpClient.GetStream();
this.handler.Log("Connected");
ThreadPool.QueueUserWorkItem(ReadThread);
}
public DefaultSocketClient(IPAddress address, int port, IClientHandler handler,IEncoder encoder)
: base(address, port, handler)
{
if (encoder == null) throw new ArgumentNullException("encoder");
this._encoder = encoder;
}
public void Add(IPEndPoint endpoint, IClientHandler clientHandler)
{
this.m_Handlers.Add(endpoint, clientHandler);
}
private void RemoveHandler(IClientHandler handler)
{
lock(_openConnections) {
_openConnections.Remove(handler);
}
}
