public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var names = typeof(SkinView3D.Class).Assembly.GetManifestResourceNames();
Uri u = new Uri(request.Url);
string resourceName = string.Format("{0}{1}", u.Authority, u.AbsolutePath).ToLower();
string resourcePath = @"/SkinView3D;component/" + resourceName;
var assembly = typeof(SkinView3D.Class).Assembly;
var rm = new ResourceManager(assembly.GetName().Name + ".g", assembly);
var resources = rm.GetResourceSet(CultureInfo.CurrentCulture, true, true);
var resourceDictionary = resources.Cast <DictionaryEntry>().ToDictionary(r => r.Key.ToString(), r => r.Value.ToString());
bool validResource = resourceDictionary.ContainsKey(resourceName);
if (validResource)
{
Task.Run(() =>
{
using (callback)
{
try
{
StreamResourceInfo sri = Application.GetResourceStream(new Uri(resourcePath, UriKind.Relative));
if (sri != null)
{
Stream stream = sri.Stream;
string mimeType = sri.ContentType;
// Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer
stream.Position = 0;
// Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect)
ResponseLength = stream.Length;
MimeType = mimeType;
StatusCode = (int)HttpStatusCode.OK;
Stream = stream;
callback.Continue();
}
else
{
callback.Cancel();
}
}
catch (Exception ex)
{
callback.Cancel();
Program.LogConsoleLine(ex);
}
}
});
}
else
{
callback.Cancel();
}
rm.ReleaseAllResources();
return(CefReturnValue.ContinueAsync);
}
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var uri = new Uri(request.Url);
var file = $"{uri.Host}:{uri.LocalPath}";
Task.Run(() =>
{
using (callback)
{
if (!File.Exists(file))
{
callback.Cancel();
return;
}
byte[] bytes = File.ReadAllBytes(file);
var stream = new MemoryStream(bytes)
{
Position = 0
};
ResponseLength = stream.Length;
var fileExtension = Path.GetExtension(file);
MimeType = GetMimeType(fileExtension);
StatusCode = (int)HttpStatusCode.OK;
Stream = stream;
callback.Continue();
}
});
return(CefReturnValue.ContinueAsync);
}
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
Task.Run(() =>
{
using (callback)
{
try
{
string url = request.Url;
var uri = new Uri(url);
//Get the absolute path and remove the leading slash
var asbolutePath = string.Format("{0}:\\", uri.Authority) + uri.AbsolutePath.Substring(1);
var filePath = WebUtility.UrlDecode(Path.GetFullPath(asbolutePath));
if (File.Exists(filePath))
{
Stream stream = File.OpenRead(filePath);
string mimeType = MimeMapping.GetMimeMapping(filePath);
// Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer
stream.Position = 0;
// Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect)
ResponseLength = stream.Length;
MimeType = mimeType;
StatusCode = (int)HttpStatusCode.OK;
Stream = stream;
callback.Continue();
}
else
{
callback.Cancel();
}
}
catch (Exception ex)
{
callback.Cancel();
System.Diagnostics.Debug.WriteLine(ex);
}
}
});
return(CefReturnValue.ContinueAsync);
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var uri = new Uri(request.Url);
var fileName = uri.AbsolutePath;
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_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)
{
_chromelyResource.Content = null;
_chromelyResource.MimeType = "text/html";
try
{
byte[] fileBytes = File.ReadAllBytes(file);
_chromelyResource.Content = new MemoryStream(fileBytes);
string extension = Path.GetExtension(file);
_chromelyResource.MimeType = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception);
}
if (_chromelyResource.Content == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
}
return(CefReturnValue.ContinueAsync);
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var u = new Uri(request.Url);
var fileAbsolutePath = u.AbsolutePath;
var file = u.Authority + fileAbsolutePath;
_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)
{
_chromelyResource.Content = null;
_chromelyResource.MimeType = "text/html";
try
{
if (!ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath))
{
ProcessLocalFile(file);
}
}
catch (Exception exception)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception);
}
if (_chromelyResource.Content == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
}
return(CefReturnValue.ContinueAsync);
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
if (!this.PrepareRequest(request))
{
return(CefReturnValue.Cancel);
}
_cancellationTokenSource = new CancellationTokenSource();
_dataStream = null;
Task.Run(async() =>
{
using (callback)
{
try
{
if (await LoadResourceData(_cancellationTokenSource.Token))
{
_dataStream = await GetResourceDataStream(_cancellationTokenSource.Token);
}
}
catch (TaskCanceledException)
{
Logger.Instance.Log.LogInformation("The request was canceled.");
}
catch (Exception ex) when(ex.Message == "The request was aborted: The request was canceled.")
{
Logger.Instance.Log.LogInformation("The request was canceled.");
}
catch (Exception ex)
{
Logger.Instance.Log.LogError(ex, "Exception thrown while loading resource");
}
if (_dataStream == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
return(CefReturnValue.ContinueAsync);
}
public override bool ProcessRequestAsync(IRequest request, ICallback callback)
{
var domain = GlobalConfig.Domain.EmbeddedName;
if (!request.Url.StartsWith(domain, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
Task.Run(() =>
{
// In this task you can perform your time consuming operations, e.g query a database
// NOTE: We suggest that you wrap callbacks in a using statemnt so that they're disposed
// even if there is an exception as they wrap an unmanaged response which will cause memory
// leaks if not freed
using (callback)
{
var url = request.Url.Replace(domain, string.Empty);
var requestRes = this.GetEmbeddedResName(url.ToAppPath(true));
var stream = CurrentAssembly.GetManifestResourceStream(requestRes);
if (stream == null)
{
callback.Cancel();
}
else
{
//Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer
stream.Position = 0;
//Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect)
ResponseLength = stream.Length;
MimeType = GetMimeType(Path.GetExtension(requestRes));
StatusCode = (int)HttpStatusCode.OK;
Stream?.Dispose();
Stream = stream;
callback.Continue();
}
}
}).ConfigureAwait(false);
return(true);
}
public override bool ProcessRequestAsync(IRequest request, ICallback callback)
{
Task.Run(() =>
{
var uri = new Uri(request.Url);
try
{
var resource = Application.GetResourceStream(new Uri(uri.AbsolutePath, UriKind.Relative));
MimeType = resource.ContentType;
StatusCode = (int)(HttpStatusCode.OK);
Stream = resource.Stream;
ResponseLength = Stream.Length;
callback.Continue();
}
catch (IOException)
{
callback.Cancel();
}
});
return(true);
}
public bool ProcessRequest(IRequest request, ICallback callback)
{
try
{
// Request start/finish is logged already by Asp.Net Core, so we'll only log at debug level
_logger.LogDebug(LoggerEventIds.RequestStarting, "Request starting {0} '{1}'", request.Method, request.Url);
var url = new Uri(request.Url);
_requestUri = url;
var internalRequest = new PositronRequest
{
Protocol = "HTTP/1.1",
Method = request.Method,
Path = Uri.UnescapeDataString(url.AbsolutePath),
QueryString = url.Query,
Scheme = url.Scheme,
Headers = new CefHeaderDictionary(request.Headers)
};
if (!internalRequest.Headers.ContainsKey("Host"))
{
// We need to pass the Host header to ensure correct URL in logging
internalRequest.Headers.Add("Host", new StringValues("positron"));
}
if (request.PostData != null && request.PostData.Elements.Any())
{
internalRequest.Body = new MemoryStream(request.PostData.Elements.First().Bytes);
}
Task.Run(() =>
{
var processor = _webHost.ServerFeatures.Get <IInternalHttpRequestFeature>();
// Do this in a task to ensure it doesn't execute synchronously on the ProcessRequest thread
processor.ProcessRequestAsync(internalRequest)
.ContinueWith(task =>
{
_logger.LogDebug(LoggerEventIds.RequestFinished, "Request finished {0} '{1}': {2}",
internalRequest.Method, _requestUri, task.Result.StatusCode);
using (callback)
{
_response = task.Result;
callback.Continue();
}
}, TaskContinuationOptions.OnlyOnRanToCompletion)
.ContinueWith(task =>
{
_logger.LogError(LoggerEventIds.RequestError, task.Exception, "Error processing request '{0}'",
_requestUri);
using (callback)
{
_response = null;
callback.Cancel();
}
}, TaskContinuationOptions.NotOnRanToCompletion)
.ContinueWith(task =>
{
internalRequest.Body?.Dispose();
});
});
return(true);
}
catch (Exception ex)
{
_logger.LogError(LoggerEventIds.RequestError, ex, "Error processing request '{0}'", _requestUri);
callback.Cancel();
callback.Dispose();
return(true);
}
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var uri = new Uri(request.Url);
var fileName = uri.AbsolutePath;
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
SetResponseInfoOnFailure((int)HttpStatusCode.NotFound, STATUSTEXT_FILENOTFOUND);
callback.Continue();
Logger.Instance.Log.LogWarning($"File: {file}: {StatusText}");
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
SetResponseInfoOnFailure((int)HttpStatusCode.BadRequest, STATUSTEXT_ZEROFILESIZE);
callback.Continue();
Logger.Instance.Log.LogWarning($"File: {file}: {StatusText}");
}
else
{
Task.Run(() =>
{
using (callback)
{
_stream = null;
_mimeType = "text/html";
try
{
byte[] fileBytes = File.ReadAllBytes(file);
_stream = new MemoryStream(fileBytes);
string extension = Path.GetExtension(file);
_mimeType = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
SetResponseInfoOnFailure((int)HttpStatusCode.BadRequest, STATUSTEXT_BADREQUEST);
Logger.Instance.Log.LogError(exception, exception.Message);
}
if (_stream == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
}
return CefReturnValue.ContinueAsync;
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var u = new Uri(request.Url);
var fileAbsolutePath = u.AbsolutePath;
var file = u.Authority + fileAbsolutePath;
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
SetResponseInfoOnFailure((int)HttpStatusCode.NotFound, STATUSTEXT_FILENOTFOUND);
callback.Continue();
Logger.Instance.Log.LogWarning($"File: {file}: {StatusText}");
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
SetResponseInfoOnFailure((int)HttpStatusCode.BadRequest, STATUSTEXT_ZEROFILESIZE);
callback.Continue();
Logger.Instance.Log.LogWarning($"File: {file}: {StatusText}");
}
else
{
Task.Run(() =>
{
using (callback)
{
_stream = null;
_mimeType = "text/html";
try
{
if (!ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath))
{
ProcessLocalFile(file);
}
}
catch (Exception exception)
{
SetResponseInfoOnFailure((int)HttpStatusCode.BadRequest, STATUSTEXT_BADREQUEST);
Logger.Instance.Log.LogError(exception, exception.Message);
}
if (_stream == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
}
return(CefReturnValue.ContinueAsync);
}
//
// Parameters:
// request:
// The request object.
//
// callback:
//
//
// Returns:
// To handle the request return true and call CefSharp.ICallback.Continue once the
// response header information is available CefSharp.ICallback.Continue can also
// be called from inside this method if header information is available immediately).
// To cancel the request return false.
/// <summary>
/// Begin processing the request by mapping it to a file on the file system.
/// </summary>
/// <param name="request">The request object.</param>
/// <param name="callback">The callback used to Continue or Cancel the request (async).</param>
/// <returns></returns>
public override bool ProcessRequestAsync(IRequest request, ICallback callback)
{
var uri = new Uri(request.Url);
// Only handle fs scheme.
if (uri.Scheme != "fs")
{
return(false);
}
var root = uri.Authority;
// If the root of the path is a system volume then add the volume separator ":"
// else it will be consider as just another directory.
if (_systemVolumes.Any(v => v.StartsWith(root)))
{
root = root + Path.VolumeSeparatorChar;
}
var filepath = root + uri.AbsolutePath;
Task.Run(() =>
{
var mimeType = "";
using (callback)
{
if (File.Exists(filepath))
{
switch (Path.GetExtension(filepath).ToLower())
{
case ".css":
mimeType = "text/css";
break;
case ".html":
case ".htm":
mimeType = "text/html";
break;
case ".json":
mimeType = "application/json";
break;
case ".js":
mimeType = "text/javascript";
break;
case ".png":
mimeType = "image/png";
break;
case ".appcache":
case ".manifest":
mimeType = "text/cache-manifest";
break;
default:
mimeType = "application/octet-stream";
break;
}
var stream = new MemoryStream(File.ReadAllBytes(filepath));
//Reset the stream position to 0 so the stream can be copied into the underlying unmanaged buffer
stream.Position = 0;
//Populate the response values - No longer need to implement GetResponseHeaders (unless you need to perform a redirect)
ResponseLength = stream.Length;
MimeType = mimeType;
StatusCode = (int)HttpStatusCode.OK;
Stream = stream;
callback.Continue();
}
else
{
ForErrorMessage("File not found.", HttpStatusCode.NotFound);
StatusCode = 404;
callback.Cancel();
}
}
});
return(true);
}
/// <summary>
/// The process request async.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
{
var scheme = _requestSchemeHandlerProvider?.GetScheme(request.Url);
if (scheme != null && scheme.UrlSchemeType == UrlSchemeType.LocalRquest)
{
_stream = null;
var uri = new Uri(request.Url);
var path = uri.LocalPath;
_mimeType = "application/json";
bool isRequestAsync = _routeProvider.IsActionRouteAsync(path);
if (isRequestAsync)
{
ProcessRequestAsync(path);
}
else
{
ProcessRequest(path);
}
}
return(CefReturnValue.ContinueAsync);
#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)System.Net.HttpStatusCode.BadRequest;
response.StatusText = "Bad Request";
_chromelyResponse = response;
}
else
{
var parameters = request.Url.GetParameters();
var postData = request.GetPostData();
_chromelyResponse = _requestTaskRunner.Run(path, parameters, postData);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
var content = Encoding.UTF8.GetBytes(jsonData);
_stream = new MemoryStream();
_stream.Write(content, 0, content.Length);
}
}
catch (Exception exception)
{
_stream = null;
Logger.Instance.Log.LogError(exception, exception.Message);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
if (_stream == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
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 = request.GetPostData();
_chromelyResponse = await _requestTaskRunner.RunAsync(path, parameters, postData);
string jsonData = _serializerUtil.EnsureResponseDataIsJson(_chromelyResponse.Data);
var content = Encoding.UTF8.GetBytes(jsonData);
_stream = new MemoryStream();
_stream.Write(content, 0, content.Length);
}
}
catch (Exception exception)
{
_stream = null;
Logger.Instance.Log.LogError(exception, exception.Message);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
if (_stream == null)
{
callback.Cancel();
}
else
{
SetResponseInfoOnSuccess();
callback.Continue();
}
}
});
}
#endregion
}
