/// <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();
}
