/// <summary> /// 发送给WIFI /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void MapIPFromWifi(object sender, DataTransmissionEventArgs args) { if (args.Token.ConnectSocket != null) { AsyncSocketUserToken socket = args.Token; long ip = ControllerManager.GetLongIPFromSocket(socket); Controller controller = ControllerManager.Instance().Get(ip); if (controller != null) { if (controller.SocketToken != null) { AsyncServer.Instance().CloseClientSocketEx(controller.SocketToken); } controller.SocketToken = socket; if (SocketConnectOrCloseResponse != null) { SocketConnectOrCloseResponse(this, new SocketConnectArgs(true, socket)); } //新连接的客户端要对它发送泵类型指令 if (SendPumpType2Wifi != null) { SendPumpType2Wifi(this, new SocketConnectArgs(true, socket)); } } else { if (m_Device != null) { m_Device.CloseClientSocket(args.Token); } Logger.Instance().ErrorFormat("MapIPFromWifi()->ControllerManager.Instance().Get 错误,IP={0}", ip); return; } } }
public Users() { _users = new List <User>(); _server.ConnectionAccept += _server_ConnectionAccept; _server = new AsyncServer(5999); _server.Start(); }
/* * Packet flow * * 0001. S => C : unk * 0002. C => S : RSA Encrypted chunk (Salsa20 Key encrypted with RSA) * 0003. C => S : Password (1st packet) * 0004. C => S : Ping Packet (encrypted Salsa20) * */ static void Main(string[] args) { PacketProcessor.TRSAInit(); AsyncServer server = new AsyncServer(IPAddress.Parse("0.0.0.0"), 7979); server.Start(); server.ConnectionAccepted += new AsyncServer.ConnectionAcceptedHandler(connection => { Console.WriteLine("New connection: " + connection.GetHashCode()); // Create AsyncState object connection.AsyncState = new AsyncConnectionData(); // Send Packet 0001 connection.DataReceived += new AsyncConnection.ConnectionDataReceivedHandler(data => { PacketProcessor.ProcessPacket(data, connection); }); connection.SendClear(new byte[] { 0x03, 0x16, 0x00, 0x00, 0x00, 0x15, 0x11, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x36, 0x40, 0xce, 0x72, 0x71, 0xfe, 0x8d, 0x7e }); // State is 1 connection.SetState(1); connection.EngageReading(); }); Console.WriteLine("Server running, press Enter to exit ..."); Console.ReadLine(); }
static void Main(string[] args) { AsyncServer server = new AsyncServer("127.0.0.1", 1024); server.StartServer(); Console.Read(); }
void _updateLengthTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { double videoLength = this.mediaPlayer.currentMedia.duration; AsyncServer.GetInstance().SendToAll(string.Format("video:totalTime&{0}|", videoLength.ToString())); this._updateLengthTimer.Stop(); }
/// <summary> /// После выполнения этого метода сервер не пересоздается /// </summary> public static void DisposeAsyncServer() { _isManualDispose = true; _pipesAsyncServer.Dispose(); _pipesAsyncServer = null; _isManualDispose = false; }
static void Main(string[] args) { Command hello = new Command("hello", (state, parts) => { return($"hello variant {parts[1]}"); }); Command bye = new Command("bye", (state, parts) => { return($"bye variant {parts[1]}"); }); AsyncServer server = new AsyncServer(new Command[] { hello, bye }); server.Start(); //Thread thread = new Thread(() => //{ // Client client = new Client(); // client.Start(); // int i = 0; // while (true) // { // Console.WriteLine(client.SendMessage($"hello {i}")); // ++i; // Thread.Sleep(1000); // } //}); //thread.Start(); }
async Task ShutdownServerAsync(AsyncServer server, Task <Result> runServerTask) { try { var runClientResult = Result.Fail("Timeout"); await server.ShutdownAsync().ConfigureAwait(false); if (runServerTask == await Task.WhenAny(runServerTask, Task.Delay(1000)).ConfigureAwait(false)) { runClientResult = await runServerTask; } if (runClientResult.Failure) { //_cts.Cancel(); } } catch (AggregateException ex) { Console.WriteLine("\nException messages:"); foreach (var ie in ex.InnerExceptions) { Console.WriteLine($"\t{ie.GetType().Name}: {ie.Message}"); } } catch (TaskCanceledException) { Console.WriteLine("Accept connection task canceled"); } }
public void AsyncServerConstructorTest() { AsyncServer server = new AsyncServer(); SetOfAnswers1 soa = new SetOfAnswers1(); StringAssert.ReferenceEquals(soa.GetType().ToString(), server.SetOfAnswers.GetType().ToString()); }
private void btnServerStop_Click(object sender, EventArgs e) { AsyncServer.StopServer(); ServerSL = null; btnServerStop.Enabled = false; btnServerStart.Enabled = true; }
/***********************************************************************************************************/ /***********************************************************************************************************/ /***********************************************************************************************************/ //Custom functions #region Custom functions private void sendAll(string m) { foreach (Socket sock in AsyncServer.MySocketList) { AsyncServer.Send(sock, m); } }
public ActionResult Index() { AsyncServer tcp = new AsyncServer(); AsyncServer.DataReceived += new EventHandler <MyEventArgs>(DataReceivedEventHandler); return(View()); }
/// <summary> /// 关闭协议解析及发送引擎 /// </summary> public void Stop() { if (m_Keeping) { m_Keeping = false; m_Queue.ClearQueue(); //close semaphore m_SemCommand.Close(); m_SemReceiveCommand.Close(); m_SemCommand.Dispose(); m_SemReceiveCommand.Dispose(); m_SemCommand = null; m_SemReceiveCommand = null; //阻塞主线程,等待自然死亡 m_SendCommandProcThread.Join(); m_WaitCommandProcThread.Join(); m_AnalysizeProcThread.Abort(); //m_AnalysizeProcThread.Join(); m_SendCommandProcThread = null; m_WaitCommandProcThread = null; //m_AnalysizeProcThread = null; if (m_Device != null) { m_Device.Exit(); m_Device = null; } } }
public static void Delegate() { AsyncServer server = new AsyncServer(); // TcpServer server = new TcpServer(); server.start(); // Waits until a connection is established string input = ""; CommItem comm = new CommItem(); List <Task> taskList = new List <Task>(); while (server.isConnected() && comm.taskType != 1) { input = server.readMessage(); if (input != "") { Console.WriteLine("Got: " + input); } comm = Conversation.Interpret(input); if (comm.taskType != 0) { server.writeMessage("Alexis: " + comm.commString); } } server.close(); }
public async Task VerifyRequestFileListAndFolderDoesNotExist() { var clientLogFilePath = $"{Logging.GetTimeStampForFileName()}_VerifyRequestFileListAndFolderDoesNotExist_client.log"; var serverLogFilePath = $"{Logging.GetTimeStampForFileName()}_VerifyRequestFileListAndFolderDoesNotExist_server.log"; _clientSettings.LocalServerPortNumber = 8021; _serverSettings.LocalServerPortNumber = 8022; var token = _cts.Token; _serverSettings.LocalServerFolderPath = _tempFolder; var server = new AsyncServer(_serverSettings); server.EventOccurred += HandleServerEvent; server.SocketEventOccurred += HandleServerEvent; var client = new AsyncServer(_clientSettings); client.EventOccurred += HandleClientEvent; client.SocketEventOccurred += HandleClientEvent; await server.InitializeAsync("server").ConfigureAwait(false); await client.InitializeAsync("client").ConfigureAwait(false); var runServerTask = Task.Run(() => server.RunAsync(token), token); var runClientTask = Task.Run(() => client.RunAsync(token), token); while (!server.IsRunning) { } while (!client.IsRunning) { } Assert.IsFalse(Directory.Exists(_tempFolder)); var fileListRequest1 = await client.RequestFileListAsync(server.MyInfo).ConfigureAwait(false); if (fileListRequest1.Failure) { Assert.Fail("Error sending request for transfer folder path."); } while (!_clientWasNotifiedFolderDoesNotExist) { } await ShutdownServerAsync(client, runClientTask); await ShutdownServerAsync(server, runServerTask); if (_generateLogFiles) { File.AppendAllLines(clientLogFilePath, _clientLogMessages); File.AppendAllLines(serverLogFilePath, _serverLogMessages); } }
/// <summary> /// Initializes the various modules required by the server. /// Called after LoadSettings and before Update. /// </summary> public virtual void Init() { Running = true; //CommandInput = new CommandExecuter(); SocketPolicyServer.LoadPort(AppSettings.UdpPort, AppSettings.UdpPort); Server = new AsyncServer(AppSettings.TcpPort, AppSettings.UdpPort); Server.AddCommands(this); }
public void Reset() { this.mediaPlayer.Ctlcontrols.currentPosition = 0; double videoLength = this.mediaPlayer.currentMedia.duration; AsyncServer.GetInstance().SendToAll(string.Format("video:totalTime&{0}|", videoLength.ToString())); PlayVideo(); }
private void btnStop_Click(object sender, EventArgs e) { SetButtonEnabled(btnStop, false); _Server.Shutdown(); _Server.Dispose(); _Server = null; SetButtonEnabled(btnStart, true); }
private void Start() { AsyncServer server = gameObject.AddComponent <AsyncServer>() as AsyncServer; AsyncServer.port = port; AsyncServer.ipAddress = ipAddress; AsyncServer.StartServer(server); }
//launch an async server , this program needs to be manually closed static void Main(string[] args) { AsyncServer server = new AsyncServer(); server.Start(); while (true) { } }
public void CleanSocketListTest() { AsyncServer server = new AsyncServer(); Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); server.ListSocket.Add(s); Assert.AreEqual(1, server.ListSocket.Count); Assert.AreEqual(0, server.CleanSocketList(server.ListSocket).Count); }
private void btnServerStart_Click(object sender, EventArgs e) { serverPORT = txtServerPort.Text; ServerSL = new Thread(() => AsyncServer.StartListening(Int32.Parse(serverPORT))); AsyncServer.SetLogBox(txtServerLog); ServerSL.Start(); btnServerStop.Enabled = true; btnServerStart.Enabled = false; }
public void Listen(long port = 0) { try { _listenSocket = new AsyncServer(Convert.ToInt32(port)); _listenSocket.Start(); } catch (Exception ex) { throw ex; } }
private static void Main() { Game game = new Game(); string ipAddress = "192.168.1.132"; //Get from user-input or config AsyncServer server = new AsyncServer(ipAddress, game); server.StartListening(); }
public void GetAnswerTest() { AsyncServer server = new AsyncServer(); CollectionAssert.AreEqual(Encoding.ASCII.GetBytes("HI" + Environment.NewLine), server.GetAnswer("HELO", true)); CollectionAssert.AreEqual(new byte[1024], server.GetAnswer("TERMINATE", false)); CollectionAssert.AreEqual(Encoding.ASCII.GetBytes("0" + Environment.NewLine), server.GetAnswer("CONNECTIONS", true)); CollectionAssert.AreEqual(Encoding.ASCII.GetBytes("0" + Environment.NewLine), server.GetAnswer("COUNT", true)); CollectionAssert.AreEqual(Encoding.ASCII.GetBytes("BYE" + Environment.NewLine), server.GetAnswer("TERMINATE", true)); }
public void Template() { using (var server = new AsyncServer(new Handler())) { server.Bind("inproc://test"); var client = new ClientSafe("inproc://test"); client.Init(); client.Task.Wait(); Assert.Throws <ArgumentNullException>(() => client.Dispose()); } }
//start game public void startGame() { System.Threading.Thread.Sleep(10000); waiting_for_players = false; for (int i = 0; i < num_of_players; i++) { players[i].Ques = game_questions[current_ques_num]; } current_ques_num++; AsyncServer.Set("id"); }
static void Main(string[] args) { PluginStore.Init(); Console.WriteLine("Starting Listener"); AsyncServer.StartListening(); while (AsyncServer.IsListening) { Thread.Sleep(1000); } }
private static void Main(string[] args) { Helper.SetupConsole(120, Console.BufferHeight); var configFile = new FileInfo(Path.Combine(Environment.CurrentDirectory, "Config", ModuleName + ".xml")); using (var stream = configFile.OpenRead()) { var serializer = new XmlSerializer(typeof(CertificationConfig)); var config = serializer.Deserialize(stream) as CertificationConfig; if (config == null) { Logger.Error("Failed to deserialize config"); Console.ReadLine(); } certificationManager = new CertificationManager(config); billingManager = new BillingManager(config.Billing); } certificationManager.Load(ModuleName); billingManager.Load(); var network = new AsyncServer(); network.Accept(certificationManager.CertificationMachine.PrivateIP, certificationManager.CertificationBody.BindPort, 5, new ServerInterface(), certificationManager); Logger.Info($"Certification server started on {certificationManager.CertificationMachine.PrivateIP}:{certificationManager.CertificationBody.BindPort}"); Logger.Info("Press ESC to exit..."); while (true) { if (Console.KeyAvailable) { var keyInfo = Console.ReadKey(true); if (keyInfo.Key == ConsoleKey.Escape) { break; } } network.Tick(); Thread.Sleep(1); } certificationManager.CertificationBody.State = ServerBodyState.Exit; }
public static void Init(ServerInitializer initializer) { if (Interlocked.CompareExchange(ref _chat, new ServerChat(), null) != null) { throw new InvalidOperationException("model already inited"); } Api = new ServerApi(initializer.AdminPassword); Server = new AsyncServer(Api, _notifier, Logger); Plugins = new ServerPluginManager(initializer.PluginsPath); Plugins.LoadPlugins(initializer.ExcludedPlugins); }
public static void Init(ServerInitializer initializer) { if (Interlocked.CompareExchange(ref model, new ServerModel(), null) != null) { throw new InvalidOperationException("model already inited"); } Server = new AsyncServer(); API = initializer.API ?? new StandardServerAPI(); Plugins = new ServerPluginManager(initializer.PluginsPath); Plugins.LoadPlugins(initializer.ExcludedPlugins); }
public void RequestResponse() { int i = 0; var serverHandler = new Handler(); using (AsyncServer server = new AsyncServer(serverHandler)) { server.Bind("tcp://*:6666"); using (Client client = new Client("tcp://localhost:6666")) { // client to server var reply = (string) client.SendRequestAsync("Hello", "World").Result; Assert.That(reply == "Welcome"); } } }
public static void Main() { var endEntry = Dns.GetHostEntry("localhost"); IPEndPoint ipe = new IPEndPoint(IPAddress.Any, 998); SyncServer syncServer = new SyncServer(ipe); //syncServer.Start(); AsyncServer asyncServer = new AsyncServer(ipe); asyncServer.Start(); Console.ReadLine(); return; TcpListener server=null; try { // Set the TcpListener on port 13000. Int32 port = 8081; IPAddress localAddr = IPAddress.Parse("127.0.0.1"); // TcpListener server = new TcpListener(port); server = new TcpListener(localAddr, port); // Start listening for client requests. server.Start(); // Buffer for reading data Byte[] bytes = new Byte[256]; String data = null; // Enter the listening loop. while(true) { Console.Write("Waiting for a connection... "); // Perform a blocking call to accept requests. // You could also user server.AcceptSocket() here. TcpClient client = server.AcceptTcpClient(); Console.WriteLine("Connected!"); data = null; // Get a stream object for reading and writing NetworkStream stream = client.GetStream(); int i; // Loop to receive all the data sent by the client. while((i = stream.Read(bytes, 0, bytes.Length))!=0) { // Translate data bytes to a ASCII string. data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); Console.WriteLine("Received: {0}", data); // Process the data sent by the client. data = data.ToUpper(); byte[] msg = System.Text.Encoding.ASCII.GetBytes(data); // Send back a response. stream.Write(msg, 0, msg.Length); Console.WriteLine("Sent: {0}", data); } // Shutdown and end connection client.Close(); } } catch(SocketException e) { Console.WriteLine("SocketException: {0}", e); } finally { // Stop listening for new clients. server.Stop(); } Console.WriteLine("\nHit enter to continue..."); Console.Read(); }