private IpcResponse ProcessOneRequest(IpcRequest request) { try { var processor = _protocolHandlers.FirstOrDefault(x => x.CanProcess(request)); if (processor == null) { throw new Exception(string.Format("Request protocol {0} is not recognized by any request processor!", request.Protocol)); } return(processor.Process(request)); } catch (OperationCanceledException e) { Logger.LogInfo("Request {0} of type \"{1}\" has been canceled.", request.RequestId, request.Data.GetType().Name); return(ErrorResponseHelper.CreateIpcErrorResponse(request.RequestId, e)); } catch (RecoverableErrorException e) { Logger.LogInfo("Request {0} of type \"{1}\" generated a recoverable error: {2}.", request.RequestId, request.Data.GetType().Name, e.Message); return(ErrorResponseHelper.CreateIpcErrorResponse(request.RequestId, e)); } catch (Exception e) { var message = string.Format("Error executing request {0} of type \"{1}\".", request.RequestId, request.Data.GetType().Name); Logger.LogError(e, "{0}", message); var outer = new Exception(message, e); return(ErrorResponseHelper.CreateIpcErrorResponse(request.RequestId, outer)); } }
private void OnRequestError(IpcRequest request, Exception error) { var callback = _callbacks.Remove(request.RequestId); var response = ErrorResponseHelper.CreateIpcErrorResponse(request, error); callback(response); }
protected static Func <T> SendRequest <T>(ITypedRequestProcessProxy server, TypedRequest request, TimeSpan timeout) where T : TypedResponse { var sw = new Stopwatch(); var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); T response = null; ErrorResponse error = null; sw.Start(); server.RunAsync(request, typedResponse => { Assert.IsInstanceOfType(typedResponse, typeof(T)); sw.Stop(); Logger.LogInfo("Request {0} took {1} msec to complete.", request.ClassName, sw.ElapsedMilliseconds); response = (T)typedResponse; waitHandle.Set(); }, errorResponse => { error = errorResponse; }); return(() => { if (!waitHandle.WaitOne(timeout)) { return null; } if (error != null) { throw ErrorResponseHelper.CreateException(error); } return response; }); }
private void SearchEngineOnFilesLoaded(object sender, OperationResultEventArgs args) { _typedEventSender.SendEventAsync(new SearchEngineFilesLoaded { OperationId = args.OperationId, Error = ErrorResponseHelper.CreateErrorResponse(args.Error) }); }
private void SearchEngineOnFilesLoaded(object sender, FilesLoadedResult args) { _typedEventSender.SendEventAsync(new SearchEngineFilesLoaded { OperationId = args.OperationInfo.OperationId, Error = ErrorResponseHelper.CreateErrorResponse(args.Error), TreeVersion = args.TreeVersion, }); }
public void OnException(ExceptionContext context) { var errorResponse = ErrorResponseHelper.From(context.Exception); context.Result = new ObjectResult(errorResponse) { StatusCode = 500 }; }
private void ReportServerError(ErrorResponse error) { if (!ErrorResponseHelper.IsReportableError(error)) { return; } var viewModel = CreateErrorResponseViewModel(error); ViewModel.SetInformationMessages(viewModel); }
private void HandleSendRequestError(IpcRequest request, Exception error) { var callback = _callbacks.Remove(request.RequestId); var response = ErrorResponseHelper.CreateIpcErrorResponse(request.RequestId, error); callback(response); // We assume the server is down as soon as there is an error // sending a request. _isServerRunning = false; OnProcessFatalError(new ErrorEventArgs(error)); }
private void HandleReceiveThreadFatalError(ErrorEventArgs args) { // Terminate all pending requests with errors foreach (var kvp in _callbacks.RemoveAll()) { var response = ErrorResponseHelper.CreateIpcErrorResponse(kvp.Key, args.GetException()); kvp.Value(response); } // We assume the server is down as soon as there is an error // sending a request. _isServerRunning = false; OnProcessFatalError(args); }
private void FileSystemProcessorOnSnapshotComputed(object sender, SnapshotComputedResult e) { var fileSystemTreeComputed = new FileSystemTreeComputed { OperationId = e.OperationInfo.OperationId, Error = ErrorResponseHelper.CreateErrorResponse(e.Error) }; if (e.PreviousSnapshot != null) { fileSystemTreeComputed.OldVersion = e.PreviousSnapshot.Version; fileSystemTreeComputed.NewVersion = e.NewSnapshot.Version; } _typedEventSender.SendEventAsync(fileSystemTreeComputed); }
public async Task <DataTransferObject <LoginResponseDTO> > Login(LoginDTO credentials) { var response = new DataTransferObject <LoginResponseDTO>(); var appUser = _mapper.Map <ApplicationUser>(credentials); var error = await ValidateUser(credentials.UserName, credentials.Password); if (error != "") { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(error)); } var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password, credentials.DeviceId); if (identity == null) { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(ErrorStrings.LoginFailed)); } var jwt = await Token.GenerateJwt(identity, _jwtFactory, credentials.UserName, credentials.DeviceId, _jwtOptions); var refreshToken = GetRefreshToken(appUser); var refreshTokenExpiry = _refreshTokenConfig.RefreshTokenExpiry; jwt.RefreshToken = refreshToken; var prevToken = await _repository.Find(e => e.UserName == appUser.UserName && e.DeviceId == appUser.DeviceId); if (prevToken == null) { await this.Repository.Create(new AuthStore() { Token = jwt.AuthToken, RefreshToken = refreshToken, RefreshTokenExpiry = refreshTokenExpiry, UserName = credentials.UserName, DeviceId = credentials.DeviceId, IsRevoked = false, Name = credentials.UserName }); } else { prevToken.Token = jwt.AuthToken; prevToken.RefreshToken = refreshToken; prevToken.IsRevoked = false; prevToken.RefreshTokenExpiry = refreshTokenExpiry; _mapper.Map <LoginDTO>(prevToken); await this.Repository.Update(prevToken); } await SaveContext(); return(new DataTransferObject <LoginResponseDTO>(jwt)); }
public async Task <DataTransferObject <LoginResponseDTO> > RefreshToken(AuthStoreDTO tokenDto) { var response = new DataTransferObject <LoginResponseDTO>(); var queryParams = new Dictionary <string, string>(); queryParams.Add("filter.RefreshToken", tokenDto.RefreshToken); var jsonApiRequest = FilterRequest.GetRequest(queryParams); var existingToken = (await _repository.GetAll(jsonApiRequest)).FirstOrDefault(); if (existingToken == null) { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(ErrorStrings.InvalidRefreshToken)); } else if (existingToken.RefreshTokenExpiry <= DateTime.UtcNow) { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(ErrorStrings.RefreshTokenExpired)); } else if (existingToken.IsRevoked) { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(ErrorStrings.TokenAlreadyRevoked)); } var identity = await GetClaimsIdentity(existingToken.UserName, existingToken.DeviceId); if (identity == null) { return(ErrorResponseHelper.CreateErrorResponse <LoginResponseDTO>(ErrorStrings.InvalidRefreshToken)); } var jwt = await Token.GenerateJwt(identity, _jwtFactory, existingToken.UserName, tokenDto.DeviceId, _jwtOptions); var appUser = await userIdentityManager.FindByNameAsync(existingToken.UserName); var refreshToken = GetRefreshToken(appUser); var refreshTokenExpiry = _refreshTokenConfig.RefreshTokenExpiry; jwt.RefreshToken = refreshToken; await this.Repository.Create(new AuthStore() { Token = jwt.AuthToken, RefreshToken = refreshToken, RefreshTokenExpiry = refreshTokenExpiry, UserName = existingToken.UserName, DeviceId = tokenDto.DeviceId, IsRevoked = false }); await DeleteAsync(existingToken.Id); await SaveContext(); return(new DataTransferObject <LoginResponseDTO>(jwt)); }
private static void SendResponses(IEnumerable <BufferedResponse> reponsesToSend) { reponsesToSend.ForAll(bufferedResponse => { Logger.LogInfo("Request {0} of type \"{1}\" took {2:n0} msec to handle.", bufferedResponse.IpcRequest.RequestId, bufferedResponse.IpcRequest.Data.GetType().Name, bufferedResponse.Elapsed.TotalMilliseconds); if (bufferedResponse.IpcResponse.Protocol == IpcProtocols.TypedMessage) { bufferedResponse.SuccessCallback((TypedResponse)bufferedResponse.IpcResponse.Data); } else if (bufferedResponse.IpcResponse.Protocol == IpcProtocols.Exception) { bufferedResponse.ErrorCallback((ErrorResponse)bufferedResponse.IpcResponse.Data); } else { var error = new InvalidOperationException(string.Format("Unknown response protocol: {0}", bufferedResponse.IpcResponse.Protocol)); var errorResponse = ErrorResponseHelper.CreateErrorResponse(error); bufferedResponse.ErrorCallback(errorResponse); } }); }
private static void SendResponse(BufferedResponse bufferedResponse) { Logger.LogInfo("Server request #{0} ({1}) took {2:n0} msec to execute.", bufferedResponse.IpcRequest.RequestId, GetRequestDescription(bufferedResponse.IpcRequest), bufferedResponse.Elapsed.TotalMilliseconds); if (bufferedResponse.IpcResponse.Protocol == IpcProtocols.TypedMessage) { bufferedResponse.SuccessCallback((TypedResponse)bufferedResponse.IpcResponse.Data); } else if (bufferedResponse.IpcResponse.Protocol == IpcProtocols.Exception) { bufferedResponse.ErrorCallback((ErrorResponse)bufferedResponse.IpcResponse.Data); } else { var error = new InvalidOperationException(string.Format("Unknown response protocol: {0}", bufferedResponse.IpcResponse.Protocol)); var errorResponse = ErrorResponseHelper.CreateErrorResponse(error); bufferedResponse.ErrorCallback(errorResponse); } }
private void DispatchThreadServerRequestExecutor_OnProcessFatalError(object sender, ErrorEventArgs args) { ViewModel.ServerIsRunning = false; ReportServerError(ErrorResponseHelper.CreateErrorResponse(args.GetException())); }