public void ReadValue(JsonAction <object, JsonValueType> value, JsonAction readArray, JsonAction readObject)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
if (readArray is null)
{
throw new ArgumentNullException(nameof(readArray));
}
if (readObject is null)
{
throw new ArgumentNullException(nameof(readObject));
}
switch (Values.Peek().Type)
{
case JsonValueType.Array:
readArray();
return;
case JsonValueType.Object:
readObject();
return;
}
if (JsonApi.HasFlag(Values.Peek().Type, JsonValueType.Value))
{
value(Values.Peek().Value, Values.Peek().Type);
return;
}
throw new JsonNotSupportException(Values.Peek().Type);
}
public ActionResult SaveAppendix()
{
HelpPermissions.ViewHelp.AssertAuthorized();
var ctx = this.ExtractEntity <AppendixHelpEntity>().ApplyChanges(this);
var entity = ctx.Value;
if (!entity.Title.HasText() && !entity.Description.HasText())
{
if (!entity.IsNew)
{
entity.Delete();
}
return(JsonAction.RedirectAjax(RouteHelper.New().Action((HelpController a) => a.Index())));
}
else
{
var wasNew = entity.IsNew;
entity.Execute(AppendixHelpOperation.Save);
if (wasNew)
{
return(JsonAction.RedirectAjax(RouteHelper.New().Action((HelpController a) => a.ViewAppendix(entity.UniqueName))));
}
return(null);
}
}
public ActionResult UpdateRegions(Guid?CityId = null)
{
try
{
var regions = new core.Controllers.RegionController().GetList(CityId);
regions.Insert(0, new Region()
{
RegionName = "Select"
});
IEnumerable <SelectListItem> list = regions
.Select(o => new SelectListItem
{
Value = o.RegionId.ToString(),
Text = o.RegionName
});
var ret = new JsonAction
{
success = true,
data = list
};
ViewBag.Regions = list;
return(Json(ret));
}
catch (Exception)
{
var ret = new JsonAction {
success = false, message = "Something's Wrong"
};
return(Json(ret));
}
}
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);
}
}
private void LoadAction(Subtask subtask, JsonAction jsonAction, string mode)
{
AppAction action = subtask.gameObject.AddComponent <AppAction>();
action.actor = AppController.instance.FindObjectByName(jsonAction.actor);
action.actionName = jsonAction.name;
action.parameters = new List <string>(jsonAction.parameters);
action.parameters.Insert(0, mode.ToLower());
subtask.Action = action;
}
public void ReadObject(JsonFunc <string, bool> key, JsonAction readValue)
{
if (key is null)
{
throw new ArgumentNullException(nameof(key));
}
if (readValue is null)
{
throw new ArgumentNullException(nameof(readValue));
}
Read(false, key, i => readValue());
}
private static JsonTimelineMessage CreateJsonTimelineMessage(JsonAction action, string type)
{
JsonTimelineMessage timelineMessage = new JsonTimelineMessage();
string eventName = action.ToString("G");
if (type != null)
{
eventName += " - " + RemoveAssemblyDetails(type);
}
timelineMessage.AsTimelineMessage(eventName, new TimelineCategoryItem(action.ToString("G"), "#B3DF00", "#9BBB59"));
return(timelineMessage);
}
public void ReadValue(JsonAction <object, JsonValueType> value, JsonAction readArray, JsonAction readObject)
{
if (readArray is null)
{
throw new ArgumentNullException(nameof(readArray));
}
if (readObject is null)
{
throw new ArgumentNullException(nameof(readObject));
}
switch (Current.Type)
{
case JsonTokenType.Integer:
value?.Invoke(Current.Value, JsonValueType.Integer);
return;
case JsonTokenType.Decimal:
value?.Invoke(Current.Value, JsonValueType.Decimal);
return;
case JsonTokenType.String: {
string text = Current;
if (DateTime.TryParse(text, out DateTime dateTime))
{
value?.Invoke(dateTime, JsonValueType.DateTime);
return;
}
value?.Invoke(Regex.Unescape(text), JsonValueType.String);
return;
}
case JsonTokenType.Null:
value?.Invoke(Current.Value, JsonValueType.Null);
return;
case JsonTokenType.Bool:
value?.Invoke(Current.Value, JsonValueType.Bool);
return;
case JsonTokenType.LeftBracket:
readArray();
return;
case JsonTokenType.LeftBrace:
readObject();
return;
}
throw new JsonTextReaderException(
this,
JsonKeyword.Null, "整数", "小数", JsonKeyword.True, JsonKeyword.False, "字符串", JsonKeyword.LeftBracket, JsonKeyword.LeftBrace
);
}
public void ReadValue(JsonAction <object, JsonValueType> value, JsonAction readArray, JsonAction readObject)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
if (readArray is null)
{
throw new ArgumentNullException(nameof(readArray));
}
if (readObject is null)
{
throw new ArgumentNullException(nameof(readObject));
}
if (Stacks.Peek().ArrayType != JsonArrayType.Unknown)
{
readArray();
return;
}
if (Stacks.Peek().ObjectType != JsonObjectType.Unknown)
{
readObject();
return;
}
Stacks.Peek().IsInitialized = true;
if (Stacks.Peek().Instance is null)
{
value(null, JsonValueType.Null);
return;
}
if (Stacks.Peek().Type is null)
{
Stacks.Peek().Type = Stacks.Peek().Instance.GetType();
}
if (JsonApi.TryGetValueType(Stacks.Peek().Type, out JsonValueType valueType, Config))
{
value(Stacks.Peek().Instance, valueType);
return;
}
if (JsonApi.TryGetArrayType(Stacks.Peek().Type, out Stacks.Peek().ArrayType))
{
readArray();
return;
}
if (JsonApi.TryGetObjectType(Stacks.Peek().Type, out Stacks.Peek().ObjectType))
{
readObject();
return;
}
throw new JsonNotSupportException(Stacks.Peek().Type);
}
public float[] getTau(JsonAction action, Character character)
{
List <JsonPDController> jsonPDs = character.mjsonObject.PDControllers;
List <GameObject> bodies = character.mBodies;
int numJoint = jsonPDs.Count;
float[] targetTau = new float[numJoint];
float[] tauErr = new float[numJoint];
for (int i = 1; i < numJoint; i++)
{
targetTau [i] = 0;
JsonPDController pd = jsonPDs [i];
GameObject body = bodies [i];
HingeJoint joint = bodies [i].GetComponent <HingeJoint> ();
float currTheta = Mathf.Deg2Rad * joint.angle;
float currVel = Mathf.Deg2Rad * joint.velocity;
float targetTheta;
// if current joint is controlled by action, use that theta
if (pd.Name.Contains("spine"))
{
targetTheta = getTargetTheta(action.StateParams, "SpineCurve");
}
else if (CONTROL_PARAMS.Contains(pd.Name))
{
targetTheta = getTargetTheta(action.StateParams, pd.Name);
}
else
{
targetTheta = pd.TargetTheta;
}
JointSpring spring = joint.spring;
spring.targetPosition = Mathf.Rad2Deg * targetTheta;
joint.spring = spring;
//targetTau[i] += calcSPD(currTheta, targetTheta, currVel, pd);
int parent = character.mjsonObject.Skeleton.Joints[i].Parent;
float mass = character.mjsonObject.BodyDefs [i].Mass;
calcGravity(ref targetTau, body, joint, mass, i, parent);
// targetTau[i] += calcVirtual
tauErr [i] = targetTau [i] - mPastTau [i];
mPastTau [i] = targetTau [i];
}
return(tauErr);
}
public static void ForEachSerializableMembers(Type type, JsonAction <MemberInfo, FieldInfo, PropertyInfo, JsonField> action)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (action is null)
{
throw new ArgumentNullException(nameof(action));
}
foreach (MemberInfo memberInfo in GetMembers(type))
{
if (CanSerializeMember(memberInfo, out FieldInfo fieldInfo, out PropertyInfo propertyInfo, out JsonField field))
{
action(memberInfo, fieldInfo, propertyInfo, field);
}
}
}
public override async Task <EntityView> Run(EntityView entityView, CommercePipelineExecutionContext context)
{
if (entityView == null ||
!entityView.Action.Equals("DevOps-CleanEnvironment", StringComparison.OrdinalIgnoreCase))
{
return(entityView);
}
var appService = await this._commerceCommander.GetEntity <AppService>(context.CommerceContext, entityView.ItemId);
var jsonAction = new JsonAction {
Environment = context.CommerceContext.Environment.Name
};
await this._commerceCommander.Command <JsonCommander>()
.Put(context.CommerceContext, $"http://{appService.Host}/commerceops/CleanEnvironment()", jsonAction);
return(entityView);
}
void FixedUpdate()
{
float time = Time.time;
/*
* mPolicy.updatePolicy ();
*/
JsonAction action = mPolicy.getAction(mActionJson);
float[] t = mController.getTau(action, mCharacter);
mCharacter.simulate(t);
//if (Input.anyKeyDown) {
if (lastTime + 0.125 < time)
{
mController.advanceState();
lastTime = time;
}
}
public void ReadObject(JsonFunc <string, bool> key, JsonAction readValue)
{
if (key is null)
{
throw new ArgumentNullException(nameof(key));
}
if (readValue is null)
{
throw new ArgumentNullException(nameof(readValue));
}
foreach (JsonKey jsonKey in Values.Peek())
{
if (key(jsonKey.Name))
{
Values.Push(jsonKey);
readValue();
Values.Pop();
}
}
}
public ActionResult Authentication(string username, string password)
{
Session.Clear();
password = Utils.Encryption.getHashSha256(password);
try
{
User user = new Auth().Authentication(username, password);
SiteSession.Current.User = user;
SiteSession.Current.Login = user.Email;
SiteSession.Current.Password = user.Password;
SiteSession.Current.Administrator = user.Name.ToUpper().Contains("ADMIN");
JsonAction jsonObject = new JsonAction();
jsonObject.success = true;
if (user.Name.ToUpper().Contains("SELLER") || /// == (int)UserTypes.Role.Seller)
user.Name.ToUpper().Contains("ADMIN")) /// == (int)UserTypes.Role.Admin)
{
jsonObject.data = Url.Action("Index", "Home");
}
return(Json(jsonObject));
}
catch (Exception ex)
{
JsonAction jsonObject = new JsonAction();
jsonObject.success = false;
if (ex.GetType() == typeof(WrongUserPasswordException))
{
jsonObject.message = Resources.Resource.ResourceManager.GetString("Error_Wrong_UserPwd");
}
else
{
jsonObject.message = "Something's Wrong";
}
return(Json(jsonObject));
}
}
public async Task <JsonResponse> Put(CommerceContext commerceContext, string uri, JsonAction body)
{
var response = new JsonResponse {
Uri = uri
};
using (CommandActivity.Start(commerceContext, this))
{
try
{
using (var httpClient = new HttpClient())
{
var postResponse = await httpClient.PutAsJsonAsync(response.Uri, body);
response.Json = await postResponse.Content.ReadAsStringAsync();
}
var reader = new StringReader(response.Json);
response.Reader = new JsonTextReader(reader);
}
catch (Exception ex)
{
await commerceContext.AddMessage(
commerceContext.GetPolicy <KnownResultCodes>().Error,
"FailedToDeserialize",
new object[] { ex },
$"GetProdPadCommand.Exception: Message={ex.Message}|Stack={ex.StackTrace}");
commerceContext.Logger.LogWarning($"Exception: {ex.Message}");
response = null;
}
return(response);
}
}
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);
}
private void ListenState()
{
NetworkChannel channel = null;
try
{
// Connect
if (!Connected)
{
State = DemonState.Restart;
Status = DemonStatus.Info;
return;
}
// NOTE: No need to close the channel
channel = new NetworkChannel(Connection);
Status = DemonStatus.Success;
// Request
HttpRequest httpRequest;
channel.Receive(out httpRequest);
if (httpRequest == null)
{
Status = DemonStatus.Warning;
return;
}
// TODO: Version check
//
// Message
SessionComponent session = Owner.Get <SessionComponent>();
string decrypted = session.Decrypt(httpRequest.Data);
JsonPacket jsonRequest = JsonPacket.Parse(decrypted);
JsonMessage jsonRequestMessage = JsonMessage.Parse(jsonRequest.Message);
JsonType jsonType = jsonRequestMessage.Type;
switch (jsonType)
{
case JsonType.Ping:
{
PingResponseCommand command = new PingResponseCommand(Owner, Connection);
command.Execute(httpRequest, jsonRequest);
break;
}
case JsonType.Search:
{
JsonAction action = jsonRequestMessage.Action;
switch (action)
{
case JsonAction.Request:
{
SearchRequestCommand command = new SearchRequestCommand(Owner, Connection);
command.Execute(httpRequest, jsonRequest);
break;
}
case JsonAction.Response:
{
SearchResponseCommand command = new SearchResponseCommand(Owner, Connection);
List <FileComponent> list = command.Execute(httpRequest, jsonRequest);
OnListAdded(list);
break;
}
default:
{
channel.SendBadRequest();
break;
}
}
break;
}
case JsonType.Browse:
{
BrowseResponseCommand command = new BrowseResponseCommand(Owner, Connection);
command.Execute(httpRequest, jsonRequest);
break;
}
case JsonType.Download:
{
// TODO
//
DownloadResponseCommand command = new DownloadResponseCommand(Owner, Connection); // { Handler = UploadEvent };
command.Execute(httpRequest, jsonRequest);
break;
}
default:
{
channel.SendBadRequest();
State = DemonState.Restart;
Status = DemonStatus.Info;
return;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Status = DemonStatus.Error;
if (channel != null)
{
try
{
channel.SendInternalServerError();
}
catch (Exception) { }
}
}
}
private void ProcessState(object obj)
{
Socket socket = (Socket)obj;
NetworkChannel channel = null;
JsonAction action = JsonAction.None;
JsonType jsonType = JsonType.None;
try
{
do
{
// Connect
channel = new NetworkChannel(socket);
// Receive
HttpRequest httpRequest;
channel.Receive(out httpRequest);
if (httpRequest == null)
{
channel.SendBadRequest();
return;
}
// Data
Status = DemonStatus.Success;
// Handshake
if (httpRequest.Session == null)
{
ServerStatusComponent status = Owner.Get <ServerStatusComponent>();
HandshakeResponseCommand command = new HandshakeResponseCommand(Owner, socket)
{
Listener = status.Update
};
command.Execute(httpRequest);
break;
}
// Session
SessionMapComponent sessions = Owner.Get <SessionMapComponent>();
Entity entity = sessions.Get(httpRequest.Session);
if (entity == null)
{
channel.SendUnauthorized();
break;
}
// TODO: Version check
//
// Message
SessionComponent session = entity.Get <SessionComponent>();
string decrypted = session.Decrypt(httpRequest.Data);
JsonPacket jsonRequest = JsonPacket.Parse(decrypted);
JsonMessage jsonRequestMessage = JsonMessage.Parse(jsonRequest.Message);
jsonType = jsonRequestMessage.Type;
switch (jsonType)
{
case JsonType.Handshake:
{
HandshakeResponseCommand command = new HandshakeResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Ping:
{
PingResponseCommand command = new PingResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Info:
{
InfoResponseCommand command = new InfoResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Join:
{
JoinResponseCommand command = new JoinResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Tunnel:
{
TunnelResponseCommand command = new TunnelResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Search:
{
SearchResponseCommand command = new SearchResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Group:
{
GroupResponseCommand command = new GroupResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Browse:
{
BrowseResponseCommand command = new BrowseResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Download:
{
// TODO: Add max transfer check!
//
DownloadResponseCommand command = new DownloadResponseCommand(Owner, socket);
action = command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Upload:
{
UploadResponseCommand command = new UploadResponseCommand(Owner, socket);
action = command.Execute(httpRequest, jsonRequest, session);
break;
}
case JsonType.Quit:
{
QuitResponseCommand command = new QuitResponseCommand(Owner, socket);
command.Execute(httpRequest, jsonRequest, session);
break;
}
default:
{
channel.SendBadRequest();
return;
}
}
}while (action != JsonAction.None);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Status = DemonStatus.Error;
channel.SendInternalServerError();
}
finally
{
if (channel != null)
{
channel.Shutdown();
}
if (jsonType != JsonType.Tunnel)
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
}
}
}
public void ReadObject(JsonFunc <string, bool> key, JsonAction readValue)
{
if (key is null)
{
throw new ArgumentNullException(nameof(key));
}
if (readValue is null)
{
throw new ArgumentNullException(nameof(readValue));
}
Initialize(false);
switch (Stacks.Peek().ObjectType)
{
default:
throw new JsonNotSupportException(Stacks.Peek().ObjectType);
case JsonObjectType.Class:
JsonApi.ForEachSerializableMembers(Stacks.Peek().Type, (memberInfo, fieldInfo, propertyInfo, field) => {
bool isReaded = false;
object instance = null;
Type fieldType = null;
object Read()
{
if (isReaded)
{
return(instance);
}
isReaded = true;
switch (memberInfo.MemberType)
{
default:
throw new JsonNotSupportException(memberInfo.MemberType);
case MemberTypes.Field:
fieldType = fieldInfo.FieldType;
return(instance = fieldInfo.GetValue(Stacks.Peek().Instance));
case MemberTypes.Property:
fieldType = propertyInfo.PropertyType;
return(instance = propertyInfo.GetValue(Stacks.Peek().Instance, null));
}
}
object ConverterWrite(object value)
{
if (field?.HasConverter ?? false)
{
if (field.ConverterWriteType != fieldType.BaseType &&
JsonApi.GetElementType(field.ConverterWriteType) != JsonApi.GetElementType(fieldType).BaseType
)
{
fieldType = field.ConverterWriteType;
}
return(field.ConverterWrite(value, Config));
}
return(value);
}
if (!JsonApi.CanSerializeValue(Read(), Config))
{
return;
}
if (key(field?.Name ?? memberInfo.Name))
{
Stacks.Push(new JsonSerializerStack(ConverterWrite(Read()), field));
Stacks.Peek().Type = fieldType;
readValue();
Stacks.Pop();
}
});
break;
case JsonObjectType.DataRow: {
DataRow dataRow = (DataRow)Stacks.Peek().Instance;
for (int i = 0; i < dataRow.Table.Columns.Count; i++)
{
if (key(dataRow.Table.Columns[i].ColumnName))
{
Stacks.Push(new JsonSerializerStack(dataRow[i]));
readValue();
Stacks.Pop();
}
}
break;
}
case JsonObjectType.DataSet: {
DataSet dataSet = (DataSet)Stacks.Peek().Instance;
foreach (DataTable dataTable in dataSet.Tables)
{
if (key(dataTable.TableName))
{
Stacks.Push(new JsonSerializerStack(dataTable));
readValue();
Stacks.Pop();
}
}
break;
}
case JsonObjectType.GenericDictionary:
case JsonObjectType.GenericSortedDictionary:
case JsonObjectType.GenericSortedList: {
IDictionary dictionary = (IDictionary)Stacks.Peek().Instance;
foreach (DictionaryEntry entry in dictionary)
{
if (key(Convert.ToString(entry.Key)))
{
Stacks.Push(new JsonSerializerStack(entry.Value));
readValue();
Stacks.Pop();
}
}
break;
}
case JsonObjectType.GenericKeyValuePair: {
if (key(Convert.ToString(Stacks.Peek().Type.GetProperty("Key").GetValue(Stacks.Peek().Instance, null))))
{
Stacks.Push(new JsonSerializerStack(Stacks.Peek().Type.GetProperty("Value").GetValue(Stacks.Peek().Instance, null)));
readValue();
Stacks.Pop();
}
break;
}
}
}
public void ReadArray(Action <int> readValue)
{
if (readValue is null)
{
throw new ArgumentNullException(nameof(readValue));
}
Initialize(true);
switch (Stacks.Peek().ArrayType)
{
default:
throw new JsonNotSupportException(Stacks.Peek().ArrayType);
case JsonArrayType.Array: {
if (ForEachArray is null)
{
Array array = (Array)Stacks.Peek().Instance;
if (array.Rank == 1)
{
for (int i = 0; i < array.Length; i++)
{
Stacks.Push(new JsonSerializerStack(array.GetValue(i)));
readValue(i);
Stacks.Pop();
}
return;
}
int[] indices = new int[array.Rank];
int dimension = 0;
int count = 0;
ForEachArray = () => {
int length = array.GetLength(dimension);
for (int i = 0; i < length; i++)
{
indices[dimension] = i;
if (dimension == indices.Length - 1)
{
Stacks.Push(new JsonSerializerStack(array.GetValue(indices)));
readValue(count++);
Stacks.Pop();
continue;
}
dimension++;
readValue(count++);
}
dimension--;
if (dimension < 0)
{
ForEachArray = null;
}
};
}
ForEachArray();
break;
}
case JsonArrayType.GenericList:
case JsonArrayType.GenericIList:
case JsonArrayType.GenericObservableCollection: {
IList list = (IList)Stacks.Peek().Instance;
for (int i = 0; i < list.Count; i++)
{
Stacks.Push(new JsonSerializerStack(list[i]));
readValue(i);
Stacks.Pop();
}
break;
}
case JsonArrayType.DataTable: {
DataTable dataTable = (DataTable)Stacks.Peek().Instance;
for (int i = 0; i < dataTable.Rows.Count; i++)
{
Stacks.Push(new JsonSerializerStack(dataTable.Rows[i]));
readValue(i);
Stacks.Pop();
}
break;
}
}
}
protected JsonMessage(JsonType type, JsonAction action)
{
Type = type; Action = action;
}
private void Listen()
{
NetworkChannel channel = null;
try
{
// Connect
if (!Connected)
{
Data.Status = DemonStatus.Info;
State = DemonState.Restart;
return;
}
// NOTE: No need to close the channel
channel = new NetworkChannel(Connection);
Data.Status = DemonStatus.Success;
// Response
HttpRequest httpRequest;
channel.Receive(out httpRequest);
if (httpRequest == null)
{
return;
}
string decrypted = Data.Session.Decrypt(httpRequest.Data);
JsonPacket jsonRequest = JsonPacket.Parse(decrypted);
if (jsonRequest == null)
{
return;
}
JsonMessage jsonRequestMessage = JsonMessage.Parse(jsonRequest.Message);
switch (jsonRequestMessage.Type)
{
case JsonType.Ping:
{
//ClientPingCommand command = new ClientPingCommand(Connection, Data);
//command.SetLogHandlers(RequestHandler, ResponseHandler, CommandHandler);
//command.Execute(httpRequest, jsonRequest);
break;
}
case JsonType.Search:
{
JsonAction action = jsonRequestMessage.Action;
switch (action)
{
case JsonAction.Request:
{
//ClientSearchCommand command = new ClientSearchCommand(Connection, Data);
//command.SetLogHandlers(RequestHandler, ResponseHandler, CommandHandler);
//command.Execute(httpRequest, jsonRequest);
break;
}
case JsonAction.Response:
{
//ClientSearchCommand2 command = new ClientSearchCommand2(Connection, Data) { SearchHandler = SearchEvent };
//command.SetLogHandlers(RequestHandler, ResponseHandler, CommandHandler);
//command.Execute(httpRequest, jsonRequest);
break;
}
default:
{
channel.SendBadRequest();
break;
}
}
break;
}
case JsonType.Browse:
{
//ClientBrowseCommand command = new ClientBrowseCommand(Connection, Data);
//command.SetLogHandlers(RequestHandler, ResponseHandler, CommandHandler);
//command.Execute(httpRequest, jsonRequest);
break;
}
case JsonType.Download:
{
//ClientDownloadCommand command = new ClientDownloadCommand(Connection, Data) { Handler = UploadEvent };
//command.SetLogHandlers(RequestHandler, ResponseHandler, CommandHandler);
//command.Execute(httpRequest, jsonRequest);
break;
}
default:
{
channel.SendBadRequest();
Data.Status = DemonStatus.Info;
State = DemonState.Restart;
return;
}
}
Data.Status = DemonStatus.Success;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Data.Status = DemonStatus.Info;
State = DemonState.Restart;
if (channel != null)
{
try
{
channel.SendInternalServerError();
}
catch (Exception) { }
}
}
}
public void Trace(TraceLevel level, string message, Exception ex)
{
// write to any existing trace writer
if (_innerTraceWriter != null && level <= _innerTraceWriter.LevelFilter)
{
_innerTraceWriter.Trace(level, message, ex);
}
IExecutionTimer timer = _timerStrategy();
if (_traceMessages.Count > 0)
{
// check message to see if serialization is complete
if (message.StartsWith("Serialized JSON:", StringComparison.Ordinal) || message.StartsWith("Deserialized JSON:", StringComparison.Ordinal))
{
TimerResult timeResult = null;
if (timer != null)
{
timeResult = timer.Stop(_start);
_timelineMessage.AsTimedMessage(timeResult);
}
// set final JSON onto previous message
JsonTraceMessage lastMessage = _traceMessages.Last();
lastMessage.JsonText = message.Substring(message.IndexOf(Environment.NewLine, StringComparison.Ordinal)).Trim();
lastMessage.Duration = (timeResult != null) ? (TimeSpan?)timeResult.Duration : null;
_traceMessages.Clear();
return;
}
}
JsonAction action = JsonAction.Unknown;
string type = null;
string json = null;
if (_traceMessages.Count == 0)
{
Match match = Regex.Match(message, @"^Started serializing ([^\s]+)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
if (match.Success)
{
type = match.Groups[1].Value.TrimEnd('.');
action = JsonAction.Serialize;
}
else
{
match = Regex.Match(message, @"^Started deserializing ([^\s]+)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
if (match.Success)
{
type = match.Groups[1].Value.TrimEnd('.');
action = JsonAction.Deserialize;
}
else
{
if (message.StartsWith("Serialized JSON:", StringComparison.Ordinal))
{
action = JsonAction.Serialize;
}
else if (message.StartsWith("Deserialized JSON:", StringComparison.Ordinal))
{
action = JsonAction.Deserialize;
}
if (action != JsonAction.Unknown)
{
json = message.Substring(message.IndexOf(Environment.NewLine, StringComparison.Ordinal)).Trim();
message = null;
}
}
}
// create timeline message
// will be updated each trace with new duration
_timelineMessage = CreateJsonTimelineMessage(action, type);
_messageBroker.Publish(_timelineMessage);
if (timer != null)
{
_start = timer.Start();
}
}
else
{
JsonTraceMessage previous = _traceMessages.Last();
previous.Duration = null;
action = previous.Action;
type = previous.Type;
}
TimerResult result = null;
if (timer != null)
{
result = timer.Stop(_start);
_timelineMessage.AsTimedMessage(result);
}
JsonTraceMessage traceMessage = new JsonTraceMessage
{
Ordinal = _traceMessages.Count,
MessageDate = DateTime.Now,
Level = level,
Message = message,
Exception = ex,
JsonText = json,
Action = action,
Type = (type != null) ? RemoveAssemblyDetails(type) : null,
Duration = (result != null) ? (TimeSpan?)result.Duration : null
};
_messageBroker.Publish(traceMessage);
_traceMessages.Add(traceMessage);
}
protected JsonIdMessage(JsonType type, JsonAction action, string id = null) : base(type, action)
{
Id = id;
}
private static JsonTimelineMessage CreateJsonTimelineMessage(JsonAction action, string type)
{
JsonTimelineMessage timelineMessage = new JsonTimelineMessage();
string eventName = action.ToString("G");
if (type != null)
eventName += " - " + RemoveAssemblyDetails(type);
timelineMessage.AsTimelineMessage(eventName, new TimelineCategoryItem(action.ToString("G"), "#B3DF00", "#9BBB59"));
return timelineMessage;
}
IEnumerator DoBenchmark()
{
yield return(null);
// Attempt to find a wrapper matching the selection name
IJsonLibrary wrapper = null;
foreach (var w in m_knownJsonLibraryWrappers)
{
System.Type t = w.GetType();
if (t.ToString() == Lib)
{
wrapper = w;
break;
}
}
if (wrapper != null)
{
yield return(null);
LastLibName.text = Lib;
LastActionName.text = Action.ToString();
long sum = 0;
long samples = long.Parse(NumSamplesToRun.text);
string notes = string.Empty; // Gets overwritten, only last notes are shown
long avg = 0;
#if !UNITY_EDITOR
long memoryAllocatedDuringAction = 0;
#endif
if (samples > 0)
{
for (int i = 0; i < samples; i++)
{
Stopwatch timer = new Stopwatch();
#if !UNITY_EDITOR
System.GC.Collect();
UnityEngine.Scripting.GarbageCollector.GCMode = UnityEngine.Scripting.GarbageCollector.Mode.Disabled;
long totalGCBeforeAction = System.GC.GetTotalMemory(true);
#endif
if (Action == JsonAction.Deserialize)
{
notes = string.Format("Json being used is {0} char long", m_jsonText.Length);
notes += wrapper.Deserialize(timer);
}
else if (Action == JsonAction.Serialize)
{
notes = string.Format("Class being serialized has {0} complex elements", m_holder.junkList.Length);
notes += wrapper.Serialize(timer);
}
if (!timer.IsRunning)
{
throw new System.Exception("Stopwatch timer was not started by wrapper");
}
timer.Stop();
sum += timer.ElapsedMilliseconds;
#if !UNITY_EDITOR
memoryAllocatedDuringAction += System.GC.GetTotalMemory(true) - totalGCBeforeAction;
UnityEngine.Scripting.GarbageCollector.GCMode = UnityEngine.Scripting.GarbageCollector.Mode.Enabled;
#endif
//UnityEngine.Debug.Log(string.Format("----> {0} using {1} took {2}", Action, Lib, timer.ElapsedMilliseconds));
yield return(null);
}
avg = (sum / samples);
}
notes += "\n" + samples.ToString() + " samples taken";
#if !UNITY_EDITOR
notes += "\n" + (memoryAllocatedDuringAction / samples * 1e-6).ToString("F2") + " mb GC allocated";
#endif
Notes.text = notes;
LastTimeValue.text = avg.ToString();
}
else
{
UnityEngine.Debug.Log(string.Format("Unable to find suitable IJsonWrapper to match selection {0}", Lib));
}
Action = JsonAction.None;
m_working = -1;
}
// Constructors
protected JsonChunkMessage(JsonType type, JsonAction action, string id = null) : base(type, action, id)
{
}
