/// <summary> /// register service and method to server for client call thats /// </summary> /// <typeparam name="T">type of interface for create instanse</typeparam> /// <returns>return instance of interface that client can call methods</returns> public T RegisterClientServiceInterface <T>() { var type = typeof(T); var name = type.GetCustomAttributes <ServiceContractAttribute>(true).FirstOrDefault().Name; MethodCallInfo callInfo = new MethodCallInfo() { ServiceName = name, MethodName = "/RegisterService", Guid = Guid.NewGuid().ToString() }; var callback = this.SendData <MethodCallbackInfo>(callInfo); var t = CSCodeInjection.GenerateInterfaceType(type, typeof(OperationCalls), new List <Type>() { typeof(ServiceContractAttribute), this.GetType() }, false); var objectInstance = Activator.CreateInstance(t); dynamic dobj = objectInstance; dobj.InvokedClientMethodAction = CSCodeInjection.InvokedClientMethodAction; dobj.InvokedClientMethodFunction = CSCodeInjection.InvokedClientMethodFunction; var duplex = objectInstance as OperationCalls; duplex.Connector = this; Services.TryAdd(name, objectInstance); return((T)objectInstance); }
public void OnEnable() { var methods = target.GetType() .GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); foreach (var method in methods) { if (method.GetCustomAttributes(typeof(DebugButtonAttribute), false).Any()) { if (_methodCallInfo == null) { _methodCallInfo = new List <MethodCallInfo>(); } var mci = new MethodCallInfo { MethodInfo = method, Parameters = new List <ParamTuple>() }; foreach (var p in method.GetParameters().ToList()) { mci.Parameters.Add(new ParamTuple { Obj = p.DefaultValue, ParamInfo = p }); } _methodCallInfo.Add(mci); } } }
/// <summary> /// This returns true if we have set (changed) values during a transaction /// </summary> /// <param name="methodCallInfo">MethodCallInfo</param> private void IsTransactionDirty(MethodCallInfo methodCallInfo) { lock (_transactionProperties) { methodCallInfo.ReturnValue = _inTransaction && _transactionProperties.Count > 0; } }
internal static async Task RunMethod(ServerBase serverBase, ClientInfo client) { MethodCallbackInfo callback = null; try { byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(client.ClientStream, CompressMode.None, serverBase.ProviderSetting.MaximumReceiveStreamHeaderBlock); string json = Encoding.UTF8.GetString(bytes); MethodCallInfo callInfo = ServerSerializationHelper.Deserialize <MethodCallInfo>(json, serverBase); //MethodsCallHandler.BeginStreamCallAction?.Invoke(client, guid, serviceName, methodName, values); CallMethodResultInfo <OperationContext> result = await CallMethod(callInfo.ServiceName, callInfo.Guid, callInfo.MethodName, callInfo.Parameters, null, client, null, serverBase, null, null); callback = result.CallbackInfo; } catch (Exception ex) { callback = new MethodCallbackInfo { IsException = true, Data = ServerSerializationHelper.SerializeObject(ex) }; } finally { //MethodsCallHandler.EndStreamCallAction?.Invoke(client, guid, serviceName, methodName, values, jsonResult, exception); } await SendCallbackData(callback, client, serverBase); }
private string OnCallMqlMethod(string methodName, IEnumerable <string> parameters) { string returnValue = ""; try { try { this.ClientMethod = new MethodCallInfo(methodName, parameters); this.ClientCallSemaphore.Set(); this.ServerCallSemaphore.WaitOne(); returnValue = this.ClientMethod.ReturnValue; if (!string.IsNullOrEmpty(this.ClientMethod.ErrorMessage) && this._mqlHandler.MqlError != null) { MqlErrorException mqlErrorException = new MqlErrorException(this.ExpertInfo, this.ClientMethod); this._mqlHandler.MqlError(mqlErrorException); Trace.Write(new TraceInfo(BridgeTraceErrorType.MqlError, mqlErrorException, "")); } } catch (Exception exception1) { Exception exception = exception1; Trace.Write(new TraceInfo(BridgeTraceErrorType.Execption, exception, "")); } } finally { this.ClientMethod = null; } return(returnValue); }
/// <summary> /// Logic to start the transaction, any setter used after this will be in the transaction /// </summary> /// <param name="methodCallInfo">MethodCallInfo</param> private void StartTransaction(MethodCallInfo methodCallInfo) { lock (_transactionProperties) { _inTransaction = true; } }
private string OnCallMqlMethod(string methodName, IEnumerable <string> parameters) { string str = ""; try { this.ClientMethod = new MethodCallInfo(methodName, parameters); this.ClientCallSemaphore.Set(); this.ServerCallSemaphore.WaitOne(); str = this.ClientMethod.ReturnValue; if (!string.IsNullOrEmpty(this.ClientMethod.ErrorMessage)) { if (this._mqlHandler.MqlError != null) { MqlErrorException mqlErrorException = new MqlErrorException(this.ExpertInfo, this.ClientMethod); this._mqlHandler.MqlError(mqlErrorException); Trace.Write((object)new LogInfo(LogType.MqlError, (Exception)mqlErrorException, "")); } } } catch (Exception ex) { Trace.Write((object)new LogInfo(LogType.Execption, ex, "")); } finally { this.ClientMethod = (MethodCallInfo)null; } return(str); }
/// <summary> /// send data to server /// </summary> /// <param name="client">client is sended</param> /// <param name="callerName">methos name</param> /// <param name="attibName">service name</param> /// <param name="args">method parameters</param> /// <returns></returns> internal static object SendData(this OperationCalls client, string callerName, string attibName, params object[] args) { MethodCallInfo callInfo = new MethodCallInfo(); if (string.IsNullOrEmpty(attibName)) { callInfo.ServiceName = client.GetType().GetCustomAttributes <ServiceContractAttribute>(true).FirstOrDefault().Name; } else { callInfo.ServiceName = attibName; } callInfo.MethodName = callerName; foreach (var item in args) { callInfo.Parameters.Add(new Shared.Models.ParameterInfo() { Value = JsonConvert.SerializeObject(item), Type = item?.GetType().FullName }); } var guid = Guid.NewGuid().ToString(); callInfo.Guid = guid; return(SendData(client.Connector, callInfo, args.Length == 1 && args[0] != null && args[0].GetType() == typeof(StreamInfo) ? (StreamInfo)args[0] : null)); }
/// <summary> /// return types of method parameter /// </summary> /// <param name="serviceType"></param> /// <param name="callInfo"></param> /// <returns></returns> public static List <Type> GetMethodTypes(Type serviceType, MethodCallInfo callInfo) { List <Type> methodParameterTypes = new List <Type>(); #if (NETSTANDARD1_6) var methods = serviceType.GetTypeInfo().GetMethods(); #else var methods = serviceType.GetMethods(); #endif foreach (var item in methods) { if (item.Name == callInfo.MethodName) { if (item.GetParameters().Length != callInfo.Parameters.Count) { continue; } foreach (var p in item.GetParameters()) { methodParameterTypes.Add(p.ParameterType); } break; } } return(methodParameterTypes); }
private void FindMethods(Type targetType) { var methods = targetType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); foreach (var method in methods) { if (method.GetCustomAttributes(typeof(DebugButtonAttribute), false).Any()) { var mci = new MethodCallInfo { methodInfo = method, parameters = new List <ParamTuple>() }; foreach (var p in method.GetParameters()) { mci.parameters.Add(new ParamTuple { obj = p.DefaultValue, paramInfo = p }); } _methodCallInfo.Add(mci); } } if (_methodCallInfo.Count == 0 && targetType.BaseType != null) { // Could not find methods, look in parent class (as long as it is not simply 'object') FindMethods(targetType.BaseType); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageInfo"/> class. /// </summary> /// <param name="source">The source.</param> /// <param name="target">The target.</param> /// <param name="methodCallName">Name of the method call.</param> /// <param name="methodCallInfo">The method call info.</param> internal MessageInfo(ObjectInfo source, ObjectInfo target, string methodCallName, MethodCallInfo methodCallInfo) { this.Source = source; this.Target = target; this.MethodCallName = methodCallName; this.MethodCallInfo = methodCallInfo; }
internal static object SendCustomCallbackToClient(ClientInfo client, MethodCallInfo callInfo) { var guid = Guid.NewGuid().ToString(); callInfo.Guid = guid; var waitedMethodsForResponse = client.ServerBase.WaitedMethodsForResponse[client]; waitedMethodsForResponse.TryAdd(guid, new KeyValue <AutoResetEvent, MethodCallbackInfo>(new AutoResetEvent(false), null)); client.ServerBase.CallClientMethod(client, callInfo); var seted = waitedMethodsForResponse[guid].Key.WaitOne(client.ServerBase.ProviderSetting.ReceiveDataTimeout); if (!seted) { client.ServerBase.CheckClient(client); waitedMethodsForResponse.Remove(guid); throw new TimeoutException(); } if (waitedMethodsForResponse[guid].Value.IsException) { var data = waitedMethodsForResponse[guid].Value.Data; waitedMethodsForResponse.Remove(guid); throw new Exception("call method return exception: " + data); } var result = waitedMethodsForResponse[guid].Value.Data; waitedMethodsForResponse.Remove(guid); return(result); }
//public object SendData(this ClientDuplex client, string className, string callerName, params object[] args) //{ // MethodCallInfo callInfo = new MethodCallInfo(); // callInfo.FullClassName = className; // callInfo.MethodName = callerName; // foreach (var item in args) // { // callInfo.Parameters.Add(new Shared.Models.ParameterInfo() { Type = item.GetType().FullName, Value = JsonConvert.SerializeObject(item) }); // } // SendData(callInfo); // return null; //} /// <summary> /// send data to call server method /// </summary> /// <param name="Data"></param> internal void SendData(MethodCallInfo Data) { AsyncActions.Run(() => { try { var json = JsonConvert.SerializeObject(Data); List <byte> bytes = new List <byte> { (byte)DataType.CallMethod, (byte)CompressMode.None }; var jsonBytes = Encoding.UTF8.GetBytes(json); if (SecuritySettings != null) { jsonBytes = EncryptBytes(jsonBytes); } byte[] dataLen = BitConverter.GetBytes(jsonBytes.Length); bytes.AddRange(dataLen); bytes.AddRange(jsonBytes); if (bytes.Count > ProviderSetting.MaximumSendDataBlock) { throw new Exception("SendData data length is upper than MaximumSendDataBlock"); } GoStreamWriter.WriteToStream(_client.GetStream(), bytes.ToArray(), IsWebSocket); } catch (Exception ex) { AutoLogger.LogError(ex, "ConnectorBase SendData"); } }); }
/// <summary> /// this method call when client want to upload file or stream to your server /// </summary> /// <param name="stream">client stream</param> /// <param name="client">client</param> private static async Task DownloadStreamFromClient(ClientInfo client, ServerBase serverBase) { MethodCallbackInfo callback = null; string guid = Guid.NewGuid().ToString(); try { byte[] bytes = await client.StreamHelper.ReadBlockToEndAsync(client.ClientStream, CompressMode.None, serverBase.ProviderSetting.MaximumReceiveStreamHeaderBlock); string json = Encoding.UTF8.GetString(bytes); MethodCallInfo callInfo = ServerSerializationHelper.Deserialize <MethodCallInfo>(json, serverBase); CallMethodResultInfo <OperationContext> result = await CallMethod(callInfo.ServiceName, callInfo.Guid, callInfo.MethodName, callInfo.Parameters, null, client, null, serverBase, null, null); callback = result.CallbackInfo; } catch (IOException ex) { callback = new MethodCallbackInfo(); callback.IsException = true; callback.Data = ServerSerializationHelper.SerializeObject(ex); //return; } catch (Exception ex) { callback = new MethodCallbackInfo(); callback.IsException = true; callback.Data = ServerSerializationHelper.SerializeObject(ex); } finally { } await SendCallbackData(callback, client, serverBase); }
/// <summary> /// Check if a property is tagged with a certain tag /// </summary> /// <param name="methodCallInfo">IMethodCallMessage</param> private void IsTaggedWith(MethodCallInfo methodCallInfo) { methodCallInfo.ReturnValue = false; if (_taggedProperties.TryGetValue(methodCallInfo.PropertyNameOf(0), out var tags)) { methodCallInfo.ReturnValue = tags.ContainsKey(methodCallInfo.Arguments[1]); } }
public void Equals_OtherNull_ReturnsFalse() { MethodCallInfo subject = CreateSubject(() => Console.WriteLine()); bool result = subject.Equals(default(MethodCallInfo)); Assert.IsFalse(result); }
public void Equals_OtherSameInstance_ReturnsTrue() { MethodCallInfo subject = CreateSubject(() => Console.WriteLine()); bool result = subject.Equals(subject); Assert.IsTrue(result); }
public static ValueSet ToValueSet(this MethodCallInfo methodCall) { var set = new ValueSet { { FuncMethodBase64Key, methodCall.ToBase64BinaryString() }, }; return(set); }
public void Test_Two_Objects_With_The_Same_Arguments_Returns_The_Same_HashCode() { // Arrange var callInfo1 = new MethodCallInfo("Foo", new object[] { 1, "foo", 2.0 }); var callInfo2 = new MethodCallInfo("Foo", new object[] { 1, "foo", 2.0 }); // Assert Assert.AreEqual(callInfo1.GetHashCode(), callInfo2.GetHashCode()); }
public void Test_Two_Objects_With_The_Same_Arguments_Are_Equal() { // Arrange var callInfo1 = new MethodCallInfo("Foo", new object[] { 1, "foo", 2.0 }); var callInfo2 = new MethodCallInfo("Foo", new object[] { 1, "foo", 2.0 }); // Assert Assert.AreEqual(callInfo1, callInfo2); }
public void EqualsObject_OtherSameMethod_ReturnsTrue() { MethodCallInfo subject = CreateSubject(() => Console.WriteLine()); MethodCallInfo other = CreateSubject(() => Console.WriteLine()); bool result = subject.Equals((object)other); Assert.IsTrue(result); }
/// <summary> /// Bind a subscription to an event name, and prepare it for disposal. /// </summary> private void BindInnerHandler(MethodCallInfo eventToBind, Action <IList <JToken> > innerHandler) { var subscription = _proxy.Subscribe(eventToBind.MethodName); subscription.Received += innerHandler; DisposalActions.Add(() => { subscription.Received -= innerHandler; }); }
public void EqualsObject_OtherDifferentType_ReturnsFalse() { MethodCallInfo subject = CreateSubject(() => Console.WriteLine()); object other = new StringBuilder(); bool result = subject.Equals(other); Assert.IsFalse(result); }
public void EqualsObject_OtherDifferentMethod_ReturnsFalse() { MethodCallInfo subject = CreateSubject(() => Console.WriteLine()); MethodCallInfo other = CreateSubject(() => Console.ReadLine()); bool result = subject.Equals((object)other); Assert.IsFalse(result); }
internal static async Task <T> SendWebSocketDataWithCallClientServiceMethod <T>(ServerBase serverBase, ClientInfo client, Type returnType, string serviceName, string methodName, params Shared.Models.ParameterInfo[] args) { if (returnType == null || returnType == typeof(void)) { returnType = typeof(object); } else if (returnType.GetBaseType() == typeof(Task)) { returnType = returnType.GetGenericArguments()[0]; } if (methodName.LastIndexOf("Async", StringComparison.OrdinalIgnoreCase) == methodName.Length - 5) { methodName = methodName.Substring(0, methodName.Length - 5); } #if (NET35 || NET40) return(null);// Task<object>.Factory.StartNew(run); #else Type type = typeof(TaskCompletionSource <>).MakeGenericType(returnType); object taskCompletionSource = Activator.CreateInstance(type); MethodCallInfo callInfo = new MethodCallInfo(); callInfo.ServiceName = serviceName; callInfo.MethodName = methodName; callInfo.Parameters = args; string guid = Guid.NewGuid().ToString(); callInfo.Guid = guid; serverBase.ClientServiceCallMethodsResult.TryAdd(guid, new KeyValue <Type, object>(returnType, taskCompletionSource)); string json = ServerSerializationHelper.SerializeObject(callInfo, serverBase); ///when length is large we need to send data by parts if (json.Length > 30000) { List <string> listOfParts = WebSocketProvider.GeneratePartsOfData(json); int i = 1; foreach (string item in listOfParts) { MethodCallInfo cb = callInfo.Clone(); cb.PartNumber = i == listOfParts.Count ? (short)-1 : (short)i; json = (int)DataType.CallMethod + "," + (int)CompressMode.None + "/" + ServerSerializationHelper.SerializeObject(cb, serverBase); byte[] bytes = Encoding.UTF8.GetBytes(json); await client.StreamHelper.WriteToStreamAsync(client.ClientStream, bytes); i++; } } else { json = (int)DataType.CallMethod + "," + (int)CompressMode.None + "/" + json; byte[] bytes = Encoding.UTF8.GetBytes(json); await client.StreamHelper.WriteToStreamAsync(client.ClientStream, bytes); } object value = taskCompletionSource.GetType().GetProperty("Task").GetValue(taskCompletionSource, null); T result = await(Task <T>) value; return(result); #endif }
/// <summary> /// Return the default value for a property /// </summary> private static void GetDefaultValue(MethodCallInfo methodCallInfo) { var propertyInfo = typeof(T).GetProperty(methodCallInfo.PropertyNameOf(0)); // Prevent ArgumentNullExceptions if (propertyInfo != null) { methodCallInfo.ReturnValue = GetConvertedDefaultValue(propertyInfo); } }
public void RegisterClientServiceInterface(string serviceName) { MethodCallInfo callInfo = new MethodCallInfo() { ServiceName = serviceName, MethodName = "/RegisterService", Guid = Guid.NewGuid().ToString() }; var callback = this.SendData <MethodCallbackInfo>(callInfo); }
/// <summary> /// send data to connector /// </summary> /// <typeparam name="T">return type data</typeparam> /// <param name="connector">connetor for send data</param> /// <param name="callInfo">method for send</param> /// <returns></returns> internal static T SendData <T>(this ConnectorBase connector, MethodCallInfo callInfo) { var data = SendData(connector, callInfo, null); if (data == null || data.ToString() == "") { return(default(T)); } return(JsonConvert.DeserializeObject <T>(data.ToString())); }
public void RegisterStaticCall(MethodDescriptor callee, IList <PropGraphNodeDescriptor> arguments, VariableNode lhs, AnalysisCallNode callNode) { Contract.Requires(callee != null); Contract.Requires(callNode != null); Contract.Requires(arguments != null); var callExp = new MethodCallInfo(this.Method, callNode, callee, arguments, lhs, false); RegisterInvocation(arguments, callNode, callExp); }
/// <summary> /// Return the default value for a property /// </summary> private void RestoreToDefault(MethodCallInfo methodCallInfo) { var propertyInfo = typeof(T).GetProperty(methodCallInfo.PropertyNameOf(0)); // Prevent ArgumentNullExceptions if (propertyInfo == null) { return; } RestoreToDefault(methodCallInfo.Interceptor, propertyInfo, out var _); }
internal static async Task <T> SendData <T>(this ConnectorBase connector, MethodCallInfo callInfo) { string data = await SendDataAsync(connector, callInfo); #endif if (string.IsNullOrEmpty(data)) { return(default(T)); } return(ClientSerializationHelper.DeserializeObject <T>(data.ToString())); }
private void DecompileAndEnqueueCallees(CodeDescriptor cd, object instance, object[] arguments, MethodCallInfo mymci = null) { IPackageOrComponentDescriptor owner = cd.Owner as IPackageOrComponentDescriptor; var rmd = cd.Method.GetCustomOrInjectedAttribute<RewriteMethodDefinition>(); IDecompilationResult result; var md = cd as MethodDescriptor; var pd = cd as ProcessDescriptor; if (pd != null) _context.CurrentProcess = pd.Instance; else _context.CurrentProcess = md.CallingProcess.Instance; EVariability[] argVar; if (md == null) argVar = new EVariability[0]; else argVar = md.ArgVariabilities; if (rmd != null) { result = rmd.Rewrite(_context, cd, instance, arguments); } else if (cd.Method.IsMoveNext()) { var decomp = new AsyncMethodDecompiler(_context, cd, instance, arguments); result = decomp.Decompile(); cd.Implementation = result.Decompiled; cd.GenuineImplementation = result.Decompiled; } else { var decomp = new MSILDecompiler(cd, instance, arguments, argVar); if (cd is ProcessDescriptor) { decomp.Template.DisallowReturnStatements = true; } decomp.Template.DisallowConditionals = true; if (mymci != null) mymci.Inherit(decomp.Template); result = decomp.Decompile(); cd.Implementation = result.Decompiled; cd.GenuineImplementation = result.Decompiled; } foreach (var mci in result.CalledMethods) { _methodQ.Enqueue(mci); } foreach (var fri in result.ReferencedFields) { AnalyzeFieldRef(fri, cd); } _allMethods.Add(cd); }
private MethodDescriptor ConstructMethodDescriptor(MethodCallInfo mci, bool special) { MethodBase method = mci.GetStrongestOverride(); MethodDescriptor md = new MethodDescriptor( method, mci.EvaluatedArgumentsWithoutThis, special ? mci.ArgumentVariabilities : VariabilityPattern.CreateDefault(method).Pattern); var caller = mci.CallerTemplate.Decompilee; var callerPd = caller as ProcessDescriptor; var callerMd = caller as MethodDescriptor; if (callerPd != null) md.CallingProcess = callerPd; else md.CallingProcess = callerMd.CallingProcess; return md; }
public ExpertInfo(string discriminator, string handlerName, MethodCallInfo methodCallInfo) { this.Discriminator = discriminator; this.HandlerName = handlerName; this.MethodCallInfo = methodCallInfo; }
internal Setup(MethodCallInfo methodCall) : base(methodCall) { }
string GenerateProperty(IPropertySymbol property, MethodCallInfo changed, MethodCallInfo changing) { var setterModifier = property.SetMethod.DeclaredAccessibility.ToAccessibilityModifier(property.DeclaredAccessibility); var oldValueStorage = changed.NeedParameter ? $"var oldValue = base.{property.Name};".AddTabs(2) : null; return $@"public override {property.TypeDisplayString(model)} {property.Name} {{ get {{ return base.{property.Name}; }} {setterModifier}set {{ if(base.{property.Name} == value) return; {changing.MethodCall} {oldValueStorage} base.{property.Name} = value; RaisePropertyChanged(""{property.Name}""); {changed.MethodCall} }} }}"; }
private void Resolve(MethodCallInfo mci) { Function genericImpl; var md = ConstructMethodDescriptor(mci, false); if (md == null) return; object instance = mci.Instance; bool hasThis = md.Method.CallingConvention.HasFlag(CallingConventions.HasThis); if (hasThis) { if (instance != null) { var owner = instance as Component; if (owner == null) { ReportError("Method " + md.Method.Name + " is not declared inside a component."); } else { md.Owner = owner.Descriptor; } } else { ReportError("Method " + md.Method.Name + ": unable to resolve declaring component instance."); } } else { md.Owner = GetPackageDescriptor(md.Method.DeclaringType); } var key = new MethodKey(md); if (_methodMap.TryGetValue(key, out genericImpl)) { md.Implementation = genericImpl; } else { DecompileAndEnqueueCallees(md, instance, md.ArgValueSamples, mci); System.Diagnostics.Debug.Assert(md.Implementation != null); _methodMap[key] = md.Implementation; } System.Diagnostics.Debug.Assert(md.Implementation != null); if (md.Owner != null) md = md.Owner.Canonicalize(md); var mds = ConstructMethodDescriptor(mci, true); mds.Owner = md.Owner; DecompileAndEnqueueCallees(mds, instance, mds.ArgValueSamples, mci); System.Diagnostics.Debug.Assert(mds.Implementation != null); mci.Resolve(md, mds); }