public static IServiceChecker CreateServiceChecker(ServiceDef serviceDef)
{
if (serviceDef.Port == null)
{
return(new HttpServiceChecker(serviceDef.Host));
}
return(new TcpServiceChecker(serviceDef.Host, serviceDef.Port.Value));
}
public ServiceDef ParseDefinition(string serviceDefintion)
{
var ServiceDefinition = new ServiceDef();
JObject o = JObject.Parse(serviceDefintion);
var ModelDef = o["definitions"];
ServiceDefinition.ModelDefinitions = ParseModelDefs(ModelDef);
var Paths = o["paths"];
ServiceDefinition.Paths = ParsePathDefs(Paths);
return(ServiceDefinition);
}
public Task Write(DateTime timestamp, ServiceDef serviceDef, CheckResult r)
{
return(Task.Run(() => {
StorageElement sEl = new StorageElement()
{
Id = Guid.NewGuid().ToString(),
ServiceName = serviceDef.Name,
Timestamp = timestamp,
Status = r.Status,
LastError = r.LastError == null? null : r.LastError.Message
};
File.AppendAllText(_strFileFullPath, JsonConvert.SerializeObject(sEl) + Environment.NewLine);
}));
}
private static ContractInterface CreateInterfaceContract(ServiceDef owner, Type type)
{
if (!interfacedefs.TryGetValue(type, out ContractInterface contract))
{
var mm = type.GetMethods().Where(_m => _m.GetCustomAttributes <ContractAttribute>().Any());
contract = new ContractInterface()
{
Owner = owner,
Type = type
};
contract.Methods = mm.Select(_m => CreateMethodContract(contract, _m)).ToArray();
interfacedefs[type] = contract;
}
return(contract);
}
public static ServiceDef GetServiceDefinition(Type type)
{
using (ReadLock(lockobj))
{
if (!servicedefs.TryGetValue(type, out ServiceDef service))
{
var interfaces = _GetInterfaces(type).Where(_t => _t.GetCustomAttributes <ContractAttribute>().Any()).ToList();
if (type.IsInterface)
{
interfaces.Insert(0, type);
}
service = new ServiceDef()
{
Type = type
};
var l = interfaces.Select(_t => CreateInterfaceContract(service, _t)).ToList();
if (!type.IsInterface)
{
l.Insert(0, CreateInterfaceContract(service, type));
}
service.Contracts = l.ToArray();// interfaces.Select(_t => CreateInterfaceContract(service, _t)).ToArray();
ServicesFactory.CheckDataContracts(service);
var cookie = lockobj.UpgradeToWriterLock(-1);
try
{
servicedefs[type] = service;
}
catch { throw; }
finally
{
lockobj.DowngradeFromWriterLock(ref cookie);
}
}
return(service);
}
}
public void UseRServiceIo__AddsRoutesToRouting()
{
IRouteBuilder routeBuilder = null;
var route = new RouteAttribute("/Foobar");
var def = new ServiceDef { Route = route };
var services = new ServiceCollection();
services.AddRServiceIo(EmptyRServieOptions, EmptyRouteOptions);
var builder = BuildApplicationBuilder(services);
var service = builder.ApplicationServices.GetService<RService>();
service?.Routes.Add(route.Path, def);
builder.UseRServiceIo(x =>
{
routeBuilder = x;
});
routeBuilder.Should().NotBeNull();
var actualRoutes = GetRouteTemplates((RouteBuilder) routeBuilder)
.FirstOrDefault(x => x.RouteTemplate.Equals(route.Path.Substring(1)));
actualRoutes.Should().NotBeNull();
}
public static Compilation Compile <TOwner, T>(ServiceDef servicedef) // TOwner has _Call,_CallAsync to invoke, T is interface/class to communiate with, creates Type for class derived from T
{
using (WriteLock(lockobj))
{
if (!compiledtypes.TryGetValue(typeof(T), out Compilation wrapper))
{
Type t = typeof(T);
var assemblyname = new AssemblyName(Guid.NewGuid().ToString());
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyname, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
bool isclass = t.IsClass;
TypeBuilder typeBuilder = moduleBuilder.DefineType($"_{t.FullName.Replace(".", "_")}"
, TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit |
TypeAttributes.AutoLayout
, isclass?t:null);
if (!isclass)
{
typeBuilder.AddInterfaceImplementation(t);
}
var _methods = typeBuilder.DefineField("methods", typeof(ContractMethod[]), FieldAttributes.Private);
var _owner = typeBuilder.DefineField("owner", typeof(TOwner), FieldAttributes.Private);
MethodInfo _invoke = typeof(TOwner).GetMethod("_Call");
MethodInfo _invokeasync = typeof(TOwner).GetMethod("_CallAsync");
{
ConstructorBuilder cb = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(TOwner), typeof(ContractMethod[]) });
var il = cb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
if (isclass)
{
il.Emit(OpCodes.Call, typeof(T).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null));
}
else
{
il.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, _owner);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld, _methods);
il.Emit(OpCodes.Ret);
}
var mm = servicedef.Methods;
for (int nit = 0; nit < mm.Length; nit++)
{
var m = mm[nit].MethodInfo;
var pp = m.GetParameters();
var mb = typeBuilder.DefineMethod(m.Name, MethodAttributes.Public | MethodAttributes.Virtual, m.ReturnType, pp.Select(_p => _p.ParameterType).ToArray());
var il = mb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _owner);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _methods);
Ldc_i4_x(il, nit); // method-#
il.Emit(OpCodes.Ldelem_Ref);
Ldc_i4_x(il, pp.Length);
il.Emit(OpCodes.Newarr, typeof(object));
for (int pc = 0; pc < pp.Length; pc++)
{
il.Emit(OpCodes.Dup);
Ldc_i4_x(il, pc);
LdArg(il, pc + 1);
if (pp[pc].ParameterType.IsPrimitive || pp[pc].ParameterType.IsEnum)
{
il.Emit(OpCodes.Box, pp[pc].ParameterType);
}
il.Emit(OpCodes.Stelem_Ref);
}
if (m.ReturnType.IsDerived(typeof(Task)))
{
il.Emit(OpCodes.Callvirt, _invokeasync);
}
else
{
il.Emit(OpCodes.Callvirt, _invoke);
if (m.ReturnType == typeof(void))
{
il.Emit(OpCodes.Pop);
}
else
{
if (m.ReturnType.IsPrimitive || m.ReturnType.IsEnum)
{
il.Emit(OpCodes.Unbox_Any, m.ReturnType);
}
else
{
il.Emit(OpCodes.Castclass, m.ReturnType);
}
}
}
il.Emit(OpCodes.Ret);
}
var info = typeBuilder.CreateTypeInfo();
var type = info.AsType();
wrapper = new Compilation()
{
Type = type,
Methods = mm
};
compiledtypes[typeof(T)] = wrapper;
}
return(wrapper);
}
}
private static void CheckDataContracts(ServiceDef service)
{
_CheckDataContracts(service.Methods.Select(_m => _m.ReturnContract));
_CheckDataContracts(service.Methods.SelectMany(_m => _m.Parameters));
}
public async Task <object> ConnectService(Transport c, string url, string username = null, object credentials = null, string objecttype = null, CancellationToken cancel = default(CancellationToken))
{
this.connecturl = url;
this.connecttransport = c;
var u = TransportUtil.ParseConnectionUrl(url);
m_RemoteNodeID = u.nodeid;
m_RemoteNodeName = u.nodename;
m_ServiceName = u.service;
//ProgramName = ProgramName1;
/* try
* {*/
//if (RobotRaconteurService.s.transports[c] == null) return null;
if (!c.CanConnectService(url))
{
throw new ServiceException("Invalid transport");
}
TransportConnection = await c.CreateTransportConnection(url, this, cancel);
m_Connected = true;
try
{
transport = c.TransportID;
m_RemoteEndpoint = 0;
ServiceDefinition[] d = await PullServiceDefinitionAndImports(null, cancel : cancel);
lock (pulled_service_defs)
{
foreach (var d2 in d)
{
if (!pulled_service_defs.ContainsKey(d2.Name))
{
pulled_service_defs.Add(d2.Name, d2);
}
}
}
if (!UsePulledServiceTypes)
{
m_ServiceDef = node.GetServiceType(d[0].Name);
}
else
{
var f = DynamicServiceFactory_.CreateServiceFactories(d.Select(x => x.ToString()).ToArray(), this);
lock (pulled_service_defs)
{
foreach (var f2 in f)
{
if (!pulled_service_types.ContainsKey(f2.GetServiceName()))
{
pulled_service_types.Add(f2.GetServiceName(), f2);
}
}
}
m_ServiceDef = GetPulledServiceType(d[0].Name);
}
MessageEntry e = new MessageEntry(MessageEntryType.ObjectTypeName, "");
//e.AddElement("servicepath", ServiceName);
e.ServicePath = ServiceName;
MessageEntry ret = await ProcessRequest(e, cancel);
if (ret.Error != MessageErrorType.None)
{
return(null);
}
string type = ret.FindElement("objecttype").CastData <string>();
if (type == "")
{
return(new ObjectNotFoundException("Could not find object type"));
}
;
if (objecttype != null)
{
VerifyObjectImplements(type, objecttype);
type = objecttype;
await PullServiceDefinitionAndImports(ServiceDefinitionUtil.SplitQualifiedName(type).Item2, cancel);
}
MessageEntry e2 = new MessageEntry();
e2.ServicePath = ServiceName;
e2.MemberName = "registerclient";
e2.EntryType = MessageEntryType.ConnectClient;
await ProcessRequest(e2, cancel);
if (username != null)
{
await AuthenticateUser(username, credentials, cancel);
}
ServiceStub stub = ServiceDef.CreateStub(type, ServiceName, this);
stubs.Add(ServiceName, stub);
Task noop = PeriodicTask.Run(PeriodicCleanupTask, TimeSpan.FromSeconds(5), cancel_source.Token).IgnoreResult();
return(stub);
}
catch (Exception e)
{
try
{
TransportConnection.Close();
}
catch { }
m_Connected = false;
throw e;
}
/*}
* catch {
* return null;
* }*/
}
private static ControllerCompilation Compile <T>(ServiceDef servicedef)
{
if (!compiledtypes.TryGetValue(typeof(T), out ControllerCompilation wrapper))
{
Type t = typeof(T);
var assemblyname = new AssemblyName(Guid.NewGuid().ToString());
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyname, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
TypeBuilder typeBuilder = moduleBuilder.DefineType($"{t.FullName}Controller"
, TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit |
TypeAttributes.AutoLayout
, typeof(ControllerBase));
foreach (var a in t.GetCustomAttributes(true))
{
if (a is RouteAttribute)
{
var ca = new CustomAttributeBuilder(a.GetType().GetConstructor(new Type[] { typeof(string) }), new object[] { (a as RouteAttribute).Template });
typeBuilder.SetCustomAttribute(ca);
}
}
var _services = typeBuilder.DefineField("_services", typeof(ISimpleServicesFactory), FieldAttributes.Private);
{
ConstructorBuilder cb = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(ISimpleServicesFactory) });
var il = cb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeof(ControllerBase).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, _services);
il.Emit(OpCodes.Ret);
}
var mm = servicedef.Methods;
for (int nit = 0; nit < mm.Length; nit++)
{
var m = mm[nit].MethodInfo;
// var pp = m.GetParameters();
var mb = typeBuilder.DefineMethod(m.Name, MethodAttributes.Public /*| MethodAttributes.Virtual*/, typeof(IActionResult), new Type[0] /* pp.Select(_p => _p.ParameterType).ToArray() */);
var il = mb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _services);
il.Emit(OpCodes.Ldarg_0);
var mi = typeof(ISimpleServicesFactory).GetMethods().Single(_m => _m.Name == "CheckRequest" && _m.GetGenericArguments().Length == 1);
var mi2 = mi.MakeGenericMethod(typeof(T));
il.Emit(OpCodes.Callvirt, mi2);
// il.Emit(OpCodes.Ldstr, "info");
// il.Emit(OpCodes.Newobj, typeof(OkObjectResult).GetConstructor(new Type[] { typeof(object) }));
// il.Emit(OpCodes.Stloc_0);
// il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
}
var info = typeBuilder.CreateTypeInfo();
var type = info.AsType();
wrapper = new ControllerCompilation()
{
Type = type,
Methods = mm
};
compiledtypes[typeof(T)] = wrapper;
}
return(wrapper);
}
private static ControllerCompilation Compile2(ServiceDef servicedef, Type t) // PROTO4
{
if (!compiledtypes.TryGetValue(t, out ControllerCompilation wrapper))
{
var assemblyname = new AssemblyName(Guid.NewGuid().ToString());
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyname, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
TypeBuilder typeBuilder = moduleBuilder.DefineType($"{t.FullName}Controller"
, TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit |
TypeAttributes.AutoLayout
, typeof(Internals.ServiceControllerBase));
foreach (var a in t.GetCustomAttributes(true))
{
if (a is RouteAttribute)
{
var ca = new CustomAttributeBuilder(a.GetType().GetConstructor(new Type[] { typeof(string) }), new object[] { (a as RouteAttribute).Template });
typeBuilder.SetCustomAttribute(ca);
}
if (a is AuthorizeAttribute)
{
var aa = a as AuthorizeAttribute;
var ca = new CustomAttributeBuilder(a.GetType().GetConstructor(new Type[0]), new object[0],
new PropertyInfo[] { a.GetType().GetProperty("Policy"), a.GetType().GetProperty("Roles"), a.GetType().GetProperty("AuthenticationSchemes") },
new object[] { aa.Policy, aa.Roles, aa.AuthenticationSchemes });
typeBuilder.SetCustomAttribute(ca);
}
if (a is AllowAnonymousAttribute)
{
var aa = a as AllowAnonymousAttribute;
var ca = new CustomAttributeBuilder(a.GetType().GetConstructor(new Type[0]), new object[0]);
typeBuilder.SetCustomAttribute(ca);
}
}
var oc = t.GetConstructors().SingleOrDefault();
var pp = oc.GetParameters();
// var _services = typeBuilder.DefineField("_services", typeof(ISimpleServicesFactory), FieldAttributes.Private);
var _controller = typeBuilder.DefineField("_controller", t, FieldAttributes.Private);
{
var _methods = typeof(Internals.ServiceControllerBase).GetField("_methods", BindingFlags.NonPublic | BindingFlags.Instance);
ConstructorBuilder cb = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.Standard, pp.Select(_p => _p.ParameterType).ToArray());
var il = cb.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeof(Internals.ServiceControllerBase).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null));
il.Emit(OpCodes.Ldarg_0);
for (int nit = 0; nit < pp.Length; nit++)
{
LdArg(il, nit + 1);
}
il.Emit(OpCodes.Newobj, t.GetConstructors().Single());
il.Emit(OpCodes.Stfld, _controller);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldtoken, t);
il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Public | BindingFlags.Static));
il.Emit(OpCodes.Call, typeof(SimpleServicesFactory).GetMethod("GetMethods", new Type[] { typeof(Type) }));
il.Emit(OpCodes.Stfld, _methods);
il.Emit(OpCodes.Ret);
}
// ConstructorBuilder cb2 = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.Standard, new Type[0]);
// var ils = cb2.GetILGenerator();
var mm = SimpleServicesFactory.GetMethods(t);
var done = Enumerable.Repeat(false, mm.Length).ToArray();
for (int nit = 0; nit < mm.Length; nit++)
{
if (!done[nit])
{
var themethods = mm.Skip(nit).Where(_m => mm[nit].Contract.Name == _m.Contract.Name).OrderBy(_m => _m.Order).ToArray();
var getm = themethods.Where(_m => _m.Get).ToArray();
var postm = themethods.Where(_m => _m.Post).ToArray();
if (getm.Length > 1 || postm.Length > 1)
{
throw new AmbiguousMatchException();
}
if (getm.FirstOrDefault() == postm.FirstOrDefault())
{
var ind = Array.IndexOf(mm, getm.First());
MakeMethod(typeBuilder, null, mm, ind, _controller);
}
else
{
if (getm.Any())
{
var ind = Array.IndexOf(mm, getm.First());
MakeMethod(typeBuilder, "GET", mm, ind, _controller);
}
if (postm.Any())
{
var ind = Array.IndexOf(mm, postm.First());
MakeMethod(typeBuilder, "POST", mm, ind, _controller);
}
}
string url;// = m.MethodInfo.GetCustomAttributes<HttpMethodAttribute>().FirstOrDefault()?.Template;
// if ((url?.Length ?? 0) == 0)
{
url = mm[nit].Contract.Name;
}
/* var n = "_static" + mm[nit].Contract.Name;
* var _static = typeBuilder.DefineField(n, typeof(int[]), FieldAttributes.Static|FieldAttributes.Private);
*
* Ldc_i4_x(ils, themethods.Length);
* ils.Emit(OpCodes.Newarr, typeof(int));
* ils.Emit(OpCodes.Stsfld, _static);
*
* for (int g = 0; g < themethods.Count(); g++)
* {
* var ind = Array.IndexOf(mm, themethods.Skip(g).First());
*
* ils.Emit(OpCodes.Ldsfld, _static);
* Ldc_i4_x(ils, g);
* Ldc_i4_x(ils, ind);
* ils.Emit(OpCodes.Stelem_I4);
* done[ind] = true;
* }*/
}
}
// ils.Emit(OpCodes.Ret);
var info = typeBuilder.CreateTypeInfo();
var type = info.AsType();
wrapper = new ControllerCompilation()
{
Type = type,
Methods = servicedef.Methods
};
compiledtypes[t] = wrapper;
}
return(wrapper);
}
public Task Write(DateTime timestamp, ServiceDef serviceDef, CheckResult r)
{
// Default implementation does nothing
return(Task.CompletedTask);
}
async Task MainAsync()
{
string Definition = await NDAServiceSystem.GetService().RetrieveDefinition();
ServiceDefinition = NDAServiceSystem.GetParser().ParseDefinition(Definition);
}
