Esempio n. 1
0
 public void LoadServices(ISocketManager socketManager)
 {
     foreach (var service in _services)
     {
         service.Start(socketManager);
     }
 }
Esempio n. 2
0
 public RealTimeCommMiddleWare(RequestDelegate next, ISocketManager socketManager, ISocketServiceLoader loader, IEnumerable <int> ports)
 {
     _socketManager = socketManager;
     _ports         = ports;
     loader.LoadServices(_socketManager);
     _next = next ?? throw new ArgumentNullException(nameof(next));
 }
        private IServiceCollection GetServices(ISocketManager <ISocketClient <Message, Message>, Message> manager,
                                               ISocketClient <Message, Message> gmClient)
        {
            IServiceCollection services = new ServiceCollection();
            var conf = new ServerConfiguration()
            {
                GMPort = 44360, ListenerIP = "127.0.0.1", PlayerPort = 44370
            };

            services.AddSingleton(conf);
            services.AddSingleton(MockGenerator.Get <Serilog.ILogger>());

            services.AddSingleton(manager);

            ServiceShareContainer shareContainer = new ServiceShareContainer
            {
                GameStarted     = false,
                ConfirmedAgents = new Dictionary <int, bool>(),
                GMClient        = gmClient
            };

            services.AddSingleton(shareContainer);

            services.AddSingleton(Mock.Of <IApplicationLifetime>());
            services.AddSingleton(new ServiceSynchronization(2, 2));

            services.AddHostedService <CommunicationService>();

            return(services);
        }
Esempio n. 4
0
 /// <summary>
 /// 初始化默认管理器
 /// </summary>
 public void InitDefaultManagers()
 {
     _timerManager = new TimerManager();
     AddManager(_timerManager);
     _stageManager = new StageManager();
     AddManager(_stageManager);
     _pathManager = new PathManager();
     AddManager(_pathManager);
     _logManager = new LogManager();
     AddManager(_logManager);
     _langManager = new LangManager();
     AddManager(_langManager);
     _socketManager = new SocketManager();
     AddManager(_socketManager);
     _tableManager = new TableManager();
     AddManager(_tableManager);
     _objectPoolManager = new ObjectPoolManager();
     AddManager(_objectPoolManager);
     _fileManager = new FileManager();
     AddManager(_fileManager);
     _resourceManager = new ResourceManager();
     AddManager(_resourceManager);
     _assetManager = new AssetManager();
     AddManager(_assetManager);
     _audioManager = new AudioManager();
     AddManager(_audioManager);
     _sceneManager = new ScenesManager();
     AddManager(_sceneManager);
     _touchManager = new TouchManager();
     AddManager(_touchManager);
     _platformManager = new PlatformManager();
     AddManager(_platformManager);
 }
Esempio n. 5
0
        public GameStateManager(ISocketManager socketManager, IConnectionManager connectionManager)
        {
            _socketManager     = socketManager;
            _connectionManager = connectionManager;

            _lastWorldState = new WorldState();
        }
Esempio n. 6
0
 protected SocketServer(ISocketManager socketManager, FrameParser <TMeta> frameParser,
                        Action <Exception> onError = default)
 {
     _cts           = new CancellationTokenSource();
     _onError       = onError;
     _socketManager = socketManager;
     _frameParser   = frameParser ?? throw new ArgumentNullException(nameof(frameParser));
 }
 public CommunicationService(ISocketManager <ISocketClient <Message, Message>, Message> manager,
                             ServiceShareContainer container, BufferBlock <Message> queue, ILogger log, ServiceSynchronization sync)
 {
     this.manager   = manager;
     this.queue     = queue;
     this.container = container;
     this.logger    = log.ForContext <CommunicationService>();
     this.sync      = sync;
 }
 public GameProcessManager(
     IClientManager clientManager,
     IConnectionManager connectionManager,
     IGameStateManager gameStateManager,
     ISocketManager socketManager)
 {
     _clientManager     = clientManager;
     _connectionManager = connectionManager;
     _gameStateManager  = gameStateManager;
     _socketManager     = socketManager;
 }
 public PlayersTcpSocketService(ISocketManager <ISocketClient <Message, Message>, Message> manager,
                                BufferBlock <Message> queue, ServiceShareContainer container, ServerConfiguration conf, ILogger log,
                                ServiceSynchronization sync)
     : base(log.ForContext <PlayersTcpSocketService>())
 {
     this.manager   = manager;
     this.queue     = queue;
     this.container = container;
     this.conf      = conf;
     this.log       = log;
     this.sync      = sync;
 }
Esempio n. 10
0
 public void Start(ISocketManager manager)
 {
     if (_isStarted)
     {
         return;
     }
     Manager            = manager;
     Manager.OnInit    += Manager_OnInit;
     Manager.OnMessage += Manager_OnMessage;
     Manager.OnSend    += Manager_OnSend;
     Manager.OnClose   += Manager_OnClose;
     _isStarted         = true;
 }
        public ConnectionWindowViewModel(
            IDataManager dataManager,
            ISocketManager socketManager,
            IGameDataRepository gameDataRepository)
        {
            _dataManager        = dataManager;
            _socketManager      = socketManager;
            _gameDataRepository = gameDataRepository;
            _settings           = dataManager.Settings;

            ConnectCommand    = new RelayCommand(StartConnection);
            DisconnectCommand = new RelayCommand(StopConnection);

            ClearCommand = new RelayCommand(ClearConnectionLog);
            CloseCommand = new RelayCommand(() => CloseRequested?.Invoke(this, new DialogCloseRequestedEventArgs()));
        }
