public void TestArray()
{
var tests = new[]
{
(float)0,
(float)50505,
Single.NaN,
Single.MaxValue,
Single.MinValue,
Single.PositiveInfinity,
Single.NegativeInfinity,
Single.Epsilon,
}.Select(f => MPack.From(f))
.ToArray();
var arr = new MPackArray(tests);
var bytes = arr.EncodeToBytes();
var round = MPack.ParseFromBytes(bytes) as MPackArray;
Assert.IsTrue(round != null);
Assert.IsTrue(arr.Count == round.Count);
for (int i = 0; i < arr.Count; i++)
{
Assert.AreEqual(arr[i], round[i]);
}
Assert.AreEqual(arr, round);
}
public void TestArray()
{
var tests = new[]
{
(float) 0,
(float) 50505,
Single.NaN,
Single.MaxValue,
Single.MinValue,
Single.PositiveInfinity,
Single.NegativeInfinity,
Single.Epsilon,
}.Select(f => MPack.From(f))
.ToArray();
var arr = new MPackArray(tests);
var bytes = arr.EncodeToBytes();
var round = MPack.ParseFromBytes(bytes) as MPackArray;
Assert.IsTrue(round != null);
Assert.IsTrue(arr.Count == round.Count);
for (int i = 0; i < arr.Count; i++)
{
Assert.AreEqual(arr[i], round[i]);
}
Assert.AreEqual(arr, round);
}
private MPack Execute(MPack p)
{
var map = (MPackMap)p;
//var responseBody = new RResponseBody();
RSession sesh = null;
DateTime start = DateTime.Now;
string method = null;
MPackMap result = new MPackMap();
if (map.ContainsKey(CONST.HDR_ID))
result[CONST.HDR_ID] = map[CONST.HDR_ID];
try
{
// parse client input packet
var token = map[CONST.HDR_TOKEN].To<string>();
var sig = map[CONST.HDR_METHOD].To<string>();
var parsedSig = RemoteCallHelper.ParseMethodName(sig);
method = parsedSig.Name;
sesh = _parent.Sessions.Get(token);
if (sesh == null)
throw new ArgumentException("Specified token is invalid");
result[CONST.HDR_TOKEN] = MPack.From(token);
// get method details, parameters, return type, etc
//sesh = _parent._sessions[token];
var methodInfo = sesh.Endpoint.Methods.Single(mth => mth.Name == method);
var methodParams = methodInfo.Parameters;
var serverArgTypes = methodParams
.Select(x => x.ParameterType)
.ToArray();
var serverRetType = methodInfo.ReturnType;
if (!RemoteCallHelper.CheckMethodSignature(methodInfo.Method, parsedSig))
throw new InvalidOperationException("Method signature does not match that of the server's implementation");
// check if user is authorized to execute this method
//if (methodInfo.Attributes.FirstOrDefault(a => a is RRequireAuth) != null)
// if (!_authenticated && _parent.CredentialValidator != null)
// throw new MethodAccessException("This method requires authentication");
//var role = methodInfo.Attributes.FirstOrDefault(a => a is RRequireRole) as RRequireRole;
//if (role != null && _parent.CredentialValidator != null)
//{
// if (!_authenticated || !_parent.CredentialValidator.IsInRole(_user, role.RequiredRole))
// throw new MethodAccessException(
// $"User must be in {role.RequiredRole} role to access this method.");
//}
// deserialize the request body
//var requestBody = ClassifyJson.Deserialize<RRequestBody>(JsonValue.Parse(p.Payload));
var mpackArgs = map[CONST.HDR_ARGS];
object[] reconArgs = new object[serverArgTypes.Length];
List<int> refParams = new List<int>();
for (int i = 0; i < reconArgs.Length; i++)
{
var mpk = mpackArgs[i];
var type = serverArgTypes[i];
var byref = methodParams[i].IsOut || type.IsByRef;
var streamed = serverArgTypes[i].IsAssignableFrom(typeof(Stream));
if (streamed)
{
reconArgs[i] = new MessageConsumerStream(mpk.To<string>(), _protocol.Buffer, _cancelSource.Token, WritePacket);
}
else
{
if (byref)
refParams.Add(i);
reconArgs[i] = RemoteCallHelper.ParamaterToObject(type, mpk);
}
}
// validate that we have all the required parameters
for (int i = 0; i < reconArgs.Length; i++)
{
//if (reconArgs[i] == null && !methodParams[i].IsOptional && !methodParams[i].IsOut)
// throw new ArgumentException("A required method parameter is missing.");
if (reconArgs[i] == null && methodParams[i].IsOptional)
reconArgs[i] = Type.Missing;
}
//var returnValue = methodInfo.Delegate(sesh.Instance, reconArgs);
var returnValue = methodInfo.Method.Invoke(sesh.Instance, reconArgs);
if (returnValue != null && !serverRetType.IsInstanceOfType(returnValue))
throw new InvalidOperationException("Return value type mismatch");
// populate ref / out parameters to the response body
if (refParams.Any())
{
var refoutParams = new MPackArray(Enumerable.Range(0, reconArgs.Length).Select(v => MPack.Null()));
for (int i = 0; i < refParams.Count; i++)
{
var paramIndex = refParams[i];
refoutParams[paramIndex] = RemoteCallHelper.ObjectToParamater(reconArgs[paramIndex]);
}
result[CONST.HDR_ARGS] = refoutParams;
}
// set the return value of response body
if (typeof(Stream).IsAssignableFrom(serverRetType))
{
bool writable = methodInfo.Method.ReturnParameter.GetCustomAttributes(typeof(RWritable)).Any();
string tkn = Guid.NewGuid().ToString();
var wrappedStream = new MessageProviderStream(tkn, (Stream)returnValue, _protocol.Buffer,
WritePacket, _cancelSource.Token, writable);
result[CONST.HDR_STATUS] = MPack.From(CONST.STA_STREAM);
result[CONST.HDR_VALUE] = MPack.From(tkn);
}
else if (serverRetType == typeof(void))
{
result[CONST.HDR_STATUS] = MPack.From(CONST.STA_VOID);
}
else if (Attribute.IsDefined(serverRetType ?? typeof(object), typeof(RContractProvider)))
{
result[CONST.HDR_STATUS] = MPack.From(CONST.STA_SERVICE);
REndpoint endpoint = _parent.Endpoints.SingleOrDefault(ed => ed.Interface == serverRetType);
if (endpoint == null)
endpoint = new REndpoint(RandomEx.GetString(20), serverRetType, context => null);
// create new session
var ses = new RSession(endpoint, returnValue);
var policy = new CacheItemPolicy() { SlidingExpiration = _parent.SessionTimeout };
_parent.Sessions.Add(ses.Token, ses, policy);
if (returnValue is IDisposable)
{
policy.RemovedCallback = args => ((IDisposable)args.CacheItem.Value).Dispose();
}
result[CONST.HDR_VALUE] = MPack.From(ses.Token);
}
else
{
result[CONST.HDR_STATUS] = MPack.From(CONST.STA_NORMAL);
result[CONST.HDR_VALUE] = RemoteCallHelper.ObjectToParamater(returnValue);
}
}
catch (Exception ex)
{
string message;
string type;
if (ex is TargetInvocationException || ex is AggregateException)
{
type = ex.InnerException.GetType().Name;
message = ex.InnerException.Message;
}
else
{
type = ex.GetType().Name;
message = ex.Message;
}
result[CONST.HDR_STATUS] = MPack.From(CONST.STA_ERROR);
result[CONST.HDR_VALUE] = MPack.From($"({type}){message}");
result[CONST.HDR_LOCATION] = MPack.From($"{sesh?.Endpoint.Path ?? "[invalid]"}/{method ?? "[invalid]"}()");
}
DateTime end = DateTime.Now;
var time = end - start;
result[CONST.HDR_TIME] = MPack.From(time.TotalMilliseconds);
return result;
}
