private static Action <T1, T2, T3, T4, T5> fromJSMethod <T1, T2, T3, T4, T5>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value); Action <T1, T2, T3, T4, T5> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); JavaScriptValue p2 = converter.ToJSValue <T2>(para2); JavaScriptValue p3 = converter.ToJSValue <T3>(para3); JavaScriptValue p4 = converter.ToJSValue <T4>(para4); JavaScriptValue p5 = converter.ToJSValue <T5>(para5); node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; p1.AddRef(); p2.AddRef(); p3.AddRef(); p4.AddRef(); p5.AddRef(); value.CallFunction(caller, p1, p2, p3, p4, p5); p1.Release(); p2.Release(); p3.Release(); p4.Release(); p5.Release(); }); GC.KeepAlive(stub); //keep referenced javascript value alive }; return(result); }
private static IAsyncResult BeginMethod <T>(JavaScriptValue func, IServiceNode node, AsyncCallback callback, object state) { var conveter = node.GetService <IJSValueConverterService>(); var result = new AsyncResult <T>(); Action <T> fullfilledCallback = (x) => { result.SetResult(x); callback(result); }; Action <JavaScriptValue> rejectedCallback = (s) => { result.SetError(s); callback(result); }; Func <JSValue> promiseCall = conveter.FromJSValue <Func <JSValue> >(func); // the target function which returns a promise object JSValue promiseObject = promiseCall(); //call the function,get the Promise object var service = promiseObject.ServiceNode.GetService <PromiseCallbackPairService>(); //get the delegate interceptor service.Begin(); //enable the interceptor promiseObject.CallMethod("then", fullfilledCallback, rejectedCallback); System.Diagnostics.Debug.WriteLine("[Then] called"); service.End();//disable the interceptor return(result); }
private static Func <TResult> fromJSCallbackFunction <TResult>(IServiceNode node, JavaScriptValue value) { return(() => { return fromJSFunction <TResult>(node, value)(false); }); }
private static JavaScriptValue toJSMethod <T1, T2, T3, T4, T5, T6> (IServiceNode node, Action <T1, T2, T3, T4, T5, T6> a) { var converter = node.GetService <IJSValueConverterService>(); var jsValueService = node.GetService <IJSValueService>(); JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) => { if (argumentCount != 7) { throw new InvalidOperationException("call from javascript did not pass enough parameters"); } T1 para1 = converter.FromJSValue <T1>(arguments[1]); T2 para2 = converter.FromJSValue <T2>(arguments[2]); T3 para3 = converter.FromJSValue <T3>(arguments[3]); T4 para4 = converter.FromJSValue <T4>(arguments[4]); T5 para5 = converter.FromJSValue <T5>(arguments[5]); T6 para6 = converter.FromJSValue <T6>(arguments[6]); arguments[1].AddRef(); arguments[2].AddRef(); arguments[3].AddRef(); arguments[4].AddRef(); arguments[5].AddRef(); arguments[6].AddRef(); a(para1, para2, para3, para4, para5, para6); arguments[1].Release(); arguments[2].Release(); arguments[3].Release(); arguments[4].Release(); arguments[5].Release(); arguments[6].Release(); return(jsValueService.JSValue_Undefined); }; return(jsValueService.CreateFunction(f, IntPtr.Zero)); }
private static Action <T1, T2, T3, T4, T5> fromJSMethod <T1, T2, T3, T4, T5>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); Action <T1, T2, T3, T4, T5> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); JavaScriptValue p2 = converter.ToJSValue <T2>(para2); JavaScriptValue p3 = converter.ToJSValue <T3>(para3); JavaScriptValue p4 = converter.ToJSValue <T4>(para4); JavaScriptValue p5 = converter.ToJSValue <T5>(para5); node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; p1.AddRef(); p2.AddRef(); p3.AddRef(); p4.AddRef(); p5.AddRef(); value.CallFunction(caller, p1, p2, p3, p4, p5); p1.Release(); p2.Release(); p3.Release(); p4.Release(); p5.Release(); }); }; return(result); }
private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); var jsValueService = node.GetService <IJSValueService>(); var callContext = node.GetService <ICallContextService>(); IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value); Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); JavaScriptValue r = node.WithContext <JavaScriptValue>(() => { p1.AddRef(); JavaScriptValue resultValue; if (isConstruct) { resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1); } else { resultValue = jsValueService.CallFunction(value, callContext.Caller, p1); } p1.Release(); GC.KeepAlive(stub);//keep referenced javascript value alive return(resultValue); }); return(converter.FromJSValue <TResult>(r)); }; return(result); }
public static void InjectShareMemoryObjects(this IServiceNode target) { //create/release all these objects inside the runtime internal context, this make sure all objects can be destroyed even user context is released var converter = target.GetService <IJSValueConverterService>(); //var switchService = target.ServiceNode.GetService<IRuntimeService>().InternalContextSwitchService; if (converter.CanConvert <JSArrayBuffer>()) { return; } converter.RegisterConverter <JSArrayBuffer>( (node, value) => { var jsValueService = node.GetService <IJSValueService>(); return(jsValueService.CreateArrayBuffer(value)); }, (node, value) => { var switchService = node.GetService <IRuntimeService>().InternalContextSwitchService; return(switchService.With <JSArrayBuffer>(() => { if (value.ValueType != JavaScriptValueType.ArrayBuffer) { throw new InvalidOperationException("source type should be ArrayBuffer"); } IntPtr buffer = JavaScriptValue.GetArrayBufferStorage(value, out uint size); var result = JSArrayBuffer.CreateFromJS(buffer, size, value, switchService); return result; })); }, false
private static JavaScriptValue toJSFunction <T1, T2, T3, T4, T5, TResult> (IServiceNode node, Func <bool, T1, T2, T3, T4, T5, TResult> callback) { var converter = node.GetService <IJSValueConverterService>(); JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) => { if (argumentCount != 6) { throw new InvalidOperationException("call from javascript did not pass enough parameters"); } T1 para1 = converter.FromJSValue <T1>(arguments[1]); T2 para2 = converter.FromJSValue <T2>(arguments[2]); T3 para3 = converter.FromJSValue <T3>(arguments[3]); T4 para4 = converter.FromJSValue <T4>(arguments[4]); T5 para5 = converter.FromJSValue <T5>(arguments[5]); arguments[1].AddRef(); arguments[2].AddRef(); arguments[3].AddRef(); arguments[4].AddRef(); arguments[5].AddRef(); TResult result = callback(isConstructCall, para1, para2, para3, para4, para5); arguments[1].Release(); arguments[2].Release(); arguments[3].Release(); arguments[4].Release(); arguments[5].Release(); return(converter.ToJSValue <TResult>(result)); }; return(node.GetService <IJSValueService>().CreateFunction(f, IntPtr.Zero)); }
public JSValue(IServiceNode parentNode, JavaScriptValue value) : base(parentNode, "JSValue") { ReferenceValue = value; ServiceNode.PushService <ICallContextService>(new CallContextService(value)); //inject service Binding = new JSValueBinding(ServiceNode, value);//binding will create a branch of current service node to persistent hold all delegates created by binding function }
public void AddServiceNode(IServiceNode serviceNode) { lock (this.locker) { if (this.ServiceNodes.Contains(serviceNode)) { this.Logger.LogTrace("(-)[ALREADY_EXISTS]"); return; } // Remove any that have a matching collateral address BitcoinAddress serviceNodeCollateralAddress = serviceNode.GetCollateralAddress(this.network); var nodesWithMatchingPubKeys = this.ServiceNodes.Where(sn => sn.GetCollateralAddress(this.network) == serviceNodeCollateralAddress).ToList(); foreach (IServiceNode matchingNode in nodesWithMatchingPubKeys) { this.ServiceNodes.Remove(matchingNode); } // Add new one this.ServiceNodes.Add(serviceNode); SaveServiceNodes(); SetIsServiceNode(); this.Logger.LogInformation("Federation member '{0}' was added!", serviceNode); // Publish events foreach (IServiceNode node in nodesWithMatchingPubKeys) { this.signals.Publish(new ServiceNodeRemoved(serviceNode)); } this.signals.Publish(new ServiceNodeAdded(serviceNode)); } }
//private async Task CheckCollateralAsync(int height) //{ // foreach (IServiceNode serviceNode in this.serviceNodeManager.GetServiceNodes()) // { // try // { // Script scriptToCheck = BitcoinAddress.Create(serviceNode.RegistrationRecord.Token.ServerId, this.network).ScriptPubKey; // Money serverCollateralBalance = // //await this.blockStoreClient.GetAddressBalanceAsync(registractionRecord.Token.ServerId, 1); // this.addressIndexer.GetAddressBalance(serviceNode.RegistrationRecord.Token.ServerId, 1); // this.logger.LogDebug("Collateral balance for server " + serviceNode.RegistrationRecord.Token.ServerId + " is " + // serverCollateralBalance.ToString() + ", original registration height " + // serviceNode.RegistrationRecord.BlockReceived + ", current height " + height); // if ((serverCollateralBalance.ToUnit(MoneyUnit.BTC) < this.network.Consensus.ServiceNodeCollateralThreshold) && // ((height - serviceNode.RegistrationRecord.BlockReceived) > this.network.Consensus.ServiceNodeCollateralBlockPeriod)) // { // // Remove server registrations as funding has not been performed within block count, // // or funds have been removed from the collateral address subsequent to the // // registration being performed // this.logger.LogDebug("Insufficient collateral within window period for server: " + serviceNode.RegistrationRecord.Token.ServerId); // this.logger.LogDebug("Deleting registration records for server: " + serviceNode.RegistrationRecord.Token.ServerId); // this.serviceNodeManager.RemoveServiceNode(serviceNode); // // TODO: Need to make the TumbleBitFeature change its server address if this is the address it was using // } // } // catch (Exception e) // { // this.logger.LogError("Error calculating server collateral balance: " + e); // } // } //} public bool CheckCollateral(IServiceNode serviceNode) { lock (this.locker) { return(this.depositsByServerId[serviceNode.ServerId] >= this.network.Consensus.ServiceNodeCollateralThreshold); } }
private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); var jsValueService = node.GetService <IJSValueService>(); var callContext = node.GetService <ICallContextService>(); Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); JavaScriptValue r = node.WithContext <JavaScriptValue>(() => { p1.AddRef(); JavaScriptValue resultValue; if (isConstruct) { resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1); } else { resultValue = jsValueService.CallFunction(value, callContext.Caller, p1); } p1.Release(); return(resultValue); }); return(converter.FromJSValue <TResult>(r)); }; return(result); }
private static JavaScriptValue toJSCallbackFunction <TResult> (IServiceNode node, Func <TResult> callback) { return(toJSFunction <TResult>(node, (b) => { return callback(); } )); }
private static JavaScriptValue toJSCallbackFunction <T1, T2, T3, TResult> (IServiceNode node, Func <T1, T2, T3, TResult> callback) { return(toJSFunction <T1, T2, T3, TResult>(node, (b, para1, para2, para3) => { return callback(para1, para2, para3); } )); }
public static void InjecTimerService(this IServiceNode target) { target.GetService <IJSValueConverterService>().RegisterProxyConverter <JSTimer>((binding, value, node) => { binding.SetMethod <Action, int>("setTimeout", value.SetTimeout); binding.SetFunction <Action, int, Guid>("setInterval", value.SetInterval); binding.SetMethod <Guid>("clearInterval", value.ClearInterval); }); }
public static void InjectTaskService(this IServiceNode target) { if (target.CanGetService <PromiseCallbackPairService>()) { return; } PromiseCallbackPairService service = new PromiseCallbackPairService(); target.PushService(service); }
public JSValue(IServiceNode parentNode, JavaScriptValue value) : base(parentNode, "JSValue") { ReferenceValue = value; ServiceNode.PushService <ICallContextService>(new CallContextService(value)); //inject service Binding = new JSValueBinding(ServiceNode, value);//binding will create a branch of current service node to persistent hold all delegates created by binding function //add my own one time delegate handler for method/function call ServiceNode.PushService <INativeFunctionHolderService>(new NativeFunctionHolderService(true)); }
public IHub <T> Undeploy(IServiceNode <T> serviceNode) { serviceNode.Stop(); if (_services.Contains(serviceNode)) { _services.Remove(serviceNode); } return(this); }
public IHub <T> Deploy(IServiceNode <T> serviceNode) { _services.Add(serviceNode); if (_state == State.Started) { serviceNode.Start(_messageBus); } return(this); }
private static JavaScriptValue ToJSMethod(IServiceNode node, Action <IEnumerable <JavaScriptValue> > a) { IJSValueService jsValueService = node.GetService <IJSValueService>(); return(jsValueService.CreateFunction( (JavaScriptNativeFunction)((callee, isConstructCall, arguments, argumentCount, callbackData) => { a(arguments.Skip(1)); return jsValueService.JSValue_Undefined; }), IntPtr.Zero)); }
private ChakraRuntime(JavaScriptRuntime runtime, IServiceNode service, EventWaitHandle syncHandler) : base(service, "ChakraRuntime") { this.runtime = runtime; SyncHandler = syncHandler; runtimeService = new RuntimeService(runtime); //inject service ServiceNode.PushService(runtimeService); ServiceNode.PushService <IJSValueConverterService>(converter); ServiceNode.PushService <IJSValueService>(new JSValueService()); ServiceNode.InjectShareMemoryObjects(); ServiceNode.InjecTimerService(); converter.RegisterTask(); }
public void RemoveServiceNode(IServiceNode serviceNode) { lock (this.locker) { this.ServiceNodes.Remove(serviceNode); SaveServiceNodes(); SetIsServiceNode(); this.Logger.LogInformation("Federation member '{0}' was removed!", serviceNode); this.signals.Publish(new ServiceNodeRemoved(serviceNode)); } }
private static Action fromJSMethod(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); Action result = () => { node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; value.CallFunction(caller); }); }; return(result); }
private static Action fromJSMethod(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value); Action result = () => { node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; value.CallFunction(caller); }); GC.KeepAlive(stub); //keep referenced javascript value alive }; return(result); }
public virtual TResult GetService <TResult>(IServiceNode currentNode) where TResult : IService { if (tryGetService <TResult>(out TResult result)) { result.CurrentNode = currentNode; return(result); } else { if (Parent != null) { var r = Parent.GetService <TResult>(currentNode); //PushService<TResult>(r);//cache the service instace r.CurrentNode = currentNode; return(r); } throw new ServiceNotRegisteredException <TResult>(); } }
private static JavaScriptValue toJSFunction <TResult> (IServiceNode node, Func <bool, TResult> callback) { var converter = node.GetService <IJSValueConverterService>(); JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) => { if (argumentCount != 1) { throw new InvalidOperationException("call from javascript did not pass enough parameters"); } TResult result = callback(isConstructCall); return(converter.ToJSValue <TResult>(result)); }; return(node.GetService <IJSValueService>().CreateFunction(f, IntPtr.Zero)); }
private static Action <T1> fromJSMethod <T1>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); Action <T1> result = (T1 para1) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; p1.AddRef(); value.CallFunction(caller, p1); p1.Release(); }); }; return(result); }
private static JavaScriptValue toJSMethod(IServiceNode node, Action a) { var converter = node.GetService <IJSValueConverterService>(); var jsValueService = node.GetService <IJSValueService>(); JavaScriptNativeFunction f = (callee, isConstructCall, arguments, argumentCount, callbackData) => { if (argumentCount != 1) { throw new InvalidOperationException("call from javascript did not pass enough parameters"); } a(); return(jsValueService.JSValue_Undefined); }; return(jsValueService.CreateFunction(f, IntPtr.Zero)); }
private static Action <T1> fromJSMethod <T1>(IServiceNode node, JavaScriptValue value) { var converter = node.GetService <IJSValueConverterService>(); IDisposable stub = node.GetService <IGCSyncService>().CreateJsGCWrapper(value); Action <T1> result = (T1 para1) => { JavaScriptValue p1 = converter.ToJSValue <T1>(para1); node.WithContext(() => { var caller = node.GetService <ICallContextService>().Caller; p1.AddRef(); value.CallFunction(caller, p1); p1.Release(); }); GC.KeepAlive(stub); //keep referenced javascript value alive }; return(result); }
private static IAsyncResult BeginMethod <T>(JavaScriptValue promiseObject, IServiceNode node, AsyncCallback callback, object state) { var converter = node.GetService <IJSValueConverterService>(); var valueService = node.GetService <IJSValueService>(); var result = new AsyncResult <T>(); Action <T> fullfilledCallback = (x) => { result.SetResult(x); callback(result); }; Action <JavaScriptValue> rejectedCallback = (s) => { try { valueService.ThrowIfErrorValue(s); } catch (JavaScriptFatalException ex) { result.SetError(ex.Message); } if (s.ValueType == JavaScriptValueType.String) { result.SetError(s.ToString()); } else { result.SetError(string.Empty); } callback(result); }; var pObj = converter.FromJSValue <JSValue>(promiseObject); pObj.CallMethod("then", fullfilledCallback, rejectedCallback); System.Diagnostics.Debug.WriteLine("[Then] called"); return(result); }