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);
}
