Beispiel #1
0
        public void Execute(Instance ins, IStopStatus status)
        {
            this.status = status;

            if (ins is IntegrationInstance instance && instance.ActualTasks.Length > 0)
            {
                // 构建待汇集任务清单:lst[0] = 独立任务,lst[1+] = 依赖树
                List <List <IntegrationTask> > lst = new List <List <IntegrationTask> >
                {
                    new List <IntegrationTask>(instance.ActualTasks[0]),
                    new List <IntegrationTask>()
                };

                for (int i = 1; i < instance.ActualTasks.Length; i++)
                {
                    for (int j = 0; j < instance.ActualTasks[i].Length; j++)
                    {
                        IntegrationTask ta = instance.ActualTasks[i][j];

                        for (int k = 0; k < ta.Table.References.Length; k++)
                        {
                            for (int l = 0; l < lst[0].Count; l++)
                            {
                                if (ta.Table.References[k].Equals(lst[0][l].Table.DestName))
                                {
                                    lst[1].Add(lst[0][l]);
                                    lst[0].RemoveAt(l);
                                    break;
                                }
                            }
                        }
                    }
                    lst.Add(new List <IntegrationTask>(instance.ActualTasks[i]));
                }

                TaskComparer comparer = new TaskComparer();

                foreach (List <IntegrationTask> tasks in lst)
                {
                    tasks.Sort(comparer);
                }

                List <IntegrationTask> runList = new List <IntegrationTask>();

                // 开始汇集
                Parallel.ForEach(CreateThreadAction((int)instance.Threads), i =>
                {
                    IntegrationTask task = GetTask(lst, runList);

                    while (task != null)
                    {
                        try
                        {
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{task.Table.DestName}", "汇集开始...");

                            task.StartTick = WinAPI.GetTickCount();
                            task.Status    = DataStates.Running;

                            IntegrateTask(task, out string reason);
                            if (task.Status == DataStates.Done)
                            {
                                Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{task.Table.DestName}", "汇集成功。");
                                Logger.WriteRpt(task.Dest.Server, task.Dest.DB, task.Table.DestName, "成功",
                                                task.Table.Progress.ToString("#,##0"));
                            }
                            else
                            {
                                task.Progress -= task.Table.Progress;
                                task.ErrorMsg  = reason;
                                Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{task.Table.DestName}",
                                                $"汇集失败!{reason}");
                                Logger.WriteRpt(task.Dest.Server, task.Dest.DB, task.Table.DestName, "失败", reason);
                            }
                            task.StartTick = WinAPI.GetTickCount() - task.StartTick;
                            lock (runList) { runList.Remove(task); }

                            task = GetTask(lst, runList);
                        }
                        catch (Exception ex)
                        {
                            task.Status   = DataStates.Error;
                            task.ErrorMsg = ex.Message;
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", $"汇集失败!{ex.Message}");
                        }
                    }
                });

                foreach (Common.Task task in instance.Tasks)
                {
                    if (task.Status != DataStates.Done)
                    {
                        Logger.WriteLog(instance.Name, "汇集失败!");
                        return;
                    }
                }

                Logger.WriteLog(instance.Name, "汇集成功。");
            }
        }
        public void Execute(Instance ins, IStopStatus status)
        {
            this.status = status;

            foreach (Common.Task t in ins.Tasks)
            {
                if (status.Stopped)
                {
                    break;
                }

                if (t is MigrationTask task && task.Tables.Length > 0)
                {
                    task.StartTick = WinAPI.GetTickCount();
                    task.Status    = DataStates.Running;

                    // 构建待迁移表清单:lst[0] = 独立表,lst[1+] = 依赖树
                    List <List <MigrationTable> > lst = new List <List <MigrationTable> >
                    {
                        new List <MigrationTable>(task.Tables[0]),
                        new List <MigrationTable>()
                    };

                    for (int i = 1; i < task.Tables.Length; i++)
                    {
                        for (int j = 0; j < task.Tables[i].Length; j++)
                        {
                            MigrationTable ta = task.Tables[i][j];

                            for (int k = 0; k < ta.References.Length; k++)
                            {
                                for (int l = 0; l < lst[0].Count; l++)
                                {
                                    if (ta.References[k].Equals(lst[0][l].DestName))
                                    {
                                        lst[1].Add(lst[0][l]);
                                        lst[0].RemoveAt(l);
                                        break;
                                    }
                                }
                            }
                        }
                        lst.Add(new List <MigrationTable>(task.Tables[i]));
                    }

                    TableComparer comparer = new TableComparer();

                    foreach (List <MigrationTable> tables in lst)
                    {
                        tables.Sort(comparer);
                    }

                    List <MigrationTable> runList = new List <MigrationTable>();

                    // 开始迁移
                    try
                    {
                        Parallel.ForEach(CreateThreadAction((int)task.Threads), i =>
                        {
                            MigrationTable table = GetTable(lst, runList);

                            while (table != null)
                            {
                                Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.DestName}", "迁移开始...");

                                MigrateTable(task, table, out string reason);
                                if (table.Status == DataStates.Done)
                                {
                                    Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.DestName}", "迁移成功。");
                                    Logger.WriteRpt(task.Dest.Server, task.Dest.DB, table.DestName, "成功",
                                                    table.Progress.ToString("#,##0"));
                                }
                                else
                                {
                                    task.Status    = DataStates.RunningError;
                                    task.ErrorMsg  = reason;
                                    task.Progress -= table.Progress;
                                    Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.DestName}",
                                                    $"迁移失败!{reason}");
                                    Logger.WriteRpt(task.Dest.Server, task.Dest.DB, table.DestName, "失败", reason);
                                }
                                lock (runList) { runList.Remove(table); }

                                table = GetTable(lst, runList);
                            }
                        });

                        if (status.Stopped || task.Status == DataStates.RunningError || task.Status == DataStates.Error)
                        {
                            task.Status = DataStates.Error;
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", "迁移失败!");
                        }
                        else
                        {
                            task.Status = DataStates.Done;
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", "迁移成功!");
                        }
                    }
                    catch (Exception ex)
                    {
                        task.Status   = DataStates.Error;
                        task.ErrorMsg = ex.Message;
                        Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", $"迁移失败!{ex.Message}");
                    }
                    task.StartTick = WinAPI.GetTickCount() - task.StartTick;
                }
            }
        }
        public void Execute(Instance ins, IStopStatus status)
        {
            this.status = status;

            foreach (Common.Task t in ins.Tasks)
            {
                if (status.Stopped)
                {
                    break;
                }

                if (t is MaskingTask task && task.Tables.Length > 0)
                {
                    task.StartTick = WinAPI.GetTickCount();
                    task.Status    = DataStates.Running;

                    // 构建待脱敏表清单
                    List <MaskingTable> lst      = new List <MaskingTable>();
                    TableComparer       comparer = new TableComparer();

                    foreach (Table tt in task.Tables)
                    {
                        if (tt is MaskingTable table)
                        {
                            lst.Add(table);
                        }
                    }
                    lst.Sort(comparer);

                    // 开始脱敏
                    try
                    {
                        Parallel.ForEach(CreateThreadAction((int)task.Threads), i =>
                        {
                            MaskingTable table = GetTable(lst);

                            while (table != null)
                            {
                                Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.SourceName}", "脱敏开始...");

                                MaskTable(task, table, out string reason);
                                if (table.Status == DataStates.Done)
                                {
                                    Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.SourceName}", "脱敏成功。");
                                    Logger.WriteRpt(task.Dest.Server, task.Dest.DB, table.SourceName, "成功",
                                                    table.Progress.ToString("#,##0"));
                                }
                                else
                                {
                                    task.Status    = DataStates.RunningError;
                                    task.ErrorMsg  = reason;
                                    task.Progress -= table.Progress;
                                    Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}.{table.SourceName}",
                                                    $"脱敏失败!{reason}");
                                    Logger.WriteRpt(task.Dest.Server, task.Dest.DB, table.SourceName, "失败", reason);
                                }

                                table = GetTable(lst);
                            }
                        });

                        if (status.Stopped || task.Status == DataStates.RunningError || task.Status == DataStates.Error)
                        {
                            task.Status = DataStates.Error;
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", "脱敏失败!");
                        }
                        else
                        {
                            task.Status = DataStates.Done;
                            Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", "脱敏成功!");
                        }
                    }
                    catch (Exception ex)
                    {
                        task.Status   = DataStates.Error;
                        task.ErrorMsg = ex.Message;
                        Logger.WriteLog($"{task.Dest.Server}/{task.Dest.DB}", $"脱敏失败!{ex.Message}");
                    }
                    task.StartTick = WinAPI.GetTickCount() - task.StartTick;
                }
            }
        }