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()));
}
