Exemplo n.º 1
0
        public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
        {
            bool res = true;

            try
            {
                var data         = task.GetData <DatabaseUpdateTaskData>();
                var sl           = ServiceLocatorFactory.CreateMasterSysAdmin();
                var districts    = sl.DistrictService.GetDistricts();
                var masterSqls   = data.Sqls.Where(x => x.RunOnMaster).ToList();
                var districtSqls = data.Sqls.Where(x => !x.RunOnMaster).ToList();

                using (var uow = new UnitOfWork(Settings.MasterConnectionString, true))
                {
                    foreach (var updateSql in masterSqls)
                    {
                        var cmd = uow.GetTextCommandWithParams(updateSql.Sql, new Dictionary <string, object>());
                        cmd.CommandTimeout = Settings.DbUpdateTimeout;
                        cmd.ExecuteNonQuery();
                    }
                    uow.Commit();
                }


                foreach (var dbServer in Settings.ChalkableSchoolDbServers)
                {
                    using (var uow = new UnitOfWork(Settings.GetSchoolTemplateConnectionString(dbServer), true))
                    {
                        foreach (var updateSql in districtSqls)
                        {
                            var cmd = uow.GetTextCommandWithParams(updateSql.Sql, new Dictionary <string, object>());
                            cmd.CommandTimeout = Settings.DbUpdateTimeout;
                            cmd.ExecuteNonQuery();
                        }
                        uow.Commit();
                    }
                }
                var runer = new AllSchoolRunner <IEnumerable <UpdateSql> >();
                if (!runer.Run(districts, districtSqls, log, ExecSql, task1 => AllSchoolRunner <IEnumerable <UpdateSql> > .TaskStatusEnum.Completed))
                {
                    res = false;
                }
            }
            catch (Exception ex)
            {
                while (ex != null)
                {
                    log.LogError("Error during database update");
                    log.LogError(ex.Message);
                    log.LogError(ex.StackTrace);
                    ex = ex.InnerException;
                }
                res = false;
            }
            return(res);
        }
        public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
        {
            bool res;

            try
            {
                var data = DatabaseDacPacUpdateTaskData.FromString(task.Data);
                log.LogInfo("DACPAC: " + data.DacPacName);
                var azureJobsCreds = new AzureSqlJobCredentials
                {
                    ServerName   = data.ServerName,
                    DatabaseName = data.DatabaseName,
                    Username     = data.Username,
                    Password     = data.Password
                };

                var work = Do(azureJobsCreds, log, data);
                work.Wait();
                res = work.Result;
            }
            catch (Exception ex)
            {
                log.LogError("Error during database update");
                log.LogException(ex);
                res = false;
            }
            return(res);
        }
        private static async Task <bool> DeployDacPac(AzureSqlJobCredentials azureJobsCreds, string dacPacName, string dacPacUri,
                                                      IList <DatabaseTarget> targets, BackgroundTaskService.BackgroundTaskLog log)
        {
            var elasticJobs = CreateAzureSqlJobClient(azureJobsCreds);

            var jobExecution = await StartJob(elasticJobs, targets, log, dacPacName, dacPacUri);

            JobStatHelper helper = new JobStatHelper(azureJobsCreds);

            DateTime?since     = null;
            var      lifecycle = jobExecution.Lifecycle;

            while (true)
            {
                try
                {
                    var status = await elasticJobs.JobExecutions.GetJobExecutionAsync(jobExecution.JobExecutionId);

                    if (status.Lifecycle != lifecycle)
                    {
                        log.LogInfo($"{dacPacName} job is {status.Lifecycle}");
                    }
                    lifecycle = status.Lifecycle;

                    var stats = helper.GetChilderJobExecutionStat(jobExecution.JobName);
                    log.LogInfo("Task stats:\n" + stats.Select(x => x.Lifecycle + ": " + x.Count).JoinString("\n"));

                    var taskExecutions = helper.GetJobTaskExecutions(jobExecution.JobName, since, null);
                    log.LogInfo(taskExecutions.Select(x => x.Message));
                    since = taskExecutions.Max(x => x.EndTime);

                    switch (status.Lifecycle)
                    {
                    case JobExecutionLifecycle.Failed:
                    case JobExecutionLifecycle.Canceled:
                    case JobExecutionLifecycle.Skipped:
                    case JobExecutionLifecycle.TimedOut:
                        log.LogError("Deploy " + status.Lifecycle);
                        return(false);

                    case JobExecutionLifecycle.Succeeded:
                        log.Flush();
                        return(true);
                    }
                }
                catch (SqlException e)
                {
                    log.LogInfo($"Failed to connect to {azureJobsCreds.DatabaseName}@{azureJobsCreds.DatabaseName}: {e.Message}");
                    log.LogException(e);
                }

                await Task.Delay(30000);
            }
        }
Exemplo n.º 4
0
        public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
        {
            var sl = ServiceLocatorFactory.CreateMasterSysAdmin();

            if (!task.DistrictRef.HasValue)
            {
                log.LogError(string.Format("attendance notification task {0} should contains school id", task.Id));
                return(false);
            }
            //var schoolSl = sl.SchoolServiceLocator(task.DistrictRef.Value, null);
            //schoolSl.AttendanceService.ProcessClassAttendance(schoolSl.Context.NowSchoolTime);
            throw new NotImplementedException();
            return(true);
        }
