Code/Tools/VisualStudioExtensions/CryEngineMonoDebugger/source/CryEngine.Debugger.Mono/RemoteConsole.cs

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 using System;
   4 using System.Collections.Generic;
   5 using System.Net.Sockets;
   6 using System.Threading;
   7
   8 namespace CryEngine.Debugger.Mono
   9 {
  10         static class Constants
  11         {
  12                 public const int DefaultPort = 4600;
  13                 public const int DefaultBuffer = 4096;
  14                 public const int ReconnectionTime = 3000;
  15                 public const int ConnectionAttempts = 25;
  16         }
  17
  18         public enum MessageType
  19         {
  20                 Message = 0,
  21                 Warning,
  22                 Error,
  23         }
  24
  25         public class LogMessage
  26         {
  27                 public MessageType Type { get; set; }
  28                 public string Message { get; set; }
  29
  30                 public LogMessage(MessageType type, string message)
  31                 {
  32                         Type = type;
  33                         Message = message;
  34                 }
  35         }
  36
  37         interface IRemoteConsoleClientListener
  38         {
  39                 void OnLogMessage(LogMessage message);
  40                 void OnAutoCompleteDone(List<string> autoCompleteList);
  41                 void OnConnected();
  42                 void OnDisconnected();
  43         }
  44
  45         interface IRemoteConsoleClient
  46         {
  47                 void Start();
  48                 void Stop();
  49                 void SetServer(string ip);
  50                 void ExecuteConsoleCommand(string command);
  51                 void ExecuteGameplayCommand(string command);
  52                 void SetListener(IRemoteConsoleClientListener listener);
  53                 void PumpEvents();
  54         }
  55
  56         class RemoteConsoleClientListenerState
  57         {
  58                 public IRemoteConsoleClientListener Listener { get; set; } = null;
  59                 public bool Connected { get; set; } = false;
  60                 public bool AutoCompleteSent { get; set; } = false;
  61
  62                 public void SetListener(IRemoteConsoleClientListener listener)
  63                 {
  64                         Listener = listener;
  65                         Reset();
  66                 }
  67
  68                 public void Reset()
  69                 {
  70                         AutoCompleteSent = false;
  71                 }
  72         }
  73
  74         class RemoteConsole : IRemoteConsoleClient, IDisposable
  75         {
  76                 private enum ConsoleEventType
  77                 {
  78                         Noop = 0,
  79                         Req,
  80                         LogMessage,
  81                         LogWarning,
  82                         LogError,
  83                         ConsoleCommand,
  84                         AutoCompleteList,
  85                         AutoCompleteListDone,
  86
  87                         Strobo_GetThreads,
  88                         Strobo_ThreadAdd,
  89                         Strobo_ThreadDone,
  90
  91                         Strobo_GetResult,
  92                         Strobo_ResultStart,
  93                         Strobo_ResultDone,
  94
  95                         Strobo_StatStart,
  96                         Strobo_StatAdd,
  97                         Strobo_IPStart,
  98                         Strobo_IPAdd,
  99                         Strobo_SymStart,
 100                         Strobo_SymAdd,
 101                         Strobo_CallstackStart,
 102                         Strobo_CallstackAdd,
 103
 104                         GameplayEvent,
 105                 }
 106
 107                 private class CommandEvent
 108                 {
 109                         public ConsoleEventType Type { get; set; }
 110                         public string Command { get; set; }
 111
 112                         public CommandEvent(ConsoleEventType type, string command)
 113                         {
 114                                 Type = type;
 115                                 Command = command;
 116                         }
 117                 }
 118
 119                 private Thread _consoleThread = null;
 120                 private TcpClient _clientSocket = null;
 121                 private byte[] _inStream = new byte[Constants.DefaultBuffer];
 122
 123                 private string _server = "";
 124                 private Queue<CommandEvent> _commands = new Queue<CommandEvent>();
 125                 private Queue<string> _autoComplete = new Queue<string>();
 126                 private Queue<LogMessage> _messages = new Queue<LogMessage>();
 127
 128                 private RemoteConsoleClientListenerState _listener = new RemoteConsoleClientListenerState();
 129
 130                 private object _locker = new object();
 131                 private object _clientLocker = new object();
 132
 133                 private volatile bool _running = false;
 134                 private volatile bool _stopping = false;
 135                 private volatile bool _isConnected = false;
 136                 private volatile bool _autoCompleteIsDone = false;
 137                 private volatile bool _resetConnection = false;
 138                 private int _ticks = 0;
 139                 private int _connectionAttempts = 0;
 140
 141                 public int Port { get; private set; }
 142
 143                 public RemoteConsole()
 144                 {
 145                         _clientSocket = null;
 146                         Port = Constants.DefaultPort;
 147                 }
 148
 149                 public RemoteConsole(int port)
 150                 {
 151                         _clientSocket = null;
 152                         Port = port;
 153                 }
 154
 155                 public bool SetPort(string portText)
 156                 {
 157                         int port = -1;
 158                         if((!_isConnected || _resetConnection) && int.TryParse(portText, out port))
 159                         {
 160                                 Port = port;
 161                                 return true;
 162                         }
 163                         return false;
 164                 }
 165
 166                 public void Start()
 167                 {
 168                         if (!_running)
 169                         {
 170                                 _running = true;
 171                                 _consoleThread = new Thread(RemoteConsoleLoop);
 172                                 _consoleThread.Name = nameof(RemoteConsoleLoop);
 173                                 _consoleThread.Start();
 174                         }
 175                 }
 176
 177                 public void Stop()
 178                 {
 179                         if (_running)
 180                         {
 181                                 _running = false;
 182                                 _stopping = true;
 183                                 lock (_clientLocker)
 184                                 {
 185                                         if (_clientSocket != null)
 186                                         {
 187                                                 _clientSocket.Close();
 188                                         }
 189                                 }
 190                                 while (_stopping && _consoleThread.IsAlive)
 191                                 {
 192                                         Thread.Sleep(10);
 193                                 }
 194                                 _consoleThread = null;
 195                         }
 196                 }
 197
 198                 public void SetServer(string ip)
 199                 {
 200                         if (_listener.Listener != null)
 201                         {
 202                                 _listener.Listener.OnDisconnected();
 203                                 _listener.Connected = false;
 204                         }
 205                         lock (_locker)
 206                         {
 207                                 _server = ip;
 208                                 _ticks = 0;
 209                                 _autoCompleteIsDone = false;
 210                                 _listener.Reset();
 211                                 _resetConnection = true;
 212                                 _connectionAttempts = 0;
 213                         }
 214                 }
 215
 216                 public void ExecuteConsoleCommand(string command)
 217                 {
 218                         lock (_locker)
 219                         {
 220                                 _commands.Enqueue(new CommandEvent(ConsoleEventType.ConsoleCommand, command));
 221                         }
 222                 }
 223
 224                 public void ExecuteGameplayCommand(string command)
 225                 {
 226                         lock (_locker)
 227                         {
 228                                 _commands.Enqueue(new CommandEvent(ConsoleEventType.GameplayEvent, command));
 229                         }
 230                 }
 231
 232                 public void SetListener(IRemoteConsoleClientListener listener)
 233                 {
 234                         lock (_locker)
 235                         {
 236                                 _listener.SetListener(listener);
 237                         }
 238                 }
 239
 240                 public void PumpEvents()
 241                 {
 242                         List<LogMessage> messages = null;
 243                         List<string> autoComplete = null;
 244                         bool sendConn = false;
 245                         bool isConn = false;
 246                         IRemoteConsoleClientListener l = null;
 247                         lock (_locker)
 248                         {
 249                                 l = _listener.Listener;
 250                                 messages = new List<LogMessage>(_messages);
 251                                 _messages.Clear();
 252                                 if (_autoCompleteIsDone && !_listener.AutoCompleteSent)
 253                                 {
 254                                         autoComplete = new List<string>(_autoComplete);
 255                                         _autoComplete.Clear();
 256                                         _listener.AutoCompleteSent = true;
 257                                 }
 258                                 if (_isConnected != _listener.Connected && !_resetConnection)
 259                                 {
 260                                         _listener.Connected = _isConnected;
 261                                         sendConn = true;
 262                                         isConn = _isConnected;
 263                                 }
 264                         }
 265                         if (l != null)
 266                         {
 267                                 if (sendConn)
 268                                 {
 269                                         if (isConn)
 270                                         {
 271                                                 l.OnConnected();
 272                                         }
 273                                         else
 274                                         {
 275                                                 l.OnDisconnected();
 276                                         }
 277                                 }
 278                                 if (messages != null)
 279                                 {
 280                                         foreach (var message in messages)
 281                                         {
 282                                                 l.OnLogMessage(message);
 283                                         }
 284                                 }
 285                                 if (autoComplete != null)
 286                                 {
 287                                         l.OnAutoCompleteDone(autoComplete);
 288                                 }
 289                         }
 290                 }
 291
 292                 private void RemoteConsoleLoop()
 293                 {
 294                         while (_running)
 295                         {
 296                                 if(!_resetConnection && !_isConnected && _connectionAttempts >= Constants.ConnectionAttempts)
 297                                 {
 298                                         AddLogMessage(MessageType.Message, string.Format("Unable to connect after {0} connection attemtps.", _connectionAttempts));
 299                                         break;
 300                                 }
 301
 302                                 if (!_isConnected || _resetConnection)
 303                                 {
 304                                         ClearCommands();
 305                                         if (_ticks++ % Constants.ReconnectionTime == 0)
 306                                         {
 307                                                 _connectionAttempts++;
 308                                                 lock (_clientLocker)
 309                                                 {
 310                                                         if (_clientSocket != null && _clientSocket.Connected)
 311                                                         {
 312                                                                 _clientSocket.GetStream().Close();
 313                                                                 _clientSocket.Close();
 314                                                                 _clientSocket.Dispose();
 315                                                         }
 316                                                         _clientSocket = new TcpClient();
 317                                                 }
 318                                                 try
 319                                                 {
 320                                                         _clientSocket.Connect(_server, Port);
 321                                                         NetworkStream stream = _clientSocket.GetStream();
 322                                                         stream.ReadTimeout = 3000;
 323                                                         stream.WriteTimeout = 3000;
 324                                                         _ticks = 0;
 325                                                 }
 326 #if DEBUG
 327                                                 catch (Exception ex)
 328                                                 {
 329                                                         // Prevent log-spam if connecting failed but there are still connection attempts left.
 330                                                         if(!(ex is SocketException) && _connectionAttempts < Constants.ConnectionAttempts)
 331                                                         {
 332                                                                 AddLogMessage(MessageType.Message, ex.Message);
 333                                                         }
 334                                                 }
 335 #else
 336                                                 catch (System.Exception){ }
 337 #endif
 338                                         }
 339
 340                                         _isConnected = _clientSocket.Client != null ? _clientSocket.Connected : false;
 341                                         if (!_isConnected)
 342                                         {
 343                                                 _autoCompleteIsDone = false;
 344                                         }
 345                                         else
 346                                         {
 347                                                 // Reset the connection attempts if reconnecting was succesful.
 348                                                 _connectionAttempts = 0;
 349                                         }
 350
 351                                         if (_resetConnection)
 352                                         {
 353                                                 _resetConnection = false;
 354                                         }
 355                                 }
 356                                 else
 357                                 {
 358                                         try
 359                                         {
 360                                                 if(_clientSocket.Available > 0)
 361                                                 {
 362                                                         _isConnected = ProcessClient();
 363                                                 }
 364
 365                                                 // Pump the events immediately since they will be logged thread-safe later on.
 366                                                 PumpEvents();
 367                                         }
 368                                         catch(Exception ex)
 369                                         {
 370                                                 string message = string.Format("Disconnecting the remote console because it ran into the following exception: {0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace);
 371                                                 AddLogMessage(MessageType.Error, message);
 372                                                 break;
 373                                         }
 374
 375                                 }
 376                         }
 377                         _stopping = false;
 378                 }
 379
 380                 private bool ReadData(ref ConsoleEventType id, ref string data)
 381                 {
 382                         try
 383                         {
 384                                 NetworkStream stream = _clientSocket.GetStream();
 385                                 int ret = 0;
 386                                 while (true)
 387                                 {
 388                                         ret += stream.Read(_inStream, ret, Constants.DefaultBuffer - ret);
 389                                         if(ret == 0)
 390                                         {
 391                                                 return false;
 392                                         }
 393
 394                                         if (_inStream[ret - 1] == '\0')
 395                                         {
 396                                                 break;
 397                                         }
 398                                 }
 399                                 string returndata = System.Text.Encoding.ASCII.GetString(_inStream);
 400                                 id = (ConsoleEventType)(returndata[0] - '0');
 401                                 int index = returndata.IndexOf('\0');
 402                                 data = returndata.Substring(1, index - 1);
 403                         }
 404                         catch (Exception)
 405                         {
 406                                 return false;
 407                         }
 408                         return true;
 409                 }
 410
 411                 private bool SendData(ConsoleEventType id, string data = "")
 412                 {
 413                         char cid = (char)((char)id + '0');
 414                         string msg = "";
 415                         msg += cid;
 416                         msg += data;
 417                         msg += "\0";
 418                         try
 419                         {
 420                                 byte[] outStream = System.Text.Encoding.ASCII.GetBytes(msg);
 421                                 NetworkStream stream = _clientSocket.GetStream();
 422                                 stream.Write(outStream, 0, outStream.Length);
 423                                 stream.Flush();
 424                         }
 425                         catch (Exception)
 426                         {
 427                                 return false;
 428                         }
 429                         return true;
 430                 }
 431
 432                 private void AddLogMessage(MessageType type, string message)
 433                 {
 434                         lock (_locker)
 435                         {
 436                                 _messages.Enqueue(new LogMessage(type, message));
 437                         }
 438                 }
 439
 440                 private void AddAutoCompleteItem(string item)
 441                 {
 442                         lock (_locker)
 443                         {
 444                                 _autoComplete.Enqueue(item);
 445                         }
 446                 }
 447
 448                 private bool GetCommand(ref CommandEvent command)
 449                 {
 450                         bool res = false;
 451                         lock (_locker)
 452                         {
 453                                 if (_commands.Count > 0)
 454                                 {
 455                                         command = _commands.Dequeue();
 456                                         res = true;
 457                                 }
 458                         }
 459                         return res;
 460                 }
 461
 462                 private void AutoCompleteDone()
 463                 {
 464                         lock (_locker)
 465                         {
 466                                 _autoCompleteIsDone = true;
 467                         }
 468                 }
 469
 470                 private void ClearCommands()
 471                 {
 472                         lock (_locker)
 473                         {
 474                                 _commands.Clear();
 475                         }
 476                 }
 477
 478                 private bool ProcessClient()
 479                 {
 480                         ConsoleEventType eventType = ConsoleEventType.Noop;
 481                         string data = "";
 482                         if (!ReadData(ref eventType, ref data))
 483                                 return false;
 484
 485                         switch (eventType)
 486                         {
 487                                 case ConsoleEventType.LogMessage:
 488                                         AddLogMessage(MessageType.Message, data);
 489                                         return SendData(ConsoleEventType.Noop);
 490                                 case ConsoleEventType.LogWarning:
 491                                         AddLogMessage(MessageType.Warning, data);
 492                                         return SendData(ConsoleEventType.Noop);
 493                                 case ConsoleEventType.LogError:
 494                                         AddLogMessage(MessageType.Error, data);
 495                                         return SendData(ConsoleEventType.Noop);
 496                                 case ConsoleEventType.AutoCompleteList:
 497                                         AddAutoCompleteItem(data);
 498                                         return SendData(ConsoleEventType.Noop);
 499                                 case ConsoleEventType.AutoCompleteListDone:
 500                                         AutoCompleteDone();
 501                                         return SendData(ConsoleEventType.Noop);
 502                                 case ConsoleEventType.Req:
 503                                         CommandEvent command = null;
 504                                         if (GetCommand(ref command))
 505                                                 return SendData(command.Type, command.Command);
 506                                         else
 507                                                 return SendData(ConsoleEventType.Noop);
 508                                 default:
 509                                         return SendData(ConsoleEventType.Noop);
 510                         }
 511                 }
 512
 513                 public void Dispose()
 514                 {
 515                         Dispose(true);
 516                         GC.SuppressFinalize(this);
 517                 }
 518
 519                 public void Dispose(bool disposing)
 520                 {
 521                         if(disposing)
 522                         {
 523                                 _clientSocket.Dispose();
 524                                 _clientSocket = null;
 525                         }
 526                 }
 527         }
 528 }