public void Load(string collectionName, CallbackFunction.Load<IList<JsonDocument>> callback)
{
Guard.Assert(() => !string.IsNullOrEmpty(collectionName));
Guard.Assert(() => callback != null);
SynchronizationContext context = SynchronizationContext.Current;
IndexSession.Query("Raven/DocumentsByEntityName", new IndexQuery {Query = string.Format("Tag:{0}", collectionName)}, null, (result) =>
{
var documents = new List<JsonDocument>();
if (result.IsSuccess)
{
var jsonSerializer = new JsonSerializer();
documents =
result.Data.Results.Select(
document =>
(JsonDocument) jsonSerializer.Deserialize(document.CreateReader(), typeof (JsonDocument))).
ToList();
}
var loadResponse = new LoadResponse<IList<JsonDocument>>
{
Data = documents,
Exception = result.Exception,
StatusCode = result.StatusCode
};
context.Post(delegate { callback.Invoke(loadResponse); },
null);
});
}
public static LoadResponse Load(BinaryReader reader, SaveType saveType)
{
/* 0 - Depersist object table. */
uint rootId = 0;
bool rootFound = false;
Dictionary <uint, ISaveable> objectTable = new Dictionary <uint, ISaveable>();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
uint objectId = reader.ReadUInt32();
String assemblyQualifiedTypeName = reader.ReadString();
bool isRoot = reader.ReadBoolean();
if (isRoot && rootFound)
{
throw new NotSupportedException("More than one root object defined in the save file!");
}
else if (isRoot)
{
rootFound = true;
rootId = objectId;
}
ISaveable loadedObject = constructType(assemblyQualifiedTypeName, objectId);
loadedObject.Load(reader, saveType);
objectTable.Add(loadedObject.GetId(), loadedObject);
}
if (rootFound == false)
{
throw new NotSupportedException("No root object defined in the save file!");
}
/* 1 - Inflate all objects */
inflateObjects(objectTable, saveType);
/* 2 - Construct the result object */
List <ISaveable> values = new List <ISaveable>();
foreach (ISaveable saveable in objectTable.Values)
{
values.Add(saveable);
}
LoadResponse response = new LoadResponse();
response.root = objectTable[rootId];
response.objects = values;
/* 3 - Return the response object */
return(response);
}
public void LoadPackage(string package, string version, string tarballPath)
{
if (_loadedPackages.Contains(package))
{
return;
}
_logger.LogDebug($"Loading package {package}@{version}...");
_loadedPackages.Add(package);
LoadResponse response = Load(package, version, tarballPath);
}
protected override void Load(BusinessContext context)
{
LoadRequest loadRequest = context.Request as LoadRequest;
bool forceBase = loadRequest.Parameters.GetValue <bool>(EventHelper.FORCE_BASE_PARAM, false);
if (!forceBase)
{
LoadResponse response = new LoadResponse();
EntityObject entity = EventHelper.PrerpareLoadEventRequest(loadRequest);
response.EntityObject = entity;
context.SetResponse(response);
}
else
{
base.Load(context);
}
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public void Execute(BusinessContext context)
{
switch (context.GetMethod())
{
case RequestMethod.Load:
if (context.GetTargetPrimaryKeyId().HasValue)
{
EntityObject item = LoadEntityObject(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);
if (item != null)
{
LoadResponse response = new LoadResponse(item);
context.SetResponse(response);
}
}
break;
case RequestMethod.List:
{
// Filters Not Implemented
ListResponse response = context.Response as ListResponse;
if (response != null)
{
EntityObject[] items = LoadEntityObjects(context.GetTargetMetaClassName(), ((ListRequest)context.Request).Filters);
if (items.Length > 0)
{
List <EntityObject> newArray = new List <EntityObject>(response.EntityObjects.Length + items.Length);
newArray.AddRange(response.EntityObjects);
newArray.AddRange(items);
// TODO: Sorting Not Implemented
response.EntityObjects = newArray.ToArray();
}
}
}
break;
}
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public void Execute(BusinessContext context)
{
switch (context.GetMethod())
{
case RequestMethod.Load:
if (context.GetTargetPrimaryKeyId().HasValue)
{
EntityObject item = LoadEntityObject(context.GetTargetMetaClassName(), context.GetTargetPrimaryKeyId().Value);
if (item != null)
{
LoadResponse response = new LoadResponse(item);
context.SetResponse(response);
}
}
break;
case RequestMethod.List:
{
// Filters Not Implemented
ListResponse response = context.Response as ListResponse;
if (response != null)
{
EntityObject[] items = LoadEntityObjects(context.GetTargetMetaClassName(), ((ListRequest)context.Request).Filters);
if (items.Length > 0)
{
List<EntityObject> newArray = new List<EntityObject>(response.EntityObjects.Length + items.Length);
newArray.AddRange(response.EntityObjects);
newArray.AddRange(items);
// TODO: Sorting Not Implemented
response.EntityObjects = newArray.ToArray();
}
}
}
break;
}
}
/// <summary>
/// Функция основной работы теста, передаваемая на поток
/// </summary>
public void Callback()
{
try
{
LoadRequest loader = new LoadRequest(1, LoadRequest.Controllers.acc);
Random rand = new Random(DateTime.Now.Millisecond);
double number = rand.NextDouble();
for (int i = 0; i < _entries; i++)
{
if (number > 1)
{
number -= 1.0f;
}
else
{
number *= 1.073;
}
loader.AddData(DateTime.Now.AddSeconds(-i), number);
if (i % 100 == 0 && _verbose)
{
VerboseMessage(string.Format("datagen: RunId={2} TestId={1} Generated={0} Total={3}", i, TestId, RunId, _entries));
}
}
DateTime startTime = DateTime.Now;
HttpRequest http = new HttpRequest(_host, _port, _chunked)
{
Debug = _debug,
KeepAlive = _keepAlive
};
http.Post("/api/v1/load", loader);
http.SendHeader();
while (true)
{
bool flag = false;
if (_chunked)
{
int count = rand.Next(_minSendingData, _maxSendingData);
if (_verbose)
{
DebugMessage(string.Format("send: RunId={3} TestId={4} Sent={2} Current={0} Total={1}",
http.ChunkedPosition,
http.ContentLength,
count < http.ContentLength ? count : http.ContentLength,
RunId,
TestId));
}
flag = http.Send(count);
}
else
{
flag = http.Send();
}
if (flag)
{
break;
}
System.Threading.Thread.Sleep(rand.Next(_minSleepTime, _maxSleepTime));
}
LoadResponse loadResponse = http.Response <LoadResponse>();
TimeSpan endTime = DateTime.Now - startTime;
ResultMessage(string.Format("result: RunId={5} TestId={3} Success={0} StatusCode={1} Status={2} Time={4}ms",
loadResponse.Success,
(int)http.StatusCode,
http.StatusCode,
TestId,
endTime.TotalMilliseconds,
RunId));
}
catch (Exception e)
{
ExceptionMessage(e);
}
}
private void StatisticsGet_Callback(HttpJsonRequest request, IAsyncResult result, CallbackFunction.Load<DatabaseStatistics> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
var statistics = this.StatisticsMapper.Map(json);
var loadResponse = new LoadResponse<DatabaseStatistics>()
{
Data = statistics,
Exception = exception,
StatusCode = statusCode
};
context.Post(delegate { callback.Invoke(loadResponse); }, null);
}
private void AttachmentGetAll_Callback(HttpJsonRequest request, IAsyncResult result, CallbackFunction.Load<IList<KeyValuePair<string, Attachment>>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
JArray array = JArray.Parse(json);
var attachments = new List<KeyValuePair<string, Attachment>>();
string key;
foreach (JToken attachment in array)
{
attachments.Add(AttachmentMapper.Map(attachment));
}
var loadResponse = new LoadResponse<IList<KeyValuePair<string, Attachment>>>
{
Data = attachments,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
private void AttachmentGet_Callback(string key, HttpJsonRequest request, IAsyncResult result,
CallbackFunction.Load<KeyValuePair<string, Attachment>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
Attachment attachment = AttachmentMapper.Map(key, request.HttpWebRequest, result, out statusCode,
out exception);
var loadResponse = new LoadResponse<KeyValuePair<string, Attachment>>
{
Data = new KeyValuePair<string, Attachment>(key, attachment),
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
private void IndexGetAll_Callback(IDictionary<string, IndexDefinition> existingEntities, HttpJsonRequest request,
IAsyncResult result,
CallbackFunction.Load<IDictionary<string, IndexDefinition>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
JArray array = JArray.Parse(json);
var responseResult = new Dictionary<string, IndexDefinition>();
if (exception == null)
{
var entities = array.Select(index => IndexMapper.Map(index.ToString()));
responseResult = responseResult.Concat(entities).ToDictionary(x => x.Key, y => y.Value);
if (existingEntities != null)
{
responseResult.Concat(existingEntities);
}
}
var loadResponse = new LoadResponse<IDictionary<string, IndexDefinition>>
{
Data = responseResult,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
private void IndexGet_Callback(string name, HttpJsonRequest request, IAsyncResult result,
CallbackFunction.Load<KeyValuePair<string, IndexDefinition>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
var index = new KeyValuePair<string, IndexDefinition>();
if (exception == null)
{
index = IndexMapper.Map(json);
}
var loadResponse = new LoadResponse<KeyValuePair<string, IndexDefinition>>
{
Data = index,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
private void DocumentGetAll_Callback(HttpJsonRequest request, IAsyncResult result,
CallbackFunction.Load<IList<JsonDocument>> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
JArray array = JArray.Parse(json);
var responseResult = new List<JsonDocument>();
if (exception == null)
{
responseResult = array.Select(jsonDocument => DocumentMapper.Map(jsonDocument.ToString())).ToList();
}
var loadResponse = new LoadResponse<IList<JsonDocument>>
{
Data = responseResult,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
private void DocumentGet_Callback(string key, HttpJsonRequest request, IAsyncResult result,
CallbackFunction.Load<JsonDocument> callback)
{
SynchronizationContext context = GetContext(request);
DeleteContext(request);
HttpStatusCode statusCode;
Exception exception;
NameValueCollection headers;
string json = GetResponseStream(request.HttpWebRequest, result, out statusCode, out exception, out headers);
JsonDocument document = null;
if (exception == null)
{
document = DocumentMapper.Map(json);
document.Metadata = headers.FilterHeaders(isServerDocument: false);
document.Key = key;
}
var loadResponse = new LoadResponse<JsonDocument>
{
Data = document,
StatusCode = statusCode,
Exception = exception
};
context.Post(
delegate { callback.Invoke(loadResponse); },
null);
}
