static async void Server()
{
if (!File.Exists("app.ini"))
{
Out.WriteLine("Error #1 loading app.ini", "Boot", ConsoleColor.Red);
Console.ReadKey();
Environment.Exit(0);
}
Setting = await ReadSettings(File.ReadAllText("app.ini"));
if (!Setting.ContainsKey("server") || !Setting.ContainsKey("mport") || !Setting.ContainsKey("username"))
{
Out.WriteLine("Error loading app.ini", "Boot", ConsoleColor.Red);
Console.ReadKey();
Environment.Exit(0);
}
Console.Beep();
AddRooms();
Out.WriteLine("");
Out.WriteLine("-----------------------------------------------------");
Out.WriteLine("Starting Private Server Chat Emulator by ~ Z3K");
Out.WriteLine("------------------------------------------------------");
Console.WriteLine();
CountUser();
AsynchronousSocketListener.StartListening();
}
public static int Main(String[] args)
{
Robot robot = new Robot();
Console.WriteLine("Please select functions:");
Console.WriteLine("[1] Run As Server");
Console.WriteLine("[2] Run As Client");
Console.WriteLine("[3] Run As Listenner");
var input = Console.ReadLine();
if (input == "1")
{
AsynchronousSocketListener.StartListening();
}
if (input == "2")
{
Console.Write("Please Input the Server Ip Address:");
var str = Console.ReadLine();
Console.Write("Please Input the Robot Ip Address:");
var str2 = Console.ReadLine();
robot.Init(str2);
AsynchronousClient.StartClient(str, false, robot);
}
if (input == "3")
{
Console.Write("Please Input the Server Ip Address:");
var str = Console.ReadLine();
Console.Write("Please Input the Robot Ip Address:");
var str2 = Console.ReadLine();
robot.Init(str2);
AsynchronousClient.StartClient(str, true, robot);
}
return(0);
}
public c_masterConn() //Costructor
{
socketListener = new AsynchronousSocketListener(); // Socketlistner async
t_listener = new Thread(socketListener.StartListening); // Thread for socketlistener
t_listener.Start(); // Start socketlistener
}
public MainWindow()
{
Console.WriteLine(DateTime.Now.ToString("MM-dd-yyyy-HH.mm.ss"));
try
{
InitializeComponent();
socetListener = new AsynchronousSocketListener();
socetListener.SocketEvent += SocetListener_SocketEvent;
socetListener.Start();
APIHandler = new CanonAPI();
APIHandler.CameraAdded += APIHandler_CameraAdded;
ErrorHandler.SevereErrorHappened += ErrorHandler_SevereErrorHappened;
ErrorHandler.NonSevereErrorHappened += ErrorHandler_NonSevereErrorHappened;
localPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "RemotePhoto");
SavePathTextBox.Text = localPath;
SetImageAction = (BitmapImage img) => { bgbrush.ImageSource = img; };
SaveFolderBrowser.Description = "Save Images To...";
RefreshCamera();
IsInit = true;
}
catch (DllNotFoundException) { ReportError("Canon DLLs not found!", true); }
catch (Exception ex) { ReportError(ex.Message, true); }
}
public Bot(Manager botManager, LoginInfo loginInfo, Config config, AsynchronousSocketListener socket)
{
this.socket = socket;
this.config = config;
this.loginInfo = loginInfo;
this.botManager = botManager;
steamClient = new SteamClient();
messageHandler = new HandleMessage();
steamWeb = new SteamTrade.SteamWeb();
manager = new CallbackManager(steamClient);
steamchatHandler = new HandleSteamChat(this);
MyGenericInventory = new GenericInventory(steamWeb);
steamCallbackManager = new CallbackManager(steamClient);
this.socket.MessageReceived += Socket_MessageReceived;
DB = new Database(config.DatabaseServer, config.DatabaseUser, config.DatabasePassword, config.DatabaseName, config.DatabasePort);
DB.InitialiseDatabase();
botThread = new BackgroundWorker {
WorkerSupportsCancellation = true
};
botThread.DoWork += BackgroundWorkerOnDoWork;
botThread.RunWorkerCompleted += BackgroundWorkerOnRunWorkerCompleted;
System.Timers.Timer refreshMarket = new System.Timers.Timer(421000);//15*1000*60);
refreshMarket.Elapsed += UpdateMarketItems;
refreshMarket.AutoReset = true;
refreshMarket.Enabled = true;
}
public static int Main(String[] args)
{
AsynchronousSocketListener Lanch = new AsynchronousSocketListener();
Lanch.StartListening();
return(0);
}
public MewQTTServer(string SettingsLocation)
{
ServerSettings = new Settings()
{
ip = "127.0.0.1",
port = 1883,
acounts = new List <Acount>()
{
new Acount()
{
userName = "******", password = "******"
}
},
useAuthentication = true
};
if (ServerSettings.useAuthentication)
{
AuthHandler.Acounts = ServerSettings.acounts;
}
Clients = new Dictionary <string, List <IMQTTMessage> >();
Listener = new AsynchronousSocketListener(ServerSettings.ip, ServerSettings.port, this);
instance = this;
}
private void StartSocketServer(int port)
{
Console.WriteLine("Starting TCP server on port {0}", port);
socketServer = new AsynchronousSocketListener(port, config.TCPPassword);
threadSocket = new Thread(new ThreadStart(socketServer.StartListening));
threadSocket.Start();
}
private void btn_startserver_Click(object sender, EventArgs e)
{
int nPort = sysConfig.tcp_port;
//Regex r = new Regex(@"\d[1-9]\d{1,4}");
//if (r.IsMatch(this.txtPort.Text))
//{
// try
// {
// nPort = int.Parse(r.Match(this.txtPort.Text).ToString());
// }
// catch (System.Exception ex)
// {
// MessageBox.Show(ex.Message);
// return;
// }
//}
listener = new AsynchronousSocketListener();
listener.eventProcessMsg += new deleAsynSocketProcessMsg(listener_eventProcessMsg);
listener.eventGetSendContent += new deleAsynSocketListenerGetContent(listener_eventGetSendContent);
listener.PortNum = nPort;
listener.StartListening();
this.bRemoteCheckClosed = false;
this.btn_startserver.Enabled = false;
this.labelStatus.Text = "远程考勤服务(" + this.GetLocalIP4() + ":" + nPort.ToString() + ")运行中...";
//rfidCheck_CheckOn.CheckOn("20112104");
}
private void BtnSync_Click(object sender, RoutedEventArgs e)
{
if (ServerChannel.Text.Length > 0 && ClientChannel.Text.Length > 0)
{
MessageBox.Show("Note: only one of The Client or server should be filled in ");
return;
}
if (int.TryParse(ServerChannel.Text, out int serverPort))
{
if (server != null)
{
server.EndSocket();
}
server = new AsynchronousSocketListener(serverPort, SyncedData);
server.StartSocket();
}
else if (int.TryParse(ClientChannel.Text, out int clientPort))
{
client = new AsynchronousClient(clientPort);
//of type object so I can use LINQ, Then aggregate combines the items into a string with a newline seperating them
var data = HistoryText.Items.OfType <object>().Aggregate("", (acc, x) => acc += x.ToString() + Environment.NewLine);
client.Start(data);
}
}
static void Main(string[] args)
{
log.Info("Phantom getting started...");
AsynchronousSocketListener.StartListening();
Console.ReadKey();
}
public static void Main()
{
Thread thread = new Thread(() => new MainServer());
thread.Start();
AsynchronousSocketListener.StartListening();
}
public CentralServerForm()
{
InitializeComponent();
socketListener = new AsynchronousSocketListener();
Messenger <Msg> .Default.AddHandler <string>(Msg.AppLog, UpdateUI);
this.FormClosed += CloseServer; // TO-DO: Update : kill asyncrenous socket listener thread
}
protected override void OnStop()
{
Logger.Log("Server Stopping");
AsynchronousSocketListener.Disconnect();
_serverThread.Join();
_serverThread = null;
Logger.Log("Server Stopped");
}
public static int Main(String[] args)
{
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 9761);
AsynchronousSocketListener.endpointSetup(localEndPoint);
listenerAsync = new Thread(new ThreadStart(AsynchronousSocketListener.StartListening));
listenerAsync.Start();
return(0);
}
private static void InitializeServers()
{
foreach (string directory in Directory.GetDirectories(ServerDirectories))
{
string serverName = new DirectoryInfo(directory).Name;
AsynchronousSocketListener socketListener = new AsynchronousSocketListener(serverName);
TcpServers.Add(socketListener);
}
}
public static void HeartBeat()
{
Task.Factory.StartNew(() => AsynchronousSocketListener.StartListening());
while (true)
{
Send("<HEARTBEAT> " + LocalIP);
Thread.Sleep(10000);
}
}
/// <summary>
/// Shutdown all processes.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Form1_Closing(object sender, CancelEventArgs e)
{
// Close HRM device connection
childThread.Abort();
// Stop listening
AsynchronousSocketListener.Shutdown();
// Clean up ANT
ANTInterface.Shutdown();
}
public ClientWorkObject(Socket ClientSocket, AsynchronousSocketListener ServerObject)
{
clientSocket = ClientSocket;
serverSocket = ServerObject;
clientSender = new ClientSender(this);
clientTracker = new ClientTracker(serverSocket.ServerName);
clientTimeoutTimer = new ClientTimeout(this);
}
// Use this for initialization
void Start()
{
var tmp = Loom.Current;
Loom.RunAsync(() =>
{
AsynchronousSocketListener.StartListening();
});
}
public static int Main(String[] args)
{
AsynchronousSocketListener.StartListening();
//HttpServer.SimpleListenerExample(new string[]{"http://localhost/"});
//sqlite.create_db(@"D:/cache/keylogger.sqlite");
//sqlite.create_table();
//sqlite.insert_into("SOURCE1", "CONTENT1");
return(0);
}
//FileSystemWatcher _watcher;
public bool Start()
{
//_watcher = new FileSystemWatcher(@"c:\temp\a", "*_in.txt");
//_watcher.Created += FileCreated;
//_watcher.IncludeSubdirectories = false;
//_watcher.EnableRaisingEvents = true;
AsynchronousSocketListener.StartListening();
return(true);
}
public void StartListening()
{
RT.load("unityRepl");
listener = new AsynchronousSocketListener();
listener.OnGetData += GetData;
listener.OnConnect += (s) => Debug.Log("OnConnect");
thread = new Thread(() => listener.StartListening());
thread.Start();
}
private void button1_Click(object sender, EventArgs e)
{
button1.Enabled = false;
PortNumber = Int32.Parse(PortBox.Text);
ipAd = IPAddress.Parse(textBox1.Text);
Task.Factory.StartNew(() => AsynchronousSocketListener.StartListening());
Task.Factory.StartNew(() => start());
Task.Factory.StartNew(() => reset());
Task.Factory.StartNew(() => UDPHeartBeat.start());
}
public Form()
{
InitializeComponent();
listener = new AsynchronousSocketListener(IPAddress.Parse(settings.IPSource), settings.PortSource);
sender = new SynchronousSenderClient(IPAddress.Parse(settings.IPDestination), settings.PortDestination);
this.Load += (s, e) => StartListener();
lblMax.Text = $"{trbTemp.Maximum} °C";
lblMin.Text = $"{trbTemp.Minimum} °C";
trbTemp.Enabled = false;
}
static void Main(string[] args)
{
//TCPServer server =
// new TCPServer();
//server.Start();
//Console.ReadKey();
AsynchronousSocketListener.StartListening();
}
public static int Main(String[] args)
{
AsynchronousSocketListener listener = new AsynchronousSocketListener();
listener.StartListening();
//CalculationManager cm = new CalculationManager();
//Console.Write(cm.testCalculate());
return 0;
}
public void tryCommunicateReceiver(String x)
{
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
ReceiverIP = ipHostInfo.AddressList[0].ToString();
while (ReceiverIP == "")
{
System.Threading.Thread.Sleep(1000);
}
AsynchronousSocketListener.StartListening();
}
public static void Main()
{
AsynchronousSocketListener.StartListening();
AsynchronousClient.StartClient();
while (true)
{
string input = Console.ReadLine();
CommandProvider.RunCommand(input.Split(' ')[0], input);
}
}
static void Main(string[] args)
{
var asyncSocketListener = new AsynchronousSocketListener();
var listenerThread = new Thread(asyncSocketListener.StartListening);
listenerThread.Start();
Console.WriteLine("Server Started");
listenerThread.Join();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
private void OnEnable()
{
if (!Enabled.Value)
{
return;
}
socketListener = new AsynchronousSocketListener();
socketListener.OnMessage += SocketListener_OnMessage;
Logger.LogInfo("RCON Listening on port: " + Port.Value);
socketListener.StartListening(Port.Value);
}
public static void StartListening() {
StopListening();
RT.load("unityRepl");
listener = new AsynchronousSocketListener();
listener.OnGetData += GetData;
listener.OnConnect += (s) => Debug.Log("OnConnect");
thread = new Thread(() => listener.StartListening());
thread.Start();
running = true;
}
void LoadWifiListener()
{
listener = new AsynchronousSocketListener(screenWriterDelegate, videoFormActionDelegate);
ioThread = new Thread(new ThreadStart(listener.StartListening));
ioThread.SetApartmentState(ApartmentState.STA);
ioThread.Start();
WriteToScreen("Socket server listening");
}
public TCPServer(int port)
{
_socket = new AsynchronousSocketListener(port);
_socket.StartListening();
}
public MainWindow()
{
InitializeComponent();
//ScoreSocketServer server = new ScoreSocketServer();
//server.StartSocketServer();
asl = new AsynchronousSocketListener();
asl.StartListening();
this.Closed +=new EventHandler(MainWindow_Closed);
//call cearabean quest
launch();
}
