private static void RunExpirationHandler(TaskHandle handle)
{
bool succeeded = false;
do
{
if (_fullTrust)
{
try
{
ThreadPool.UnsafeQueueUserWorkItem(handle.TimeoutHandler, handle.UserState);
succeeded = true;
}
catch (SecurityException ex)
{
_fullTrust = false;
_log.WarnFormat("Failed ThreadPool.UnsafeQueueUserWorkItem for security reasons. Switching to use ThreadPool.QueueUserWorkItem: {0}", ex);
}
}
else
{
ThreadPool.QueueUserWorkItem(handle.TimeoutHandler, handle.UserState);
succeeded = true;
}
}while (!succeeded);
}
/// <summary>
/// <para>Registers a monitor that will invoke <paramref name="timeoutHandler"/> with argument
/// <paramref name="state"/> if the consumer does not successfully invoke
/// <see cref="ITaskHandle.TrySetComplete"/> on the return value before the specified timeout
/// elapses. <paramref name="timeout"/> will be rounded up to the nearest multiple of
/// <see cref="TimeoutFactor"/> for performance reasons.</para>
/// </summary>
/// <param name="timeout">
/// <para>The time, in milliseconds, allowed to elapse before the timeout handler will be invoked.
/// This value will be rounded up to the nearest multiple of <see cref="TimeoutFactor"/>
/// for performance reasons. If <see cref="Timeout.Infinite"/> (-1) is specified <paramref name="timeoutHandler"/>
/// will never be called. 0 or values less than -1 are not valid.</para>
/// </param>
/// <param name="timeoutHandler">The timeout handler that will run in the event of a timeout.</param>
/// <param name="state">The user-defined state object that will be passed to <paramref name="timeoutHandler"/>.</param>
/// <returns>
/// <para>A <see cref="ITaskHandle"/> implementation that must be set to a complete state
/// before <paramref name="timeout"/> elapses. If not set <paramref name="timeoutHandler"/>
/// will be invoked.</para>
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="timeout"/> timeout is not a positive integer greater than zero or <see cref="Timeout.Infinite"/> (-1).</para>
/// </exception>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="timeoutHandler"/> is <see langword="null"/>.</para>
/// </exception>
public static ITaskHandle RegisterMonitor(int timeout, WaitCallback timeoutHandler, object state)
{
if (timeout != Timeout.Infinite && timeout <= 0)
{
throw new ArgumentOutOfRangeException("timeout", "timeout must be a positive integer greater than zero or Timeout.Infinite (-1).");
}
if (timeoutHandler == null)
{
throw new ArgumentNullException("timeoutHandler");
}
var handle = new TaskHandle
{
TimeoutHandler = timeoutHandler,
UserState = state
};
handle.Start();
if (timeout != Timeout.Infinite)
{
var queue = GetQueue(timeout);
lock (queue)
{
queue.Enqueue(handle);
}
}
return(handle);
}
internal WurmLogFiles(IWurmCharacterDirectories wurmCharacterDirectories, IWurmApiLogger logger, IWurmLogDefinitions wurmLogDefinitions,
[NotNull] IInternalEventAggregator eventAggregator, [NotNull] IInternalEventInvoker internalEventInvoker,
[NotNull] TaskManager taskManager, [NotNull] IWurmPaths wurmPaths)
{
if (wurmCharacterDirectories == null)
{
throw new ArgumentNullException(nameof(wurmCharacterDirectories));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (wurmLogDefinitions == null)
{
throw new ArgumentNullException(nameof(wurmLogDefinitions));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
if (internalEventInvoker == null)
{
throw new ArgumentNullException(nameof(internalEventInvoker));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
if (wurmPaths == null)
{
throw new ArgumentNullException(nameof(wurmPaths));
}
this.wurmCharacterDirectories = wurmCharacterDirectories;
this.logger = logger;
this.wurmLogDefinitions = wurmLogDefinitions;
this.eventAggregator = eventAggregator;
this.internalEventInvoker = internalEventInvoker;
this.taskManager = taskManager;
this.wurmPaths = wurmPaths;
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial WurmLogFiles refresh", this, exception);
}
eventAggregator.Subscribe(this);
taskHandle = new TaskHandle(Refresh, "WurmLogFiles refresh");
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
private void ScheduleTimer(TaskHandle handle)
{
int dueTime = (int)TimeSpan.FromTicks(handle.TicksStarted + _timeoutTicks - DateTime.UtcNow.Ticks).TotalMilliseconds + 1;
if (dueTime < 0)
{
dueTime = 0;
}
_timer.Change(dueTime, Timeout.Infinite);
}
public void Update(object count)
{
for (int i = 0; i < (int)count; i++)
{
//更新UI
UpdateUIHandle?.Invoke(1);
}
//完成更新
TaskHandle?.Invoke();
}
internal WurmConfigs(
[NotNull] IWurmConfigDirectories wurmConfigDirectories,
[NotNull] IWurmApiLogger logger, [NotNull] IPublicEventInvoker publicEventInvoker,
[NotNull] IInternalEventAggregator eventAggregator, [NotNull] TaskManager taskManager)
{
if (wurmConfigDirectories == null)
{
throw new ArgumentNullException(nameof(wurmConfigDirectories));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
this.wurmConfigDirectories = wurmConfigDirectories;
this.logger = logger;
this.publicEventInvoker = publicEventInvoker;
this.eventAggregator = eventAggregator;
this.taskManager = taskManager;
onAvailableConfigsChanged = publicEventInvoker.Create(
() => AvailableConfigsChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
onAnyConfigChanged = publicEventInvoker.Create(
() => AnyConfigChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial configs update", this, exception);
}
taskHandle = new TaskHandle(Refresh, "WurmConfigs update");
taskManager.Add(taskHandle);
eventAggregator.Subscribe(this);
taskHandle.Trigger();
}
public void Enqueue(TaskHandle handle)
{
lock (_queue)
{
_queue.Enqueue(handle);
if (_queue.Count == 1)
{
ScheduleTimer(handle);
}
}
}
/// <summary>
/// 任务参数构造函数
/// </summary>
/// <param name="executeMethod">执行方法</param>
/// <param name="parameter">方法参数</param>
/// <param name="isOnce">是否执行一次</param>
/// <param name="interval">执行间隔（秒），默认为24小时</param>
/// <param name="isExecuteNow">是否立即执行</param>
public BackgroundTask(TaskHandle executeMethod, object parameter = null, bool isOnce = true, int interval = 86400, bool isExecuteNow = false, DateTime?ExecuteDateTime = null)
{
this._ExecuteMethod = executeMethod;
this._Parameter = parameter;
this._IsOnce = isOnce;
this._Interval = interval;
if (interval < 0)
{
this._Interval = 1;
}
this._IsExecuteNow = isExecuteNow;
this._ExecuteDateTime = ExecuteDateTime;
}
internal WurmConfig(string gameSettingsFullPath, [NotNull] IPublicEventInvoker publicEventMarshaller,
[NotNull] TaskManager taskManager, IWurmApiLogger logger)
{
if (gameSettingsFullPath == null)
{
throw new ArgumentNullException(nameof(gameSettingsFullPath));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
gameSettingsFileInfo = new FileInfo(gameSettingsFullPath);
if (gameSettingsFileInfo.Directory == null)
{
throw new WurmApiException("gameSettingsFileInfo.Directory is null, provided file raw path: "
+ gameSettingsFullPath);
}
Name = gameSettingsFileInfo.Directory.Name;
this.taskManager = taskManager;
onConfigChanged = publicEventMarshaller.Create(() => ConfigChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
configReader = new ConfigReader(this);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial config update: " + Name, this, exception);
}
configFileWatcher = new FileSystemWatcher(gameSettingsFileInfo.Directory.FullName)
{
Filter = gameSettingsFileInfo.Name,
NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite
};
configFileWatcher.Changed += ConfigFileWatcherOnChanged;
configFileWatcher.Created += ConfigFileWatcherOnChanged;
configFileWatcher.Deleted += ConfigFileWatcherOnChanged;
configFileWatcher.Renamed += ConfigFileWatcherOnChanged;
configFileWatcher.EnableRaisingEvents = true;
taskHandle = new TaskHandle(Refresh, "WurmConfig update: " + Name);
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
private VoxelModelGenerationRequest(GenerationJob generator, bool async)
{
m_Generator = generator;
if (async)
{
m_Task = TaskFactory.Instance.StartNew(generator);
}
else
{
m_Task = null;
generator.ExecuteTask();
}
m_OutputMesh = null;
}
/**
* 请求任务列表
*/
public void requestTaskList()
{
TaskHandle.getTaskList((error, result) =>
{
if (error == null)
{
userTask = result;
foreach (UserTaskModel task in userTask.list)
{
PKTaskStatus status = (PKTaskStatus)Enum.Parse(typeof(PKTaskStatus), task.task_type_id.ToString());
switch (status)
{
case PKTaskStatus.PKTaskTodayStatus:
{
todayTasks.Add(task);
break;
}
case PKTaskStatus.PKTaskWeekStatus:
{
weekTasks.Add(task);
break;
}
case PKTaskStatus.PKTaskAchievementStatus:
{
achievementTasks.Add(task);
break;
}
case PKTaskStatus.PKTaskChallengeStatus:
{
challengeTasks.Add(task);
break;
}
}
}
// 对任务进行排序
todayTasks = sortTask(todayTasks);
weekTasks = sortTask(weekTasks);
achievementTasks = sortTask(achievementTasks);
challengeTasks = sortTask(challengeTasks);
currentTasks = challengeTasks.ToArray();
currentStatus = PKTaskStatus.PKTaskChallengeStatus;
loadTaskView(false);
}
});
}
private static void BootCallback(TaskHandle taskId, string taskName, var returnValue, TaskExitStatus exitStatus)
{
if (!_booted)
{
string reason = "reason unknown";
if (exitStatus == TaskExitStatus.UnhandledException)
{
if (returnValue != null)
{
Exception exception = returnValue.Cast<Exception>();
reason = exception.ToString() + "\n " + exception.StackTrace;
}
}
throw new NativeError("XaeiOS.Boot process failed to boot: " + reason);
}
}
public Mesh GetMeshOutput()
{
if (m_OutputMesh == null)
{
if (m_Task != null)
{
m_Task.AwaitCompletion();
}
m_OutputMesh = m_Generator.UploadMesh();
// Release everything except the output
m_Task = null;
m_Generator = default;
}
return(m_OutputMesh);
}
public ClientHandle QueueUserTask(UserTask task, Action <TaskStatus> callback)
{
TaskHandle th = new TaskHandle()
{
task = task,
Token = new ClientHandle()
{
ID = Guid.NewGuid()
},
callback = callback
};
lock (syncLock) // main-lock - will be used for accessing ReadyQueue always
{
ReadyQueue.Enqueue(th);
}
return(th.Token);
}
public void GatherOutput(out Mesh mesh, out Material[] materials)
{
if (m_OutputMesh == null)
{
if (m_Task != null)
{
m_Task.AwaitCompletion();
}
m_OutputMesh = new Mesh();
m_Generator.UploadData(m_OutputMesh, out m_OutputMaterials);
// Release everything except the output
m_Task = null;
m_Generator = default;
}
mesh = m_OutputMesh;
materials = m_OutputMaterials;
}
public CHandleMgr()
{
//m_Handle = new Handle[(int)D2CMessage.ECount];
m_byteDataList = new byte[DataDefine.MAX_PACKET_SIZE];
m_Singleton = this;
m_nbyteDataLength = 0;
m_sPacketMinLength = (short)(sizeof(short));
m_HandleDiction = new Dictionary <UInt32, Handle>();
m_HandleList = new ArrayList();
m_LoginHandle = new CLoginHandle(m_Singleton);
m_ResHandle = new CResourceHandle(m_Singleton);
m_ItemHandle = new CItemHandle(m_Singleton);
m_ShopHandle = new CShopHandle(m_Singleton);
m_HeroSkillHandle = new CHeroSkillHandle(m_Singleton);
m_HeroHandle = new CHeroHandle(m_Singleton);
m_RoleHandle = new CRoleHandle(m_Singleton);
m_LotteryHandle = new CLotteryHandle(m_Singleton);
m_ActionPointHandle = new CActionPointHandle(m_Singleton);
m_LotteryHandle = new CLotteryHandle(m_Singleton);
m_GoldHandHandle = new CGoldHandHandle(m_Singleton);
m_LotterHotHandle = new CLotterHotHandle(m_Singleton);
m_MailHandle = new CMailHandle(m_Singleton);
m_ChatHandle = new CChatHandle(m_Singleton);
m_BattleHandle = new CBattleHandle(m_Singleton);
m_MobaHandle = new CMobaHandle(m_Singleton);
m_RankList = new CRankListHandle(m_Singleton);
m_FriendHandle = new CFriendHandle(m_Singleton);
m_TaskHandle = new TaskHandle(m_Singleton);
m_MarqueeHandle = new CMarqueeHandle(m_Singleton);
m_UISign_inHandle = new UISign_inHandle(m_Singleton);
m_GetEnergyHandle = new CGetEnergyHandle(m_Singleton);
m_TitleHandle = new CTitleHandle(m_Singleton);
m_NewplayerReward = new CNewplayerRewardHandle(m_Singleton);
m_WalkHandle = new WalkHandle(m_Singleton);
m_CGuideFuncOpenHandle = new CGuideFuncOpenHandle(m_Singleton);
m_SocietyHandle = new CSocietyHandle(m_Singleton);
m_FixedDataHandle = new CFixedDataHandle(m_Singleton);
m_GuideHandle = new CGuideHandle(m_Singleton);
m_PetHandle = new CPetHandel(m_Singleton);
}
private void handleMessage(TaskSocketMessage msg)
{
log.Info("当前执行线程名称：" + Thread.CurrentThread.GetHashCode());
if (!msg.request && !msg.async)
{
lock (reqReturnMap)
{
reqReturnMap[msg.id] = msg;
}
return;
}
try
{
TaskHandle.handle(msg);
}
catch (Exception exp)
{
log.Error("处理TaskSocketMessage 失败" + JsonConvert.SerializeObject(msg), exp);
}
}
public ClientHandle QueueUserTask(UserTask task, Action <TaskStatus> callback)
{
TaskHandle th = new TaskHandle()
{
task = task,
Token = new ClientHandle()
{
ID = Guid.NewGuid()
},
callback = callback
};
lock (syncLock) // main-lock - will be used for accessing ReadyQueue always
{
ReadyQueue.Enqueue(th);
if (countAddToQueue)
{
totalAddedToQueue++;
}
//Debug.Log ("Send to queue: " + th.Token.ID);
}
return(th.Token);
}
/**
* 任务领取奖励
*/
public void taskReceiveClick(UserTaskModel userTaskModel)
{
TaskHandle.taskReceive(userTaskModel.task_id.ToString(), (error, receiveResult) => {
if (error == null)
{
if (receiveResult.ret == 1)
{
// 成功之后刷新界面
refreshNewTask(userTaskModel, receiveResult.data);
// 更新用户信息
UserInfoRefreshManager.refreshUserInfo(null);
PopUtil.ShowSignInSuccessView(userTaskModel.image_describe);
}
else
{
PopUtil.ShowMessageBoxWithConfirm("提示", "领取失败!");
}
}
else
{
PopUtil.ShowMessageBoxWithConfirm("提示", "领取失败!");
}
});
}
public WurmLogsMonitor([NotNull] IWurmLogFiles wurmLogFiles, [NotNull] IWurmApiLogger logger,
[NotNull] IPublicEventInvoker publicEventInvoker, [NotNull] IInternalEventAggregator internalEventAggregator,
[NotNull] IWurmCharacterDirectories wurmCharacterDirectories,
[NotNull] InternalEventInvoker internalEventInvoker, [NotNull] TaskManager taskManager,
[NotNull] LogFileStreamReaderFactory logFileStreamReaderFactory)
{
if (wurmLogFiles == null)
{
throw new ArgumentNullException(nameof(wurmLogFiles));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (internalEventAggregator == null)
{
throw new ArgumentNullException(nameof(internalEventAggregator));
}
if (wurmCharacterDirectories == null)
{
throw new ArgumentNullException(nameof(wurmCharacterDirectories));
}
if (internalEventInvoker == null)
{
throw new ArgumentNullException(nameof(internalEventInvoker));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
if (logFileStreamReaderFactory == null)
{
throw new ArgumentNullException(nameof(logFileStreamReaderFactory));
}
this.wurmLogFiles = wurmLogFiles;
this.logger = logger;
this.publicEventInvoker = publicEventInvoker;
this.internalEventAggregator = internalEventAggregator;
this.wurmCharacterDirectories = wurmCharacterDirectories;
this.internalEventInvoker = internalEventInvoker;
this.taskManager = taskManager;
this.logFileStreamReaderFactory = logFileStreamReaderFactory;
try
{
Rebuild();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at WurmLogsMonitor initial rebuild", this, exception);
}
internalEventAggregator.Subscribe(this);
taskHandle = new TaskHandle(Rebuild, "WurmLogsMonitor rebuild");
taskManager.Add(taskHandle);
updater = new Task(() =>
{
while (true)
{
if (stop)
{
return;
}
Thread.Sleep(500);
if (stop)
{
return;
}
try
{
foreach (var logsMonitorEngineManager in characterNameToEngineManagers.Values)
{
logsMonitorEngineManager.Update(allEventSubscriptionsTsafe);
}
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "WurmLogsMonitor 'updater' task crashed", this, exception);
}
}
}, TaskCreationOptions.LongRunning);
updater.Start();
taskHandle.Trigger();
}
private void HandleTimerElapsed(object state)
{
bool running = true;
int iteration = 0;
try
{
while (true)
{
lock (_queue)
{
for (int i = 0; i < _maxIterations; ++i)
{
if (_queue.Count == 0)
{
running = false;
break;
}
var handle = _queue.Peek();
if (handle.IsComplete)
{
_queue.Dequeue();
continue;
}
if (IsExpired(handle))
{
_queue.Dequeue();
_expiredQueue.Enqueue(handle);
}
else
{
running = false;
break;
}
}
}
if (!running)
{
break;
}
if (_expiredQueue.Count == 0)
{
Thread.Sleep(iteration & 1);
++iteration;
}
else
{
ClearExpiredQueue();
}
}
}
finally
{
ClearExpiredQueue();
TaskHandle nextHandle = null;
lock (_queue)
{
if (_queue.Count > 0)
{
nextHandle = _queue.Peek();
}
}
if (nextHandle != null)
{
ScheduleTimer(nextHandle);
}
}
}
private object criticalLock = new object(); // to be used for locking Pool
private void InitializeThreadPool()
{
ReadyQueue = new Queue <TaskHandle>();
Pool = new List <TaskItem>();
InitPoolWithMinCapacity(); // initialize Pool with Minimum capacity - that much thread must be kept ready
DateTime LastCleanup = DateTime.Now; // monitor this time for next cleaning activity
taskScheduler = new Thread(() =>
{
do
{
lock (syncLock) // obtaining lock for ReadyQueue
{
while (ReadyQueue.Count > 0 && ReadyQueue.Peek().task == null)
{
ReadyQueue.Dequeue(); // remove cancelled item/s - cancelled item will have it's task set to null
}
int itemCount = ReadyQueue.Count;
for (int i = 0; i < itemCount; i++)
{
TaskHandle readyItem = ReadyQueue.Peek(); // the Top item of queue
bool Added = false;
lock (criticalLock) // lock for the Pool
{
foreach (TaskItem ti in Pool) // while reading the pool another thread should not add/remove to that pool
{
lock (ti) // locking item
{
if (ti.taskState == TaskState.completed)
{ // if in the Pool task state is completed then a different task can be handed over to that thread
ti.taskHandle = readyItem;
ti.taskState = TaskState.notstarted;
Added = true;
ReadyQueue.Dequeue();
break;
}
}
}
if (!Added && Pool.Count < MAX)
{ // if all threads in pool are busy and the count is still less than the Max limit set then create a new thread and add that to pool
TaskItem ti = new TaskItem()
{
taskState = TaskState.notstarted
};
ti.taskHandle = readyItem;
// add a new TaskItem in the pool
AddTaskToPool(ti);
Added = true;
ReadyQueue.Dequeue();
}
}
if (!Added)
{
break; // It's already crowded so try after sometime
}
}
}
if ((DateTime.Now - LastCleanup) > TimeSpan.FromMilliseconds(CLEANUP_INTERVAL)) // It's long time - so try to cleanup Pool once.
{
CleanupPool();
LastCleanup = DateTime.Now;
}
else
{
Thread.Yield(); // either of these two can work - the combination is also fine for our demo.
Thread.Sleep(SCHEDULING_INTERVAL); // Dont run madly in a loop - wait for sometime for things to change.
// the wait should be minimal - close to zero
}
} while (true);
});
taskScheduler.Priority = ThreadPriority.AboveNormal;
taskScheduler.Start();
}
private bool IsExpired(TaskHandle handle)
{
return(handle.TicksStarted + _timeoutTicks <= DateTime.UtcNow.Ticks);
}
public WurmCharacter([NotNull] CharacterName name, [NotNull] string playerDirectoryFullPath,
[NotNull] IWurmConfigs wurmConfigs, [NotNull] IWurmServers wurmServers,
[NotNull] IWurmServerHistory wurmServerHistory,
[NotNull] IWurmApiLogger logger,
[NotNull] TaskManager taskManager, [NotNull] IWurmLogsMonitorInternal logsMonitor,
[NotNull] IPublicEventInvoker publicEventInvoker, [NotNull] InternalEventAggregator internalEventAggregator,
[NotNull] IWurmLogsHistory logsHistory, [NotNull] IWurmPaths wurmPaths,
[NotNull] IWurmServerGroups wurmServerGroups)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (playerDirectoryFullPath == null)
{
throw new ArgumentNullException(nameof(playerDirectoryFullPath));
}
if (wurmConfigs == null)
{
throw new ArgumentNullException(nameof(wurmConfigs));
}
if (wurmServers == null)
{
throw new ArgumentNullException(nameof(wurmServers));
}
if (wurmServerHistory == null)
{
throw new ArgumentNullException(nameof(wurmServerHistory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
if (logsMonitor == null)
{
throw new ArgumentNullException(nameof(logsMonitor));
}
if (publicEventInvoker == null)
{
throw new ArgumentNullException(nameof(publicEventInvoker));
}
if (internalEventAggregator == null)
{
throw new ArgumentNullException(nameof(internalEventAggregator));
}
if (logsHistory == null)
{
throw new ArgumentNullException(nameof(logsHistory));
}
if (wurmPaths == null)
{
throw new ArgumentNullException(nameof(wurmPaths));
}
if (wurmServerGroups == null)
{
throw new ArgumentNullException(nameof(wurmServerGroups));
}
this.wurmConfigs = wurmConfigs;
this.wurmServers = wurmServers;
this.wurmServerHistory = wurmServerHistory;
this.logger = logger;
this.taskManager = taskManager;
this.logsMonitor = logsMonitor;
this.publicEventInvoker = publicEventInvoker;
this.internalEventAggregator = internalEventAggregator;
this.logsHistory = logsHistory;
this.wurmServerGroups = wurmServerGroups;
internalEventAggregator.Subscribe(this);
Name = name;
configDefiningFileFullPath = Path.Combine(playerDirectoryFullPath, ConfigDefinerFileName);
RefreshCurrentConfig();
configUpdateTask = new TaskHandle(RefreshCurrentConfig, "Current config update for player " + Name);
taskManager.Add(configUpdateTask);
configFileWatcher = new FileSystemWatcher(playerDirectoryFullPath)
{
Filter = ConfigDefinerFileName
};
configFileWatcher.Changed += ConfigFileWatcherOnChanged;
configFileWatcher.Created += ConfigFileWatcherOnChanged;
configFileWatcher.Deleted += ConfigFileWatcherOnChanged;
configFileWatcher.Renamed += ConfigFileWatcherOnChanged;
configFileWatcher.EnableRaisingEvents = true;
configUpdateTask.Trigger();
try
{
wurmServerHistory.BeginTracking(Name);
}
catch (Exception exception)
{
logger.Log(LogLevel.Error,
string.Format("Failed to initiate tracking of server history for character {0}", name),
this,
exception);
}
skills = new WurmCharacterSkills(this,
publicEventInvoker,
logsMonitor,
logsHistory,
logger,
wurmPaths,
internalEventAggregator);
Logs = new WurmCharacterLogs(this, wurmServerGroups, logsHistory, wurmServers, logger);
}
protected WurmSubdirsMonitor([NotNull] string directoryFullPath, [NotNull] TaskManager taskManager,
[NotNull] Action onChanged, [NotNull] IWurmApiLogger logger,
[NotNull] Action <string, IWurmPaths> validateDirectory, [NotNull] IWurmPaths wurmPaths)
{
if (directoryFullPath == null)
{
throw new ArgumentNullException(nameof(directoryFullPath));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
if (onChanged == null)
{
throw new ArgumentNullException(nameof(onChanged));
}
if (validateDirectory == null)
{
throw new ArgumentNullException(nameof(validateDirectory));
}
if (wurmPaths == null)
{
throw new ArgumentNullException(nameof(wurmPaths));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
DirectoryFullPath = directoryFullPath;
this.taskManager = taskManager;
this.onChanged = onChanged;
this.validateDirectory = validateDirectory;
this.wurmPaths = wurmPaths;
this.logger = logger;
directoryBlacklist = new Blacklist <string>(logger, "Character directories blacklist");
task = new TaskHandle(Refresh, "WurmSubdirsMonitor for path: " + directoryFullPath);
taskManager.Add(task);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial Refresh of " + GetType().Name, this, exception);
}
fileSystemWatcher = new FileSystemWatcher(directoryFullPath)
{
NotifyFilter = NotifyFilters.DirectoryName
};
fileSystemWatcher.Created += DirectoryMonitorOnDirectoriesChanged;
fileSystemWatcher.Renamed += DirectoryMonitorOnDirectoriesChanged;
fileSystemWatcher.Deleted += DirectoryMonitorOnDirectoriesChanged;
fileSystemWatcher.Changed += DirectoryMonitorOnDirectoriesChanged;
fileSystemWatcher.EnableRaisingEvents = true;
task.Trigger();
}
internal WurmCharacterLogFiles([NotNull] CharacterName characterName, [NotNull] string fullDirPathToCharacterLogsDir, [NotNull] IWurmApiLogger logger, [NotNull] LogFileInfoFactory logFileInfoFactory, [NotNull] IInternalEventInvoker internalEventInvoker,
[NotNull] TaskManager taskManager)
{
if (characterName == null)
{
throw new ArgumentNullException(nameof(characterName));
}
if (fullDirPathToCharacterLogsDir == null)
{
throw new ArgumentNullException(nameof(fullDirPathToCharacterLogsDir));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (logFileInfoFactory == null)
{
throw new ArgumentNullException(nameof(logFileInfoFactory));
}
if (internalEventInvoker == null)
{
throw new ArgumentNullException(nameof(internalEventInvoker));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
this.logger = logger;
this.logFileInfoFactory = logFileInfoFactory;
this.taskManager = taskManager;
CharacterName = characterName;
FullDirPathToCharacterLogsDir = fullDirPathToCharacterLogsDir;
onFilesAddedOrRemoved = internalEventInvoker.Create(() => new CharacterLogFilesAddedOrRemoved(CharacterName));
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial WurmCharacterLogFiles refresh: " + CharacterName, this, exception);
}
directoryWatcher = new FileSystemWatcher(fullDirPathToCharacterLogsDir)
{
Filter = "*.txt",
NotifyFilter = NotifyFilters.FileName
};
directoryWatcher.Created += DirectoryWatcherOnChanged;
directoryWatcher.Deleted += DirectoryWatcherOnChanged;
directoryWatcher.Renamed += DirectoryWatcherOnChanged;
directoryWatcher.Changed += DirectoryWatcherOnChanged;
directoryWatcher.EnableRaisingEvents = true;
taskHandle = new TaskHandle(Refresh, "WurmCharacterLogFiles refresh: " + CharacterName);
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
