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 void Constructor_ProjectAndException_ServerNameEqualsMachineName()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project, new Exception("Error"));
Assert.That(json.ServerName, Is.EqualTo(Environment.MachineName));
}
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 Handle(ClientSession session, JsonPacket message)
{
if (session.UpgradeClientStatus(ClientStatus.ConnectionConfirmed))
{
session.SendPackets(new VersionOutgoingMessage(PlatformRacing3Server.PROTOCOL_VERSION), new SocketIdOutgoingMessage(session.SocketId));
}
}
public void Constructor_Project_ProjectIsEqual()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project);
Assert.That(json.Project, Is.EqualTo(project));
}
protected override string Send(JsonPacket packet)
{
// TODO(dcramer): this is duped from RavenClient
packet = PreparePacket(packet);
LastPacket = packet;
return(packet.Project);
}
public void Constructor_ProjectAndException_ModulesHasCountGreaterThanZero()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project, new Exception("Error"));
Assert.That(json.Modules, Has.Count.GreaterThan(0));
}
public void Add(HttpRequest httpRequest, HttpResponse httpResponse, object objRequest = null, object objResponse = null)
{
lock (View)
{
++Count;
JsonType jsonType = JsonType.Handshake;
JsonAction jsonAction = JsonAction.Request;
LogDevice device = LogDevice.Client;
if (objRequest != null && objRequest is JsonPacket)
{
JsonPacket jsonRequest = (JsonPacket)objRequest;
JsonMessage jsonMessage = JsonMessage.Parse(jsonRequest.Message);
jsonAction = jsonMessage.Action;
jsonType = jsonMessage.Type;
if (!httpRequest.HasSession())
{
device = LogDevice.Server;
}
}
StringBuilder sb = new StringBuilder();
sb.Append("[ ").Append(device.ToString().ToUpper()).Append(" ]").Append(Constant.Newline);
sb.Append("[ ").Append(jsonType.ToString().ToUpper()).Append(" ").Append(jsonAction.ToString().ToUpper()).Append(" ]");
Add(sb);
Add(httpRequest, objRequest, Suffix.EOM);
Add(httpResponse, objResponse, Suffix.EOL);
}
}
public void Constructor_ProjectAndException_ProjectIsEqual()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project, new Exception("Error"));
Assert.That(json.Project, Is.EqualTo(project));
}
public void SerializedJsonPacket_WithValidData_IsValid()
{
var exception = TestHelper.GetException();
// TODO: This packet should preferably be "complete", i.e. contain as much information as possible. --asbjornu
JsonPacket packet = new JsonPacket("https://*****:*****@app.getsentry.com/1337", exception)
{
Level = ErrorLevel.Fatal,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
},
Request = new SentryRequest
{
QueryString = "?a=b&c=d",
Data = new
{
A = true,
B = 1,
C = "Hello"
}
}
};
JObject jPacket = JObject.Parse(packet.ToString());
JsonSchema schema = SchemaHelper.GetSchema();
jPacket.Validate(schema, (s, e) => Console.WriteLine(e.Message));
Console.WriteLine(jPacket);
var valid = jPacket.IsValid(schema);
Assert.That(valid, Is.True);
}
public void Handle(JsonPacket message)
{
Player.Client.Write($"%xt%zm%moveToCell%{Player.UserId}%Enter%Spawn%");
Player.Client.Write($"%xt%zm%retrieveUserDatas%{World.RoomId}%{Player.UserId}%");
Thread.Sleep(2000);
}
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);
}
internal JsonOutgoingMessage(JsonPacket jsonPacket)
{
ServerMessage message = new ServerMessage();
message.WriteUShort(JsonOutgoingMessage.PACKET_HEADER);
message.WriteBytes(Encoding.UTF8.GetBytes(this.SerializeObject(jsonPacket)));
this.Bytes = message.GetBytes();
}
public void Constructor_ProjectAndException_EventIDIsValidGuid()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project, new Exception("Error"));
Assert.That(json.EventID, Is.Not.Null.Or.Empty, "EventID");
Assert.That(Guid.Parse(json.EventID), Is.Not.Null);
}
public void Constructor_ProjectAndException_MessageEqualsExceptionMessage()
{
var project = Guid.NewGuid().ToString();
Exception exception = new Exception("Error");
var json = new JsonPacket(project, exception);
Assert.That(json.Message, Is.EqualTo(exception.Message));
}
public void Constructor_Project_EventIDIsValidGuid()
{
var project = Guid.NewGuid().ToString();
var json = new JsonPacket(project);
Assert.That(json.EventID, Is.Not.Null.Or.Empty, "EventID");
Assert.That(TestHelper.Parse(json.EventID), Is.Not.Null);
}
public int CaptureException(Exception e)
{
JsonPacket packet = new JsonPacket(CurrentDSN.ProjectID, e);
packet.Logger = Logger;
Send(packet, CurrentDSN);
return(0);
}
public async Task <string> CaptureAsync(SentryEvent sentryEvent)
{
var jsonPacket = new JsonPacket(CurrentDsn.ProjectId, sentryEvent);
var result = await sentryApi.StoreAsync(jsonPacket);
return(result.id);
}
protected override JsonPacket OnCreate(JsonPacket jsonPacket)
{
jsonPacket.Project = this.project;
jsonPacket.Release = this.release;
jsonPacket.Environment = this.environment;
jsonPacket.Logger = this.logger;
return(base.OnCreate(jsonPacket));
}
/// <summary>
/// Captures the message.
/// </summary>
/// <param name="message">The message to capture.</param>
/// <param name="level">The <see cref="ErrorLevel" /> of the captured <paramref name="message" />. Default <see cref="ErrorLevel.Info" />.</param>
/// <param name="tags">The tags to annotate the captured <paramref name="message" /> with.</param>
/// <param name="extra">The extra metadata to send with the captured <paramref name="message" />.</param>
/// <returns>
/// The <see cref="JsonPacket.EventID" /> of the successfully captured <paramref name="message" />, or <c>null</c> if it fails.
/// </returns>
public string CaptureMessage(SentryMessage message,
ErrorLevel level = ErrorLevel.Info,
Dictionary<string, string> tags = null,
object extra = null)
{
JsonPacket packet = this.jsonPacketFactory.Create(CurrentDsn.ProjectID, message, level, tags, extra);
return Send(packet, CurrentDsn);
}
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 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 void Handle(ClientSession session, JsonPacket message)
{
if (!session.IsLoggedIn)
{
return;
}
session.LobbySession.MatchListing?.ForceStart(session);
}
public void Handle(JsonPacket message)
{
Player.IsLoggedIn = true;
Console.WriteLine($"{Player.Client.Username} was connected!");
Thread.Sleep(3000);
Player.Client.Write($"%xt%zm%cmd%1%goto%minae%");
}
public void Handle(ClientSession session, JsonPacket message)
{
if (!session.IsLoggedIn)
{
return;
}
session.MultiplayerMatchSession?.Match.FinishDrawing(session);
}
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 JsonPacket CreatePacket(UnityLogEvent log)
{
JsonPacket packet = new JsonPacket(log);
packet.Project = Dsn.ProjectID;
packet.Level = GetErrorLevel(log.LogType);
return(packet);
}
public void Handle(ClientSession session, JsonPacket message)
{
if (!session.IsLoggedIn)
{
return;
}
session.MultiplayerMatchSession?.MatchPlayer?.Match.Forfeit(session);
}
public void Handle(ClientSession session, JsonPacket message)
{
if (session.IsLoggedIn)
{
return;
}
this.matchListingManager.StopQuickJoin(session);
}