Exemplo n.º 5
0
        public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
        {
            if (!task.DistrictRef.HasValue)
            {
                throw new ChalkableException("No district id for district task");
            }
            var sl = ServiceLocatorFactory.CreateMasterSysAdmin();

            if (!sl.DistrictService.IsOnline(task.DistrictRef.Value))
            {
                log.LogError($"district {task.DistrictRef.Value} is not online yet");
                return(false);
            }

            var districtId = task.DistrictRef.Value;

            var district = sl.DistrictService.GetByIdOrNull(districtId);

            HandleInternal(task, district, log);
            return(true);
        }
Exemplo n.º 6
0
        public bool Run(IList <District> schools, T data, BackgroundTaskService.BackgroundTaskLog log, Func <Task, string> f, Func <Task, TaskStatusEnum> checkStatus)
        {
            var allTasks    = new List <Task>();
            var threadTasks = new List <Task>();
            var threads     = new List <Thread>();

            var ts = new ParameterizedThreadStart(delegate(object o)
            {
                var tasks = (IList <Task>)o;
                Run(tasks, f, checkStatus);
            });
            var districtPerThread = Settings.AllSchoolRunnerDistrictPerThread;

            foreach (var school in schools)
            {
                var t = new Task
                {
                    Completed = false,
                    Database  = school.Id.ToString(),
                    Server    = school.ServerUrl,
                    Success   = false,
                    Data      = data
                };
                allTasks.Add(t);
                threadTasks.Add(t);
                if (threadTasks.Count == districtPerThread)
                {
                    var thread = new Thread(ts);
                    threads.Add(thread);
                    thread.Start(threadTasks);
                    threadTasks = new List <Task>();
                }
            }
            if (threadTasks.Count > 0)
            {
                var thread = new Thread(ts);
                threads.Add(thread);
                thread.Start(threadTasks);
            }


            for (int i = 0; i < threads.Count; i++)
            {
                threads[i].Join();
            }

            bool res = true;

            for (int i = 0; i < allTasks.Count; i++)
            {
                if (!allTasks[i].Success)
                {
                    log.LogError(string.Format("Db error: {0} - {1}", allTasks[i].Server, allTasks[i].Database));
                    if (allTasks[i].ErrorMessage != null)
                    {
                        log.LogError(allTasks[i].ErrorMessage);
                    }
                    res = false;
                }
            }
            return(res);
        }
Exemplo n.º 7
0
        public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
        {
            var sl   = ServiceLocatorFactory.CreateMasterSysAdmin();
            var data = task.GetData <DatabaseBackupRestoreTaskData>();

            if (data.BackupMaster)
            {
                var c = new SqlConnection(sl.Context.MasterConnectionString);
                var t = new AllSchoolRunner <long> .Task
                {
                    Database  = c.Database,
                    Server    = c.DataSource,
                    Data      = data.Time,
                    Success   = false,
                    Completed = false
                };
                if (backup)
                {
                    AllSchoolRunner <long> .Run(new List <AllSchoolRunner <long> .Task> {
                        t
                    }, x => BackupHelper.DoExport(x.Data, x.Server, x.Database), CheckStatus);
                }
                else
                {
                    AllSchoolRunner <long> .Run(new List <AllSchoolRunner <long> .Task> {
                        t
                    }, Restore, CheckStatus);
                }
                if (!t.Success)
                {
                    log.LogError($"Db {actionName} error: Master Database");
                    if (t.ErrorMessage != null)
                    {
                        log.LogError(t.ErrorMessage);
                    }
                    return(false);
                }
            }

            string[] serversForTemplateDbs = Settings.ChalkableSchoolDbServers;
            if (backup)
            {
                serversForTemplateDbs = serversForTemplateDbs.Take(1).ToArray();
            }
            foreach (var dbServer in serversForTemplateDbs)
            {
                var c = new SqlConnection(Settings.GetSchoolTemplateConnectionString(dbServer));
                var t = new AllSchoolRunner <long> .Task
                {
                    Database  = c.Database,
                    Server    = c.DataSource,
                    Data      = data.Time,
                    Success   = false,
                    Completed = false
                };
                if (backup)
                {
                    AllSchoolRunner <long> .Run(new List <AllSchoolRunner <long> .Task> {
                        t
                    }, x => BackupHelper.DoExport(x.Data, x.Server, x.Database), CheckStatus);
                }
                else
                {
                    AllSchoolRunner <long> .Run(new List <AllSchoolRunner <long> .Task> {
                        t
                    }, Restore, CheckStatus);
                }
                if (!t.Success)
                {
                    log.LogError(string.Format("Db {0} error: Template Database", actionName));
                    if (t.ErrorMessage != null)
                    {
                        log.LogError(t.ErrorMessage);
                    }
                    return(false);
                }
            }

            var  schools = sl.DistrictService.GetDistricts();
            var  runer   = new AllSchoolRunner <long>();
            bool res;

            if (backup)
            {
                res = runer.Run(schools, data.Time, log, t => BackupHelper.DoExport(t.Data, t.Server, t.Database), CheckStatus);
            }
            else
            {
                res = runer.Run(schools, data.Time, log, Restore, CheckStatus);
            }
            return(res);
        }
Exemplo n.º 8
0
 public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
 {
     log.LogError("This operation is not supported");
     return(false);
 }