public static void Start(string[] args) { var bootServices = Management.GetClassesByInterface<IServiceDefinition>(); if (!bootServices.Any()) return; Service = bootServices[0].CreateInstance<IServiceDefinition>(); Main(args); }
public void CopyFrom(IServiceDefinition copyFrom) { if (copyFrom == null) { return; } var svcDef = copyFrom as ServiceDefinition; if (svcDef != null) { Entities.AddRange(svcDef.Entities); Operations.AddRange(svcDef.Operations); return; } Entities.AddRange( copyFrom.Enums .SelectMany(x => x) .Select(x => new EnumDefinition(x)) ); Entities.AddRange( copyFrom.Models .SelectMany(x => x) .Select(x => new ModelDefinition(x)) ); Operations.AddRange( copyFrom.ResourceOperations .SelectMany(x => x) .Select(x => new OperationDefinition(x)) ); }
private IConfiguration ComposeConfiguration(IServiceDefinition serviceDefinition, PrimitiveType primitiveType, string sectionName, bool forceExternal) { var sections = new List <IConfigurationSection>(6); var serviceCategory = forceExternal || serviceDefinition.Type == ServiceType.External ? ServiceCategory.External : ServiceCategory.Local; // [base] var key = new ConfigurationSectionKey { SectionName = sectionName }; if (TryGetSection(key, out var section)) { sections.Add(section); } // [primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out section)) { sections.Add(section); } // [service category] key.PrimitiveType = PrimitiveType.Any; key.ServiceCategory = serviceCategory; if (TryGetSection(key, out section)) { sections.Add(section); } // [service category + primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out section)) { sections.Add(section); } // [service] key.ServiceCategory = ServiceCategory.Any; key.PrimitiveType = PrimitiveType.Any; key.ServiceName = serviceDefinition.Name; if (TryGetSection(key, out section)) { sections.Add(section); } // [service + primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out section)) { sections.Add(section); } return(CombineSections(sections)); }
private ConfigOverrideLevels GetOverrideLevels(IServiceDefinition serviceDefinition, PrimitiveType primitiveType, string sectionName, bool forceExternal) { var result = ConfigOverrideLevels.None; var serviceCategory = forceExternal || serviceDefinition.Type == ServiceType.External ? ServiceCategory.External : ServiceCategory.Local; // [base] var key = new ConfigurationSectionKey { SectionName = sectionName }; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.Base; } // [primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.BasePrimitives; } // [service category] key.PrimitiveType = PrimitiveType.Any; key.ServiceCategory = serviceCategory; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.ServiceType; } // [service category + primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.ServiceTypePrimitives; } // [service] key.ServiceCategory = ServiceCategory.Any; key.PrimitiveType = PrimitiveType.Any; key.ServiceName = serviceDefinition.Name; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.Service; } // [service + primitive type] key.PrimitiveType = primitiveType; if (TryGetSection(key, out _)) { result |= ConfigOverrideLevels.Primitive; } return(result); }
public async Task Register(IServiceDefinition service) { var registration = new AgentServiceRegistration() { Name = service.Name() }; await _client.Agent.ServiceRegister(registration); }
public async Task <IEnumerable <IMessageListener> > StartListeningAsync( IConfiguration configuration, IServiceDefinition serviceDefinition, IDictionary <IMethodDefinition, IConfiguration> methodConfigMap, CancellationToken ct) { await _sinleListener.StartAsync(ct); return(new[] { _sinleListener }); }
private async Task StartListeningEventsAsync( string communicationType, IServiceDefinition serviceDefinition, IConfiguration configuration, Dictionary <IEventDefinition, IConfiguration> eventConfigMap, CancellationToken ct) { var method = GetListeningMethod(communicationType); var listeners = await method.StartListeningAsync(configuration, serviceDefinition, eventConfigMap, ct); // TODO: keep referene to the listerner }
private void EnumerateThroughPrimitiveType( IConfigurationSection parentSection, ConfigurationSectionKey serviceKey, PrimitiveType type, IServiceDefinition serviceDefinition, Dictionary <ConfigurationSectionKey, IConfigurationSection> map) { foreach (var section in parentSection.GetChildren()) { if (section.Key.Equals("_all", StringComparison.OrdinalIgnoreCase)) { var allPrimitivesKey = serviceKey; allPrimitivesKey.PrimitiveType = type; map[allPrimitivesKey] = section; } else if (type == PrimitiveType.Command || type == PrimitiveType.Query) { var methodType = type; var methodName = section.Key; if (serviceDefinition != null && _methodResolver.TryResolve(serviceDefinition, new MethodId { Name = methodName }, out var methodReference)) { methodType = methodReference.Definition.IsQuery ? PrimitiveType.Query : PrimitiveType.Command; methodName = methodReference.Definition.Name; } var methodKey = serviceKey; methodKey.PrimitiveType = methodType; methodKey.PrimitiveName = methodName; map[methodKey] = section; } else if (type == PrimitiveType.Event) { var eventName = section.Key; if (serviceDefinition != null && _eventResolver.TryResolve(serviceDefinition, new EventId { Name = eventName }, out var eventReference)) { eventName = eventReference.Definition.Name; } var eventKey = serviceKey; eventKey.PrimitiveType = type; eventKey.PrimitiveName = eventName; map[eventKey] = section; } } }
private IResolver CreateResolverByExpression (IServiceDefinition definition, Expression <Func <ServiceRequest, object> > expression) { if (expression.Body is NewExpression nex) { expression = _configuration.Options.ExpressionBuilder .CreateResolutionExpressionFromConstructorExpression(nex); } var resolver = new ExpressionResolver(definition, expression, InstanceType); return(BuildUp(resolver, definition, true)); }
public DepsCatalog(ServiceWrapperConf conf, IServiceDefinition def, Type implType) { Prefix = conf.Prefix ?? "PayQueue"; MiddlewareCommand = conf.MiddlewareCommand ?? (() => new DefaultMiddleware()); MiddlewareEvent = conf.MiddlewareEvent ?? (() => new DefaultMiddleware()); Logger = LoggerFactory.Create(builder => { builder.AddConsole(); builder.SetMinimumLevel(LogLevel.Debug); }) .CreateLogger(PrepareCategory(def, implType)); }
private MethodCommunicationSettings ComposeMethodCommunicationSettings(IServiceDefinition serviceDefinition, IMethodDefinition methodDefinition) { var settings = new MethodCommunicationSettings(); if (methodDefinition != null) { if (methodDefinition.IsQuery) { settings.RunInPlace = true; settings.IgnoreTransaction = true; } else { settings.Deduplicate = true; settings.Resilient = true; settings.Persistent = true; settings.Transactional = true; } var configuration = _communicationModelConfiguration.GetMethodConfiguration(methodDefinition); configuration.Bind(settings); settings.CommunicationType = _communicationModelConfiguration .GetMethodConfiguration(methodDefinition, CommunicationSectionName) .GetSection("type").Value; settings.PersistenceType = _communicationModelConfiguration .GetMethodConfiguration(methodDefinition, PersistenceSectionName) .GetSection("type").Value; } else { var configuration = _communicationModelConfiguration.GetServiceConfiguration(serviceDefinition); configuration.Bind(settings); settings.CommunicationType = _communicationModelConfiguration .GetServiceConfiguration(serviceDefinition, CommunicationSectionName) .GetSection("type").Value; settings.PersistenceType = _communicationModelConfiguration .GetServiceConfiguration(serviceDefinition, PersistenceSectionName) .GetSection("type").Value; } return(settings); }
public void SaveServiceDefinition_UnitTest() { IServiceDefinition serviceDefinition = default(IServiceDefinition); ExecuteMethod( () => { return((IILocationService)GetInstance()); }, instance => { serviceDefinition = ServiceDefinitionImpl_UnitTests.GetInstance(); SaveServiceDefinition_PreCondition(instance, ref serviceDefinition); }, instance => { instance.SaveServiceDefinition(serviceDefinition); }, instance => { SaveServiceDefinition_PostValidate(instance, serviceDefinition); }); }
private async Task LoadServiceDefinitionAsync(CancellationToken cancelToken) { var getServiceDefinitionResponse = await m_client.ServiceMethods.GetServiceDefinition( new ServiceDefinitionResponseSections[] { ServiceDefinitionResponseSections.Platform }, cancelToken); ConfigurationEntry[] entires = getServiceDefinitionResponse.Platform.ConfigurationEntries; ConfigurationEntry liveIdAuthPolicyConfig = entires.FirstOrDefault(configEntry => configEntry.Key.Equals("liveIdAuthPolicy")); m_serviceDefinition = new ServiceDefinitionProxy { LiveIdAuthPolicy = liveIdAuthPolicyConfig.Value }; }
public PlatformHttpClient( IServiceDefinition serviceDefinition, ISerializerFactorySelector serializerFactorySelector, IServiceHttpConfigurator serviceHttpConfigurator) { _serviceDefinition = serviceDefinition; _serializerFactorySelector = serializerFactorySelector; _serviceHttpConfigurator = serviceHttpConfigurator; _httpClient = new HttpClient(); serviceHttpConfigurator.ConfigureBase(_httpClient, _serviceDefinition); _dasyncJsonSerializer = serializerFactorySelector.Select("dasync+json").Create(); }
/// <summary> /// Register service to builder. /// </summary> /// <param name="builder">Container builder.</param> /// <param name="service">Service definition.</param> private void RegisterServiceToBuilder(ContainerBuilder builder, IServiceDefinition service) { if (service.ImplementFactory != null) { this.RegisterServiceWithFactoryToBuilder(builder, service); } else if (service.ImplementInstance != null) { this.RegisterServiceWithInstanceToBuilder(builder, service); } else { this.RegisterServiceWithImplementToBuilder(builder, service); } }
/// <summary> /// Register scoped service. /// </summary> /// <param name="definition">Service definition.</param> private void RegisterScopedService(IServiceDefinition definition) { if (definition.ImplementInstance != null) { this._servicesCollection.AddScoped(definition.ServiceType, definition.ImplementInstance.GetType()); } else if (definition.ImplementFactory != null) { this._servicesCollection.AddScoped(definition.ServiceType, definition.ImplementFactory); } else if (definition.ImplementType != null) { this._servicesCollection.AddScoped(definition.ServiceType, definition.ImplementType); } }
private IResolver CreateResolverByType(IServiceDefinition definition, Type implementationType) { var constructor = _configuration.Options.ConstructorSelector.SelectConstructor (implementationType, _configuration); if (constructor == null) { return(new NonResolver(InstanceType)); } var expression = _configuration.Options.ExpressionBuilder.CreateResolutionExpressionFromDefaultConstructor(constructor); var isTracked = typeof(IDisposable).IsAssignableFrom(implementationType); var resolver = new ExpressionResolver(definition, expression, InstanceType); return(BuildUp(resolver, definition, isTracked)); }
public bool TryResolve(IServiceDefinition serviceDefinition, EventId eventId, out IEventReference eventReference) { var eventDefinition = serviceDefinition.FindEvent(eventId.Name); if (eventDefinition == null || eventDefinition.IsIgnored) { eventReference = null; return(false); } var delegateMethodInfo = eventDefinition.EventInfo.EventHandlerType.GetMethod("Invoke"); var invoker = _methodInvokerFactory.Create(delegateMethodInfo); eventReference = new EventReference(eventId, eventDefinition, invoker); return(true); }
private IResolver BuildUp(IResolver resolver, IServiceDefinition definition, bool isTracked) { /* * IMPORTANT: * * Resplvers must be decorated in the following order: * * 1. Instance resolver / Expression resolver * 2. Decorator resolver * 3. Service tracker resolver * 4. Service cache resolver * 5. Conditional resolver * 6. Enumerable resolver / Selector resolver */ IResolver built = resolver; var interceptorType = typeof(IInterceptor <>).MakeGenericType(InstanceType); if (_configuration.CanResolve(interceptorType)) { var interceptorResolverType = typeof(InterceptorResolver <>).MakeGenericType(InstanceType); built = (IResolver)Activator.CreateInstance (interceptorResolverType, built, _configuration); } if (isTracked && definition.Lifecycle.Tracked) { built = new ServiceTrackerResolver(definition, built); } if (resolver is ExpressionResolver exr && definition.Lifecycle.Cached) { built = new ServiceCacheResolver(definition, built, exr.Key); } if (definition.Precondition != null) { built = new ConditionalResolver(definition, built); } return(built); }
public bool TryResolve(IServiceDefinition serviceDefinition, MethodId methodId, out IMethodReference methodReference) { var methodDefinition = serviceDefinition.FindMethod(methodId.Name); if (methodDefinition == null || methodDefinition.IsIgnored) { methodReference = null; return(false); } // WARNING: Need to know exact interface used by caller to select the right MethodInfo. // This can be an issue only if two or more interfaces have a method with exactly the same signature. var interfaceMappedMethodInfo = methodDefinition.InterfaceMethods?.FirstOrDefault(); var invoker = _methodInvokerFactory.Create(methodDefinition.MethodInfo, interfaceMappedMethodInfo); methodReference = new MethodReference(methodId, methodDefinition, invoker); return(true); }
private async void RunRoutineInBackground(IServiceDefinition serviceDefinition, ExecuteRoutineIntent intent) { try { var serviceInstance = _domainServiceProvider.GetService(serviceDefinition.Implementation); var routineMethod = _routineMethodResolver.Resolve(serviceDefinition, intent.MethodId); var methodInvoker = _methodInvokerFactory.Create(routineMethod); foreach (var postAction in _transitionActions) { await postAction.OnRoutineStartAsync(serviceDefinition, intent.ServiceId, intent.MethodId, intent.Id); } Task task; try { task = methodInvoker.Invoke(serviceInstance, intent.Parameters); if (routineMethod.ReturnType != typeof(void)) { try { await task; } catch { } } } catch (Exception ex) { if (ex is TargetInvocationException) { ex = ex.InnerException; } task = Task.FromException(ex); } var taskResult = task?.ToTaskResult() ?? new TaskResult(); foreach (var postAction in _transitionActions) { await postAction.OnRoutineCompleteAsync(serviceDefinition, intent.ServiceId, intent.MethodId, intent.Id, taskResult); } _routineCompletionSink.OnRoutineCompleted(intent.Id, taskResult); } catch { } }
private async Task HandleEventSubsciptionAsync(IServiceDefinition serviceDefinition, string eventName, HttpContext context, CancellationToken ct) { if (context.Request.Method != "PUT" && context.Request.Method != "POST") { context.Response.StatusCode = 405; // Method Not Allowed context.Response.ContentType = "text/plain"; await context.Response.Body.WriteAsync(Encoding.UTF8.GetBytes("To subscribe to an event, use one of these HTTP verbs: GET, POST, PUT")); return; } var serviceName = (context.Request.Query.TryGetValue("service", out var serviceValues) && serviceValues.Count == 1) ? serviceValues[0] : null; if (string.IsNullOrWhiteSpace(serviceName)) { context.Response.StatusCode = 404; context.Response.ContentType = "text/plain"; await context.Response.Body.WriteAsync(Encoding.UTF8.GetBytes("Missing 'service=xxx' in the URL query.")); return; } var proxyName = (context.Request.Query.TryGetValue("proxy", out var proxyValues) && proxyValues.Count == 1) ? proxyValues[0] : null; var subscriberServiceId = new ServiceId { ServiceName = serviceName, ProxyName = proxyName }; var eventId = new EventId { EventName = eventName }; var publisherServiceId = new ServiceId { ServiceName = serviceDefinition.Name }; var eventDesc = new EventDescriptor { ServiceId = publisherServiceId, EventId = eventId }; _eventDispatcher.OnSubscriberAdded(eventDesc, subscriberServiceId); context.Response.StatusCode = 200; }
/// <summary> /// Register service with service implement type to builder. /// </summary> /// <param name="builder">Container builder.</param> /// <param name="service">Service definition.</param> private void RegisterServiceWithImplementToBuilder(ContainerBuilder builder, IServiceDefinition service) { var step1 = builder.RegisterType(service.ImplementType); var step2 = step1.As(service.ServiceType); switch (service.LifeTime) { case ServiceLifeTime.Singleton: step2.SingleInstance(); break; case ServiceLifeTime.Transient: step2.InstancePerDependency(); break; case ServiceLifeTime.Scope: default: step2.InstancePerLifetimeScope(); break; } }
public IPlatformHttpClient GetClient(IServiceDefinition serviceDefinition) { lock (_clients) { if (_clients.TryGetValue(serviceDefinition.Name, out var connector)) { return(connector); } } lock (_clients) { var connector = new PlatformHttpClient( serviceDefinition, _serializerFactorySelector, _serviceHttpConfigurator); _clients.Add(serviceDefinition.Name, connector); return(connector); } }
private async void SubscribePeriodicallyInBackground( EventDescriptor eventDesc, ServiceId subscriber, IServiceDefinition publisherServiceDefinition) { var subscriberServiceDefinition = GetServiceDefinition(subscriber); while (true) { var client = _platformHttpClientProvider.GetClient(publisherServiceDefinition); try { await client.SubscribeToEvent(eventDesc, subscriber, publisherServiceDefinition); await Task.Delay(TimeSpan.FromMinutes(2)); } catch { await Task.Delay(TimeSpan.FromSeconds(5)); } } }
public async Task PublishEvent(RaiseEventIntent intent, IServiceDefinition subscriberServiceDefinition, NameValueCollection context) { var uri = string.Concat(_serviceHttpConfigurator.GetUrl(subscriberServiceDefinition), "?react&event=", intent.EventId.EventName, "&service=", intent.ServiceId.ServiceName); var json = _dasyncJsonSerializer.SerializeToString(intent); var content = new StringContent(json); content.Headers.ContentType = new MediaTypeHeaderValue("application/dasync+json"); if (context?.Count > 0) { content.Headers.TryAddWithoutValidation(DasyncHttpHeaders.Context, context.Serialize()); } var response = await _httpClient.PutAsync(uri, content); var statusCode = (int)response.StatusCode; if (statusCode != DasyncHttpCodes.Succeeded && statusCode != DasyncHttpCodes.Scheduled) { throw new InvalidOperationException($"Unexpected HTTP {statusCode} response:\r\n{await response.Content.ReadAsStringAsync()}"); } }
private IResolver CreateResolverByInstance(IServiceDefinition definition, object implementation) { var resolver = new InstanceResolver(definition, implementation); return(BuildUp(resolver, definition, implementation is IDisposable)); }
partial void ToolType_SetCondition(ref IServiceDefinition instance, ref String setValue);
partial void RemoveLocationMapping_PreCondition(IServiceDefinition instance, ref IAccessMapping accessMapping);
partial void RemoveLocationMapping_PostValidate(IServiceDefinition instance, IAccessMapping accessMapping);
partial void RelativeToSetting_SetCondition(ref IServiceDefinition instance, ref IRelativeToSetting setValue);
partial void RelativePath_SetCondition(ref IServiceDefinition instance, ref String setValue);
private async Task LoadServiceDefinitionAsync(CancellationToken cancelToken) { var getServiceDefinitionResponse = await m_client.ServiceMethods.GetServiceDefinition( new ServiceDefinitionResponseSections[] { ServiceDefinitionResponseSections.Platform }, cancelToken); ConfigurationEntry[] entires = getServiceDefinitionResponse.Platform.ConfigurationEntries; ConfigurationEntry liveIdAuthPolicyConfig = entires.FirstOrDefault(configEntry => configEntry.Key.Equals("liveIdAuthPolicy")); m_serviceDefinition = new ServiceDefinitionProxy {LiveIdAuthPolicy = liveIdAuthPolicyConfig.Value}; }
public ServiceDefinition(IServiceDefinition copyFrom) : this() { CopyFrom(copyFrom); }