private DbTypeConverter() { _logger = CurrentIocManager.CreateLogger <DbTypeConverter>(); var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "config", "DbTypeMaps.xml"); _typeMap = XmlHelper.XmlDeserializeFromPath(path, new DbTypeMap()); }
/// <summary> 通知配置更新 </summary> /// <param name="module"></param> /// <param name="env"></param> /// <param name="config"></param> /// <returns></returns> private void NotifyConfig(string module, string env, object config) { Task.Factory.StartNew <Task>(async() => { using var scope = CurrentIocManager.BeginLifetimeScope(); var hub = scope.Resolve <IHubContext <ConfigHub> >(); if (string.IsNullOrWhiteSpace(env)) { var contract = scope.Resolve <IConfigContract>(); //default var existsEnvs = (await contract.GetEnvsAsync(Project.Id, module)).ToList(); foreach (ConfigEnv configEnv in Enum.GetValues(typeof(ConfigEnv))) { var item = configEnv.ToString().ToLower(); if (existsEnvs.Contains(item)) { continue; } await hub.UpdateAsync(Project.Code, module, item, config); } } else { await hub.UpdateAsync(Project.Code, module, env, config); } }); }
/// <summary> 构造函数 </summary> /// <param name="baseUri"></param> /// <param name="timeout">超时时间(秒)</param> public RestHelper(string baseUri = null, int timeout = -1) { _baseUri = baseUri; _httpHelper = HttpHelper.Instance; _timeout = timeout; _logger = CurrentIocManager.CreateLogger <RestHelper>(); }
/// <summary> Ioc注册 </summary> protected override void IocRegisters() { Builder = Builder ?? new ContainerBuilder(); //注入程序集查找器 var finder = new DefaultAssemblyFinder(); Builder.RegisterInstance(finder).As <IAssemblyFinder>().SingleInstance(); var assemblies = finder.FindAll().ToArray(); Builder.RegisterAssemblyTypes(assemblies) .Where(type => typeof(IScopedDependency).IsAssignableFrom(type) && !type.IsAbstract) .AsSelf() //自身服务,用于没有接口的类 .AsImplementedInterfaces() //接口服务 .PropertiesAutowired() //属性注入 .InstancePerLifetimeScope(); //保证生命周期基于请求 Builder.RegisterAssemblyTypes(assemblies) .Where(type => typeof(IDependency).IsAssignableFrom(type) && !type.IsAbstract) .AsSelf() //自身服务,用于没有接口的类 .AsImplementedInterfaces() //接口服务 .PropertiesAutowired(); //属性注入 Builder.RegisterAssemblyTypes(assemblies) .Where(type => typeof(ISingleDependency).IsAssignableFrom(type) && !type.IsAbstract) .AsSelf() //自身服务,用于没有接口的类 .AsImplementedInterfaces() //接口服务 .PropertiesAutowired() //属性注入 .SingleInstance(); //保证单例注入 IocManager = new IocManager(this); CurrentIocManager.SetIocManager(IocManager); Builder.RegisterInstance(IocManager).AsSelf().As <IIocManager>().SingleInstance(); }
public static void Start(params string[] args) { var builder = new MicroBuilder(); builder.AddLogging(builder => { builder.SetMinimumLevel(LogLevel.Information); builder.AddConsole(); }); var services = builder .AddMicroClient(builder => { builder .AddJsonCodec() //.AddMessagePackCodec() //.AddProtoBufCodec() .AddSession() //.AddHttpProtocol() .AddTcpProtocol() //.AddWebSocketProtocol() //.AddGrpcProtocol() //.AddNacos(opt => //{ // opt.Host = "http://192.168.0.231:8848/"; // opt.Tenant = "ef950bae-865b-409b-9c3b-bc113cf7bf37"; //}) //.AddConsul("http://192.168.0.231:8500") .AddDefaultRouter(r => { r.Regist("Spear.Tests.Contracts_v1", new ServiceAddress("127.0.0.1", 5003) { Service = "192.168.10.217", Protocol = ServiceProtocol.Tcp, Codec = ServiceCodec.Json, Gzip = false }); }) ; }); services.AddSingleton <IService, ServieA>(); services.AddSingleton <IService, ServieB>(); var provider = services.BuildServiceProvider(); CurrentIocManager.CreateLogger <Client>().LogInformation("test"); var logger = provider.GetService <ILogger <Client> >(); logger.LogInformation("请输入消息"); while (true) { var message = Console.ReadLine(); if (string.IsNullOrWhiteSpace(message)) { continue; } //SingleTest(provider, message, logger); CodeTimerTest(provider, message, logger); } }
/// <summary> 添加本地Json配置 </summary> /// <param name="builder"></param> /// <param name="dirPath"></param> /// <returns></returns> public static ISpearConfigBuilder AddLocal(this ISpearConfigBuilder builder, string dirPath = null) { var configPath = string.IsNullOrWhiteSpace(dirPath) ? "configPath".Config <string>() : dirPath; if (string.IsNullOrWhiteSpace(configPath)) { return(builder); } configPath = Path.Combine(Directory.GetCurrentDirectory(), configPath); if (!Directory.Exists(configPath)) { return(builder); } CurrentIocManager.CreateLogger(typeof(ConfigBuilderExtensions)).LogInformation($"正在加载本地配置[{configPath}]"); var jsons = Directory.GetFiles(configPath, "*.json"); if (jsons.Any()) { foreach (var json in jsons) { builder.AddJsonFile(json, false, true); } } return(builder); }
public object Get(string key, Type type) { if (_config == null) { SetConfig(CreateDefaultBuilder().Build()); } if (type.IsSimpleType() || type.IsEnum) { var str = _config.GetValue <string>(key); return(GetEnvOrValue(str, type)); } ////枚举类型处理 //if (type.IsEnum) // return _config.GetValue<string>(key).CastTo(defaultValue); try { //区分大小写 return(_config.GetSection(key).Get(type)); } catch (Exception ex) { CurrentIocManager.CreateLogger <ConfigHelper>().LogError(ex, ex.Message); return(null); } }
/// <summary> 路由处理 </summary> /// <param name="context"></param> /// <returns></returns> public Task RouteAsync(RouteContext context) { var requestedUrl = context.HttpContext.Request.Path.Value.Trim('/'); if (string.IsNullOrWhiteSpace(requestedUrl)) { context.Handler = async ctx => await WriteJsonAsync(ctx, Methods.Keys); return(Task.CompletedTask); } requestedUrl = requestedUrl.ToLower(); //健康状态 if (requestedUrl == "healthy") { context.Handler = async ctx => await ctx.Response.WriteAsync("ok"); return(Task.CompletedTask); } if (!Methods.TryGetValue(requestedUrl, out var method)) { context.Handler = async ctx => await WriteJsonAsync(ctx, DResult.Error($"{requestedUrl} not found"), (int)HttpStatusCode.NotFound); return(Task.CompletedTask); } var instance = CurrentIocManager.Resolve(method.DeclaringType); context.Handler = async ctx => await Runner(ctx, instance, method); return(Task.CompletedTask); }
public MicroEntryFactory() { _logger = LogManager.Logger <MicroEntryFactory>(); _methods = new ConcurrentDictionary <string, MethodInfo>(); _typeFinder = CurrentIocManager.Resolve <ITypeFinder>(); InitServices(); }
/// <summary> 订阅配置 </summary> /// <param name="modules">模块</param> /// <param name="env">环境模式</param> /// <returns></returns> public async Task Subscript(string[] modules, string env) { if (string.IsNullOrWhiteSpace(Code)) { return; } Logger.LogInformation($"hub:{Context.ConnectionId} Subscript {env} - {string.Join(',', modules)}"); foreach (var mode in modules) { await Groups.AddToGroupAsync(Context.ConnectionId, $"{Code}_{mode}_{env}"); } if (ProjectId.IsNotNullOrEmpty()) { using var scope = CurrentIocManager.BeginLifetimeScope(); var contract = scope.Resolve <IConfigContract>(); var dict = new Dictionary <string, object>(); foreach (var module in modules) { var config = await contract.GetAsync(ProjectId, module, env); dict.Add(module, config); } await Clients.Caller.SendAsync("UPDATE", dict); } }
/// <summary> RabbitMQ事件总线 </summary> /// <param name="connection"></param> /// <param name="subsManager"></param> /// <param name="messageCodec"></param> public EventBusRabbitMq(IRabbitMqConnection connection, ISubscribeManager subsManager, IMessageCodec messageCodec) : base(subsManager, messageCodec, connection?.Name) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); _brokerName = connection.Broker; _logger = CurrentIocManager.CreateLogger <EventBusRabbitMq>(); SubscriptionManager.OnEventRemoved += SubsManager_OnEventRemoved; }
protected DRepository(IUnitOfWork unitOfWork) { UnitOfWork = unitOfWork; _connProvider = CurrentIocManager.Resolve <IDbConnectionProvider>(); Logger = CurrentIocManager.CreateLogger(GetType()); if (Logger.IsEnabled(LogLevel.Debug)) { Logger.LogDebug($"{GetType().Name} Create"); } }
public RabbitMessageQueue(IRabbitMqConnection connection, string queue) { _connection = connection; _encoding = Encoding.UTF8; _logger = CurrentIocManager.CreateLogger <RabbitMessageQueue>(); _queue = queue; Channel.ExchangeDeclare(_connection.Broker, ExchangeType.Direct, false, true); Channel.QueueDeclare(_queue, true, false, false); Channel.QueueBind(_queue, _connection.Broker, _queue); }
protected void ConsumerTo <TEvent, TConsumer>() where TConsumer : IEventHandler <TEvent> where TEvent : class { var consumer = CurrentIocManager.Resolve <TConsumer>(); var name = consumer.GetType().GetCustomAttribute <NamingAttribute>(); var eventBus = _provider.GetEventBus(name?.Name); eventBus.Subscribe <TEvent, TConsumer>(() => consumer); }
//private static readonly object SyncObj = new object(); private UnitOfWork() { Id = Guid.NewGuid(); _connProvider = CurrentIocManager.Resolve <IDbConnectionProvider>(); _connections = new ConcurrentDictionary <int, Lazy <IDbConnection> >(); _logger = CurrentIocManager.CreateLogger(GetType()); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"{GetType().Name}:{Id} Create"); } }
public static List <Type> GetServices() { if (_services != null) { return(_services); } _services = CurrentIocManager.Resolve <ITypeFinder>() .Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService)) .ToList(); return(_services); }
/// <summary> 根据编码获取项目 </summary> /// <param name="context"></param> /// <returns></returns> public static ProjectDto GetProjectByToken(this HttpContext context) { var ticket = context.GetTicket(); if (ticket?.ProjectId == null) { return(null); } using var scope = CurrentIocManager.BeginLifetimeScope(); var contract = scope.Resolve <IProjectContract>(); return(contract.DetailAsync(ticket.ProjectId).SyncRun()); }
/// <summary> 根据编码获取项目 </summary> /// <param name="context"></param> /// <returns></returns> public static ProjectDto GetProjectByCode(this HttpContext context) { var code = context.GetProjectCode(); if (string.IsNullOrWhiteSpace(code)) { return(null); } using var scope = CurrentIocManager.BeginLifetimeScope(); var contract = scope.Resolve <IProjectContract>(); return(contract.DetailByCodeAsync(code).SyncRun()); }
/// <summary> 开启微服务 </summary> /// <param name="provider"></param> /// <param name="addressAction"></param> /// <returns></returns> public static void UseMicroService(this IServiceProvider provider, Action <ServiceAddress> addressAction = null) { if (CurrentIocManager.IocManager == null) { CurrentIocManager.SetIocManager(new DefaultIocManager(provider)); } var address = SpearConfig.GetConfig().Service; addressAction?.Invoke(address); var host = provider.GetService <IMicroHost>(); Task.Factory.StartNew(async() => await host.Start(address)); }
/// <summary> 建立连接 </summary> /// <returns></returns> public override async Task OnConnectedAsync() { Logger.LogInformation($"hub:{Context.ConnectionId} Connected,{RemoteAddress()}"); var context = CurrentIocManager.Resolve <IHttpContextFeature>()?.HttpContext; var code = context.GetProject(); if (code == null) { return; } Context.Items.Add(ProjectKey, code); await Connected(); await base.OnConnectedAsync(); }
public Task RouteAsync(RouteContext context) { var requestedUrl = context.HttpContext.Request.Path.Value.Trim('/'); var arrs = requestedUrl.Split('/'); if (arrs == null || arrs.Length != 2) { return(Task.CompletedTask); } var service = arrs[0]; var method = arrs[1]; var type = GetServices().FirstOrDefault(t => string.Equals(t.Name, service, StringComparison.CurrentCultureIgnoreCase)); if (type == null) { return(Task.CompletedTask); } var instance = CurrentIocManager.Resolve(type); var m = instance.GetType().GetMethod(method, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase); if (m == null) { return(Task.CompletedTask); } context.Handler = async ctx => { var input = ctx.Request.Body; string html; using (var stream = new StreamReader(input)) { html = stream.ReadToEnd(); } var arg = JsonConvert.DeserializeObject(html, m.GetParameters()[0].ParameterType); var result = m.Invoke(instance, new[] { arg }); var response = ctx.Response; response.ContentType = "application/json"; var bytes = Encoding.ASCII.GetBytes(JsonHelper.ToJson(result)); await response.Body.WriteAsync(bytes, 0, bytes.Length); }; return(Task.CompletedTask); }
/// <summary> 初始化服务 </summary> internal static void InitServices() { var services = CurrentIocManager.Resolve <ITypeFinder>() .Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService)) .ToList(); foreach (var service in services) { var assKey = service.Assembly.AssemblyKey(); if (!ServiceAssemblies.Contains(assKey)) { ServiceAssemblies.Add(assKey); } var methods = service.GetMethods(BindingFlags.Public | BindingFlags.Instance); foreach (var method in methods) { Methods.TryAdd($"{service.Name}/{method.Name}".ToLower(), method); } } }
private async Task LocalExecute(InvokeMessage invokeMessage, ResultMessage result) { try { var service = _entryFactory.Find(invokeMessage.ServiceId); var args = new List <object>(); var parameters = invokeMessage.Parameters ?? new Dictionary <string, object>(); foreach (var parameter in service.GetParameters()) { if (parameters.ContainsKey(parameter.Name)) { var parameterType = parameter.ParameterType; args.Add(parameters[parameter.Name].CastTo(parameterType)); } else { args.Add(parameter.DefaultValue); } } var instance = CurrentIocManager.Resolve(service.DeclaringType); var data = service.Invoke(instance, args.ToArray()); if (!(data is Task task)) { result.Data = data; } else { await task; var taskType = task.GetType().GetTypeInfo(); if (taskType.IsGenericType) { var prop = taskType.GetProperty("Result"); if (prop != null) { result.Data = prop.GetValue(task); } } } }
public DefaultRabbitMqConnection(RabbitMqConfig config = null) { config = config ?? RabbitMqConfig.Config(); if (string.IsNullOrWhiteSpace(config?.Host)) { throw new ArgumentException(nameof(config)); } _connectionFactory = new ConnectionFactory { HostName = config.Host, Port = config.Port }; if (!string.IsNullOrWhiteSpace(config.VirtualHost)) { _connectionFactory.VirtualHost = config.VirtualHost; } if (!string.IsNullOrWhiteSpace(config.User)) { _connectionFactory.UserName = config.User; _connectionFactory.Password = config.Password; } _logger = CurrentIocManager.CreateLogger <DefaultRabbitMqConnection>(); Broker = config.Broker; }
/// <summary> 自动创建数据库(自动备份) </summary> /// <param name="path">路径</param> /// <param name="password">密码(可选)</param> public static void AutoCreateDb(this string path, string password = null) { if (File.Exists(path)) { //备份 var dir = Path.GetDirectoryName(path); var name = Path.GetFileNameWithoutExtension(path); var ext = Path.GetExtension(path); var backupPath = $"{dir}/__old_{name}_{DateTime.Now:yyyyMMddHHmm}{ext}"; var fi = new FileInfo(path); fi.MoveTo(backupPath); } var finder = CurrentIocManager.Resolve <ITypeFinder>(); var tableTypes = finder.Find(t => t.BaseType == typeof(BaseEntity <string>)).Take(1); var sql = new StringBuilder(); foreach (var tableType in tableTypes) { sql.AppendLine(tableType.CreateTableSql()); } using (var conn = path.CreateConnection()) { conn.Open(); using (var cmd = conn.CreateCommand()) { if (!string.IsNullOrWhiteSpace(password)) { //设置密码 cmd.CommandText = $"PRAGMA key = {password};"; cmd.ExecuteNonQuery(); } cmd.CommandText = sql.ToString(); cmd.ExecuteNonQuery(); } } }
/// <summary> 添加任务日志 </summary> /// <param name="record"></param> /// <returns></returns> public async Task <int> InsertAsync(TJobRecord record) { const string sql = "UPDATE [t_job_trigger] SET [prev_time]=@start WHERE [id] = @id;" + "UPDATE [t_job_trigger] SET [times]=[times]-1 WHERE [id] = @id AND [type]=2 AND [times]>0;"; var fmtSql = Connection.FormatSql(sql); return(await Transaction(async (conn, trans) => { try { var count = await conn.ExecuteAsync(fmtSql, new { id = record.TriggerId, start = record.StartTime }, trans); count += await conn.InsertAsync(record, trans: trans); return count; } catch (Exception ex) { CurrentIocManager.CreateLogger <JobRecordRepository>().LogError(ex, "添加任务日志异常"); throw; } })); }
/// <summary> 执行事务 </summary> /// <param name="manager"></param> /// <param name="eventName"></param> /// <param name="data"></param> /// <returns></returns> public static async Task ProcessEvent(this ISubscribeManager manager, string eventName, byte[] data) { var codec = CurrentIocManager.Resolve <IMessageCodec>(); if (manager.HasSubscriptionsForEvent(eventName)) { var eventType = manager.GetEventTypeByName(eventName); var @event = codec.Decode(data, eventType); var handlers = manager.GetHandlersForEvent(eventName); foreach (var handlerfactory in handlers) { var handler = handlerfactory.DynamicInvoke(); var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType); var method = concreteType.GetMethod("Handle"); if (method == null) { continue; } await(Task) method.Invoke(handler, new[] { @event }); } } }
public async Task Execute(IJobExecutionContext context) { var record = new JobRecordDto { Id = IdentityHelper.Guid32, StartTime = Clock.Now, TriggerId = context.Trigger.Key.Name }; try { var data = context.JobDetail.JobDataMap.Get(Constants.JobData).CastTo <T>(); if (data == null) { throw new BusiException("任务数据异常"); } record.JobId = data.Id; await ExecuteJob(data, record); record.Status = RecordStatus.Success; } catch (Exception ex) { record.Remark = ex.Message; if (!(ex is BusiException)) { Logger.LogError(ex, ex.Message); } record.Status = RecordStatus.Fail; } finally { record.CompleteTime = Clock.Now; var repository = CurrentIocManager.Resolve <IJobContract>(); var result = await repository.AddRecordAsync(record); } }
/// <summary> 初始化服务 </summary> private void InitServices() { if (_typeFinder == null) { return; } var services = _typeFinder .Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService)) .ToList(); foreach (var service in services) { if (!CurrentIocManager.IsRegisted(service)) { continue; } var methods = service.GetMethods(BindingFlags.Public | BindingFlags.Instance); foreach (var method in methods) { var serviceId = GenerateServiceId(method); _methods.TryAdd(serviceId, method); } } }
///// <summary> 从body中读取对象 </summary> ///// <typeparam name="T"></typeparam> ///// <returns></returns> //[NonAction] //protected async Task<T> FromBody<T>() //{ // return await AcbHttpContext.FromBody<T>(); //} /// <summary> 获取IOC注入 </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> protected T Resolve <T>() { return(Current?.RequestServices != null ? Current.RequestServices.GetService <T>() : CurrentIocManager.Resolve <T>()); }