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