You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

463 lines
15 KiB

using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Reflection;
using System.Text;
using System.Threading;
namespace Apewer
{
/// <summary>Cron 特性,默认间隔为 60 秒。</summary>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public sealed class CronAttribute : Attribute, IToJson
{
#region attribute
private int _mode = 0;
private int _seconds = 0;
private CronCycle _cycle = CronCycle.Once;
/// <summary>获取秒数。</summary>
public int Seconds { get { return _seconds; } }
/// <summary>创建 Cron 特性,可指定两次 Cron 执行的间隔秒数。</summary>
public CronAttribute(int seconds = 60)
{
_mode = 1;
_seconds = seconds;
if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));
}
/// <summary>创建 Cron 特性,在每个周期中延迟指定秒数后执行。</summary>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public CronAttribute(CronCycle cycle, int seconds = 0)
{
_mode = 2;
_cycle = cycle;
_seconds = seconds;
if (seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));
}
/// <summary>生成 Json 对象。</summary>
public Json ToJson()
{
var mode = _mode == 1 ? "interval" : "cycle";
var type = _type == null ? null : _type.FullName;
var json = Json.NewObject();
json.SetProperty("type", type);
json.SetProperty("mode", mode);
if (_mode == 2) json.SetProperty("cycle", _cycle.ToString().ToLower());
json.SetProperty("second", _seconds);
return json;
}
/// <summary></summary>
public override string ToString()
{
if (_type != null)
{
if (_mode == 1) return $"Type = {_type.FullName}, Seconds = {_seconds}";
if (_mode == 2) return $"Type = {_type.FullName}, Cycle = {_cycle}, Seconds = {_seconds}";
}
return base.ToString();
}
#endregion
#region payload
/// <summary>执行 Cron 的类。</summary>
public Type Type { get => _type; }
// 传入。
Type _type = null;
Logger _logger = null;
bool _event = false;
// 实时。
Thread _thread = null;
bool _alive = false;
bool _break = false;
/// <summary>运行当前 Cron。</summary>
void Run()
{
if (_alive) return;
if (_type == null) return;
_break = false;
UsePool(pool =>
{
if (pool.ContainsKey(_type)) return;
pool.Add(_type, this);
_alive = true;
_thread = new Thread(Payload);
_thread.IsBackground = false;
_thread.Start();
});
}
// 当前进程睡眠。
static void Sleep() => Thread.Sleep(500);
// 线程负载。
void Payload()
{
// 基于间隔时间调用。
if (_mode == 1)
{
// 初始值为最小值,保证第一次启动时必定运行。
var next = DateTime.MinValue;
while (true)
{
if (_break || _break_all) break;
if (_now < next)
{
Sleep();
if (_break || _break_all) break;
continue;
}
Invoke();
next = DateTime.Now.AddSeconds(_seconds);
}
}
// 仅执行一次,延迟启动。
if (_mode == 2 && _cycle == CronCycle.Once)
{
var next = DateTime.Now.AddSeconds(_seconds);
while (_now < next)
{
if (_break || _break_all) break;
Sleep();
if (_break || _break_all) break;
}
Invoke();
}
// 基于周期调用。
if (_mode == 2 && _cycle != CronCycle.Once)
{
// 计算当前期间的运行时间。
DateTime next = DateTime.Now;
switch (_cycle)
{
case CronCycle.Minute:
next = new DateTime(next.Year, next.Month, next.Day, next.Hour, next.Minute, 0, 0);
break;
case CronCycle.Hour:
next = new DateTime(next.Year, next.Month, next.Day, next.Hour, 0, 0, 0);
break;
case CronCycle.Day:
next = new DateTime(next.Year, next.Month, next.Day, 0, 0, 0, 0);
break;
case CronCycle.Week:
next = new DateTime(next.Year, next.Month, next.Day, 0, 0, 0, 0).AddDays(-(int)next.DayOfWeek);
break;
}
if (_seconds > 0) next = next.AddSeconds(_seconds);
// 启动循环。
while (true)
{
if (_break || _break_all) break;
if (_now < next)
{
Sleep();
if (_break || _break_all) break;
continue;
}
Invoke();
switch (_cycle)
{
case CronCycle.Minute:
next = next.AddMinutes(1);
break;
case CronCycle.Hour:
next = next.AddHours(1);
break;
case CronCycle.Day:
next = next.AddDays(1);
break;
case CronCycle.Week:
next = next.AddDays(7);
break;
default:
_alive = false;
return;
}
}
}
UsePool(pool =>
{
if (pool.ContainsKey(_type)) pool.Remove(_type);
_break = false;
_alive = false;
});
}
void Invoke()
{
var caption = CaptionAttribute.Parse(_type);
var sender = caption?.Title;
if (sender.IsEmpty()) sender = _type.Name;
if (_event) _logger.Text(sender, "Beginning");
var instance = null as object;
try
{
instance = Activator.CreateInstance(_type);
if (_event) _logger.Text(sender, "Ended");
}
catch (Exception ex)
{
_logger.Exception(ex.InnerException, sender);
}
RuntimeUtility.Dispose(instance);
}
#endregion
#region pool
static Dictionary<Type, CronAttribute> _pool = new Dictionary<Type, CronAttribute>();
static void UsePool(Action<Dictionary<Type, CronAttribute>> callback)
{
if (callback == null) throw new ArgumentNullException(nameof(callback));
lock (_pool)
{
callback.Invoke(_pool);
}
}
static T UsePool<T>(Func<Dictionary<Type, CronAttribute>, T> callback)
{
if (callback == null) throw new ArgumentNullException(nameof(callback));
lock (_pool)
{
return callback.Invoke(_pool);
}
}
#endregion
#region invoker
static bool _break_all = false;
static DateTime _now;
/// <summary>获取状态,指示打断 Cron 循环。</summary>
public static bool Breaking { get => _break_all; }
/// <summary>正在运行的 Cron 数量。</summary>
public static int AliveCount { get => CountAlive(UsePool(pool => pool.Values)); }
/// <summary>获取正在运行的 Cron 数量。</summary>
/// <returns></returns>
static int CountAlive(IEnumerable<CronAttribute> crons)
{
var alive = 0;
foreach (var cron in crons)
{
if (cron._alive) alive += 1;
}
return alive;
}
static CronAttribute[] Init(IEnumerable<Assembly> assemblies, Logger logger, bool logEvent)
{
var ab = new ArrayBuilder<CronAttribute>();
if (assemblies == null) assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
var types = assembly.GetTypes();
foreach (var type in types)
{
if (!type.IsClass) continue;
if (type.IsAbstract) continue;
if (!RuntimeUtility.CanNew(type)) continue;
var attributes = type.GetCustomAttributes(false);
if (attributes == null) continue;
foreach (var attribute in attributes)
{
var cron = attribute as CronAttribute;
if (cron == null) continue;
cron._type = type;
cron._logger = logger;
cron._event = logEvent;
ab.Add(cron);
}
}
}
var array = ab.Export();
return array;
}
/// <summary>启动指定的 Cron。</summary>
/// <exception cref="ArgumentNullException"></exception>
public static void Start(CronAttribute cron)
{
if (cron == null) throw new ArgumentNullException(nameof(cron));
cron.Run();
}
/// <summary>开始 Cron 调用(阻塞当前线程)。</summary>
/// <param name="assemblies">包含 Cron 的程序集,不指定此参数时将在 AppDomain 中搜索。</param>
/// <param name="logger">日志记录程序,不指定此参数时将使用 Logger.Default。</param>
/// <param name="logEvent">对 Cron 开始和结束记录日志。</param>
/// <remarks>
/// 参数<br />
/// - assemblies: 包含 Cron 的程序集,不指定此参数时将在 AppDomain 中搜索;<br />
/// - logger: 日志记录程序,不指定此参数时将使用 Logger.Default;<br />
/// - logEvent:对 Cron 开始和结束记录日志。
/// </remarks>
public static void Start(IEnumerable<Assembly> assemblies = null, Logger logger = null, bool logEvent = true)
{
if (logger == null) logger = Logger.Default;
// 设置控制台事件。
Console.CancelKeyPress += (s, e) =>
{
_break_all = true;
e.Cancel = true;
};
// 初始化。
_now = DateTime.Now;
var crons = Init(assemblies, logger, logEvent);
if (crons.Length > 0)
{
logger.Text(nameof(CronAttribute), "Crons started。");
// 启动 Cron。
foreach (var cron in crons) Start(cron);
// 等待 Cron 退出。
while (true)
{
Thread.Sleep(100);
_now = DateTime.Now;
if (AliveCount < 1) break;
}
}
logger.Text(nameof(CronAttribute), "Crons ended。");
}
/// <summary>打断指定的 Cron。</summary>
/// <exception cref="ArgumentNullException" />
public static void Abort(Type type)
{
if (type == null) throw new ArgumentNullException(nameof(type));
UsePool(pool =>
{
if (pool.TryGetValue(type, out var cron))
{
try { cron._thread.Abort(); } catch { }
}
pool.Remove(type);
});
}
/// <summary>打断指定的 Cron。</summary>
/// <exception cref="ArgumentNullException" />
public static void Abort(object instance)
{
if (instance == null) throw new ArgumentNullException(nameof(instance));
if (instance is Type type) Abort(type);
else Abort(instance.GetType());
}
/// <summary>打断所有 Cron。</summary>
public static void Abort()
{
UsePool(pool =>
{
foreach (var item in pool)
{
try
{
item.Value._thread.Abort();
item.Value._alive = false;
item.Value._break = false;
}
catch { }
}
});
}
/// <summary>打断 Cron 循环,不打断正在执行的 Job。</summary>
/// <exception cref="ArgumentNullException" />
public static void Break(Type type)
{
if (type == null) throw new ArgumentNullException(nameof(type));
UsePool(pool =>
{
if (pool.TryGetValue(type, out var cron))
{
cron._break = true;
}
});
}
/// <summary>打断 Cron 循环,不打断正在执行的 Job。</summary>
/// <exception cref="ArgumentNullException" />
public static void Break(object instance)
{
if (instance == null) throw new ArgumentNullException(nameof(instance));
if (instance is Type type) Break(type);
else Break(instance.GetType());
}
/// <summary>打断 Cron 循环,不打断正在执行的 Job。</summary>
public static void Break()
{
_break_all = true;
}
/// <summary>打断 Cron 循环并等待 Job 执行结束。等待指定的时间后打断正在执行的 Job。</summary>
/// <param name="timeout">强制打断前的等待毫秒数,指定为负数时将无限等待。</param>
public static void Break(int timeout)
{
_break_all = true;
const int interval = 100;
if (timeout < 0)
{
while (AliveCount > 0) Thread.Sleep(interval);
return;
}
else
{
if (timeout > 0)
{
var remains = timeout;
while (remains > 0 && AliveCount > 0)
{
Thread.Sleep(interval);
remains -= interval;
}
}
Abort();
}
}
#endregion
}
}