private void SendCallback(IAsyncResult result) { IClientInformation toUserInformation = result as IClientInformation; ISocketClientConnection toUser = _SessionMembers.Find(x => x.clientInformation.UniqueID == toUserInformation.UniqueID); toUser.userSocket.EndSend(result); }
public void Attack() { Task.Run(() => { Thread.Sleep(300); using (ISocketClientConnection connection = SocketConnectionFactory.GetConnection()) { for (int i = 0; i < TotalFired; i++) { try { connection.SendRequest("CustomerController", "AddCustomer", new { customer = $"Customer n {i + 1} of attacker #{AttackerId}" }); if (connection.GetResult().Status == 600) { RequestsSuccess += 1; } else { RequestFails += 1; } } catch { RequestFails += 1; } } manager.EndBatch(TotalFired, RequestsSuccess, RequestFails); } }); }
static void Main() { SocketConnectionFactory.SetDefaultSettings(new SocketClientSettings ( "localhost", 2500, Encoding.UTF8 )); using (ISocketClientConnection connection = SocketConnectionFactory.GetConnection()) { connection.SendRequest("controller", "action", new { nome = "XPTO", idade = 39, outroParametroQualquer = Guid.NewGuid() }); var response = connection.ReadResponse(); } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); }
public int AcceptConnection() { ISocketClientConnection newUser = SocketClientConnectionFactory.CreateClientConnection(); _SessionMembers.Add(newUser); _ServerSocket.BeginAccept(AcceptCallback, newUser.clientInformation); //create a better state object for information transfer. Future return(1); //success, if logic to check for failed listen, return zero. future }
private void AcceptCallback(IAsyncResult result) { IClientInformation userInformation = result.AsyncState as IClientInformation; ISocketClientConnection user = _SessionMembers.Find(x => x.clientInformation.UniqueID == userInformation.UniqueID); user.userSocket = _ServerSocket.EndAccept(result); ReceiveMessage(user); }
public static ISocketClientConnection CreateClientConnection() { if (_connection != null) { return(_connection); } ClientInformation client = new ClientInformation(); _connection = new SocketClientConnection(client); return(_connection); }
private int GetCurrentThreadCountOnServer(SubServer server) { using (ISocketClientConnection client = BuildClient(server)) { Logger.WriteLog($"Querying availability on '{server.Address}:{server.Port}'", ServerLogType.INFO); client.SendRequest("ServerInfoController", "GetCurrentThreadsCount"); int result = int.Parse(client.GetResult().Entity.ToString()); return(result); } }
private ISocketClientConnection GetClient() { IServiceManager manager = ServiceManager.GetInstance(); logging = manager.GetService <ILoggingService>(); ICoreServerService coreServer = manager.GetService <ICoreServerService>(); ServerConfiguration config = coreServer.GetConfiguration(); ISocketClientConnection connection = SocketConnectionFactory .GetConnection(new SocketClientSettings("localhost", config.Port, config.ServerEncoding)); return(connection); }
private bool AreServerConnected(SubServer server, string cacheKey) { try { using (ISocketClientConnection client = BuildClient(server)) return(true); } catch { Logger.WriteLog($"Sub-server node '{server.Address}:{server.Port}' is unreachable", ServerLogType.ALERT); CacheRepository <bool> .Set(cacheKey, true, 120); return(false); } }
private OperationResult ExecuteRequest(string controllerName, string actionName, [FromBody] RequestParameter[] parameters) { var rb = RequestBody.Create(controllerName, actionName); if (parameters != null) { parameters.ToList().ForEach(p => rb.AddParameter(p.Name, p.Value)); } using (ISocketClientConnection client = GetClient()) { client.SendRequest(rb); var result = client.GetResult(); return(result); } }
public ActionResult RunAction(string receivedData) { SocketAppServerClient.RequestBody rb = JsonConvert.DeserializeObject <SocketAppServerClient.RequestBody>(receivedData, AppServerConfigurator.SerializerSettings); if (rb.Controller.Equals("ServerInfoController") && rb.Action.Equals("FullServerInfo")) { return(new ServerInfoController().FullServerInfo()); } string cacheResultKey = BuildCacheResultKey(rb); SubServer targetServer = GetAvailableSubServer(); if (targetServer == null) { CheckAllocateNewInstance(); if (retried) { return(ResolveResultOnUreachableServer(cacheResultKey)); } else { retried = true; return(RunAction(receivedData)); } } using (ISocketClientConnection client = BuildClient(targetServer)) { client.SendRequest(rb); SocketAppServerClient.OperationResult result = client.GetResult(); if (EnabledCachedResultsForUnreachableServers) { CacheRepository <SocketAppServerClient.OperationResult> .Set(cacheResultKey, result, 380); } targetServer.RefreshLifetimeIfHas(); return(ActionResult.Json(result)); } }
static void Main(string[] args) { try { SocketConnectionFactory.SetDefaultSettings(new SocketClientSettings( "localhost", 7001, Encoding.UTF8, 3 )); using (ISocketClientConnection conn = SocketConnectionFactory.GetConnection()) { } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(ex.Message); } }
private void ReceiveCallback(IAsyncResult result) { IClientInformation userInformation = result as IClientInformation; ISocketClientConnection fromUser = _SessionMembers.Find(x => x.clientInformation.UniqueID == userInformation.UniqueID); fromUser.userSocket.EndRecieve(result); bool successfulMessage = fromUser.packet.CreateMessage(); if (successfulMessage) { try { ISocketClientConnection toUser = _SessionMembers.Find(x => x.clientInformation.UniqueID == fromUser.packet.message.RecipientID); SendMessage(toUser, fromUser); } catch (ArgumentNullException) { //log when I get logging implemented } } fromUser.userSocket.BeginReceive(fromUser, ReceiveCallback, fromUser.clientInformation); }
public int ReceiveMessage(ISocketClientConnection user) { user.userSocket.BeginReceive(user, ReceiveCallback, user.clientInformation); return(1); }
public ServerInfoServiceImpl(ISocketClientConnection connection) { this.connection = connection; }
public static void SetSocketClientConnection(ISocketClientConnection conn) { _connection = conn; }
public int SendMessage(ISocketClientConnection toUser, ISocketClientConnection fromUser) { toUser.userSocket.BeginSend(fromUser, SendCallback, toUser.clientInformation); return(1); }
public void BeginSend(ISocketClientConnection connectionInfo, AsyncCallback AcceptCallback, object State) { throw new NotImplementedException(); }
public void BeginSend(ISocketClientConnection connectionInfo, AsyncCallback AcceptCallback, object State) { _socket.BeginSend(connectionInfo.packet.buffer, connectionInfo.packet.offset, connectionInfo.packet.bufferSize, SocketFlags.None, AcceptCallback, State); }