M对象 创建对象(IT服务端 __IT服务端, B资源监控 __监控, string __对象名称 = "资源监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__监控.配置), E角色.客户, null);
__对象.添加属性("总内存", () => string.Format("{0} GB", __监控.总内存 / 1024), E角色.客户, null);
__对象.添加方法("设置配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M资源监控配置>(__实参列表["配置"]);
__监控.配置 = __配置;
File.WriteAllText(H路径.获取绝对路径("资源监控配置.txt"), HJSON.序列化(__配置), Encoding.UTF8);
return("");
}, E角色.客户, null, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__监控.查询状态()));
}, E角色.客户, null, null);
__对象.添加事件("告警", E角色.客户, new List <M形参> {
new M形参("描述", "string")
});
__监控.阈值告警 += __描述 =>
{
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
return(__对象);
}
public void 过滤开发日志(M过滤开发日志 __过滤开发日志)
{
_过滤开发日志 = __过滤开发日志;
_IT客户端.执行方法(_对象名称, "过滤开发日志", new Dictionary <string, string> {
{ "过滤参数", HJSON.序列化(__过滤开发日志) }
});
}
public void 登录(M登录请求 __请求, IPEndPoint __地址)
{
if (_登录验证 != null)
{
try
{
_登录验证(__请求, __地址);
}
catch (Exception ex)
{
_IT服务端.触发事件(_对象名称, "登录完毕", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(new M登录事件 {
成功 = false, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号, 描述 = ex.Message
}) }
});
throw;
}
}
_登录缓存[__地址] = new M已登录设备 {
IP = __地址.Address, 端口号 = __地址.Port, 登录时间 = DateTime.Now, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号
};
_IT服务端.触发事件(_对象名称, "登录完毕", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(new M登录事件 {
成功 = true, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号
}) }
});
}
public void 新增开发日志(M上报开发日志 __日志)
{
var __缓存 = new Dictionary <IPEndPoint, M过滤开发日志>(_开发日志过滤);
var __匹配 = new List <IPEndPoint>();
foreach (var __kv in __缓存)
{
var __条件 = __kv.Value;
if (__条件.线程关键字 != null && __条件.线程关键字.Count > 0 && !string.IsNullOrEmpty(__日志.线程) && __条件.线程关键字.All(q => !__日志.线程.Contains(q)))
{
continue;
}
if (__条件.标题关键字 != null && __条件.标题关键字.Count > 0 && !string.IsNullOrEmpty(__日志.标题) && __条件.标题关键字.All(q => !__日志.标题.Contains(q)))
{
continue;
}
if (__条件.内容关键字 != null && __条件.内容关键字.Count > 0 && !string.IsNullOrEmpty(__日志.内容) && __条件.内容关键字.All(q => !__日志.内容.Contains(q)))
{
continue;
}
if (__条件.重要性.HasValue && __条件.重要性 > __日志.重要性)
{
continue;
}
__匹配.Add(__kv.Key);
}
if (__匹配.Count > 0)
{
_IT服务端.触发事件(_对象名称, "上报开发日志", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(__日志) }
}, __匹配);
}
}
private void 增加(List <string> __号码列表, IPEndPoint __地址)
{
HB日志.记录("订阅", string.Format("{0} 增加 {1}", __地址, string.Join(",", __号码列表)));
if (!_客户端订阅缓存.ContainsKey(__地址))
{
_客户端订阅缓存[__地址] = __号码列表;
}
else
{
var __合并 = new List <int>();
_客户端订阅缓存[__地址].AddRange(__号码列表);
_客户端订阅缓存[__地址] = _客户端订阅缓存[__地址].Distinct().ToList();
}
__号码列表.ForEach(q =>
{
if (!_号码状态缓存.ContainsKey(q))
{
_号码状态缓存[q] = new M号码状态();
}
if (!_号码状态缓存[q].订购者.Contains(__地址))
{
_号码状态缓存[q].订购者.Add(__地址);
}
if (_号码状态缓存[q].最后位置 != null && _号码状态缓存[q].最后位置.时间.AddMinutes(2) > DateTime.Now)
{
_IT服务端.触发事件("订阅", "GPS上报", new Dictionary <string, string> {
{ "号码", q }, { "GPS", HJSON.序列化(_号码状态缓存[q].最后位置) }
}, new List <IPEndPoint> {
__地址
});
}
});
}
void do保存_Click(object sender, EventArgs e)
{
var __账号 = this.in账号.Text;
var __密码 = this.in密码.Text;
var __数据源 = this.in数据源.Text;
var __保留天数 = this.in保留.Text;
var __GPS过滤_开启 = this.inGPS过滤_开启.Checked;
var __GPS过滤_省 = this.inGPS过滤_省.Text;
var __GPS过滤_市 = this.inGPS过滤_市.Text;
var __插件配置 = new List <M插件配置>();
for (int i = 0; i < this.out互联插件.Rows.Count; i++)
{
__插件配置.Add(new M插件配置
{
目录 = this.out互联插件.Rows[i].Cells[1].Value.ToString(),
启用 = (bool)this.out互联插件.Rows[i].Cells[0].Value
});
}
_IT客户端.执行方法("数据库", "设置连接参数", new Dictionary <string, string> {
{ "账号", __账号 }, { "密码", __密码 }, { "数据源", __数据源 }
});
_IT客户端.执行方法("数据库", "设置保留天数", new Dictionary <string, string> {
{ "天数", __保留天数 }
});
_IT客户端.执行方法("GPS过滤", "设置", new Dictionary <string, string> {
{ "启用", __GPS过滤_开启.ToString() }, { "省", __GPS过滤_省 }, { "市", __GPS过滤_市 }
});
_IT客户端.执行方法("插件", "设置", new Dictionary <string, string> {
{ "配置", HJSON.序列化(__插件配置) }
});
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加方法("重启", q =>
{
if (重启 != null)
{
重启();
return("");
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_对象.添加方法("关闭", q =>
{
if (关闭 != null)
{
关闭();
return("");
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_对象.添加方法("查询版本记录", q =>
{
if (查询版本记录 != null)
{
return(HJSON.序列化(查询版本记录()));
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_IT服务端.添加对象(_对象名称, () => _对象);
}
public void 点名(M点名条件 __条件)
{
var __udp = new UdpClient(0);
var __内容 = Encoding.UTF8.GetBytes(HJSON.序列化(__条件));
__udp.Send(__内容, __内容.Length, _请求地址);
}
public M对象 创建对象(string __名称 = "测试", string __分类 = "")
{
var __对象 = new M对象(__名称, __分类);
__对象.添加属性("点结构属性1", () => "HELLO 你好!!!!!!!!");
__对象.添加属性("点结构属性2", () => "1");
__对象.添加属性("列结构属性", () => HJSON.序列化(new List <int> {
1, 2, 3
}), E角色.开发, new M元数据 {
类型 = "int", 结构 = E数据结构.单值数组, 默认值 = "[1,2,3]", 范围 = "1-10",
});
__对象.添加属性("行结构属性", () => HJSON.序列化(new Mdemo {
点属性 = 111, 行属性 = new Mdemo1 {
点属性1 = 1211, 点属性2 = "1221"
}
}));
__对象.添加属性("表结构属性", () => HJSON.序列化(new List <Mdemo>
{
new Mdemo {
点属性 = 111, 行属性 = new Mdemo1 {
点属性1 = 1211, 点属性2 = "1221"
}
},
new Mdemo {
点属性 = 112, 行属性 = new Mdemo1 {
点属性1 = 1212, 点属性2 = "1222"
}
},
}));
__对象.添加方法("使用单值", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", "int"),
new M形参("参数2", "string"),
}, new M元数据 {
类型 = "string", 描述 = "描述xxx", 结构 = E数据结构.单值, 范围 = "范围xxx"
});
__对象.添加方法("使用对象", 实参列表 => 执行方法("使用对象", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", 获取行元数据()),
}, 获取行元数据());
__对象.添加方法("使用单值数组", 实参列表 => 执行方法("使用单值数组", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", "int", E数据结构.单值数组),
new M形参("参数2", "string"),
}, new M元数据 {
类型 = "int", 描述 = "描述xxx", 结构 = E数据结构.单值数组, 范围 = "范围xxx"
});
__对象.添加方法("使用对象数组", 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", 获取表元数据()),
}, 获取表元数据());
//__对象.添加方法("使用单值2", "参数1:int.参数2:string", "string", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发);
//__对象.添加方法("使用对象数组2",
// "参数1:,对象数组(参数1:int;参数2:string),描述.参数2:MXXX,对象(参数1:int,单值数组,xxx;参数2:string,,事大法师的).参数3:int,单值数组",
// "",
// 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发);
__对象.添加方法("返回字符串表格", 实参列表 => 执行方法("返回字符串表格", 实参列表));
__对象.添加方法("返回字符串表格2", 实参列表 => 执行方法("返回字符串表格2", 实参列表));
return(__对象);
}
public float 统计(M频率统计条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "统计频率", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
return(float.Parse(__返回值));
}
public int 统计(M活跃号码查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "统计活跃号码", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
return(int.Parse(__返回值));
}
public M活跃号码查询结果 查询(M活跃号码查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询活跃号码", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 60000);
return(HJSON.反序列化 <M活跃号码查询结果>(__返回值));
}
public M最后位置查询结果 查询(M最后位置查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询最后位置", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
return(HJSON.反序列化 <M最后位置查询结果>(H序列化.AES解压(__返回值)));
}
public List <M上报告警> 查询未清除告警(M查询条件 查询条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询未清除告警", new Dictionary <string, string> {
{ "条件", 查询条件 == null ? "" : HJSON.序列化(查询条件) }
});
return(HJSON.反序列化 <List <M上报告警> >(__返回值));
}
public void 发布事件(E事件 __事件, M点名事件参数 __参数)
{
var __udp = new UdpClient(0);
var __点名事件 = new M点名事件 {
地址 = (IPEndPoint)__udp.Client.LocalEndPoint, 参数 = __参数, 类型 = __事件
};
var __内容 = Encoding.UTF8.GetBytes(HJSON.序列化(__点名事件));
__udp.Send(__内容, __内容.Length, _响应地址);
}
public void 新增工程日志(M上报工程日志 __日志)
{
var __缓存 = new Dictionary <IPEndPoint, M过滤工程日志>(_工程日志过滤);
var __匹配 = new List <IPEndPoint>();
foreach (var __kv in __缓存)
{
var __条件 = __kv.Value;
if (!string.IsNullOrEmpty(__条件.边界类型) && __条件.边界类型 != __日志.边界类型)
{
continue;
}
if (!string.IsNullOrEmpty(__条件.边界标识) && __条件.边界标识 != __日志.边界标识)
{
continue;
}
if (!string.IsNullOrEmpty(__条件.方向) && __条件.方向 != __日志.方向)
{
continue;
}
if (!string.IsNullOrEmpty(__条件.业务标识) && __条件.业务标识 != __日志.业务标识)
{
continue;
}
if (__条件.重要性.HasValue && __条件.重要性 > __日志.重要性)
{
continue;
}
if (__条件.关键字 != null && __条件.关键字.Count > 0 && (
__条件.关键字.All(q => !__日志.描述.Contains(q)) ||
__条件.关键字.All(q => !__日志.业务标识.Contains(q)) ||
__条件.关键字.All(q => !__日志.边界类型.Contains(q)) ||
__条件.关键字.All(q => !__日志.边界标识.Contains(q)) ||
(__日志.业务标签 != null && __日志.业务标签.Count > 0 && __条件.关键字.All(q => !__日志.业务标签.Contains(q)))
))
{
continue;
}
if (__条件.业务类型 != null && __条件.业务类型.Count > 0 && __条件.业务类型.All(q => __日志.业务类型 != q))
{
continue;
}
if (__条件.业务标签 != null && __条件.业务标签.Count > 0 && __条件.业务标签.All(q => __日志.业务标签.Contains(q)))
{
continue;
}
__匹配.Add(__kv.Key);
}
if (__匹配.Count > 0)
{
_IT服务端.触发事件(_对象名称, "上报工程日志", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(__日志) }
}, __匹配);
}
}
public M轨迹查询结果 查询(M轨迹查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询轨迹", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
//return HJSON.反序列化<M轨迹查询结果>(__返回值);
var __解压 = H序列化.AES解压(__返回值);
return(HJSON.反序列化 <M轨迹查询结果>(__解压));
}
//public void 执行(string __进程标识, M命令 __命令, Dictionary<string, string> __参数 = null)
//{
// if (!_客户端.连接正常)
// {
// throw new ApplicationException("未连接");
// }
// var __命令行列表 = __命令.命令行列表;
// if (__命令.参数列表 != null && __命令.参数列表.Count > 0 && __参数 != null)
// {
// __命令行列表 = new List<string>(__命令行列表);
// for (int i = 0; i < __命令行列表.Count; i++)
// {
// foreach (var item in __参数)
// {
// __命令行列表[i] = __命令行列表[i].Replace("<" + item.Key + ">", item.Value);
// }
// }
// }
// _客户端.执行方法(_对象名, "执行", new Dictionary<string, string> {
// { "进程标识",__进程标识},
// { "命令行列表",HJSON.序列化(__命令行列表) },
// });
//}
public void 执行(string __进程标识, List <string> __命令列表)
{
if (!_客户端.连接正常)
{
throw new ApplicationException("未连接");
}
_客户端.执行方法(_对象名, "执行", new Dictionary <string, string> {
{ "进程标识", __进程标识 },
{ "命令行列表", HJSON.序列化(__命令列表) },
});
}
public void 新增告警(M上报告警 告警)
{
if (告警.重要性 != E重要性.一般)
{
_待处理问题.Add(告警);
计算健康状态(true);
}
_IT服务端.触发事件(_对象名称, "上报告警", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(告警) }
});
}
public void 断开(IPEndPoint __来源地址)
{
if (_登录缓存.ContainsKey(__来源地址))
{
var __链路 = _登录缓存[__来源地址];
On已断开连接(__链路);
_IT服务端.触发事件(_对象名称, "已断开连接", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(__链路) }
});
_登录缓存.Remove(__来源地址);
}
}
protected virtual void On健康状态变化(M概要状态 __新状态)
{
var handler = 健康状态变化;
if (handler != null)
{
handler(__新状态);
}
_IT服务端.触发事件(_对象名称, "健康状态变化", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(__新状态) }
});
}
public void 清除告警(M上报清除 清除)
{
var __数量 = _待处理问题.RemoveAll(q => q.标识 == 清除.标识 && q.来源设备标识 == 清除.来源设备标识 && q.来源设备类型 == 清除.来源设备类型);
if (__数量 > 0)
{
计算健康状态(true);
_IT服务端.触发事件(_对象名称, "上报清除", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(清除) }
});
}
}
public void 设置(List <M插件配置> __配置)
{
__配置.ForEach(q =>
{
var __匹配 = _所有插件.Find(k => k.目录 == q.目录);
if (__匹配 != null)
{
__匹配.启用 = q.启用;
}
});
H程序配置.设置("插件配置", HJSON.序列化(__配置, false).Replace('"', '\''));
}
public void 注销(IPEndPoint __来源地址)
{
if (_登录缓存.ContainsKey(__来源地址))
{
var __已登录设备 = _登录缓存[__来源地址];
_IT服务端.触发事件(_对象名称, "注销完毕", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(new 通用命令.鉴权.M注销事件 {
设备标识 = __已登录设备.设备标识, 设备类型 = __已登录设备.设备类型, 账号 = __已登录设备.账号
}) }
});
_登录缓存.Remove(__来源地址);
}
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("名称", () => 片.称, E角色.客户);
_对象.添加属性("描述", () => 片.描述, E角色.客户);
_对象.添加属性("版本号", () => 片.版本号, E角色.客户);
_对象.添加属性("版本时间", () => 片.版本时间, E角色.客户);
_对象.添加方法("查询", __实参列表 => HJSON.序列化(片), E角色.客户, null, null);
_对象.添加方法("查询参数", __实参列表 => HJSON.序列化(参数列表), E角色.客户, null, null);
_IT服务端.添加对象(_对象名称, () => _对象);
}
public void 建立(M链路 __链路)
{
var __地址 = new IPEndPoint(__链路.IP, __链路.端口号);
if (!_登录缓存.ContainsKey(__地址))
{
_登录缓存[__地址] = __链路;
On已建立连接(__链路);
_IT服务端.触发事件(_对象名称, "已建立连接", new Dictionary <string, string> {
{ "事件参数", HJSON.序列化(__链路) }
});
}
}
M对象 创建对象(IT服务端 __IT服务端, string __对象名称 = "业务日志", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("缓存上限", () => H业务日志.缓存上限.ToString(), E角色.客户, null);
__对象.添加方法("查询缓存", __实参列表 =>
{
//return HJSON.AES压缩(HJSON.序列化(H业务日志.查询缓存()));
return(HJSON.序列化(H业务日志.查询缓存()));
}, E角色.客户, null, null);
return(__对象);
}
M对象 创建对象(IT服务端 __IT服务端, B链路监控 __Ping, string __对象名称 = "链路监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__Ping.配置), E角色.客户, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__Ping.查询状态()));
}, E角色.客户, null, null);
__对象.添加方法("修改配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M链路监控配置>(__实参列表["配置"]);
__Ping.修改配置(__配置);
File.WriteAllText(H路径.获取绝对路径("链路监控配置.txt"), HJSON.序列化(__Ping.配置), Encoding.UTF8);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("配置", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("超时", new M元数据 {
类型 = "int", 描述 = "毫秒", 默认值 = "1000"
}),
new M子成员("频率", new M元数据 {
类型 = "int", 描述 = "毫秒/次", 默认值 = "1000"
}),
new M子成员("阈值", new M元数据 {
类型 = "int", 描述 = "1-10, 通过10次中成功的次数表示当前通断", 默认值 = "7"
}),
new M子成员("IP列表", new M元数据 {
类型 = "string", 描述 = "ip或域名", 结构 = E数据结构.单值数组
}),
}
}),
}, null);
__对象.添加事件("连接变化", E角色.客户, new List <M形参> {
new M形参("地址", "string"), new M形参("旧", "bool"), new M形参("新", "bool")
});
__Ping.连接变化 += (__地址, __旧, __新) =>
{
H业务日志.记录("链路", string.Format("{0} {1}", __地址, __新 == true ? "通" : "断"));
__IT服务端.触发事件(__对象名称, "连接变化", new Dictionary <string, string> {
{ "地址", __地址 }, { "旧", __旧.ToString() }, { "新", __新.ToString() }
});
};
return(__对象);
}
public void 请求上传(M请求上传 请求, string 文件路径)
{
_文件路径 = 文件路径;
_IT客户端.订阅事件(_对象名称, "准备好接收数据", 数据);
try
{
_IT客户端.执行方法(_对象名称, "请求上传", new Dictionary <string, string> {
{ "版本", HJSON.序列化(请求) }
});
}
catch (Exception)
{
_IT客户端.注销事件(_对象名称, "准备好接收数据", 数据);
}
}
public List <MGPS> 查询轨迹(List <Tuple <int, DateTime, DateTime> > __条件)
{
var __结果 = new List <MGPS>();
__条件.ForEach(q =>
{
var __轨迹查询条件 = new M轨迹查询条件 {
号码 = q.Item1, 开始时间 = q.Item2, 结束时间 = q.Item3
};
var __返回值 = _IT客户端.执行方法(_对象名称, "查询轨迹", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__轨迹查询条件) }
});
__结果.AddRange(HJSON.反序列化 <M轨迹查询结果>(H序列化.AES解压(__返回值)).列表);
});
return(__结果);
}