static void StartTrainingAsync(PredictorEntity p) { var cancellationSource = new CancellationTokenSource(); var ctx = new PredictorTrainingContext(p, cancellationSource.Token); var state = new PredictorTrainingState(cancellationSource, ctx); if (!Trainings.TryAdd(p.ToLite(), state)) { throw new InvalidOperationException(PredictorMessage._0IsAlreadyBeingTrained.NiceToString(p)); } using (ExecutionContext.SuppressFlow()) { Task.Run(() => { var user = ExecutionMode.Global().Using(_ => p.User !.RetrieveAndRemember()); using (UserHolder.UserSession(user)) { try { DoTraining(ctx); } finally { Trainings.TryRemove(p.ToLite(), out var _); } } }); } }
protected T Return <T>(IUserEntity user, MethodBase mi, string description, Func <T> function) { try { using (UserHolder.UserSession(user)) { return(function()); } } catch (Exception e) { e.LogException(el => { el.ControllerName = GetType().Name; el.ActionName = mi.Name; el.QueryString = description; el.Version = Schema.Current.Version.ToString(); }); throw; } finally { Statics.CleanThreadContextAndAssert(); } }
public async Task <HttpResponseMessage> ExecuteAuthorizationFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func <Task <HttpResponseMessage> > continuation) { string action = ProfilerActionSplitterAttribute.GetActionDescription(actionContext); try { using (TimeTracker.Start(action)) { using (HeavyProfiler.Log("Web.API " + actionContext.Request.Method, () => actionContext.Request.RequestUri.ToString())) { var user = (IUserEntity)GetProp(actionContext, SignumAuthenticationFilterAttribute.UserKey); using (user != null ? UserHolder.UserSession(user) : null) { var culture = SignumAuthenticationFilterAttribute.GetCurrentCultures?.Invoke(actionContext); using (culture != null ? CultureInfoUtils.ChangeBothCultures(culture) : null) { var result = await continuation(); return(result); } } } } } finally { Statics.CleanThreadContextAndAssert(); } }
public void Execute() { var user = ExecutionMode.Global().Using(_ => CurrentProcess.User.RetrieveAndRemember()); using (UserHolder.UserSession(user)) { using (ProcessLogic.OnApplySession(CurrentProcess)) { if (UserEntity.Current == null) { UserEntity.Current = AuthLogic.SystemUser !; } try { Algorithm.Execute(this); CurrentProcess.ExecutionEnd = TimeZoneManager.Now; CurrentProcess.State = ProcessState.Finished; CurrentProcess.Progress = null; CurrentProcess.User.ClearEntity(); using (OperationLogic.AllowSave <ProcessEntity>()) CurrentProcess.Save(); } catch (OperationCanceledException e) { if (!e.CancellationToken.Equals(this.CancellationToken)) { throw; } CurrentProcess.SuspendDate = TimeZoneManager.Now; CurrentProcess.State = ProcessState.Suspended; using (OperationLogic.AllowSave <ProcessEntity>()) CurrentProcess.Save(); } catch (Exception e) { if (Transaction.InTestTransaction) { throw; } CurrentProcess.State = ProcessState.Error; CurrentProcess.ExceptionDate = TimeZoneManager.Now; CurrentProcess.Exception = e.LogException(el => el.ActionName = CurrentProcess.Algorithm.ToString()).ToLite(); using (OperationLogic.AllowSave <ProcessEntity>()) CurrentProcess.Save(); } finally { ProcessRunnerLogic.OnFinally?.Invoke(this); } } } }
public override IDisposable GetResource(ResourceExecutingContext context) { var result = Authenticate(context); if (result == null) { return(null); } return(result.User != null?UserHolder.UserSession(result.User) : null); }
public override IDisposable?GetResource(ResourceExecutingContext context) { var result = Authenticate(context); if (result == null) { return(null); } context.HttpContext.Items[Signum_User_Key] = result.User; return(result.User != null?UserHolder.UserSession(result.User) : null); }
public static IDisposable UnsafeUserSession(string username) { UserEntity?user; using (AuthLogic.Disable()) { user = RetrieveUser(username); if (user == null) { throw new ApplicationException(AuthMessage.Username0IsNotValid.NiceToString().FormatWith(username)); } } return(UserHolder.UserSession(user)); }
public static ResetPasswordRequestEntity ResetPasswordRequestExecute(string code, string password) { using (AuthLogic.Disable()) { var rpr = Database.Query <ResetPasswordRequestEntity>() .Where(r => r.Code == code && r.IsValid) .SingleEx(); using (UserHolder.UserSession(rpr.User)) { rpr.Execute(ResetPasswordRequestOperation.Execute, password); } return(rpr); } }
public static ResetPasswordRequestEntity ResetPasswordRequestExecute(string code, string password) { using (AuthLogic.Disable()) { //Remove old previous requests var rpr = Database.Query <ResetPasswordRequestEntity>() .Where(r => r.Code == code && !r.Lapsed) .SingleOrDefault(); using (UserHolder.UserSession(rpr.User)) { rpr.Execute(ResetPasswordRequestOperation.Execute, password); } return(rpr); } }
public virtual Lite <DisconnectedExportEntity> BeginExportDatabase(DisconnectedMachineEntity machine) { Lite <DisconnectedExportEntity> export = new DisconnectedExportEntity { Machine = machine.ToLite(), Copies = downloadTables.Select(t => new DisconnectedExportTableEmbedded { Type = t.Type.ToTypeEntity().ToLite() }).ToMList() }.Save().ToLite(); var cancelationSource = new CancellationTokenSource(); var user = UserHolder.Current; var token = cancelationSource.Token; var task = Task.Factory.StartNew(() => { using (UserHolder.UserSession(user)) { OnStartExporting(machine); DisconnectedMachineEntity.Current = machine.ToLite(); try { using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.Lock, s => l).Execute())) { foreach (var tuple in downloadTables) { token.ThrowIfCancellationRequested(); if (tuple.Strategy.Upload == Upload.Subset) { miUnsafeLock.MakeGenericMethod(tuple.Type).Invoke(this, new object[] { machine.ToLite(), tuple.Strategy, export }); } } } string connectionString; using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.CreateDatabase, s => l).Execute())) connectionString = CreateDatabase(machine); var newDatabase = new SqlServerConnector(connectionString, Schema.Current, ((SqlServerConnector)Connector.Current).Version); using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.CreateSchema, s => l).Execute())) using (Connector.Override(newDatabase)) using (ObjectName.OverrideOptions(new ObjectNameOptions { AvoidDatabaseName = true })) { Administrator.TotalGeneration(); } using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.DisableForeignKeys, s => l).Execute())) using (Connector.Override(newDatabase)) using (ObjectName.OverrideOptions(new ObjectNameOptions { AvoidDatabaseName = true })) { foreach (var tuple in downloadTables.Where(t => !t.Type.IsEnumEntity())) { token.ThrowIfCancellationRequested(); DisableForeignKeys(tuple.Table); } } var isPostgres = Schema.Current.Settings.IsPostgres; DatabaseName newDatabaseName = new DatabaseName(null, newDatabase.DatabaseName(), isPostgres); foreach (var tuple in downloadTables) { token.ThrowIfCancellationRequested(); int ms = 0; using (token.MeasureTime(l => ms = l)) { tuple.Strategy.Exporter !.Export(tuple.Table, tuple.Strategy, newDatabaseName, machine); } export.MListElementsLite(_ => _.Copies).Where(c => c.Element.Type.Is(tuple.Type.ToTypeEntity())).UnsafeUpdateMList() .Set(mle => mle.Element.CopyTable, mle => ms) .Execute(); } using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.EnableForeignKeys, s => l).Execute())) foreach (var tuple in downloadTables.Where(t => !t.Type.IsEnumEntity())) { token.ThrowIfCancellationRequested(); EnableForeignKeys(tuple.Table); } using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.ReseedIds, s => l).Execute())) { var tablesToUpload = Schema.Current.Tables.Values.Where(t => DisconnectedLogic.GetStrategy(t.Type).Upload != Upload.None) .SelectMany(t => t.TablesMList().Cast <ITable>().And(t)).Where(t => t.PrimaryKey.Identity).ToList(); var maxIdDictionary = tablesToUpload.ToDictionary(t => t, t => DisconnectedTools.MaxIdInRange(t, machine.SeedMin, machine.SeedMax)); using (Connector.Override(newDatabase)) using (ObjectName.OverrideOptions(new ObjectNameOptions { AvoidDatabaseName = true })) { foreach (var table in tablesToUpload) { token.ThrowIfCancellationRequested(); long?max = maxIdDictionary.GetOrThrow(table); DisconnectedTools.SetNextId(table, (max + 1) ?? machine.SeedMin); } } } CopyExport(export, newDatabase); machine.InDB().UnsafeUpdate().Set(s => s.State, s => DisconnectedMachineState.Disconnected).Execute(); using (SqlServerConnector.Override(newDatabase)) using (ObjectName.OverrideOptions(new ObjectNameOptions { AvoidDatabaseName = true })) machine.InDB().UnsafeUpdate().Set(s => s.State, s => DisconnectedMachineState.Disconnected).Execute(); using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.BackupDatabase, s => l).Execute())) BackupDatabase(machine, export, newDatabase); using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.DropDatabase, s => l).Execute())) DropDatabase(newDatabase); token.ThrowIfCancellationRequested(); export.InDB().UnsafeUpdate() .Set(s => s.State, s => DisconnectedExportState.Completed) .Set(s => s.Total, s => s.CalculateTotal()) .Execute(); } catch (Exception e) { var ex = e.LogException(); export.InDB().UnsafeUpdate() .Set(s => s.Exception, s => ex.ToLite()) .Set(s => s.State, s => DisconnectedExportState.Error) .Execute(); OnExportingError(machine, export, e); } finally { runningExports.Remove(export); DisconnectedMachineEntity.Current = null; OnEndExporting(); } } }); runningExports.Add(export, new RunningExports(task, cancelationSource)); return(export); }
public LoginResponse Login([FromBody] LoginRequest data) { if (string.IsNullOrEmpty(data.userName)) { throw ModelException("userName", AuthMessage.UserNameMustHaveAValue.NiceToString()); } if (string.IsNullOrEmpty(data.password)) { throw ModelException("password", AuthMessage.PasswordMustHaveAValue.NiceToString()); } // Attempt to login UserEntity user = null; try { user = AuthLogic.Login(data.userName, Security.EncodePassword(data.password)); } catch (Exception e) when(e is IncorrectUsernameException || e is IncorrectPasswordException) { if (AuthServer.MergeInvalidUsernameAndPasswordMessages) { ModelState.AddModelError("userName", AuthMessage.InvalidUsernameOrPassword.NiceToString()); ModelState.AddModelError("password", AuthMessage.InvalidUsernameOrPassword.NiceToString()); throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, this.ModelState)); } else if (e is IncorrectUsernameException) { throw ModelException("userName", AuthMessage.InvalidUsername.NiceToString()); } else if (e is IncorrectPasswordException) { throw ModelException("password", AuthMessage.InvalidPassword.NiceToString()); } } catch (IncorrectPasswordException) { throw ModelException("password", AuthServer.MergeInvalidUsernameAndPasswordMessages ? AuthMessage.InvalidUsernameOrPassword.NiceToString() : AuthMessage.InvalidPassword.NiceToString()); } using (UserHolder.UserSession(user)) { if (data.rememberMe == true) { UserTicketServer.SaveCookie(); } AuthServer.AddUserSession(user); string message = AuthLogic.OnLoginMessage(); var token = AuthTokenServer.CreateToken(user); return(new LoginResponse { message = message, userEntity = user, token = token }); } }
private static void ExecuteProcess() { if (running) { throw new InvalidOperationException("WorkflowScriptRunner process is already running"); } using (ExecutionContext.SuppressFlow()) { Task.Factory.StartNew(() => { SystemEventLogLogic.Log("Start WorkflowScriptRunner"); ExceptionEntity exception = null; try { running = true; CancelProcess = new CancellationTokenSource(); autoResetEvent.Set(); timer = new Timer(ob => WakeUp("TimerNextExecution", null), null, Timeout.Infinite, Timeout.Infinite); GC.KeepAlive(timer); using (UserHolder.UserSession(AuthLogic.SystemUser)) { if (CacheLogic.WithSqlDependency) { SetSqlDependency(); } while (autoResetEvent.WaitOne()) { if (CancelProcess.IsCancellationRequested) { return; } timer.Change(Timeout.Infinite, Timeout.Infinite); nextPlannedExecution = null; using (HeavyProfiler.Log("WorkflowScriptRunner", () => "Execute process")) { processIdentifier = Guid.NewGuid(); if (RecruitQueuedItems()) { while (queuedItems > 0 || RecruitQueuedItems()) { var items = Database.Query <CaseActivityEntity>().Where(m => m.DoneDate == null && m.ScriptExecution.ProcessIdentifier == processIdentifier) .Take(WorkflowLogic.Configuration.ChunkSizeRunningScripts).ToList(); queuedItems = items.Count; foreach (var caseActivity in items) { CancelProcess.Token.ThrowIfCancellationRequested(); try { using (Transaction tr = Transaction.ForceNew()) { caseActivity.Execute(CaseActivityOperation.ScriptExecute); tr.Commit(); } } catch { try { var ca = caseActivity.ToLite().Retrieve(); var retry = ca.WorkflowActivity.Script.RetryStrategy; var nextDate = retry?.NextDate(ca.ScriptExecution.RetryCount); if (nextDate == null) { ca.Execute(CaseActivityOperation.ScriptFailureJump); } else { ca.Execute(CaseActivityOperation.ScriptScheduleRetry, nextDate.Value); } } catch (Exception e) { e.LogException(); throw; } } queuedItems--; } queuedItems = Database.Query <CaseActivityEntity>() .Where(m => m.ScriptExecution.ProcessIdentifier == processIdentifier && m.DoneDate == null) .Count(); } } SetTimer(); SetSqlDependency(); } } } } catch (Exception e) { try { exception = e.LogException(edn => { edn.ControllerName = "WorkflowScriptRunner"; edn.ActionName = "ExecuteProcess"; }); } catch { } } finally { SystemEventLogLogic.Log("Stop WorkflowScriptRunner", exception); running = false; } }, TaskCreationOptions.LongRunning); } }
public virtual Lite <DisconnectedImportEntity> BeginImportDatabase(DisconnectedMachineEntity machine, Stream file = null) { Lite <DisconnectedImportEntity> import = new DisconnectedImportEntity { Machine = machine.ToLite(), Copies = uploadTables.Select(t => new DisconnectedImportTableEmbedded { Type = t.Type.ToTypeEntity().ToLite(), DisableForeignKeys = t.Strategy.DisableForeignKeys.Value, }).ToMList() }.Save().ToLite(); if (file != null) { using (FileStream fs = File.OpenWrite(BackupNetworkFileName(machine, import))) { file.CopyTo(fs); file.Close(); } } var threadContext = Statics.ExportThreadContext(); var cancelationSource = new CancellationTokenSource(); var user = UserEntity.Current; var token = cancelationSource.Token; var task = Task.Factory.StartNew(() => { lock (SyncLock) using (UserHolder.UserSession(user)) { OnStartImporting(machine); DisconnectedMachineEntity.Current = machine.ToLite(); try { if (file != null) { using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.RestoreDatabase, s => l).Execute())) { DropDatabaseIfExists(machine); RestoreDatabase(machine, import); } } string connectionString = GetImportConnectionString(machine); var newDatabase = new SqlConnector(connectionString, Schema.Current, DynamicQueryManager.Current, ((SqlConnector)Connector.Current).Version); using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.SynchronizeSchema, s => l).Execute())) using (Connector.Override(newDatabase)) using (ObjectName.OverrideOptions(new ObjectNameOptions { AvoidDatabaseName = true })) using (ExecutionMode.DisableCache()) { var script = Administrator.TotalSynchronizeScript(interactive: false, schemaOnly: true); if (script != null) { string fileName = BackupNetworkFileName(machine, import) + ".sql"; script.Save(fileName); throw new InvalidOperationException("The schema has changed since the last export. A schema sync script has been saved on: {0}".FormatWith(fileName)); } } try { using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.DisableForeignKeys, s => l).Execute())) foreach (var item in uploadTables.Where(u => u.Strategy.DisableForeignKeys.Value)) { DisableForeignKeys(item.Table); } foreach (var tuple in uploadTables) { ImportResult result = null; using (token.MeasureTime(l => { if (result != null) { import.MListElementsLite(_ => _.Copies).Where(mle => mle.Element.Type.RefersTo(tuple.Type.ToTypeEntity())).UnsafeUpdateMList() .Set(mle => mle.Element.CopyTable, mle => l) .Set(mle => mle.Element.DisableForeignKeys, mle => tuple.Strategy.DisableForeignKeys.Value) .Set(mle => mle.Element.InsertedRows, mle => result.Inserted) .Set(mle => mle.Element.UpdatedRows, mle => result.Updated) .Execute(); } })) { result = tuple.Strategy.Importer.Import(machine, tuple.Table, tuple.Strategy, newDatabase); } } using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.Unlock, s => l).Execute())) UnlockTables(machine.ToLite()); } finally { using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.EnableForeignKeys, s => l).Execute())) foreach (var item in uploadTables.Where(u => u.Strategy.DisableForeignKeys.Value)) { EnableForeignKeys(item.Table); } } using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.DropDatabase, s => l).Execute())) DropDatabase(newDatabase); token.ThrowIfCancellationRequested(); import.InDB().UnsafeUpdate() .Set(s => s.State, s => DisconnectedImportState.Completed) .Set(s => s.Total, s => s.CalculateTotal()) .Execute(); machine.InDB().UnsafeUpdate() .Set(m => m.State, m => file == null ? DisconnectedMachineState.Fixed : DisconnectedMachineState.Connected) .Execute(); } catch (Exception e) { var ex = e.LogException(); import.InDB().UnsafeUpdate() .Set(m => m.Exception, m => ex.ToLite()) .Set(m => m.State, m => DisconnectedImportState.Error) .Execute(); machine.InDB().UnsafeUpdate() .Set(m => m.State, m => DisconnectedMachineState.Faulted) .Execute(); OnImportingError(machine, import, e); } finally { runningImports.Remove(import); DisconnectedMachineEntity.Current = null; OnEndImporting(); } } }); runningImports.Add(import, new RunningImports { Task = task, CancelationSource = cancelationSource }); return(import); }
public static ScheduledTaskLogEntity ExecuteSync(ITaskEntity task, ScheduledTaskEntity?scheduledTask, IUserEntity?user) { IUserEntity entityIUser = (user ?? (IUserEntity?)scheduledTask?.User.RetrieveAndRemember()) !; var isolation = entityIUser.TryIsolation(); if (isolation == null) { var ientity = task as IEntity; isolation = ientity?.TryIsolation(); } using (IsolationEntity.Override(isolation)) { ScheduledTaskLogEntity stl = new ScheduledTaskLogEntity { Task = task, ScheduledTask = scheduledTask, StartTime = TimeZoneManager.Now, MachineName = Environment.MachineName, ApplicationName = Schema.Current.ApplicationName, User = entityIUser.ToLite(), }; using (AuthLogic.Disable()) { using (Transaction tr = Transaction.ForceNew()) { stl.Save(); tr.Commit(); } } try { var ctx = new ScheduledTaskContext(stl); RunningTasks.TryAdd(stl, ctx); using (UserHolder.UserSession(entityIUser)) { using (Transaction tr = Transaction.ForceNew()) { stl.ProductEntity = ExecuteTask.Invoke(task, ctx); using (AuthLogic.Disable()) { stl.EndTime = TimeZoneManager.Now; stl.Remarks = ctx.StringBuilder.ToString(); stl.Save(); } tr.Commit(); } } } catch (Exception ex) { using (AuthLogic.Disable()) { if (Transaction.InTestTransaction) { throw; } var exLog = ex.LogException().ToLite(); using (Transaction tr = Transaction.ForceNew()) { stl.Exception = exLog; stl.EndTime = TimeZoneManager.Now; stl.Save(); tr.Commit(); } } throw; } finally { RunningTasks.TryRemove(stl, out var ctx); OnFinally?.Invoke(stl); } return(stl); } }
public ActionResult <LoginResponse> Login([Required, FromBody] LoginRequest data) { if (string.IsNullOrEmpty(data.userName)) { return(ModelError("userName", AuthMessage.UserNameMustHaveAValue.NiceToString())); } if (string.IsNullOrEmpty(data.password)) { return(ModelError("password", AuthMessage.PasswordMustHaveAValue.NiceToString())); } // Attempt to login UserEntity user; try { if (AuthLogic.Authorizer == null) { user = AuthLogic.Login(data.userName, Security.EncodePassword(data.password)); } else { user = AuthLogic.Authorizer.Login(data.userName, data.password); } } catch (Exception e) when(e is IncorrectUsernameException || e is IncorrectPasswordException) { if (AuthServer.MergeInvalidUsernameAndPasswordMessages) { return(ModelError("login", AuthMessage.InvalidUsernameOrPassword.NiceToString())); } else if (e is IncorrectUsernameException) { return(ModelError("userName", AuthMessage.InvalidUsername.NiceToString())); } else if (e is IncorrectPasswordException) { return(ModelError("password", AuthMessage.InvalidPassword.NiceToString())); } throw; } catch (Exception e) { return(ModelError("login", e.Message)); } using (UserHolder.UserSession(user)) { if (data.rememberMe == true) { UserTicketServer.SaveCookie(ControllerContext); } AuthServer.OnUserPreLogin(ControllerContext, user); AuthServer.AddUserSession(ControllerContext, user); string?message = AuthLogic.OnLoginMessage(); var token = AuthTokenServer.CreateToken(user); return(new LoginResponse { message = message, userEntity = user, token = token }); } }