public void 初始化()
{
配置通用访问("数据库");
Task.Factory.StartNew(() =>
{
while (true)
{
检测状态();
Thread.Sleep(10000);
}
});
Task.Factory.StartNew(() =>
{
Thread.Sleep(_清除过期数据延迟);
while (true)
{
try
{
if (GIS数据库正常)
{
On清除过期数据(H程序配置.获取Int32值("保留天数"));
}
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
Thread.Sleep(_清除过期数据频率);
}
});
}
public void 添加事项 <T>(string __队列标识, T __数据, Action <T> __处理数据, H队列监控 __监控 = null)
{
if (_已关闭)
{
return;
}
//Debug.WriteLine("{0} 添加事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据);
var __接收时间 = Environment.TickCount;
var __队列 = _队列字典.GetOrAdd(__队列标识, k => new ConcurrentQueue <Action>());
__队列.Enqueue(() =>
{
if (!_取消标志.IsCancellationRequested)
{
try
{
//Debug.WriteLine("{0} 执行事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据);
if (__监控 == null)
{
__处理数据(__数据);
}
else
{
__监控.监控下执行(_名称, __数据, __接收时间, __处理数据);
}
}
catch (Exception ex)
{
H日志.记录异常(ex, _名称);
}
}
});
Interlocked.Increment(ref _待处理数量);
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
if (e.ExceptionObject == null)
{
return;
}
H日志.记录致命(e.ExceptionObject.ToString());
};
IsWindows = Environment.NewLine == "\r\n";
if (!Environment.UserInteractive)
{
var ServicesToRun = new ServiceBase[] { new Service1() };
ServiceBase.Run(ServicesToRun);
return;
}
var __B控制器 = new B控制器();
__B控制器.配置();
__B控制器.开启();
Console.WriteLine("开启成功,按回车键结束");
Console.ReadLine();
__B控制器.关闭();
}
public void 开启()
{
if (_FTP == null)
{
_FTP = new FTPServer
{
DownloadSpeedLimit = -1,
UploadSpeedLimit = -1,
StartupDir = H路径.序目录,
//UTF8 = true,
Port = 端口号
};
//_FTP.OnLogEvent += (m, n) => H调试.记录(n.ToString());
//_FTP.AcceptedAdresses.Add(addr);
//_FTP.BannedAdresses.Add(addr);
try
{
_FTP.Start();
运行中 = true;
}
catch (Exception ex)
{
H日志.记录异常(ex);
运行中 = false;
}
}
}
public void 开启(string __目录, int __端口号 = 2121)
{
端口号 = __端口号;
目录 = string.IsNullOrEmpty(__目录) ? H路径.序目录 : __目录;
if (_FTP == null)
{
_FTP = new FTPServer
{
DownloadSpeedLimit = -1,
UploadSpeedLimit = -1,
StartupDir = 目录,
//UTF8 = true,
Port = 端口号
};
//_FTP.OnLogEvent += (m, n) => H调试.记录(n.ToString());
//_FTP.OnLogEvent += (m, n) => Console.WriteLine(n.ToString());
//_FTP.AcceptedAdresses.Add(addr);
//_FTP.BannedAdresses.Add(addr);
try
{
_FTP.Start();
if (!运行中)
{
运行中 = true;
on状态变化(运行中);
}
}
catch (Exception ex)
{
H日志.记录异常(ex);
运行中 = false;
}
}
}
public static void 异步执行(Control __影响区域, Action __异步任务, Action __成功后执行 = null, Action <Exception> __失败后执行 = null, bool __禁用影响区域 = true)
{
//获取并验证输入
//限制界面
var __等待面板 = new F等待();
__影响区域.创建局部覆盖控件(__等待面板, null, __禁用影响区域);
//配置任务
var __任务 = new Task(() =>
{
var __停留最小间隔 = 500;
var __计时器 = new System.Diagnostics.Stopwatch();
__计时器.Start();
__异步任务();
__计时器.Stop();
if (__计时器.ElapsedMilliseconds < __停留最小间隔)
{
Thread.Sleep((int)(__停留最小间隔 - __计时器.ElapsedMilliseconds));
}
});
//反馈操作结果
__任务.ContinueWith(task =>
{
__等待面板.隐藏();
__成功后执行?.Invoke();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.FromCurrentSynchronizationContext());
__任务.ContinueWith(task =>
{
__等待面板.隐藏();
task.Exception.Handle(q => true);
if (task.Exception.InnerException == null)
{
H日志.记录异常(task.Exception);
return;
}
if (__失败后执行 != null)
{
__失败后执行(task.Exception.InnerException);
}
else
{
new F对话框_确定("执行出错!\r\n" + task.Exception.InnerException.Message, "").ShowDialog();
H日志.记录异常(task.Exception);
}
},
CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext());
//开始任务
__任务.Start();
}
void do连接_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
H日志输出.设置(q =>
{
if (q.等级 <= TraceEventType.Information)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
});
_IT客户端 = FT通用访问工厂.创建客户端();
H容器.注入 <IT客户端>(_IT客户端, false);
_IT客户端.自动重连 = true;
_IT客户端.已断开 += q => 设置连接状态();
_IT客户端.已连接 += 设置连接状态;
_IT客户端.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)));
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_F主窗口 = new F空窗口(new F主窗口(), "");
设置连接状态();
_F主窗口.FormClosing += OnClosing;
_F主窗口.ShowDialog();
}
public static void 立刻定位(string __号码)
{
try
{
B入口.IT客户端.执行方法("NEOTRO.MNIS", "立刻上报", new Dictionary <string, string> {
{ "号码范围", __号码 }, { "类型", "有计划信道" }
});
}
catch (Exception ex)
{
H日志.记录异常(ex);
throw new ApplicationException("立刻定位失败，" + ex.Message);
}
}
public static void 发短信(string __号码, bool __组号码, string __内容)
{
var __webapi地址 = string.Format("http://{0}/sendmessage.k", _号码簿地址);
try
{
HttpClient.发送请求(__webapi地址, new Dictionary <string, string> {
{ "号码", __号码 }, { "组号码", __组号码.ToString() }, { "内容", __内容 }
}, "POST", Encoding.UTF8);
}
catch (Exception ex)
{
H日志.记录提示(string.Format("从webapi {0} 发短信失败", __webapi地址), ex.Message);
throw new ApplicationException("发短信失败，服务不存在");
}
}
public void 配置()
{
var __调试编解码 = H程序配置.获取Bool值("调试编解码");
H日志输出.设置(q =>
{
if (q.等级 < TraceEventType.Information || __调试编解码)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
}, TraceEventType.Verbose);
_IT服务端 = FT通用访问工厂.创建服务端();
_IT服务端.端口 = H程序配置.获取Int32值("端口号");
H容器.注入(_IT服务端, false);
B通用命令.配置(_IT服务端);
H容器.注入 <IB数据库, B数据库>();
H容器.注入 <IB插件, B插件>();
H容器.注入 <IB订阅, B订阅>();
H容器.注入 <IBGPS数据, BGPS数据>();
if (H程序配置.获取Bool值("内存数据库"))
{
H容器.注入 <ID数据库, D数据库_内存>();
H容器.注入 <IDGPS数据, DGPS数据_内存>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false);
}
else
{
H容器.注入 <ID数据库, D数据库>();
H容器.注入 <IDGPS数据, DGPS数据>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false); //未保存到数据库
}
H容器.注入 <IBGPS过滤, BGPS过滤>(__拦截: false);
H容器.取出 <IB数据库>().初始化();
H容器.取出 <IB订阅>().初始化();
H容器.取出 <IB插件>().初始化();
H容器.取出 <IBGPS数据>().初始化();
H容器.取出 <IB日志>().初始化();
}
public void 执行(Action __动作)
{
lock (_任务同步)
{
_外部任务 = _外部任务.ContinueWith(q =>
{
try
{
__动作();
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
}, CancellationToken.None, TaskContinuationOptions.None, 调度服务);
}
}
public static void 连接(IPEndPoint __服务器地址, bool __自动重连 = true)
{
if (_IT客户端 == null)
{
H日志输出.设置(q =>
{
if (H程序配置.获取Bool值("调试编解码"))
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}, System.Diagnostics.TraceEventType.Verbose);
_IT客户端 = FT通用访问工厂.创建客户端();
_IT客户端.自动重连 = __自动重连;
_IT客户端.已连接 += On已连接;
_IT客户端.已断开 += On已断开;
}
_IT客户端.连接(__服务器地址);
}
/// <returns>item1表示实例, item2表示文件路径</returns>
public static List <Tuple <T, string> > 获取实例 <T>(string __目录, params string[] __文件搜索条件)
{
var __所有实例 = new List <Tuple <T, string> >();
var __列表 = new List <string>();
if (__文件搜索条件.Length == 0)
{
__文件搜索条件 = new string[] { "*.dll" };
}
for (int i = 0; i < __文件搜索条件.Length; i++)
{
var __文件列表 = Directory.GetFiles(__目录, __文件搜索条件[i]);
if (__文件列表.Length > 0)
{
__列表.AddRange(__文件列表);
}
}
//加载插件程序集；并查看哪个类型对宿主可用
foreach (var __dll文件 in __列表)
{
try
{
var __程序集 = Assembly.LoadFrom(__dll文件);
//检查每个公开导出的类型
foreach (Type __类型 in __程序集.GetExportedTypes())
{
//如果类型是实现了插件接口的类，那么类型就对宿主可用
if (__类型.IsClass && typeof(T).IsAssignableFrom(__类型))
{
var __实例 = (T)Activator.CreateInstance(__类型);
__所有实例.Add(new Tuple <T, string>(__实例, new FileInfo(__dll文件).Name));
Debug.WriteLine("加载插件成功: " + __类型.AssemblyQualifiedName);
}
}
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
}
return(__所有实例);
}
public void 监控下执行 <T>(string __队列名称, T __数据, int __接收时间, Action <T> __处理数据)
{
var __延迟 = Environment.TickCount - __接收时间;
Interlocked.Add(ref _总延时, __延迟);
var __计时器 = new Stopwatch();
__计时器.Start();
__处理数据(__数据);
var __耗时 = __计时器.ElapsedMilliseconds;
Interlocked.Add(ref _总耗时, __耗时);
Interlocked.Add(ref _数量, 1);
if (_数量 >= _分组统计数量)
{
var __日志 = new StringBuilder();
__日志.AppendFormat("处理数量 {0},", _数量);
__日志.AppendFormat("总耗时 {0},", _总耗时);
__日志.AppendFormat("平均处理耗时 {0} 毫秒,", _总耗时 / _数量);
__日志.AppendFormat("平均延迟 {0},", _总延时 / _数量);
H日志.记录("统计", _总延时 / _数量 > _延迟阈值 ? TraceEventType.Warning : TraceEventType.Information, __日志.ToString());
Interlocked.Exchange(ref _数量, 0);
Interlocked.Exchange(ref _总耗时, 0);
Interlocked.Exchange(ref _总延时, 0);
}
if (__耗时 > _耗时阈值)
{
var __日志 = new StringBuilder();
__日志.AppendFormat("处理 {0} ,", __数据);
__日志.AppendFormat("耗时 {0} 毫秒. ", __计时器.ElapsedMilliseconds);
H调试.记录提示("耗时告警:" + __队列名称, __日志.ToString());
}
if (__延迟 > _延迟阈值)
{
var __日志 = new StringBuilder();
__日志.AppendFormat("处理 {0} ,", __数据);
__日志.AppendFormat("延迟 {0} 毫秒, ", __延迟);
H调试.记录提示("延迟:" + __队列名称, __日志.ToString());
}
}
public static void 异步执行(Action __异步任务, Action __成功后执行 = null, Action <Exception> __失败后执行 = null)
{
//获取并验证输入
//限制界面
//配置任务
var __任务 = new Task(() =>
{
__异步任务();
});
//反馈操作结果
__任务.ContinueWith(task =>
{
__成功后执行?.Invoke();
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.FromCurrentSynchronizationContext());
__任务.ContinueWith(task =>
{
task.Exception.Handle(q => true);
if (task.Exception.InnerException == null)
{
H日志.记录异常(task.Exception);
return;
}
if (__失败后执行 != null)
{
__失败后执行(task.Exception.InnerException);
}
else
{
new F对话框_确定("执行出错!\r\n" + task.Exception.InnerException.Message, "").ShowDialog();
H日志.记录异常(task.Exception);
}
},
CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext());
//开始任务
__任务.Start();
}
public static List <M部门> 获取部门()
{
var __webapi地址 = string.Format("http://{0}/numberbook.k", _号码簿地址);
try
{
var __json = HttpClient.发送请求(__webapi地址, null, "GET", Encoding.UTF8);
File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), __json, Encoding.UTF8);
return(H序列化.FromJSON字符串 <List <M部门> >(__json, false, 50000000) ?? new List <M部门>());
}
catch (Exception ex)
{
H日志.记录提示(string.Format("从webapi {0} 同步失败", __webapi地址), ex.Message);
}
if (!H路径.验证文件是否存在("部门数据.json", true))
{
//File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), HJSON.序列化(H部门测试数据.部门列表), Encoding.UTF8);
return(new List <M部门>());
}
return(H序列化.FromJSON字符串 <List <M部门> >(File.ReadAllText(H路径.获取绝对路径("部门数据.json", true), Encoding.UTF8), false, 20000000) ?? new List <M部门>());
}
public bool 存在GIS数据库(string __账号, string __密码, string __数据源, string __数据库名称)
{
var __字符串 = 生成连接字符串(__账号, __密码, __数据源).ToString();
try
{
return(H限时执行.执行(() =>
{
using (var __连接 = new SqlConnection(__字符串))
{
__连接.Open();
return new SqlCommand("select * from [master].[dbo].[sysdatabases] where [name]='" + __数据库名称 + "'", __连接).ExecuteScalar() != null;
}
}, 5000));
}
catch (Exception ex)
{
H日志.记录提示(__字符串, ex.Message);
return(false);
}
}
public bool 连接SQLSERVER(string __账号, string __密码, string __数据源)
{
var __字符串 = 生成连接字符串(__账号, __密码, __数据源).ToString();
try
{
return(H限时执行.执行(() =>
{
using (var __连接 = new SqlConnection(__字符串))
{
H限时执行.执行(() => __连接.Open(), 5000);
return true;
}
}, 5000));
}
catch (Exception ex)
{
H日志.记录提示(__字符串, ex.Message);
return(false);
}
}
public static void 配置(IT服务端 __IT服务端)
{
H容器.注入 <IB名片_S, B名片_S>(true, false, "", __IT服务端);
H容器.注入 <IB系统_S, B系统_S>(true, false, "", __IT服务端);
H容器.注入 <IB状态_S, B状态_S>(true, false, "", __IT服务端);
H容器.注入 <IBFTP_S, BFTP_S>(true, false, "", __IT服务端);
var __版本号 = H程序配置.获取字符串("版本号");
if (string.IsNullOrEmpty(__版本号))
{
__版本号 = H调试.查询版本();
}
H容器.取出 <IB名片_S>().初始化(
new M名片 {
称 = "GIS服务器", 描述 = "", 版本号 = __版本号, 版本时间 = H程序配置.获取字符串("版本时间")
},
new List <M参数>
{
new M参数("IP列表", HJSON.序列化(H网络配置.获取IP配置())),
new M参数("操作系统", Environment.OSVersion.ToString()),
new M参数("64位系统", Environment.Is64BitOperatingSystem.ToString()),
new M参数("登录账号", Environment.UserName),
});
H容器.取出 <IB状态_S>().初始化(null, DateTime.Now);
H容器.取出 <IBFTP_S>();
H容器.取出 <IB系统_S>().初始化(() =>
{
H日志.记录提示("重启");
H服务管理.重启("GIS服务器", new TimeSpan(0, 1, 0));
}, () =>
{
H日志.记录提示("关闭");
H服务管理.关闭("GIS服务器", new TimeSpan(0, 1, 0));
}, () => new List <M版本记录>
{
//new M版本记录{ 版本号 = "1.0.0.0", 修改记录 = "xxx", 标签 = new List<string>{ "a", "b"}},
//new M版本记录{ 版本号 = "1.0.1.0", 修改记录 = "yyy", 标签 = new List<string>{ "a1", "b1"}},
});
}
public static T 获取实例 <T>(string __文件路径)
{
try
{
var __程序集 = Assembly.LoadFrom(__文件路径);
//检查每个公开导出的类型
foreach (Type __类型 in __程序集.GetExportedTypes())
{
//如果类型是实现了插件接口的类，那么类型就对宿主可用
if (__类型.IsClass && typeof(T).IsAssignableFrom(__类型))
{
return((T)Activator.CreateInstance(__类型));
}
}
}
catch (Exception ex)
{
H日志.记录异常(ex);
return(default(T));
}
return(default(T));
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
_B进程管理 = new B进程管理(_IT客户端);
this.do刷新.Click += Do停止刷新_Click;
this.out列表.MouseDoubleClick += Out列表_MouseDoubleClick;
Task.Factory.StartNew(() =>
{
List <M进程状态> __状态列表 = null;
Action __UI执行 = () =>
{
if (__状态列表 == null)
{
this.out列表.Items.Clear();
_缓存.Clear();
return;
}
for (int i = 0; i < __状态列表.Count; i++)
{
var __状态 = __状态列表[i];
if (_缓存.ContainsKey(__状态.Id))
{
var __旧 = _缓存[__状态.Id].Tag as M进程状态;
if (object.Equals(__旧.称, __状态.称) && object.Equals(__旧.CPU, __状态.CPU) &&
object.Equals(__旧.内存, __状态.内存) && object.Equals(__旧.路径, __状态.路径))
{
continue;
}
_缓存[__状态.Id].SubItems[1].Text = __状态.称;
_缓存[__状态.Id].SubItems[2].Text = __状态.CPU.HasValue ? __状态.CPU.ToString() : "";
_缓存[__状态.Id].SubItems[3].Text = (__状态.内存 / 1024).ToString("0,00");
_缓存[__状态.Id].SubItems[4].Text = __状态.路径;
}
else
{
_缓存[__状态.Id] = this.out列表.Items.Insert(i, new ListViewItem(new string[] {
__状态.Id.ToString(),
__状态.称,
__状态.CPU.ToString(),
(__状态.内存 / 1024).ToString("0,00"),
__状态.路径
}));
_缓存[__状态.Id].Tag = __状态;
}
}
var __已关闭 = _缓存.Keys.ToList().FindAll(q => !__状态列表.Exists(k => k.Id == q));
__已关闭.ForEach(q =>
{
this.out列表.Items.Remove(_缓存[q]);
_缓存.Remove(q);
});
};
while (!this.Disposing && !this.IsDisposed)
{
if (!Visible || !_允许刷新)
{
Thread.Sleep(2000);
continue;
}
try
{
__状态列表 = null;
__状态列表 = _B进程管理.查询所有();
}
catch (Exception)
{
}
try
{
this.Invoke(new Action(__UI执行));
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
Thread.Sleep(2000);
}
});
}
public B资源监控(M资源监控配置 __配置)
{
配置 = __配置;
if (Program.IsWindows)
{
_可用内存计数器 = new PerformanceCounter("Memory", "Available MBytes");
var __内存信息 = new MEMORYSTATUSEX();
GlobalMemoryStatusEx(__内存信息);
总内存 = (int)(__内存信息.ullTotalPhys / 1024 / 1024);
}
else
{
//var __内存计数器 = new PerformanceCounterCategory("Mono Memory");
//foreach (var __计数器 in __内存计数器.GetCounters())
//{
// Console.WriteLine(string.Format("CounterName:{0}; CounterType:{1}; CounterHelp:{2}; Value:{3}", __计数器.CounterName, __计数器.CounterType, __计数器.CounterHelp, __计数器.NextValue()));
//}
_可用内存计数器 = new PerformanceCounter("Mono Memory", "Available Physical Memory"); //通过free命令行，实际是free性质的内存，非Available性质的内存
using (var __内存总数计数器 = new PerformanceCounter("Mono Memory", "Total Physical Memory"))
{
总内存 = (int)(__内存总数计数器.NextValue() / 1024 / 1024);
}
}
_状态 = new M资源状态();
Task.Factory.StartNew(() =>
{
while (true)
{
try
{
var __CPU使用率 = 获取CPU使用率();
if (_CPU阈值告警 == null)
{
_CPU阈值告警 = new H阈值告警 <int>(配置.CPU阈值, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
_状态.CPU告警 = __告警;
on阈值告警(string.Format("CPU{0}，明细：{1}", __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 配置.阈值次数);
}
_CPU阈值告警.阈值 = 配置.CPU阈值;
_CPU阈值告警.告警判定次数 = 配置.阈值次数;
_CPU阈值告警.添加(__CPU使用率);
_状态.CPU使用率 = _CPU阈值告警.缓存;
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
try
{
var __内存使用率 = 获取内存使用率();
if (_内存阈值告警 == null)
{
_内存阈值告警 = new H阈值告警 <int>(配置.内存阈值, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
_状态.内存告警 = __告警;
on阈值告警(string.Format("内存{0}，明细：{1}", __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 配置.阈值次数);
}
_内存阈值告警.阈值 = 配置.内存阈值;
_内存阈值告警.告警判定次数 = 配置.阈值次数;
_内存阈值告警.添加(__内存使用率);
_状态.内存使用率 = _内存阈值告警.缓存;
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
Thread.Sleep(配置.频率);
}
});
}
public void 初始化()
{
var __路径 = Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(B插件)).Location), "插件");
if (!Directory.Exists(__路径))
{
H日志.记录错误("插件目录不存在");
return;
}
var __子目录 = Directory.GetDirectories(__路径);
if (__子目录.Length == 0)
{
H日志.记录错误("无任何插件");
return;
}
配置通用访问("插件");
H日志.记录提示("开始加载插件");
var __插件配置 = HJSON.反序列化 <List <M插件配置> >(H程序配置.获取字符串("插件配置"));
Action <string, string> __记录日志 = (__插件名称, __内容) => _IB日志.增加(new DTO.日志.M日志 {
描述 = __内容, 时间 = DateTime.Now, 类别 = __插件名称
});
var __输入插件 = new List <IPluginGPS输入>();
var __输出插件 = new List <IPluginGPS输出>();
for (int i = 0; i < __子目录.Length; i++)
{
var __目录 = new DirectoryInfo(__子目录[i]).Name;
var __入口路径 = Path.Combine(__子目录[i], __目录 + ".dll");
if (!File.Exists(__入口路径))
{
continue;
}
var __输入实例 = H反射.获取实例 <IPluginGPS输入>(__入口路径);
if (__输入实例 != null)
{
__输入插件.Add(__输入实例);
var __启用 = 查询启用(__插件配置, __目录);
_所有插件.Add(new M插件参数
{
描述 = __输入实例.接口描述,
称 = __输入实例.接口名称,
启用 = __启用,
管理界面 = __输入实例.管理界面,
目录 = __目录
});
if (__启用)
{
_输入插件列表.Add(__输入实例);
}
__输入实例.记录日志 = __内容 => __记录日志(__输入实例.接口名称, __内容);
}
var __输出实例 = H反射.获取实例 <IPluginGPS输出>(__入口路径);
if (__输出实例 != null)
{
__输出插件.Add(__输出实例);
var __启用 = 查询启用(__插件配置, __目录);
_所有插件.Add(new M插件参数
{
描述 = __输出实例.接口描述,
称 = __输出实例.接口名称,
启用 = __启用,
管理界面 = __输出实例.管理界面,
目录 = __目录
});
if (__启用)
{
_输出插件列表.Add(__输出实例);
}
__输出实例.记录日志 = __内容 => __记录日志(__输出实例.接口名称, __内容);
}
}
H日志.记录提示("插件状态", H序列化.ToJSON字符串(_所有插件));
_输入插件列表.ForEach(__插件 =>
{
__插件.GPS上报 += (__号码, __GPS) =>
{
if (!_IBGPS过滤.判断合法(__号码, __GPS))
{
return;
}
OnGps上报(__号码, __GPS);
_输出插件列表.ForEach(k =>
{
try
{
k.接收GPS(__号码, __GPS);
}
catch (Exception ex)
{
H调试.记录异常(ex);
}
});
};
});
_输出插件列表.ForEach(q =>
{
q.初始化();
});
_输入插件列表.ForEach(q =>
{
q.初始化();
});
}
public B进程监控(M进程监控配置 __配置)
{
配置 = __配置;
Task.Factory.StartNew(() =>
{
var __比较器 = new B比较器();
while (true)
{
lock (_锁)
{
if (配置.列表.Count == 0)
{
_上次存在进程.Clear();
continue;
}
var __本次存在进程 = new List <M进程状态>();
配置.列表.ForEach(k =>
{
var __进程列表 = Process.GetProcessesByName(k.进程名);
if (__进程列表 != null && __进程列表.Length > 0)
{
__进程列表.ToList().ForEach(q =>
{
try
{
var __标识 = string.Format("{0}-{1}", q.Id, q.ProcessName);
var __路径 = "";
if (_路径缓存.ContainsKey(__标识))
{
__路径 = _路径缓存[__标识];
}
else
{
try
{
__路径 = q.MainModule.FileName;
}
catch (Exception)
{
}
_路径缓存[__标识] = __路径;
}
var __状态 = new M进程状态
{
Id = q.Id,
称 = q.ProcessName,
描述 = k.描述,
启动时间 = q.StartTime,
路径 = __路径
};
__状态.内存 = 获取内存使用(__状态.Id, __状态.称);
__状态.线程数 = 获取线程数(__状态.Id, __状态.称);
__状态.CPU = 获取CPU使用率(__状态.Id, __状态.称);
__本次存在进程.Add(__状态);
if (k.内存阈值.HasValue)
{
if (!_内存阈值告警.ContainsKey(__状态.称))
{
_内存阈值告警[__状态.称] = new H阈值告警 <int>(k.内存阈值.Value, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
on阈值告警(string.Format("进程 {0} 内存{1}，明细：{2}", __状态.称, __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 5);
}
_内存阈值告警[__状态.称].阈值 = k.内存阈值.Value;
_内存阈值告警[__状态.称].添加((int)(__状态.内存 / 1024 / 1024));
}
if (k.CPU阈值.HasValue)
{
if (!_CPU阈值告警.ContainsKey(__状态.称))
{
_CPU阈值告警[__状态.称] = new H阈值告警 <int>(k.CPU阈值.Value, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
on阈值告警(string.Format("进程 {0} CPU{1}，明细：{2}", __状态.称, __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 5);
}
_CPU阈值告警[__状态.称].阈值 = k.CPU阈值.Value;
_CPU阈值告警[__状态.称].添加((int)(__状态.CPU));
}
q.Dispose();
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
});
}
});
_上次存在进程.Except(__本次存在进程, __比较器).ToList().ForEach(q => on进程关闭(q.Id, q.称));
__本次存在进程.Except(_上次存在进程, __比较器).ToList().ForEach(q =>
{
if (q.启动时间.AddSeconds(10) > DateTime.Now)
{
on进程开启(q.Id, q.称, q.启动时间);
}
});
_上次存在进程 = __本次存在进程;
}
Thread.Sleep(配置.频率);
}
});
}
