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 async static Task <bool> Do(AzureSqlJobCredentials azureJobsCreds, BackgroundTaskService.BackgroundTaskLog log, DatabaseDacPacUpdateTaskData data)
{
var serviceLocator = ServiceLocatorFactory.CreateMasterSysAdmin();
var masterTargets = new List <DatabaseTarget>
{
new DatabaseTarget(Settings.ChalkableSchoolDbServers.First(), Settings.MasterDbName)
};
log.LogInfo("Master DacPac deployment initated");
if (!(await DeployDacPac(azureJobsCreds, data.DacPacName + "-master", data.MasterDacPacUri, masterTargets, log)))
{
return(false);
}
log.LogInfo("Preparing schools DacPac targets");
var schoolTargets = new List <DatabaseTarget>(
Settings.ChalkableSchoolDbServers.Select(x => new DatabaseTarget(x, Settings.SchoolTemplateDbName))
.Concat(serviceLocator.DistrictService.GetDistricts().Select(x => new DatabaseTarget(x.ServerUrl, x.Id.ToString())))
);
log.LogInfo("Schools DacPac deployment initated");
if (!(await DeployDacPac(azureJobsCreds, data.DacPacName + "-school", data.SchoolDacPacUri, schoolTargets, log)))
{
return(false);
}
log.LogInfo("Deploy success");
return(true);
}
public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
{
var importService = new AcademicBenchmarkImport.ImportService(log);
importService.Import();
return(true);
}
public ImportService(BackgroundTaskService.BackgroundTaskLog log)
{
var admin = new User {
Id = Guid.Empty, Login = "******", LoginInfo = new UserLoginInfo()
};
_sysAdminContext = new UserContext(admin, CoreRoles.SUPER_ADMIN_ROLE, null, null, null, null, null);
Log = log;
}
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)
{
var data = task.GetData <ReportProcessingTaskData>();
var sl = ServiceLocatorFactory.CreateSchoolLocator(data.UserContext);
string appRoot = Environment.GetEnvironmentVariable("RoleRoot");
data.ReportInputModel.DefaultDataPath = Path.Combine(appRoot + @"\", @"approot\");
sl.ReportService.GenerateReportCard(data.ReportInputModel);
return(true);
}
public ImportService(Guid districtId, SisConnectionInfo connectionInfo, BackgroundTaskService.BackgroundTaskLog log)
{
ConnectionInfo = connectionInfo;
Log = log;
this.districtId = districtId;
var admin = new User {
Id = Guid.Empty, Login = "******", LoginInfo = new UserLoginInfo()
};
sysadminCntx = new UserContext(admin, CoreRoles.SUPER_ADMIN_ROLE, null, null, null, null, null);
}
public override void HandleInternal(BackgroundTask task, District district, BackgroundTaskService.BackgroundTaskLog log)
{
var info = new SisConnectionInfo
{
SisPassword = district.SisPassword,
SisUrl = district.SisUrl,
SisUserName = district.SisUserName
};
var importService = new ImportService(district.Id, info, log);
importService.Resync(task.Data);
}
public ImportService(Guid districtId, SisConnectionInfo connectionInfo, BackgroundTaskService.BackgroundTaskLog log, Guid taskId)
{
// TODO: obviously we don't want duplicate code here
this.taskId = taskId;
ConnectionInfo = connectionInfo;
Log = log;
this.districtId = districtId;
var admin = new User {
Id = Guid.Empty, Login = "******", LoginInfo = new UserLoginInfo()
};
sysadminCntx = new UserContext(admin, CoreRoles.SUPER_ADMIN_ROLE, null, null, null, null, null);
}
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);
}
public void Test()
{
AzureSqlJobCredentials creds = new AzureSqlJobCredentials()
{
DatabaseName = "edjb0d1a0ab363747abbc2ee",
Password = "******",
ServerName = "edjb0d1a0ab363747abbc2ee.database.windows.net",
Username = "******"
};
var id = Guid.NewGuid();
Debug.WriteLine(id);
BackgroundTaskService.BackgroundTaskLog log = new BackgroundTaskService.BackgroundTaskLog(id, 1);
var data = DatabaseDacPacUpdateTaskData.FromString("{\"DacPacName\":\"0-7-1d38ca879106-2321\",\"MasterDacPacUri\":\"https://chalkablestat.blob.core.windows.net/artifacts-db/0-7-1d38ca879106-2321/Chalkable.Database.Master.dacpac\",\"SchoolDacPacUri\":\"https://chalkablestat.blob.core.windows.net/artifacts-db/0-7-1d38ca879106-2321/Chalkable.Database.School.dacpac\",\"ServerName\":\"edjb0d1a0ab363747abbc2ee.database.windows.net\",\"DatabaseName\":\"edjb0d1a0ab363747abbc2ee\",\"Username\":\"chalkadmin@edjb0d1a0ab363747abbc2ee\",\"Password\":\"Hellowebapps1!\"}");
DatabaseDacPacUpdateTaskHandler.Test(creds, log, data).Wait();
}
private static async Task <JobExecutionInfo> StartJob(AzureSqlJobClient elasticJobs, IList <DatabaseTarget> targets
, BackgroundTaskService.BackgroundTaskLog log, string dacPacName, string dacPacUri)
{
var dacPackDef = await elasticJobs.Content.GetContentAsync(dacPacName) ??
await elasticJobs.Content.CreateDacpacAsync(dacPacName, new Uri(dacPacUri));
var pwd = CreatePassword(Settings.ChalkableSchoolDbPassword);
var credential = await elasticJobs.Credentials.CreateCredentialAsync(Guid.NewGuid().ToString(), Settings.ChalkableSchoolDbUser, pwd);
string jobNamePrefix = "Apply DACPAC " + dacPacName + " ";
int lastNumber = await FindLastUsedNumber(elasticJobs, jobNamePrefix, log);
if (lastNumber >= 0)
{
bool inProgress = await IsJobInProgress(elasticJobs, BuildJobName(jobNamePrefix, lastNumber));
if (inProgress)
{
throw new Exception("Previous job on this version is not end yet");
}
}
var rooTarget = await elasticJobs.Targets.CreateCustomCollectionTargetAsync("Targets for DACPAC " + dacPacName + " " + Guid.NewGuid());
log.LogInfo("Job targets created as " + rooTarget.TargetId + " " + rooTarget.CustomCollectionName);
await CreateDbTargets(elasticJobs, rooTarget, log, targets, 20, 2000);
var jobName = BuildJobName(jobNamePrefix, lastNumber + 1);
var job = await elasticJobs.Jobs.CreateJobAsync(jobName, new JobBuilder
{
ContentName = dacPackDef.ContentName,
TargetId = rooTarget.TargetId,
CredentialName = credential.CredentialName
});
log.LogInfo("Job created as " + job.TargetId + " " + job.JobName);
var jobExecution = await elasticJobs.JobExecutions.StartJobExecutionAsync(job.JobName);
log.LogInfo($"{dacPacName} execution job as {jobExecution.JobExecutionId} with lifecycle {jobExecution.Lifecycle}");
return(jobExecution);
}
public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
{
var sl = ServiceLocatorFactory.CreateMasterSysAdmin();
var data = task.GetData <PictureImportTaskData>();
var district = sl.DistrictService.GetByIdOrNull(data.DistrictId);
var connectorLocator = ConnectorLocator.Create(district.SisUserName, district.SisPassword, district.SisUrl);
foreach (var person in data.PersonIds)
{
var content = connectorLocator.UsersConnector.GetPhoto(person);
if (content != null)
{
sl.PersonPictureService.UploadPicture(data.DistrictId, person, content);
}
else
{
sl.PersonPictureService.DeletePicture(data.DistrictId, person);
}
}
return(true);
}
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);
}
private static async Task CreateDbTarget(AzureSqlJobClient elasticJobs, CustomCollectionTargetInfo rootTarget
, BackgroundTaskService.BackgroundTaskLog log, DatabaseTarget dbTarget)
{
try
{
var dbTargetInfo = await elasticJobs.Targets.GetDatabaseTargetAsync(dbTarget.Server, dbTarget.Name)
?? await elasticJobs.Targets.CreateDatabaseTargetAsync(dbTarget.Server, dbTarget.Name);
var result = await elasticJobs.Targets.AddChildTargetAsync(rootTarget.TargetId, dbTargetInfo.TargetId);
if (!result)
{
throw new Exception("child target adding returns false");
}
log.LogInfo("Targeting db " + dbTarget.Name + "@" + dbTarget.Server + " complete as " + dbTargetInfo.TargetId);
}
catch (Exception e)
{
log.LogException(e);
throw new Exception("Targeting db " + dbTarget.Name + "@" + dbTarget.Server + " failed.", e);
}
}
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);
}
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);
}
}
public abstract void HandleInternal(BackgroundTask task, District district, BackgroundTaskService.BackgroundTaskLog log);
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);
}
private static async Task <int> FindLastUsedNumber(AzureSqlJobClient elasticJobs, string jobNamePrefix, BackgroundTaskService.BackgroundTaskLog log)
{
for (int i = 0; i < int.MaxValue; i++)
{
var jobName = BuildJobName(jobNamePrefix, i);
log.LogInfo($"checking if {jobName} exists");
var job = await elasticJobs.Jobs.GetJobAsync(jobName);
if (job == null)
{
return(i - 1);
}
}
throw new Exception($"we used {int.MaxValue} numbers for jobs ????");
}
public static Task <bool> Test(AzureSqlJobCredentials creds, BackgroundTaskService.BackgroundTaskLog log, DatabaseDacPacUpdateTaskData data)
{
return(Do(creds, log, data));
}
private static async Task CreateDbTargets(AzureSqlJobClient elasticJobs, CustomCollectionTargetInfo rootTarget, BackgroundTaskService.BackgroundTaskLog log
, IList <DatabaseTarget> dbTargets, int pageSize, int delay)
{
for (int i = 0; i < dbTargets.Count; i += pageSize)
{
await Task.WhenAll(dbTargets.Skip(i).Take(pageSize).Select(x => CreateDbTarget(elasticJobs, rootTarget, log, x)).ToArray());
Thread.Sleep(delay);
}
}
public bool Handle(BackgroundTask task, BackgroundTaskService.BackgroundTaskLog log)
{
log.LogError("This operation is not supported");
return(false);
}
