/// <summary>
/// Запись происходит в один поток, так как требуется упорядочить сжатые блоки по Id через Hashtable
/// </summary>
private void WritingThread(object obj)
{
FileDescriptor writeFileDescriptor = obj as FileDescriptor;
try
{
using (FileStream writeFileStream = writeFileDescriptor.GetDescription.OpenWrite())
{
while (_lastWritedBlock < _totalCount && !_cancellationToken.IsCancellationRequested)
{
ITaskInfo taskInfo = _writeTaskPool.NextTask() as ITaskInfo;
if (taskInfo == null)
{
Thread.Sleep(1);
continue;
}
taskInfo.Execute(writeFileStream);
_lastWritedBlock++;
}
}
}
catch (Exception exc)
{
Console.WriteLine("Error on file writing");
#if DEBUG
Console.WriteLine(exc);
#endif
}
}
public async Task AddAsync(ITaskInfo task)
{
var context = _contextStorage.Get();
context.Tasks.Add(new TaskEntity(task));
await context.SaveChangesAsync();
}
public PlayerCompletedTaskEvent(IGame game, IClientPlayer clientPlayer, IInnerPlayerControl playerControl, ITaskInfo task)
{
Game = game;
ClientPlayer = clientPlayer;
PlayerControl = playerControl;
Task = task;
}
public void AddTask(ITaskInfo task)
{
lock (this)
{
_tasksInfo.Add(task.GetId(), task);
}
}
protected virtual void TaskDistribution(string serverCode, ITaskInfo taskInfo)
{
IEnumerator enumor = ServerManager.GetServerEnumerator();
taskInfo.EmitServerCode = serverCode;
if (enumor != null)
{
while (enumor.MoveNext())
{
IServerInfo s = (IServerInfo)enumor.Current;
if (string.Compare(serverCode, s.ServerCode, true) != 0 && //去掉自己发给自己
taskInfo.EmitServerCode != s.ServerCode) //去掉发给源服务器
{
if (s.ServerStatus == ServerStatus.Active &&
TaskAllocAlgFactory.GetProvider().Alloc(taskInfo, s))
{
try
{
Console.WriteLine("正在往" + s.ServerCode + "服务器分发数据");
ITaskRequest request = RegisterService.TaskRequestService.GetService(s.ServerCode);
ITaskInfo disTaskInfo = request.SendRequest(s.ServerCode, taskInfo);
}
catch (Exception ex)
{
s.ServerStatus = ServerStatus.Shutdown;
Console.WriteLine("向" + s.ServerCode + "服务器分发数据失败，异常信息为:" + ex.Message + "|" + ex.Source + "|" + ex.StackTrace);
}
}
}
}
}
}
public void AddTask(ITaskInfo task)
{
lock (this)
{
_tasksInfo.Enqueue(task);
}
}
public virtual ITaskInfo Handle(string serverCode, ITaskInfo taskInfo)
{
try
{
IServerInfo s = ServerManager.Get(serverCode);
if (s.ServerStatus == ServerStatus.Active)
{
if (s.TaskBeginHandler != null)
{
s.TaskBeginHandler(serverCode, taskInfo);
}
if (s.TaskHandler != null)
{
s.TaskHandler(serverCode, taskInfo);
}
if (s.TaskEndHandler != null)
{
s.TaskEndHandler(serverCode, taskInfo);
}
}
}
catch (Exception ex)
{
taskInfo.TaskRemark = ex.Message + "|" + ex.Source + "|" + ex.StackTrace;
taskInfo.TaskProcess = TaskProcess.Completed;
taskInfo.TaskStatus = TaskStatus.Failed;
}
return(taskInfo);
}
public static ITaskHandle CreateTaskHandle(ITaskInfo taskInfo)
{
ITaskHandle handle = null;
lock (m_taskHandleObj)
{
m_taskHandleDic.TryGetValue(taskInfo.TaskName, out handle);
}
if (handle == null)
{
string type = TaskHandleManager.GetHandle(taskInfo.TaskName);
if (!string.IsNullOrEmpty(type))
{
Type t = Type.GetType(type);
if (type.IndexOf(",") > 0)
{
string[] arr = type.Split(new char[] { ',' });
ObjectHandle oh = Activator.CreateInstance(arr[1].Trim(), arr[0].Trim());
if (oh != null)
{
handle = oh.Unwrap() as ITaskHandle;
lock (m_taskHandleObj)
{
m_taskHandleDic.Add(taskInfo.TaskName, handle);
}
}
}
}
}
return(handle);
}
/// <summary>
/// Сжатие и генерация задач записи работает в том количестве потоков, сколько процессоров доступно системе,
/// давая распределённую и почти 100% нагрузку на все ядра процессора
/// </summary>
private void CompressingThread()
{
try
{
while (_lastZippedBlock < _totalCount && !_cancellationToken.IsCancellationRequested)
{
// Защита от переполнения памяти
if (_writeTaskPool.TaskCount() > _maxTasks)
{
Thread.Sleep(_sleep);
continue;
}
ITaskInfo taskInfo = _compressTaskPool.NextTask();
if (taskInfo == null)
{
Thread.Sleep(_sleep);
continue;
}
_writeTaskPool.AddTask(_taskFactory.CreateWriteTaskInfo(taskInfo.GetId(), taskInfo.Execute(null) as byte[]));
_lastZippedBlock++;
}
#if DEBUG
Console.WriteLine("End of compressing");
#endif
}
catch (Exception exc)
{
Console.WriteLine("Error on file compressing");
#if DEBUG
Console.WriteLine(exc);
#endif
}
}
public HomeController(ITaskInfo taskInfo, IUserInfo userInfo, ICharacterInfo characterInfo, ITaskManager taskManager, IQuestLogic questLogic)
{
_taskInfo = taskInfo;
_taskManager = taskManager;
_userInfo = userInfo;
_characterInfo = characterInfo;
_questLogic = questLogic;
}
private string GetJITInfo(ITaskInfo someTaskInfo, IAccessProperty somePropInfo)
{
if(mJITChecker == null)
{
return "N/A";
}
return mJITChecker(someTaskInfo.Task,somePropInfo.FullPath) ? "yes" : "no";
}
private string GetJITInfo(ITaskInfo someTaskInfo, IAccessProperty somePropInfo)
{
if (mJITChecker == null)
{
return("N/A");
}
return(mJITChecker(someTaskInfo.Task, somePropInfo.FullPath) ? "yes" : "no");
}
public ITaskInfo SendRequest(string serverCode, ITaskInfo taskInfo)
{
ITaskHandle taskHandle = TaskHandleFactory.CreateTaskHandle(taskInfo);
if (taskHandle != null)
{
return(taskHandle.Handle(serverCode, taskInfo));
}
return(null);
}
protected virtual void TaskDistribution(object obj)
{
object[] objArr = obj as object[];
if (objArr != null && objArr.Length == 2)
{
string serverCode = (string)objArr[0];
ITaskInfo taskInfo = (ITaskInfo)objArr[1];
TaskDistribution(serverCode, taskInfo);
}
}
public TaskEntity(ITaskInfo taskInfo)
{
Name = taskInfo.Name;
Description = taskInfo.Description;
Priority = taskInfo.Priority;
TimeToComplete = taskInfo.TimeToComplete;
Added = taskInfo.Added;
FeatureId = taskInfo.FeatureId;
Status = TaskStatus.Active;
}
public async Task AddAsync(int userId, ITaskInfo task)
{
if (await _projectsDataAccessor.IsProjectCreator(userId, task.FeatureId.Value) ||
await _permissionsDataAccessor.HasPermissionForFeature(userId, task.FeatureId.Value, Permission.CreateTask))
{
await _taskDataAccessor.AddAsync(task);
}
else
{
throw new NoPermissionsForOperationException(ErrorMessages.NoPermissionsForOperation);
}
}
public override ITaskInfo Handle(string serverCode, ITaskInfo taskInfo)
{
try
{
LogMessageTaskInfo log = taskInfo as LogMessageTaskInfo;
IServerInfo s = ServerManager.Get(serverCode);
if (log != null && s != null && s.ServerStatus == ServerStatus.Active)
{
if (s.TaskBeginHandler != null)
{
s.TaskBeginHandler(serverCode, taskInfo);
}
if (s.TaskHandler != null)
{
s.TaskHandler(serverCode, taskInfo);
}
else
{
MsmqLogger logger = MsmqLogger.GetInstance();
if (log.IsList)
{
List <LogMessage> ls = log.CurrLogMessageList;
foreach (LogMessage logMessage in ls)
{
logger.SendMessage(logMessage);
}
taskInfo.TaskProcess = TaskProcess.Completed;
taskInfo.TaskStatus = TaskStatus.Success;
}
else
{
LogMessage lm = log.CurrLogMessage;
logger.SendMessage(lm);
taskInfo.TaskProcess = TaskProcess.Completed;
taskInfo.TaskStatus = TaskStatus.Success;
}
}
if (s.TaskEndHandler != null)
{
s.TaskEndHandler(serverCode, taskInfo);
}
}
}
catch (Exception ex)
{
taskInfo.TaskRemark = ex.Message + "|" + ex.Source + "|" + ex.StackTrace;
taskInfo.TaskProcess = TaskProcess.Completed;
taskInfo.TaskStatus = TaskStatus.Failed;
}
return(taskInfo);
}
public ITaskInfo NextTask()
{
ITaskInfo task = null;
lock (this)
{
if (IsHasTasks())
{
task = _tasksInfo.Dequeue();
}
}
return(task);
}
public ITaskInfo NextTask()
{
ITaskInfo task = null;
lock (this)
{
if (IsHasTasks())
{
if (_tasksInfo.ContainsKey(_last))
{
task = _tasksInfo[_last] as ITaskInfo;
_tasksInfo.Remove(_last++);
}
}
}
return(task);
}
public Task AddTaskToUser(int userId, int taskId, TaskStatus status, ITaskInfo taskInfo)
{
return(_context.Users.UpdateOneAsync(x => x.UserId == userId && !x.Tasks.Any(y => y.Id == taskId),
Builders <UserEntity> .Update.Push(x => x.Tasks, new TaskEntity
{
Id = taskId,
Added = taskInfo.Added,
TimeToComplete = taskInfo.TimeToComplete,
FeatureId = taskInfo.FeatureId,
Name = taskInfo.Name,
Description = taskInfo.Description,
Priority = taskInfo.Priority,
Status = status
}), new UpdateOptions {
IsUpsert = true
}));
}
/// <summary>
/// Метод для потока чтения. Чтение и генерация задач сжатия происходит в 1 поток, что даёт максимальную нагрузку на диск
/// </summary>
/// <param name="obj">
/// Дескриптор файла для записи
/// </param>
private void ReadingThread(object obj)
{
FileDescriptor read_file = obj as FileDescriptor;
try
{
using (FileStream _fileToBeCompressed = read_file.GetDescription.OpenRead())
{
Int64 lastBlock = 0;
while (lastBlock < _totalCount && !_cancellationToken.IsCancellationRequested)
{
// Защита от переполнения памяти
if (_compressTaskPool.TaskCount() > _maxTasks * _cores)
{
Thread.Sleep(1);
continue;
}
ITaskInfo taskInfo = null;
taskInfo = _readTaskPool.NextTask();
if (taskInfo == null)
{
Thread.Sleep(_sleep);
continue;
}
_compressTaskPool.AddTask(_taskFactory.CreateProcessTaskInfo(lastBlock++, (taskInfo.Execute(_fileToBeCompressed) as byte[])));
}
#if DEBUG
Console.WriteLine("End of reading");
#endif
}
}
catch (Exception exc)
{
Console.WriteLine("Error on file reading");
#if DEBUG
Console.WriteLine(exc);
#endif
}
}
/// <summary>
/// Метод для потока чтения. Чтение и генерация задач сжатия происходит в 1 поток, что даёт максимальную нагрузку на диск
/// </summary>
/// <param name="obj">
/// Дескриптор файла для чтения
/// </param>
private void ReadingThread(object obj)
{
FileDescriptor readFile = obj as FileDescriptor;
_fileLength = readFile.GetDescription.Length;
try
{
using (FileStream fileToBeDecompressed = readFile.GetDescription.OpenRead())
{
// Читать блоки архива, пока не закончится файл
while (fileToBeDecompressed.Position < _fileLength && !_cancellationToken.IsCancellationRequested)
{
_position = fileToBeDecompressed.Position;
// Защита от переполнения памяти
if (_compressTaskPool.TaskCount() > _maxTasks * _cores)
{
Thread.Sleep(_sleep);
continue;
}
ITaskInfo task = _taskFactory.CreateReadTaskInfo(_batchCount, 0);
_compressTaskPool.AddTask(_taskFactory.CreateProcessTaskInfo(_batchCount++, task.Execute(fileToBeDecompressed) as byte[]));
}
_isReading = false;
#if DEBUG
Console.WriteLine("End of reading");
#endif
}
}
catch (Exception exc)
{
Console.WriteLine("Error on file reading");
#if DEBUG
Console.WriteLine(exc);
#endif
}
}
public override ITaskInfo Handle(string serverCode, ITaskInfo taskInfo)
{
taskInfo.TaskProcess = TaskProcess.Completed;
taskInfo.TaskStatus = TaskStatus.Success;
return(taskInfo);
}
public override ITaskInfo Handle(string serverCode, ITaskInfo taskInfo)
{
GetFileTransTaskInfo task = taskInfo as GetFileTransTaskInfo;
try
{
string[] res = Directory.GetFiles(@"D:\APP\JinRi.App.Server\", "*.txt");
task.AllFiles = string.Join("|", res);
}
catch (Exception)
{
}
IServerInfo serverInfo = ServerManager.Get(serverCode);
try
{
if (serverInfo.TaskBeginHandler != null)
{
serverInfo.TaskBeginHandler(serverCode, taskInfo);
}
if (serverInfo.TaskHandler != null)
{
serverInfo.TaskHandler(serverCode, taskInfo);
}
else
{
if (task.TransProcess == FileTransProcess.TransDatas)
{
string filename = task.Filename;
if (File.Exists(filename))
{
using (FileStream stream = new FileStream(filename, FileMode.Open))
{
task.FileLength = (int)stream.Length;
task.ReadedBytes = Math.Min(task.FileLength - task.StartPos, task.ReadedBytes);
if (task.ReadedBytes > 0)
{
stream.Position = task.StartPos;
task.Data = new byte[task.ReadedBytes];
task.ReadedBytes = stream.Read(task.Data, 0, task.ReadedBytes);
stream.Close();
}
else
{
task.ReadedBytes = 0;
}
}
}
else
{
task.ReadedBytes = 0;
}
task.TaskStatus = TaskStatus.Success;
task.EmitServerCode = serverInfo.ServerCode;
task.TransProcess = FileTransProcess.TransDatas;
task.TaskCompleteTime = DateTime.Now;
}
}
if (serverInfo.TaskEndHandler != null)
{
serverInfo.TaskEndHandler(serverCode, taskInfo);
}
}
catch (Exception ex)
{
task.TaskRemark = ex.Message + "|" + ex.Source + "|" + ex.StackTrace;
task.TaskStatus = TaskStatus.Failed;
}
return(task);
}
public override ITaskInfo Handle(string serverCode, ITaskInfo taskInfo)
{
FileTransTaskInfo task = taskInfo as FileTransTaskInfo;
IServerInfo serverInfo = ServerManager.Get(serverCode);
try
{
if (serverInfo.TaskBeginHandler != null)
{
serverInfo.TaskBeginHandler(serverCode, taskInfo);
}
if (serverInfo.TaskHandler != null)
{
serverInfo.TaskHandler(serverCode, taskInfo);
}
else
{
if (task.TransProcess == FileTransProcess.TransDatas)
{
ITaskInfo newTask = null;
if (serverInfo.IsDistributionServer)
{
newTask = (ITaskInfo)taskInfo.Clone();
}
if (task.Data != null && task.Data.Length > 0)
{
string filename = task.SaveFilename;
FileStream fs = null;
if (!File.Exists(filename))
{
fs = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.Write);
}
else
{
fs = new FileStream(filename, FileMode.Append, FileAccess.Write);
}
task.TaskStartTime = DateTime.Now;
fs.Write(task.Data, 0, task.Data.Length);
fs.Close();
task.TaskStatus = TaskStatus.Success;
if (serverInfo.IsDistributionServer)
{
Console.WriteLine("开始分发数据");
object[] objArr = new object[] { serverCode, newTask };
ThreadPool.QueueUserWorkItem(new WaitCallback(TaskDistribution), objArr);
}
task.EmitServerCode = serverInfo.ServerCode;
task.TransProcess = FileTransProcess.TransDatas;
task.Data = null;
task.TaskCompleteTime = DateTime.Now;
}
}
}
if (serverInfo.TaskEndHandler != null)
{
serverInfo.TaskEndHandler(serverCode, taskInfo);
}
}
catch (Exception ex)
{
task.TaskRemark = ex.Message + "|" + ex.Source + "|" + ex.StackTrace;
task.TaskStatus = TaskStatus.Failed;
}
return(task);
}
/// <summary>
/// 分布式任务分配算法
/// </summary>
/// <param name="taskInfo">任务信息</param>
/// <param name="info">服务器信息</param>
/// <returns>是否在此服务器上执行任务(true:是，false:否)</returns>
public bool Alloc(ITaskInfo taskInfo, IServerInfo info)
{
return(true);
}
public virtual object Execute(ICommandContext commandContext)
{
if (task == null)
{
throw new ActivitiIllegalArgumentException("task is null");
}
if (task.Revision == 0)
{
commandContext.TaskEntityManager.Insert(task, null);
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_CREATED, task));
if (!(task.Assignee is null))
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_ASSIGNED, task));
}
}
}
else
{
ITaskInfo originalTaskEntity = null;
if (commandContext.ProcessEngineConfiguration.HistoryLevel.IsAtLeast(HistoryLevel.AUDIT))
{
originalTaskEntity = commandContext.HistoricTaskInstanceEntityManager.FindById <IHistoricTaskInstanceEntity>(new KeyValuePair <string, object>("historicTaskInstanceId", task.Id));
}
if (originalTaskEntity == null)
{
originalTaskEntity = commandContext.TaskEntityManager.FindById <ITaskEntity>(task.Id);
}
string originalName = originalTaskEntity.Name;
string originalAssignee = originalTaskEntity.Assignee;
string originalOwner = originalTaskEntity.Owner;
string originalDescription = originalTaskEntity.Description;
DateTime?originalDueDate = originalTaskEntity.DueDate;
int? originalPriority = originalTaskEntity.Priority;
string originalCategory = originalTaskEntity.Category;
string originalFormKey = originalTaskEntity.FormKey;
string originalParentTaskId = originalTaskEntity.ParentTaskId;
string originalTaskDefinitionKey = originalTaskEntity.TaskDefinitionKey;
// Only update history if history is enabled
if (commandContext.ProcessEngineConfiguration.HistoryLevel.IsAtLeast(HistoryLevel.AUDIT))
{
if (originalName != task.Name)
{
commandContext.HistoryManager.RecordTaskNameChange(task.Id, task.Name);
}
if (originalDescription != task.Description)
{
commandContext.HistoryManager.RecordTaskDescriptionChange(task.Id, task.Description);
}
if ((!originalDueDate.HasValue && task.DueDate.HasValue) || (originalDueDate.HasValue && !task.DueDate.HasValue) || (originalDueDate.HasValue && !originalDueDate.Equals(task.DueDate)))
{
commandContext.HistoryManager.RecordTaskDueDateChange(task.Id, task.DueDate.Value);
}
if (originalPriority != task.Priority)
{
commandContext.HistoryManager.RecordTaskPriorityChange(task.Id, task.Priority);
}
if (originalCategory != task.Category)
{
commandContext.HistoryManager.RecordTaskCategoryChange(task.Id, task.Category);
}
if (originalFormKey != task.FormKey)
{
commandContext.HistoryManager.RecordTaskFormKeyChange(task.Id, task.FormKey);
}
if (originalParentTaskId != task.ParentTaskId)
{
commandContext.HistoryManager.RecordTaskParentTaskIdChange(task.Id, task.ParentTaskId);
}
if (originalTaskDefinitionKey != task.TaskDefinitionKey)
{
commandContext.HistoryManager.RecordTaskDefinitionKeyChange(task.Id, task.TaskDefinitionKey);
}
}
if (originalOwner != task.Owner)
{
if (!(task.ProcessInstanceId is null))
{
commandContext.IdentityLinkEntityManager.InvolveUser(task.ProcessInstance, task.Owner, IdentityLinkType.PARTICIPANT);
}
commandContext.HistoryManager.RecordTaskOwnerChange(task.Id, task.Owner);
}
if (originalAssignee != task.Assignee)
{
if (!(task.ProcessInstanceId is null))
{
commandContext.IdentityLinkEntityManager.InvolveUser(task.ProcessInstance, task.Assignee, IdentityLinkType.PARTICIPANT);
}
commandContext.HistoryManager.RecordTaskAssigneeChange(task.Id, task.Assignee, task.AssigneeUser);
commandContext.ProcessEngineConfiguration.ListenerNotificationHelper.ExecuteTaskListeners(task, BaseTaskListenerFields.EVENTNAME_ASSIGNMENT);
commandContext.HistoryManager.RecordTaskAssignment(task);
if (commandContext.EventDispatcher.Enabled)
{
commandContext.EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.TASK_ASSIGNED, task));
}
}
commandContext.TaskEntityManager.Update(task);
}
return(null);
}
//分布式批量提交数据到远程
/// <summary>
/// 分布式批量提交数据到远程
/// </summary>
/// <param name="obj"></param>
/// <param name="isHandle"></param>
private static void BatchSendRequest(object obj, bool isHandle)
{
//获取日志实体列表
IDataBuffer buffer = obj as IDataBuffer;
if (buffer == null)
{
return;
}
List <LogMessage> logMessageList = buffer.GetList <LogMessage>();
if (logMessageList == null)
{
return;
}
if (m_openLogCenter)
{
#if THRIFT
try
{
SyncLogServerEvent.WaitOne();
SendRequestToNewLogCenter(logMessageList);
if (logMessageList.Count > 1 && DateTime.Now > lastExecuteLogTime.AddMinutes(5))
{
lastExecuteLogTime = DateTime.Now;
string content = string.Format("本次批量插入{0}条数据，结果：{1}，IsHandle：{2}", logMessageList.Count, "Success", isHandle);
RecordLogCenterState("分布式日志2.0", content, isHandle, true);
}
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Success.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.V2.ToString()) });
return;
}
catch (Exception ex)
{
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Failed.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.V2.ToString()) });
m_localLog.Error(ex);
string content = string.Format("批量插入数据异常，原因：{0}，IsHandle：{1}", ex.ToString(), isHandle);
RecordLogCenterState("分布式日志2.0", content, isHandle, false);
}
#endif
}
else
{
try
{
LogMessageTaskInfo taskInfo = new LogMessageTaskInfo
{
CurrLogMessageObj = logMessageList,
TaskCreateTime = DateTime.Now,
TaskName = "LogMessage",
EmitServerCode = m_localServerCode
};
//发送日志实体列表到远程消息队列
ITaskInfo retTask = m_request.SendRequest(m_logToServer, taskInfo);
if (logMessageList.Count > 1 &&
DateTime.Now > lastExecuteLogTime.AddMinutes(5))
{
lastExecuteLogTime = DateTime.Now;
string content = string.Format("本次批量插入{0}条数据，结果：{1}，IsHandle：{2}", logMessageList.Count, retTask.TaskStatus, isHandle);
RecordLogCenterState("分布式日志1.0", content, isHandle, retTask.TaskStatus == TaskStatus.Success);
}
if (retTask.TaskStatus == TaskStatus.Success)
{
#if THRIFT
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Success.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.V1.ToString()) });
#endif
return;
}
}
catch (Exception ex)
{
#if THRIFT
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Failed.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.V1.ToString()) });
#endif
m_localLog.Error(ex);
string content = string.Format("批量插入数据异常，原因：{0}，IsHandle：{1}", ex.ToString(), isHandle);
RecordLogCenterState("分布式日志1.0", content, isHandle, false);
}
}
int insertResult = LogMessageDAL.GetInstance().Insert(buffer.GetEnumerator(), isHandle);
#if THRIFT
if (insertResult > 0)
{
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Success.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.Local.ToString()) });
}
else
{
AppMetricsKeys.LogCenterClient.MeterMark(MetricsEnum.Failed.ToString(), new string[] { string.Format("Client={0}", MetricsTagEnum.Local.ToString()) });
}
#endif
RecordLogCenterState("本地批量保存日志", string.Format("本地批量插入{0}条数据, IsHandler: {1}", logMessageList.Count, isHandle), isHandle, false);
}
