public HttpCode Execute()
{
Clear();
// Connect
NetworkChannel channel = null;
try
{
channel = new NetworkChannel(Connection);
// Request
JsonPingRequestMessage jsonRequestMessage = new JsonPingRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage);
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
// Response
HttpResponse httpResponse;
if (Owner)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
else
{
lock (Socket)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
}
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
return(Code);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonHandshakeRequestMessage jsonRequestMessage = JsonHandshakeRequestMessage.Parse(jsonRequest.Message);
JsonKey jsonRequestKey = jsonRequestMessage.Key;
// Response
JsonKey jsonResponseKey = jsonRequestKey;
JsonHandshakeResponseMessage jsonResponseMessage = new JsonHandshakeResponseMessage()
{
Key = jsonResponseKey
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
// Data
session.Key = Key.Parse(jsonRequestKey.Id);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonTunnelRequestMessage jsonRequestMessage = JsonTunnelRequestMessage.Parse(jsonRequest.Message);
// Data
Entity entity = session.Owner;
TunnelComponent tunnel = new TunnelComponent(Connection);
entity.Add(tunnel);
// Response
JsonTunnelResponseMessage jsonResponseMessage = new JsonTunnelResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public List <BrowseComponent> Execute()
{
Clear();
NetworkChannel channel = null;
List <BrowseComponent> list = new List <BrowseComponent>();
try
{
// Connect
channel = new NetworkChannel(Connection);
// Request
JsonGroupRequestMessage jsonRequestMessage = new JsonGroupRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage);
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonGroupResponseMessage jsonResponseMessage = JsonGroupResponseMessage.Parse(jsonResponse.Message);
if (jsonResponseMessage != null)
{
// Clients
foreach (JsonClient jsonClient in jsonResponseMessage.Clients)
{
BrowseComponent browse = new BrowseComponent(jsonClient.Name)
{
ClientId = jsonClient.Id, Owner = Entity
};
list.Add(browse);
}
}
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
return(list);
}
private void SendMessage()
{
var message = new Message(DateTime.UtcNow, User, Typing);
channel.Send(message);
Typing = string.Empty;
Conversation.Add(new MessageViewModel(message, true));
}
public void Send(T data)
{
using (var memory = new MemoryStream())
{
_builder.WriteStreamingResult(memory, _streamingType, _implementationType, data);
_channel.Send(memory);
}
}
private void ExecuteThread()
{
NetworkChannel channel = null;
try
{
// Connect
channel = new NetworkChannel(Connection);
// Request
JsonSearchRequestMessage jsonRequestMessage = new JsonSearchRequestMessage();
JsonSearch jsonSearch = new JsonSearch()
{
Keyword = Keyword, Filter = Filter
};
JsonSearchRequestData jsonRequestData = new JsonSearchRequestData()
{
Search = jsonSearch
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, Group.Encrypt(jsonRequestData));
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonSearchResponseMessage jsonResponseMessage = JsonSearchResponseMessage.Parse(jsonResponse.Message);
Debug.Assert(!string.IsNullOrEmpty(jsonResponseMessage.Id));
// Data
SearchList.Id = jsonResponseMessage.Id;
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
}
public HttpCode Execute()
{
Clear();
// Connect
NetworkChannel channel = null;
try
{
channel = new NetworkChannel(Connection);
// Request
JsonEntity jsonEntity = (JsonEntity)Entity;
JsonClient jsonClient = (JsonClient)Client;
JsonGroup jsonGroup = (JsonGroup)Group;
JsonJoinRequestMessage jsonRequestMessage = new JsonJoinRequestMessage()
{
Entity = jsonEntity, Client = jsonClient, Group = jsonGroup
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage);
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonJoinResponseMessage jsonResponseMessage = JsonJoinResponseMessage.Parse(jsonResponse.Message);
// Data
Server.Entities = jsonResponseMessage.Entities;
Server.Sessions = jsonResponseMessage.Sessions;
Server.Clients = jsonResponseMessage.Clients;
Server.Groups = jsonResponseMessage.Groups;
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
return(Code);
}
public HttpCode Execute(string jsonId, FileComponent file, string clientId = null)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonChunk jsonChunk = new JsonChunk()
{
Size = file.Size
};
JsonClient jsonClient = (clientId != null) ? new JsonClient(clientId) : null;
JsonDownloadRequestMessage jsonRequestMessage = new JsonDownloadRequestMessage(jsonId)
{
Chunk = jsonChunk, Client = jsonClient
};
JsonFile jsonFile = (JsonFile)file;
JsonDownloadRequestData jsonRequestData = new JsonDownloadRequestData()
{
File = jsonFile
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, Group.Encrypt(jsonRequestData));
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonDownloadResponseMessage jsonResponseMessage = JsonDownloadResponseMessage.Parse(jsonResponse.Message);
Chunk = jsonResponseMessage.Chunk;
Id = jsonResponseMessage.Id;
JsonDownloadResponseData jsonResponseData = JsonDownloadResponseData.Parse(Group.Decrypt(jsonResponse.Data));
if (jsonResponseData != null)
{
Data = jsonResponseData.Data;
}
#if DEBUG
jsonResponse.Data = null;
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
return(httpResponse.Code);
}
private static void Program_Received(object sender, OutgoingMessage e)
{
Console.WriteLine("Received outgoing: " + e.Message);
returnChannel.Send(
new ReturnMessage
{
Message = e.Message,
NodeAddress = network.Local.Address.AsString
});
}
private void ExecuteThread()
{
Clear();
// Connect
NetworkChannel channel = null;
try
{
channel = new NetworkChannel(Connection);
// Request
JsonInfoRequestMessage jsonRequestMessage = new JsonInfoRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage);
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonInfoResponseMessage jsonResponseMessage = JsonInfoResponseMessage.Parse(jsonResponse.Message);
// Data
Server.Entities = jsonResponseMessage.Entities;
Server.Sessions = jsonResponseMessage.Sessions;
Server.Clients = jsonResponseMessage.Clients;
Server.Groups = jsonResponseMessage.Groups;
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Machine.Status = DemonStatus.Warning;
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
}
public void Connect()
{
SetState(ConnectionState.CONNECTING);
Connect connect = new Connect(_username, _password, _clientID, _isClean, _keepalive, _will);
if (_timers != null)
{
_timers.StopAllTimers();
}
_timers = new TimersMap(this, _client, RESEND_PERIOND, _keepalive * 1000);
_timers.StoreConnectTimer(connect);
if (_client.IsConnected())
{
_client.Send(connect);
}
}
private void ExecuteThread()
{
// Connect
NetworkChannel channel = null;
try
{
channel = new NetworkChannel(Connection);
// Request
JsonPingRequestMessage jsonRequestMessage = new JsonPingRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage);
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
if (Owner && Machine != null)
{
Machine.Restart();
}
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
}
public JsonChunk Execute(string jsonId, byte[] jsonData, JsonChunk jsonChunk)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonUploadRequestMessage jsonRequestMessage = new JsonUploadRequestMessage(jsonId)
{
Chunk = jsonChunk
};
JsonUploadRequestData jsonRequestData = new JsonUploadRequestData()
{
Data = jsonData
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, Group.Encrypt(jsonRequestData));
HttpRequest httpRequest = new HttpRequest(Session.Id)
{
Data = Session.Encrypt(jsonRequest)
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
JsonUploadResponseMessage jsonResponseMessage = JsonUploadResponseMessage.Parse(jsonResponse.Message);
jsonChunk = jsonResponseMessage.Chunk;
#if DEBUG
jsonResponse.Data = null;
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
if (jsonResponseMessage.Delay > 0)
{
Thread.Sleep(TimeSpan.FromMilliseconds(jsonResponseMessage.Delay));
}
}
return(jsonChunk);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonBrowseRequestMessage jsonRequestMessage = JsonBrowseRequestMessage.Parse(jsonRequest.Message);
JsonClient jsonClient = jsonRequestMessage.Client;
if (jsonClient == null)
{
channel.SendNotFound();
return;
}
Entity entity = ClientMap.Get(jsonClient.Id);
if (entity == null)
{
channel.SendNotFound();
return;
}
// Command
TunnelComponent tunnel = entity.Get <TunnelComponent>();
BrowseRequestCommand command = new BrowseRequestCommand(entity, tunnel.Connection);
string jsonData = command.Execute(jsonRequest.Data);
if (string.IsNullOrEmpty(jsonData))
{
channel.SendNotFound();
return;
}
// Response
JsonBrowseResponseMessage jsonResponseMessage = new JsonBrowseResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage, jsonData);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void OnTimedEvent(Object sender, ElapsedEventArgs args)
{
_timer = null;
if (retriesLeft.HasValue)
{
retriesLeft--;
if (retriesLeft == 0)
{
_timersMap.CancelConnectTimer();
return;
}
}
_client.Send(_message);
_timersMap.RefreshTimer(this);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonSearchRequestMessage jsonRequestMessage = JsonSearchRequestMessage.Parse(jsonRequest.Message);
JsonSearchRequestData jsonRequestData = JsonSearchRequestData.Parse(Group.Decrypt(jsonRequest.Data));
JsonSearch jsonSearch = jsonRequestData.Search;
// Data
List <FileComponent> compFiles = FileMap.Search(jsonSearch);
if (compFiles.Count == 0)
{
channel.SendNotFound();
return;
}
List <JsonFile> jsonFiles = new List <JsonFile>();
foreach (FileComponent file in compFiles)
{
JsonFile jsonFile = (JsonFile)file;
jsonFiles.Add(jsonFile);
}
// Response
JsonSearchResponseMessage jsonResponseMessage = new JsonSearchResponseMessage();
JsonSearchResponseData jsonResponseData = new JsonSearchResponseData()
{
Files = jsonFiles
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage, Group.Encrypt(jsonResponseData));
HttpResponse httpResponse = new HttpResponse()
{
Data = Session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void TestChannelPackerErrorDecode()
{
var fromClient = new byte[] { };
using (var server = new TcpServer((data) =>
{
fromClient = Arr.Merge(fromClient, data);
}))
{
var socket = MakeEnv().Make <ISocketManager>().Make("tcp://127.0.0.1", "TestChannelPackerErrorDecode");
var channel = new NetworkChannel(socket, new PackerError(PackerError.ErrorType.Decode), "TestChannelPackerErrorDecode");
var wait = channel.Connect("127.0.0.1", 7777);
var count = 0;
while (!wait.IsDone && count++ < 3000)
{
Thread.Sleep(1);
}
try
{
string err = string.Empty;
channel.OnError += (c, ex) =>
{
if (err == string.Empty)
{
err = ex.ToString();
}
};
channel.Send(Encoding.Default.GetBytes("helloworld"));
count = 0;
while (channel.Socket.Connected && count++ < 3000)
{
Thread.Sleep(1);
}
Assert.AreEqual(false, channel.Socket.Connected);
Assert.AreEqual("CatLib.RuntimeException: exception decode", err);
}
finally
{
channel.Disconnect();
}
}
}
public List <FileComponent> Execute(HttpRequest httpRequest, JsonPacket jsonRequest)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Response
JsonSearchResponseMessage jsonResponseMessage = new JsonSearchResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = Session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
// Request
JsonSearchResponseMessage jsonRequestMessage = JsonSearchResponseMessage.Parse(jsonRequest.Message);
string jsonId = jsonRequestMessage.Id;
if (SearchList.Id != jsonId)
{
return(null);
}
JsonSearchResponseData jsonRequestData = JsonSearchResponseData.Parse(Group.Decrypt(jsonRequest.Data));
List <JsonFile> jsonFiles = jsonRequestData.Files;
List <FileComponent> list = new List <FileComponent>();
// Data
foreach (JsonFile jsonFile in jsonFiles)
{
FileComponent file = new FileComponent(jsonFile.Id, jsonFile.Name, jsonFile.Size)
{
Owner = Entity
};
list.Add(file);
}
return(list);
}
public HttpCode Execute()
{
Clear();
// Connect
NetworkChannel channel = null;
try
{
channel = new NetworkChannel(Connection);
// Request
HttpRequest httpRequest = new HttpRequest()
{
Data = SecurityUtil.Token
};
channel.Send(httpRequest);
// Response
HttpResponse httpResponse;
channel.Receive(out httpResponse);
Code = httpResponse.Code;
if (httpResponse.Ok)
{
// Data
Session.Id = httpResponse.Session;
Session.Key = Key.Parse(httpResponse.Data);
#if DEBUG
Log.Add(httpRequest, httpResponse);
#endif
}
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
}
return(Code);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonDownloadRequestMessage jsonRequestMessage = JsonDownloadRequestMessage.Parse(jsonRequest.Message);
JsonChunk jsonChunk = jsonRequestMessage.Chunk;
string jsonId = jsonRequestMessage.Id;
JsonDownloadRequestData jsonRequestData = JsonDownloadRequestData.Parse(Group.Decrypt(jsonRequest.Data));
JsonFile jsonFile = jsonRequestData.File;
// Data
FileComponent file = FileMap.Get(jsonFile.Id);
if (file == null)
{
channel.SendNotFound();
return;
}
// Controller
//UploadData uploadData = new UploadData(fileData, Client) { Id = jsonId, Chunk = jsonChunk };
//OnUpload(uploadData);
// Response
JsonDownloadResponseMessage jsonResponseMessage = new JsonDownloadResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = Session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
jsonRequest.Data = null;
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void Execute(HttpRequest httpRequest)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Data
Entity entity = new Entity(null);
entity.EntityShutdown += Listener;
EntityIdleComponent idle = new EntityIdleComponent();
entity.Add(idle);
SessionComponent session = new SessionComponent()
{
Key = Key.Parse(httpRequest.Data)
};
entity.Add(session);
SessionMap.Add(session.Id, entity);
Server.Sessions = SessionMap.Count;
// TODO: Use Diffie–Hellman
//
// Response
HttpResponse httpResponse = new HttpResponse(session.Id)
{
Data = SecurityUtil.Token
};
channel.Send(httpResponse);
#if DEBUG
LogComponent log = new LogComponent(Log.Controller);
entity.Add(log);
Log.Add(httpRequest, httpResponse);
#endif
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonInfoRequestMessage jsonRequestMessage = JsonInfoRequestMessage.Parse(jsonRequest.Message);
// Data
HttpCode code = HttpCode.Ok;
Entity entity = session.Owner;
TunnelComponent tunnel = entity.Get <TunnelComponent>();
if (tunnel != null)
{
PingRequestCommand command = new PingRequestCommand(entity, tunnel.Connection);
code = command.Execute();
if (code == HttpCode.Ok)
{
entity.Update();
}
}
// Response
JsonInfoResponseMessage jsonResponseMessage = new JsonInfoResponseMessage()
{
Entities = Server.Entities, Sessions = Server.Sessions, Clients = Server.Clients, Groups = Server.Groups
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse(code)
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public HttpCode Execute(string jsonId, string jsonData, JsonChunk jsonChunk)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonDownloadRequestMessage jsonRequestMessage = new JsonDownloadRequestMessage(jsonId)
{
Chunk = jsonChunk
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, jsonData);
HttpRequest httpRequest = new HttpRequest()
{
Data = Session.Encrypt(jsonRequest)
};
// Response
HttpResponse httpResponse;
lock (Socket)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
return(Code);
}
public string Execute(string jsonData)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonSearchRequestMessage jsonRequestMessage = new JsonSearchRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, jsonData);
HttpRequest httpRequest = new HttpRequest()
{
Data = Session.Encrypt(jsonRequest)
};
// Response
HttpResponse httpResponse;
// NOTE: We need to lock this send/receive message pairs
lock (Socket)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
// Data
return(jsonResponse.Data);
}
return(null);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonPingRequestMessage jsonRequestMessage = JsonPingRequestMessage.Parse(jsonRequest.Message);
// Response
JsonPingResponseMessage jsonResponseMessage = new JsonPingResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = Session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void TestChannelPackerErrorEncode()
{
var fromClient = new byte[] { };
using (var server = new TcpServer((data) =>
{
fromClient = Arr.Merge(fromClient, data);
}))
{
var socket = MakeEnv().Make <ISocketManager>().Make("tcp://127.0.0.1", "TestChannelPackerErrorEncode");
var channel = new NetworkChannel(socket, new PackerError(PackerError.ErrorType.Encode), "TestChannelPackerErrorEncode");
var wait = channel.Connect("127.0.0.1", 7777);
var count = 0;
while (!wait.IsDone && count++ < 3000)
{
Thread.Sleep(1);
}
try
{
var isThrow = false;
try
{
channel.Send(Encoding.Default.GetBytes("helloworld"));
}
catch (RuntimeException)
{
isThrow = true;
}
Assert.AreEqual(true, isThrow);
}
finally
{
channel.Disconnect();
}
}
}
public JsonAction Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonAction jsonAction = JsonAction.None;
JsonDownloadRequestMessage jsonRequestMessage = JsonDownloadRequestMessage.Parse(jsonRequest.Message);
string jsonId = jsonRequestMessage.Id;
if (jsonId != null)
{
// Data
Entity entity = TransferMap.Get(jsonId);
if (entity == null)
{
channel.SendNotFound();
return(jsonAction);
}
ChunkComponent transfer = entity.Get <ChunkComponent>();
if (transfer == null)
{
channel.SendNotFound();
return(jsonAction);
}
JsonTransfer jsonTransfer = transfer.PopData();
if (!transfer.Finished)
{
jsonAction = JsonAction.Request;
entity.Update();
}
else
{
TransferMap.Remove(jsonId);
}
string jsonData = null;
JsonChunk jsonChunk = null;
if (jsonTransfer != null)
{
jsonData = jsonTransfer.Data;
jsonChunk = jsonTransfer.Chunk;
}
// Response
JsonDownloadResponseMessage jsonResponseMessage = new JsonDownloadResponseMessage(jsonId)
{
Chunk = jsonChunk
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage, jsonData);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
jsonResponse.Data = null;
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
else
{
// Data
Entity entity = session.Owner;
SearchListComponent search = entity.Get <SearchListComponent>();
JsonClient jsonClient = jsonRequestMessage.Client;
// Request
if (jsonClient == null && search.Empty)
{
channel.SendNotFound();
return(jsonAction);
}
// Response
jsonId = SecurityUtil.CreateKeyString();
JsonDownloadResponseMessage jsonResponseMessage = new JsonDownloadResponseMessage(jsonId);
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
// Data
entity = new Entity(jsonId);
EntityIdleComponent idle = new EntityIdleComponent();
entity.Add(idle);
JsonChunk jsonChunk = jsonRequestMessage.Chunk;
ChunkComponent transfer = new ChunkComponent(jsonChunk.Size, Options.ChunkSize, Options.MaxChunks);
entity.Add(transfer);
TransferMap.Add(entity);
// Command
string jsonData = jsonRequest.Data;
jsonChunk = transfer.PopChunk();
if (jsonClient == null)
{
foreach (Entity e in search)
{
CommandState state = new CommandState()
{
Id = jsonId, Data = jsonData, Chunk = jsonChunk, Entity = e
};
Thread thread = new Thread(new ParameterizedThreadStart(ExecuteThread))
{
Priority = ThreadPriority.BelowNormal, IsBackground = true
};
thread.Start(state);
}
}
else
{
Entity e = ClientMap.Get(jsonClient.Id);
if (e == null)
{
channel.SendNotFound();
return(jsonAction);
}
CommandState state = new CommandState()
{
Id = jsonId, Data = jsonData, Chunk = jsonChunk, Entity = e
};
Thread thread = new Thread(new ParameterizedThreadStart(ExecuteThread))
{
Priority = ThreadPriority.BelowNormal, IsBackground = true
};
thread.Start(state);
}
jsonAction = JsonAction.Request;
}
return(jsonAction);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonGroupRequestMessage jsonRequestMessage = JsonGroupRequestMessage.Parse(jsonRequest.Message);
// Data
Entity entity = session.Owner;
GroupComponent group = entity.Get <GroupComponent>();
EntityList entities = GroupList.Get(group.Id);
if (entities == null)
{
channel.SendNotFound();
return;
}
List <JsonClient> jsonClients = new List <JsonClient>();
lock (entities)
{
foreach (Entity e in entities)
{
#if !DEBUG
if (entity.Id.Equals(e.Id))
{
continue;
}
#endif
ClientComponent c = e.Get <ClientComponent>();
JsonClient jsonClient = (JsonClient)c;
jsonClients.Add(jsonClient);
}
}
if (jsonClients.Count == 0)
{
channel.SendNotFound();
return;
}
jsonClients.Sort();
// Response
JsonGroupResponseMessage jsonResponseMessage = new JsonGroupResponseMessage()
{
Clients = jsonClients
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonJoinRequestMessage jsonRequestMessage = JsonJoinRequestMessage.Parse(jsonRequest.Message);
// Data
JsonEntity jsonEntity = jsonRequestMessage.Entity;
Entity entity = EntityMap.Get(jsonEntity.Id);
if (entity != null)
{
entity.Shutdown();
}
entity = session.Owner;
entity.Id = jsonEntity.Id;
EntityMap.Add(entity.Id, entity);
Server.Entities = EntityMap.Count;
JsonGroup jsonGroup = jsonRequestMessage.Group;
if (jsonGroup == null)
{
jsonGroup = JsonGroup.Default;
}
JsonClient jsonClient = jsonRequestMessage.Client;
ClientComponent client = new ClientComponent(jsonClient.Id, jsonClient.Name);
entity.Add(client);
ClientMap.Add(client.Id, entity);
Server.Clients = ClientMap.Count;
GroupComponent group = new GroupComponent(jsonGroup.Id);
entity.Add(group);
GroupList.Add(group.Id, entity);
Server.Groups = GroupList.Count;
SearchListComponent download = new SearchListComponent();
entity.Add(download);
// Response
JsonJoinResponseMessage jsonResponseMessage = new JsonJoinResponseMessage()
{
Entities = Server.Entities, Sessions = Server.Sessions, Clients = Server.Clients, Groups = Server.Groups
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
