protected void Page_Load(object sender, EventArgs e)
{
//HmTrace.WriteWarn("我来了这里99");
if (!IsPostBack)
{
// 引发反向工程
ThreadPoolX.QueueUserWorkItem(delegate() { EntityFactory.CreateOperate(ManageProvider.Provider.ManageUserType).FindCount(); });
IManageUser user = ManageProvider.Provider.Current;
//HmTrace.WriteWarn("我来了这里99");
if (user != null)
{
if (String.Equals("logout", Request["action"], StringComparison.OrdinalIgnoreCase))
{
IAdministrator admin = user as IAdministrator;
if (admin == null)
{
admin.Logout();
}
}
else
{
Response.Redirect("Default.aspx");
}
}
}
}
static void TestServer()
{
Int32 port = ReadInt("请输入监听端口：", 1, 65535);
// 扩大事件池
//NetEventArgs.Pool.Max = 200000;
server = new NetServer();
server.ProtocolType = ProtocolType.Tcp;
server.Port = port;
server.UseSession = true;
server.Received += server_Received;
// 最大不活跃时间设为10分钟
foreach (TcpServer item in server.Servers)
{
item.SessionTimeout = 10 * 60;
}
server.Start();
server.Log = null;
ThreadPoolX.QueueUserWorkItem(ShowStatus);
Console.WriteLine("服务端准备就绪，任何时候任意键退出服务程序！");
Console.ReadKey(true);
server.Dispose();
}
public MyService()
{
ServiceName = "AntServer";
ThreadPoolX.QueueUserWorkItem(() =>
{
var n = App.Meta.Count;
var set = NewLife.Setting.Current;
if (set.IsNew)
{
set.DataPath = @"..\Data";
set.Save();
}
var set2 = XCode.Setting.Current;
if (set2.IsNew)
{
set2.Debug = true;
set2.ShowSQL = false;
set2.TraceSQLTime = 3000;
//set2.SQLiteDbPath = @"..\Data";
set2.Save();
}
});
// 注册菜单，在控制台菜单中按 t 可以执行Test函数，主要用于临时处理数据
AddMenu('t', "数据测试", Test);
}
static Ip()
{
var dir = Runtime.IsWeb ? "..\\Data" : "Data";
var ip = dir.CombinePath("ip.gz").GetFullPath();
if (File.Exists(ip))
{
DbFile = ip;
}
// 如果本地没有IP数据库，则从网络下载
if (DbFile.IsNullOrWhiteSpace())
{
ThreadPoolX.QueueUserWorkItem(() =>
{
var url = Setting.Current.PluginServer;
XTrace.WriteLine("没有找到IP数据库{0}，准备联网获取 {1}", ip, url);
var client = new WebClientX
{
Log = XTrace.Log
};
var file = client.DownloadLink(url, "ip.gz", dir.GetFullPath());
if (File.Exists(file))
{
DbFile = file.GetFullPath();
zip = null;
// 让它重新初始化
_inited = null;
}
});
}
}
protected override void OnReceive(ReceivedEventArgs e)
{
LastActive = DateTime.Now;
// Api解码消息得到Action和参数
var msg = e.Message as IMessage;
if (msg == null || msg.Reply)
{
return;
}
// 连接复用
if (_Host is ApiServer svr && svr.Multiplex)
{
// 如果消息使用了原来SEAE的数据包，需要拷贝，避免多线程冲突
// 也可能在粘包处理时，已经拷贝了一次
if (e.Packet != null)
{
if (msg.Payload != null && e.Packet.Data == msg.Payload.Data)
{
msg.Payload = msg.Payload.Clone();
}
}
ThreadPoolX.QueueUserWorkItem(m =>
{
var rs = _Host.Process(this, m);
if (rs != null && Session != null && !Session.Disposed)
{
Session?.SendMessage(rs);
}
}, msg);
}
void DetectRemote(Object state)
{
var list = new List <String>();
foreach (var item in DAL.ConnStrs)
{
if (!String.IsNullOrEmpty(item.Value.ConnectionString))
{
list.Add(item.Key);
}
}
var localName = "local_MSSQL";
foreach (var item in list)
{
ThreadPoolX.QueueUserWorkItem(DetectSqlServer, item);
}
if (DAL.ConnStrs.ContainsKey(localName))
{
DAL.ConnStrs.Remove(localName);
}
//if (list.Contains(localName)) list.Remove(localName);
}
public AgentInfo Info(AgentInfo info)
{
XTrace.WriteLine(info.ToJson());
var set = Setting;
// 使用对方送过来的星尘服务端地址
if (set.Server.IsNullOrEmpty() && !info.Server.IsNullOrEmpty())
{
set.Server = info.Server;
set.Save();
XTrace.WriteLine("StarAgent使用应用[{0}]送过来的星尘服务端地址：{1}", info.ProcessName, info.Server);
if (Service is MyService svc)
{
ThreadPoolX.QueueUserWorkItem(() =>
{
svc.StartFactory();
svc.StartClient();
});
}
}
var ai = AgentInfo.GetLocal();
ai.Server = set.Server;
ai.Services = Manager?.Services.Select(e => e.Name).ToArray();
return(ai);
}
/// <summary>
/// 接收注册中心的消息
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void m_CometClient_OnReceiveNotify(object sender, CometEventArgs e)
{
try
{
if (e.Type == CometEventType.ReceiveMessage) // 接收到来自服务器的配置信息
{
RegistryMessage rm = XmlUtil.LoadObjFromXML <RegistryMessage>(e.Response);
if (rm.Action == RegistryMessageAction.ServiceConfig)
{
m_ESBProxy.ESBConfig = XmlUtil.LoadObjFromXML <ESBConfig>(rm.MessageBody);
ThreadPoolX.QueueUserWorkItem(x =>
{
m_ConfigurationManager.SaveESBConfig(m_ESBProxy.ESBConfig);
});
}
}
else if (e.Type == CometEventType.Connected) // 当和服务器取得联系时发送消费者配置文件到服务端
{
m_CometClient.SendData(RegistryMessageAction.Hello, m_ESBProxy.ConsumerConfig.ToXml());
}
}
catch (Exception ex)
{
XTrace.WriteLine("接收注册中心消息时发生错误：" + ex.ToString());
}
}
/// <summary>注册区域</summary>
/// <param name="context"></param>
public override void RegisterArea(AreaRegistrationContext context)
{
base.RegisterArea(context);
context.Routes.IgnoreRoute("bootstrap/{*relpath}");
//// 自动解压Bootstrap
//var bs = "bootstrap".AsDirectory();
//if (!bs.Exists)
//{
// var bszip = "bootstrap.zip".GetFullPath();
// if (File.Exists(bszip))
// {
// XTrace.WriteLine("自动解压释放Bootstrap");
// ZipFile.Extract(bszip, ".".GetFullPath());
// }
//}
//// 绑定资源，绑定路径不能跟物理目录相同，否则因为上面的忽略路由而得不到处理
//var bundles = BundleTable.Bundles;
//bundles.Add(new StyleBundle("~/bootstrap_css").IncludeDirectory("~/bootstrap/css", "*.css", true));
//bundles.Add(new ScriptBundle("~/bootstrap_js").IncludeDirectory("~/bootstrap/js", "*.js", true));
// 自动检查并下载魔方资源
ThreadPoolX.QueueUserWorkItem(CheckContent);
// 自动检查并添加菜单
XTrace.WriteLine("初始化权限管理体系");
var user = ManageProvider.User;
}
public async void Test1()
{
var q = new MemoryQueue <String>();
Assert.True(q.IsEmpty);
Assert.Equal(0, q.Count);
q.Add("test");
q.Add("newlife", "stone");
Assert.False(q.IsEmpty);
Assert.Equal(3, q.Count);
var s1 = q.TakeOne();
Assert.Equal("test", s1);
var ss = q.Take(3).ToArray();
Assert.Equal(2, ss.Length);
ThreadPoolX.QueueUserWorkItem(() =>
{
Thread.Sleep(1100);
q.Add("delay");
});
var s2 = await q.TakeOneAsync(1500);
Assert.Equal("delay", s2);
}
static XTrace()
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
ThreadPoolX.Init();
}
private void Push(Object state)
{
if (Queue.Count == 0)
{
return;
}
if (Subscribers.Count == 0)
{
return;
}
ThreadPoolX.QueueUserWorkItem(() =>
{
while (Queue.Count > 0)
{
// 消息出列
var item = Queue.Dequeue();
// 向每一个订阅者推送消息
foreach (var ss in Subscribers)
{
ss.SendMessage(item);
}
}
});
}
/// <summary>读取管道过滤后最终处理消息</summary>
/// <param name="message"></param>
public override void FireRead(Object message)
{
// 经历编码器管道，万水千山来到这里！
// 对于消息协议来说，意味着协议解包已经完成，IOCP层可以着手去接收下一消息，而无需等待当前消息是否已处理完成
if (!Session.ProcessAsync)
{
var ori = Data as ReceivedEventArgs;
var e = new ReceivedEventArgs
{
Remote = ori.Remote,
Message = message,
UserState = ori.UserState,
};
// 如果消息使用了原来SEAE的数据包，需要拷贝，避免多线程冲突
// 也可能在粘包处理时，已经拷贝了一次
if (ori.Packet != null && message is IMessage msg)
{
if (msg.Payload != null && ori.Packet.Data == msg.Payload.Data)
{
msg.Payload = msg.Payload.Clone();
}
}
// 异步处理
ThreadPoolX.QueueUserWorkItem(Session.Process, e);
}
else
{
var data = Data ?? new ReceivedEventArgs();
data.Message = message;
Session.Process(data);
}
}
/// <summary>执行</summary>
public static void Execute()
{
var list = new List <Event>();
var events = ScheduleConfigInfo.Current.Events;
if (events != null && events.Length > 0)
{
foreach (var ev in events)
{
if (ev.Enabled)
{
list.Add(new Event
{
Key = ev.Key,
Minutes = ev.Minutes,
ScheduleType = ev.ScheduleType,
TimeOfDay = ev.TimeOfDay
});
}
}
}
foreach (var ev in list)
{
if (ev.ShouldExecute)
{
ev.UpdateTime();
if (ev.IEventInstance != null)
{
ThreadPoolX.QueueUserWorkItem(ev.IEventInstance.Execute);
}
}
}
}
private void Work(Object state)
{
if (_Running)
{
return;
}
if (Entities.Count == 0)
{
return;
}
IEntity[] es = null;
lock (this)
{
es = Entities.ToArray();
Entities.Clear();
}
if (es.Length == 0)
{
return;
}
_Running = true;
ThreadPoolX.QueueUserWorkItem(Process, es);
}
private void btnExecute_Click(Object sender, EventArgs e)
{
var sql = txtSQL.Text;
if (sql.IsNullOrWhiteSpace())
{
return;
}
ThreadPoolX.QueueUserWorkItem(() =>
{
var sw = Stopwatch.StartNew();
String msg = null;
try
{
var n = Dal.Session.Execute(sql);
msg = String.Format("执行完成！共影响{0}行！", n);
}
catch (Exception ex)
{
msg = ex.Message;
}
finally
{
sw.Stop();
msg += String.Format(" 耗时{0}", sw.Elapsed);
}
this.Invoke(() => lbStatus.Text = msg);
});
}
void UpdateCache(Boolean nodata)
{
// 异步更新时，如果为空，表明首次，同步获取数据
// 有且仅有非首次且数据不为空时执行异步查询
if (Times > 0 && Asynchronous && !nodata)
{
// 这里直接计算有效期，避免每次判断缓存有效期时进行的时间相加而带来的性能损耗
// 设置时间放在获取缓存之前，让其它线程不要空等
ExpiredTime = DateTime.Now.AddSeconds(Expire);
Times++;
if (Debug)
{
var reason = Times == 1 ? "第一次" : (nodata ? "无缓存数据" : Expire + "秒过期");
DAL.WriteLog("异步更新实体缓存（第{2}次）：{0} 原因：{1} {3}", typeof(TEntity).FullName, reason, Times, XTrace.GetCaller(3, 16));
}
ThreadPoolX.QueueUserWorkItem(FillWaper, Times);
}
else
{
Times++;
if (Debug)
{
var reason = Times == 1 ? "第一次" : (nodata ? "无缓存数据" : Expire + "秒过期");
DAL.WriteLog("更新实体缓存（第{2}次）：{0} 原因：{1} {3}", typeof(TEntity).FullName, reason, Times, XTrace.GetCaller(3, 16));
}
FillWaper(Times);
// 这里直接计算有效期，避免每次判断缓存有效期时进行的时间相加而带来的性能损耗
// 设置时间放在获取缓存之后，避免缓存尚未拿到，其它线程拿到空数据
ExpiredTime = DateTime.Now.AddSeconds(Expire);
}
}
private DataSchema(UserConn conn)
{
m_conn = conn;
m_initStatus = DataSchemaInitStatus.Initializing;
m_initError = String.Empty;
ThreadPoolX.QueueUserWorkItem(x => InitDataSchema());
}
/// <summary>初始化数据</summary>
protected internal override void InitData()
{
// 预热数据
if (Meta.Session.Count > 0)
{
ThreadPoolX.QueueUserWorkItem(() => Preload());
}
}
void OnPost(Object sender, EventArgs e)
{
if (!WebOnline && !WebBehavior && !WebStatistics)
{
return;
}
var ctx = HttpContext.Current;
if (ctx == null)
{
return;
}
var req = ctx.Request;
if (req == null)
{
return;
}
var user = ctx.User?.Identity as IManageUser ?? ManageProvider.User as IManageUser;
var sid = ctx.Session?.SessionID;
var ip = WebHelper.UserHost;
var page = GetPage(req);
var title = GetTitle(ctx, req);
var msg = GetMessage(ctx, req, title);
ThreadPoolX.QueueUserWorkItem(() =>
{
try
{
// 统计网页状态
if (WebOnline && !sid.IsNullOrEmpty())
{
UserOnline.SetWebStatus(sid, page, msg, user, ip);
}
// 记录用户访问的Url
if (WebBehavior)
{
SaveBehavior(user, ip, page, msg);
}
// 每个页面的访问统计
if (WebStatistics)
{
SaveStatistics(ctx, user, ip, page, title);
}
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
});
}
void MakeTree(String path, TreeNode Node)
{
BizLog.Info("展开目录 {0}", path);
Node.Nodes.Clear();
////修正大小
//if (Node.Text.EndsWith("-1 Byte"))
//{
// Node.Text = Node.Text.Substring(0, Node.Text.Length - 8) + FormatSize(FolderSize(Node.Tag.ToString()));
//}
var di = new DirectoryInfo(path);
var dis = di.GetDirectories();
var fis = di.GetFiles();
var list = new List <FileSystemInfo>();
list.AddRange(dis);
list.AddRange(fis);
var max = 0;
foreach (var item in list)
{
max = Math.Max(max, StrLen(item.Name));
}
max++;
foreach (var item in list)
{
var len = max;
len -= (StrLen(item.Name) - item.Name.Length);
Int64 size = 0;
if (item is FileInfo)
{
size = (item as FileInfo).Length;
}
else//默认不统计大小，加快显示速度
{
size = -1;
}
var str = String.Format("{0,-" + len.ToString() + "} {1,10}", item.Name, FormatSize(size));
var tn = Node.Nodes.Add(str);
tn.Tag = item;
tn.BackColor = GetColor(size);
tn.ContextMenuStrip = contextMenuStrip1;
if (item is DirectoryInfo)
{
tn.Nodes.Add("no");
//使用后台线程统计大小信息
ThreadPoolX.QueueUserWorkItem(() => TongJi(tn));
}
}
}
/// <summary>用一个事件参数来开始异步接收</summary>
/// <param name="se">事件参数</param>
/// <param name="io">是否在IO线程调用</param>
/// <returns></returns>
Boolean StartReceive(SocketAsyncEventArgs se, Boolean io)
{
if (Disposed)
{
ReleaseRecv(se, "Disposed " + se.SocketError);
throw new ObjectDisposedException(GetType().Name);
}
var rs = false;
try
{
// 开始新的监听
rs = OnReceiveAsync(se);
}
catch (Exception ex)
{
ReleaseRecv(se, "ReceiveAsyncError " + ex.Message);
if (!ex.IsDisposed())
{
OnError("ReceiveAsync", ex);
// 异常一般是网络错误，UDP不需要关闭
if (!io && ThrowException)
{
throw;
}
}
return(false);
}
// 同步返回0数据包，断开连接
if (!rs && se.BytesTransferred == 0 && se.SocketError == SocketError.Success)
{
Close("BytesTransferred == 0");
Dispose();
return(false);
}
// 如果当前就是异步线程，直接处理，否则需要开任务处理，不要占用主线程
if (!rs)
{
if (io)
{
ProcessEvent(se, -1);
}
else
{
ThreadPoolX.QueueUserWorkItem(s => ProcessEvent(s, -1), se);
}
}
return(true);
}
/// <summary>同步或异步收到数据</summary>
/// <param name="se"></param>
void ProcessEvent(SocketAsyncEventArgs se)
{
if (!Active)
{
ReleaseRecv(se, "!Active " + se.SocketError);
return;
}
// 判断成功失败
if (se.SocketError != SocketError.Success)
{
// 未被关闭Socket时，可以继续使用
if (OnReceiveError(se))
{
var ex = se.GetException();
if (ex != null)
{
OnError("ReceiveAsync", ex);
}
ReleaseRecv(se, "SocketError " + se.SocketError);
return;
}
}
else
{
var ep = se.RemoteEndPoint as IPEndPoint ?? Remote.EndPoint;
var pk = new Packet(se.Buffer, se.Offset, se.BytesTransferred);
if (ProcessAsync)
{
// 拷贝走数据，参数要重复利用
pk = pk.Clone();
// 根据不信任用户原则，这里另外开线程执行用户逻辑
// 有些用户在处理数据时，又发送数据并等待响应
ThreadPoolX.QueueUserWorkItem(() => ProcessReceive(pk, ep));
}
else
{
// 同步执行，直接使用数据，不需要拷贝
// 直接在IO线程调用业务逻辑
ProcessReceive(pk, ep);
}
}
// 开始新的监听
if (Active && !Disposed)
{
ReceiveAsync(se, true);
}
else
{
ReleaseRecv(se, "!Active || Disposed");
}
}
static XTrace()
{
#if __CORE__
#else
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
#endif
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
ThreadPoolX.Init();
}
void UpdateCacheAsync(String reason)
{
// 控制只有一个线程能更新
if (Interlocked.CompareExchange(ref _updating, 1, 0) != 0)
{
return;
}
ThreadPoolX.QueueUserWorkItem(UpdateCache, reason);
}
/// <summary>注册区域</summary>
/// <param name="context"></param>
public override void RegisterArea(AreaRegistrationContext context)
{
var ns = GetType().Namespace + ".Controllers";
XTrace.WriteLine("开始注册权限管理区域[{0}]，控制器命名空间[{1}]", AreaName, ns);
// 注册本区域默认路由
// Json输出，需要配置web.config
//context.MapRoute(
// AreaName + "_Data",
// AreaName + "/{controller}.json/",
// new { controller = "Index", action = "Index", id = UrlParameter.Optional, output = "json" },
// new[] { ns }
//);
// Json输出，不需要配置web.config
//context.MapRoute(
// AreaName + "_Json",
// AreaName + "/{controller}Json/{action}/{id}",
// new { controller = "Index", action = "Export", id = UrlParameter.Optional, output = "json" },
// new[] { ns }
//);
//context.MapRoute(
// AreaName + "_Detail",
// AreaName + "/{controller}/{id}",
// new { controller = "Index", action = "Detail" },
// new[] { ns }
//);
//context.MapRoute(
// AreaName + "_Detail_Json",
// AreaName + "/{controller}/{id}/Json",
// new { controller = "Index", action = "Detail", output = "json" },
// new { id = @"\d+" },
// new[] { ns }
//);
//context.MapRoute(
// AreaName + "_Json",
// AreaName + "/{controller}/Json",
// new { controller = "Index", action = "Index", output = "json" },
// new[] { ns }
//);
// 本区域默认配置
context.MapRoute(
AreaName,
AreaName + "/{controller}/{action}/{id}",
new { controller = "Index", action = "Index", id = UrlParameter.Optional },
new[] { ns }
);
// 所有已存在文件的请求都交给Mvc处理，比如Admin目录
//routes.RouteExistingFiles = true;
// 自动检查并添加菜单
ThreadPoolX.QueueUserWorkItem(ScanController);
}
private Int32 ServiceCommandCallbackEx(ControlOptions command, Int32 eventType, IntPtr eventData, IntPtr eventContext)
{
if (command != ControlOptions.PowerEvent &&
command != ControlOptions.SessionChange &&
command != ControlOptions.Interrogate)
{
XTrace.WriteLine("ServiceCommandCallbackEx(command={0}, eventType={1}, eventData={2:x}, eventContext={3:x})", command, eventType, eventData, eventContext);
}
switch (command)
{
case ControlOptions.Interrogate:
ReportStatus(_status.currentState, 0, false);
break;
case ControlOptions.Stop:
case ControlOptions.Shutdown:
ReportStatus(ServiceControllerStatus.StopPending);
ThreadPoolX.QueueUserWorkItem(() =>
{
try
{
_service.StopLoop();
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
ReportStatus(ServiceControllerStatus.Stopped);
});
break;
case ControlOptions.PowerEvent:
XTrace.WriteLine("PowerEvent {0}", (PowerBroadcastStatus)eventType);
break;
case ControlOptions.SessionChange:
var sessionNotification = new WTSSESSION_NOTIFICATION();
Marshal.PtrToStructure(eventData, sessionNotification);
XTrace.WriteLine("SessionChange {0}, {1}", (SessionChangeReason)eventType, sessionNotification.sessionId);
break;
case ControlOptions.TimeChange:
var time = new SERVICE_TIMECHANGE_INFO();
Marshal.PtrToStructure(eventData, time);
XTrace.WriteLine("TimeChange {0}=>{1}", DateTime.FromFileTime(time.OldTime), DateTime.FromFileTime(time.NewTime));
break;
default:
ReportStatus(_status.currentState);
break;
}
return(0);
}
static DeviceSession()
{
// 异步初始化数据
ThreadPoolX.QueueUserWorkItem(() =>
{
var n = 0;
n = Device.Meta.Count;
n = DeviceOnline.Meta.Count;
n = DeviceHistory.Meta.Count;
});
}
private static void NewBiliRtmpPush()
{
// Thread bgPushMusic = new Thread(BgMusicPush);
// bgPushMusic.Start();
// Thread bgFFmpeg = new Thread(BgFFmpegRun);
// bgFFmpeg.Start();
// ThreadPoolX.QueueUserWorkItem(BgMusicPush);
// ThreadPoolX.QueueUserWorkItem(BgFFmpegRun);
// ThreadPoolX.QueueUserWorkItem(BgFFmpegPush);
ThreadPoolX.QueueUserWorkItem(BgFFmpegRunEx);
}
static UserSession()
{
// 异步初始化数据
ThreadPoolX.QueueUserWorkItem(() =>
{
var n = 0;
n = User.Meta.Count;
n = UserOnline.Meta.Count;
n = UserHistory.Meta.Count;
});
}
