protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback) { // Backwards compatibility. ProcessRequest will be called. callback.Dispose(); handleRequest = false; return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var u = new Uri(request.Url); var fileAbsolutePath = u.AbsolutePath; var file = u.Authority + fileAbsolutePath; if (string.IsNullOrEmpty(Path.GetFileName(file))) { file = Path.Combine(file, "index.html"); } _totalBytesRead = 0; _chromelyResource.Content = null; _completed = false; if (ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath, callback)) { return(true); } if (ProcessLocalFile(file, callback)) { return(true); } callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var isCustomScheme = _config?.UrlSchemes?.IsUrlRegisteredCustomScheme(request.Url); if (isCustomScheme.HasValue && isCustomScheme.Value) { Task.Run(() => { using (callback) { try { var uri = new Uri(request.Url); var path = uri.LocalPath; var response = new ChromelyResponse(); if (string.IsNullOrEmpty(path)) { response.ReadyState = (int)ReadyState.ResponseIsReady; response.Status = (int)System.Net.HttpStatusCode.BadRequest; response.StatusText = "Bad Request"; _chromelyResponse = response; } else { var parameters = request.Url.GetParameters(); var postData = GetPostData(request); _chromelyResponse = _requestTaskRunner.Run(request.Method, path, parameters, postData); string jsonData = _chromelyResponse.Data.EnsureResponseDataIsJsonFormat(); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } } catch (Exception exception) { Logger.Instance.Log.Error(exception); _chromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); return(true); } Logger.Instance.Log.Error($"Url {request.Url} is not of a registered custom scheme."); callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; _totalBytesRead = 0; _fileBytes = null; _completed = false; var fileInfo = new FileInfo(file); // Check if file exists if (!fileInfo.Exists) { _chromelyErrorHandler.HandleResourceError(ResourceStatus.FileNotFound, file, out _statusCode, out _statusText); _fileBytes = _statusText.GetMemoryStream(); callback.Continue(); } // Check if file exists but empty else if (fileInfo.Length == 0) { _chromelyErrorHandler.HandleResourceError(ResourceStatus.ZeroFileSize, file, out _statusCode, out _statusText); _fileBytes = _statusText.GetMemoryStream(); callback.Continue(); } else { Task.Run(() => { using (callback) { try { _fileBytes = File.ReadAllBytes(file); string extension = Path.GetExtension(file); _mime = MimeMapper.GetMimeType(extension); _statusCode = ResourceConstants.StatusOK; _statusText = ResourceConstants.StatusOKText; } catch (Exception exception) { _chromelyErrorHandler.HandleResourceError(ResourceStatus.FileProcessingError, file, exception, out _statusCode, out _statusText); _fileBytes = _statusText.GetMemoryStream(); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { uri = new Uri(request.Url); fileName = uri.AbsolutePath; // if url is blocked /*if (!myForm.IsURLOk(request.Url)) { * * // return true so it does not open up * return true; * }*/ // if url is browser file if (uri.Host == "storage") { fileName = appPath + uri.Host + fileName; if (File.Exists(fileName)) { Task.Factory.StartNew(() => { using (callback) { //var bytes = Encoding.UTF8.GetBytes(resource); //stream = new MemoryStream(bytes); FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); // mimeType = CefResourceHandler.GetMimeType(Path.GetExtension(fileName)); stream = fStream; callback.Continue(); } }); return(true); } } // if url is request for icon of another file if (uri.Host == "fileicon") { Task.Factory.StartNew(() => { using (callback) { stream = FileIconUtils.GetFileIcon(fileName, FileIconSize.Large); // mimeType = ResourceHandler.GetMimeType(".png"); callback.Continue(); } }); return(true); } // by default reject callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { if (!this.PrepareRequest(request)) { return(false); } _cancellationTokenSource = new CancellationTokenSource(); _dataStream = null; GetResource(); return(true); async void GetResource() { try { if (await LoadResourceData(_cancellationTokenSource.Token)) { _dataStream = await GetResourceDataStream(_cancellationTokenSource.Token); } } catch (TaskCanceledException) { Logger.Instance.Log.Info("The request was canceled."); } catch (Exception ex) when(ex.Message == "The request was aborted: The request was canceled.") { Logger.Instance.Log.Info("The request was canceled."); } catch (Exception ex) { Logger.Instance.Log.Error(ex, "Exception thrown while loading resource"); } finally { callback.Continue(); callback.Dispose(); } } }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; _totalBytesRead = 0; _fileBytes = null; _completed = false; // Check if file exists and not empty var fileInfo = new FileInfo(file); if ((fileInfo.Exists) && fileInfo.Length > 0) { Task.Run(() => { using (callback) { try { _fileBytes = File.ReadAllBytes(file); string extension = Path.GetExtension(file); _mime = MimeMapper.GetMimeType(extension); } catch (Exception exception) { Logger.Instance.Log.Error(exception); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback) { //Dispose the callback as it's an unmanaged resource, we don't need it in this case callback.Dispose(); if (stream == null) { bytesRead = 0; return(false); } //Data out represents an underlying buffer (typically 32kb in size). var buffer = new byte[response.Length]; bytesRead = stream.Read(buffer, 0, buffer.Length); response.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
/// <summary> /// The process request. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> protected override bool ProcessRequest(CefRequest request, CefCallback callback) { bool isCustomScheme = UrlSchemeProvider.IsUrlOfRegisteredCustomScheme(request.Url); if (isCustomScheme) { Task.Run(() => { using (callback) { try { mChromelyResponse = RequestTaskRunner.Run(request); string jsonData = mChromelyResponse.Data.EnsureResponseIsJsonFormat(); mResponseBytes = Encoding.UTF8.GetBytes(jsonData); } catch (Exception exception) { Log.Error(exception); mChromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); return(true); } Log.Error($"Url {request.Url} is not of a registered custom scheme."); callback.Dispose(); return(false); }
/// <summary> /// The process request. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; this.mTotalBytesRead = 0; this.mFileBytes = null; this.mCompleted = false; if (File.Exists(file)) { Task.Factory.StartNew(() => { using (callback) { try { this.mFileBytes = File.ReadAllBytes(file); string extension = Path.GetExtension(file); this.mMime = MimeMapper.GetMimeType(extension); } catch (Exception exception) { Log.Error(exception); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback) { callback.Dispose(); if (Response == null) { bytesRead = 0; return(false); } var buffer = new byte[response.Length]; bytesRead = Response.Read(buffer, 0, buffer.Length); if (bytesRead == 0) { return(false); } response.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback) { callback.Dispose(); if (Stream == null) { bytesRead = 0; return(false); } var buffer = new byte[response.Length]; bytesRead = Stream.Read(buffer, 0, buffer.Length); response.Write(buffer, 0, buffer.Length); if (Stream.Position >= Stream.Length - 1 && bytesRead == 0) { Stream.Close(); LogManager.CefLog("Closed file stream!"); } return(bytesRead > 0); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { bool isCustomScheme = UrlSchemeProvider.IsUrlOfRegisteredCustomScheme(request.Url); if (isCustomScheme) { Task.Factory.StartNew(() => { using (callback) { try { m_chromelyResponse = CefGlueRequestTaskRunner.Run(request); } catch (Exception exception) { Log.Error(exception); m_chromelyResponse = new ChromelyResponse(); m_chromelyResponse.Status = (int)HttpStatusCode.BadRequest; m_chromelyResponse.Data = "An error occured."; } finally { callback.Continue(); } } }); return(true); } Log.Error(string.Format("Url {0} is not of a registered custom scheme.", request.Url)); callback.Dispose(); return(false); }
/// <summary> /// The process request. /// </summary> /// <param name="request"> /// The request. /// </param> /// <param name="callback"> /// The callback. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> protected override bool ProcessRequest(CefRequest request, CefCallback callback) { //var baseRelative = _baseDir.Replace("\\", "/"); var u = new Uri(request.Url); var file = Path.Join(AppDomain.CurrentDomain.BaseDirectory, _appDirectory, u.AbsolutePath); //if (first == null) //{ // first = Path.GetDirectoryName(file); //} //else //{ // file = Path.Join(first, u.AbsolutePath); //} this.mTotalBytesRead = 0; this.mFileBytes = null; this.mCompleted = false; if (File.Exists(file)) { Task.Factory.StartNew(() => { using (callback) { try { this.mFileBytes = File.ReadAllBytes(file); string extension = Path.GetExtension(file); Log.Info(extension); if (extension == ".wasm") { this.mMime = "application/wasm"; } else if (extension == ".dll") { this.mMime = "application/octet-stream"; } else if (extension == ".json") { this.mMime = "application/json"; } else if (extension == ".woff" || extension == ".woff2") { this.mMime = "application/font-woff"; } else { this.mMime = MimeMapper.GetMimeType(extension); } } catch (Exception exception) { Log.Error(exception); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var u = new Uri(request.Url); var file = u.Authority + u.AbsolutePath; _totalBytesRead = 0; _fileBytes = null; _completed = false; var fileInfo = new FileInfo(file); // Check if file exists if (!fileInfo.Exists) { var status = ResourceFileStatus.FileNotFound.GetStatus(); _status = status.Item1; _statusText = status.Item2; _fileBytes = _statusText.GetMemoryStream(); Logger.Instance.Log.LogWarning($"File: {file}: {_statusText}"); callback.Continue(); } // Check if file exists but empty else if (fileInfo.Length == 0) { var status = ResourceFileStatus.ZeroFileSize.GetStatus(); _status = status.Item1; _statusText = status.Item2; _fileBytes = _statusText.GetMemoryStream(); Logger.Instance.Log.LogWarning($"File: {file}: {_statusText}"); callback.Continue(); } else { Task.Run(() => { using (callback) { try { _fileBytes = File.ReadAllBytes(file); string extension = Path.GetExtension(file); _mime = MimeMapper.GetMimeType(extension); var status = ResourceFileStatus.FileFound.GetStatus(); _status = status.Item1; _statusText = status.Item2; } catch (Exception exception) { var status = ResourceFileStatus.FileProcessingError.GetStatus(); _status = status.Item1; _statusText = status.Item2; _fileBytes = _statusText.GetMemoryStream(); Logger.Instance.Log.LogError(exception, exception.Message); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var isSchemeRegistered = _requestSchemeProvider?.IsSchemeRegistered(request.Url); if (isSchemeRegistered.HasValue && isSchemeRegistered.Value) { var uri = new Uri(request.Url); var path = uri.LocalPath; bool isRequestAsync = _routeProvider.IsActionRouteAsync(path); if (isRequestAsync) { ProcessRequestAsync(path); } else { ProcessRequest(path); } return(true); } else { _chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), request.Url); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } callback.Dispose(); return(false); #region Process Request void ProcessRequest(string path) { Task.Run(() => { using (callback) { try { if (string.IsNullOrWhiteSpace(path)) { _chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), path); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } else { var parameters = request.Url.GetParameters(request.ReferrerURL); var postData = GetPostData(request); var jsonRequest = _serializerUtil.ObjectToJson(request); _chromelyResponse = _requestTaskRunner.Run(request.Identifier.ToString(), path, parameters, postData, jsonRequest); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } } catch (Exception exception) { var chromelyRequest = new ChromelyRequest() { Id = request.Identifier.ToString(), RouteUrl = request.Url }; _chromelyResponse = _chromelyErrorHandler.HandleError(chromelyRequest, exception); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } finally { callback.Continue(); } } }); } #endregion #region Process Request Async void ProcessRequestAsync(string path) { Task.Run(async() => { using (callback) { try { if (string.IsNullOrWhiteSpace(path)) { _chromelyResponse = _chromelyErrorHandler.HandleRouteNotFound(request.Identifier.ToString(), path); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } else { var parameters = request.Url.GetParameters(request.ReferrerURL); var postData = GetPostData(request); var jsonRequest = _serializerUtil.ObjectToJson(request); _chromelyResponse = await _requestTaskRunner.RunAsync(request.Identifier.ToString(), path, parameters, postData, jsonRequest); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } } catch (Exception exception) { var chromelyRequest = new ChromelyRequest() { Id = request.Identifier.ToString(), RouteUrl = request.Url }; _chromelyResponse = _chromelyErrorHandler.HandleError(chromelyRequest, exception); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } finally { callback.Continue(); } } }); } #endregion }
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback) { // if no data stream was specified, then nothing to read // and we should stop reading. // return false to indicate this. if (_dataStream == null) { bytesRead = 0; callback.Continue(); callback.Dispose(); return(false); } // when this is second call of ReadResponse, _bytesRead will be set to non negative number if (_bytesRead >= 0) { WriteReadBytes(out bytesRead); callback.Dispose(); return(bytesRead != 0); //If read 0 bytes, then we should return in false } bytesRead = 0; _ = ReadDataAsync(); return(true); // Copies read bytes into response and return true, if data is completed, owtherwize returns false async Task ReadDataAsync() { try { if (_rentedBuffer == null) { _rentedBuffer = ArrayPool <byte> .Shared.Rent(_bufferSize); } //await _semaphore.WaitAsync(); _bytesRead = await _dataStream.ReadAsync(_rentedBuffer, 0, Math.Min(bytesToRead, _bufferSize), _cancellationTokenSource.Token); //_semaphore.Release(); } catch (TaskCanceledException) { FreeResources(); _bytesRead = 0; Logger.Instance.Log.Warn("Cancellation requested"); } // Sometimes cef disposes object, before it is cancelled // then this exception is thrown // and i don't know how to fix this :( catch (ObjectDisposedException) { FreeResources(); _bytesRead = 0; Logger.Instance.Log.Warn("Cancellation requested"); } catch (Exception ex) { FreeResources(); _bytesRead = 0; Logger.Instance.Log.Error(ex, "Exception thrown while loading resource"); } finally { callback.Continue(); callback.Dispose(); } } bool WriteReadBytes(out int bytesAlreadyRead) { if (_bytesRead == 0) //if 0 bytes read, then no data was read and we should complete request { bytesAlreadyRead = 0; this.FreeResources(); return(true); } if (_bytesRead > 0) //writing read bytes into a buffer if there was something { response.Write(_rentedBuffer, 0, _bytesRead); } bytesAlreadyRead = _bytesRead; //incrementing counters _totalRead += _bytesRead; // Setting read bytes count to -1 to indicate, that nothing left to write // End on next call Read from source should be performed _bytesRead = -1; var dataSize = this.GetDataSize(); // If datasize is known and we already read that amount, then stoping bool completed = dataSize >= 0 && _totalRead == dataSize; // if we completed data reading, freeing resources imediatly, // because this ReadResponse will never be called again // and any open file will left open forever if (completed) { this.FreeResources(); } return(completed); } }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var uri = new Uri(request.Url); var scheme = _config.UrlSchemes.GetScheme(request.Url); var isFolderResourceScheme = scheme != null && scheme.IsUrlSchemeFolderResource(); var u = new Uri(request.Url); var file = isFolderResourceScheme ? scheme.GetResourceFolderFile(u.AbsolutePath) : u.Authority + u.AbsolutePath; _totalBytesRead = 0; _chromelyResource.Content = null; _completed = false; _fileInfo = new FileInfo(file); // Check if file exists if (!_fileInfo.Exists) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } // Check if file exists but empty else if (_fileInfo.Length == 0) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo); callback.Continue(); } else { Task.Run(() => { using (callback) { try { var fileBytes = File.ReadAllBytes(file); _chromelyResource.Content = new MemoryStream(fileBytes); string extension = Path.GetExtension(file); _chromelyResource.MimeType = MimeMapper.GetMimeType(extension); _chromelyResource.StatusCode = ResourceConstants.StatusOK; _chromelyResource.StatusText = ResourceConstants.StatusOKText; } catch (Exception exception) { _chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception); } finally { callback.Continue(); } } }); return(true); } callback.Dispose(); return(false); }
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback) { bytesRead = 0; callback.Dispose(); return(true); }
protected override bool ProcessRequest(CefRequest request, CefCallback callback) { var isSchemeRegistered = _requestSchemeProvider?.IsSchemeRegistered(request.Url); if (isSchemeRegistered.HasValue && isSchemeRegistered.Value) { var uri = new Uri(request.Url); var path = uri.LocalPath; bool isRequestAsync = _routeProvider.IsActionRouteAsync(path); if (isRequestAsync) { ProcessRequestAsync(path); } else { ProcessRequest(path); } return(true); } Logger.Instance.Log.LogWarning($"Url {request.Url} is not of a registered custom scheme."); callback.Dispose(); return(false); #region Process Request void ProcessRequest(string path) { Task.Run(() => { using (callback) { try { var response = new ChromelyResponse(); if (string.IsNullOrEmpty(path)) { response.ReadyState = (int)ReadyState.ResponseIsReady; response.Status = (int)HttpStatusCode.BadRequest; response.StatusText = "Bad Request"; _chromelyResponse = response; } else { var parameters = request.Url.GetParameters(); var postData = GetPostData(request); var jsonRequest = _serializerUtil.ObjectToJson(request); _chromelyResponse = _requestTaskRunner.Run(request.Identifier.ToString(), path, parameters, postData, jsonRequest); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } } catch (Exception exception) { Logger.Instance.Log.LogError(exception, exception.Message); _chromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); } #endregion #region Process Request Async void ProcessRequestAsync(string path) { Task.Run(async() => { using (callback) { try { var response = new ChromelyResponse(); if (string.IsNullOrEmpty(path)) { response.ReadyState = (int)ReadyState.ResponseIsReady; response.Status = (int)System.Net.HttpStatusCode.BadRequest; response.StatusText = "Bad Request"; _chromelyResponse = response; } else { var parameters = request.Url.GetParameters(); var postData = GetPostData(request); var jsonRequest = _serializerUtil.ObjectToJson(request); _chromelyResponse = await _requestTaskRunner.RunAsync(request.Identifier.ToString(), path, parameters, postData, jsonRequest); string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data); _responseBytes = Encoding.UTF8.GetBytes(jsonData); } } catch (Exception exception) { Logger.Instance.Log.LogError(exception, exception.Message); _chromelyResponse = new ChromelyResponse { Status = (int)HttpStatusCode.BadRequest, Data = "An error occured." }; } finally { callback.Continue(); } } }); } #endregion }