Esempio n. 12
0
        public void InitSocketManager(ISocketManager socketManager)
        {
            Socket           = socketManager.Create("http://192.168.1.3:3000/");
            Socket.OnConnect = () =>
            {
                Socket.Emit("shoes2", new { F**k = "Yopu" });
            };
            Socket.On <Boo>("shoes", a =>
            {
            });
            Socket.On <Boo>("shoes3", a =>
            {
            });

            Socket.Connect();
        }
        /// <summary>
        /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping)
        ///
        /// To use this you should pass a class that inherits ISocketManager. You can use
        /// SocketManager to get connections and send messages, but the ISocketManager class
        /// will received all the appropriate callbacks.
        ///
        /// </summary>
        public static SocketManager CreateRelaySocket(int virtualport, ISocketManager intrface)
        {
            var options = Array.Empty <NetKeyValue>();
            var socket  = Internal.CreateListenSocketP2P(virtualport, options.Length, options);

            var t = new SocketManager
            {
                Socket    = socket,
                Interface = intrface
            };

            t.Initialize();

            SetSocketManager(t.Socket.Id, t);
            return(t);
        }
Esempio n. 14
0
        /// <summary>
        /// Creates a "server" socket that listens for clients to connect to by calling
        /// Connect, over ordinary UDP (IPv4 or IPv6).
        ///
        /// To use this you should pass a class that inherits ISocketManager. You can use
        /// SocketManager to get connections and send messages, but the ISocketManager class
        /// will received all the appropriate callbacks.
        ///
        /// </summary>
        public static SocketManager CreateNormalSocket(NetAddress address, ISocketManager intrface)
        {
            var options = Array.Empty <NetKeyValue>();
            var socket  = Internal.CreateListenSocketIP(ref address, options.Length, options);

            var t = new SocketManager
            {
                Socket    = socket,
                Interface = intrface
            };

            t.Initialize();

            SetSocketManager(t.Socket.Id, t);
            return(t);
        }
Esempio n. 15
0
        public Server(Container container, ServerConfig config)
        {
            Log.Info($"Starting the server on {config.Port} port with rate {config.Rate}");

            _queue = new ConcurrentQueue <Packet>();

            _socketManager      = container.GetInstance <ISocketManager>();
            _clientManager      = container.GetInstance <IClientManager>();
            _gameStateManager   = container.GetInstance <IGameStateManager>();
            _gameProcessManager = container.GetInstance <IGameProcessManager>();

            _config = config;

            Log.Info($"Configuring...");

            _socketManager.Configure(config);

            Log.Info($"Done");
        }
        /// <summary>
        /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping)
        ///
        /// To use this you should pass a class that inherits ISocketManager. You can use
        /// SocketManager to get connections and send messages, but the ISocketManager class
        /// will received all the appropriate callbacks.
        ///
        /// </summary>
        public static SocketManager CreateRelaySocket(int virtualport, ISocketManager intrface)
        {
            var options = new NetKeyValue[]
            {
                new NetKeyValue()
                {
                    Value      = NetConfig.IP_AllowWithoutAuth,
                    DataType   = NetConfigType.Int32,
                    Int32Value = SteamNetworkingUtils.AllowWithoutAuth
                }
            };
            var socket = Internal.CreateListenSocketP2P(virtualport, options.Length, options);

            var t = new SocketManager
            {
                Socket    = socket,
                Interface = intrface
            };

            t.Initialize();

            SetSocketManager(t.Socket.Id, t);
            return(t);
        }
Esempio n. 17
0
 public SocketController(ISocketManager socketManager)
 {
     _socketManager = socketManager;
 }
Esempio n. 18
0
 public DrawingShareHandler(ISocketManager webSocketConnectionManager) : base(webSocketConnectionManager)
 {
 }
Esempio n. 19
0
 public ConnectionManager(ISocketManager socketManager)
 {
     _socketManager           = socketManager;
     _connections             = new ConcurrentDictionary <int, ClientConnection>();
     _clientIdentifierCounter = 0;
 }
Esempio n. 20
0
 public EventManager(ISocketManager socketManager)
 {
     _socketManager = socketManager;
 }
Esempio n. 21
0
 public void InitSocketManager(ISocketManager socketManager)
 {
 }
Esempio n. 22
0
 public ClientManager(ISocketManager socketManager, IConnectionManager connectionManager)
 {
     _socketManager     = socketManager;
     _connectionManager = connectionManager;
 }
