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 _待处理数量);
}
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 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 开启()
{
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 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 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, 调度服务);
}
}
/// <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 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 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进程监控配置 __配置)
{
配置 = __配置;
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(配置.频率);
}
});
}
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(配置.频率);
}
});
}
