private static void LoadCtor(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap) { var ctorNode = xmlNode.SelectSingleNode("//ns:Constructor", xmlNsM); if (ctorNode != null) { var argNodes = ctorNode.SelectNodes("//ns:Arg", xmlNsM); if (argNodes.Count > 0) { var ctorMap = new Constructor { Args = new List <Arg>() }; foreach (XmlNode argNode in argNodes) { var arg = new Arg { Column = argNode.Attributes["Column"].Value, Type = argNode.Attributes["Type"].Value, TypeHandler = argNode.Attributes["TypeHandler"]?.Value }; arg.ArgType = ArgTypeConvert(arg.Type); if (!String.IsNullOrEmpty(arg.TypeHandler)) { arg.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == arg.TypeHandler).Handler; } ctorMap.Args.Add(arg); } resultMap.Constructor = ctorMap; } } }
public static ResultMap LoadResultMap(XElement xmlNode, SmartSqlMapConfig sqlMapConfig) { ResultMap resultMap = new ResultMap { Id = xmlNode.Attribute("Id").Value, Results = new List <Result> { } }; var type = xmlNode.Attribute("ResultType")?.Value; if (string.IsNullOrWhiteSpace(type) == false) { resultMap.ResultType = Type.GetType(type); } if (resultMap.ResultType == null) { throw new SmartSqlException($"Entity map {resultMap.Id} 找不到类型{resultMap.ResultType}!"); } foreach (XElement childNode in xmlNode.Elements()) { var result = new Result { Property = childNode.Attribute("Property").Value, Column = (childNode.Attribute("Column") ?? childNode.Attribute("Property")).Value, TypeHandler = childNode.Attribute("TypeHandler")?.Value }; result.Handler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == result.TypeHandler)?.Handler; resultMap.Results.Add(result); } return(resultMap); }
public static ParameterMap LoadParameterMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig) { ParameterMap parameterMap = new ParameterMap { Id = xmlNode.Attributes["Id"].Value, Parameters = new List <Parameter> { } }; foreach (XmlNode childNode in xmlNode.ChildNodes) { var parameter = new Parameter { Property = childNode.Attributes["Property"].Value, Name = (childNode.Attributes["Name"] ?? childNode.Attributes["Property"]).Value, TypeHandler = childNode.Attributes["TypeHandler"].Value }; if (!String.IsNullOrEmpty(parameter.TypeHandler)) { TypeHandler typeHandler = TypeHanderNotNull(sqlMapConfig, parameter.TypeHandler); parameter.Handler = typeHandler.Handler; } parameterMap.Parameters.Add(parameter); } return(parameterMap); }
public override async Task process(WatchedEvent @event) { string path = @event.getPath(); _logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher process : {path} ."); var eventType = @event.get_Type(); if (eventType == Event.EventType.NodeDataChanged) { if (!SmartSqlMapConfig.Settings.IsWatchConfigFile) { _logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap,dot not watch: {path} ."); } else { _logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} Starting"); var sqlmap = SmartSqlMapConfig.SmartSqlMaps.FirstOrDefault(m => m.Path == path); var newSqlmap = await ConfigLoader.LoadSmartSqlMapAsync(path, SmartSqlMapConfig); sqlmap.Scope = newSqlmap.Scope; sqlmap.Statements = newSqlmap.Statements; sqlmap.Caches = newSqlmap.Caches; SmartSqlMapConfig.ResetMappedStatements(); SmartSqlMapConfig.SmartSqlMapper.CacheManager.ResetMappedCaches(); _logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} End"); } } }
private void LoadSmartSqlMap(SmartSqlMapConfig config, String sqlmapSourcePath) { _logger.LogDebug($"LoadSmartSqlMap Load: {sqlmapSourcePath}"); var sqlmapStream = LoadConfigStream(sqlmapSourcePath); var sqlmap = LoadSmartSqlMap(sqlmapStream, config); config.SmartSqlMaps.Add(sqlmap); }
public SmartSqlContext( ILogger <SmartSqlContext> logger , SmartSqlMapConfig sqlMapConfig ) { _logger = logger; SqlMapConfig = sqlMapConfig; Setup(); }
private static TypeHandler TypeHanderNotNull(SmartSqlMapConfig sqlMapConfig, string typeHandlerName) { var typeHandler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == typeHandlerName); if (typeHandler == null) { throw new SmartSqlException($"Can not find TypeHandler.Name:{typeHandlerName}"); } return(typeHandler); }
public SmartSqlMapWatcher(ILoggerFactory loggerFactory , SmartSqlMapConfig smartSqlMapConfig , ZooKeeperConfigLoader configLoader , Func <WatchedEvent, Task> onWatch = null ) : base(loggerFactory, onWatch) { _logger = loggerFactory.CreateLogger <SmartSqlMapWatcher>(); SmartSqlMapConfig = smartSqlMapConfig; ConfigLoader = configLoader; }
/// <summary> /// 监控配置文件-热更新 /// </summary> private void WatchConfig(SmartSqlMapConfig config) { #region SmartSqlMaps File Watch foreach (var sqlmapKV in SqlMapConfig.SmartSqlMaps) { var sqlmap = sqlmapKV.Value; #region SqlMap File Watch if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Watch SmartSqlMap: {sqlmap.Path} ."); } var sqlMapFileInfo = FileLoader.GetInfo(sqlmap.Path); _fileWatcherLoader.Watch(sqlMapFileInfo, () => { Thread.Sleep(DELAYED_LOAD_FILE); lock (this) { try { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Changed Reload SmartSqlMap: {sqlmap.Path} Starting"); } var newSqlMap = LoadSmartSqlMap(config, sqlmap.Path); var oldSqlMap = SqlMapConfig.SmartSqlMaps.Values.First(s => s.Path == sqlmap.Path); oldSqlMap.Caches = newSqlMap.Caches; oldSqlMap.Scope = newSqlMap.Scope; oldSqlMap.Statements = newSqlMap.Statements; InitDependency(); OnChanged?.Invoke(this, new OnChangedEventArgs { SqlMapConfig = SqlMapConfig, SqlMap = oldSqlMap, EventType = EventType.SqlMapChangeed }); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Changed Reload SmartSqlMap: {sqlmap.Path} End"); } } catch (Exception ex) { _logger.LogError(new EventId(ex.HResult), ex, ex.Message); } } }); #endregion SqlMap File Watch } #endregion SmartSqlMaps File Watch }
private void LoadManifestSmartSqlMap(SmartSqlMapConfig config, string name) { var configStream = new ConfigStream { Path = name, Stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name) }; var sqlmap = LoadSmartSqlMap(configStream, config); config.SmartSqlMaps.Add(sqlmap); }
public SmartSqlMapConfig LoadConfig(ConfigStream configStream) { using (configStream.Stream) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig)); SqlMapConfig = xmlSerializer.Deserialize(configStream.Stream) as SmartSqlMapConfig; SqlMapConfig.Path = configStream.Path; SqlMapConfig.SmartSqlMaps = new List <SmartSqlMap> { }; return(SqlMapConfig); } }
public static ResultMap LoadResultMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM) { ResultMap resultMap = new ResultMap { Id = xmlNode.Attributes["Id"].Value, Results = new List <Result> { } }; LoadCtor(xmlNode, sqlMapConfig, xmlNsM, resultMap); LoadResult(xmlNode, sqlMapConfig, xmlNsM, resultMap); return(resultMap); }
public async Task <SmartSqlMap> LoadSmartSqlMapAsync(String path, SmartSqlMapConfig config) { _logger.LogDebug($"SmartSql.LoadSmartSqlMapAsync Load: {path}"); var sqlmapResult = await ZooClient.getDataAsync(path, new SmartSqlMapWatcher(_loggerFactory, config, this)); var sqlmapStream = new ConfigStream { Path = path, Stream = new MemoryStream(sqlmapResult.Data) }; return(LoadSmartSqlMap(sqlmapStream, config)); }
private SmartSqlMap LoadSmartSqlMap(SmartSqlMapConfig config, string sqlMapPath) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LoadSmartSqlMap Load: {sqlMapPath}"); } var sqlmapStream = LoadConfigStream(sqlMapPath); var sqlmap = LoadSmartSqlMap(sqlmapStream); config.SmartSqlMaps.Add(sqlmap); return(sqlmap); }
public SmartSqlMapConfig LoadConfig(ConfigStream configStream) { using (configStream.Stream) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig)); SqlMapConfig = xmlSerializer.Deserialize(configStream.Stream) as SmartSqlMapConfig; SqlMapConfig.Path = configStream.Path; SqlMapConfig.SmartSqlMaps = new Dictionary <String, SmartSqlMap> { }; if (SqlMapConfig.TypeHandlers != null) { foreach (var typeHandler in SqlMapConfig.TypeHandlers) { typeHandler.Handler = TypeHandlerFactory.Create(typeHandler.Type); } } return(SqlMapConfig); } }
private static void LoadResult(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap) { var resultNodes = xmlNode.SelectNodes("//ns:Result", xmlNsM); foreach (XmlNode resultNode in resultNodes) { var result = new Result { Property = resultNode.Attributes["Property"].Value, Column = (resultNode.Attributes["Column"] ?? resultNode.Attributes["Property"]).Value, TypeHandler = resultNode.Attributes["TypeHandler"]?.Value }; if (!String.IsNullOrEmpty(result.TypeHandler)) { result.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == result.TypeHandler).Handler; } resultMap.Results.Add(result); } }
private static void LoadProperty(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap) { var resultNodes = xmlNode.SelectNodes("./ns:Result", xmlNsM); foreach (XmlNode resultNode in resultNodes) { var property = new Property { Name = resultNode.Attributes["Property"].Value, Column = (resultNode.Attributes["Column"] ?? resultNode.Attributes["Property"]).Value, TypeHandler = resultNode.Attributes["TypeHandler"]?.Value }; if (!String.IsNullOrEmpty(property.TypeHandler)) { TypeHandler typeHandler = TypeHanderNotNull(sqlMapConfig, property.TypeHandler); property.Handler = typeHandler.Handler; } resultMap.Properties.Add(property); } }
private SmartSqlMapConfig LoadConfig(String path, ISmartSqlMapper smartSqlMapper) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig)); SmartSqlMapConfig config = null; using (var configStream = FileLoader.Load(path)) { config = xmlSerializer.Deserialize(configStream) as SmartSqlMapConfig; config.Path = path; config.SmartSqlMapper = smartSqlMapper; } config.SmartSqlMaps = new List <SmartSqlMap> { }; foreach (var sqlmapSource in config.SmartSqlMapSources) { var sqlmap = LoadSmartSqlMap(sqlmapSource.Path, config); config.SmartSqlMaps.Add(sqlmap); } return(config); }
public async Task <SmartSqlMap> LoadSmartSqlMapAsync(string path, SmartSqlMapConfig smartSqlMapConfig) { var sqlMap = new SmartSqlMap { SmartSqlMapConfig = smartSqlMapConfig, Path = path, Statements = new List <Statement> { }, Caches = new List <SqlMap.Cache> { } }; var configResult = await ZooClient.getDataAsync(path, new SmartSqlMapWatcher(smartSqlMapConfig, this)); using (MemoryStream configStream = new MemoryStream(configResult.Data)) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(configStream); XmlNamespaceManager xmlNsM = new XmlNamespaceManager(xmlDoc.NameTable); xmlNsM.AddNamespace("ns", "http://SmartSql.net/schemas/SmartSqlMap.xsd"); sqlMap.Scope = xmlDoc.SelectSingleNode("//ns:SmartSqlMap", xmlNsM) .Attributes["Scope"].Value; #region Init Caches var cacheNodes = xmlDoc.SelectNodes("//ns:Cache", xmlNsM); foreach (XmlElement cacheNode in cacheNodes) { var cache = SqlMap.Cache.Load(cacheNode); sqlMap.Caches.Add(cache); } #endregion #region Init Statement var statementNodes = xmlDoc.SelectNodes("//ns:Statement", xmlNsM); foreach (XmlElement statementNode in statementNodes) { var statement = Statement.Load(statementNode, sqlMap); sqlMap.Statements.Add(statement); } #endregion return(sqlMap); } }
private SmartSqlMap LoadSmartSqlMap(string path, SmartSqlMapConfig smartSqlMapConfig) { var sqlMap = new SmartSqlMap { SmartSqlMapConfig = smartSqlMapConfig, Path = path, Statements = new List <Statement> { }, Caches = new List <SqlMap.Cache> { } }; using (var configStream = FileLoader.Load(path)) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(configStream); XmlNamespaceManager xmlNsM = new XmlNamespaceManager(xmlDoc.NameTable); xmlNsM.AddNamespace("ns", "http://SmartSql.net/schemas/SmartSqlMap.xsd"); sqlMap.Scope = xmlDoc.SelectSingleNode("//ns:SmartSqlMap", xmlNsM) .Attributes["Scope"].Value; #region Init Caches var cacheNodes = xmlDoc.SelectNodes("//ns:Cache", xmlNsM); foreach (XmlElement cacheNode in cacheNodes) { var cache = SqlMap.Cache.Load(cacheNode); sqlMap.Caches.Add(cache); } #endregion #region Init Statement var statementNodes = xmlDoc.SelectNodes("//ns:Statement", xmlNsM); foreach (XmlElement statementNode in statementNodes) { var statement = Statement.Load(statementNode, sqlMap); sqlMap.Statements.Add(statement); } #endregion return(sqlMap); } }
public async Task <SmartSqlMapConfig> LoadConfigAsync(String path, ISmartSqlMapper smartSqlMapper) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig)); SmartSqlMapConfig config = null; var configResult = await ZooClient.getDataAsync(path, new SmartSqlMapConfigWatcher(smartSqlMapper, this)); using (MemoryStream configStream = new MemoryStream(configResult.Data)) { config = xmlSerializer.Deserialize(configStream) as SmartSqlMapConfig; config.Path = path; config.SmartSqlMapper = smartSqlMapper; } config.SmartSqlMaps = new List <SmartSqlMap> { }; foreach (var sqlmapSource in config.SmartSqlMapSources) { var sqlmap = await LoadSmartSqlMapAsync(sqlmapSource.Path, config); config.SmartSqlMaps.Add(sqlmap); } return(config); }
public static ParameterMap LoadParameterMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig) { ParameterMap parameterMap = new ParameterMap { Id = xmlNode.Attributes["Id"].Value, Parameters = new List <Parameter> { } }; foreach (XmlNode childNode in xmlNode.ChildNodes) { var parameter = new Parameter { Property = childNode.Attributes["Property"].Value, Name = (childNode.Attributes["Name"] ?? childNode.Attributes["Property"]).Value, TypeHandler = childNode.Attributes["TypeHandler"].Value }; parameter.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == parameter.TypeHandler).Handler; parameterMap.Parameters.Add(parameter); } return(parameterMap); }
public static ParameterMap LoadParameterMap(XElement xmlNode, SmartSqlMapConfig sqlMapConfig) { ParameterMap parameterMap = new ParameterMap { Id = xmlNode.Attribute("Id").Value, Parameters = new List <Parameter> { } }; foreach (XElement childNode in xmlNode.Elements()) { var parameter = new Parameter { Property = childNode.Attribute("Property").Value, Name = (childNode.Attribute("Name") ?? childNode.Attribute("Property")).Value, TypeHandler = childNode.Attribute("TypeHandler")?.Value }; parameter.Handler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == parameter.TypeHandler)?.Handler; parameterMap.Parameters.Add(parameter); } return(parameterMap); }
public SmartSqlMapWatcher(SmartSqlMapConfig smartSqlMapConfig, ZooKeeperConfigLoader configLoader) { SmartSqlMapConfig = smartSqlMapConfig; ConfigLoader = configLoader; }
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig) { SqlMapper.LoadConfig(smartSqlMapConfig); }
public SmartSqlMapWatcher(ILoggerFactory loggerFactory, SmartSqlMapConfig smartSqlMapConfig, ZooKeeperConfigLoader configLoader) { _logger = loggerFactory.CreateLogger <SmartSqlMapWatcher>(); SmartSqlMapConfig = smartSqlMapConfig; ConfigLoader = configLoader; }
public override SmartSqlMapConfig Load() { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Load: {_sqlMapConfigFilePath} Starting"); } //读取xml文件 var smartSqlConfig = LoadSmartSqlConfig(); SqlMapConfig = new SmartSqlMapConfig() { Database = new SmartSql.Configuration.Database() { DbProvider = _options.Database.DbProvider, ReadDataSources = _options.Database.Read, WriteDataSource = _options.Database.Write }, SmartSqlMaps = new Dictionary <String, SmartSqlMap>(), SmartSqlMapSources = smartSqlConfig.SmartSqlMaps, Settings = smartSqlConfig.Settings, TypeHandlers = smartSqlConfig.TypeHandlers, }; foreach (var sqlMapSource in SqlMapConfig.SmartSqlMapSources) { switch (sqlMapSource.Type) { case SmartSqlMapSource.ResourceType.File: { LoadSmartSqlMapAndInConfig(sqlMapSource.Path); break; } case SmartSqlMapSource.ResourceType.Directory: case SmartSqlMapSource.ResourceType.DirectoryWithAllSub: { SearchOption searchOption = SearchOption.TopDirectoryOnly; if (sqlMapSource.Type == SmartSqlMapSource.ResourceType.DirectoryWithAllSub) { searchOption = SearchOption.AllDirectories; } var dicPath = Path.Combine(AppContext.BaseDirectory, sqlMapSource.Path); var childSqlmapSources = Directory.EnumerateFiles(dicPath, "*.xml", searchOption); foreach (var childSqlmapSource in childSqlmapSources) { LoadSmartSqlMapAndInConfig(childSqlmapSource); } break; } default: { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader unknow SmartSqlMapSource.ResourceType:{sqlMapSource.Type}."); } break; } } } InitDependency(); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Load: {_sqlMapConfigFilePath} End"); } if (SqlMapConfig.Settings.IsWatchConfigFile) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Load Add WatchConfig: {_sqlMapConfigFilePath} Starting."); } WatchConfig(); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"LocalFileConfigLoader Load Add WatchConfig: {_sqlMapConfigFilePath} End."); } } return(SqlMapConfig); }
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig) { SqlMapConfig = smartSqlMapConfig; SqlMapConfig.SetLogger(_loggerFactory.CreateLogger <SmartSqlMapConfig>()); }
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig) { MapperInstance.LoadConfig(smartSqlMapConfig); }
public override SmartSqlMapConfig Load() { SqlMapConfig = new SmartSqlMapConfig() { SmartSqlMaps = new List <SmartSqlMap>(), SmartSqlMapSources = _options.SmartSqlMaps, Database = new Configuration.Database() { DbProvider = _options.Database.DbProvider, WriteDataSource = _options.Database.Write, ReadDataSources = _options.Database.Read }, Settings = _options.Settings, TypeHandlers = _options.TypeHandlers, }; foreach (var sqlMapSource in SqlMapConfig.SmartSqlMapSources) { switch (sqlMapSource.Type) { case SmartSqlMapSource.ResourceType.File: { LoadSmartSqlMap(SqlMapConfig, sqlMapSource.Path); break; } case SmartSqlMapSource.ResourceType.Directory: case SmartSqlMapSource.ResourceType.DirectoryWithAllSub: { SearchOption searchOption = SearchOption.TopDirectoryOnly; if (sqlMapSource.Type == SmartSqlMapSource.ResourceType.DirectoryWithAllSub) { searchOption = SearchOption.AllDirectories; } var dicPath = Path.Combine(AppContext.BaseDirectory, sqlMapSource.Path); var childSqlmapSources = Directory.EnumerateFiles(dicPath, "*.xml", searchOption); foreach (var childSqlmapSource in childSqlmapSources) { LoadSmartSqlMap(SqlMapConfig, childSqlmapSource); } break; } default: { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"OptionConfigLoader unknow SmartSqlMapSource.ResourceType:{sqlMapSource.Type}."); } break; } } } if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"OptionConfigLoader Load End"); } if (SqlMapConfig.Settings.IsWatchConfigFile) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"OptionConfigLoader Load Add WatchConfig Starting."); } WatchConfig(SqlMapConfig); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"OptionConfigLoader Load Add WatchConfig End."); } } return(SqlMapConfig); }