Esempio n. 23
0
        /// <summary>
        /// Configure Megalodon
        /// </summary>
        /// <param name="log"></param>
        /// <param name="configStore"></param>
        /// <param name="socketManager"></param>
        public MegalodonService(ILoggerFactory log, IConfigurationStore configStore, ISocketManager socketManager)
        {
            _log = log.CreateLogger <MegalodonService>();

            _log.LogInformation($"Configuration Setup {TagConstants.APP_NAME}.");

            _config        = configStore;
            _socketManager = socketManager;
            // Check we have important settings
            var _TCIP = configStore.GetValueString("TCIP");

            if (string.IsNullOrEmpty(_TCIP))
            {
                throw new ArgumentException($"Missing variable TCIP in appsettings.json");
            }
            var _Port = configStore.GetValueString("Port");

            if (string.IsNullOrEmpty(_Port))
            {
                throw new ArgumentException($"Missing variable Port in appsettings.json");
            }

            var _Folder = configStore.GetValueString("InstallFolder");

            if (string.IsNullOrEmpty(_Folder))
            {
                throw new ArgumentException($"Missing variable InstallFolder in appsettings.json");
            }
            else
            {
                // Make sure folder exists early for monitor
                // tagfile path
                var tmpPath = Path.Combine(_Folder, TagConstants.TAGFILE_FOLDER);
                Directory.CreateDirectory(tmpPath);
                tagFile.TagFileFolder = tmpPath;
                tmpPath = Path.Combine(tmpPath, TagConstants.TAGFILE_FOLDER_TOSEND);
                Directory.CreateDirectory(tmpPath);
                // logging path
                _logPath = Path.Combine(_Folder, TagConstants.LOG_FOLDER);
                Directory.CreateDirectory(_logPath);
            }

            var _seedLat = configStore.GetValueString("SeedLat");

            if (!string.IsNullOrEmpty(_seedLat))
            {
                tagFile.Parser.SeedLat = TagUtils.ToRadians(Convert.ToDouble(_seedLat));
            }

            var _seedLon = configStore.GetValueString("SeedLon");

            if (!string.IsNullOrEmpty(_seedLon))
            {
                tagFile.Parser.SeedLon = TagUtils.ToRadians(Convert.ToDouble(_seedLon));
            }

            var _SerialOverride = configStore.GetValueString("SerialOverride");

            if (!string.IsNullOrEmpty(_SerialOverride))
            {
                tagFile.MachineSerial      = _SerialOverride;
                tagFile.Parser.ForceSerial = _SerialOverride;
            }

            tagFile.MachineID = configStore.GetValueString("MachineName");

            tagFile.SendTagFilesDirect = configStore.GetValueBool("SendTagFilesDirect") ?? false;
            _log.LogInformation($"SendTagFilesDirect: {tagFile.SendTagFilesDirect}");

            tagFile.TransmissionProtocolVersion        = Convert.ToByte(configStore.GetValueString("TransmissionProtocolVersion", TagConstants.CURRENT_TRANSMISSION_PROTOCOL_VERSION.ToString()));
            tagFile.Parser.TransmissionProtocolVersion = tagFile.TransmissionProtocolVersion;

            var fBOG = configStore.GetValueBool("ForceBOG") ?? false;

            tagFile.Parser.ForceBOG = fBOG;

            tagFile.Log        = _log;
            tagFile.Parser.Log = _log;

            _log.LogInformation($"Socket Settings: {_TCIP}:{_Port}");

            var _TagFileIntervalSecs = configStore.GetValueString("TagFileIntervalSecs");

            if (!string.IsNullOrEmpty(_TagFileIntervalSecs))
            {
                tagFile.TagFileIntervalMilliSecs = Convert.ToInt32(_TagFileIntervalSecs) * 1000;
            }

            _DebugTraceToLog = configStore.GetValueBool("DebugTraceToLog") ?? false;
            tagFile.Parser.DebugTraceToLog = _DebugTraceToLog;

            _appVersion = configStore.GetValueString("ApplicationVersion") ?? string.Empty;
            tagFile.ApplicationVersion = _appVersion;
            _log.LogInformation($"#Result# Application Version: {_appVersion}");

            var prodHost = configStore.GetValueString("production-host") ?? string.Empty;
            var prodBase = configStore.GetValueString("production-base") ?? string.Empty;

            _log.LogInformation($"RemoteHost: {prodHost}, Base:{prodBase}");
        }
Esempio n. 24
0
 public AbstractSocketHandler(ISocketManager socketManager)
 {
     _socketManager = socketManager;
 }
Esempio n. 25
0
 public void Dispose()
 {
     _cts.Cancel();
     _socketManager?.Dispose();
     _socketManager = null;
 }
Esempio n. 26
0
 public WebSocketHandler(ISocketManager webSocketConnectionManager)
 {
     WebSocketManager = webSocketConnectionManager;
 }
 public SocketRepository(ISocketManager socketManager)
 {
     _socketManager = socketManager;
 }
Esempio n. 28
0
 public SocketManagerTests()
 {
     _listener      = new MockSocketProxy();
     _socketCluster = new SocketCluster(1000);
     _socketManager = new SocketManager(_listener, _socketCluster);
 }