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