diff options
101 files changed, 20451 insertions, 0 deletions
diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b2d2554 --- /dev/null +++ b/.gitignore @@ -0,0 +1,353 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# exclude all json files as blanket for config +*.json
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/AccessTokenEndpoint.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/AccessTokenEndpoint.cs new file mode 100644 index 0000000..271328a --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/AccessTokenEndpoint.cs @@ -0,0 +1,109 @@ +using System; +using System.Net; + +using VNLib.Utils.Memory; +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Essentials.Extensions; +using VNLib.Plugins.Extensions.Validation; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Extensions.Loading.Sql; + + +namespace VNLib.Plugins.Essentials.Sessions.OAuth.Endpoints +{ + /// <summary> + /// Grants authorization to OAuth2 clients to protected resources + /// with access tokens + /// </summary> + internal sealed class AccessTokenEndpoint : ResourceEndpointBase + { + + private readonly Lazy<ITokenManager> TokenStore; + private readonly Applications Applications; + + //override protection settings to allow most connections to authenticate + protected override ProtectionSettings EndpointProtectionSettings { get; } = new() + { + BrowsersOnly = false, + SessionsRequired = false, + VerifySessionCors = false + }; + + public AccessTokenEndpoint(string path, PluginBase pbase, Lazy<ITokenManager> tokenStore) + { + InitPathAndLog(path, pbase.Log); + TokenStore = tokenStore; + Applications = new(pbase.GetContextOptions(), pbase.GetPasswords()); + } + + protected override async ValueTask<VfReturnType> PostAsync(HttpEntity entity) + { + //Check for refresh token + if (entity.RequestArgs.IsArgumentSet("grant_type", "refresh_token")) + { + //process a refresh token + } + //Check for grant_type parameter from the request body + if (!entity.RequestArgs.IsArgumentSet("grant_type", "client_credentials")) + { + entity.CloseResponseError(HttpStatusCode.BadRequest, ErrorType.InvalidClient, "Invalid grant type"); + //Default to bad request + return VfReturnType.VirtualSkip; + } + //Get client id and secret (and make sure theyre not empty + if (entity.RequestArgs.TryGetNonEmptyValue("client_id", out string? clientId) && + entity.RequestArgs.TryGetNonEmptyValue("client_secret", out string? secret)) + { + if (!ValidatorExtensions.OnlyAlphaNumRegx.IsMatch(clientId)) + { + //respond with error message + entity.CloseResponseError(HttpStatusCode.UnprocessableEntity, ErrorType.InvalidRequest, "Invalid client_id"); + return VfReturnType.VirtualSkip; + } + if (!ValidatorExtensions.OnlyAlphaNumRegx.IsMatch(secret)) + { + //respond with error message + entity.CloseResponseError(HttpStatusCode.UnprocessableEntity, ErrorType.InvalidRequest, "Invalid client_secret"); + return VfReturnType.VirtualSkip; + } + //Convert the clientid and secret to lowercase + clientId = clientId.ToLower(); + secret = secret.ToLower(); + //Convert secret to private string + PrivateString secretPv = new(secret, false); + //Get the application from apps store + UserApplication? app = await Applications.VerifyAppAsync(clientId, secretPv); + if (app == null) + { + //App was not found or the credentials do not match + entity.CloseResponseError(HttpStatusCode.UnprocessableEntity, ErrorType.InvalidClient, "The client credentials are invalid"); + return VfReturnType.VirtualSkip; + } + //Create a new session + IOAuth2TokenResult? result = await TokenStore.Value.CreateAccessTokenAsync(entity.Entity, app, entity.EventCancellation); + if (result == null) + { + entity.CloseResponseError(HttpStatusCode.ServiceUnavailable, ErrorType.TemporarilyUnabavailable, "You have reached the maximum number of valid tokens for this application"); + return VfReturnType.VirtualSkip; + } + //Create the new response message + OauthTokenResponseMessage tokenMessage = new() + { + AccessToken = result.AccessToken, + + //set expired as seconds in int form + Expires = result.ExpiresSeconds, + RefreshToken = result.RefreshToken, + TokenType = result.TokenType + }; + //Respond with the token message + entity.CloseResponseJson(HttpStatusCode.OK, tokenMessage); + return VfReturnType.VirtualSkip; + + } + //respond with error message + entity.CloseResponseError(HttpStatusCode.UnprocessableEntity, ErrorType.InvalidClient, "The request was missing required arguments"); + return VfReturnType.VirtualSkip; + } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/RevocationEndpoint.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/RevocationEndpoint.cs new file mode 100644 index 0000000..095e07e --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/Endpoints/RevocationEndpoint.cs @@ -0,0 +1,31 @@ +using System; +using System.Text.Json; + +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Extensions.Loading.Configuration; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth.Endpoints +{ + /// <summary> + /// An OAuth2 authorized endpoint for revoking the access token + /// held by the current connection + /// </summary> + [ConfigurationName("oauth2")] + internal class RevocationEndpoint : O2EndpointBase + { + + public RevocationEndpoint(PluginBase pbase, IReadOnlyDictionary<string, JsonElement> config) + { + string? path = config["revocation_path"].GetString(); + InitPathAndLog(path, pbase.Log); + } + + protected override VfReturnType Post(HttpEntity entity) + { + //Revoke the access token, by invalidating it + entity.Session.Invalidate(); + entity.CloseResponse(System.Net.HttpStatusCode.OK); + return VfReturnType.VirtualSkip; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/IOauthSessionIdFactory.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/IOauthSessionIdFactory.cs new file mode 100644 index 0000000..9a65d62 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/IOauthSessionIdFactory.cs @@ -0,0 +1,38 @@ +using System; + +using VNLib.Net.Http; +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Sessions.Cache.Client; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + public interface IOauthSessionIdFactory : ISessionIdFactory + { + /// <summary> + /// The maxium number of tokens allowed to be created per OAuth application + /// </summary> + int MaxTokensPerApp { get; } + /// <summary> + /// Allows for custom configuration of the newly created session and + /// the <see cref="IHttpEvent"/> its attached to + /// </summary> + /// <param name="session">The newly created session</param> + /// <param name="app">The application associated with the session</param> + /// <param name="entity">The http event that generated the new session</param> + void InitNewSession(RemoteSession session, UserApplication app, IHttpEvent entity); + /// <summary> + /// The time a session is valid for + /// </summary> + TimeSpan SessionValidFor { get; } + /// <summary> + /// Called when the session provider wishes to generate a new session + /// and required credential information to generate the new session + /// </summary> + /// <returns>The information genreated for the news ession</returns> + TokenAndSessionIdResult GenerateTokensAndId(); + /// <summary> + /// The type of token this session provider generates + /// </summary> + string TokenType { get; } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/O2SessionProviderEntry.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/O2SessionProviderEntry.cs new file mode 100644 index 0000000..e15c6e4 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/O2SessionProviderEntry.cs @@ -0,0 +1,117 @@ + +using System.Text.Json; + +using VNLib.Net.Http; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Essentials.Sessions.OAuth; +using VNLib.Plugins.Essentials.Sessions.OAuth.Endpoints; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Extensions.Loading.Sql; +using VNLib.Plugins.Extensions.Loading.Events; +using VNLib.Plugins.Extensions.Loading.Routing; +using VNLib.Plugins.Extensions.Loading.Configuration; + +namespace VNLib.Plugins.Essentials.Sessions.Oauth +{ + public sealed class O2SessionProviderEntry : IRuntimeSessionProvider + { + const string VNCACHE_CONFIG_KEY = "vncache"; + const string OAUTH2_CONFIG_KEY = "oauth2"; + + private OAuth2SessionProvider? _sessions; + + bool IRuntimeSessionProvider.CanProcess(IHttpEvent entity) + { + //If authorization header is set try to process as oauth2 session + return entity.Server.Headers.HeaderSet(System.Net.HttpRequestHeader.Authorization); + } + + ValueTask<SessionHandle> ISessionProvider.GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + return _sessions!.GetSessionAsync(entity, cancellationToken); + } + + + void IRuntimeSessionProvider.Load(PluginBase plugin, ILogProvider localized) + { + //Try get vncache config element + IReadOnlyDictionary<string, JsonElement> cacheConfig = plugin.GetConfig(VNCACHE_CONFIG_KEY); + + IReadOnlyDictionary<string, JsonElement> oauth2Config = plugin.GetConfig(OAUTH2_CONFIG_KEY); + + string tokenEpPath = oauth2Config["token_path"].GetString() ?? throw new KeyNotFoundException($"Missing required 'token_path' in '{OAUTH2_CONFIG_KEY}' config"); + + //TODO fix with method that will wait until cache is actually loaded + Lazy<ITokenManager> lazyTokenMan = new(() => _sessions!, false); + + //Init auth endpoint + AccessTokenEndpoint authEp = new(tokenEpPath, plugin, lazyTokenMan); + + //route auth endpoint + plugin.Route(authEp); + + //Route revocation endpoint + plugin.Route<RevocationEndpoint>(); + + //Run + _ = WokerDoWorkAsync(plugin, localized, cacheConfig, oauth2Config); + } + + /* + * Starts and monitors the VNCache connection + */ + + private async Task WokerDoWorkAsync(PluginBase plugin, ILogProvider localized, IReadOnlyDictionary<string, JsonElement> cacheConfig, IReadOnlyDictionary<string, JsonElement> oauth2Config) + { + //Init cache client + using VnCacheClient cache = new(plugin.IsDebug() ? plugin.Log : null, Utils.Memory.Memory.Shared); + + try + { + int cacheLimit = oauth2Config["cache_size"].GetInt32(); + int maxTokensPerApp = oauth2Config["max_tokens_per_app"].GetInt32(); + int sessionIdSize = (int)oauth2Config["access_token_size"].GetUInt32(); + TimeSpan tokenValidFor = oauth2Config["token_valid_for_sec"].GetTimeSpan(TimeParseType.Seconds); + TimeSpan cleanupInterval = oauth2Config["gc_interval_sec"].GetTimeSpan(TimeParseType.Seconds); + string sessionIdPrefix = oauth2Config["cache_prefix"].GetString() ?? throw new KeyNotFoundException($"Missing required key 'cache_prefix' in '{OAUTH2_CONFIG_KEY}' config"); + + //init the id provider + OAuth2SessionIdProvider idProv = new(sessionIdPrefix, maxTokensPerApp, sessionIdSize, tokenValidFor); + + //Try loading config + await cache.LoadConfigAsync(plugin, cacheConfig); + + //Init session provider now that client is loaded + _sessions = new(cache.Resource!, cacheLimit, idProv, plugin.GetContextOptions()); + + //Schedule cleanup interval with the plugin scheduler + plugin.ScheduleInterval(_sessions, cleanupInterval); + + + localized.Information("Session provider loaded"); + + //Run and wait for exit + await cache.RunAsync(localized, plugin.UnloadToken); + + } + catch (OperationCanceledException) + {} + catch (KeyNotFoundException e) + { + localized.Error("Missing required configuration variable for VnCache client: {0}", e.Message); + } + catch (Exception ex) + { + localized.Error(ex, "Cache client error occured in session provider"); + } + finally + { + _sessions = null; + } + + localized.Information("Cache client exited"); + } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2Session.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2Session.cs new file mode 100644 index 0000000..5987c81 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2Session.cs @@ -0,0 +1,107 @@ +using System; + +using VNLib.Net.Http; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Sessions.Cache.Client; + +using static VNLib.Plugins.Essentials.Sessions.ISessionExtensions; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + /// <summary> + /// The implementation of the OAuth2 session container for HTTP sessions + /// </summary> + internal sealed class OAuth2Session : RemoteSession + { + private readonly Action<OAuth2Session> InvalidateCache; + + /// <summary> + /// Initalizes a new <see cref="OAuth2Session"/> + /// </summary> + /// <param name="sessionId">The session id (or token)</param> + /// <param name="client">The <see cref="FBMClient"/> used as the backing cache provider</param> + /// <param name="backgroundTimeOut">The ammount of time to wait for a background operation (delete, update, get)</param> + /// <param name="invalidCache">Called when the session has been marked as invalid and the close even hook is being executed</param> + public OAuth2Session(string sessionId, FBMClient client, TimeSpan backgroundTimeOut, Action<OAuth2Session> invalidCache) + : base(sessionId, client, backgroundTimeOut) + { + InvalidateCache = invalidCache; + IsInvalid = false; + } + + public bool IsInvalid { get; private set; } + + + ///<inheritdoc/> + ///<exception cref="NotSupportedException"></exception> + public override string Token + { + get => throw new NotSupportedException("Token property is not supported for OAuth2 sessions"); + set => throw new NotSupportedException("Token property is not supported for OAuth2 sessions"); + } + + ///<inheritdoc/> + protected override void IndexerSet(string key, string value) + { + //Guard protected entires + switch (key) + { + case TOKEN_ENTRY: + case LOGIN_TOKEN_ENTRY: + throw new InvalidOperationException("Token entry may not be changed!"); + } + base.IndexerSet(key, value); + } + ///<inheritdoc/> + ///<exception cref="SessionStatusException"></exception> + public override async Task WaitAndLoadAsync(IHttpEvent entity, CancellationToken token = default) + { + //Wait to enter lock + await base.WaitAndLoadAsync(entity, token); + if (IsInvalid) + { + //Release lock + MainLock.Release(); + throw new SessionStatusException("The session has been invalidated"); + } + //Set session type + if (IsNew) + { + SessionType = SessionType.OAuth2; + } + } + ///<inheritdoc/> + protected override async ValueTask<Task?> UpdateResource(bool isAsync, IHttpEvent state) + { + Task? result = null; + //Invalid flag is set, so exit + if (IsInvalid) + { + result = Task.CompletedTask; + } + //Check flags in priority level, Invalid is highest state priority + else if (Flags.IsSet(INVALID_MSK)) + { + //Clear all stored values + DataStore!.Clear(); + //Delete the entity syncronously + await ProcessDeleteAsync(); + //Set invalid flag + IsInvalid = true; + //Invlidate cache + InvalidateCache(this); + result = Task.CompletedTask; + } + else if (Flags.IsSet(MODIFIED_MSK)) + { + //Send update to server + result = Task.Run(ProcessUpdateAsync); + } + + //Clear all flags + Flags.ClearAll(); + + return result; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionIdProvider.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionIdProvider.cs new file mode 100644 index 0000000..2b23721 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionIdProvider.cs @@ -0,0 +1,109 @@ +using System; +using System.Diagnostics.CodeAnalysis; + +using VNLib.Utils; +using VNLib.Utils.Memory; +using VNLib.Utils.Extensions; +using VNLib.Hashing; +using VNLib.Net.Http; +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Essentials.Extensions; +using VNLib.Plugins.Sessions.Cache.Client; +using static VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions; + + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + /// <summary> + /// Generates secure OAuth2 session tokens and initalizes new OAuth2 sessions + /// </summary> + internal class OAuth2SessionIdProvider : IOauthSessionIdFactory + { + private readonly string SessionIdPrefix; + private readonly int _bufferSize; + private readonly int _tokenSize; + + ///<inheritdoc/> + public int MaxTokensPerApp { get; } + ///<inheritdoc/> + public TimeSpan SessionValidFor { get; } + ///<inheritdoc/> + string IOauthSessionIdFactory.TokenType => "Bearer"; + + public OAuth2SessionIdProvider(string sessionIdPrefix, int maxTokensPerApp, int tokenSize, TimeSpan validFor) + { + SessionIdPrefix = sessionIdPrefix; + MaxTokensPerApp = maxTokensPerApp; + SessionValidFor = validFor; + _tokenSize = tokenSize; + _bufferSize = tokenSize * 2; + } + + ///<inheritdoc/> + bool ISessionIdFactory.TryGetSessionId(IHttpEvent entity, [NotNullWhen(true)] out string? sessionId) + { + //Get authorization token and make sure its not too large to cause a buffer overflow + if (entity.Server.HasAuthorization(out string? token) && (token.Length + SessionIdPrefix.Length) <= _bufferSize) + { + //Compute session id from token + sessionId = ComputeSessionIdFromToken(token); + + return true; + } + else + { + sessionId = null; + } + + return false; + } + + private string ComputeSessionIdFromToken(string token) + { + //Buffer to copy data to + using UnsafeMemoryHandle<char> buffer = Memory.UnsafeAlloc<char>(_bufferSize, true); + + //Writer to accumulate data + ForwardOnlyWriter<char> writer = new(buffer.Span); + + //Append session id prefix and token + writer.Append(SessionIdPrefix); + writer.Append(token); + + //Compute base64 hash of token and + return ManagedHash.ComputeBase64Hash(writer.AsSpan(), HashAlg.SHA256); + } + + ///<inheritdoc/> + TokenAndSessionIdResult IOauthSessionIdFactory.GenerateTokensAndId() + { + //Alloc buffer for random data + using UnsafeMemoryHandle<byte> mem = Memory.UnsafeAlloc<byte>(_tokenSize, true); + + //Generate token from random cng bytes + RandomHash.GetRandomBytes(mem); + + //Token is the raw value + string token = Convert.ToBase64String(mem.Span); + + //The session id is the HMAC of the token + string sessionId = ComputeSessionIdFromToken(token); + + //Clear buffer + Utils.Memory.Memory.InitializeBlock(mem.Span); + + //Return sessid result + return new(sessionId, token, null); + } + + ///<inheritdoc/> + void IOauthSessionIdFactory.InitNewSession(RemoteSession session, UserApplication app, IHttpEvent entity) + { + //Store session variables + session[APP_ID_ENTRY] = app.Id; + session[TOKEN_TYPE_ENTRY] = "client_credential,bearer"; + session[SCOPES_ENTRY] = app.Permissions; + session.UserID = app.UserId; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionProvider.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionProvider.cs new file mode 100644 index 0000000..d938641 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2SessionProvider.cs @@ -0,0 +1,183 @@ +using System; +using System.Net; + +using Microsoft.EntityFrameworkCore; + +using VNLib.Utils; +using VNLib.Utils.Logging; +using VNLib.Net.Http; +using VNLib.Data.Caching; +using VNLib.Data.Caching.Exceptions; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Essentials.Oauth; +using VNLib.Plugins.Essentials.Oauth.Tokens; +using VNLib.Plugins.Sessions.Cache.Client; +using VNLib.Plugins.Extensions.Loading.Events; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + + /// <summary> + /// Provides OAuth2 session management + /// </summary> + internal sealed class OAuth2SessionProvider : SessionCacheClient, ISessionProvider, ITokenManager, IIntervalScheduleable + { + + private static readonly SessionHandle NotFoundHandle = new(null, FileProcessArgs.NotFound, null); + static readonly TimeSpan BackgroundTimeout = TimeSpan.FromSeconds(10); + + private readonly IOauthSessionIdFactory factory; + private readonly TokenStore TokenStore; + + public OAuth2SessionProvider(FBMClient client, int maxCacheItems, IOauthSessionIdFactory idFactory, DbContextOptions dbCtx) + : base(client, maxCacheItems) + { + factory = idFactory; + TokenStore = new(dbCtx); + } + + ///<inheritdoc/> + protected override RemoteSession SessionCtor(string sessionId) => new OAuth2Session(sessionId, Client, BackgroundTimeout, InvlidatateCache); + + private void InvlidatateCache(OAuth2Session session) + { + lock (CacheLock) + { + _ = CacheTable.Remove(session.SessionID); + } + } + + ///<inheritdoc/> + public async ValueTask<SessionHandle> GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + //Callback to close the session when the handle is closeed + static ValueTask HandleClosedAsync(ISession session, IHttpEvent entity) + { + return ((SessionBase)session).UpdateAndRelease(true, entity); + } + try + { + //Get session id + if (!factory.TryGetSessionId(entity, out string? sessionId)) + { + //Id not allowed/found, so do not attach a session + return SessionHandle.Empty; + } + + //Recover the session + RemoteSession session = await base.GetSessionAsync(entity, sessionId, cancellationToken); + + //Session should not be new + if (session.IsNew) + { + //Invalidate the session, so it is deleted + session.Invalidate(); + await session.UpdateAndRelease(true, entity); + return SessionHandle.Empty; + } + //Make sure session is still valid + if (session.Created.Add(factory.SessionValidFor) < DateTimeOffset.UtcNow) + { + //Invalidate the handle + session.Invalidate(); + //Flush changes + await session.UpdateAndRelease(false, entity); + //Remove the token from the db backing store + await TokenStore.RevokeTokenAsync(sessionId, cancellationToken); + //close entity + entity.CloseResponseError(HttpStatusCode.Unauthorized, ErrorType.InvalidToken, "The token has expired"); + //return a completed handle + return NotFoundHandle; + } + + return new SessionHandle(session, HandleClosedAsync); + } + //Pass session exceptions + catch (SessionException) + { + throw; + } + catch (Exception ex) + { + throw new SessionException("Exception raised while retreiving or loading OAuth2 session", ex); + } + } + ///<inheritdoc/> + async Task<IOAuth2TokenResult?> ITokenManager.CreateAccessTokenAsync(IHttpEvent ev, UserApplication app, CancellationToken cancellation) + { + //Get a new session for the current connection + TokenAndSessionIdResult ids = factory.GenerateTokensAndId(); + //try to insert token into the store, may fail if max has been reached + if (await TokenStore.InsertTokenAsync(ids.SessionId, app.Id, ids.RefreshToken, factory.MaxTokensPerApp, cancellation) != ERRNO.SUCCESS) + { + return null; + } + //Create new session from the session id + RemoteSession session = SessionCtor(ids.SessionId); + await session.WaitAndLoadAsync(ev, cancellation); + try + { + //Init new session + factory.InitNewSession(session, app, ev); + } + finally + { + await session.UpdateAndRelease(false, ev); + } + //Init new token result to pass to client + return new OAuth2TokenResult() + { + ExpiresSeconds = (int)factory.SessionValidFor.TotalSeconds, + TokenType = factory.TokenType, + //Return token and refresh token + AccessToken = ids.AccessToken, + RefreshToken = ids.RefreshToken, + }; + } + ///<inheritdoc/> + Task ITokenManager.RevokeTokensAsync(IReadOnlyCollection<string> tokens, CancellationToken cancellation) + { + throw new NotImplementedException(); + } + ///<inheritdoc/> + Task ITokenManager.RevokeTokensForAppAsync(string appId, CancellationToken cancellation) + { + throw new NotImplementedException(); + } + + async Task IIntervalScheduleable.OnIntervalAsync(ILogProvider log, CancellationToken cancellationToken) + { + //Calculate valid token time + DateTimeOffset validAfter = DateTimeOffset.UtcNow.Subtract(factory.SessionValidFor); + //Remove tokens from db store + IReadOnlyCollection<ActiveToken> revoked = await TokenStore.CleanupExpiredTokensAsync(validAfter, cancellationToken); + //exception list + List<Exception>? errors = null; + //Remove all sessions from the store + foreach (ActiveToken token in revoked) + { + try + { + //Remove tokens by thier object id from cache + await base.Client.DeleteObjectAsync(token.Id, cancellationToken); + } + //Ignore if the object has already been removed + catch (ObjectNotFoundException) + {} + catch (Exception ex) + { + errors ??= new(); + errors.Add(ex); + } + } + if (errors?.Count > 0) + { + throw new AggregateException(errors); + } + if(revoked.Count > 0) + { + log.Debug("Cleaned up {0} expired tokens", revoked.Count); + } + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2TokenResult.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2TokenResult.cs new file mode 100644 index 0000000..1bff743 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OAuth2TokenResult.cs @@ -0,0 +1,13 @@ +using VNLib.Plugins.Essentials.Oauth; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + internal class OAuth2TokenResult : IOAuth2TokenResult + { + public string? IdentityToken { get; } + public string? AccessToken { get; set; } + public string? RefreshToken { get; set; } + public string? TokenType { get; set; } + public int ExpiresSeconds { get; set; } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OauthTokenResponseMessage.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OauthTokenResponseMessage.cs new file mode 100644 index 0000000..c80891e --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/OauthTokenResponseMessage.cs @@ -0,0 +1,20 @@ +using System.Text.Json.Serialization; + +#nullable enable + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + public sealed class OauthTokenResponseMessage + { + [JsonPropertyName("access_token")] + public string? AccessToken { get; set; } + [JsonPropertyName("refresh_token")] + public string? RefreshToken { get; set; } + [JsonPropertyName("token_type")] + public string? TokenType { get; set; } + [JsonPropertyName("expires_in")] + public int Expires { get; set; } + [JsonPropertyName("id_token")] + public string? IdToken { get; set; } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/TokenAndSessionIdResult.cs b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/TokenAndSessionIdResult.cs new file mode 100644 index 0000000..f8d381f --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/TokenAndSessionIdResult.cs @@ -0,0 +1,20 @@ +#nullable enable + +using VNLib; + +namespace VNLib.Plugins.Essentials.Sessions.OAuth +{ + public readonly struct TokenAndSessionIdResult + { + public readonly string SessionId; + public readonly string AccessToken; + public readonly string? RefreshToken; + + public TokenAndSessionIdResult(string sessionId, string token, string? refreshToken) + { + SessionId = sessionId; + AccessToken = token; + RefreshToken = refreshToken; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/VNLib.Plugins.Essentials.Sessions.OAuth.csproj b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/VNLib.Plugins.Essentials.Sessions.OAuth.csproj new file mode 100644 index 0000000..cba7822 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.OAuth/VNLib.Plugins.Essentials.Sessions.OAuth.csproj @@ -0,0 +1,28 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <PlatformTarget>x64</PlatformTarget> + <GenerateDocumentationFile>False</GenerateDocumentationFile> + <Authors>Vaughn Nugent</Authors> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + + <EnableDynamicLoading>true</EnableDynamicLoading> + + </PropertyGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Loading.Sql\VNLib.Plugins.Extensions.Loading.Sql.csproj" /> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Validation\VNLib.Plugins.Extensions.Validation.csproj" /> + <ProjectReference Include="..\..\..\Oauth Plugins\VNLib.Plugins.Essentials.Oauth\VNLib.Plugins.Essentials.Oauth.csproj" /> + <ProjectReference Include="..\..\Libs\VNLib.Plugins.Sessions.Cache.Client\VNLib.Plugins.Sessions.Cache.Client.csproj" /> + <ProjectReference Include="..\VNLib.Plugins.Essentials.Sessions.Runtime\VNLib.Plugins.Essentials.Sessions.Runtime.csproj" /> + </ItemGroup> + + <Target Name="PostBuild" AfterTargets="PostBuildEvent"> + <Exec Command="start xcopy "$(TargetDir)" "F:\Programming\Web Plugins\DevPlugins\SessionProviders\$(TargetName)" /E /Y /R" /> + </Target> + +</Project> diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/IRuntimeSessionProvider.cs b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/IRuntimeSessionProvider.cs new file mode 100644 index 0000000..9941e6a --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/IRuntimeSessionProvider.cs @@ -0,0 +1,26 @@ + +using VNLib.Net.Http; +using VNLib.Utils.Logging; + +namespace VNLib.Plugins.Essentials.Sessions +{ + /// <summary> + /// Represents a dynamically loadable type that an provide sessions to http connections + /// </summary> + public interface IRuntimeSessionProvider : ISessionProvider + { + /// <summary> + /// Called immediatly after the plugin is loaded into the appdomain + /// </summary> + /// <param name="plugin">The plugin instance that is loading the module</param> + /// <param name="localizedLog">The localized log provider for the provider</param> + void Load(PluginBase plugin, ILogProvider localizedLog); + + /// <summary> + /// Determines if the provider can return a session for the connection + /// </summary> + /// <param name="entity">The entity to process</param> + /// <returns>A value indicating if this provider should be called to load a session for</returns> + bool CanProcess(IHttpEvent entity); + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/ISessionIdFactory.cs b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/ISessionIdFactory.cs new file mode 100644 index 0000000..1e88e5c --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/ISessionIdFactory.cs @@ -0,0 +1,17 @@ +using System.Diagnostics.CodeAnalysis; + +using VNLib.Net.Http; + +namespace VNLib.Plugins.Essentials.Sessions +{ + public interface ISessionIdFactory + { + /// <summary> + /// Attempts to recover a session-id from the connection + /// </summary> + /// <param name="entity">The connection to process</param> + /// <param name="sessionId"></param> + /// <returns></returns> + bool TryGetSessionId(IHttpEvent entity, [NotNullWhen(true)] out string? sessionId); + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VNLib.Plugins.Essentials.Sessions.Runtime.csproj b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VNLib.Plugins.Essentials.Sessions.Runtime.csproj new file mode 100644 index 0000000..5924b93 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VNLib.Plugins.Essentials.Sessions.Runtime.csproj @@ -0,0 +1,40 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <Platforms>AnyCPU;x64</Platforms> + <Authors>Vaughn Nugent</Authors> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <Version>1.0.0.1</Version> + <PlatformTarget>x64</PlatformTarget> + <SignAssembly>False</SignAssembly> + <PackageProjectUrl>www.vaughnnugent.com/resources</PackageProjectUrl> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"> + <Deterministic>True</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <Deterministic>True</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Essentials\VNLib.Plugins.Essentials.csproj" /> + <ProjectReference Include="..\..\..\..\VNLib\Http\VNLib.Net.Http.csproj" /> + <ProjectReference Include="..\..\..\DataCaching\VNLib.Data.Caching.Extensions\VNLib.Data.Caching.Extensions.csproj" /> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Loading\VNLib.Plugins.Extensions.Loading.csproj" /> + <ProjectReference Include="..\..\..\PluginBase\VNLib.Plugins.PluginBase.csproj" /> + </ItemGroup> + +</Project> diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VnCacheClient.cs b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VnCacheClient.cs new file mode 100644 index 0000000..a6979ef --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.Runtime/VnCacheClient.cs @@ -0,0 +1,162 @@ +using System; +using System.Text.Json; +using System.Net.Sockets; +using System.Net.WebSockets; +using System.Security.Cryptography; + +using VNLib.Utils; +using VNLib.Utils.Memory; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Data.Caching.Extensions; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Extensions.Loading; + +namespace VNLib.Plugins.Essentials.Sessions +{ + /// <summary> + /// A wrapper to simplify a cache client object + /// </summary> + public sealed class VnCacheClient : OpenResourceHandle<FBMClient?> + { + FBMClient? _client; + + /// <summary> + /// The wrapped client + /// </summary> + public override FBMClient? Resource => _client; + + + private TimeSpan RetryInterval; + + private readonly ILogProvider? DebugLog; + private readonly IUnmangedHeap? ClientHeap; + + /// <summary> + /// Initializes an emtpy client wrapper that still requires + /// configuration loading + /// </summary> + /// <param name="debugLog">An optional debugging log</param> + /// <param name="heap">An optional <see cref="IUnmangedHeap"/> for <see cref="FBMClient"/> buffers</param> + public VnCacheClient(ILogProvider? debugLog, IUnmangedHeap? heap = null) + { + DebugLog = debugLog; + //Default to 10 seconds + RetryInterval = TimeSpan.FromSeconds(10); + + ClientHeap = heap; + } + + protected override void Free() + { + _client?.Dispose(); + _client = null; + } + + /// <summary> + /// Loads required configuration variables from the config store and + /// intializes the interal client + /// </summary> + /// <param name="config">A dictionary of configuration varables</param> + /// <exception cref="KeyNotFoundException"></exception> + public async Task LoadConfigAsync(PluginBase pbase, IReadOnlyDictionary<string, JsonElement> config) + { + int maxMessageSize = config["max_message_size"].GetInt32(); + string? brokerAddress = config["broker_address"].GetString() ?? throw new KeyNotFoundException("Missing required configuration variable broker_address"); + + //Get keys async + Task<string?> clientPrivTask = pbase.TryGetSecretAsync("client_private_key"); + Task<string?> brokerPubTask = pbase.TryGetSecretAsync("broker_public_key"); + + //Wait for all tasks to complete + string?[] keys = await Task.WhenAll(clientPrivTask, brokerPubTask); + + byte[] privKey = Convert.FromBase64String(keys[0] ?? throw new KeyNotFoundException("Missing required secret client_private_key")); + byte[] brokerPub = Convert.FromBase64String(keys[1] ?? throw new KeyNotFoundException("Missing required secret broker_public_key")); + + RetryInterval = config["retry_interval_sec"].GetTimeSpan(TimeParseType.Seconds); + + Uri brokerUri = new(brokerAddress); + + //Init the client with default settings + FBMClientConfig conf = FBMDataCacheExtensions.GetDefaultConfig(ClientHeap ?? Memory.Shared, maxMessageSize, DebugLog); + + _client = new(conf); + //Add the configuration + _client.UseBroker(brokerUri) + .ImportBrokerPublicKey(brokerPub) + .ImportClientPrivateKey(privKey) + .UseTls(brokerUri.Scheme == Uri.UriSchemeHttps); + + //Zero the key memory + Memory.InitializeBlock(privKey.AsSpan()); + Memory.InitializeBlock(brokerPub.AsSpan()); + } + + /// <summary> + /// Discovers nodes in the configured cluster and connects to a random node + /// </summary> + /// <param name="Log">A <see cref="ILogProvider"/> to write log events to</param> + /// <param name="cancellationToken">A token to cancel the operation</param> + /// <returns>A task that completes when the operation has been cancelled or an unrecoverable error occured</returns> + /// <exception cref="InvalidOperationException"></exception> + /// <exception cref="OperationCanceledException"></exception> + public async Task RunAsync(ILogProvider Log, CancellationToken cancellationToken) + { + _ = Resource ?? throw new InvalidOperationException("Client configuration not loaded, cannot connect to cache servers"); + + while (true) + { + //Load the server list + ActiveServer[]? servers; + while (true) + { + try + { + Log.Debug("Discovering cluster nodes in broker"); + //Get server list + servers = await Resource.DiscoverNodesAsync(cancellationToken); + break; + } + catch (HttpRequestException re) when (re.InnerException is SocketException) + { + Log.Warn("Broker server is unreachable"); + } + catch (Exception ex) + { + Log.Warn("Failed to get server list from broker, reason {r}", ex.Message); + } + //Gen random ms delay + int randomMsDelay = RandomNumberGenerator.GetInt32(1000, 2000); + await Task.Delay(randomMsDelay, cancellationToken); + } + if (servers?.Length == 0) + { + Log.Warn("No cluster nodes found, retrying"); + await Task.Delay(RetryInterval, cancellationToken); + continue; + } + //select random server from the list of servers + ActiveServer selected = servers!.SelectRandom(); + try + { + Log.Debug("Connecting to server {server}", selected.ServerId); + //Try to connect to server + await Resource.ConnectAndWaitForExitAsync(selected, cancellationToken); + Log.Debug("Cache server disconnected"); + } + catch (WebSocketException wse) + { + Log.Warn("Failed to connect to cache server {reason}", wse.Message); + continue; + } + catch (HttpRequestException he) when (he.InnerException is SocketException) + { + Log.Debug("Failed to connect to recommended server {server}", selected.ServerId); + //Continue next loop + continue; + } + } + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/IWebSessionIdFactory.cs b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/IWebSessionIdFactory.cs new file mode 100644 index 0000000..81f44b8 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/IWebSessionIdFactory.cs @@ -0,0 +1,26 @@ + +using VNLib.Net.Http; + +namespace VNLib.Plugins.Essentials.Sessions.VNCache +{ + /// <summary> + /// Id factory for <see cref="WebSessionProvider"/> + /// </summary> + internal interface IWebSessionIdFactory: ISessionIdFactory + { + /// <summary> + /// The maxium amount of time a session is valid for. Sessions will be invalidated + /// after this time + /// </summary> + TimeSpan ValidFor { get; } + + /// <summary> + /// Gets a new session-id for the connection and manipulates the entity as necessary + /// </summary> + /// <param name="entity">The connection to generate the new session for</param> + /// <returns>The new session-id</returns> + string GenerateSessionId(IHttpEvent entity); + } + + +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/VNLib.Plugins.Essentials.Sessions.VNCache.csproj b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/VNLib.Plugins.Essentials.Sessions.VNCache.csproj new file mode 100644 index 0000000..ecb80b1 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/VNLib.Plugins.Essentials.Sessions.VNCache.csproj @@ -0,0 +1,47 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <Platforms>AnyCPU;x64</Platforms> + <Authors>Vaughn Nugent</Authors> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <Version>1.0.0.1</Version> + <PlatformTarget>x64</PlatformTarget> + <SignAssembly>False</SignAssembly> + <PackageProjectUrl>www.vaughnnugent.com/resources</PackageProjectUrl> + + <EnableDynamicLoading>true</EnableDynamicLoading> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"> + <Deterministic>True</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <Deterministic>True</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + + <ItemGroup> + <ProjectReference Include="..\VNLib.Plugins.Essentials.Sessions.Runtime\VNLib.Plugins.Essentials.Sessions.Runtime.csproj" /> + <ProjectReference Include="..\VNLib.Plugins.Sessions.Cache.Client\VNLib.Plugins.Sessions.Cache.Client.csproj" /> + </ItemGroup> + + <ItemGroup> + <Folder Include="Endpoints\" /> + </ItemGroup> + + <Target Name="PostBuild" AfterTargets="PostBuildEvent"> + <Exec Command="start xcopy "$(TargetDir)" "F:\Programming\Web Plugins\DevPlugins\SessionProviders\$(TargetName)" /E /Y /R" /> + </Target> + +</Project> diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSession.cs b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSession.cs new file mode 100644 index 0000000..a7a6f5e --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSession.cs @@ -0,0 +1,103 @@ +using VNLib.Net.Http; +using VNLib.Data.Caching; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Essentials.Extensions; +using VNLib.Plugins.Sessions.Cache.Client; +using static VNLib.Plugins.Essentials.Sessions.ISessionExtensions; + + +namespace VNLib.Plugins.Essentials.Sessions.VNCache +{ + internal class WebSession : RemoteSession + { + protected const ulong UPGRADE_MSK = 0b0000000000010000UL; + + protected readonly Func<IHttpEvent, string, string> UpdateId; + private string? _oldId; + + public WebSession(string sessionId, FBMClient client, TimeSpan backgroundTimeOut, Func<IHttpEvent, string, string> UpdateId) + : base(sessionId, client, backgroundTimeOut) + { + this.UpdateId = UpdateId; + } + + protected override void IndexerSet(string key, string value) + { + //Set value + base.IndexerSet(key, value); + switch (key) + { + //Set the upgrade flag when token data is modified + case LOGIN_TOKEN_ENTRY: + case TOKEN_ENTRY: + Flags.Set(UPGRADE_MSK); + break; + } + } + + public override async Task WaitAndLoadAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + //Wait for the session to load + await base.WaitAndLoadAsync(entity, cancellationToken); + //If the session is new, set to web mode + if (IsNew) + { + SessionType = SessionType.Web; + } + } + + private async Task ProcessUpgradeAsync() + { + //Setup timeout cancellation for the update, to cancel it + using CancellationTokenSource cts = new(UpdateTimeout); + await Client.AddOrUpdateObjectAsync(_oldId!, SessionID, DataStore, cts.Token); + _oldId = null; + } + + protected override ValueTask<Task?> UpdateResource(bool isAsync, IHttpEvent state) + { + Task? result = null; + //Check flags in priority level, Invalid is highest state priority + if (Flags.IsSet(INVALID_MSK)) + { + //Clear all stored values + DataStore!.Clear(); + //Reset ip-address + UserIP = state.Server.GetTrustedIp(); + //Update created time + Created = DateTimeOffset.UtcNow; + //Init the new session-data + this.InitNewSession(state.Server); + //Restore session type + SessionType = SessionType.Web; + //generate new session-id and update the record in the store + _oldId = SessionID; + //Update the session-id + SessionID = UpdateId(state, _oldId); + //write update to server + result = Task.Run(ProcessUpgradeAsync); + } + else if (Flags.IsSet(UPGRADE_MSK | REGEN_ID_MSK)) + { + //generate new session-id and update the record in the store + _oldId = SessionID; + //Update the session-id + SessionID = UpdateId(state, _oldId); + //Update created time + Created = DateTimeOffset.UtcNow; + //write update to server + result = Task.Run(ProcessUpgradeAsync); + } + else if (Flags.IsSet(MODIFIED_MSK)) + { + //Send update to server + result = Task.Run(ProcessUpdateAsync); + } + + //Clear all flags + Flags.ClearAll(); + + return ValueTask.FromResult<Task?>(null); + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionIdFactoryImpl.cs b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionIdFactoryImpl.cs new file mode 100644 index 0000000..001723a --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionIdFactoryImpl.cs @@ -0,0 +1,96 @@ +using System.Diagnostics.CodeAnalysis; + +using VNLib.Hashing; +using VNLib.Net.Http; +using VNLib.Utils.Memory; +using VNLib.Utils.Extensions; +using VNLib.Plugins.Essentials.Extensions; + + +namespace VNLib.Plugins.Essentials.Sessions.VNCache +{ + /// <summary> + /// <see cref="IWebSessionIdFactory"/> implementation, using + /// http cookies as session id storage + /// </summary> + internal sealed class WebSessionIdFactoryImpl : IWebSessionIdFactory + { + public TimeSpan ValidFor { get; } + + public string GenerateSessionId(IHttpEvent entity) + { + //Random hex hash + string cookie = RandomHash.GetRandomBase32(_tokenSize); + + //Set the session id cookie + entity.Server.SetCookie(SessionCookieName, cookie, ValidFor, secure: true, httpOnly: true); + + //return session-id value from cookie value + return ComputeSessionIdFromCookie(cookie); + } + + bool ISessionIdFactory.TryGetSessionId(IHttpEvent entity, [NotNullWhen(true)] out string? sessionId) + { + //Get authorization token and make sure its not too large to cause a buffer overflow + if (entity.Server.GetCookie(SessionCookieName, out string? cookie) && (cookie.Length + SessionIdPrefix.Length) <= _bufferSize) + { + //Compute session id from token + sessionId = ComputeSessionIdFromCookie(cookie); + + return true; + } + //Only add sessions for user-agents + else if(entity.Server.IsBrowser()) + { + //Get a new session id + sessionId = GenerateSessionId(entity); + + return true; + } + else + { + sessionId = null; + return false; + } + } + + private readonly string SessionCookieName; + private readonly string SessionIdPrefix; + private readonly int _bufferSize; + private readonly int _tokenSize; + + /// <summary> + /// Initialzies a new web session Id factory + /// </summary> + /// <param name="cookieSize">The size of the cookie in bytes</param> + /// <param name="sessionCookieName">The name of the session cookie</param> + /// <param name="sessionIdPrefix">The session-id internal prefix</param> + /// <param name="validFor">The time the session cookie is valid for</param> + public WebSessionIdFactoryImpl(uint cookieSize, string sessionCookieName, string sessionIdPrefix, TimeSpan validFor) + { + ValidFor = validFor; + SessionCookieName = sessionCookieName; + SessionIdPrefix = sessionIdPrefix; + _tokenSize = (int)cookieSize; + //Calc buffer size + _bufferSize = Math.Max(32, ((int)cookieSize * 3) + sessionIdPrefix.Length); + } + + + private string ComputeSessionIdFromCookie(string sessionId) + { + //Buffer to copy data to + using UnsafeMemoryHandle<char> buffer = Memory.UnsafeAlloc<char>(_bufferSize, true); + + //Writer to accumulate data + ForwardOnlyWriter<char> writer = new(buffer.Span); + + //Append prefix and session id + writer.Append(SessionIdPrefix); + writer.Append(sessionId); + + //Compute base64 hash of token and + return ManagedHash.ComputeBase64Hash(writer.AsSpan(), HashAlg.SHA256); + } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProvider.cs b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProvider.cs new file mode 100644 index 0000000..fd725bf --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProvider.cs @@ -0,0 +1,122 @@ +using System; + +using VNLib.Net.Http; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Sessions.Cache.Client; + +namespace VNLib.Plugins.Essentials.Sessions.VNCache +{ + /// <summary> + /// The implementation of a VNCache web based session + /// </summary> + internal sealed class WebSessionProvider : SessionCacheClient, ISessionProvider + { + static readonly TimeSpan BackgroundUpdateTimeout = TimeSpan.FromSeconds(10); + + private readonly IWebSessionIdFactory factory; + private readonly uint MaxConnections; + + /// <summary> + /// Initializes a new <see cref="WebSessionProvider"/> + /// </summary> + /// <param name="client">The cache client to make cache operations against</param> + /// <param name="maxCacheItems">The max number of items to store in cache</param> + /// <param name="maxWaiting">The maxium number of waiting session events before 503s are sent</param> + /// <param name="factory">The session-id factory</param> + public WebSessionProvider(FBMClient client, int maxCacheItems, uint maxWaiting, IWebSessionIdFactory factory) : base(client, maxCacheItems) + { + this.factory = factory; + MaxConnections = maxWaiting; + } + + private string UpdateSessionId(IHttpEvent entity, string oldId) + { + //Generate and set a new sessionid + string newid = factory.GenerateSessionId(entity); + //Aquire lock on cache + lock (CacheLock) + { + //Change the cache lookup id + if (CacheTable.Remove(oldId, out RemoteSession? session)) + { + CacheTable.Add(newid, session); + } + } + return newid; + } + + protected override RemoteSession SessionCtor(string sessionId) => new WebSession(sessionId, Client, BackgroundUpdateTimeout, UpdateSessionId); + + + private uint _waitingCount; + + public async ValueTask<SessionHandle> GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + //Callback to close the session when the handle is closeed + static ValueTask HandleClosedAsync(ISession session, IHttpEvent entity) + { + return (session as SessionBase)!.UpdateAndRelease(true, entity); + } + + try + { + //Get session id + if (!factory.TryGetSessionId(entity, out string? sessionId)) + { + //Id not allowed/found, so do not attach a session + return SessionHandle.Empty; + } + + //Limit max number of waiting clients + if (_waitingCount > MaxConnections) + { + //Set 503 for temporary unavail + entity.CloseResponse(System.Net.HttpStatusCode.ServiceUnavailable); + return new SessionHandle(null, FileProcessArgs.VirtualSkip, null); + } + + RemoteSession session; + + //Inc waiting count + Interlocked.Increment(ref _waitingCount); + try + { + //Recover the session + session = await GetSessionAsync(entity, sessionId, cancellationToken); + } + finally + { + //Dec on exit + Interlocked.Decrement(ref _waitingCount); + } + + //If the session is new (not in cache), then overwrite the session id with a new one as user may have specified their own + if (session.IsNew) + { + session.RegenID(); + } + + //Make sure the session has not expired yet + if (session.Created.Add(factory.ValidFor) < DateTimeOffset.UtcNow) + { + //Invalidate the session, so its technically valid for this request, but will be cleared on this handle close cycle + session.Invalidate(); + //Clear basic login status + session.Token = null; + session.UserID = null; + session.Privilages = 0; + session.SetLoginToken(null); + } + return new SessionHandle(session, HandleClosedAsync); + } + catch (SessionException) + { + throw; + } + catch (Exception ex) + { + throw new SessionException("Exception raised while retreiving or loading Web session", ex); + } + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProviderEntry.cs b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProviderEntry.cs new file mode 100644 index 0000000..f72d1c5 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions.VNCache/WebSessionProviderEntry.cs @@ -0,0 +1,101 @@ +using System.Text.Json; + +using VNLib.Net.Http; +using VNLib.Utils.Memory; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Extensions.Loading.Configuration; + +namespace VNLib.Plugins.Essentials.Sessions.VNCache +{ + public sealed class WebSessionProviderEntry : IRuntimeSessionProvider + { + const string VNCACHE_CONFIG_KEY = "vncache"; + const string WEB_SESSION_CONFIG = "web"; + + private WebSessionProvider? _sessions; + + public bool CanProcess(IHttpEvent entity) + { + //Web sessions can always be provided so long as cache is loaded + return _sessions != null; + } + + public ValueTask<SessionHandle> GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + return _sessions!.GetSessionAsync(entity, cancellationToken); + } + + void IRuntimeSessionProvider.Load(PluginBase plugin, ILogProvider localized) + { + //Try get vncache config element + IReadOnlyDictionary<string, JsonElement> cacheConfig = plugin.GetConfig(VNCACHE_CONFIG_KEY); + + IReadOnlyDictionary<string, JsonElement> webSessionConfig = plugin.GetConfig(WEB_SESSION_CONFIG); + + uint cookieSize = webSessionConfig["cookie_size"].GetUInt32(); + string cookieName = webSessionConfig["cookie_name"].GetString() ?? throw new KeyNotFoundException($"Missing required element 'cookie_name' for config '{WEB_SESSION_CONFIG}'"); + string cachePrefix = webSessionConfig["cache_prefix"].GetString() ?? throw new KeyNotFoundException($"Missing required element 'cache_prefix' for config '{WEB_SESSION_CONFIG}'"); + TimeSpan validFor = webSessionConfig["valid_for_sec"].GetTimeSpan(TimeParseType.Seconds); + + + //Init id factory + WebSessionIdFactoryImpl idFactory = new(cookieSize, cookieName, cachePrefix, validFor); + + //Run client connection + _ = WokerDoWorkAsync(plugin, localized, idFactory, cacheConfig, webSessionConfig); + } + + + /* + * Starts and monitors the VNCache connection + */ + + private async Task WokerDoWorkAsync( + PluginBase plugin, + ILogProvider localized, + WebSessionIdFactoryImpl idFactory, + IReadOnlyDictionary<string, JsonElement> cacheConfig, + IReadOnlyDictionary<string, JsonElement> webSessionConfig) + { + //Init cache client + using VnCacheClient cache = new(plugin.IsDebug() ? plugin.Log : null, Memory.Shared); + + try + { + int cacheLimit = (int)webSessionConfig["cache_size"].GetUInt32(); + uint maxConnections = webSessionConfig["max_waiting_connections"].GetUInt32(); + + //Try loading config + await cache.LoadConfigAsync(plugin, cacheConfig); + + //Init provider + _sessions = new(cache.Resource!, cacheLimit, maxConnections, idFactory); + + + localized.Information("Session provider loaded"); + + //Run and wait for exit + await cache.RunAsync(localized, plugin.UnloadToken); + + } + catch (OperationCanceledException) + { } + catch (KeyNotFoundException e) + { + localized.Error("Missing required configuration variable for VnCache client: {0}", e.Message); + } + catch (Exception ex) + { + localized.Error(ex, "Cache client error occured in session provider"); + } + finally + { + _sessions = null; + } + + localized.Information("Cache client exited"); + } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/MemorySession.cs b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySession.cs new file mode 100644 index 0000000..35e2fea --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySession.cs @@ -0,0 +1,107 @@ +using System; +using System.Net; +using System.Threading.Tasks; +using System.Collections.Generic; + +using VNLib.Net.Http; +using VNLib.Plugins.Essentials.Extensions; + +using static VNLib.Plugins.Essentials.Sessions.ISessionExtensions; + +#nullable enable + +namespace VNLib.Plugins.Essentials.Sessions.Memory +{ + internal class MemorySession : SessionBase + { + private readonly Dictionary<string, string> DataStorage; + + private readonly MemorySessionStore SessionStore; + + public MemorySession(IPAddress ipAddress, MemorySessionStore SessionStore) + { + //Set the initial is-new flag + DataStorage = new Dictionary<string, string>(10); + this.SessionStore = SessionStore; + //Get new session id + SessionID = SessionStore.NewSessionID; + UserIP = ipAddress; + SessionType = SessionType.Web; + Created = DateTimeOffset.UtcNow; + //Init + IsNew = true; + } + //Store in memory directly + public override IPAddress UserIP { get; protected set; } + + //Session type has no backing store, so safe to hard-code it's always web + + public override SessionType SessionType => SessionType.Web; + + protected override ValueTask<Task?> UpdateResource(bool isAsync, IHttpEvent state) + { + //if invalid is set, invalide the current session + if (Flags.IsSet(INVALID_MSK)) + { + //Clear storage, and regenerate the sessionid + DataStorage.Clear(); + RegenId(state); + //Reset ip-address + UserIP = state.Server.GetTrustedIp(); + //Update created-time + Created = DateTimeOffset.UtcNow; + //Re-initialize the session to the state of the current connection + this.InitNewSession(state.Server); + //Modified flag doesnt matter since there is no write-back + + } + else if (Flags.IsSet(REGEN_ID_MSK)) + { + //Regen id without modifying the data store + RegenId(state); + } + //Clear flags + Flags.ClearAll(); + //Memory session always completes + return ValueTask.FromResult<Task?>(null); + } + + private void RegenId(IHttpEvent entity) + { + //Get a new session-id + string newId = SessionStore.NewSessionID; + //Update the cache entry + SessionStore.UpdateRecord(newId, this); + //store new sessionid + SessionID = newId; + //set cookie + SessionStore.SetSessionCookie(entity, this); + } + + protected override Task OnEvictedAsync() + { + //Clear all session data + DataStorage.Clear(); + return Task.CompletedTask; + } + + protected override string IndexerGet(string key) + { + return DataStorage.GetValueOrDefault(key, string.Empty); + } + + protected override void IndexerSet(string key, string value) + { + //Check for special keys + switch (key) + { + //For tokens/login hashes, we can set the upgrade flag + case TOKEN_ENTRY: + case LOGIN_TOKEN_ENTRY: + Flags.Set(REGEN_ID_MSK); + break; + } + DataStorage[key] = value; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionConfig.cs b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionConfig.cs new file mode 100644 index 0000000..cbbaf53 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionConfig.cs @@ -0,0 +1,33 @@ +using System; +using VNLib.Utils.Logging; + +namespace VNLib.Net.Sessions +{ + /// <summary> + /// Represents configration variables used to create and operate http sessions. + /// </summary> + public readonly struct MemorySessionConfig + { + /// <summary> + /// The name of the cookie to use for matching sessions + /// </summary> + public string SessionCookieID { get; init; } + /// <summary> + /// The size (in bytes) of the genreated SessionIds + /// </summary> + public uint SessionIdSizeBytes { get; init; } + /// <summary> + /// The amount of time a session is valid (within the backing store) + /// </summary> + public TimeSpan SessionTimeout { get; init; } + /// <summary> + /// The log for which all errors within the <see cref="SessionProvider"/> instance will be written to. + /// </summary> + public ILogProvider SessionLog { get; init; } + /// <summary> + /// The maximum number of sessions allowed to be cached in memory. If this value is exceed requests to this + /// server will be denied with a 503 error code + /// </summary> + public int MaxAllowedSessions { get; init; } + } +}
\ No newline at end of file diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionEntrypoint.cs b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionEntrypoint.cs new file mode 100644 index 0000000..f41d384 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionEntrypoint.cs @@ -0,0 +1,64 @@ +using System; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; + + +using VNLib.Net.Http; +using VNLib.Net.Sessions; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Plugins.Extensions.Loading.Configuration; +using VNLib.Plugins.Extensions.Loading.Events; + +#nullable enable + +namespace VNLib.Plugins.Essentials.Sessions.Memory +{ + public sealed class MemorySessionEntrypoint : IRuntimeSessionProvider, IIntervalScheduleable + { + const string WEB_SESSION_CONFIG = "web"; + + private MemorySessionStore? _sessions; + + bool IRuntimeSessionProvider.CanProcess(IHttpEvent entity) + { + //Web sessions can always be provided + return _sessions != null; + } + + public ValueTask<SessionHandle> GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + return _sessions!.GetSessionAsync(entity, cancellationToken); + } + + void IRuntimeSessionProvider.Load(PluginBase plugin, ILogProvider localized) + { + //Get websessions config element + + IReadOnlyDictionary<string, JsonElement> webSessionConfig = plugin.GetConfig(WEB_SESSION_CONFIG); + + MemorySessionConfig config = new() + { + SessionLog = localized, + MaxAllowedSessions = webSessionConfig["cache_size"].GetInt32(), + SessionIdSizeBytes = webSessionConfig["cookie_size"].GetUInt32(), + SessionTimeout = webSessionConfig["valid_for_sec"].GetTimeSpan(TimeParseType.Seconds), + SessionCookieID = webSessionConfig["cookie_name"].GetString() ?? throw new KeyNotFoundException($"Missing required element 'cookie_name' for config '{WEB_SESSION_CONFIG}'"), + }; + + _sessions = new(config); + + //Schedule garbage collector + _ = plugin.ScheduleInterval(this, TimeSpan.FromMinutes(1)); + } + + Task IIntervalScheduleable.OnIntervalAsync(ILogProvider log, CancellationToken cancellationToken) + { + //Cleanup expired sessions on interval + _sessions?.GC(); + return Task.CompletedTask; + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionStore.cs b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionStore.cs new file mode 100644 index 0000000..15c3002 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/MemorySessionStore.cs @@ -0,0 +1,127 @@ +using System; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; + +using VNLib.Hashing; +using VNLib.Net.Http; +using VNLib.Net.Sessions; +using VNLib.Utils; +using VNLib.Utils.Async; +using VNLib.Utils.Extensions; +using VNLib.Plugins.Essentials.Extensions; + + +namespace VNLib.Plugins.Essentials.Sessions.Memory +{ + + /// <summary> + /// An <see cref="ISessionProvider"/> for in-process-memory backed sessions + /// </summary> + internal sealed class MemorySessionStore : ISessionProvider + { + private readonly Dictionary<string, MemorySession> SessionsStore; + + internal readonly MemorySessionConfig Config; + + public MemorySessionStore(MemorySessionConfig config) + { + Config = config; + SessionsStore = new(config.MaxAllowedSessions, StringComparer.Ordinal); + } + + ///<inheritdoc/> + public async ValueTask<SessionHandle> GetSessionAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + + static ValueTask SessionHandleClosedAsync(ISession session, IHttpEvent ev) + { + return (session as MemorySession).UpdateAndRelease(true, ev); + } + + //Check for previous session cookie + if (entity.Server.RequestCookies.TryGetNonEmptyValue(Config.SessionCookieID, out string sessionId)) + { + //Try to get the old record or evict it + ERRNO result = SessionsStore.TryGetOrEvictRecord(sessionId, out MemorySession session); + if(result > 0) + { + //Valid, now wait for exclusive access + await session.WaitOneAsync(cancellationToken); + return new (session, SessionHandleClosedAsync); + } + //Continue creating a new session + } + + //Dont service non browsers for new sessions + if (!entity.Server.IsBrowser()) + { + return SessionHandle.Empty; + } + + //try to cleanup expired records + SessionsStore.CollectRecords(); + //Make sure there is enough room to add a new session + if (SessionsStore.Count >= Config.MaxAllowedSessions) + { + entity.Server.SetNoCache(); + //Set 503 when full + entity.CloseResponse(System.Net.HttpStatusCode.ServiceUnavailable); + //Cannot service new session + return new(null, FileProcessArgs.VirtualSkip, null); + } + //Initialze a new session + MemorySession ms = new(entity.Server.GetTrustedIp(), this); + //Set session cookie + SetSessionCookie(entity, ms); + //Increment the semaphore + (ms as IWaitHandle).WaitOne(); + //store the session in cache while holding semaphore, and set its expiration + SessionsStore.StoreRecord(ms.SessionID, ms, Config.SessionTimeout); + //Init new session handle + return new SessionHandle(ms, SessionHandleClosedAsync); + } + + /// <summary> + /// Gets a new unique sessionid for sessions + /// </summary> + internal string NewSessionID => RandomHash.GetRandomHex((int)Config.SessionIdSizeBytes); + + internal void UpdateRecord(string newSessId, MemorySession session) + { + lock (SessionsStore) + { + //Remove old record from the store + SessionsStore.Remove(session.SessionID); + //Insert the new session + SessionsStore.Add(newSessId, session); + } + } + /// <summary> + /// Sets a standard session cookie for an entity/connection + /// </summary> + /// <param name="entity">The entity to set the cookie on</param> + /// <param name="session">The session attached to the </param> + internal void SetSessionCookie(IHttpEvent entity, MemorySession session) + { + //Set session cookie + entity.Server.SetCookie(Config.SessionCookieID, session.SessionID, null, "/", Config.SessionTimeout, CookieSameSite.Lax, true, true); + } + /// <summary> + /// Evicts all sessions from the current store + /// </summary> + public void Cleanup() + { + //Expire all old records to cleanup all entires + this.SessionsStore.CollectRecords(DateTime.MaxValue); + } + /// <summary> + /// Collects all expired records from the current store + /// </summary> + public void GC() + { + //collect expired records + this.SessionsStore.CollectRecords(); + } + } +} diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.csproj b/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.csproj new file mode 100644 index 0000000..0d21b31 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.csproj @@ -0,0 +1,43 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <Platforms>AnyCPU;x64</Platforms> + + <EnableDynamicLoading>true</EnableDynamicLoading> + </PropertyGroup> + + <!-- Resolve nuget dll files and store them in the output dir --> + <PropertyGroup> + <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> + <AssemblyName>VNLib.Plugins.Essentials.Sessions.Memory</AssemblyName> + <RootNamespace>VNLib.Plugins.Essentials.Sessions.Memory</RootNamespace> + <Authors>Vaughn Nugent</Authors> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <PackageProjectUrl>www.vaughnnugent.com/resources</PackageProjectUrl> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <DocumentationFile></DocumentationFile> + </PropertyGroup> + <ProjectExtensions><VisualStudio><UserProperties /></VisualStudio></ProjectExtensions> + <ItemGroup> + <PackageReference Include="ErrorProne.NET.CoreAnalyzers" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="ErrorProne.NET.Structs" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Essentials\VNLib.Plugins.Essentials.csproj" /> + <ProjectReference Include="..\..\..\..\VNLib\Http\VNLib.Net.Http.csproj" /> + <ProjectReference Include="..\VNLib.Plugins.Essentials.Sessions.Runtime\VNLib.Plugins.Essentials.Sessions.Runtime.csproj" /> + </ItemGroup> + <Target Name="PostBuild" AfterTargets="PostBuildEvent"> + <Exec Command="start xcopy "$(TargetDir)" "F:\Programming\Web Plugins\DevPlugins\SessionProviders\$(TargetName)" /E /Y /R" /> + </Target> + + +</Project> diff --git a/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.xml b/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.xml new file mode 100644 index 0000000..9c596c3 --- /dev/null +++ b/Libs/VNLib.Plugins.Essentials.Sessions/VNLib.Plugins.Essentials.Sessions.Memory.xml @@ -0,0 +1,75 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Essentials.Sessions.Memory</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore"> + <summary> + An <see cref="T:VNLib.Plugins.Essentials.Sessions.ISessionProvider"/> for in-process-memory backed sessions + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore.GetSessionAsync(VNLib.Net.Http.HttpEvent,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore.NewSessionID"> + <summary> + Gets a new unique sessionid for sessions + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore.SetSessionCookie(VNLib.Net.Http.HttpEvent,VNLib.Plugins.Essentials.Sessions.Memory.MemorySession)"> + <summary> + Sets a standard session cookie for an entity/connection + </summary> + <param name="entity">The entity to set the cookie on</param> + <param name="session">The session attached to the </param> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore.Cleanup"> + <summary> + Evicts all sessions from the current store + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Memory.MemorySessionStore.GC"> + <summary> + Collects all expired records from the current store + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.Memory.MemSessionHandle"> + <summary> + Provides a one-time-use handle (similar to asyncReleaser, or openHandle) + that holds exclusive access to a session until it is released + </summary> + </member> + <member name="T:VNLib.Net.Sessions.MemorySessionConfig"> + <summary> + Represents configration variables used to create and operate http sessions. + </summary> + </member> + <member name="P:VNLib.Net.Sessions.MemorySessionConfig.SessionCookieID"> + <summary> + The name of the cookie to use for matching sessions + </summary> + </member> + <member name="P:VNLib.Net.Sessions.MemorySessionConfig.SessionIdSizeBytes"> + <summary> + The size (in bytes) of the genreated SessionIds + </summary> + </member> + <member name="P:VNLib.Net.Sessions.MemorySessionConfig.SessionTimeout"> + <summary> + The amount of time a session is valid (within the backing store) + </summary> + </member> + <member name="P:VNLib.Net.Sessions.MemorySessionConfig.SessionLog"> + <summary> + The log for which all errors within the <see cref="!:SessionProvider"/> instance will be written to. + </summary> + </member> + <member name="P:VNLib.Net.Sessions.MemorySessionConfig.MaxAllowedSessions"> + <summary> + The maximum number of sessions allowed to be cached in memory. If this value is exceed requests to this + server will be denied with a 503 error code + </summary> + </member> + </members> +</doc> diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/MessageTooLargeException.cs b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/MessageTooLargeException.cs new file mode 100644 index 0000000..15164ca --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/MessageTooLargeException.cs @@ -0,0 +1,27 @@ +using System; +using System.Runtime.Serialization; + +using VNLib.Net.Messaging.FBM; + +namespace VNLib.Plugins.Sessions.Cache.Client +{ + /// <summary> + /// Raised when a request message is too large to send to + /// the server and the server may close the connection. + /// </summary> + public class MessageTooLargeException : FBMException + { + ///<inheritdoc/> + public MessageTooLargeException() + {} + ///<inheritdoc/> + public MessageTooLargeException(string message) : base(message) + {} + ///<inheritdoc/> + public MessageTooLargeException(string message, Exception innerException) : base(message, innerException) + {} + ///<inheritdoc/> + protected MessageTooLargeException(SerializationInfo info, StreamingContext context) : base(info, context) + {} + } +} diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionStatusException.cs b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionStatusException.cs new file mode 100644 index 0000000..5bb6f42 --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionStatusException.cs @@ -0,0 +1,19 @@ +using System; +using System.Runtime.Serialization; + +using VNLib.Plugins.Essentials.Sessions; + +namespace VNLib.Plugins.Sessions.Cache.Client +{ + public class SessionStatusException : SessionException + { + public SessionStatusException() + {} + public SessionStatusException(string message) : base(message) + {} + public SessionStatusException(string message, Exception innerException) : base(message, innerException) + {} + protected SessionStatusException(SerializationInfo info, StreamingContext context) : base(info, context) + {} + } +} diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionUpdateFailedException.cs b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionUpdateFailedException.cs new file mode 100644 index 0000000..1b842b7 --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/Exceptions/SessionUpdateFailedException.cs @@ -0,0 +1,17 @@ +using System; +using System.Runtime.Serialization; + +namespace VNLib.Plugins.Sessions.Cache.Client +{ + public class SessionUpdateFailedException : SessionStatusException + { + public SessionUpdateFailedException() + {} + public SessionUpdateFailedException(string message) : base(message) + {} + public SessionUpdateFailedException(string message, Exception innerException) : base(message, innerException) + {} + protected SessionUpdateFailedException(SerializationInfo info, StreamingContext context) : base(info, context) + {} + } +} diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/RemoteSession.cs b/Libs/VNLib.Plugins.Sessions.Cache.Client/RemoteSession.cs new file mode 100644 index 0000000..2ab27f5 --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/RemoteSession.cs @@ -0,0 +1,173 @@ +using System; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; + +using Microsoft.VisualStudio.Threading; + +using VNLib.Net.Http; +using VNLib.Data.Caching; +using VNLib.Data.Caching.Exceptions; +using VNLib.Utils.Extensions; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Essentials.Sessions; +using VNLib.Plugins.Essentials.Extensions; + +#nullable enable + +namespace VNLib.Plugins.Sessions.Cache.Client +{ + /// <summary> + /// Base class for cacheable lazy initialized session entires + /// that exist in a remote caching server + /// </summary> + public abstract class RemoteSession : SessionBase + { + protected const string CREATED_TIME_ENTRY = "__.i.ctime"; + + protected readonly FBMClient Client; + protected readonly TimeSpan UpdateTimeout; + + private readonly AsyncLazyInitializer Initializer; + + /// <summary> + /// The lazy loaded data-store + /// </summary> + protected Dictionary<string, string>? DataStore; + + public RemoteSession(string sessionId, FBMClient client, TimeSpan backgroundTimeOut) + { + SessionID = sessionId; + UpdateTimeout = backgroundTimeOut; + Client = client; + Initializer = new(InitializeAsync, null); + } + + /// <summary> + /// The data initializer, loads the data store from the connected cache server + /// </summary> + /// <returns>A task that completes when the get operation completes</returns> + protected virtual async Task InitializeAsync() + { + //Setup timeout cancellation for the get, to cancel it + using CancellationTokenSource cts = new(UpdateTimeout); + //get or create a new session + DataStore = await Client.GetObjectAsync<Dictionary<string, string>>(SessionID, cancellationToken: cts.Token); + } + /// <summary> + /// Updates the current sessin agaisnt the cache store + /// </summary> + /// <returns>A task that complets when the update has completed</returns> + protected virtual async Task ProcessUpdateAsync() + { + //Setup timeout cancellation for the update, to cancel it + using CancellationTokenSource cts = new(UpdateTimeout); + await Client.AddOrUpdateObjectAsync(SessionID, null, DataStore, cts.Token); + } + /// <summary> + /// Delets the current session in the remote store + /// </summary> + /// <returns>A task that completes when instance has been deleted</returns> + protected virtual async Task ProcessDeleteAsync() + { + //Setup timeout cancellation for the update, to cancel it + using CancellationTokenSource cts = new(UpdateTimeout); + try + { + await Client.DeleteObjectAsync(SessionID, cts.Token); + } + catch (ObjectNotFoundException) + { + //This is fine, if the object does not exist, nothing to invalidate + } + } + + ///<inheritdoc/> + public override DateTimeOffset Created + { + get + { + //Deserialze the base32 ms + long unixMs = this.GetValueType<string, long>(CREATED_TIME_ENTRY); + //set created time from ms + return DateTimeOffset.FromUnixTimeMilliseconds(unixMs); + } + + protected set => this.SetValueType(CREATED_TIME_ENTRY, value.ToUnixTimeMilliseconds()); + } + ///<inheritdoc/> + protected override string IndexerGet(string key) + { + //Get the value at the key or an empty string as a default + return DataStore!.GetValueOrDefault(key, string.Empty); + } + ///<inheritdoc/> + protected override void IndexerSet(string key, string value) + { + //If the value is null, remove the key from the store + if (value == null) + { + //Set modified flag + IsModified |= DataStore!.Remove(key); + } + else + { + //Store the value at the specified key + DataStore![key] = value; + IsModified = true; + } + } + + + /* + * If the data-store is not found it means the session does not + * exist in cache, so its technically not dangerous to reuse, + * so the new mask needs to be set, but the old ID is going + * to be reused + */ + + /// <summary> + /// Waits for exclusive access to the session, and initializes + /// session data (loads it from the remote store) + /// </summary> + /// <param name="entity">The event to attach a session to</param> + /// <param name="cancellationToken">A token to cancel the operaion</param> + /// <returns></returns> + public virtual async Task WaitAndLoadAsync(IHttpEvent entity, CancellationToken cancellationToken) + { + //Wait for exclusive access + await base.WaitOneAsync(cancellationToken); + try + { + //Lazily initalize the current instance + await Initializer.InitializeAsync(cancellationToken); + //See if data-store is null (new session was created + if (DataStore == null) + { + //New session was created + DataStore = new(10); + //Set is-new flag + Flags.Set(IS_NEW_MSK); + //Set created time + Created = DateTimeOffset.UtcNow; + //Init ipaddress + UserIP = entity.Server.GetTrustedIp(); + //Set modified flag so session will be updated + IsModified = true; + } + } + catch + { + MainLock.Release(); + throw; + } + } + ///<inheritdoc/> + protected override Task OnEvictedAsync() + { + //empty the dict to help the GC + DataStore!.Clear(); + return Task.CompletedTask; + } + } +} diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/SessionCacheClient.cs b/Libs/VNLib.Plugins.Sessions.Cache.Client/SessionCacheClient.cs new file mode 100644 index 0000000..de0e370 --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/SessionCacheClient.cs @@ -0,0 +1,159 @@ +using System; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; + +using VNLib.Utils; +using VNLib.Utils.Memory.Caching; +using VNLib.Net.Http; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Essentials.Sessions; + +#nullable enable + +namespace VNLib.Plugins.Sessions.Cache.Client +{ + + /// <summary> + /// A client that allows access to sessions located on external servers + /// </summary> + public abstract class SessionCacheClient : VnDisposeable, ICacheHolder + { + public class LRUSessionStore<T> : LRUCache<string, T> where T : ISession, ICacheable + { + public override bool IsReadOnly => false; + protected override int MaxCapacity { get; } + + public LRUSessionStore(int maxCapacity) : base(StringComparer.Ordinal) => MaxCapacity = maxCapacity; + + protected override bool CacheMiss(string key, [NotNullWhen(true)] out T? value) + { + value = default; + return false; + } + protected override void Evicted(KeyValuePair<string, T> evicted) + { + //Evice record + evicted.Value.Evicted(); + } + } + + protected readonly LRUSessionStore<RemoteSession> CacheTable; + protected readonly object CacheLock; + protected readonly int MaxLoadedEntires; + + protected FBMClient Client { get; } + + /// <summary> + /// Initializes a new <see cref="SessionCacheClient"/> + /// </summary> + /// <param name="client"></param> + /// <param name="maxCacheItems">The maximum number of sessions to keep in memory</param> + public SessionCacheClient(FBMClient client, int maxCacheItems) + { + MaxLoadedEntires = maxCacheItems; + CacheLock = new(); + CacheTable = new(maxCacheItems); + Client = client; + //Listen for close events + Client.ConnectionClosed += Client_ConnectionClosed; + } + + private void Client_ConnectionClosed(object? sender, EventArgs e) => CacheHardClear(); + + /// <summary> + /// Attempts to get a session from the cache identified by its sessionId asynchronously + /// </summary> + /// <param name="entity">The connection/request to attach the session to</param> + /// <param name="sessionId">The ID of the session to retrieve</param> + /// <param name="cancellationToken">A token to cancel the operation</param> + /// <returns>A <see cref="ValueTask"/> that resolves the remote session</returns> + /// <exception cref="SessionException"></exception> + public virtual async ValueTask<RemoteSession> GetSessionAsync(IHttpEvent entity, string sessionId, CancellationToken cancellationToken) + { + Check(); + try + { + RemoteSession? session; + //Aquire lock on cache + lock (CacheLock) + { + //See if session is loaded into cache + if (!CacheTable.TryGetValue(sessionId, out session)) + { + //Init new record + session = SessionCtor(sessionId); + //Add to cache + CacheTable.Add(session.SessionID, session); + } + //Valid entry found in cache + } + try + { + //Load session-data + await session.WaitAndLoadAsync(entity, cancellationToken); + return session; + } + catch + { + //Remove the invalid cached session + lock (CacheLock) + { + _ = CacheTable.Remove(sessionId); + } + throw; + } + } + catch (SessionException) + { + throw; + } + catch (OperationCanceledException) + { + throw; + } + //Wrap exceptions + catch (Exception ex) + { + throw new SessionException("An unhandled exception was raised", ex); + } + } + + /// <summary> + /// Gets a new <see cref="RemoteSession"/> instances for the given sessionId, + /// and places it a the head of internal cache + /// </summary> + /// <param name="sessionId">The session identifier</param> + /// <returns>The new session for the given ID</returns> + protected abstract RemoteSession SessionCtor(string sessionId); + + ///<inheritdoc/> + public void CacheClear() + { + + } + ///<inheritdoc/> + public void CacheHardClear() + { + //Cleanup cache when disconnected + lock (CacheLock) + { + CacheTable.Clear(); + foreach (RemoteSession session in (IEnumerable<RemoteSession>)CacheTable) + { + session.Evicted(); + } + CacheTable.Clear(); + } + } + + protected override void Free() + { + //Unsub from events + Client.ConnectionClosed -= Client_ConnectionClosed; + //Clear all cached sessions + CacheHardClear(); + } + } +} diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.csproj b/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.csproj new file mode 100644 index 0000000..0c12cec --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.csproj @@ -0,0 +1,33 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <Platforms>AnyCPU;x64</Platforms> + <Authors>Vaughn Nugent</Authors> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <Version>1.0.0.1</Version> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <DocumentationFile></DocumentationFile> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="ErrorProne.NET.CoreAnalyzers" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="ErrorProne.NET.Structs" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="Microsoft.VisualStudio.Threading" Version="17.3.44" /> + <PackageReference Include="RestSharp" Version="108.0.2" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Essentials\VNLib.Plugins.Essentials.csproj" /> + <ProjectReference Include="..\..\..\DataCaching\VNLib.Data.Caching\src\VNLib.Data.Caching.csproj" /> + </ItemGroup> + +</Project> diff --git a/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.xml b/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.xml new file mode 100644 index 0000000..95fafd7 --- /dev/null +++ b/Libs/VNLib.Plugins.Sessions.Cache.Client/VNLib.Plugins.Sessions.Cache.Client.xml @@ -0,0 +1,69 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Sessions.Cache.Client</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException"> + <summary> + Raised when a request message is too large to send to + the server and the server may close the connection. + </summary> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Sessions.Cache.Client.SessionClient"> + <summary> + A client that allows access to sessions located on external servers + </summary> + </member> + <member name="P:VNLib.Plugins.Sessions.Cache.Client.SessionClient.GetSessionId"> + <summary> + A callback that produces a session-id from the connection (or a new id if needed) + </summary> + </member> + <member name="P:VNLib.Plugins.Sessions.Cache.Client.SessionClient.NewSessionId"> + <summary> + A callback that produces a new session-id for the connection (and updates the client if necessary) + </summary> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.#ctor(System.Int32,System.Int32,System.Int32,VNLib.Utils.Logging.ILogProvider,VNLib.Utils.Memory.PrivateHeap)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Sessions.Cache.Client.SessionClient"/> + </summary> + <param name="maxMessageSize">The maxium message size (in bytes) the client will allow receiving (maximum data size for sessions)</param> + <param name="recvBufferSize">The size (in bytes) of the client message receive buffer</param> + <param name="maxCacheItems">The maximum number of sessions to keep in memory</param> + <param name="log">A <see cref="T:VNLib.Utils.Logging.ILogProvider"/> to write log events to</param> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> to allocate buffers from</param> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.GetSessionAsync(VNLib.Net.Http.HttpEvent,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.CacheClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.CacheHardClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.OnConnected"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.OnError(VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionClient.OnDisconnected"> + <inheritdoc/> + </member> + </members> +</doc> diff --git a/Plugins/CacheBroker/CacheBroker.csproj b/Plugins/CacheBroker/CacheBroker.csproj new file mode 100644 index 0000000..5f8d771 --- /dev/null +++ b/Plugins/CacheBroker/CacheBroker.csproj @@ -0,0 +1,49 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <Platforms>AnyCPU;x64</Platforms> + </PropertyGroup> + + <ItemGroup> + <Compile Remove="liveplugin\**" /> + <EmbeddedResource Remove="liveplugin\**" /> + <None Remove="liveplugin\**" /> + </ItemGroup> + + <ItemGroup> + <PackageReference Include="ErrorProne.NET.CoreAnalyzers" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="ErrorProne.NET.Structs" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="RestSharp" Version="108.0.2" /> + </ItemGroup> + + <PropertyGroup> + <!--Enable dynamic loading--> + <EnableDynamicLoading>true</EnableDynamicLoading> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <RootNamespace>VNLib.Plugins.Cache.Broker</RootNamespace> + <Authors>Vaughn Nugent</Authors> + <Version>1.0.0.1</Version> + </PropertyGroup> + + + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Essentials\VNLib.Plugins.Essentials.csproj" /> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Loading\VNLib.Plugins.Extensions.Loading.csproj" /> + <ProjectReference Include="..\..\..\PluginBase\VNLib.Plugins.PluginBase.csproj" /> + <ProjectReference Include="..\..\..\VNLib.Net.Rest.Client\VNLib.Net.Rest.Client.csproj" /> + </ItemGroup> + + <ItemGroup> + <None Update="CacheBroker.json"> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + </ItemGroup> + +</Project> diff --git a/Plugins/CacheBroker/CacheBrokerEntry.cs b/Plugins/CacheBroker/CacheBrokerEntry.cs new file mode 100644 index 0000000..762f66b --- /dev/null +++ b/Plugins/CacheBroker/CacheBrokerEntry.cs @@ -0,0 +1,43 @@ +using System; +using System.IO; +using System.Collections.Generic; + +using VNLib.Utils.Logging; +using VNLib.Plugins.Cache.Broker.Endpoints; +using VNLib.Plugins.Extensions.Loading.Routing; + +namespace VNLib.Plugins.Cache.Broker +{ + public sealed class CacheBrokerEntry : PluginBase + { + public override string PluginName => "Cache.Broker"; + + protected override void OnLoad() + { + try + { + this.Route<BrokerRegistrationEndpoint>(); + + Log.Information("Plugin loaded"); + } + catch (FileNotFoundException) + { + Log.Error("Public key file was not found at the specified path"); + } + catch (KeyNotFoundException knf) + { + Log.Error("Required configuration keys were not found {mess}", knf.Message); + } + } + + protected override void OnUnLoad() + { + Log.Debug("Plugin unloaded"); + } + + protected override void ProcessHostCommand(string cmd) + { + throw new NotImplementedException(); + } + } +} diff --git a/Plugins/CacheBroker/Endpoints/BrokerRegistrationEndpoint.cs b/Plugins/CacheBroker/Endpoints/BrokerRegistrationEndpoint.cs new file mode 100644 index 0000000..cdc0dc1 --- /dev/null +++ b/Plugins/CacheBroker/Endpoints/BrokerRegistrationEndpoint.cs @@ -0,0 +1,389 @@ +using System; +using System.IO; +using System.Linq; +using System.Text; +using System.Net; +using System.Net.Http; +using System.Text.Json; +using System.Threading; +using System.Net.Sockets; +using System.Threading.Tasks; +using System.Collections.Generic; +using System.Security.Cryptography; +using System.Text.Json.Serialization; + +using RestSharp; + +using VNLib.Net; +using VNLib.Utils; +using VNLib.Utils.IO; +using VNLib.Utils.Memory; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Hashing.IdentityUtility; +using VNLib.Plugins.Essentials; +using VNLib.Plugins.Essentials.Extensions; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Extensions.Loading.Events; +using VNLib.Plugins.Extensions.Loading.Configuration; +using VNLib.Net.Rest.Client; + + +#nullable enable + +namespace VNLib.Plugins.Cache.Broker.Endpoints +{ + [ConfigurationName("broker_endpoint")] + public sealed class BrokerRegistrationEndpoint : ResourceEndpointBase + { + const string HEARTBEAT_PATH = "/heartbeat"; + + private static readonly RestClientPool ClientPool = new(10,new RestClientOptions() + { + Encoding = Encoding.UTF8, + FollowRedirects = false, + MaxTimeout = 10 * 1000, + ThrowOnAnyError = true + }, null); + + private static readonly HashAlgorithmName SignatureHashAlg = HashAlgorithmName.SHA384; + //using the es384 algorithm for signing + private static readonly ECCurve DefaultCurve = ECCurve.CreateFromFriendlyName("secp384r1"); + + private static readonly IReadOnlyDictionary<string, string> BrokerJwtHeader = new Dictionary<string, string>() + { + { "alg","ES384" }, + { "typ", "JWT"} + }; + + private class ActiveServer + { + [JsonIgnore] + public IPAddress? ServerIp { get; set; } + [JsonPropertyName("address")] + public Uri? Address { get; set; } + [JsonPropertyName("server_id")] + public string? ServerId { get; init; } + [JsonPropertyName("ip_address")] + public string? Ip => ServerIp?.ToString(); + [JsonIgnore] + public string? Token { get; init; } + } + + + private readonly object ListLock; + private readonly Dictionary<string, ActiveServer> ActiveServers; + + private readonly Task<byte[]> CachePubKey; + private readonly Task<byte[]> ClientPubKey; + private readonly Task<byte[]> BrokerPrivateKey; + + protected override ProtectionSettings EndpointProtectionSettings { get; } + + public BrokerRegistrationEndpoint(PluginBase plugin, IReadOnlyDictionary<string, JsonElement> config) + { + string? path = config["path"].GetString(); + + //Get the keys from the vault + BrokerPrivateKey = plugin.TryGetSecretAsync("broker_private_key").ContinueWith((Task<string?> secret) => + { + _ = secret.Result ?? throw new InvalidOperationException("Broker private key not found in vault"); + return Convert.FromBase64String(secret.Result); + }); + + CachePubKey = plugin.TryGetSecretAsync("cache_public_key").ContinueWith((Task<string?> secret) => + { + _ = secret.Result ?? throw new InvalidOperationException("Cache public key not found in vault"); + return Convert.FromBase64String(secret.Result); + }); + + ClientPubKey = plugin.TryGetSecretAsync("client_public_key").ContinueWith((Task<string?> secret) => + { + _ = secret.Result ?? throw new InvalidOperationException("Client public key not found in vault"); + return Convert.FromBase64String(secret.Result); + }); + + + InitPathAndLog(path, plugin.Log); + + //Loosen up protection settings since this endpoint is not desinged for browsers or sessions + EndpointProtectionSettings = new() + { + SessionsRequired = false, + BrowsersOnly = false, + CrossSiteDenied = false, + }; + + ListLock = new(); + ActiveServers = new(); + } + + + protected override async ValueTask<VfReturnType> PostAsync(HttpEntity entity) + { + //Parse jwt + using JsonWebToken? jwt = await entity.ParseFileAsAsync(ParseJwtAsync); + //Verify with the client's pub key + using (ECDsa alg = ECDsa.Create(DefaultCurve)) + { + alg.ImportSubjectPublicKeyInfo(ClientPubKey.Result, out _); + //Verify with client public key + if (!jwt.Verify(alg, SignatureHashAlg)) + { + entity.CloseResponse(HttpStatusCode.Unauthorized); + return VfReturnType.VirtualSkip; + } + } + try + { + //Get all active servers + ActiveServer[] servers; + lock (ListLock) + { + servers = ActiveServers.Values.ToArray(); + } + + //Create response payload with list of active servers and sign it + using JsonWebToken response = new(); + response.WriteHeader(BrokerJwtHeader); + response.InitPayloadClaim(1) + .AddClaim("servers", servers) + .CommitClaims(); + + //Sign the jwt using the broker key + using(ECDsa alg = ECDsa.Create(DefaultCurve)) + { + alg.ImportPkcs8PrivateKey(BrokerPrivateKey.Result, out _); + + response.Sign(alg, in SignatureHashAlg, 128); + } + + //Alloc output buffer + int bufSize = response.ByteSize * 2; + + using UnsafeMemoryHandle<char> charBuf = Memory.UnsafeAlloc<char>(bufSize, true); + + //compile jwt + ERRNO count = response.Compile(charBuf); + + entity.CloseResponse(HttpStatusCode.OK, ContentType.Text, charBuf.Span[..(int)count]); + return VfReturnType.VirtualSkip; + } + catch (KeyNotFoundException) + { + entity.CloseResponse(HttpStatusCode.UnprocessableEntity); + return VfReturnType.VirtualSkip; + } + } + + /* + * Server's call the put method to register or update their registration + * for availability + */ + + private static async ValueTask<JsonWebToken?> ParseJwtAsync(Stream inputStream) + { + //get a buffer to store data in + using VnMemoryStream buffer = new(); + //Copy input stream to buffer + await inputStream.CopyToAsync(buffer, 4096, Memory.Shared); + //Parse jwt + return JsonWebToken.Parse(buffer.AsSpan()); + } + + protected override async ValueTask<VfReturnType> PutAsync(HttpEntity entity) + { + //Parse jwt + using JsonWebToken? jwt = await entity.ParseFileAsAsync(ParseJwtAsync); + //Verify with the cache server's pub key + using (ECDsa alg = ECDsa.Create(DefaultCurve)) + { + alg.ImportSubjectPublicKeyInfo(CachePubKey.Result, out _); + //Verify the jwt + if (!jwt.Verify(alg, SignatureHashAlg)) + { + entity.CloseResponse(HttpStatusCode.Unauthorized); + return VfReturnType.VirtualSkip; + } + } + + try + { + + //Get message body + using JsonDocument requestBody = jwt.GetPayload(); + + //Get request keys + string? serverId = requestBody.RootElement.GetProperty("server_id").GetString(); + string? hostname = requestBody.RootElement.GetProperty("address").GetString(); + string? token = requestBody.RootElement.GetProperty("token").GetString(); + + if (string.IsNullOrWhiteSpace(serverId) || string.IsNullOrWhiteSpace(hostname)) + { + entity.CloseResponse(HttpStatusCode.UnprocessableEntity); + return VfReturnType.VirtualSkip; + } + + //Build the hostname uri + Uri serverUri = new(hostname); + + //Check hostname + if (Uri.CheckHostName(serverUri.DnsSafeHost) != UriHostNameType.Dns) + { + entity.CloseResponse(HttpStatusCode.UnprocessableEntity); + return VfReturnType.VirtualSkip; + } + + //Check dns-ip resolution to the current connection if not local connection + if (!entity.Server.IsLoopBack()) + { + //Resolve the ip address of the server's hostname to make sure its ip-address matches + IPHostEntry remoteHost = await Dns.GetHostEntryAsync(serverUri.DnsSafeHost); + //See if the dns lookup resolved the same ip address that connected to the server + bool isAddressMatch = (from addr in remoteHost.AddressList + where addr.Equals(entity.TrustedRemoteIp) + select addr) + .Any(); + //If the lookup fails, exit with forbidden + if (!isAddressMatch) + { + entity.CloseResponse(HttpStatusCode.Forbidden); + return VfReturnType.VirtualSkip; + } + } + + //Server is allowed to be put into an active state + ActiveServer server = new() + { + Address = serverUri, + ServerIp = entity.TrustedRemoteIp, + ServerId = serverId, + Token = token + }; + + //Store/update active server + lock (ListLock) + { + ActiveServers[serverId] = server; + } + + Log.Debug("Server {s}:{ip} added ", serverId, entity.TrustedRemoteIp); + //Send the broker public key used to verify authenticating clients + entity.CloseResponse(HttpStatusCode.OK); + return VfReturnType.VirtualSkip; + } + catch (KeyNotFoundException) + { + entity.CloseResponse(HttpStatusCode.UnprocessableEntity); + return VfReturnType.VirtualSkip; + } + catch (InvalidOperationException) + { + entity.CloseResponse(HttpStatusCode.BadRequest); + return VfReturnType.VirtualSkip; + } + catch (UriFormatException) + { + entity.CloseResponse(HttpStatusCode.UnprocessableEntity); + return VfReturnType.VirtualSkip; + } + catch (FormatException) + { + entity.CloseResponse(HttpStatusCode.BadRequest); + return VfReturnType.BadRequest; + } + catch (JsonException) + { + entity.CloseResponse(HttpStatusCode.BadRequest); + return VfReturnType.BadRequest; + } + } + + + /* + * Schedule heartbeat interval + */ + [ConfigurableAsyncInterval("heartbeat_sec", IntervalResultionType.Seconds)] + public async Task OnIntervalAsync(BrokerRegistrationEndpoint bep, CancellationToken pluginExit) + { + ActiveServer[] servers; + //Get the current list of active servers + lock (ListLock) + { + servers = ActiveServers.Values.ToArray(); + } + List<Task> all = new(); + //Run keeplaive request for all active servers + foreach (ActiveServer server in servers) + { + all.Add(RunHeartbeatAsync(server)); + } + //Wait for all to complete + await Task.WhenAll(all); + } + + private async Task RunHeartbeatAsync(ActiveServer server) + { + try + { + //build httpuri + UriBuilder uri = new(server.Address!) + { + Path = HEARTBEAT_PATH + }; + string authMessage; + //Init jwt for signing auth messages + using (JsonWebToken jwt = new()) + { + jwt.WriteHeader(BrokerJwtHeader); + jwt.InitPayloadClaim() + .AddClaim("token", server.Token) + .CommitClaims(); + + //Sign the jwt using the broker key + using (ECDsa alg = ECDsa.Create(DefaultCurve)) + { + alg.ImportPkcs8PrivateKey(BrokerPrivateKey.Result, out _); + //Sign with broker key + jwt.Sign(alg, in SignatureHashAlg, 128); + } + //compile + authMessage = jwt.Compile(); + } + //Build keeplaive request + RestRequest keepaliveRequest = new(uri.Uri, Method.Get); + //Add authorization token + keepaliveRequest.AddHeader("Authorization", authMessage); + + //Rent client from pool + using ClientContract client = await ClientPool.GetClientAsync(); + //Exec + RestResponse response = await client.Resource.ExecuteAsync(keepaliveRequest); + //If the response was successful, then keep it in the list, if the response fails, + if (response.IsSuccessful) + { + return; + } + //Remove the server + } + catch (HttpRequestException re) when (re.InnerException is SocketException) + { + Log.Debug("Server {s} removed, failed to connect", server.ServerId); + } + catch (TimeoutException) + { + Log.Information("Server {s} removed from active list due to a connection timeout", server.ServerId); + } + catch (Exception ex) + { + Log.Information("Server {s} removed from active list due to failed heartbeat request", server.ServerId); + Log.Debug(ex); + } + //Remove server from active list + lock (ListLock) + { + _ = ActiveServers.Remove(server.ServerId!); + } + } + } +} diff --git a/Plugins/SessionCacheServer/Endpoints/BrokerHeartBeat.cs b/Plugins/SessionCacheServer/Endpoints/BrokerHeartBeat.cs new file mode 100644 index 0000000..e80be77 --- /dev/null +++ b/Plugins/SessionCacheServer/Endpoints/BrokerHeartBeat.cs @@ -0,0 +1,111 @@ +using System; +using System.Net; +using System.Linq; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; +using System.Security.Cryptography; + +using VNLib.Data.Caching.Extensions; +using VNLib.Hashing.IdentityUtility; +using VNLib.Plugins.Essentials.Extensions; +using VNLib.Plugins.Extensions.Loading; + +#nullable enable + +namespace VNLib.Plugins.Essentials.Sessions.Server.Endpoints +{ + internal class BrokerHeartBeat : ResourceEndpointBase + { + public override string Path => "/heartbeat"; + + private readonly Func<string> Token; + private readonly ManualResetEvent KeepaliveSet; + private readonly Task<IPAddress[]> BrokerIpList; + private readonly PluginBase Pbase; + + protected override ProtectionSettings EndpointProtectionSettings { get; } + + public BrokerHeartBeat(Func<string> token, ManualResetEvent keepaliveSet, Uri brokerUri, PluginBase pbase) + { + Token = token; + KeepaliveSet = keepaliveSet; + BrokerIpList = Dns.GetHostAddressesAsync(brokerUri.DnsSafeHost); + + this.Pbase = pbase; + + EndpointProtectionSettings = new() + { + BrowsersOnly = false, + SessionsRequired = false, + VerifySessionCors = false, + }; + } + + private async Task<byte[]> GetBrokerPubAsync() + { + string? brokerPubKey = await Pbase.TryGetSecretAsync("broker_public_key") ?? throw new KeyNotFoundException("Missing required secret : broker_public_key"); + + return Convert.FromBase64String(brokerPubKey); + } + + protected override async ValueTask<VfReturnType> GetAsync(HttpEntity entity) + { + //If-not loopback then verify server address + if (!entity.Server.IsLoopBack()) + { + //Load and verify the broker's ip address matches with an address we have stored + IPAddress[] addresses = await BrokerIpList; + if (!addresses.Contains(entity.TrustedRemoteIp)) + { + //Token invalid + entity.CloseResponse(HttpStatusCode.Forbidden); + return VfReturnType.VirtualSkip; + } + } + //Get the authorization jwt + string? jwtAuth = entity.Server.Headers[HttpRequestHeader.Authorization]; + if (string.IsNullOrWhiteSpace(jwtAuth)) + { + //Token invalid + entity.CloseResponse(HttpStatusCode.Forbidden); + return VfReturnType.VirtualSkip; + } + //Parse the jwt + using JsonWebToken jwt = JsonWebToken.Parse(jwtAuth); + //Init signature alg + using (ECDsa alg = ECDsa.Create(FBMDataCacheExtensions.CacheCurve)) + { + //Get pub key + byte[] key = await GetBrokerPubAsync(); + + alg.ImportSubjectPublicKeyInfo(key, out _); + //Verify the jwt + if (!jwt.Verify(alg, FBMDataCacheExtensions.CacheJwtAlgorithm)) + { + //Token invalid + entity.CloseResponse(HttpStatusCode.Forbidden); + return VfReturnType.VirtualSkip; + } + } + string? auth; + //Recover the auth token from the jwt + using (JsonDocument doc = jwt.GetPayload()) + { + auth = doc.RootElement.GetProperty("token").GetString(); + } + //Verify token + if(Token().Equals(auth, StringComparison.Ordinal)) + { + //Signal keepalive + KeepaliveSet.Set(); + entity.CloseResponse(HttpStatusCode.OK); + return VfReturnType.VirtualSkip; + } + //Token invalid + entity.CloseResponse(HttpStatusCode.Forbidden); + return VfReturnType.VirtualSkip; + } + } +} diff --git a/Plugins/SessionCacheServer/Endpoints/ConnectEndpoint.cs b/Plugins/SessionCacheServer/Endpoints/ConnectEndpoint.cs new file mode 100644 index 0000000..fc4de30 --- /dev/null +++ b/Plugins/SessionCacheServer/Endpoints/ConnectEndpoint.cs @@ -0,0 +1,243 @@ +using System; +using System.Net; +using System.Text; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using System.Threading.Channels; +using System.Collections.Generic; +using System.Security.Cryptography; +using System.Collections.Concurrent; + +using VNLib.Utils.Async; +using VNLib.Utils.Logging; +using VNLib.Hashing.IdentityUtility; +using VNLib.Net.Messaging.FBM; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Net.Messaging.FBM.Server; +using VNLib.Data.Caching.Extensions; +using VNLib.Data.Caching.ObjectCache; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Essentials.Extensions; + + +namespace VNLib.Plugins.Essentials.Sessions.Server +{ + class ConnectEndpoint : ResourceEndpointBase + { + + const int MAX_RECV_BUF_SIZE = 1000 * 1024; + const int MIN_RECV_BUF_SIZE = 8 * 1024; + const int MAX_HEAD_BUF_SIZE = 2048; + const int MIN_MESSAGE_SIZE = 10 * 1024; + const int MAX_MESSAGE_SIZE = 1000 * 1024; + const int MIN_HEAD_BUF_SIZE = 128; + const int MAX_EVENT_QUEUE_SIZE = 10000; + const int MAX_RESPONSE_BUFFER_SIZE = 10 * 1024; + + private static readonly Encoding FBMHeaderEncoding = Helpers.DefaultEncoding; + + private readonly ObjectCacheStore Store; + private readonly PluginBase Pbase; + + private readonly ConcurrentDictionary<string, AsyncQueue<ChangeEvent>> StatefulEventQueue; + + private uint _connectedClients; + + public uint ConnectedClients => _connectedClients; + + protected override ProtectionSettings EndpointProtectionSettings { get; } + + public ConnectEndpoint(string path, ObjectCacheStore store, PluginBase pbase) + { + InitPathAndLog(path, pbase.Log); + Store = store;//Load client public key to verify signed messages + Pbase = pbase; + + + StatefulEventQueue = new(StringComparer.OrdinalIgnoreCase); + //Start the queue worker + _ = ChangeWorkerAsync().ConfigureAwait(false); + + //Loosen up protection settings + EndpointProtectionSettings = new() + { + BrowsersOnly = false, + SessionsRequired = false, + CrossSiteDenied = false + }; + } + + private async Task<byte[]> GetClientPubAsync() + { + string? brokerPubKey = await Pbase.TryGetSecretAsync("client_public_key") ?? throw new KeyNotFoundException("Missing required secret : client_public_key"); + + return Convert.FromBase64String(brokerPubKey); + } + + private async Task ChangeWorkerAsync() + { + try + { + //Listen for changes + while (true) + { + ChangeEvent ev = await Store.EventQueue.DequeueAsync(Pbase.UnloadToken); + //Add event to queues + foreach (AsyncQueue<ChangeEvent> queue in StatefulEventQueue.Values) + { + if (!queue.TryEnque(ev)) + { + Log.Debug("Listener queue has exeeded capacity, change events will be lost"); + } + } + } + } + catch (OperationCanceledException) + {} + catch(Exception ex) + { + Log.Error(ex); + } + } + + private class WsUserState + { + public int RecvBufferSize { get; init; } + public int MaxHeaderBufferSize { get; init; } + public int MaxMessageSize { get; init; } + public int MaxResponseBufferSize { get; init; } + public AsyncQueue<ChangeEvent>? SyncQueue { get; init; } + } + + protected override async ValueTask<VfReturnType> WebsocketRequestedAsync(HttpEntity entity) + { + try + { + //Parse jwt from authoriation + string? jwtAuth = entity.Server.Headers[HttpRequestHeader.Authorization]; + if (string.IsNullOrWhiteSpace(jwtAuth)) + { + entity.CloseResponse(HttpStatusCode.Unauthorized); + return VfReturnType.VirtualSkip; + } + string? nodeId = null; + //Parse jwt + using (JsonWebToken jwt = JsonWebToken.Parse(jwtAuth)) + { + //Get the client public key + byte[] clientPub = await GetClientPubAsync(); + + //Init sig alg + using ECDsa sigAlg = ECDsa.Create(FBMDataCacheExtensions.CacheCurve); + //Import client pub key + sigAlg.ImportSubjectPublicKeyInfo(clientPub, out _); + //verify signature for client + if (!jwt.Verify(sigAlg, FBMDataCacheExtensions.CacheJwtAlgorithm)) + { + entity.CloseResponse(HttpStatusCode.Unauthorized); + return VfReturnType.VirtualSkip; + } + //Recover json body + using JsonDocument doc = jwt.GetPayload(); + if (doc.RootElement.TryGetProperty("server_id", out JsonElement servIdEl)) + { + nodeId = servIdEl.GetString(); + } + } + //Get query config suggestions from the client + string recvBufCmd = entity.QueryArgs[FBMClient.REQ_RECV_BUF_QUERY_ARG]; + string maxHeaderCharCmd = entity.QueryArgs[FBMClient.REQ_HEAD_BUF_QUERY_ARG]; + string maxMessageSizeCmd = entity.QueryArgs[FBMClient.REQ_MAX_MESS_QUERY_ARG]; + //Parse recv buffer size + int recvBufSize = int.TryParse(recvBufCmd, out int rbs) ? rbs : MIN_RECV_BUF_SIZE; + int maxHeadBufSize = int.TryParse(maxHeaderCharCmd, out int hbs) ? hbs : MIN_HEAD_BUF_SIZE; + int maxMessageSize = int.TryParse(maxMessageSizeCmd, out int mxs) ? mxs : MIN_MESSAGE_SIZE; + AsyncQueue<ChangeEvent>? nodeQueue = null; + //The connection may be a caching server node, so get its node-id + if (!string.IsNullOrWhiteSpace(nodeId)) + { + /* + * Store a new async queue, or get an old queue for the current node + * + * We should use a bounded queue and disacard LRU items, we also know + * only a single writer is needed as the queue is processed on a single thread + * and change events may be processed on mutliple threads. + */ + + BoundedChannelOptions queueOptions = new(MAX_EVENT_QUEUE_SIZE) + { + AllowSynchronousContinuations = true, + SingleReader = false, + SingleWriter = true, + //Drop oldest item in queue if full + FullMode = BoundedChannelFullMode.DropOldest, + }; + + _ = StatefulEventQueue.TryAdd(nodeId, new(queueOptions)); + //Get the queue + nodeQueue = StatefulEventQueue[nodeId]; + } + //Init new ws state object and clamp the suggested buffer sizes + WsUserState state = new() + { + RecvBufferSize = Math.Clamp(recvBufSize, MIN_RECV_BUF_SIZE, MAX_RECV_BUF_SIZE), + MaxHeaderBufferSize = Math.Clamp(maxHeadBufSize, MIN_HEAD_BUF_SIZE, MAX_HEAD_BUF_SIZE), + MaxMessageSize = Math.Clamp(maxMessageSize, MIN_MESSAGE_SIZE, MAX_MESSAGE_SIZE), + MaxResponseBufferSize = Math.Min(maxMessageSize, MAX_RESPONSE_BUFFER_SIZE), + SyncQueue = nodeQueue + }; + Log.Debug("Client recv buffer suggestion {recv}, header buffer size {head}, response buffer size {r}", recvBufCmd, maxHeaderCharCmd, state.MaxResponseBufferSize); + //Accept socket and pass state object + entity.AcceptWebSocket(WebsocketAcceptedAsync, state); + return VfReturnType.VirtualSkip; + } + catch (KeyNotFoundException) + { + return VfReturnType.BadRequest; + } + } + private async Task WebsocketAcceptedAsync(WebSocketSession wss) + { + //Inc connected count + Interlocked.Increment(ref _connectedClients); + //Register plugin exit token to cancel the connected socket + CancellationTokenRegistration reg = Pbase.UnloadToken.Register(wss.CancelAll); + try + { + WsUserState state = (wss.UserState as WsUserState)!; + + //Init listener args from request + FBMListenerSessionParams args = new() + { + MaxMessageSize = state.MaxMessageSize, + RecvBufferSize = state.RecvBufferSize, + ResponseBufferSize = state.MaxResponseBufferSize, + MaxHeaderBufferSize = state.MaxHeaderBufferSize, + HeaderEncoding = FBMHeaderEncoding, + }; + + //Listen for requests + await Store.ListenAsync(wss, args, state.SyncQueue); + } + catch (OperationCanceledException) + { + Log.Debug("Websocket connection was canceled"); + //Disconnect the socket + await wss.CloseSocketOutputAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, "unload", CancellationToken.None); + } + catch (Exception ex) + { + Log.Debug(ex); + } + finally + { + //Dec connected count + Interlocked.Decrement(ref _connectedClients); + //Unregister the + reg.Unregister(); + } + Log.Debug("Server websocket exited"); + } + } +} diff --git a/Plugins/SessionCacheServer/SessionCacheServer.csproj b/Plugins/SessionCacheServer/SessionCacheServer.csproj new file mode 100644 index 0000000..8c45a24 --- /dev/null +++ b/Plugins/SessionCacheServer/SessionCacheServer.csproj @@ -0,0 +1,55 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <Authors>Vaughn Nugent</Authors> + <Version>1.0.0.1</Version> + <RootNamespace>VNLib.Plugins.Essentials.Sessions.Server</RootNamespace> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <Platforms>AnyCPU;x64</Platforms> + </PropertyGroup> + + <!-- Resolve nuget dll files and store them in the output dir --> + <PropertyGroup> + <EnableDynamicLoading>true</EnableDynamicLoading> + <Nullable>enable</Nullable> + </PropertyGroup> + <ItemGroup> + <Compile Remove="liveplugin2\**" /> + <Compile Remove="liveplugin\**" /> + <EmbeddedResource Remove="liveplugin2\**" /> + <EmbeddedResource Remove="liveplugin\**" /> + <None Remove="liveplugin2\**" /> + <None Remove="liveplugin\**" /> + </ItemGroup> + <ItemGroup> + <PackageReference Include="ErrorProne.NET.CoreAnalyzers" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="ErrorProne.NET.Structs" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Essentials\VNLib.Plugins.Essentials.csproj" /> + <ProjectReference Include="..\..\..\DataCaching\VNLib.Data.Caching.Extensions\VNLib.Data.Caching.Extensions.csproj" /> + <ProjectReference Include="..\..\..\DataCaching\VNLib.Data.Caching.ObjectCache\VNLib.Data.Caching.ObjectCache.csproj" /> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Loading\VNLib.Plugins.Extensions.Loading.csproj" /> + <ProjectReference Include="..\..\..\PluginBase\VNLib.Plugins.PluginBase.csproj" /> + <ProjectReference Include="..\CacheBroker\CacheBroker.csproj" /> + </ItemGroup> + + + <ItemGroup> + <None Update="SessionCacheServer.json"> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + </ItemGroup> + + <Target Name="PostBuild" AfterTargets="PostBuildEvent"> + <Exec Command="start xcopy "$(TargetDir)" "$(ProjectDir)/liveplugin/$(TargetName)" /E /Y /R
start xcopy "$(TargetDir)" "\\vaughnnugent.com\Internal\Vaughns Folder\Programming\LiveWebPlugins\SessionServerPlugins/$(TargetName)" /E /Y /R" /> + </Target> + +</Project> diff --git a/Plugins/SessionCacheServer/SessionServerEntrypoint.cs b/Plugins/SessionCacheServer/SessionServerEntrypoint.cs new file mode 100644 index 0000000..45c5da2 --- /dev/null +++ b/Plugins/SessionCacheServer/SessionServerEntrypoint.cs @@ -0,0 +1,514 @@ +using System; +using System.IO; +using System.Net; +using System.Linq; +using System.Net.Http; +using System.Text.Json; +using System.Threading; +using System.Diagnostics; +using System.Net.Sockets; +using System.Threading.Tasks; +using System.Collections.Generic; +using System.Security.Cryptography; +using System.Collections.Concurrent; + +using VNLib.Utils.Memory; +using VNLib.Utils.Logging; +using VNLib.Utils.Extensions; +using VNLib.Hashing; +using VNLib.Data.Caching; +using VNLib.Data.Caching.Extensions; +using VNLib.Data.Caching.ObjectCache; +using static VNLib.Data.Caching.Constants; +using VNLib.Net.Messaging.FBM; +using VNLib.Net.Messaging.FBM.Client; +using VNLib.Plugins.Cache.Broker.Endpoints; +using VNLib.Plugins.Extensions.Loading; +using VNLib.Plugins.Extensions.Loading.Routing; +using VNLib.Plugins.Extensions.Loading.Configuration; +using VNLib.Plugins.Essentials.Sessions.Server.Endpoints; + + +namespace VNLib.Plugins.Essentials.Sessions.Server +{ + public sealed class SessionServerEntrypoint : PluginBase + { + public override string PluginName => "Session.Cache.Service"; + + private string? BrokerHeartBeatToken; + + protected override void OnLoad() + { + //Create default heap + IUnmangedHeap CacheHeap = Memory.InitializeNewHeapForProcess(); + try + { + IReadOnlyDictionary<string, JsonElement> clusterConf = this.GetConfig("cluster"); + + string brokerAddress = clusterConf["broker_address"].GetString() ?? throw new KeyNotFoundException("Missing required key 'broker_address' for config 'cluster'"); + + string swapDir = PluginConfig.GetProperty("swap_dir").GetString(); + int cacheSize = PluginConfig.GetProperty("max_cache").GetInt32(); + string connectPath = PluginConfig.GetProperty("connect_path").GetString() ?? throw new KeyNotFoundException("Missing required element 'connect_path' for config 'cluster'"); + TimeSpan cleanupInterval = PluginConfig.GetProperty("cleanup_interval_sec").GetTimeSpan(TimeParseType.Seconds); + TimeSpan validFor = PluginConfig.GetProperty("valid_for_sec").GetTimeSpan(TimeParseType.Seconds); + int maxMessageSize = PluginConfig.GetProperty("max_blob_size").GetInt32(); + + TimeSpan initialCleanupDelay = TimeSpan.FromSeconds(2); + //Init dir + DirectoryInfo dir = new(swapDir); + dir.Create(); + //Init cache listener, single threaded reader + ObjectCacheStore CacheListener = new(dir, cacheSize, Log, CacheHeap, true); + //Init connect endpoint + { + //Init connect endpoint + ConnectEndpoint endpoint = new(connectPath, CacheListener, this); + Route(endpoint); + } + + //Setup broker and regitration + { + //init mre to pass the broker heartbeat signal to the registration worker + ManualResetEvent mre = new(false); + //Route the broker endpoint + BrokerHeartBeat brokerEp = new(() => BrokerHeartBeatToken!, mre, new Uri(brokerAddress), this); + Route(brokerEp); + //start registration + _ = RegisterServerAsync(mre) + .ConfigureAwait(false); + } + //Setup cluster worker + { + //Get pre-configured fbm client config for caching + FBMClientConfig conf = FBMDataCacheExtensions.GetDefaultConfig(CacheHeap, maxMessageSize, this.IsDebug() ? Log : null); + + //Start Client runner + _ = RunClientAsync(CacheListener, new Uri(brokerAddress), conf) + .ConfigureAwait(false); + } + //Load a cache broker to the current server if the config is defined + { + if(this.HasConfigForType<BrokerRegistrationEndpoint>()) + { + this.Route<BrokerRegistrationEndpoint>(); + } + } + //Init timer and fire immediatly to cleanup + Timer CleanupTimer = new((object? state) => OnCleanupElapsed(state, validFor), CacheListener, initialCleanupDelay, cleanupInterval); + + void Cleanup() + { + CacheHeap.Dispose(); + CleanupTimer.Dispose(); + CacheListener.Dispose(); + } + + //Regsiter cleanup + _ = UnloadToken.RegisterUnobserved(Cleanup); + + Log.Information("Plugin loaded"); + } + catch (KeyNotFoundException kne) + { + CacheHeap.Dispose(); + Log.Error("Missing required configuration variables {m}", kne.Message); + } + catch + { + CacheHeap.Dispose(); + throw; + } + } + + protected override void OnUnLoad() + { + Log.Information("Plugin unloaded"); + } + + private void OnCleanupElapsed(object? state, TimeSpan validFor) + { + try + { + ObjectCacheStore listener = state as ObjectCacheStore; + Stopwatch sw = new(); + sw.Start(); + //Cleanup + //await listener.CleanupExpiredAsync(validFor); + sw.Stop(); + Log.Debug("Expired cache records cleaned in {ms} ms", sw.Elapsed.TotalMilliseconds); + } + catch (Exception ex) + { + Log.Error(ex); + } + } + + #region Registration + + private async Task RegisterServerAsync(ManualResetEvent keepaliveWait) + { + try + { + //Get the broker config element + IReadOnlyDictionary<string, JsonElement> clusterConfig = this.GetConfig("cluster"); + + Uri brokerAddress = new(clusterConfig["broker_address"].GetString()); + //Server id is just dns name for now + string serverId = Dns.GetHostName(); + int heartBeatDelayMs = clusterConfig["heartbeat_timeout_sec"].GetInt32() * 1000; + + string connectPath = PluginConfig.GetProperty("connect_path").GetString(); + + //Get the port of the primary webserver + int port; + bool usingTls; + { + JsonElement firstHost = HostConfig.GetProperty("virtual_hosts").EnumerateArray().First(); + + port = firstHost.GetProperty("interface") + .GetProperty("port") + .GetInt32(); + + //If a certificate is specified, tls is enabled on the port + usingTls = firstHost.TryGetProperty("cert", out _); + } + + //Try to get the cache private key + string base64Priv = await this.TryGetSecretAsync("cache_private_key") ?? throw new KeyNotFoundException("Failed to load the cache private key"); + + byte[] privKey = Convert.FromBase64String(base64Priv); + + //Init url builder for payload, see if tls is enabled + Uri connectAddress = new UriBuilder(usingTls ? Uri.UriSchemeHttps : Uri.UriSchemeHttp, Dns.GetHostName(), port, connectPath).Uri; + + while (true) + { + try + { + //Gen a random reg token before registering + BrokerHeartBeatToken = RandomHash.GetRandomHex(32); + + Log.Information("Registering with cache broker {addr}, with node-id {id}", brokerAddress, serverId); + + //Register with the broker + await FBMDataCacheExtensions.ResgisterWithBrokerAsync(brokerAddress, privKey, connectAddress.ToString(), serverId, BrokerHeartBeatToken); + + Log.Debug("Successfully registered with cache broker"); + + /* + * Wait in a loop for the broker to send a keepalive + * request with the specified token. When the event + * is signaled the task will be completed + */ + while (true) + { + await Task.Delay(heartBeatDelayMs, UnloadToken); + //Set the timeout to 0 to it will just check the status without blocking + if (!keepaliveWait.WaitOne(0)) + { + //server miseed a keepalive event, time to break the loop and retry + Log.Debug("Broker missed a heartbeat request, attempting to re-register"); + break; + } + //Reset the msr + keepaliveWait.Reset(); + } + } + catch (TaskCanceledException) + { + throw; + } + catch (TimeoutException) + { + Log.Warn("Failed to connect to cache broker server within the specified timeout period"); + } + catch (HttpRequestException re) when (re.InnerException is SocketException) + { + Log.Warn("Cache broker is unavailable or network is unavailable"); + } + catch (Exception ex) + { + Log.Warn(ex, "Failed to update broker registration"); + } + + //Gen random ms delay + int randomMsDelay = RandomNumberGenerator.GetInt32(500, 2000); + //Delay + await Task.Delay(randomMsDelay, UnloadToken); + } + } + catch (KeyNotFoundException kne) + { + Log.Error("Missing required broker configuration variables {ke}", kne.Message); + } + catch (TaskCanceledException) + { + //Normal unload/exit + } + catch (Exception ex) + { + Log.Error(ex); + } + finally + { + keepaliveWait.Dispose(); + BrokerHeartBeatToken = null; + } + Log.Debug("Registration worker exited"); + } + + #endregion + + #region Cluster + + /// <summary> + /// Starts a self-contained process-long task to discover other cache servers + /// from a shared broker server + /// </summary> + /// <param name="cacheStore">The cache store to synchronize</param> + /// <param name="brokerAddress">The broker server's address</param> + /// <param name="serverId">The node-id of the current server</param> + /// <param name="clientConf">The configuration to use when initializing synchronization clients</param> + /// <returns>A task that resolves when the plugin unloads</returns> + private async Task RunClientAsync(ObjectCacheStore cacheStore, Uri brokerAddress, FBMClientConfig clientConf) + { + TimeSpan noServerDelay = TimeSpan.FromSeconds(10); + //Init signing algs + ReadOnlyMemory<byte> clientPrivKey = null; + ReadOnlyMemory<byte> brokerPubKey = null; + string nodeId = Dns.GetHostName(); + try + { + //Get the broker config element + IReadOnlyDictionary<string, JsonElement> clusterConf = this.GetConfig("cluster"); + int serverCheckMs = clusterConf["update_interval_sec"].GetInt32() * 1000; + + //Get client priv key from secret store + string cpk = await this.TryGetSecretAsync("client_private_key") ?? throw new KeyNotFoundException("Failed to get the client private key from config"); + string bpub = await this.TryGetSecretAsync("broker_public_key") ?? throw new KeyNotFoundException("Failed to get the broker public key from config"); + + //Load client private key + clientPrivKey = Convert.FromBase64String(cpk); + //Import broker public key + brokerPubKey = Convert.FromBase64String(bpub); + + //Concurrent dict to track remote servers + ConcurrentDictionary<string, ActiveServer> ActiveServers = new(); + //Main event loop + Log.Information("Discovering available cluster nodes in broker"); + + while (!UnloadToken.IsCancellationRequested) + { + //Load the server list + ActiveServer[]? servers; + while (true) + { + try + { + //Get server list + servers = await FBMDataCacheExtensions.ListServersAsync(brokerAddress, clientPrivKey, brokerPubKey, UnloadToken); + //Servers are loaded, so continue + break; + } + catch(HttpRequestException he) when(he.InnerException is SocketException) + { + Log.Warn("Failed to connect to cache broker, trying again"); + } + catch (TimeoutException) + { + Log.Warn("Failed to connect to cache broker server within the specified timeout period"); + } + catch (Exception ex) + { + Log.Warn(ex, "Failed to get server list from broker"); + } + //Gen random ms delay + int randomMsDelay = RandomNumberGenerator.GetInt32(1000, 2000); + //Delay + await Task.Delay(randomMsDelay, UnloadToken); + } + if(servers?.Length == 0) + { + Log.Information("No cluster nodes found, retrying"); + //Delay + await Task.Delay(noServerDelay, UnloadToken); + continue; + } + //Select servers that are not the current server and are not already being monitored + IEnumerable<ActiveServer> serversToConnectTo = from s in + (from ss in servers + where ss.ServerId != nodeId + select ss) + where !ActiveServers.ContainsKey(s.ServerId) + select s; + //Connect to servers + foreach(ActiveServer server in serversToConnectTo) + { + _ = RunSyncTaskAsync(server, ActiveServers, cacheStore, clientConf, clientPrivKey, nodeId) + .ConfigureAwait(false); + } + //Delay until next check cycle + await Task.Delay(serverCheckMs, UnloadToken); + } + } + catch (FileNotFoundException) + { + Log.Error("Client/cluster private cluster key file was not found or could not be read"); + } + catch (KeyNotFoundException) + { + Log.Error("Missing required cluster configuration varables"); + } + catch (TaskCanceledException) + { + } + catch (Exception ex) + { + Log.Error(ex); + } + finally + { + Memory.UnsafeZeroMemory(clientPrivKey); + Memory.UnsafeZeroMemory(brokerPubKey); + } + Log.Debug("Cluster sync worker exited"); + } + + private async Task RunSyncTaskAsync(ActiveServer server, ConcurrentDictionary<string, ActiveServer> activeList, + ObjectCacheStore cacheStore, FBMClientConfig conf, ReadOnlyMemory<byte> privateKey, string nodeId) + { + //Setup client + FBMClient client = new(conf); + //Add server to active list, or replace its old value with the new one + activeList.AddOrUpdate(server.ServerId, server, (old, update) => server); + try + { + async Task UpdateRecordAsync(string objectId, string newId) + { + //Get request message + FBMRequest modRequest = client.RentRequest(); + try + { + //Set action as get/create + modRequest.WriteHeader(HeaderCommand.Action, Actions.Get); + //Set session-id header + modRequest.WriteHeader(ObjectId, string.IsNullOrWhiteSpace(newId) ? objectId : newId); + + //Make request + using FBMResponse response = await client.SendAsync(modRequest, UnloadToken); + + response.ThrowIfNotSet(); + //Check response code + string status = response.Headers.First(static s => s.Key == HeaderCommand.Status).Value.ToString(); + if (ResponseCodes.Okay.Equals(status, StringComparison.Ordinal)) + { + //Update the record + await cacheStore.AddOrUpdateBlobAsync(objectId, newId, static (t) => t.ResponseBody, response); + Log.Debug("Updated object {id}", objectId); + } + else + { + Log.Warn("Object {id} was missing on the remote server", objectId); + } + } + finally + { + client.ReturnRequest(modRequest); + } + } + + string challenge = RandomHash.GetRandomBase64(24); + //Connect to the server + await client.ConnectAsync(server.HostName, privateKey, challenge, nodeId, false, UnloadToken); + + //Wroker task callback method + async Task BgWorkerAsync() + { + //Listen for changes + while (true) + { + //Wait for changes + WaitForChangeResult changedObject = await client.WaitForChangeAsync(UnloadToken); + + Log.Debug("Object changed {typ} {obj}", changedObject.Status, changedObject.CurrentId); + + switch (changedObject.Status) + { + case ResponseCodes.NotFound: + Log.Warn("Server cache not properly configured, worker exiting"); + return; + case "deleted": + //Delete the object from the store + _ = cacheStore.DeleteItemAsync(changedObject.CurrentId).ConfigureAwait(false); + break; + case "modified": + //Reload the record from the store + await UpdateRecordAsync(changedObject.CurrentId, changedObject.NewId); + break; + } + } + } + + Log.Information("Connected to {server}, starting queue listeners", server.ServerId); + + //Start worker tasks + List<Task> workerTasks = new(); + for(int i = 0; i < Environment.ProcessorCount; i++) + { + workerTasks.Add(Task.Run(BgWorkerAsync)); + } + + //Wait for sync workers to exit + await Task.WhenAll(workerTasks); + } + catch (InvalidResponseException ie) + { + //See if the plugin is unloading + if (!UnloadToken.IsCancellationRequested) + { + Log.Debug("Server responded with invalid response packet, disconnected. reason {reason}", ie); + } + //Disconnect client gracefully + try + { + await client.DisconnectAsync(); + } + catch (Exception ex) + { + Log.Error(ex); + } + } + catch (OperationCanceledException) + { + //Plugin unloading, Try to disconnect + try + { + await client.DisconnectAsync(); + } + catch(Exception ex) + { + Log.Error(ex); + } + } + catch(Exception ex) + { + Log.Warn("Lost connection to server {h}, {m}", server.ServerId, ex); + } + finally + { + //Remove server from active list, since its been disconnected + _ = activeList.TryRemove(server.ServerId, out _); + client.Dispose(); + } + } + + protected override void ProcessHostCommand(string cmd) + { + Log.Debug(cmd); + } + + + #endregion + } +} diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2.dll Binary files differnew file mode 100644 index 0000000..08da729 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2RefDll.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2RefDll.dll Binary files differnew file mode 100644 index 0000000..1201f3c --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Argon2RefDll.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/CacheBroker.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/CacheBroker.dll Binary files differnew file mode 100644 index 0000000..d922fd7 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/CacheBroker.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/McMaster.NETCore.Plugins.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/McMaster.NETCore.Plugins.dll Binary files differnew file mode 100644 index 0000000..3fe7401 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/McMaster.NETCore.Plugins.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Bcl.AsyncInterfaces.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Bcl.AsyncInterfaces.dll Binary files differnew file mode 100644 index 0000000..fe6ba4c --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Bcl.AsyncInterfaces.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.DotNet.PlatformAbstractions.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.DotNet.PlatformAbstractions.dll Binary files differnew file mode 100644 index 0000000..558229b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.DotNet.PlatformAbstractions.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Extensions.DependencyModel.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Extensions.DependencyModel.dll Binary files differnew file mode 100644 index 0000000..921622d --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.Extensions.DependencyModel.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll Binary files differnew file mode 100644 index 0000000..db6416b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.dll Binary files differnew file mode 100644 index 0000000..e0ab0d0 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.TestPlatform.TestFramework.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Threading.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Threading.dll Binary files differnew file mode 100644 index 0000000..c280f69 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Threading.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Validation.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Validation.dll Binary files differnew file mode 100644 index 0000000..87fbc19 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Microsoft.VisualStudio.Validation.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Newtonsoft.Json.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Newtonsoft.Json.dll Binary files differnew file mode 100644 index 0000000..1ffeabe --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Newtonsoft.Json.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/RestSharp.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/RestSharp.dll Binary files differnew file mode 100644 index 0000000..e9220ac --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/RestSharp.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.Sinks.Console.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.Sinks.Console.dll Binary files differnew file mode 100644 index 0000000..eb3745f --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.Sinks.Console.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.dll Binary files differnew file mode 100644 index 0000000..94d38b9 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/Serilog.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/SessionCacheServer.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/SessionCacheServer.dll Binary files differnew file mode 100644 index 0000000..3520982 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/SessionCacheServer.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/System.IO.Pipelines.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/System.IO.Pipelines.dll Binary files differnew file mode 100644 index 0000000..8ee4dfd --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/System.IO.Pipelines.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.dll Binary files differnew file mode 100644 index 0000000..a1d8db6 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.xml new file mode 100644 index 0000000..090c611 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.Extensions.xml @@ -0,0 +1,186 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Data.Caching.Extensions</name> + </assembly> + <members> + <member name="T:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions"> + <summary> + Provides extension methods for FBM data caching using + cache servers and brokers + </summary> + </member> + <member name="F:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.CACHE_WS_SUB_PROCOL"> + <summary> + The websocket sub-protocol to use when connecting to cache servers + </summary> + </member> + <member name="F:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.MAX_FBM_MESSAGE_HEADER_SIZE"> + <summary> + The default cache message header size + </summary> + </member> + <member name="F:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.CacheJwtAlgorithm"> + <summary> + The default hashing algorithm used to sign an verify connection + tokens + </summary> + </member> + <member name="F:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.CacheCurve"> + <summary> + The default ECCurve used by the connection library + </summary> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.GetDefaultConfig(VNLib.Utils.Memory.IUnmangedHeap,System.Int32,VNLib.Utils.Logging.ILogProvider)"> + <summary> + Gets a <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClientConfig"/> preconfigured object caching + protocl + </summary> + <param name="heap">The client buffer heap</param> + <param name="maxMessageSize">The maxium message size (in bytes)</param> + <param name="debugLog">An optional debug log</param> + <returns>A preconfigured <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClientConfig"/> for object caching</returns> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ListServersAsync(System.Uri,System.ReadOnlyMemory{System.Byte},System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)"> + <summary> + Contacts the cache broker to get a list of active servers to connect to + </summary> + <param name="brokerAddress">The broker server to connec to</param> + <param name="clientPrivKey">The private key used to sign messages sent to the broker</param> + <param name="brokerPubKey">The broker public key used to verify broker messages</param> + <param name="cancellationToken">A token to cancel the operationS</param> + <returns>The list of active servers</returns> + <exception cref="T:System.Security.SecurityException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ListServersAsync(System.Uri,System.Security.Cryptography.ECDsa,System.Security.Cryptography.ECDsa,System.Threading.CancellationToken)"> + <summary> + Contacts the cache broker to get a list of active servers to connect to + </summary> + <param name="brokerAddress">The broker server to connec to</param> + <param name="clientAlg">The signature algorithm used to sign messages to the broker</param> + <param name="brokerAlg">The signature used to verify broker messages</param> + <param name="cancellationToken">A token to cancel the operationS</param> + <returns>The list of active servers</returns> + <exception cref="T:System.Security.SecurityException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ConnectAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String,System.ReadOnlyMemory{System.Byte},System.String,System.String,System.Boolean,System.Threading.CancellationToken)"> + <summary> + Configures a connection to the remote cache server at the specified location + with proper authentication. + </summary> + <param name="client"></param> + <param name="serverUri">The server's address</param> + <param name="signingKey">The pks8 format EC private key uesd to sign the message</param> + <param name="challenge">A challenge to send to the server</param> + <param name="nodeId">A token used to identify the current server's event queue on the remote server</param> + <param name="token">A token to cancel the connection operation</param> + <param name="useTls">Enables the secure websocket protocol</param> + <returns>A Task that completes when the connection has been established</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ResgisterWithBrokerAsync(System.Uri,System.ReadOnlyMemory{System.Byte},System.String,System.String,System.String)"> + <summary> + Registers the current server as active with the specified broker + </summary> + <param name="brokerAddress">The address of the broker to register with</param> + <param name="signingKey">The private key used to sign the message</param> + <param name="serverAddress">The local address of the current server used for discovery</param> + <param name="nodeId">The unique id to identify this server (for event queues)</param> + <param name="keepAliveToken">A unique security token used by the broker to authenticate itself</param> + <returns>A task that resolves when a successful registration is completed, raises exceptions otherwise</returns> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ImportClientPrivateKey(VNLib.Net.Messaging.FBM.Client.FBMClient,System.ReadOnlySpan{System.Byte})"> + <summary> + Imports the client signature algorithim's private key from its pkcs8 binary representation + </summary> + <param name="client"></param> + <param name="pkcs8PrivateKey">Pkcs8 format private key</param> + <returns>Chainable fluent object</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ImportBrokerPublicKey(VNLib.Net.Messaging.FBM.Client.FBMClient,System.ReadOnlySpan{System.Byte})"> + <summary> + Imports the public key used to verify broker server messages + </summary> + <param name="client"></param> + <param name="spkiPublicKey">The subject-public-key-info formatted broker public key</param> + <returns>Chainable fluent object</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.UseTls(VNLib.Net.Messaging.FBM.Client.FBMClient,System.Boolean)"> + <summary> + Specifies if all connections should be using TLS + </summary> + <param name="client"></param> + <param name="useTls">A value that indicates if connections should use TLS</param> + <returns>Chainable fluent object</returns> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.UseBroker(VNLib.Net.Messaging.FBM.Client.FBMClient,System.Uri)"> + <summary> + Specifies the broker address to discover cache nodes from + </summary> + <param name="client"></param> + <param name="brokerAddress">The address of the server broker</param> + <returns>Chainable fluent object</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.SetNodeId(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String)"> + <summary> + Specifies the current server's cluster node id. If this + is a server connection attempting to listen for changes on the + remote server, this id must be set and unique + </summary> + <param name="client"></param> + <param name="nodeId">The cluster node id of the current server</param> + <returns>Chainable fluent object</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.DiscoverNodesAsync(VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase,System.Threading.CancellationToken)"> + <summary> + Discovers cache nodes in the broker configured for the current client. + </summary> + <param name="client"></param> + <param name="token">A token to cancel the discovery</param> + <returns>A task the resolves the list of active servers on the broker server</returns> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.DiscoverNodesAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.Threading.CancellationToken)"> + <summary> + Discovers cache nodes in the broker configured for the current client. + </summary> + <param name="client"></param> + <param name="token">A token to cancel the discovery </param> + <returns>A task the resolves the list of active servers on the broker server</returns> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ConnectAndWaitForExitAsync(VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase,VNLib.Data.Caching.Extensions.ActiveServer,System.Threading.CancellationToken)"> + <summary> + Connects the client to a remote cache server + </summary> + <param name="client"></param> + <param name="server">The server to connect to</param> + <param name="token">A token to cancel the connection and/or wait operation</param> + <returns>A task that resolves when cancelled or when the connection is lost to the server</returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.ConnectAndWaitForExitAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,VNLib.Data.Caching.Extensions.ActiveServer,System.Threading.CancellationToken)"> + <summary> + Connects the client to a remote cache server + </summary> + <param name="client"></param> + <param name="server">The server to connect to</param> + <param name="token">A token to cancel the connection and/or wait operation</param> + <returns>A task that resolves when cancelled or when the connection is lost to the server</returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Data.Caching.Extensions.FBMDataCacheExtensions.SelectRandom(System.Collections.Generic.ICollection{VNLib.Data.Caching.Extensions.ActiveServer})"> + <summary> + Selects a random server from a collection of active servers + </summary> + <param name="servers"></param> + <returns>A server selected at random</returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.dll Binary files differnew file mode 100644 index 0000000..6791e56 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.xml new file mode 100644 index 0000000..6c2bc6e --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.ObjectCache.xml @@ -0,0 +1,62 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Data.Caching.ObjectCache</name> + </assembly> + <members> + <member name="T:VNLib.Data.Caching.ObjectCache.ChangeEvent"> + <summary> + An event object that is passed when change events occur + </summary> + </member> + <member name="T:VNLib.Data.Caching.ObjectCache.ObjectCacheStore"> + <summary> + A <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> implementation of a <see cref="T:VNLib.Data.Caching.CacheListener"/> + </summary> + </member> + <member name="P:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.Log"> + <inheritdoc/> + </member> + <member name="P:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.EventQueue"> + <summary> + A queue that stores update and delete events + </summary> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.#ctor(System.IO.DirectoryInfo,System.Int32,VNLib.Utils.Logging.ILogProvider,VNLib.Utils.Memory.IUnmangedHeap,System.Boolean)"> + <summary> + Initialzies a new <see cref="T:VNLib.Data.Caching.ObjectCache.ObjectCacheStore"/> + </summary> + <param name="dir">The <see cref="T:System.IO.DirectoryInfo"/> to store blob files to</param> + <param name="cacheMax"></param> + <param name="log"></param> + <param name="heap"></param> + <param name="singleReader">A value that indicates if a single thread is processing events</param> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.ProcessAsync(VNLib.Net.Messaging.FBM.Server.FBMContext,System.Object,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.DeleteItemAsync(System.String)"> + <summary> + Asynchronously deletes a previously stored item + </summary> + <param name="id">The id of the object to delete</param> + <returns>A task that completes when the item has been deleted</returns> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.AddOrUpdateBlobAsync``1(System.String,System.String,VNLib.Data.Caching.ObjectCache.GetBodyDataCallback{``0},``0)"> + <summary> + Asynchronously adds or updates an object in the store and optionally update's its id + </summary> + <param name="objectId">The current (or old) id of the object</param> + <param name="alternateId">An optional id to update the blob to</param> + <param name="bodyData">A callback that returns the data for the blob</param> + <param name="state">The state parameter to pass to the data callback</param> + <returns></returns> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.ObjectCache.ObjectCacheStore.Dispose"> + <inheritdoc/> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.dll Binary files differnew file mode 100644 index 0000000..99c1b09 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.xml new file mode 100644 index 0000000..71c6a42 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Data.Caching.xml @@ -0,0 +1,286 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Data.Caching</name> + </assembly> + <members> + <member name="T:VNLib.Data.Caching.BlobCache"> + <summary> + A general purpose binary data storage + </summary> + </member> + <member name="P:VNLib.Data.Caching.BlobCache.IsReadOnly"> + <inheritdoc/> + </member> + <member name="P:VNLib.Data.Caching.BlobCache.MaxCapacity"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.#ctor(System.IO.DirectoryInfo,System.Int32,VNLib.Utils.Logging.ILogProvider,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes a new <see cref="T:VNLib.Data.Caching.BlobCache"/> store + </summary> + <param name="swapDir">The <see cref="T:VNLib.Utils.IO.IsolatedStorageDirectory"/> to swap blob data to when cache</param> + <param name="maxCapacity">The maximum number of items to keep in memory</param> + <param name="log">A <see cref="T:VNLib.Utils.Logging.ILogProvider"/> to write log data to</param> + <param name="heap">A <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate buffers and store <see cref="T:VNLib.Data.Caching.BlobItem"/> data in memory</param> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.CacheMiss(System.String,VNLib.Utils.Memory.MemoryHandle{System.Byte}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.Evicted(System.Collections.Generic.KeyValuePair{System.String,VNLib.Utils.Memory.MemoryHandle{System.Byte}})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.TryChangeKey(System.String,System.String,VNLib.Utils.Memory.MemoryHandle{System.Byte}@)"> + <summary> + If the <see cref="T:VNLib.Data.Caching.BlobItem"/> is found in the store, changes the key + that referrences the blob. + </summary> + <param name="currentKey">The key that currently referrences the blob in the store</param> + <param name="newKey">The new key that will referrence the blob</param> + <param name="blob">The <see cref="T:VNLib.Data.Caching.BlobItem"/> if its found in the store</param> + <returns>True if the record was found and the key was changes</returns> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.Remove(System.String)"> + <summary> + Removes the <see cref="T:VNLib.Data.Caching.BlobItem"/> from the store without disposing the blobl + </summary> + <param name="key">The key that referrences the <see cref="T:VNLib.Data.Caching.BlobItem"/> in the store</param> + <returns>A value indicating if the blob was removed</returns> + </member> + <member name="M:VNLib.Data.Caching.BlobCache.Clear"> + <summary> + Removes and disposes all blobl elements in cache (or in the backing store) + </summary> + </member> + <member name="T:VNLib.Data.Caching.BlobItem"> + <summary> + A general purpose binary storage item + </summary> + </member> + <member name="T:VNLib.Data.Caching.CacheListener"> + <summary> + A base implementation of a memory/disk LRU data cache FBM listener + </summary> + </member> + <member name="P:VNLib.Data.Caching.CacheListener.Directory"> + <summary> + The directory swap files will be stored + </summary> + </member> + <member name="P:VNLib.Data.Caching.CacheListener.Cache"> + <summary> + The Cache store to access data blobs + </summary> + </member> + <member name="P:VNLib.Data.Caching.CacheListener.Heap"> + <summary> + The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate buffers from + </summary> + </member> + <member name="M:VNLib.Data.Caching.CacheListener.InitCache(System.IO.DirectoryInfo,System.Int32,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes the <see cref="P:VNLib.Data.Caching.CacheListener.Cache"/> data store + </summary> + <param name="dir">The directory to swap cache records to</param> + <param name="cacheSize">The size of the LRU cache</param> + <param name="heap">The heap to allocate buffers from</param> + </member> + <member name="T:VNLib.Data.Caching.ClientExtensions"> + <summary> + Provides caching extension methods for <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> + </summary> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.GetObjectAsync``1(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String,System.Threading.CancellationToken)"> + <summary> + Gets an object from the server if it exists + </summary> + <typeparam name="T"></typeparam> + <param name="client"></param> + <param name="objectId">The id of the object to get</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A task that completes to return the results of the response payload</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:VNLib.Data.Caching.Exceptions.InvalidStatusException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:VNLib.Net.Messaging.FBM.InvalidResponseException"></exception> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.AddOrUpdateObjectAsync``1(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String,System.String,``0,System.Threading.CancellationToken)"> + <summary> + Updates the state of the object, and optionally updates the ID of the object. The data + parameter is serialized, buffered, and streamed to the remote server + </summary> + <typeparam name="T"></typeparam> + <param name="client"></param> + <param name="objectId">The id of the object to update or replace</param> + <param name="newId">An optional parameter to specify a new ID for the old object</param> + <param name="data">The payload data to serialize and set as the data state of the session</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A task that resolves when the server responds</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:VNLib.Data.Caching.Exceptions.InvalidStatusException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:VNLib.Net.Messaging.FBM.InvalidResponseException"></exception> + <exception cref="T:VNLib.Data.Caching.Exceptions.MessageTooLargeException"></exception> + <exception cref="T:VNLib.Data.Caching.Exceptions.ObjectNotFoundException"></exception> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.DeleteObjectAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String,System.Threading.CancellationToken)"> + <summary> + Asynchronously deletes an object in the remote store + </summary> + <param name="client"></param> + <param name="objectId">The id of the object to update or replace</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A task that resolves when the operation has completed</returns> + <exception cref="T:VNLib.Data.Caching.Exceptions.InvalidStatusException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:VNLib.Net.Messaging.FBM.InvalidResponseException"></exception> + <exception cref="T:VNLib.Data.Caching.Exceptions.ObjectNotFoundException"></exception> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.WaitForChangeAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.Threading.CancellationToken)"> + <summary> + Dequeues a change event from the server event queue for the current connection, or waits until a change happens + </summary> + <param name="client"></param> + <param name="cancellationToken">A token to cancel the deuque operation</param> + <returns>A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> that contains the modified object id and optionally its new id</returns> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.ObjectId(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Gets the Object-id for the request message, or throws an <see cref="T:System.InvalidOperationException"/> if not specified + </summary> + <param name="context"></param> + <returns>The id of the object requested</returns> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.NewObjectId(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Gets the new ID of the object if specified from the request. Null if the request did not specify an id update + </summary> + <param name="context"></param> + <returns>The new ID of the object if speicifed, null otherwise</returns> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.Method(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Gets the request method for the request + </summary> + <param name="context"></param> + <returns>The request method string</returns> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.CloseResponse(VNLib.Net.Messaging.FBM.Server.FBMContext,System.String)"> + <summary> + Closes a response with a status code + </summary> + <param name="context"></param> + <param name="responseCode">The status code to send to the client</param> + </member> + <member name="M:VNLib.Data.Caching.ClientExtensions.SetReconnectPolicy``1(``0,System.TimeSpan,System.Uri)"> + <summary> + Initializes the worker for a reconnect policy and returns an object that can listen for changes + and configure the connection as necessary + </summary> + <param name="worker"></param> + <param name="retryDelay">The amount of time to wait between retries</param> + <param name="serverUri">The uri to reconnect the client to</param> + <returns>A <see cref="T:VNLib.Data.Caching.ClientRetryManager`1"/> for listening for retry events</returns> + </member> + <member name="T:VNLib.Data.Caching.ClientRetryManager`1"> + <summary> + Manages a <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase"/> reconnect policy + </summary> + </member> + <member name="E:VNLib.Data.Caching.ClientRetryManager`1.OnBeforeReconnect"> + <summary> + Raised before client is to be reconnected + </summary> + </member> + <member name="E:VNLib.Data.Caching.ClientRetryManager`1.OnReconnectFailed"> + <summary> + Raised when the client fails to reconnect. Should return a value that instructs the + manager to reconnect + </summary> + </member> + <member name="M:VNLib.Data.Caching.ClientRetryManager`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Data.Caching.Constants.Actions"> + <summary> + Contains constants the define actions + </summary> + </member> + <member name="T:VNLib.Data.Caching.Constants.ResponseCodes"> + <summary> + Containts constants for operation response codes + </summary> + </member> + <member name="T:VNLib.Data.Caching.Exceptions.InvalidStatusException"> + <summary> + Raised when the response status code of an FBM Request message is not valid for + the specified request + </summary> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.InvalidStatusException.#ctor(System.String,System.String)"> + <summary> + Initalizes a new <see cref="T:VNLib.Data.Caching.Exceptions.InvalidStatusException"/> with the specfied status code + </summary> + <param name="message"></param> + <param name="statusCode"></param> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.InvalidStatusException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.InvalidStatusException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.InvalidStatusException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Data.Caching.Exceptions.InvalidStatusException.Message"> + <inheritdoc/> + </member> + <member name="T:VNLib.Data.Caching.Exceptions.MessageTooLargeException"> + <summary> + Raised when a request (or server response) calculates the size of the message to be too large to proccess + </summary> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.MessageTooLargeException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.MessageTooLargeException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.MessageTooLargeException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Data.Caching.Exceptions.MessageTooLargeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Data.Caching.Exceptions.ObjectNotFoundException"> + <summary> + Raised when a command was executed on a desired object in the remote cache + but the object was not found + </summary> + </member> + <member name="T:VNLib.Data.Caching.WaitForChangeResult"> + <summary> + The result of a cache server change event + </summary> + </member> + <member name="P:VNLib.Data.Caching.WaitForChangeResult.Status"> + <summary> + The operation status code + </summary> + </member> + <member name="P:VNLib.Data.Caching.WaitForChangeResult.CurrentId"> + <summary> + The current (or old) id of the element that changed + </summary> + </member> + <member name="P:VNLib.Data.Caching.WaitForChangeResult.NewId"> + <summary> + The new id of the element that changed + </summary> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.dll Binary files differnew file mode 100644 index 0000000..a1e0489 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.xml new file mode 100644 index 0000000..aa48b12 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Hashing.Portable.xml @@ -0,0 +1,889 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Hashing.Portable</name> + </assembly> + <members> + <member name="T:VNLib.Hashing.VnArgon2"> + <summary> + Implements the Argon2 data hashing library in .NET for windows + </summary> + <remarks>Buffers are allocted on an internal <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> with the <see cref="F:VNLib.Utils.Memory.PrivateHeap.HEAP_ZERO_MEMORY"/> flag set.</remarks> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Hash2id(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte},System.UInt32,System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Hashes a password with a salt and specified arguments + </summary> + <param name="password">Span of characters containing the password to be hashed</param> + <param name="salt">Span of characters contating the salt to include in the hashing</param> + <param name="secret">Optional secret to include in hash</param> + <param name="hashLen">Size of the hash in bytes</param> + <param name="mem_cost">Memory cost</param> + <param name="parallelism">Degree of parallelism</param> + <param name="time_cost">Time cost of operation</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.InsufficientMemoryException"></exception> + <returns>A <see cref="P:System.Text.Encoding.Unicode"/> <see cref="T:System.String"/> containg the ready-to-store hash</returns> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Hash2id(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.UInt32,System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Hashes a password with a salt and specified arguments + </summary> + <param name="password">Span of characters containing the password to be hashed</param> + <param name="salt">Span of characters contating the salt to include in the hashing</param> + <param name="secret">Optional secret to include in hash</param> + <param name="hashLen">Size of the hash in bytes</param> + <param name="mem_cost">Memory cost</param> + <param name="parallelism">Degree of parallelism</param> + <param name="time_cost">Time cost of operation</param> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.InsufficientMemoryException"></exception> + <returns>A <see cref="P:System.Text.Encoding.Unicode"/> <see cref="T:System.String"/> containg the ready-to-store hash</returns> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Hash2id(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.UInt32,System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Hashes a password with a salt and specified arguments + </summary> + <param name="password">Span of characters containing the password to be hashed</param> + <param name="salt">Span of characters contating the salt to include in the hashing</param> + <param name="secret">Optional secret to include in hash</param> + <param name="hashLen">Size of the hash in bytes</param> + <param name="mem_cost">Memory cost</param> + <param name="parallelism">Degree of parallelism</param> + <param name="time_cost">Time cost of operation</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <returns>A <see cref="P:System.Text.Encoding.Unicode"/> <see cref="T:System.String"/>containg the ready-to-store hash</returns> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Hash2id(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.Span{System.Byte}@,System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Exposes the raw Argon2-ID hashing api to C#, using spans (pins memory references) + </summary> + <param name="password">Span of characters containing the password to be hashed</param> + <param name="rawHashOutput">The output buffer to store the raw hash output</param> + <param name="salt">Span of characters contating the salt to include in the hashing</param> + <param name="secret">Optional secret to include in hash</param> + <param name="mem_cost">Memory cost</param> + <param name="parallelism">Degree of parallelism</param> + <param name="time_cost">Time cost of operation</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Verify2id(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Compares a raw password, with a salt to a raw hash + </summary> + <param name="rawPass">Password bytes</param> + <param name="salt">Salt bytes</param> + <param name="secret">Optional secret that was included in hash</param> + <param name="hashBytes">Raw hash bytes</param> + <param name="time_cost">Time cost</param> + <param name="mem_cost">Memory cost</param> + <param name="parallelism">Degree of parallelism</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.InsufficientMemoryException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2PasswordFormatException"></exception> + <returns>True if hashes match</returns> + </member> + <member name="M:VNLib.Hashing.VnArgon2.Verify2id(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte})"> + <summary> + Compares a password to a previously hashed password from this library + </summary> + <param name="rawPass">Password data</param> + <param name="secret">Optional secret that was included in hash</param> + <param name="hash">Full hash span</param> + <param name="hashLen">Length of hash</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.InsufficientMemoryException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2PasswordFormatException"></exception> + <returns>True if the password matches the hash</returns> + </member> + <member name="T:VNLib.Hashing.VnArgon2Exception"> + <summary> + Argon2 operational exception + </summary> + </member> + <member name="P:VNLib.Hashing.VnArgon2Exception.Errno"> + <summary> + Argon2 error code that caused this exception + </summary> + </member> + <member name="T:VNLib.Hashing.VnArgon2PasswordFormatException"> + <summary> + Raised if a verify operation determined the supplied password hash is not in a valid format for this library + </summary> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.HashingExtensions"> + <summary> + Contains .NET cryptography hasing library extensions + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.HashingExtensions.ComputeBase64Hash(System.Security.Cryptography.HMAC,System.ReadOnlySpan{System.Char},System.Text.Encoding)"> + <summary> + Computes the Base64 hash of the specified data using the + specified character encoding, or <see cref="P:System.Text.Encoding.UTF8"/> + by default. + </summary> + <param name="hmac"></param> + <param name="data">The data to compute the hash of</param> + <param name="encoding">The <see cref="T:System.Text.Encoding"/> used to encode the character buffer</param> + <returns>The base64 UTF8 string of the computed hash of the specified data</returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.HashingExtensions.VerifyBase64Hash(System.Security.Cryptography.HMAC,System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char},System.Text.Encoding)"> + <summary> + Computes the hash of the raw data and compares the computed hash against + the specified base64hash + </summary> + <param name="hmac"></param> + <param name="raw">The raw data buffer (encoded characters) to decode and compute the hash of</param> + <param name="base64Hmac">The base64 hash to verify against</param> + <param name="encoding">The encoding used to encode the raw data balue</param> + <returns>A value indicating if the hash values match</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.HashingExtensions.VerifyHash(System.Security.Cryptography.HMAC,System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})"> + <summary> + Computes the hash of the raw data and compares the computed hash against + the specified hash + </summary> + <param name="hmac"></param> + <param name="raw">The raw data to verify the hash of</param> + <param name="hash">The hash to compare against the computed data</param> + <returns>A value indicating if the hash values match</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.HashingExtensions.TryEncrypt(System.Security.Cryptography.RSA,System.ReadOnlySpan{System.Char},System.Span{System.Byte}@,System.Security.Cryptography.RSAEncryptionPadding,System.Text.Encoding)"> + <summary> + Attempts to encrypt the specified character buffer using the specified encoding + </summary> + <param name="alg"></param> + <param name="data">The data to encrypt</param> + <param name="output">The output buffer</param> + <param name="padding">The encryption padding to use</param> + <param name="enc">Character encoding used to encode the character buffer</param> + <returns>The number of bytes encrypted, or 0/false otherwise</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.JsonWebKey"> + <summary> + A mutable RFC compliant JsonWebKey, that contains a variable length of + single keys. + </summary> + </member> + <member name="F:VNLib.Hashing.IdentityUtility.JsonWebKey.JWK_RFC_VERSION"> + <summary> + The RFC version that the <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> + compiles with + </summary> + </member> + <member name="F:VNLib.Hashing.IdentityUtility.JsonWebKey._keys"> + <summary> + The internal collection of single keys + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.#ctor(System.Nullable{System.Int32})"> + <summary> + Initializes a new <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> with the + specified capacity + </summary> + <param name="capacity">The initial capacity of the internal key collection</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Parse(System.String)"> + <summary> + Parses the supplied JSON string + which compiles to the JWK RFC version into + its mutable memory representation + </summary> + <param name="jsonData">The JSON string buffer</param> + <returns>The <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> from the parsed JSON</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Parse(System.ReadOnlySpan{System.Char})"> + <summary> + Parses the supplied character buffer + which compiles to the JWK RFC version into + its mutable memory representation + </summary> + <param name="jsonData">The JSON string buffer</param> + <returns>The <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> from the parsed JSON</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Parse(System.ReadOnlySpan{System.Byte})"> + <summary> + Parses the supplied utf8 buffer + which compiles to the JWK RFC version into + its mutable memory representation + </summary> + <param name="utf8Json">The utf8 encoded JSON data</param> + <returns>The <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> from the parsed JSON</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Parse(System.Text.Json.JsonElement@)"> + <summary> + Parses the supplied <see cref="T:System.Text.Json.JsonElement"/> + which compiles to the JWK RFC version into + its mutable memory representation + </summary> + <param name="root">The root element that contains the JWT object</param> + <returns>The <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebKey"/> from the parsed JSON</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebKey.Count"> + <summary> + The number of stored keys + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebKey.Item(System.Int32)"> + <summary> + Gets the key at the specified index + </summary> + <param name="index">The index of the key to get</param> + <returns>The key at the specified index</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.AddKey(System.String,System.String,System.String)"> + <summary> + Adds a new key to the collection + </summary> + <param name="alg">The algorithm type</param> + <param name="use">The intended use of the key</param> + <param name="kid">The optional key id</param> + <returns>The newly added <see cref="T:VNLib.Hashing.IdentityUtility.JWKSingleKey"/></returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.System#Collections#IEnumerable#GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Clear"> + <summary> + Empties and removes all keys + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Compile(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Compiles the JWK to the RFC compliant string + </summary> + <param name="stream">The memory stream to write the compiled data to</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Compile"> + <summary> + Compiles the JWK array into the RFC format + and write the output to the specified writer + </summary> + <returns></returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Compile(VNLib.Utils.Memory.ForwardOnlyWriter{System.Char}@)"> + <summary> + Compiles the JWK array into the RFC format + and write the output to the specified writer + </summary> + <param name="writer">The FOW to write json string to</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebKey.Compile(System.Span{System.Char}@)"> + <summary> + Compiles the JWK array into the RFC format + and write the output to the specified character buffer + </summary> + <param name="buffer">The character buffer to write data do</param> + <returns>The number of characters written to the buffer</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.JsonWebToken"> + <summary> + Provides a dynamic JSON Web Token class that will store and + compute Base64Url encoded WebTokens + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Parse(System.ReadOnlySpan{System.Char},VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Parses a JWT from a Base64URL encoded character buffer + </summary> + <param name="urlEncJwtString"></param> + <param name="heap">An optional <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> instance to alloc buffers from</param> + <returns>The parses <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/></returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Parse(System.ReadOnlySpan{System.Byte},VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Parses a buffer of UTF8 bytes of Base64URL encoded characters + </summary> + <param name="urlEncodedUtf8">The url-encoded base64 JWT data buffer</param> + <param name="heap">An optional <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> instance to alloc buffers from</param> + <returns>The parsed <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/></returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.ParseRaw(System.ReadOnlySpan{System.Byte},VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Parses a buffer of UTF8 bytes of NON url encoded base64 characters + </summary> + <param name="utf8JWTData">The JWT data buffer</param> + <param name="heap">An optional <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> instance to alloc buffers from</param> + <returns>The parsed <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/></returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.Heap"> + <summary> + The heap used to allocate buffers from + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.ByteSize"> + <summary> + The size (in bytes) of the encoded data that makes + up the current JWT. + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.CurrentBuffer"> + <summary> + A buffer that represents the current state of the JWT buffer + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.#ctor(VNLib.Utils.Memory.IUnmangedHeap,VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Creates a new <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/> with the specified initial state + </summary> + <param name="heap">The heap used to alloc buffers</param> + <param name="initialData">The initial data of the jwt</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.#ctor(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Creates a new empty JWT instance, with an optional heap to alloc + buffers from. (<see cref="P:VNLib.Utils.Memory.Memory.Shared"/> is used as default) + </summary> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to alloc buffers from</param> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.HeaderData"> + <summary> + The Base64 encoded UTF8 bytes of the header portion of the current JWT + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.WriteHeader(System.ReadOnlySpan{System.Byte})"> + <summary> + Encodes and stores the specified header value to the begining of the + JWT. This method may only be called once, if the header has not already been supplied. + </summary> + <param name="header">The value of the JWT header parameter</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.PayloadData"> + <summary> + The Base64 encoded UTF8 bytes of the payload portion of the current JWT + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.HeaderAndPayload"> + <summary> + The Base64 encoded UTF8 bytes of the header + '.' + palyad portion of the current jwt + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.WritePayload(System.ReadOnlySpan{System.Byte})"> + <summary> + Encodes and stores the specified payload data and appends it to the current + JWT buffer. This method may only be called once, if the header has not already been supplied. + </summary> + <param name="payload">The value of the JWT payload section</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.WriteValue(System.ReadOnlySpan{System.Byte})"> + <summary> + Encodes the specified value and writes it to the + internal buffer + </summary> + <param name="value">The data value to encode and buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JsonWebToken.SignatureData"> + <summary> + The Base64Url encoded UTF8 bytes of the signature portion of the current JWT + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Sign(System.Security.Cryptography.HashAlgorithm)"> + <summary> + Signs the current JWT (header + payload) data + and writes the signature the end of the current buffer, + using the specified <see cref="T:System.Security.Cryptography.HashAlgorithm"/>. + </summary> + <param name="signatureAlgorithm">An alternate <see cref="T:System.Security.Cryptography.HashAlgorithm"/> instance to sign the JWT with</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Sign(System.Security.Cryptography.RSA,System.Security.Cryptography.HashAlgorithmName@,System.Security.Cryptography.RSASignaturePadding,System.Int32)"> + <summary> + Use an RSA algorithm to sign the JWT message + </summary> + <param name="rsa">The algorithm used to sign the token</param> + <param name="hashAlg">The hash algorithm to use</param> + <param name="padding">The signature padding to use</param> + <param name="hashSize">The size (in bytes) of the hash output</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Sign(System.Security.Cryptography.ECDsa,System.Security.Cryptography.HashAlgorithmName@,System.Int32)"> + <summary> + Use an RSA algorithm to sign the JWT message + </summary> + <param name="alg">The algorithm used to sign the token</param> + <param name="hashAlg">The hash algorithm to use</param> + <param name="hashSize">The size (in bytes) of the hash output</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Compile"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Compile(VNLib.Utils.Memory.ForwardOnlyWriter{System.Char}@)"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Compile(System.Span{System.Char}@)"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Reset"> + <summary> + Reset's the internal JWT buffer + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.ToString"> + <summary> + Compiles the current JWT instance and converts it to a string + </summary> + <returns>A Base64Url enocded string of the JWT format</returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JsonWebToken.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.JWKSingleKey"> + <summary> + A structure containing properies/methods for reading/manipulating + a single JsonWebKey + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JWKSingleKey.Algorithm"> + <summary> + The key algorithm + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JWKSingleKey.KeyId"> + <summary> + The optional id of the key + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JWKSingleKey.Use"> + <summary> + The intended use of the key + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JWKSingleKey.KeyType"> + <summary> + The JWK key type + </summary> + </member> + <member name="P:VNLib.Hashing.IdentityUtility.JWKSingleKey.Item(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.Clear"> + <summary> + Removes all JWK properties + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.ToString"> + <summary> + Returns a JSON encoded string of the key object + </summary> + <returns>The JSON string representation of the key</returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.Prune"> + <summary> + Removes null values from the key + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.Write(System.Text.Json.Utf8JsonWriter)"> + <summary> + Serializes the current state to its JSON representation + and writes it to the writer + </summary> + <param name="writer">The <see cref="T:System.Text.Json.Utf8JsonWriter"/> to write serialzed data to</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.GetHashCode"> + <inheritdoc/> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.Equals(VNLib.Hashing.IdentityUtility.JWKSingleKey)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JWKSingleKey.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.JwtPayload"> + <summary> + A fluent api structure for adding and committing claims to a <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/> + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtPayload.AddClaim(System.String,System.Object)"> + <summary> + Adds a claim name-value pair to the store + </summary> + <param name="claim">The clame name</param> + <param name="value">The value of the claim</param> + <returns>The chained response object</returns> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtPayload.CommitClaims"> + <summary> + Writes all claims to the <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/> payload segment + </summary> + </member> + <member name="T:VNLib.Hashing.IdentityUtility.JwtExtensions"> + <summary> + Provides extension methods for manipulating + and verifying <see cref="T:VNLib.Hashing.IdentityUtility.JsonWebToken"/>s + </summary> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.WriteHeader``1(VNLib.Hashing.IdentityUtility.JsonWebToken,``0,System.Text.Json.JsonSerializerOptions)"> + <summary> + Writes the message header as the specified object + </summary> + <typeparam name="T"></typeparam> + <param name="jwt"></param> + <param name="header">The header object</param> + <param name="jso">Optional serialize options</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.WritePayload``1(VNLib.Hashing.IdentityUtility.JsonWebToken,``0,System.Text.Json.JsonSerializerOptions)"> + <summary> + Writes the message payload as the specified object + </summary> + <typeparam name="T"></typeparam> + <param name="jwt"></param> + <param name="payload">The payload object</param> + <param name="jso">Optional serialize options</param> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.GetPayload(VNLib.Hashing.IdentityUtility.JsonWebToken)"> + <summary> + Gets the body data as a <see cref="T:System.Text.Json.JsonDocument"/> + </summary> + <param name="jwt"></param> + <returns>The <see cref="T:System.Text.Json.JsonDocument"/> of the jwt body</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.GetPayload``1(VNLib.Hashing.IdentityUtility.JsonWebToken,System.Text.Json.JsonSerializerOptions)"> + <summary> + Deserialzes the jwt payload as the specified object + </summary> + <param name="jwt"></param> + <param name="jso">Optional serialzie options</param> + <returns>The <see cref="T:System.Text.Json.JsonDocument"/> of the jwt body</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.Verify(VNLib.Hashing.IdentityUtility.JsonWebToken,System.Security.Cryptography.HashAlgorithm)"> + <summary> + Verifies the current JWT body-segements against the parsed signature segment. + </summary> + <param name="jwt"></param> + <param name="verificationAlg"> + The <see cref="T:System.Security.Cryptography.HashAlgorithm"/> to use when calculating the hash of the JWT + </param> + <returns> + True if the signature field of the current JWT matches the re-computed signature of the header and data-fields + signature + </returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.Verify(VNLib.Hashing.IdentityUtility.JsonWebToken,System.Security.Cryptography.RSA,System.Security.Cryptography.HashAlgorithmName,System.Security.Cryptography.RSASignaturePadding)"> + <summary> + Verifies the signature of the data using the specified <see cref="T:System.Security.Cryptography.RSA"/> and hash parameters + </summary> + <param name="jwt"></param> + <param name="alg">The RSA algorithim to use while verifying the signature of the payload</param> + <param name="hashAlg">The <see cref="T:System.Security.Cryptography.HashAlgorithmName"/> used to hash the signature</param> + <param name="padding">The RSA signature padding method</param> + <returns>True if the singature has been verified, false otherwise</returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.Verify(VNLib.Hashing.IdentityUtility.JsonWebToken,System.Security.Cryptography.ECDsa,System.Security.Cryptography.HashAlgorithmName)"> + <summary> + Verifies the signature of the data using the specified <see cref="T:System.Security.Cryptography.RSA"/> and hash parameters + </summary> + <param name="jwt"></param> + <param name="alg">The RSA algorithim to use while verifying the signature of the payload</param> + <param name="hashAlg">The <see cref="T:System.Security.Cryptography.HashAlgorithmName"/> used to hash the signature</param> + <returns>True if the singature has been verified, false otherwise</returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Hashing.IdentityUtility.JwtExtensions.InitPayloadClaim(VNLib.Hashing.IdentityUtility.JsonWebToken,System.Int32)"> + <summary> + Initializes a new <see cref="T:VNLib.Hashing.IdentityUtility.JwtPayload"/> object for writing claims to the + current tokens payload segment + </summary> + <param name="jwt"></param> + <param name="initCapacity">The inital cliam capacity</param> + <returns>The fluent chainable stucture</returns> + </member> + <member name="T:VNLib.Hashing.HashEncodingMode"> + <summary> + The binary hash encoding type + </summary> + </member> + <member name="F:VNLib.Hashing.HashEncodingMode.Base64"> + <summary> + Specifies the Base64 character encoding + </summary> + </member> + <member name="F:VNLib.Hashing.HashEncodingMode.Hexadecimal"> + <summary> + Specifies the hexadecimal character encoding + </summary> + </member> + <member name="F:VNLib.Hashing.HashEncodingMode.Base32"> + <summary> + Specifies the Base32 character encoding + </summary> + </member> + <member name="T:VNLib.Hashing.ManagedHash"> + <summary> + Provides simple methods for common managed hashing functions + </summary> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Char},System.Span{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Uses the UTF8 character encoding to encode the string, then + attempts to compute the hash and store the results into the output buffer + </summary> + <param name="data">String to hash</param> + <param name="buffer">The hash output buffer</param> + <param name="type">The hash algorithm to use</param> + <returns>The number of bytes written to the buffer, false if the hash could not be computed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Char},VNLib.Hashing.HashAlg)"> + <summary> + Uses the UTF8 character encoding to encode the string, then + attempts to compute the hash and store the results into the output buffer + </summary> + <param name="data">String to hash</param> + <param name="type">The hash algorithm to use</param> + <returns>The number of bytes written to the buffer, false if the hash could not be computed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Hashes the data parameter to the output buffer using the specified algorithm type + </summary> + <param name="data">String to hash</param> + <param name="output">The hash output buffer</param> + <param name="type">The hash algorithm to use</param> + <returns>The number of bytes written to the buffer, <see cref="F:VNLib.Utils.ERRNO.E_FAIL"/> if the hash could not be computed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Hashes the data parameter to the output buffer using the specified algorithm type + </summary> + <param name="data">String to hash</param> + <param name="type">The hash algorithm to use</param> + <returns>A byte array that contains the hash of the data buffer</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Byte},VNLib.Hashing.HashAlg,VNLib.Hashing.HashEncodingMode)"> + <summary> + Hashes the data parameter to the output buffer using the specified algorithm type + </summary> + <param name="data">String to hash</param> + <param name="type">The hash algorithm to use</param> + <param name="mode">The data encoding mode</param> + <returns>The encoded hash of the input data</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHash(System.ReadOnlySpan{System.Char},VNLib.Hashing.HashAlg,VNLib.Hashing.HashEncodingMode)"> + <summary> + Uses the UTF8 character encoding to encode the string, then computes the hash and encodes + the hash to the specified encoding + </summary> + <param name="data">String to hash</param> + <param name="type">The hash algorithm to use</param> + <param name="mode">The data encoding mode</param> + <returns>The encoded hash of the input data</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char},System.Span{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Computes the HMAC of the specified character buffer using the specified key and + writes the resuts to the output buffer. + </summary> + <param name="key">The HMAC key</param> + <param name="data">The character buffer to compute the encoded HMAC of</param> + <param name="output">The buffer to write the hash to</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <returns>The number of bytes written to the ouput buffer or <see cref="F:VNLib.Utils.ERRNO.E_FAIL"/> if the operation failed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char},VNLib.Hashing.HashAlg)"> + <summary> + Computes the HMAC of the specified character buffer using the specified key and + writes the resuts to a new buffer to return + </summary> + <param name="key">The HMAC key</param> + <param name="data">The data buffer to compute the HMAC of</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <returns>A buffer containg the computed HMAC</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.Span{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Computes the HMAC of the specified data buffer using the specified key and + writes the resuts to the output buffer. + </summary> + <param name="key">The HMAC key</param> + <param name="data">The data buffer to compute the HMAC of</param> + <param name="output">The buffer to write the hash to</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <returns>The number of bytes written to the ouput buffer or <see cref="F:VNLib.Utils.ERRNO.E_FAIL"/> if the operation failed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},VNLib.Hashing.HashAlg)"> + <summary> + Computes the HMAC of the specified data buffer using the specified key and + writes the resuts to a new buffer to return + </summary> + <param name="key">The HMAC key</param> + <param name="data">The data buffer to compute the HMAC of</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <returns>A buffer containg the computed HMAC</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},VNLib.Hashing.HashAlg,VNLib.Hashing.HashEncodingMode)"> + <summary> + Computes the HMAC of the specified data buffer and encodes the result in + the specified <see cref="T:VNLib.Hashing.HashEncodingMode"/> + </summary> + <param name="key">The HMAC key</param> + <param name="data">The data buffer to compute the HMAC of</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <param name="mode">The encoding type for the output data</param> + <returns>The encoded string of the result</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Hashing.ManagedHash.ComputeHmac(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Char},VNLib.Hashing.HashAlg,VNLib.Hashing.HashEncodingMode)"> + <summary> + Computes the HMAC of the specified data buffer and encodes the result in + the specified <see cref="T:VNLib.Hashing.HashEncodingMode"/> + </summary> + <param name="key">The HMAC key</param> + <param name="data">The character buffer to compute the HMAC of</param> + <param name="type">The <see cref="T:VNLib.Hashing.HashAlg"/> type used to compute the HMAC</param> + <param name="mode">The encoding type for the output data</param> + <returns>The encoded string of the result</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Hashing.RandomHash"> + <summary> + Produces random cryptographic data in common formats + </summary> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomHash(VNLib.Hashing.HashAlg,System.Int32,VNLib.Hashing.HashEncodingMode)"> + <summary> + Generates a cryptographic random number, computes the hash, and encodes the hash as a string. + </summary> + <param name="alg">The hash algorithm to use when computing the hash</param> + <param name="size">Number of random bytes</param> + <param name="encoding"></param> + <returns>String containing hash of the random number</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetGuidHash(VNLib.Hashing.HashAlg,VNLib.Hashing.HashEncodingMode)"> + <summary> + Gets the sha512 hash of a new GUID + </summary> + <returns>String containing hash of the GUID</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetSecureGuid"> + <summary> + Generates a secure random number and seeds a GUID object, then returns the string GUID + </summary> + <returns>Guid string</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomBase64(System.Int32)"> + <summary> + Generates a cryptographic random number and returns the base64 string of that number + </summary> + <param name="size">Number of random bytes</param> + <returns>Base64 string of the random number</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomHex(System.Int32)"> + <summary> + Generates a cryptographic random number and returns the hex string of that number + </summary> + <param name="size">Number of random bytes</param> + <returns>Hex string of the random number</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomBase32(System.Int32)"> + <summary> + Generates a cryptographic random number and returns the Base32 encoded string of that number + </summary> + <param name="size">Number of random bytes</param> + <returns>Base32 string of the random number</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomBytes(System.Int32)"> + <summary> + Allocates a new byte[] of the specified size and fills it with non-zero random values + </summary> + <param name="size">Number of random bytes</param> + <returns>byte[] containing the random data</returns> + </member> + <member name="M:VNLib.Hashing.RandomHash.GetRandomBytes(System.Span{System.Byte})"> + <summary> + Fill the buffer with non-zero bytes + </summary> + <param name="data">Buffer to fill</param> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.dll Binary files differnew file mode 100644 index 0000000..ec9ec51 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.xml new file mode 100644 index 0000000..8bb970c --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Http.xml @@ -0,0 +1,1615 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Net.Http</name> + </assembly> + <members> + <member name="T:VNLib.Net.FileUpload"> + <summary> + Represents an file that was received as an entity body, either using Multipart/FormData or as the entity body itself + </summary> + </member> + <member name="F:VNLib.Net.FileUpload.ContentType"> + <summary> + Content type of uploaded file + </summary> + </member> + <member name="F:VNLib.Net.FileUpload.FileName"> + <summary> + Name of file uploaded + </summary> + </member> + <member name="F:VNLib.Net.FileUpload.FileData"> + <summary> + The file data captured on upload + </summary> + </member> + <member name="M:VNLib.Net.FileUpload.FromString(System.ReadOnlySpan{System.Char},System.Text.Encoding,System.String,VNLib.Net.ContentType)"> + <summary> + Allocates a new binary buffer, encodes, and copies the specified data to a new <see cref="T:VNLib.Net.FileUpload"/> + structure of the specified content type + </summary> + <param name="data">The string data to copy</param> + <param name="dataEncoding">The encoding instance to encode the string data from</param> + <param name="filename">The name of the file</param> + <param name="ct">The content type of the file data</param> + <returns>The <see cref="T:VNLib.Net.FileUpload"/> container</returns> + </member> + <member name="M:VNLib.Net.FileUpload.Free"> + <summary> + Releases any memory the current instance holds if it owns the handles + </summary> + </member> + <member name="T:VNLib.Net.Http.AlternateProtocolBase"> + <summary> + A base class for all non-http protocol handlers + </summary> + </member> + <member name="P:VNLib.Net.Http.AlternateProtocolBase.CancelSource"> + <summary> + A cancelation source that allows for canceling running tasks, that is linked + to the server that called <see cref="M:VNLib.Net.Http.AlternateProtocolBase.RunAsync(System.IO.Stream)"/>. + </summary> + <remarks> + This property is only available while the <see cref="M:VNLib.Net.Http.AlternateProtocolBase.RunAsync(System.IO.Stream)"/> + method is executing + </remarks> + </member> + <member name="M:VNLib.Net.Http.AlternateProtocolBase.VNLib#Net#Http#IAlternateProtocol#RunAsync(System.IO.Stream,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.AlternateProtocolBase.IsSecure"> + <summary> + Is the current socket connected using transport security + </summary> + </member> + <member name="P:VNLib.Net.Http.AlternateProtocolBase.IsCancellationRequested"> + <summary> + Determines if the instance is pending cancelation + </summary> + </member> + <member name="M:VNLib.Net.Http.AlternateProtocolBase.CancelAll"> + <summary> + Cancels all pending operations. This session will be unusable after this function is called + </summary> + </member> + <member name="M:VNLib.Net.Http.AlternateProtocolBase.RunAsync(System.IO.Stream)"> + <summary> + Called when the protocol swtich handshake has completed and the transport is + available for the new protocol + </summary> + <param name="transport">The transport stream</param> + <returns>A task that represents the active use of the transport, and when complete all operations are unwound</returns> + </member> + <member name="T:VNLib.Net.Http.ConnectionInfo"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.RequestUri"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Path"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.UserAgent"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Headers"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.CrossOrigin"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.IsWebSocketRequest"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.ContentType"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Method"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.ProtocolVersion"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.IsSecure"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.SecurityProtocol"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Origin"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Referer"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Range"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.LocalEndpoint"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.RemoteEndpoint"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Encoding"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.RequestCookies"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.Accept"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.ConnectionInfo.TransportSecurity"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.ConnectionInfo.Accepts(VNLib.Net.ContentType)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.ConnectionInfo.Accepts(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.ConnectionInfo.AcceptsAny"> + <summary> + Determines if the connection accepts any content type + </summary> + <returns>true if the connection accepts any content typ, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.ConnectionInfo.SetCookie(System.String,System.String,System.String,System.String,System.TimeSpan,VNLib.Net.Http.CookieSameSite,System.Boolean,System.Boolean)"> + <inheritdoc/> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.COMPRESSION_DISABLED_MSK"> + <summary> + When set as a response flag, disables response compression for + the current request/response flow + </summary> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.Request"> + <summary> + The reusable http request container + </summary> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.Response"> + <summary> + The reusable response controler + </summary> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.ParentServer"> + <summary> + The http server that this context is bound to + </summary> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.ContextFlags"> + <summary> + A collection of flags that can be used to control the way the context + responds to client requests + </summary> + </member> + <member name="F:VNLib.Net.Http.Core.HttpContext.ResponseData"> + <summary> + The data stream to send to the client request when closing + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.HttpContext.Encoding"> + <summary> + The default encoding type to use for encoding http data + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.HttpContext.ServerConfig"> + <summary> + Gets a referrence to the configuration of the server that is processing + the current requests + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.WriteResponseInternalAsync(System.Int32,System.Threading.CancellationToken)"> + <summary> + If implementing application set a response entity body, it is written to the output stream + </summary> + <param name="sendBufferSize">The size of the buffer to use when copying data to the stream</param> + <param name="token">A token to cancel the operation</param> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.InitializeContext(VNLib.Net.Http.ITransportContext)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.BeginRequest"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.WriteResponseAsync(System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.ReleaseContext"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContext.EndRequest"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Http.Core.IConnectionContext"> + <summary> + A request-response stream oriented connection state + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.IConnectionContext.InitializeContext(VNLib.Net.Http.ITransportContext)"> + <summary> + Initializes the context to work with the specified + transport context + </summary> + <param name="tranpsort">A referrence to the transport context to use</param> + </member> + <member name="M:VNLib.Net.Http.Core.IConnectionContext.BeginRequest"> + <summary> + Signals the context that it should prepare to process a new request + for the current transport + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.IConnectionContext.WriteResponseAsync(System.Int32,System.Threading.CancellationToken)"> + <summary> + Sends any pending data associated with the request to the + connection that begun the request + </summary> + <param name="bufferSize">The size of the buffer used to buffer data to the transport</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A Task that completes when the response has completed</returns> + </member> + <member name="M:VNLib.Net.Http.Core.IConnectionContext.EndRequest"> + <summary> + Signals to the context that it will release any request specific + resources + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.IConnectionContext.ReleaseContext"> + <summary> + Signals that the context will no-longer be attached to an active transport + and should cleanup connection associated resources + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.Http11ParseExtensions.Http1ParseRequestLine(VNLib.Net.Http.Core.HttpRequest,VNLib.Net.Http.Core.Http11ParseExtensions.Http1ParseState@,VNLib.Net.Http.Core.TransportReader@,System.Span{System.Char}@)"> + <summary> + Reads the first line from the transport stream using the specified buffer + and parses the HTTP request line components: Method, resource, Http Version + </summary> + <param name="Request"></param> + <param name="reader">The reader to read lines from the transport</param> + <param name="parseState">The HTTP1 parsing state</param> + <param name="lineBuf">The buffer to use when parsing the request data</param> + <returns>0 if the request line was successfully parsed, a status code if the request could not be processed</returns> + <exception cref="T:System.UriFormatException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.Http11ParseExtensions.Http1ParseHeaders(VNLib.Net.Http.Core.HttpRequest,VNLib.Net.Http.Core.Http11ParseExtensions.Http1ParseState@,VNLib.Net.Http.Core.TransportReader@,VNLib.Net.Http.HttpConfig@,System.Span{System.Char}@)"> + <summary> + Reads headers from the transport using the supplied character buffer, and updates the current request + </summary> + <param name="Request"></param> + <param name="parseState">The HTTP1 parsing state</param> + <param name="Config">The current server <see cref="T:VNLib.Net.Http.HttpConfig"/></param> + <param name="reader">The <see cref="T:VNLib.Utils.IO.VnStreamReader"/> to read lines from the transport</param> + <param name="lineBuf">The buffer read data from the transport with</param> + <returns>0 if the request line was successfully parsed, a status code if the request could not be processed</returns> + </member> + <member name="M:VNLib.Net.Http.Core.Http11ParseExtensions.Http1PrepareEntityBody(VNLib.Net.Http.Core.HttpRequest,VNLib.Net.Http.Core.Http11ParseExtensions.Http1ParseState@,VNLib.Net.Http.Core.TransportReader@,VNLib.Net.Http.HttpConfig@)"> + <summary> + Prepares the entity body for the current HTTP1 request + </summary> + <param name="Request"></param> + <param name="Config">The current server <see cref="T:VNLib.Net.Http.HttpConfig"/></param> + <param name="parseState">The HTTP1 parsing state</param> + <param name="reader">The <see cref="T:VNLib.Utils.IO.VnStreamReader"/> to read lines from the transport</param> + <returns>0 if the request line was successfully parsed, a status code if the request could not be processed</returns> + </member> + <member name="T:VNLib.Net.Http.Core.HttpInputStream"> + <summary> + Specialized stream to allow reading a request entity body with a fixed content length. + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpInputStream.Prepare(System.Int64,VNLib.Utils.IO.ISlindingWindowBuffer{System.Byte})"> + <summary> + Creates a new input stream object configured to allow reading of the specified content length + bytes from the stream and consumes the initial buffer to read data from on initial read calls + </summary> + <param name="contentLength">The number of bytes to allow being read from the transport or initial buffer</param> + <param name="initial">Entity body data captured on initial read</param> + </member> + <member name="M:VNLib.Net.Http.Core.HttpInputStream.DiscardRemainingAsync(VNLib.Utils.Memory.IUnmangedHeap,System.Int32)"> + <summary> + Asynchronously discards all remaining data in the stream + </summary> + <param name="heap">The heap to alloc buffers from</param> + <param name="maxBufferSize">The maxium size of the buffer to allocate</param> + <returns>A task that represents the discard operations</returns> + </member> + <member name="P:VNLib.Net.Http.Core.HttpRequest.HasEntityBody"> + <summary> + A value indicating whether the connection contained a request entity body. + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.HttpRequest.InputStream"> + <summary> + A transport stream wrapper that is positioned for reading + the entity body from the input stream + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.HttpRequest.Expect"> + <summary> + A value indicating if the client's request had an Expect-100-Continue header + </summary> + </member> + <member name="T:VNLib.Net.Http.Core.HttpRequestBody"> + <summary> + Represents a higher-level request entity body (query arguments, request body etc) + that has been parsed and captured + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestBody.Release"> + <summary> + Releases all resources used by the current instance + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestExtensions.GetCompressionSupport(VNLib.Net.Http.Core.HttpRequest)"> + <summary> + Gets the <see cref="T:VNLib.Net.Http.Core.HttpRequestExtensions.CompressionType"/> that the connection accepts + in a default order, or none if not enabled + </summary> + <param name="request"></param> + <returns>A <see cref="T:VNLib.Net.Http.Core.HttpRequestExtensions.CompressionType"/> with a value the connection support</returns> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestExtensions.IsCrossOrigin(VNLib.Net.Http.Core.HttpRequest)"> + <summary> + Tests the connection's origin header against the location URL by authority. + An origin matches if its scheme, host, and port match + </summary> + <returns>true if the origin header was set and does not match the current locations origin</returns> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestExtensions.IsWebSocketRequest(VNLib.Net.Http.Core.HttpRequest)"> + <summary> + Is the current connection a websocket upgrade request handshake + </summary> + <returns>true if the connection is a websocket upgrade request, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestExtensions.Initialize(VNLib.Net.Http.Core.HttpRequest,VNLib.Net.Http.ITransportContext,VNLib.Net.Http.HttpVersion)"> + <summary> + Initializes the <see cref="T:VNLib.Net.Http.Core.HttpRequest"/> for an incomming connection + </summary> + <param name="server"></param> + <param name="ctx">The <see cref="!:TransportEventContext"/> to attach the request to</param> + <param name="defaultHttpVersion">The default http version</param> + </member> + <member name="M:VNLib.Net.Http.Core.HttpRequestExtensions.InitRequestBodyAsync(VNLib.Net.Http.Core.HttpRequest,System.Int32,System.Text.Encoding)"> + <summary> + Initializes the <see cref="F:VNLib.Net.Http.Core.HttpRequest.RequestBody"/> for the current request + </summary> + <param name="Request"></param> + <param name="maxBufferSize">The maxium buffer size allowed while parsing reqeust body data</param> + <param name="encoding">The request data encoding for url encoded or form data bodies</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Net.Http.Core.ChunkDataAccumulator"> + <summary> + A specialized <see cref="T:VNLib.Utils.IO.IDataAccumulator`1"/> for buffering data + in Http/1.1 chunks + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.ChunkDataAccumulator.RemainingSize"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.ChunkDataAccumulator.Remaining"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.ChunkDataAccumulator.Accumulated"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.ChunkDataAccumulator.AccumulatedSize"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.TryBufferChunk(System.ReadOnlySpan{System.Byte})"> + <summary> + Attempts to buffer as much data as possible from the specified data + </summary> + <param name="data">The data to copy</param> + <returns>The number of bytes that were buffered</returns> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.Advance(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.Prepare(System.Int32)"> + <summary> + Allocates the internal buffer and intializes the accumulator + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.Release"> + <summary> + Releases all held resources and resets state + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.Reset"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.FlushAsync(System.IO.Stream,System.Threading.CancellationToken)"> + <summary> + Writes the buffered data as a single chunk to the stream asynchronously. The internal + state is reset if writing compleded successfully + </summary> + <param name="output">The stream to write data to</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>A value task that resolves when the data has been written to the stream</returns> + </member> + <member name="M:VNLib.Net.Http.Core.ChunkDataAccumulator.Flush(System.IO.Stream)"> + <summary> + Writes the buffered data as a single chunk to the stream. The internal + state is reset if writing compleded successfully + </summary> + <param name="output">The stream to write data to</param> + <returns>A value task that resolves when the data has been written to the stream</returns> + </member> + <member name="T:VNLib.Net.Http.Core.HttpResponse.ChunkedStream"> + <summary> + Writes chunked HTTP message bodies to an underlying streamwriter + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.HttpResponse.StatusCode"> + <summary> + Sets the status code of the response + </summary> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="P:VNLib.Net.Http.Core.HttpResponse.Headers"> + <summary> + Response header collection + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.AddCookie(VNLib.Net.Http.Core.HttpCookie)"> + <summary> + Adds a new http-cookie to the collection + </summary> + <param name="cookie">Cookie to add</param> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.SendEarly100ContinueAsync"> + <summary> + Allows sending an early 100-Continue status message to the client + </summary> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.FlushHeaders"> + <summary> + Sends the status message and all available headers to the client. + Headers set after method returns will be sent when output stream is requested or scope exits + </summary> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.GetStream(System.Int64)"> + <summary> + Gets a stream for writing data of a specified length directly to the client + </summary> + <param name="ContentLength"></param> + <returns>A <see cref="T:System.IO.Stream"/> configured for writing data to client</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.GetStream"> + <summary> + Sets up the client for chuncked encoding and gets a stream that allows for chuncks to be sent. User must call dispose on stream when done writing data + </summary> + <returns><see cref="T:System.IO.Stream"/> supporting chunked encoding</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpResponse.CloseAsync"> + <summary> + Finalzies the response to a client by sending all available headers if + they have not been sent yet + </summary> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Net.Http.Core.HeaderDataAccumulator"> + <summary> + Specialized data accumulator for compiling response headers + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HeaderDataAccumulator.Flush(System.Text.Encoding,System.IO.Stream)"> + <summary> + Encodes the buffered data and writes it to the stream, + attemts to avoid further allocation where possible + </summary> + <param name="enc"></param> + <param name="baseStream"></param> + </member> + <member name="M:VNLib.Net.Http.Core.HeaderDataAccumulator.Compile"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HeaderDataAccumulator.Compile(VNLib.Utils.Memory.ForwardOnlyWriter{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HeaderDataAccumulator.Compile(System.Span{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.HeaderDataAccumulator.ToString"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Http.Core.HttpContextExtensions"> + <summary> + Provides extended funcionality of an <see cref="T:VNLib.Net.Http.Core.HttpContext"/> + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContextExtensions.Respond(VNLib.Net.Http.Core.HttpContext,System.Net.HttpStatusCode)"> + <summary> + Responds to a connection with the given status code + </summary> + <param name="ctx"></param> + <param name="code">The status code to send</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContextExtensions.Redirect301(VNLib.Net.Http.Core.HttpContext,System.Uri)"> + <summary> + Begins a 301 redirection by sending status code and message heaaders to client. + </summary> + <param name="ctx"></param> + <param name="location">Location to direct client to, sets the "Location" header</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContextExtensions.SetNoCache(VNLib.Net.Http.Core.HttpResponse)"> + <summary> + Sets CacheControl and Pragma headers to no-cache + </summary> + <param name="Response"></param> + </member> + <member name="M:VNLib.Net.Http.Core.HttpContextExtensions.SetContentRange(VNLib.Net.Http.Core.HttpResponse,System.Int64,System.Int64,System.Int64)"> + <summary> + Sets the content-range header to the specified parameters + </summary> + <param name="Response"></param> + <param name="start">The content range start</param> + <param name="end">The content range end</param> + <param name="length">The total content length</param> + </member> + <member name="T:VNLib.Net.Http.Core.CoreBufferHelpers"> + <summary> + Provides memory pools and an internal heap for allocations. + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.CoreBufferHelpers.HttpCharBufPool"> + <summary> + An internal HTTP character buffer pool for HTTP specific internal buffers + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.CoreBufferHelpers.HttpBinBufferPool"> + <summary> + An internal HTTP character binary pool for HTTP specific internal buffers + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.CoreBufferHelpers.HttpPrivateHeap"> + <summary> + An <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> used for internal HTTP buffers + </summary> + </member> + <member name="M:VNLib.Net.Http.Core.CoreBufferHelpers.GetCharBuffer(System.Int32,System.Boolean)"> + <summary> + Allocates a block of unmanaged memory from the internal heap, or managed buffer pool based + on compilation flags or runtime variables + </summary> + <param name="size">The number of elemnts to allocate</param> + <param name="zero">A value indicating of the block should be zeroed before returning</param> + <returns>A handle to the block of memory</returns> + <exception cref="T:System.Security.SecurityException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.CoreBufferHelpers.GetBinBuffer(System.Int32,System.Boolean)"> + <summary> + Alloctes an unsafe block of memory from the internal heap, or buffer pool + </summary> + <param name="size">The number of elemnts to allocate</param> + <param name="zero">A value indicating of the block should be zeroed before returning</param> + <returns>A handle to the block of memory</returns> + <exception cref="T:System.Security.SecurityException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.CoreBufferHelpers.GetReminaingData``1(``0@,System.Int64)"> + <summary> + Gets the remaining data in the reader buffer and prepares a + sliding window buffer to read data from + </summary> + <typeparam name="T"></typeparam> + <param name="reader"></param> + <param name="maxContentLength">Maximum content size to clamp the remaining buffer window to</param> + <returns></returns> + </member> + <member name="M:VNLib.Net.Http.Core.CoreBufferHelpers.CopyToOutputAsync(System.IO.Stream,System.IO.Stream,System.Int64,System.Int32,System.Threading.CancellationToken)"> + <summary> + Provides an async wrapper for copying data from the current stream to another with a + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="bufferSize">The size of the buffer to use while copying data. (Value will be clamped to the size of the stream if seeking is available)</param> + <param name="count">The number of bytes to copy from the current stream to destination stream</param> + <param name="heap">The heap to alloc buffer from</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Net.Http.Core.CoreBufferHelpers.CopyToOutputAsync(System.IO.Stream,System.IO.Stream,System.Int32,System.Threading.CancellationToken)"> + <summary> + Provides an async wrapper for copying data from the current stream to another using an unmanged + buffer. + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="bufferSize">The size of the buffer to use while copying data. (Value will be clamped to the size of the stream if seeking is available)</param> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate the buffer from</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="T:VNLib.Net.Http.Core.TransportReader"> + <summary> + Structure implementation of <see cref="T:VNLib.Utils.IO.IVnTextReader"/> + </summary> + </member> + <member name="P:VNLib.Net.Http.Core.TransportReader.Encoding"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.TransportReader.LineTermination"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.TransportReader.BaseStream"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.TransportReader.#ctor(System.IO.Stream,System.Int32,System.Text.Encoding,System.ReadOnlyMemory{System.Byte})"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Http.Core.TransportReader"/> for reading text lines from the transport stream + </summary> + <param name="transport">The transport stream to read data from</param> + <param name="bufferSize">The size of the internal binary buffer</param> + <param name="encoding">The encoding to use when reading bianry</param> + <param name="lineTermination">The line delimiter to search for</param> + </member> + <member name="P:VNLib.Net.Http.Core.TransportReader.Available"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.Core.TransportReader.BufferedDataWindow"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.TransportReader.Dispose"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.TransportReader.Advance(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.TransportReader.FillBuffer"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.Core.TransportReader.CompactBufferWindow"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.HttpEvent.Server"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.HttpEvent.OriginServer"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.HttpEvent.DisableCompression"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.HttpEvent.QueryArgs"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.HttpEvent.RequestArgs"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Http.HttpEvent.Files"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.HttpEvent.DangerousChangeProtocol(VNLib.Net.Http.IAlternateProtocol)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.HttpEvent.CloseResponse(System.Net.HttpStatusCode)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.HttpEvent.CloseResponse(System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Http.HttpEvent.UncheckedCloseResponse(System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Http.HttpServer"> + <summary> + Provides a TCP based (using <see cref="!:TcpServer"/> library) high performance single library + HTTP(s) server that manages sessions, data compression, websockets, and basic file processing. + This class cannot be inherited + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpServer.WILDCARD_KEY"> + <summary> + The host key that determines a "wildcard" host, meaning the + default connection handler when an incomming connection has + not specific route + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpServer.KeepAliveTimeoutHeaderValue"> + <summary> + The cached HTTP1/1 keepalive timeout header value + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpServer.ContextStore"> + <summary> + Reusable store for obtaining <see cref="T:VNLib.Net.Http.Core.HttpContext"/> + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpServer.HeaderLineTermination"> + <summary> + The cached header-line termination value + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpServer.Config"> + <summary> + The <see cref="T:VNLib.Net.Http.HttpConfig"/> for the current server + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpServer.Running"> + <summary> + Gets a value indicating whether the server is listening for connections + </summary> + </member> + <member name="M:VNLib.Net.Http.HttpServer.#ctor(VNLib.Net.Http.HttpConfig,VNLib.Net.Http.ITransportProvider,System.Collections.Generic.IEnumerable{VNLib.Net.Http.IWebRoot})"> + <summary> + Creates a new <see cref="T:VNLib.Net.Http.HttpServer"/> with the specified configration copy (using struct). + Immutable data structures are initialzed. + </summary> + <param name="config">The configuration used to create the instance</param> + <param name="transport">The transport provider to listen to connections from</param> + <param name="sites">A collection of <see cref="T:VNLib.Net.Http.IWebRoot"/>s that route incomming connetctions</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Net.Http.HttpServer.Start(System.Threading.CancellationToken)"> + <summary> + Begins listening for connections on configured interfaces for configured hostnames. + </summary> + <param name="token">A token used to stop listening for incomming connections and close all open websockets</param> + <exception cref="T:System.Net.Sockets.SocketException"></exception> + <exception cref="T:System.Threading.ThreadStateException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="F:VNLib.Net.Http.HttpServer.INVALID_FRAME_HRESULT"> + <summary> + An invlaid frame size may happen if data is recieved on an open socket + but does not contain valid SSL handshake data + </summary> + </member> + <member name="M:VNLib.Net.Http.HttpServer.CacheClear"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Http.HttpServer.CacheHardClear"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Http.HttpServer.WriteSocketExecption(System.Net.Sockets.SocketException)"> + <summary> + Writes the specialized log for a socket exception + </summary> + <param name="se">The socket exception to log</param> + </member> + <member name="M:VNLib.Net.Http.HttpServer.ProcessHttpEventAsync(VNLib.Net.Http.ITransportContext,VNLib.Net.Http.Core.HttpContext)"> + <summary> + Main event handler for all incoming connections + </summary> + <param name="transportContext">The <see cref="!:TransportEventContext"/> describing the incoming connection</param> + <param name="context">Reusable context object</param> + </member> + <member name="M:VNLib.Net.Http.HttpServer.ParseRequest(VNLib.Net.Http.ITransportContext,VNLib.Net.Http.Core.HttpRequest)"> + <summary> + Reads data synchronously from the transport and attempts to parse an HTTP message and + built a request. + </summary> + <param name="transport"></param> + <param name="Request"></param> + <returns>0 if the request was successfully parsed, the <see cref="T:System.Net.HttpStatusCode"/> + to return to the client because the entity could not be processed</returns> + <remarks> + <para> + This method is synchronous for multiple memory optimization reasons, + and performance is not expected to be reduced as the transport layer should + <br></br> + only raise an event when a socket has data available to be read, and entity + header sections are expected to fit within a single TCP buffer. + </para> + </remarks> + </member> + <member name="M:VNLib.Net.Http.HttpServer.ProcessAsync(VNLib.Net.Http.IWebRoot,VNLib.Net.Http.Core.HttpContext)"> + <summary> + Processes a client connection after pre-processing has completed + </summary> + <param name="root">The <see cref="T:VNLib.Net.Http.IWebRoot"/> to process the event on</param> + <param name="ctx">The <see cref="T:VNLib.Net.Http.Core.HttpContext"/> to process</param> + <returns>A task that resolves when the user-code has completed processing the entity</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:VNLib.Net.Http.TerminateConnectionException"></exception> + </member> + <member name="T:VNLib.Net.Http.IHttpEvent"> + <summary> + Contains an http request and session information. + </summary> + </member> + <member name="P:VNLib.Net.Http.IHttpEvent.Server"> + <summary> + Current connection information. (Like "$_SERVER" superglobal in PHP) + </summary> + </member> + <member name="P:VNLib.Net.Http.IHttpEvent.OriginServer"> + <summary> + The <see cref="T:VNLib.Net.Http.HttpServer"/> that this connection originated from + </summary> + </member> + <member name="P:VNLib.Net.Http.IHttpEvent.QueryArgs"> + <summary> + If the request has query arguments they are stored in key value format + </summary> + <remarks>Keys are case-insensitive</remarks> + </member> + <member name="P:VNLib.Net.Http.IHttpEvent.RequestArgs"> + <summary> + If the request body has form data or url encoded arguments they are stored in key value format + </summary> + </member> + <member name="P:VNLib.Net.Http.IHttpEvent.Files"> + <summary> + Contains all files upladed with current request + </summary> + <remarks>Keys are case-insensitive</remarks> + </member> + <member name="M:VNLib.Net.Http.IHttpEvent.CloseResponse(System.Net.HttpStatusCode)"> + <summary> + Complete the session and respond to user + </summary> + <param name="code">Status code of operation</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.IHttpEvent.CloseResponse(System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream)"> + <summary> + Responds to a client with a <see cref="T:System.IO.Stream"/> containing data to be sent to user of a given contentType. + Runtime will dispose of the stream during closing event + </summary> + <param name="code">Response status code</param> + <param name="type">MIME ContentType of data</param> + <param name="stream">Data to be sent to client</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Net.Http.IHttpEvent.DangerousChangeProtocol(VNLib.Net.Http.IAlternateProtocol)"> + <summary> + Configures the server to change protocols from HTTP to the specified + custom protocol handler. + </summary> + <param name="protocolHandler">The custom protocol handler</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Http.IHttpEvent.DisableCompression"> + <summary> + Disables response compression + </summary> + </member> + <member name="M:VNLib.Net.Http.IHttpEvent.UncheckedCloseResponse(System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream)"> + <summary> + Responds to a client with a <see cref="T:System.IO.Stream"/> containing data to be sent to user of a given contentType. + Runtime will dispose of the stream during closing event + <br></br> + <br></br> + Does not check to see if the client accepts the specifed content type, the client may drop the connection and cause unexpected issues. + You should avoid using this method + </summary> + <param name="code">Response status code</param> + <param name="type">MIME ContentType of data</param> + <param name="stream">Data to be sent to client</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="T:VNLib.Net.Http.ContentTypeUnacceptableException"> + <summary> + Thrown when the application attempts to submit a response to a client + when the client does not accept the given content type + </summary> + </member> + <member name="T:VNLib.Net.Http.TerminateConnectionException"> + <summary> + User code may throw this exception to signal the <see cref="T:VNLib.Net.Http.HttpServer"/> to drop + the transport connection and return an optional status code + </summary> + </member> + <member name="M:VNLib.Net.Http.TerminateConnectionException.#ctor"> + <summary> + Creates a new instance that terminates the connection without sending a response to the connection + </summary> + </member> + <member name="M:VNLib.Net.Http.TerminateConnectionException.#ctor(System.Net.HttpStatusCode)"> + <summary> + Creates a new instance of the connection exception with an error code to respond to the connection with + </summary> + <param name="responseCode">The status code to send to the user</param> + </member> + <member name="T:VNLib.Net.Http.HttpVersion"> + <summary> + HTTP protocol version + </summary> + </member> + <member name="T:VNLib.Net.Http.CacheType"> + <summary> + HTTP response entity cache flags + </summary> + </member> + <member name="T:VNLib.Net.Http.CookieSameSite"> + <summary> + Specifies an HTTP cookie SameSite type + </summary> + </member> + <member name="T:VNLib.Net.Http.Redirect"> + <summary> + Low level 301 "hard" redirect + </summary> + </member> + <member name="M:VNLib.Net.Http.Redirect.#ctor(System.String,System.String)"> + <summary> + Quickly redirects a url to another url before sessions are established + </summary> + <param name="url">Url to redirect on</param> + <param name="redirecturl">Url to redirect to</param> + </member> + <member name="T:VNLib.Net.Http.HttpHelpers"> + <summary> + Provides a set of HTTP helper functions + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpHelpers.CRLF"> + <summary> + Carrage return + line feed characters used within the VNLib.Net.Http namespace to delimit http messages/lines + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpHelpers.Origin"> + <summary> + Extended <see cref="T:System.Net.HttpRequestHeader"/> for origin header, DO NOT USE IN <see cref="T:System.Net.WebHeaderCollection"/> + </summary> + </member> + <member name="F:VNLib.Net.Http.HttpHelpers.ContentDisposition"> + <summary> + Extended <see cref="T:System.Net.HttpRequestHeader"/> for Content-Disposition, DO NOT USE IN <see cref="T:System.Net.WebHeaderCollection"/> + </summary> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetContentTypeString(VNLib.Net.ContentType)"> + <summary> + Returns an http formatted content type string of a specified content type + </summary> + <param name="type">Contenty type</param> + <returns>Http acceptable string representing a content type</returns> + <exception cref="T:System.Collections.Generic.KeyNotFoundException"></exception> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetContentType(System.String)"> + <summary> + Returns the <see cref="T:VNLib.Net.ContentType"/> enum value from the MIME string + </summary> + <param name="type">Content type from request</param> + <returns><see cref="T:VNLib.Net.ContentType"/> of request, <see cref="F:VNLib.Net.ContentType.NonSupported"/> if unknown</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetCacheString(VNLib.Net.Http.CacheType,System.Int32,System.Boolean)"> + <summary> + Builds a Cache-Control MIME content header from the specified flags + </summary> + <param name="type">The cache type/mode</param> + <param name="maxAge">The max-age (time in seconds) argument</param> + <param name="immutable">Sets the immutable argument</param> + <returns>The string representation of the Cache-Control header</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetCacheString(VNLib.Net.Http.CacheType,System.TimeSpan,System.Boolean)"> + <summary> + Builds a Cache-Control MIME content header from the specified flags + </summary> + <param name="type">The cache type/mode</param> + <param name="maxAge">The max-age argument</param> + <param name="immutable">Sets the immutable argument</param> + <returns>The string representation of the Cache-Control header</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetRequestMethod(System.ReadOnlySpan{System.Char})"> + <summary> + Returns an enum value of an httpmethod of an http request method string + </summary> + <param name="smethod">Http acceptable method type string</param> + <returns>Request method, <see cref="F:VNLib.Net.Http.HttpMethod.NOT_SUPPORTED"/> if method is malformatted or unsupported</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.IsLocalSubnet(System.Net.IPAddress,System.Net.IPAddress)"> + <summary> + Compares the first 3 bytes of IPV4 ip address or the first 6 bytes of a IPV6. Can be used to determine if the address is local to another address + </summary> + <param name="first">Address to be compared</param> + <param name="other">Address to be comared to first address</param> + <returns>True if first 2 bytes of each address match (Big Endian)</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetContentTypeFromFile(System.ReadOnlySpan{System.Char})"> + <summary> + Selects a <see cref="T:VNLib.Net.ContentType"/> for a given file extension + </summary> + <param name="path">Path (including extension) of a file</param> + <returns><see cref="T:VNLib.Net.ContentType"/> of file. Returns <see cref="F:VNLib.Net.ContentType.Binary"/> if extension is unknown</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetResponseString(VNLib.Net.Http.HttpVersion,System.Net.HttpStatusCode)"> + <summary> + Selects a runtime compiled <see cref="T:System.String"/> matching the given <see cref="T:System.Net.HttpStatusCode"/> and <see cref="T:VNLib.Net.Http.HttpVersion"/> + </summary> + <param name="version">Version of the response string</param> + <param name="code">Status code of the response</param> + <returns>The HTTP response status line matching the code and version</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.TryParseContentType(System.String,System.String@,System.String@,System.String@)"> + <summary> + Parses the mime Content-Type header value into its sub-components + </summary> + <param name="header">The Content-Type header value field</param> + <param name="ContentType">The mime content type field</param> + <param name="Charset">The mime charset</param> + <param name="Boundry">The multi-part form boundry parameter</param> + <returns>True if parsing the content type succeded, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.ParseDisposition(System.ReadOnlySpan{System.Char},System.String@,System.String@,System.String@)"> + <summary> + Parses a standard HTTP Content disposition header into its sub-components, type, name, filename (optional) + </summary> + <param name="header">The buffer containing the Content-Disposition header value only</param> + <param name="type">The mime form type</param> + <param name="name">The mime name argument</param> + <param name="fileName">The mime filename</param> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.GetRequestHeaderEnumFromValue(System.ReadOnlySpan{System.Char})"> + <summary> + Performs a lookup of the specified header name to get the <see cref="T:System.Net.HttpRequestHeader"/> enum value + </summary> + <param name="requestHeaderName">The value of the HTTP request header to compute</param> + <returns>The <see cref="T:System.Net.HttpRequestHeader"/> enum value of the header, or 255 if not found</returns> + </member> + <member name="M:VNLib.Net.Http.HttpHelpers.ParseHttpVersion(System.ReadOnlySpan{System.Char})"> + <summary> + Gets the <see cref="T:VNLib.Net.Http.HttpVersion"/> enum value from the version string + </summary> + <param name="httpVersion">The http header version string</param> + <returns>The <see cref="T:VNLib.Net.Http.HttpVersion"/> enum value, or + <see cref="F:VNLib.Net.Http.HttpVersion.NotSupported"/> if the version could not be + determined + </returns> + </member> + <member name="T:VNLib.Net.Http.VnWebHeaderCollection"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Http.WebHeaderExtensions"> + <summary> + Extends the <see cref="T:System.Net.WebHeaderCollection"/> to provide some check methods + </summary> + </member> + <member name="M:VNLib.Net.Http.WebHeaderExtensions.HeaderSet(System.Net.WebHeaderCollection,System.Net.HttpRequestHeader)"> + <summary> + Determines if the specified request header has been set in the current header collection + </summary> + <param name="headers"></param> + <param name="header">Header value to check</param> + <returns>true if the header was set, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.WebHeaderExtensions.HeaderSet(System.Net.WebHeaderCollection,System.Net.HttpResponseHeader)"> + <summary> + Determines if the specified response header has been set in the current header collection + </summary> + <param name="headers"></param> + <param name="header">Header value to check</param> + <returns>true if the header was set, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.WebHeaderExtensions.HeaderSet(System.Net.WebHeaderCollection,System.String)"> + <summary> + Determines if the specified header has been set in the current header collection + </summary> + <param name="headers"></param> + <param name="header">Header value to check</param> + <returns>true if the header was set, false otherwise</returns> + </member> + <member name="T:VNLib.Net.Http.HttpConfig"> + <summary> + Represents configration variables used to create the instance and manage http connections + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.ServerLog"> + <summary> + A log provider that all server related log entiries will be written to + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.MaxUploadSize"> + <summary> + The absolute request entity body size limit in bytes + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.MaxFormDataUploadSize"> + <summary> + The maximum size in bytes allowed for an MIME form-data content type upload + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.FormDataBufferSize"> + <summary> + The maximum buffer size to use when parsing Multi-part/Form-data file uploads + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.CompressionLimit"> + <summary> + The maximum response entity size in bytes for which the library will allow compresssing response data + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.CompressionMinimum"> + <summary> + The minimum size (in bytes) of respones data that will be compressed + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.TransportKeepalive"> + <summary> + The maximum amount of time to listen for connected, but innactive transport connections + before closing them + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.HttpEncoding"> + <summary> + The encoding to use when sending and receiving HTTP data + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.CompressionLevel"> + <summary> + Sets the compression level for response entity streams of all supported types when + compression is used. + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.DefaultHttpVersion"> + <summary> + Sets the default Http version for responses when the client version cannot be parsed from the request + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.HeaderBufferSize"> + <summary> + The buffer size used to read HTTP headers from the transport. + </summary> + <remarks> + Setting this value too low will result in <see cref="T:System.OutOfMemoryException"/>s + when HTTP header elements are larger than this value + </remarks> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.ActiveConnectionRecvTimeout"> + <summary> + The amount of time to wait for data on a connection that is in a receive + state, aka active receive. + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.MaxRequestHeaderCount"> + <summary> + The maximum number of request headers allowed per request + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.MaxOpenConnections"> + <summary> + The maximum number of open socket connections, before 503 errors + will be returned and new connections closed. + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.ResponseHeaderBufferSize"> + <summary> + The size (in bytes) of the http response header buffer + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.DiscardBufferSize"> + <summary> + The size (in bytes) of the buffer to use to discard unread entity request bodies + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.ResponseBufferSize"> + <summary> + The size of the buffer to use when writing response data to the transport + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.ChunkedResponseAccumulatorSize"> + <summary> + The size of the buffer used to accumulate chunked response data before writing to the transport + </summary> + </member> + <member name="P:VNLib.Net.Http.HttpConfig.RequestDebugLog"> + <summary> + An <see cref="T:VNLib.Utils.Logging.ILogProvider"/> for writing verbose request logs. Set to <c>null</c> + to disable verbose request logging + </summary> + </member> + <member name="T:VNLib.Net.Http.IAlternateProtocol"> + <summary> + Allows implementation for a protocol swtich from HTTP to another protocol + </summary> + </member> + <member name="M:VNLib.Net.Http.IAlternateProtocol.RunAsync(System.IO.Stream,System.Threading.CancellationToken)"> + <summary> + Initializes and executes the protocol-switch and the protocol handler + that is stored + </summary> + <param name="transport">The prepared transport stream for the new protocol</param> + <param name="handlerToken">A cancelation token that the caller may pass for operation cancelation and cleanup</param> + <returns>A task that will be awaited by the server, that when complete, will cleanup resources held by the connection</returns> + </member> + <member name="T:VNLib.Net.Http.IConnectionInfo"> + <summary> + Represents a client's connection info as interpreted by the current server + </summary> + <remarks>Methods and properties are undefined when <see cref="M:VNLib.Net.Http.IWebRoot.ClientConnectedAsync(VNLib.Net.Http.IHttpEvent)"/> returns</remarks> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.RequestUri"> + <summary> + Full request uri of current connection + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Path"> + <summary> + Current request path. Shortcut to <seealso cref="P:VNLib.Net.Http.IConnectionInfo.RequestUri"/> <see cref="P:System.Uri.LocalPath"/> + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.UserAgent"> + <summary> + Current connection's user-agent header, (may be null if no user-agent header found) + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Headers"> + <summary> + Current connection's headers + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.CrossOrigin"> + <summary> + A value that indicates if the connection's origin header was set and it's + authority segment does not match the <see cref="P:VNLib.Net.Http.IConnectionInfo.RequestUri"/> authority + segment. + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.IsWebSocketRequest"> + <summary> + Is the current connecion a websocket request + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.ContentType"> + <summary> + Request specified content-type + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Method"> + <summary> + Current request's method + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.ProtocolVersion"> + <summary> + The current connection's HTTP protocol version + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.IsSecure"> + <summary> + Is the connection using transport security? + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.SecurityProtocol"> + <summary> + The negotiated transport protocol for the current connection + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Origin"> + <summary> + Origin header of current connection if specified, null otherwise + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Referer"> + <summary> + Referer header of current connection if specified, null otherwise + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Range"> + <summary> + The parsed range header, or -1,-1 if the range header was not set + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.LocalEndpoint"> + <summary> + The server endpoint that accepted the connection + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.RemoteEndpoint"> + <summary> + The raw <see cref="T:System.Net.IPEndPoint"/> of the upstream connection. + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Encoding"> + <summary> + The encoding type used to decode and encode character data to and from the current client + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.RequestCookies"> + <summary> + A <see cref="T:System.Collections.Generic.IReadOnlyDictionary`2"/> of client request cookies + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.Accept"> + <summary> + Gets an <see cref="T:System.Collections.Generic.IEnumerator`1"/> for the parsed accept header values + </summary> + </member> + <member name="P:VNLib.Net.Http.IConnectionInfo.TransportSecurity"> + <summary> + Gets the underlying transport security information for the current connection + </summary> + </member> + <member name="M:VNLib.Net.Http.IConnectionInfo.Accepts(VNLib.Net.ContentType)"> + <summary> + Determines if the client accepts the response content type + </summary> + <param name="type">The desired content type</param> + <returns>True if the client accepts the content type, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.IConnectionInfo.Accepts(System.String)"> + <summary> + Determines if the client accepts the response content type + </summary> + <param name="contentType">The desired content type</param> + <returns>True if the client accepts the content type, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.IConnectionInfo.SetCookie(System.String,System.String,System.String,System.String,System.TimeSpan,VNLib.Net.Http.CookieSameSite,System.Boolean,System.Boolean)"> + <summary> + Add a cookie to a browser or set a current cookie + </summary> + <param name="name">Cookie name/id</param> + <param name="value">Value to be stored in cookie</param> + <param name="domain">Domain for cookie to operate</param> + <param name="path">Path to store cookie</param> + <param name="Expires">Timespan representing how long the cookie should exist</param> + <param name="sameSite">Samesite attribute, Default = Lax</param> + <param name="httpOnly">Specify the HttpOnly flag</param> + <param name="secure">Specify the Secure flag</param> + </member> + <member name="T:VNLib.Net.Http.IHeaderCollection"> + <summary> + The container for request and response headers + </summary> + </member> + <member name="P:VNLib.Net.Http.IHeaderCollection.RequestHeaders"> + <summary> + Allows for enumeratring all requesest headers + </summary> + </member> + <member name="P:VNLib.Net.Http.IHeaderCollection.ResponseHeaders"> + <summary> + Allows for enumeratring all response headers + </summary> + </member> + <member name="P:VNLib.Net.Http.IHeaderCollection.Item(System.String)"> + <summary> + Gets request header, or sets a response header + </summary> + <param name="index"></param> + <returns>Request header with key</returns> + </member> + <member name="P:VNLib.Net.Http.IHeaderCollection.Item(System.Net.HttpResponseHeader)"> + <summary> + Sets a response header only with a response header index + </summary> + <param name="index">Response header</param> + </member> + <member name="P:VNLib.Net.Http.IHeaderCollection.Item(System.Net.HttpRequestHeader)"> + <summary> + Gets a request header + </summary> + <param name="index">The request header enum </param> + </member> + <member name="M:VNLib.Net.Http.IHeaderCollection.HeaderSet(System.Net.HttpResponseHeader)"> + <summary> + Determines if the given header is set in current response headers + </summary> + <param name="header">Header value to check response headers for</param> + <returns>true if header exists in current response headers, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.IHeaderCollection.HeaderSet(System.Net.HttpRequestHeader)"> + <summary> + Determines if the given request header is set in current request headers + </summary> + <param name="header">Header value to check request headers for</param> + <returns>true if header exists in current request headers, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Http.IHeaderCollection.Append(System.Net.HttpResponseHeader,System.String)"> + <summary> + Overwrites (sets) the given response header to the exact value specified + </summary> + <param name="header">The enumrated header id</param> + <param name="value">The value to specify</param> + </member> + <member name="M:VNLib.Net.Http.IHeaderCollection.Append(System.String,System.String)"> + <summary> + Overwrites (sets) the given response header to the exact value specified + </summary> + <param name="header">The header name</param> + <param name="value">The value to specify</param> + </member> + <member name="T:VNLib.Net.Http.ITransportContext"> + <summary> + Represents an active connection for application data processing + </summary> + </member> + <member name="P:VNLib.Net.Http.ITransportContext.ConnectionStream"> + <summary> + The transport network stream for application data marshaling + </summary> + </member> + <member name="P:VNLib.Net.Http.ITransportContext.SslVersion"> + <summary> + The transport security layer security protocol + </summary> + </member> + <member name="P:VNLib.Net.Http.ITransportContext.LocalEndPoint"> + <summary> + A copy of the local endpoint of the listening socket + </summary> + </member> + <member name="P:VNLib.Net.Http.ITransportContext.RemoteEndpoint"> + <summary> + The <see cref="T:System.Net.IPEndPoint"/> representing the client's connection information + </summary> + </member> + <member name="M:VNLib.Net.Http.ITransportContext.CloseConnectionAsync"> + <summary> + Closes the connection when its no longer in use and cleans up held resources. + </summary> + <returns></returns> + <remarks> + This method will always be called by the server when a connection is complete + regardless of the state of the trasnport + </remarks> + </member> + <member name="M:VNLib.Net.Http.ITransportContext.GetSecurityInfo"> + <summary> + Attemts to get the transport security details for the connection + </summary> + <returns>A the <see cref="T:VNLib.Net.Http.TransportSecurityInfo"/> structure if applicable, null otherwise</returns> + </member> + <member name="T:VNLib.Net.Http.ITransportProvider"> + <summary> + Listens for network connections and captures the information + required for application processing + </summary> + </member> + <member name="M:VNLib.Net.Http.ITransportProvider.Start(System.Threading.CancellationToken)"> + <summary> + Begins listening for connections (binds a socket if necessary) and is + called before the server begins listening for connections. + </summary> + <param name="stopToken">A token that is cancelled when the server is closed</param> + </member> + <member name="M:VNLib.Net.Http.ITransportProvider.AcceptAsync(System.Threading.CancellationToken)"> + <summary> + Waits for a new connection to be established and returns its context. This method + should only return an established connection (ie: connected socket). + </summary> + <param name="cancellation">A token to cancel the wait operation</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that returns an established connection</returns> + </member> + <member name="T:VNLib.Net.Http.IWebRoot"> + <summary> + Represents a root identifying the main endpoints of the server, and the primary processing actions + for requests to this endpoint + </summary> + </member> + <member name="P:VNLib.Net.Http.IWebRoot.Hostname"> + <summary> + The hostname the server will listen for, and the hostname that will identify this root when a connection requests it + </summary> + </member> + <member name="M:VNLib.Net.Http.IWebRoot.ClientConnectedAsync(VNLib.Net.Http.IHttpEvent)"> + <summary> + <para> + The main event handler for user code to process a request + </para> + <para> + NOTE: This function must be thread-safe! + </para> + </summary> + <param name="event">An active, unprocessed event capturing the request infomration into a standard format</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that the processor will await until the entity has been processed</returns> + </member> + <member name="P:VNLib.Net.Http.IWebRoot.Redirects"> + <summary> + "Low-Level" 301 redirects + </summary> + </member> + <member name="T:VNLib.Net.Http.TransportSecurityInfo"> + <summary> + Gets the transport TLS security information for the current connection + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.CheckCertRevocationStatus"> + <summary> + Gets a Boolean value that indicates whether the certificate revocation list is checked during the certificate validation process. + </summary> + <returns>true if the certificate revocation list is checked during validation; otherwise, false.</returns> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.CipherAlgorithm"> + <summary> + Gets a value that identifies the bulk encryption algorithm used by the connection. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.CipherStrength"> + <summary> + Gets a value that identifies the strength of the cipher algorithm used by the connection. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.HashAlgorithm"> + <summary> + Gets the algorithm used for generating message authentication codes (MACs). + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.HashStrength"> + <summary> + Gets a value that identifies the strength of the hash algorithm used by this instance. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.IsAuthenticated"> + <summary> + Gets a Boolean value that indicates whether authentication was successful. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.IsEncrypted"> + <summary> + Gets a Boolean value that indicates whether this connection uses data encryption. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.IsMutuallyAuthenticated"> + <summary> + Gets a Boolean value that indicates whether both server and client have been authenticated. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.IsSigned"> + <summary> + Gets a Boolean value that indicates whether the data sent using this connection is signed. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.KeyExchangeAlgorithm"> + <summary> + Gets the key exchange algorithm used by this connection + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.KeyExchangeStrength"> + <summary> + Gets a value that identifies the strength of the key exchange algorithm used by the transport connection + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.LocalCertificate"> + <summary> + Gets the certificate used to authenticate the local endpoint. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.NegotiatedApplicationProtocol"> + <summary> + The negotiated application protocol in TLS handshake. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.NegotiatedCipherSuite"> + <summary> + Gets the cipher suite which was negotiated for this connection. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.RemoteCertificate"> + <summary> + Gets the certificate used to authenticate the remote endpoint. + </summary> + </member> + <member name="P:VNLib.Net.Http.TransportSecurityInfo.TransportContext"> + <summary> + Gets the TransportContext used for authentication using extended protection. + </summary> + </member> + <member name="T:VNLib.Net.ContentType"> + <summary> + Mime content type + </summary> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.dll Binary files differnew file mode 100644 index 0000000..e3a57ba --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.xml new file mode 100644 index 0000000..511ee00 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Client.xml @@ -0,0 +1,723 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Net.Messaging.FBM.Client</name> + </assembly> + <members> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.WriteLocation(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.ReadOnlySpan{System.Char})"> + <summary> + Writes the location header of the requested resource + </summary> + <param name="request"></param> + <param name="location">The location address</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.WriteLocation(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.Uri)"> + <summary> + Writes the location header of the requested resource + </summary> + <param name="request"></param> + <param name="location">The location address</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.ThrowIfNotSet(VNLib.Net.Messaging.FBM.Client.FBMResponse)"> + <summary> + If the <see cref="F:VNLib.Net.Messaging.FBM.Client.FBMResponse.IsSet"/> property is false, raises an <see cref="T:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException"/> + </summary> + <param name="response"></param> + <exception cref="T:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMException"> + <summary> + A base exception class for all FBM Library exceptions + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMInvalidRequestException"> + <summary> + Raised when a request message is not in a valid state and cannot be sent + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException"> + <summary> + Raised when a response to an FBM request is not in a valid state + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.Exceptions.InvalidResponseException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClient"> + <summary> + A Fixed Buffer Message Protocol client. Allows for high performance client-server messaging + with minimal memory overhead. + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_RECV_BUF_QUERY_ARG"> + <summary> + The WS connection query arguments to specify a receive buffer size + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_HEAD_BUF_QUERY_ARG"> + <summary> + The WS connection query argument to suggest a maximum response header buffer size + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_MAX_MESS_QUERY_ARG"> + <summary> + The WS connection query argument to suggest a maximum message size + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_MAX_HEADER_QUERY_ARG"> + <summary> + The WS connection query argument to suggest a maximum request header buffer size + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionClosedOnError"> + <summary> + Raised when the websocket has been closed because an error occured. + You may inspect the event args to determine the cause of the error. + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionClosed"> + <summary> + Raised when the client listener operaiton has completed as a normal closure + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.Config"> + <summary> + The configuration for the current client + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionStatusHandle"> + <summary> + A handle that is reset when a connection has been successfully set, and is set + when the connection exists + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ClientSocket"> + <summary> + The <see cref="T:System.Net.WebSockets.ClientWebSocket"/> to send/recieve message on + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ControlFrame"> + <summary> + Gets the shared control frame for the current instance. The request is reset when + this property is called. (Not thread safe) + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.#ctor(VNLib.Net.Messaging.FBM.Client.FBMClientConfig)"> + <summary> + Creates a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> in a closed state + </summary> + <param name="config">The client configuration</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReuseableRequestConstructor"> + <summary> + Allocates and configures a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> message object for use within the reusable store + </summary> + <returns>The configured <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asynchronously opens a websocket connection with the specifed remote server + </summary> + <param name="address">The address of the server to connect to</param> + <param name="cancellation">A cancellation token</param> + <returns></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.RentRequest"> + <summary> + Rents a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> from the internal <see cref="T:VNLib.Utils.Memory.Caching.ReusableStore`1"/>. + Use <see cref="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReturnRequest(VNLib.Net.Messaging.FBM.Client.FBMRequest)"/> when request is no longer in use + </summary> + <returns>The configured (rented or new) <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> ready for use</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReturnRequest(VNLib.Net.Messaging.FBM.Client.FBMRequest)"> + <summary> + Stores (or returns) the reusable request in cache for use with <see cref="M:VNLib.Net.Messaging.FBM.Client.FBMClient.RentRequest"/> + </summary> + <param name="request">The request to return to the store</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.SendAsync(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.Threading.CancellationToken)"> + <summary> + Sends a <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> to the connected server + </summary> + <param name="request">The request message to send to the server</param> + <param name="cancellationToken"></param> + <returns>When awaited, yields the server response</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Messaging.FBM.Client.Exceptions.FBMInvalidRequestException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.StreamDataAsync(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.IO.Stream,VNLib.Net.ContentType,System.Threading.CancellationToken)"> + <summary> + Streams arbitrary binary data to the server with the initial request message + </summary> + <param name="request">The request message to send to the server</param> + <param name="payload">Data to stream to the server</param> + <param name="ct">The content type of the stream of data</param> + <param name="cancellationToken"></param> + <returns>When awaited, yields the server response</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessContinuousRecvAsync"> + <summary> + Begins listening for messages from the server on the internal socket (must be connected), + until the socket is closed, or canceled + </summary> + <returns></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessResponse(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Syncrhonously processes a buffered response packet + </summary> + <param name="responseMessage">The buffered response body recieved from the server</param> + <remarks>This method blocks the listening task. So operations should be quick</remarks> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessControlFrame(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Processes a control frame response from the server + </summary> + <param name="vms">The raw response packet from the server</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessControlFrame(VNLib.Net.Messaging.FBM.Client.FBMResponse@)"> + <summary> + Processes a control frame response from the server + </summary> + <param name="response">The parsed response-packet</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Closes the underlying <see cref="T:System.Net.WebSockets.WebSocket"/> and cancels all pending operations + </summary> + <param name="cancellationToken"></param> + <returns></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.CacheClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.CacheHardClear"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClientConfig"> + <summary> + A structure that defines readonly constants for the <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> to use + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.RecvBufferSize"> + <summary> + The size (in bytes) of the internal buffer to use when receiving messages from the server + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.RequestBufferSize"> + <summary> + The size (in bytes) of the <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> internal buffer sizem, when requests are rented from the client + </summary> + <remarks> + This is the entire size of the request buffer including headers and payload data, unless + data is streamed to the server + </remarks> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.ResponseHeaderBufSize"> + <summary> + The size (in chars) of the client response message header buffer + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.MaxMessageSize"> + <summary> + The maximum size (in bytes) of messages sent or recieved from the server + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.BufferHeap"> + <summary> + The heap to allocate interal (and message) buffers from + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.KeepAliveInterval"> + <summary> + The websocket keepalive interval to use (leaving this property default disables keepalives) + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.SubProtocol"> + <summary> + The websocket sub-protocol to use + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase"> + <summary> + A base class for objects that implement <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> + operations + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.SocketOptions"> + <summary> + Allows configuration of websocket configuration options + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Client"> + <summary> + The <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> to sent requests from + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Connected"> + <summary> + Raised when the client has connected successfully + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.ConnectionClosed"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.InitClient(VNLib.Net.Messaging.FBM.Client.FBMClientConfig)"> + <summary> + Creates and initializes a the internal <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> + </summary> + <param name="config">The client config</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asynchronously connects to a remote server by the specified uri + </summary> + <param name="serverUri">The remote uri of a server to connect to</param> + <param name="cancellationToken">A token to cancel the connect operation</param> + <returns>A task that compeltes when the client has connected to the remote server</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Asynchronously disonnects a client only if the client is currently connected, + returns otherwise + </summary> + <param name="cancellationToken"></param> + <returns>A task that compeltes when the client has disconnected</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnConnected"> + <summary> + Invoked when a client has successfully connected to the remote server + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnDisconnected"> + <summary> + Invoked when the client has disconnected cleanly + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnError(VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs)"> + <summary> + Invoked when the connected client is closed because of a connection error + </summary> + <param name="e">A <see cref="T:System.EventArgs"/> that contains the client error data</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"> + <summary> + A reusable Fixed Buffer Message request container. This class is not thread-safe + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.Length"> + <summary> + The size (in bytes) of the request message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.MessageId"> + <summary> + The id of the current request message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.RequestData"> + <summary> + The request message packet + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.ResponseWaitEvent"> + <summary> + An <see cref="!:AsyncManualResetEvent"/> to signal request/response + event completion + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.#ctor(System.Int32,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> with the sepcified message buffer size, + and a random messageid + </summary> + <param name="bufferSize">The fixed size of the request buffer</param> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.#ctor(System.Int32,System.Int32,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> with the sepcified message buffer size and a custom MessageId + </summary> + <param name="messageId">The custom message id</param> + <param name="bufferSize">The fixed size of the request buffer</param> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteMessageId"> + <summary> + Resets the internal buffer and writes the message-id header to the begining + of the buffer + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteBody(System.ReadOnlySpan{System.Byte}@,VNLib.Net.ContentType)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.GetBodyWriter"> + <summary> + Returns buffer writer for writing the body data to the internal message buffer + </summary> + <returns>A <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest.BufferWriter"/> to write message body to</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Reset"> + <summary> + Resets the internal buffer and allows for writing a new message with + the same message-id + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMResponse"> + <summary> + A disposeable Fixed Buffer Message response container + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMResponse.IsSet"> + <summary> + True when a response body was recieved and properly parsed + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.MessagePacket"> + <summary> + The raw response message packet + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.Headers"> + <summary> + A collection of response message headers + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.StatusFlags"> + <summary> + Status flags of the message parse operation + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.ResponseBody"> + <summary> + The body segment of the response message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMResponse.#ctor(VNLib.Utils.IO.VnMemoryStream,System.Int32)"> + <summary> + Initailzies a response message structure and parses response + packet structure + </summary> + <param name="vms">The message buffer (message packet)</param> + <param name="headerBufferSize">The size of the buffer to alloc for header value storage</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMResponse.Dispose"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs"> + <summary> + <see cref="T:System.EventArgs"/> that is raised when an error occurs + in the background listener loop + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs.ErrorClient"> + <summary> + The client that the exception was raised from + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs.Cause"> + <summary> + The exception that was raised + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.IFBMMessage"> + <summary> + Represents basic Fixed Buffer Message protocol operations + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.IFBMMessage.MessageId"> + <summary> + The unique id of the message (nonzero) + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteBody(System.ReadOnlySpan{System.Byte}@,VNLib.Net.ContentType)"> + <summary> + Writes a data body to the message of the specified content type + </summary> + <param name="body">The body of the message to copy</param> + <param name="contentType">The content type of the message body</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char}@)"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="header">The header id</param> + <param name="value">The value of the header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char}@)"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="header">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> of the header</param> + <param name="value">The value of the header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.IStatefulConnection"> + <summary> + An abstraction for a stateful connection client that reports its status + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.ConnectionClosed"> + <summary> + An event that is raised when the connection state has transition from connected to disconnected + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Connects the client to the remote resource + </summary> + <param name="serverUri">The resource location to connect to</param> + <param name="cancellationToken">A token to cancel the connect opreation</param> + <returns>A task that compeltes when the connection has succedded</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Gracefully disconnects the client from the remote resource + </summary> + <param name="cancellationToken">A token to cancel the disconnect operation</param> + <returns>A task that completes when the client has been disconnected</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket"> + <summary> + A wrapper container to manage client websockets + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Headers"> + <summary> + A collection of headers to add to the client + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.#ctor(System.Int32,System.Int32,System.TimeSpan,System.String)"> + <summary> + Initiaizes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket"/> that accepts an optional sub-protocol for connections + </summary> + <param name="txBufferSize">The size (in bytes) of the send buffer size</param> + <param name="rxBufferSize">The size (in bytes) of the receive buffer size to use</param> + <param name="keepAlive">The WS keepalive interval</param> + <param name="subProtocol">The optional sub-protocol to use</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asyncrhonously prepares a new client web-socket and connects to the remote endpoint + </summary> + <param name="serverUri">The endpoint to connect to</param> + <param name="token">A token to cancel the connect operation</param> + <returns>A task that compeltes when the client has connected</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Cleanup"> + <summary> + Cleans up internal resources to prepare for another connection + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseStatus"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseStatusDescription"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.State"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SubProtocol"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Abort"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseOutputAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ReceiveAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ReceiveAsync(System.ArraySegment{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SendAsync(System.ReadOnlyMemory{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SendAsync(System.ArraySegment{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Dispose"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.HeaderCommand"> + <summary> + A Fixed Buffer Message header command value + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.NOT_USED"> + <summary> + Default, do not use + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.MessageId"> + <summary> + Specifies the header for a message-id + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Location"> + <summary> + Specifies a resource location + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.ContentType"> + <summary> + Specifies a standard MIME content type header + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Action"> + <summary> + Specifies an action on a request + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Status"> + <summary> + Specifies a status header + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.HeaderParseStatus"> + <summary> + Specifies the results of a response parsing operation + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Helpers"> + <summary> + Contains FBM library helper methods + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Helpers.CONTROL_FRAME_MID"> + <summary> + The message-id of a connection control frame / out of band message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetMessageId(System.ReadOnlySpan{System.Byte})"> + <summary> + Parses the header line for a message-id + </summary> + <param name="line">A sequence of bytes that make up a header line</param> + <returns>The message-id if parsed, -1 if message-id is not valid</returns> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Helpers.RandomMessageId"> + <summary> + Alloctes a random integer to use as a message id + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetRemainingData(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Gets the remaining data after the current position of the stream. + </summary> + <param name="response">The stream to segment</param> + <returns>The remaining data segment</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.ReadLine(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Reads the next available line from the response message + </summary> + <param name="response"></param> + <returns>The read line</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.ParseHeaders(VNLib.Utils.IO.VnMemoryStream,System.Char[],System.Collections.Generic.ICollection{System.Collections.Generic.KeyValuePair{VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlyMemory{System.Char}}})"> + <summary> + Parses headers from the request stream, stores headers from the buffer into the + header collection + </summary> + <param name="vms">The FBM packet buffer</param> + <param name="buffer">The header character buffer to write headers to</param> + <param name="headers">The collection to store headers in</param> + <returns>The results of the parse operation</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetHeaderCommand(System.ReadOnlySpan{System.Byte})"> + <summary> + Gets a <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> enum from the first byte of the message + </summary> + <param name="line"></param> + <returns>The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> enum value from hte first byte of the message</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetHeaderValue(System.ReadOnlySpan{System.Byte},System.Span{System.Char})"> + <summary> + Gets the value of the header following the colon bytes in the specifed + data message data line + </summary> + <param name="line">The message header line to get the value of</param> + <param name="output">The output character buffer to write characters to</param> + <returns>The number of characters encoded</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteHeader(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Byte,System.ReadOnlySpan{System.Char},System.Text.Encoding)"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="buffer"></param> + <param name="header">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> of the header</param> + <param name="value">The value of the header</param> + <param name="encoding">Encoding to use when writing character message</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteBody(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.ReadOnlySpan{System.Byte})"> + <summary> + Ends the header section of the request and appends the message body to + the end of the request + </summary> + <param name="buffer"></param> + <param name="body">The message body to send with request</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteTermination(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@)"> + <summary> + Writes a line termination to the message buffer + </summary> + <param name="buffer"></param> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.dll Binary files differnew file mode 100644 index 0000000..682c591 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.xml new file mode 100644 index 0000000..e268aeb --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.Server.xml @@ -0,0 +1,278 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Net.Messaging.FBM.Server</name> + </assembly> + <members> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMContext"> + <summary> + A request/response pair message context + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMContext.Request"> + <summary> + The request message to process + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMContext.Response"> + <summary> + The response message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMContext.#ctor(System.Int32,System.Int32)"> + <summary> + Creates a new reusable <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMContext"/> + for use within a <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> + cache + </summary> + <param name="requestHeaderBufferSize">The size in characters of the request header buffer</param> + <param name="responseHeaderBufferSize">The size in characters of the response header buffer</param> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.RequestHandler"> + <summary> + Method delegate for processing FBM messages from an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + when messages are received + </summary> + <param name="context">The message/connection context</param> + <param name="userState">The state parameter passed on client connected</param> + <param name="cancellationToken">A token that reflects the state of the listener</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that resolves when processing is complete</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListener"> + <summary> + A FBM protocol listener. Listens for messages on a <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> + and raises events on requests. + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Server.FBMListener.OnProcessError"> + <summary> + Raised when a response processing error occured + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.#ctor(System.Int32,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Creates a new <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> instance ready for + processing connections + </summary> + <param name="sendBufferSize">The size (in bytes) of the size of the buffer used to send data to the client</param> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ListenAsync(VNLib.Plugins.Essentials.WebSocketSession,VNLib.Net.Messaging.FBM.Server.RequestHandler,VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams,System.Object)"> + <summary> + Begins listening for requests on the current websocket until + a close message is received or an error occurs + </summary> + <param name="wss">The <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> to receive messages on</param> + <param name="handler"></param> + <param name="args">The arguments used to configured this listening session</param> + <param name="userState">A state parameter</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the connection closes</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ProcessOOBAsync(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Processes an out-of-band request message (internal communications) + </summary> + <param name="outOfBandContext">The <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMContext"/> containing the OOB message</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the operation completes</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListenerBase"> + <summary> + Provides a simple base class for an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + processor + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Listener"> + <summary> + The initialzied listener + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Log"> + <summary> + A provider to write log information to + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.InitListener(System.Int32,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes the <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + </summary> + <param name="sendBufferSize">The size (in bytes) of the transmit buffer</param> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Listener_OnProcessError(System.Object,System.Exception)"> + <summary> + A single event service routine for servicing errors that occur within + the listener loop + </summary> + <param name="sender"></param> + <param name="e">The exception that was raised</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.ListenAsync(VNLib.Plugins.Essentials.WebSocketSession,VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams,System.Object)"> + <summary> + Begins listening for requests on the current websocket until + a close message is received or an error occurs + </summary> + <param name="wss">The <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> to receive messages on</param> + <param name="args">The arguments used to configured this listening session</param> + <param name="userState">A state token to use for processing events for this connection</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the connection closes</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.ProcessAsync(VNLib.Net.Messaging.FBM.Server.FBMContext,System.Object,System.Threading.CancellationToken)"> + <summary> + A method to service an incoming message + </summary> + <param name="context">The context containing the message to be serviced</param> + <param name="userState">A state token passed on client connected</param> + <param name="exitToken">A token that reflects the state of the listener</param> + <returns>A task that completes when the message has been serviced</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams"> + <summary> + Represents a configuration structure for an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + listening session + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.RecvBufferSize"> + <summary> + The size of the buffer to use while reading data from the websocket + in the listener loop + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.MaxHeaderBufferSize"> + <summary> + The size of the character buffer to store FBMheader values in + the <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"/> + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.MaxMessageSize"> + <summary> + The absolute maxium size (in bytes) message to process before + closing the websocket connection. This value should be negotiaed + by clients or hard-coded to avoid connection issues + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"> + <summary> + Represents a client request message to be serviced + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.#ctor(System.Int32)"> + <summary> + Creates a new resusable <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"/> + </summary> + <param name="headerBufferSize">The size of the buffer to alloc during initialization</param> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.MessageId"> + <summary> + The ID of the current message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.ConnectionId"> + <summary> + Gets the underlying socket-id fot the current connection + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.RequestBody"> + <summary> + The raw request message, positioned to the body section of the message data + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.Headers"> + <summary> + A collection of headers for the current request + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.ParseStatus"> + <summary> + Status flags set during the message parsing + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.BodyData"> + <summary> + The message body data as a <see cref="T:System.ReadOnlySpan`1"/> + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.IsControlFrame"> + <summary> + Determines if the current message is considered a control frame + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.Prepare(VNLib.Utils.IO.VnMemoryStream,VNLib.Plugins.Essentials.WebSocketSession)"> + <summary> + Prepares the request to be serviced + </summary> + <param name="vms">The request data packet</param> + <param name="wss">The connection to service</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.DeserializeBody``1(System.Text.Json.JsonSerializerOptions)"> + <summary> + Deserializes the request body into a new specified object type + </summary> + <typeparam name="T">The type of the object to deserialize</typeparam> + <param name="jso">The <see cref="T:System.Text.Json.JsonSerializerOptions"/> to use while deserializing data</param> + <returns>The deserialized object from the request body</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.GetBodyAsJson"> + <summary> + Gets a <see cref="T:System.Text.Json.JsonDocument"/> of the request body + </summary> + <returns>The parsed <see cref="T:System.Text.Json.JsonDocument"/> if parsed successfully, or null otherwise</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage"> + <summary> + Represents an FBM request response container. + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.HeaderBufferSize"> + <summary> + The size (in bytes) of the response header buffer. + The client may suggest a limit to the size of this buffer + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.MessageId"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.Prepare(System.Int32)"> + <summary> + Initializes the response message with the specified message-id + to respond with + </summary> + <param name="messageId">The message id of the context to respond to</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char})"> + <summary> + Appends a header to the response message + </summary> + <param name="cmd">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/></param> + <param name="value">The value of the response header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char})"> + <summary> + Appends a header to the response message + </summary> + <param name="cmd">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/></param> + <param name="value">The value of the response header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.SetResponseBody(System.IO.Stream)"> + <summary> + Sets the streamable message body for the response + </summary> + <param name="payload">The payload data to stream to request</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteBody(System.ReadOnlySpan{System.Byte},VNLib.Net.ContentType)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.ReadAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <summary> + Reads headers and message body as a stream. + </summary> + <param name="buffer">The buffer to write data to</param> + <param name="cancellationToken"></param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that resolves the number of bytes written to the buffer</returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.dll Binary files differnew file mode 100644 index 0000000..412c7d8 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.xml new file mode 100644 index 0000000..9f65023 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Messaging.FBM.xml @@ -0,0 +1,1129 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Net.Messaging.FBM</name> + </assembly> + <members> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.WriteLocation(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.ReadOnlySpan{System.Char})"> + <summary> + Writes the location header of the requested resource + </summary> + <param name="request"></param> + <param name="location">The location address</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.WriteLocation(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.Uri)"> + <summary> + Writes the location header of the requested resource + </summary> + <param name="request"></param> + <param name="location">The location address</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ClientExtensions.ThrowIfNotSet(VNLib.Net.Messaging.FBM.Client.FBMResponse@)"> + <summary> + If the <see cref="F:VNLib.Net.Messaging.FBM.Client.FBMResponse.IsSet"/> property is false, raises an <see cref="T:VNLib.Net.Messaging.FBM.InvalidResponseException"/> + </summary> + <param name="response"></param> + <exception cref="T:VNLib.Net.Messaging.FBM.InvalidResponseException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClient"> + <summary> + A Fixed Buffer Message Protocol client. Allows for high performance client-server messaging + with minimal memory overhead. + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_RECV_BUF_QUERY_ARG"> + <summary> + The WS connection query arguments to specify a receive buffer size + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_HEAD_BUF_QUERY_ARG"> + <summary> + The WS connection query argument to suggest a maximum response header buffer size + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMClient.REQ_MAX_MESS_QUERY_ARG"> + <summary> + The WS connection query argument to suggest a maximum message size + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionClosedOnError"> + <summary> + Raised when the websocket has been closed because an error occured. + You may inspect the event args to determine the cause of the error. + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionClosed"> + <summary> + Raised when the client listener operaiton has completed as a normal closure + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.Config"> + <summary> + The configuration for the current client + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectionStatusHandle"> + <summary> + A handle that is reset when a connection has been successfully set, and is set + when the connection exists + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ClientSocket"> + <summary> + The <see cref="T:System.Net.WebSockets.ClientWebSocket"/> to send/recieve message on + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClient.ControlFrame"> + <summary> + Gets the shared control frame for the current instance. The request is reset when + this property is called. (Not thread safe) + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.#ctor(VNLib.Net.Messaging.FBM.Client.FBMClientConfig)"> + <summary> + Creates a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> in a closed state + </summary> + <param name="config">The client configuration</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReuseableRequestConstructor"> + <summary> + Allocates and configures a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> message object for use within the reusable store + </summary> + <returns>The configured <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asynchronously opens a websocket connection with the specifed remote server + </summary> + <param name="address">The address of the server to connect to</param> + <param name="cancellation">A cancellation token</param> + <returns></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.RentRequest"> + <summary> + Rents a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> from the internal <see cref="T:VNLib.Utils.Memory.Caching.ReusableStore`1"/>. + Use <see cref="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReturnRequest(VNLib.Net.Messaging.FBM.Client.FBMRequest)"/> when request is no longer in use + </summary> + <returns>The configured (rented or new) <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> ready for use</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ReturnRequest(VNLib.Net.Messaging.FBM.Client.FBMRequest)"> + <summary> + Stores (or returns) the reusable request in cache for use with <see cref="M:VNLib.Net.Messaging.FBM.Client.FBMClient.RentRequest"/> + </summary> + <param name="request">The request to return to the store</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.SendAsync(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.Threading.CancellationToken)"> + <summary> + Sends a <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> to the connected server + </summary> + <param name="request">The request message to send to the server</param> + <param name="cancellationToken"></param> + <returns>When awaited, yields the server response</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Messaging.FBM.FBMInvalidRequestException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.StreamDataAsync(VNLib.Net.Messaging.FBM.Client.FBMRequest,System.IO.Stream,VNLib.Net.ContentType,System.Threading.CancellationToken)"> + <summary> + Streams arbitrary binary data to the server with the initial request message + </summary> + <param name="request">The request message to send to the server</param> + <param name="payload">Data to stream to the server</param> + <param name="ct">The content type of the stream of data</param> + <param name="cancellationToken"></param> + <returns>When awaited, yields the server response</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessContinuousRecvAsync"> + <summary> + Begins listening for messages from the server on the internal socket (must be connected), + until the socket is closed, or canceled + </summary> + <returns></returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessResponse(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Syncrhonously processes a buffered response packet + </summary> + <param name="responseMessage">The buffered response body recieved from the server</param> + <remarks>This method blocks the listening task. So operations should be quick</remarks> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessControlFrame(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Processes a control frame response from the server + </summary> + <param name="vms">The raw response packet from the server</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.ProcessControlFrame(VNLib.Net.Messaging.FBM.Client.FBMResponse@)"> + <summary> + Processes a control frame response from the server + </summary> + <param name="response">The parsed response-packet</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Closes the underlying <see cref="T:System.Net.WebSockets.WebSocket"/> and cancels all pending operations + </summary> + <param name="cancellationToken"></param> + <returns></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.CacheClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClient.CacheHardClear"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClientConfig"> + <summary> + A structure that defines readonly constants for the <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> to use + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.RecvBufferSize"> + <summary> + The size (in bytes) of the internal buffer to use when receiving messages from the server + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.MessageBufferSize"> + <summary> + The size (in bytes) of the <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> internal buffer size, when requests are rented from the client + </summary> + <remarks> + This is the entire size of the request buffer including headers and payload data, unless + data is streamed to the server + </remarks> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.MaxHeaderBufferSize"> + <summary> + The size (in chars) of the client/server message header buffer + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.MaxMessageSize"> + <summary> + The maximum size (in bytes) of messages sent or recieved from the server + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.BufferHeap"> + <summary> + The heap to allocate interal (and message) buffers from + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.KeepAliveInterval"> + <summary> + The websocket keepalive interval to use (leaving this property default disables keepalives) + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.SubProtocol"> + <summary> + The websocket sub-protocol to use + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.HeaderEncoding"> + <summary> + The encoding instance used to encode header values + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientConfig.DebugLog"> + <summary> + An optional log provider to write debug logs to. If this propery is not null, + debugging information will be logged with the debug log-level + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase"> + <summary> + A base class for objects that implement <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> + operations + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.SocketOptions"> + <summary> + Allows configuration of websocket configuration options + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Client"> + <summary> + The <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> to sent requests from + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Connected"> + <summary> + Raised when the client has connected successfully + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.ConnectionClosed"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.InitClient(VNLib.Net.Messaging.FBM.Client.FBMClientConfig@)"> + <summary> + Creates and initializes a the internal <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMClient"/> + </summary> + <param name="config">The client config</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asynchronously connects to a remote server by the specified uri + </summary> + <param name="serverUri">The remote uri of a server to connect to</param> + <param name="cancellationToken">A token to cancel the connect operation</param> + <returns>A task that compeltes when the client has connected to the remote server</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Asynchronously disonnects a client only if the client is currently connected, + returns otherwise + </summary> + <param name="cancellationToken"></param> + <returns>A task that compeltes when the client has disconnected</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnConnected"> + <summary> + Invoked when a client has successfully connected to the remote server + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnDisconnected"> + <summary> + Invoked when the client has disconnected cleanly + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.OnError(VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs)"> + <summary> + Invoked when the connected client is closed because of a connection error + </summary> + <param name="e">A <see cref="T:System.EventArgs"/> that contains the client error data</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"> + <summary> + A reusable Fixed Buffer Message request container. This class is not thread-safe + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.Length"> + <summary> + The size (in bytes) of the request message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.MessageId"> + <summary> + The id of the current request message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.RequestData"> + <summary> + The request message packet + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMRequest.ResponseWaitEvent"> + <summary> + An <see cref="T:System.Threading.ManualResetEvent"/> to signal request/response + event completion + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.#ctor(VNLib.Net.Messaging.FBM.Client.FBMClientConfig@)"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> with the sepcified message buffer size, + and a random messageid + </summary> + <param name="config">The fbm client config storing required config variables</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.#ctor(System.Int32,VNLib.Net.Messaging.FBM.Client.FBMClientConfig@)"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest"/> with the sepcified message buffer size and a custom MessageId + </summary> + <param name="messageId">The custom message id</param> + <param name="config">The fbm client config storing required config variables</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteMessageId"> + <summary> + Resets the internal buffer and writes the message-id header to the begining + of the buffer + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.WriteBody(System.ReadOnlySpan{System.Byte},VNLib.Net.ContentType)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.GetBodyWriter"> + <summary> + Returns buffer writer for writing the body data to the internal message buffer + </summary> + <returns>A <see cref="T:VNLib.Net.Messaging.FBM.Client.FBMRequest.BufferWriter"/> to write message body to</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Reset"> + <summary> + Resets the internal buffer and allows for writing a new message with + the same message-id + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.GetResponse"> + <summary> + Gets the response of the sent message + </summary> + <returns>The response message for the current request</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Compile"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Compile(VNLib.Utils.Memory.ForwardOnlyWriter{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.Compile(System.Span{System.Char}@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMRequest.ToString"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FBMResponse"> + <summary> + A Fixed Buffer Message client response linked to the request that generated it. + Once the request is disposed or returned this message state is invalid + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Client.FBMResponse.IsSet"> + <summary> + True when a response body was recieved and properly parsed + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.MessagePacket"> + <summary> + The raw response message packet + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.Headers"> + <summary> + A collection of response message headers + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.StatusFlags"> + <summary> + Status flags of the message parse operation + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FBMResponse.ResponseBody"> + <summary> + The body segment of the response message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMResponse.#ctor(VNLib.Utils.IO.VnMemoryStream,VNLib.Net.Messaging.FBM.HeaderParseStatus,System.Collections.Generic.IReadOnlyList{System.Collections.Generic.KeyValuePair{VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlyMemory{System.Char}}},System.Action)"> + <summary> + Initailzies a response message structure and parses response + packet structure + </summary> + <param name="vms">The message buffer (message packet)</param> + <param name="status">The size of the buffer to alloc for header value storage</param> + <param name="headerList">The collection of headerse</param> + <param name="onDispose">A method that will be invoked when the message response body is disposed</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMResponse.#ctor"> + <summary> + Creates an unset response structure + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.FBMResponse.Dispose"> + <summary> + Releases any resources associated with the response message + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs"> + <summary> + <see cref="T:System.EventArgs"/> that is raised when an error occurs + in the background listener loop + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs.ErrorClient"> + <summary> + The client that the exception was raised from + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs.Cause"> + <summary> + The exception that was raised + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.IFBMMessage"> + <summary> + Represents basic Fixed Buffer Message protocol operations + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.IFBMMessage.MessageId"> + <summary> + The unique id of the message (nonzero) + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteBody(System.ReadOnlySpan{System.Byte},VNLib.Net.ContentType)"> + <summary> + Writes a data body to the message of the specified content type + </summary> + <param name="body">The body of the message to copy</param> + <param name="contentType">The content type of the message body</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char})"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="header">The header id</param> + <param name="value">The value of the header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IFBMMessage.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char})"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="header">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> of the header</param> + <param name="value">The value of the header</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.IStatefulConnection"> + <summary> + An abstraction for a stateful connection client that reports its status + </summary> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.ConnectionClosed"> + <summary> + An event that is raised when the connection state has transition from connected to disconnected + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Connects the client to the remote resource + </summary> + <param name="serverUri">The resource location to connect to</param> + <param name="cancellationToken">A token to cancel the connect opreation</param> + <returns>A task that compeltes when the connection has succedded</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.IStatefulConnection.DisconnectAsync(System.Threading.CancellationToken)"> + <summary> + Gracefully disconnects the client from the remote resource + </summary> + <param name="cancellationToken">A token to cancel the disconnect operation</param> + <returns>A task that completes when the client has been disconnected</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket"> + <summary> + A wrapper container to manage client websockets + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Headers"> + <summary> + A collection of headers to add to the client + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.#ctor(System.Int32,System.Int32,System.TimeSpan,System.String)"> + <summary> + Initiaizes a new <see cref="T:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket"/> that accepts an optional sub-protocol for connections + </summary> + <param name="txBufferSize">The size (in bytes) of the send buffer size</param> + <param name="rxBufferSize">The size (in bytes) of the receive buffer size to use</param> + <param name="keepAlive">The WS keepalive interval</param> + <param name="subProtocol">The optional sub-protocol to use</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ConnectAsync(System.Uri,System.Threading.CancellationToken)"> + <summary> + Asyncrhonously prepares a new client web-socket and connects to the remote endpoint + </summary> + <param name="serverUri">The endpoint to connect to</param> + <param name="token">A token to cancel the connect operation</param> + <returns>A task that compeltes when the client has connected</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Cleanup"> + <summary> + Cleans up internal resources to prepare for another connection + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseStatus"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseStatusDescription"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.State"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SubProtocol"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Abort"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.CloseOutputAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ReceiveAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.ReceiveAsync(System.ArraySegment{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SendAsync(System.ReadOnlyMemory{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.SendAsync(System.ArraySegment{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Client.ManagedClientWebSocket.Dispose"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.HeaderCommand"> + <summary> + A Fixed Buffer Message header command value + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.NOT_USED"> + <summary> + Default, do not use + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.MessageId"> + <summary> + Specifies the header for a message-id + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Location"> + <summary> + Specifies a resource location + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.ContentType"> + <summary> + Specifies a standard MIME content type header + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Action"> + <summary> + Specifies an action on a request + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.HeaderCommand.Status"> + <summary> + Specifies a status header + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.HeaderParseStatus"> + <summary> + Specifies the results of a response parsing operation + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Helpers"> + <summary> + Contains FBM library helper methods + </summary> + </member> + <member name="F:VNLib.Net.Messaging.FBM.Helpers.CONTROL_FRAME_MID"> + <summary> + The message-id of a connection control frame / out of band message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetMessageId(System.ReadOnlySpan{System.Byte})"> + <summary> + Parses the header line for a message-id + </summary> + <param name="line">A sequence of bytes that make up a header line</param> + <returns>The message-id if parsed, -1 if message-id is not valid</returns> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Helpers.RandomMessageId"> + <summary> + Alloctes a random integer to use as a message id + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetRemainingData(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Gets the remaining data after the current position of the stream. + </summary> + <param name="response">The stream to segment</param> + <returns>The remaining data segment</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.ReadLine(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Reads the next available line from the response message + </summary> + <param name="response"></param> + <returns>The read line</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.ParseHeaders(VNLib.Utils.IO.VnMemoryStream,System.Char[],System.Collections.Generic.ICollection{System.Collections.Generic.KeyValuePair{VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlyMemory{System.Char}}},System.Text.Encoding)"> + <summary> + Parses headers from the request stream, stores headers from the buffer into the + header collection + </summary> + <param name="vms">The FBM packet buffer</param> + <param name="buffer">The header character buffer to write headers to</param> + <param name="headers">The collection to store headers in</param> + <param name="encoding">The encoding type used to deocde header values</param> + <returns>The results of the parse operation</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetHeaderCommand(System.ReadOnlySpan{System.Byte})"> + <summary> + Gets a <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> enum from the first byte of the message + </summary> + <param name="line"></param> + <returns>The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> enum value from hte first byte of the message</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.GetHeaderValue(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Text.Encoding)"> + <summary> + Gets the value of the header following the colon bytes in the specifed + data message data line + </summary> + <param name="line">The message header line to get the value of</param> + <param name="output">The output character buffer to write characters to</param> + <param name="encoding">The encoding to decode the specified data with</param> + <returns>The number of characters encoded</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteHeader(VNLib.Utils.Memory.ForwardOnlyWriter{System.Byte}@,System.Byte,System.ReadOnlySpan{System.Char},System.Text.Encoding)"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="buffer"></param> + <param name="header">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> of the header</param> + <param name="value">The value of the header</param> + <param name="encoding">Encoding to use when writing character message</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteBody(VNLib.Utils.Memory.ForwardOnlyWriter{System.Byte}@,System.ReadOnlySpan{System.Byte})"> + <summary> + Ends the header section of the request and appends the message body to + the end of the request + </summary> + <param name="buffer"></param> + <param name="body">The message body to send with request</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteTermination(VNLib.Utils.Memory.ForwardOnlyWriter{System.Byte}@)"> + <summary> + Writes a line termination to the message buffer + </summary> + <param name="buffer"></param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteTermination(VNLib.Utils.IO.IDataAccumulator{System.Byte})"> + <summary> + Writes a line termination to the message buffer + </summary> + <param name="buffer"></param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Helpers.WriteHeader(VNLib.Utils.IO.IDataAccumulator{System.Byte},System.Byte,System.ReadOnlySpan{System.Char},System.Text.Encoding)"> + <summary> + Appends an arbitrary header to the current request buffer + </summary> + <param name="buffer"></param> + <param name="header">The <see cref="T:VNLib.Net.Messaging.FBM.HeaderCommand"/> of the header</param> + <param name="value">The value of the header</param> + <param name="encoding">Encoding to use when writing character message</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.FBMException"> + <summary> + A base exception class for all FBM Library exceptions + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.FBMException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.FBMException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.FBMException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.FBMException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.FBMInvalidRequestException"> + <summary> + Raised when a request message is not in a valid state and cannot be sent + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.InvalidResponseException"> + <summary> + Raised when a response to an FBM request is not in a valid state + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.InvalidResponseException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.InvalidResponseException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.InvalidResponseException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.InvalidResponseException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMContext"> + <summary> + A request/response pair message context + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMContext.Request"> + <summary> + The request message to process + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMContext.Response"> + <summary> + The response message + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMContext.#ctor(System.Int32,System.Int32,System.Text.Encoding)"> + <summary> + Creates a new reusable <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMContext"/> + for use within a <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> + cache + </summary> + <param name="requestHeaderBufferSize">The size in characters of the request header buffer</param> + <param name="responseBufferSize">The size in characters of the response header buffer</param> + <param name="headerEncoding">The message header encoding instance</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMContext.Prepare(VNLib.Utils.IO.VnMemoryStream,System.String)"> + <summary> + Initializes the context with the buffered request data + </summary> + <param name="requestData">The request data buffer positioned at the begining of the request data</param> + <param name="connectionId">The unique id of the connection</param> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.RequestHandler"> + <summary> + Method delegate for processing FBM messages from an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + when messages are received + </summary> + <param name="context">The message/connection context</param> + <param name="userState">The state parameter passed on client connected</param> + <param name="cancellationToken">A token that reflects the state of the listener</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that resolves when processing is complete</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListener"> + <summary> + A FBM protocol listener. Listens for messages on a <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> + and raises events on requests. + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ListeningSession.CancelSession"> + <summary> + Cancels any pending opreations relating to the current session + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ListeningSession.RentContext"> + <summary> + Rents a new <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMContext"/> instance from the pool + and increments the counter + </summary> + <returns>The rented instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ListeningSession.ReturnContext(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Returns a previously rented context to the pool + and decrements the counter. If the session has been + cancelled, when the counter reaches 0, cleanup occurs + </summary> + <param name="ctx">The context to return</param> + </member> + <member name="E:VNLib.Net.Messaging.FBM.Server.FBMListener.OnProcessError"> + <summary> + Raised when a response processing error occured + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.#ctor(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Creates a new <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> instance ready for + processing connections + </summary> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ListenAsync(VNLib.Plugins.Essentials.WebSocketSession,VNLib.Net.Messaging.FBM.Server.RequestHandler,VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams,System.Object)"> + <summary> + Begins listening for requests on the current websocket until + a close message is received or an error occurs + </summary> + <param name="wss">The <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> to receive messages on</param> + <param name="handler">The callback method to handle incoming requests</param> + <param name="args">The arguments used to configured this listening session</param> + <param name="userState">A state parameter</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the connection closes</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListener.ProcessOOBAsync(VNLib.Net.Messaging.FBM.Server.FBMContext)"> + <summary> + Processes an out-of-band request message (internal communications) + </summary> + <param name="outOfBandContext">The <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMContext"/> containing the OOB message</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the operation completes</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListenerBase"> + <summary> + Provides a simple base class for an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + processor + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Listener"> + <summary> + The initialzied listener + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Log"> + <summary> + A provider to write log information to + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.InitListener(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes the <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + </summary> + <param name="heap">The heap to alloc buffers from</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.Listener_OnProcessError(System.Object,System.Exception)"> + <summary> + A single event service routine for servicing errors that occur within + the listener loop + </summary> + <param name="sender"></param> + <param name="e">The exception that was raised</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.ListenAsync(VNLib.Plugins.Essentials.WebSocketSession,VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams,System.Object)"> + <summary> + Begins listening for requests on the current websocket until + a close message is received or an error occurs + </summary> + <param name="wss">The <see cref="T:VNLib.Plugins.Essentials.WebSocketSession"/> to receive messages on</param> + <param name="args">The arguments used to configured this listening session</param> + <param name="userState">A state token to use for processing events for this connection</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> that completes when the connection closes</returns> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMListenerBase.ProcessAsync(VNLib.Net.Messaging.FBM.Server.FBMContext,System.Object,System.Threading.CancellationToken)"> + <summary> + A method to service an incoming message + </summary> + <param name="context">The context containing the message to be serviced</param> + <param name="userState">A state token passed on client connected</param> + <param name="exitToken">A token that reflects the state of the listener</param> + <returns>A task that completes when the message has been serviced</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams"> + <summary> + Represents a configuration structure for an <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> + listening session + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.RecvBufferSize"> + <summary> + The size of the buffer to use while reading data from the websocket + in the listener loop + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.MaxHeaderBufferSize"> + <summary> + The size of the character buffer to store FBMheader values in + the <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"/> + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.ResponseBufferSize"> + <summary> + The size of the internal message response buffer when + not streaming + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.HeaderEncoding"> + <summary> + The FMB message header character encoding + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMListenerSessionParams.MaxMessageSize"> + <summary> + The absolute maxium size (in bytes) message to process before + closing the websocket connection. This value should be negotiaed + by clients or hard-coded to avoid connection issues + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"> + <summary> + Represents a client request message to be serviced + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.#ctor(System.Int32)"> + <summary> + Creates a new resusable <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage"/> + </summary> + <param name="headerBufferSize">The size of the buffer to alloc during initialization</param> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.MessageId"> + <summary> + The ID of the current message + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.ConnectionId"> + <summary> + Gets the underlying socket-id fot the current connection + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.RequestBody"> + <summary> + The raw request message, positioned to the body section of the message data + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.Headers"> + <summary> + A collection of headers for the current request + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.ParseStatus"> + <summary> + Status flags set during the message parsing + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.BodyData"> + <summary> + The message body data as a <see cref="T:System.ReadOnlySpan`1"/> + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.IsControlFrame"> + <summary> + Determines if the current message is considered a control frame + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.Prepare(VNLib.Utils.IO.VnMemoryStream,System.String,System.Text.Encoding)"> + <summary> + Prepares the request to be serviced + </summary> + <param name="vms">The request data packet</param> + <param name="socketId">The unique id of the connection</param> + <param name="dataEncoding">The data encoding used to decode header values</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.DeserializeBody``1(System.Text.Json.JsonSerializerOptions)"> + <summary> + Deserializes the request body into a new specified object type + </summary> + <typeparam name="T">The type of the object to deserialize</typeparam> + <param name="jso">The <see cref="T:System.Text.Json.JsonSerializerOptions"/> to use while deserializing data</param> + <returns>The deserialized object from the request body</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMRequestMessage.GetBodyAsJson"> + <summary> + Gets a <see cref="T:System.Text.Json.JsonDocument"/> of the request body + </summary> + <returns>The parsed <see cref="T:System.Text.Json.JsonDocument"/> if parsed successfully, or null otherwise</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage"> + <summary> + Represents an FBM request response container. + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.MessageId"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.Prepare(System.Int32)"> + <summary> + Initializes the response message with the specified message-id + to respond with + </summary> + <param name="messageId">The message id of the context to respond to</param> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteHeader(VNLib.Net.Messaging.FBM.HeaderCommand,System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteHeader(System.Byte,System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.WriteBody(System.ReadOnlySpan{System.Byte},VNLib.Net.ContentType)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.AddMessageBody(VNLib.Net.Messaging.FBM.IAsyncMessageBody)"> + <summary> + Sets the response message body + </summary> + <param name="messageBody">The <see cref="T:VNLib.Net.Messaging.FBM.IAsyncMessageBody"/> to stream data from</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.FBMResponseMessage.GetResponseDataAsync(System.Threading.CancellationToken)"> + <summary> + Gets the internal message body enumerator and prepares the message for sending + </summary> + <param name="cancellationToken">A cancellation token</param> + <returns>A value task that returns the message body enumerator</returns> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator"> + <summary> + Reusable sliding window impl + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.WindowStartPos"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.WindowEndPos"> + <inheritdoc/> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.Buffer"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.Advance(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.AdvanceStart(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.Reset"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.Prepare"> + <summary> + Allocates the internal message buffer + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.Server.HeaderDataAccumulator.Close"> + <inheritdoc/> + </member> + <member name="T:VNLib.Net.Messaging.FBM.Server.IAsyncMessageReader"> + <summary> + Internal message body reader/enumerator for FBM messages + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.Server.IAsyncMessageReader.DataRemaining"> + <summary> + A value that indicates if there is data remaining after a + </summary> + </member> + <member name="T:VNLib.Net.Messaging.FBM.IAsyncMessageBody"> + <summary> + A disposable message body container for asynchronously reading a variable length message body + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.IAsyncMessageBody.ContentType"> + <summary> + The message body content type + </summary> + </member> + <member name="P:VNLib.Net.Messaging.FBM.IAsyncMessageBody.RemainingSize"> + <summary> + The number of bytes remaining to be read from the message body + </summary> + </member> + <member name="M:VNLib.Net.Messaging.FBM.IAsyncMessageBody.ReadAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <summary> + Reads the next chunk of data from the message body + </summary> + <param name="buffer">The buffer to copy output data to</param> + <param name="token">A token to cancel the operation</param> + <returns></returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Rest.Client.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Rest.Client.dll Binary files differnew file mode 100644 index 0000000..f327f2b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Rest.Client.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.dll Binary files differnew file mode 100644 index 0000000..d4bb001 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.xml new file mode 100644 index 0000000..f05cb68 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Net.Transport.SimpleTCP.xml @@ -0,0 +1,253 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Net.Transport.SimpleTCP</name> + </assembly> + <members> + <member name="M:VNLib.Net.Transport.Extensions.WriteSocketExecption(VNLib.Utils.Logging.ILogProvider,System.Net.Sockets.SocketException)"> + <summary> + Writes the specialized log for a socket exception + </summary> + <param name="log"></param> + <param name="se">The socket exception to log</param> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.Read(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.Read(System.Span{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.ReadAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.Write(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.Write(System.ReadOnlySpan{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.Dispose"> + <summary> + Not supported + </summary> + </member> + <member name="M:VNLib.Net.Transport.ReusableNetworkStream.DisposeInternal"> + <summary> + Disposes the stream + </summary> + </member> + <member name="M:VNLib.Net.Transport.SocketPipeLineWorker.Start(System.Net.Sockets.Socket)"> + <summary> + Begins async work to receive and send data on a connected socket + </summary> + <param name="client">The socket to read/write from</param> + <param name="token">A token to cancel any async operations</param> + </member> + <member name="T:VNLib.Net.Transport.TCPConfig"> + <summary> + Represents the required configuration variables for the transport + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.LocalEndPoint"> + <summary> + The <see cref="T:System.Net.IPEndPoint"/> the listening socket will bind to + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.Log"> + <summary> + The log provider used to write logging information to + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.ListenerPriority"> + <summary> + The listening thread priority + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.TcpKeepAliveTime"> + <summary> + If TCP keepalive is enabled, the amount of time the connection is considered alive before another probe message is sent + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.KeepaliveInterval"> + <summary> + If TCP keepalive is enabled, the amount of time the connection will wait for a keepalive message + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.TcpKeepalive"> + <summary> + Enables TCP keepalive + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.AuthenticationOptions"> + <summary> + The authentication options to use for processing TLS connections. This value must be set when a certificate has been specified + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.AcceptThreads"> + <summary> + The maximum number of waiting WSA asynchronous socket accept operations + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.InitialReceiveTimeout"> + <summary> + Specifies the amount of time in miliseconds for a newly accepted socket to wait for + the intial receive before closing the connection and releasing the listening thread + back to the pool. + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.MaxRecvBufferData"> + <summary> + The maximum size (in bytes) the transport will buffer in + the receiving pipeline. + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.BackLog"> + <summary> + The listener socket backlog value + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.BufferPool"> + <summary> + The <see cref="T:System.Buffers.ArrayPool`1"/> to allocate pre-load buffers from + </summary> + </member> + <member name="P:VNLib.Net.Transport.TCPConfig.CacheQuota"> + <summary> + <para> + The maxium number of event objects that will be cached + during normal operation + </para> + <para> + WARNING: Setting this value too low will cause significant CPU overhead and GC load + </para> + </summary> + </member> + <member name="T:VNLib.Net.Transport.DataReceived"> + <summary> + Event delegate used to receive event notifications from a <see cref="T:VNLib.Net.Transport.TcpServer"/> + instance + </summary> + <param name="sender">The <see cref="T:VNLib.Net.Transport.TcpServer"/> that received the request</param> + <param name="context">A structure of the captured context</param> + <returns></returns> + </member> + <member name="T:VNLib.Net.Transport.TcpServer"> + <summary> + <para> + Provides a simple, high performance, single process, low/no allocation, + asynchronous, event driven, TCP socket server. + </para> + <para> + IO operations are full duplex so pipe-lining reused + connections is expected. This class cannot be inherited + </para> + </summary> + </member> + <member name="P:VNLib.Net.Transport.TcpServer.Config"> + <summary> + The current <see cref="T:VNLib.Net.Transport.TcpServer"/> configuration + </summary> + </member> + <member name="P:VNLib.Net.Transport.TcpServer.Running"> + <summary> + Gets a value indicating if the server's listening thread is alive + </summary> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.#ctor(VNLib.Net.Transport.TCPConfig)"> + <summary> + Initializes a new <see cref="T:VNLib.Net.Transport.TcpServer"/> with the specified <see cref="T:VNLib.Net.Transport.TCPConfig"/> + </summary> + <param name="config">Configuration to inalize with</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.CacheClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.CacheHardClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.Start(System.Threading.CancellationToken)"> + <summary> + Begins listening for incoming TCP connections on the configured socket + </summary> + <param name="token">A token that is used to abort listening operations and close the socket</param> + <exception cref="T:System.Net.Sockets.SocketException"></exception> + <exception cref="T:System.Security.SecurityException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.AcceptAsync"> + <summary> + Retreives a connected socket from the waiting queue + </summary> + <returns>The context of the connect</returns> + </member> + <member name="M:VNLib.Net.Transport.TcpServer.CloseConnectionAsync(VNLib.Net.Transport.TransportEventContext)"> + <summary> + Closes a connect and cleans up any resources + </summary> + <param name="ctx"></param> + <returns></returns> + </member> + <member name="T:VNLib.Net.Transport.TransportEventContext"> + <summary> + Represents the context of a transport connection. It includes the active socket + and a stream representing the active transport. + </summary> + </member> + <member name="P:VNLib.Net.Transport.TransportEventContext.SslVersion"> + <summary> + The transport security layer security protocol + </summary> + </member> + <member name="P:VNLib.Net.Transport.TransportEventContext.LocalEndPoint"> + <summary> + A copy of the local endpoint of the listening socket + </summary> + </member> + <member name="P:VNLib.Net.Transport.TransportEventContext.RemoteEndpoint"> + <summary> + The <see cref="T:System.Net.IPEndPoint"/> representing the client's connection information + </summary> + </member> + <member name="F:VNLib.Net.Transport.TransportEventContext.ConnectionStream"> + <summary> + The transport stream to be actively read + </summary> + </member> + <member name="F:VNLib.Net.Transport.TransportEventContext.Socket"> + <summary> + The socket referrence to the incoming connection + </summary> + </member> + <member name="M:VNLib.Net.Transport.VnSocketAsyncArgs.BeginAccept(System.Net.Sockets.Socket)"> + <summary> + Begins an asynchronous accept operation on the current (bound) socket + </summary> + <param name="sock">The server socket to accept the connection</param> + <returns>True if the IO operation is pending</returns> + </member> + <member name="M:VNLib.Net.Transport.VnSocketAsyncArgs.EndAccept"> + <summary> + Determines if an asynchronous accept operation has completed successsfully + and the socket is connected. + </summary> + <returns>True if the accept was successful, and the accepted socket is connected, false otherwise</returns> + </member> + <member name="M:VNLib.Net.Transport.VnSocketAsyncArgs.Disconnect"> + <summary> + Begins an async disconnect operation on a currentl connected socket + </summary> + <returns>True if the operation is pending</returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.dll Binary files differnew file mode 100644 index 0000000..7f6d6ae --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.xml new file mode 100644 index 0000000..7c0f180 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.Sessions.Cache.xml @@ -0,0 +1,62 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Essentials.Sessions.Cache</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Essentials.Sessions.Cache.ChangeEvent"> + <summary> + An event object that is passed when change events occur + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore"> + <summary> + A <see cref="T:VNLib.Net.Messaging.FBM.Server.FBMListener"/> that caches, persists, and serves data to clients + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.Log"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.EventQueue"> + <summary> + A queue that stores update and delete events + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.#ctor(System.IO.DirectoryInfo,System.Int32,VNLib.Utils.Logging.ILogProvider,System.Int32,VNLib.Utils.Memory.IUnmangedHeap,System.Boolean)"> + <summary> + Initialzies a new <see cref="T:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore"/> + </summary> + <param name="dir">The <see cref="T:System.IO.DirectoryInfo"/> to store blob files to</param> + <param name="cacheMax"></param> + <param name="log"></param> + <param name="sendBufferSize"></param> + <param name="heap"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.ProcessAsync(VNLib.Net.Messaging.FBM.Server.FBMContext,System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.DeleteItemAsync(System.String)"> + <summary> + Asynchronously deletes a previously stored item + </summary> + <param name="id">The id of the object to delete</param> + <returns>A task that completes when the item has been deleted</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.AddOrUpdateBlobAsync``1(System.String,System.String,VNLib.Plugins.Essentials.Sessions.Cache.GetBodyDataCallback{``0},``0)"> + <summary> + Asynchronously adds or updates an object in the store and optionally update's its id + </summary> + <param name="objectId">The current (or old) id of the object</param> + <param name="alternateId">An optional id to update the blob to</param> + <param name="bodyData">A callback that returns the data for the blob</param> + <param name="state">The state parameter to pass to the data callback</param> + <returns></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.Cache.SessionStore.Dispose"> + <inheritdoc/> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.dll Binary files differnew file mode 100644 index 0000000..38d0c6b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.xml new file mode 100644 index 0000000..a6d2c4a --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Essentials.xml @@ -0,0 +1,3421 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Essentials</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Essentials.Accounts.AccountManager"> + <summary> + Provides essential constants, static methods, and session/user extensions + to facilitate unified user-controls, athentication, and security + application-wide + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.MAX_TIME_DIFF_SECS"> + <summary> + The maximum time in seconds for a login message to be considered valid + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.RANDOM_PASS_SIZE"> + <summary> + The size in bytes of the random passwords generated when invoking the <see cref="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetRandomPasswordAsync(VNLib.Plugins.Essentials.Accounts.PasswordHashing,VNLib.Plugins.Essentials.Users.IUserManager,VNLib.Plugins.Essentials.Users.IUser,System.Int32)"/> + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.LOGIN_TOKEN_HEADER"> + <summary> + The name of the header that will identify a client's identiy + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.LOCAL_ACCOUNT_ORIGIN"> + <summary> + The origin string of a local user account. This value will be set if an + account is created through the VNLib.Plugins.Essentials.Accounts library + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.CHALLENGE_SIZE"> + <summary> + The size (in bytes) of the challenge secret + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.SESSION_CHALLENGE_SIZE"> + <summary> + The size (in bytes) of the sesssion long user-password challenge + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.LOGIN_COOKIE_NAME"> + <summary> + The name of the login cookie set when a user logs in + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.LOGIN_COOKIE_IDENTIFIER"> + <summary> + The name of the login client identifier cookie (cookie that is set fir client to use to determine if the user is logged in) + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.ClientEncryptonPadding"> + <summary> + The client data encryption padding. + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.TokenHashSize"> + <summary> + The size (in bytes) of the web-token hash size + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Accounts.AccountManager.SpecialCharacters"> + <summary> + Speical character regual expresion for basic checks + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetRandomPasswordAsync(VNLib.Plugins.Essentials.Accounts.PasswordHashing,VNLib.Plugins.Essentials.Users.IUserManager,VNLib.Plugins.Essentials.Users.IUser,System.Int32)"> + <summary> + Generates and sets a random password for the specified user account + </summary> + <param name="manager">The configured <see cref="T:VNLib.Plugins.Essentials.Users.IUserManager"/> to process the password update on</param> + <param name="user">The user instance to update the password on</param> + <param name="passHashing">The <see cref="T:VNLib.Plugins.Essentials.Accounts.PasswordHashing"/> instance to hash the random password with</param> + <param name="size">Size (in bytes) of the generated random password</param> + <returns>A value indicating the results of the event (number of rows affected, should evaluate to true)</returns> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.IsLocalAccount(VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Checks to see if the current user account was created + using a local account. + </summary> + <param name="user"></param> + <returns>True if the account is a local account, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GetAccountOrigin(VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + If this account was created by any means other than a local account creation. + Implementors can use this method to determine the origin of the account. + This field is not required + </summary> + <returns>The origin of the account</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetAccountOrigin(VNLib.Plugins.Essentials.Users.IUser,System.String)"> + <summary> + If this account was created by any means other than a local account creation. + Implementors can use this method to specify the origin of the account. This field is not required + </summary> + <param name="ud"></param> + <param name="origin">Value of the account origin</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GetRandomUserId"> + <summary> + Gets a random user-id generated from crypograhic random number + then hashed (SHA1) and returns a hexadecimal string + </summary> + <returns>The random string user-id</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GenerateAuthorization(VNLib.Plugins.Essentials.HttpEntity,VNLib.Plugins.Essentials.Accounts.LoginMessage,VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Runs necessary operations to grant authorization to the specified user of a given session and user with provided variables + </summary> + <param name="ev">The connection and session to log-in</param> + <param name="loginMessage">The message of the client to set the log-in status of</param> + <param name="user">The user to log-in</param> + <returns>The encrypted base64 token secret data to send to the client</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GenerateAuthorization(VNLib.Plugins.Essentials.HttpEntity,System.String,System.String,VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Runs necessary operations to grant authorization to the specified user of a given session and user with provided variables + </summary> + <param name="ev">The connection and session to log-in</param> + <param name="base64PubKey">The clients base64 public key</param> + <param name="clientId">The browser/client id</param> + <param name="user">The user to log-in</param> + <returns>The encrypted base64 token secret data to send to the client</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.TryGenerateToken(System.String,System.String@,System.String@)"> + <summary> + Computes a random buffer, encrypts it with the client's public key, + computes the digest of that key and returns the base64 encoded strings + of those components + </summary> + <param name="base64clientPublicKey">The user's public key credential</param> + <param name="base64Digest">The base64 encoded digest of the secret that was encrypted</param> + <param name="base64ClientData">The client's user-agent header value</param> + <returns>A string representing a unique signed token for a given login context</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.TokenMatches(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Determines if the client sent a token header, and it maches against the current session + </summary> + <returns>true if the client set the token header, the session is loaded, and the token matches the session, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.RegenerateClientToken(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Regenerates the user's login token with the public key stored + during initial logon + </summary> + <returns>The base64 of the newly encrypted secret</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.TryEncryptClientData(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.ReadOnlySpan{System.Byte},System.Span{System.Byte}@)"> + <summary> + Tries to encrypt the specified data using the stored public key and store the encrypted data into + the output buffer. + </summary> + <param name="session"></param> + <param name="data">Data to encrypt</param> + <param name="outputBuffer">The buffer to store encrypted data in</param> + <returns> + The number of encrypted bytes written to the output buffer, + or false (0) if the operation failed, or if no credential is + stored. + </returns> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.TryEncryptClientData(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Byte},System.Span{System.Byte}@)"> + <summary> + Tries to encrypt the specified data using the specified public key + </summary> + <param name="base64PubKey">A base64 encoded public key used to encrypt client data</param> + <param name="data">Data to encrypt</param> + <param name="outputBuffer">The buffer to store encrypted data in</param> + <returns> + The number of encrypted bytes written to the output buffer, + or false (0) if the operation failed, or if no credential is + specified. + </returns> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.TryEncryptClientData(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.Span{System.Byte}@)"> + <summary> + Tries to encrypt the specified data using the specified public key + </summary> + <param name="rawPubKey">The raw SKI public key</param> + <param name="data">Data to encrypt</param> + <param name="outputBuffer">The buffer to store encrypted data in</param> + <returns> + The number of encrypted bytes written to the output buffer, + or false (0) if the operation failed, or if no credential is + specified. + </returns> + <exception cref="T:System.Security.Cryptography.CryptographicException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetBrowserPubKey(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.String)"> + <summary> + Stores the clients public key specified during login + </summary> + <param name="session"></param> + <param name="base64PubKey"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GetBrowserPubKey(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Gets the clients stored public key that was specified during login + </summary> + <returns>The base64 encoded public key string specified at login</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetLogin(VNLib.Plugins.Essentials.HttpEntity,System.Nullable{System.Boolean})"> + <summary> + Stores the login key as a cookie in the current session as long as the session exists + </summary>/ + <param name="ev">The event to log-in</param> + <param name="localAccount">Does the session belong to a local user account</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.InvalidateLogin(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Invalidates the login status of the current connection and session (if session is loaded) + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.LoginCookieMatches(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Determines if the current session login cookie matches the value stored in the current session (if the session is loaded) + </summary> + <returns>True if the session is active, the cookie was properly received, and the cookie value matches the session. False otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.ReconcileCookies(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Determines if the client's login cookies need to be updated + to reflect its state with the current session's state + for the client + </summary> + <param name="ev"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.SetBrowserID(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.String)"> + <summary> + Stores the browser's id during a login process + </summary> + <param name="session"></param> + <param name="browserId">Browser id value to store</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GetBrowserID(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Gets the current browser's id if it was specified during login process + </summary> + <returns>The browser's id if set, <see cref="F:System.String.Empty"/> otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.HasLocalAccount(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.Boolean)"> + <summary> + Specifies that the current session belongs to a local user-account + </summary> + <param name="session"></param> + <param name="value">True for a local account, false otherwise</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.HasLocalAccount(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Gets a value indicating if the session belongs to a local user account + </summary> + <param name="session"></param> + <returns>True if the current user's account is a local account</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.GenPasswordChallenge(VNLib.Plugins.Essentials.Sessions.SessionInfo@,VNLib.Utils.Memory.PrivateString)"> + <summary> + Generates a new password challenge for the current session and specified password + </summary> + <param name="session"></param> + <param name="password">The user's password to compute the hash of</param> + <returns>The raw derrivation key to send to the client</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.VerifyChallenge(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.ReadOnlySpan{System.Char})"> + <summary> + Verifies the stored unique digest of the user's password against + the client derrived password + </summary> + <param name="session"></param> + <param name="base64PasswordDigest">The base64 client derrived digest of the user's password to verify</param> + <returns>True if formatting was correct and the derrived passwords match, false otherwise</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.HasLevel(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.Byte)"> + <summary> + Compares the users privilage level against the specified level + </summary> + <param name="session"></param> + <param name="level">64bit privilage level to compare</param> + <returns>true if the current user has at least the specified level or higher</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.HasGroup(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.UInt16)"> + <summary> + Determines if the group ID of the current user matches the specified group + </summary> + <param name="session"></param> + <param name="groupId">Group ID to compare</param> + <returns>true if the user belongs to the group, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.HasOption(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.Byte)"> + <summary> + Determines if the current user has an equivalent option code + </summary> + <param name="session"></param> + <param name="option">Option code check</param> + <returns>true if the user options field equals the option</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.CanRead(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Returns the status of the user's privlage read bit + </summary> + <returns>true if the current user has the read permission, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.CanWrite(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Returns the status of the user's privlage write bit + </summary> + <returns>true if the current user has the write permission, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.CanDelete(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + Returns the status of the user's privlage delete bit + </summary> + <returns>true if the current user has the delete permission, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.FailedLoginCount(VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Gets the current number of failed login attempts + </summary> + <param name="user"></param> + <returns>The current number of failed login attempts</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.FailedLoginCount(VNLib.Plugins.Essentials.Users.IUser,System.UInt32)"> + <summary> + Sets the number of failed login attempts for the current session + </summary> + <param name="user"></param> + <param name="value">The value to set the failed login attempt count</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.FailedLoginCount(VNLib.Plugins.Essentials.Users.IUser,VNLib.Plugins.Essentials.TimestampedCounter)"> + <summary> + Sets the number of failed login attempts for the current session + </summary> + <param name="user"></param> + <param name="value">The value to set the failed login attempt count</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.AccountManager.FailedLoginIncrement(VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Increments the failed login attempt count + </summary> + <param name="user"></param> + </member> + <member name="T:VNLib.Plugins.Essentials.Accounts.INonce"> + <summary> + Represents a object that performs storage and computation of nonce values + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.INonce.ComputeNonce(System.Span{System.Byte})"> + <summary> + Generates a random nonce for the current instance and + returns a base32 encoded string. + </summary> + <param name="buffer">The buffer to write a copy of the nonce value to</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.INonce.VerifyNonce(System.ReadOnlySpan{System.Byte})"> + <summary> + Compares the raw nonce bytes to the current nonce to determine + if the supplied nonce value is valid + </summary> + <param name="nonceBytes">The binary value of the nonce</param> + <returns>True if the nonce values are equal, flase otherwise</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Accounts.NonceExtensions"> + <summary> + Provides INonce extensions for computing/verifying nonce values + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.NonceExtensions.ComputeNonce``1(``0,System.Int32)"> + <summary> + Computes a base32 nonce of the specified size and returns a string + representation + </summary> + <param name="nonce"></param> + <param name="size">The size (in bytes) of the nonce</param> + <returns>The base32 string of the computed nonce</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.NonceExtensions.VerifyNonce``1(``0,System.ReadOnlySpan{System.Char})"> + <summary> + Compares the base32 encoded nonce value against the previously + generated nonce + </summary> + <param name="nonce"></param> + <param name="base32Nonce">The base32 encoded nonce string</param> + <returns>True if the nonce values are equal, flase otherwise</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Accounts.LoginMessage"> + <summary> + A uniform JSON login message for the + accounts provider to use + </summary> + <remarks> + NOTE: This class derrives from <see cref="T:VNLib.Utils.Memory.PrivateStringManager"/> + and should be disposed properly + </remarks> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.UserName"> + <summary> + A property + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.Password"> + <summary> + A protected string property that + may represent a user's password + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.LocalTime"> + <summary> + Represents the clients local time in a <see cref="T:System.DateTime"/> struct + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.LocalLanguage"> + <summary> + The clients specified local-language + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.ClientPublicKey"> + <summary> + The clients shared public key used for encryption, this property is not protected + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.ClientID"> + <summary> + The clients browser id if shared + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.LoginMessage.#ctor"> + <summary> + Initailzies a new <see cref="T:VNLib.Plugins.Essentials.Accounts.LoginMessage"/> and its parent <see cref="T:VNLib.Utils.Memory.PrivateStringManager"/> + base + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.LoginMessage.#ctor(System.Int32)"> + <summary> + Allows for derrives classes to have multple protected + string elements + </summary> + <param name="protectedElementSize"> + The number of procted string elements required + </param> + <remarks> + NOTE: <paramref name="protectedElementSize"/> must be at-least 1 + or access to <see cref="P:VNLib.Plugins.Essentials.Accounts.LoginMessage.Password"/> will throw + </remarks> + </member> + <member name="T:VNLib.Plugins.Essentials.Accounts.SecretAction"> + <summary> + A delegate method to recover a temporary copy of the secret/pepper + for a request + </summary> + <param name="buffer">The buffer to write the pepper to</param> + <returns>The number of bytes written to the buffer</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Accounts.PasswordHashing"> + <summary> + Provides a structrued password hashing system implementing the <seealso cref="T:VNLib.Hashing.VnArgon2"/> library + with fixed time comparison + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.#ctor(VNLib.Plugins.Essentials.Accounts.SecretAction,System.Int32,System.Int32,System.UInt32,System.UInt32,System.UInt32,System.UInt32)"> + <summary> + Initalizes the <see cref="T:VNLib.Plugins.Essentials.Accounts.PasswordHashing"/> class + </summary> + <param name="getter"></param> + <param name="secreteSize">The expected size of the secret (the size of the buffer to alloc for a copy)</param> + <param name="saltLen">A positive integer for the size of the random salt used during the hashing proccess</param> + <param name="timeCost">The Argon2 time cost parameter</param> + <param name="memoryCost">The Argon2 memory cost parameter</param> + <param name="hashLen">The size of the hash to produce during hashing operations</param> + <param name="parallism"> + The Argon2 parallelism parameter (the number of threads to use for hasing) + (default = 0 - the number of processors) + </param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Verify(VNLib.Utils.Memory.PrivateString,VNLib.Utils.Memory.PrivateString)"> + <summary> + Verifies a password against its previously encoded hash. + </summary> + <param name="passHash">Previously hashed password</param> + <param name="password">Raw password to compare against</param> + <returns>true if bytes derrived from password match the hash, false otherwise</returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2PasswordFormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Verify(System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char})"> + <summary> + Verifies a password against its previously encoded hash. + </summary> + <param name="passHash">Previously hashed password</param> + <param name="password">Raw password to compare against</param> + <returns>true if bytes derrived from password match the hash, false otherwise</returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <exception cref="T:VNLib.Hashing.VnArgon2PasswordFormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Verify(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte})"> + <summary> + Verifies a password against its hash. Partially exposes the Argon2 api. + </summary> + <param name="hash">Previously hashed password</param> + <param name="salt">The salt used to hash the original password</param> + <param name="password">The password to hash and compare against </param> + <returns>true if bytes derrived from password match the hash, false otherwise</returns> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <remarks>Uses fixed time comparison from <see cref="T:System.Security.Cryptography.CryptographicOperations"/> class</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Hash(VNLib.Utils.Memory.PrivateString)"> + <summary> + Hashes a specified password, with the initialized pepper, and salted with CNG random bytes. + </summary> + <param name="password">Password to be hashed</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <returns>A <see cref="T:VNLib.Utils.Memory.PrivateString"/> of the hashed and encoded password</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Hash(System.ReadOnlySpan{System.Char})"> + <summary> + Hashes a specified password, with the initialized pepper, and salted with CNG random bytes. + </summary> + <param name="password">Password to be hashed</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <returns>A <see cref="T:VNLib.Utils.Memory.PrivateString"/> of the hashed and encoded password</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Hash(System.ReadOnlySpan{System.Byte})"> + <summary> + Hashes a specified password, with the initialized pepper, and salted with a CNG random bytes. + </summary> + <param name="password">Password to be hashed</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + <returns>A <see cref="T:VNLib.Utils.Memory.PrivateString"/> of the hashed and encoded password</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Accounts.PasswordHashing.Hash(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte},System.Span{System.Byte})"> + <summary> + Partially exposes the Argon2 api. Hashes the specified password, with the initialized pepper. + Writes the raw hash output to the specified buffer + </summary> + <param name="password">Password to be hashed</param> + <param name="salt">Salt to hash the password with</param> + <param name="hashOutput">The output buffer to store the hashed password to. The exact length of this buffer is the hash size</param> + <exception cref="T:VNLib.Hashing.VnArgon2Exception"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Content.IPageRouter"> + <summary> + Determines file routines (routing) for incomming connections + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Content.IPageRouter.RouteAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Determines what file path to return to a user for the given incoming connection + </summary> + <param name="entity">The connection to proccess</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that returns the <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> to pass to the file processor</returns> + </member> + <member name="P:VNLib.Plugins.Essentials.EnumerableTable`1.Enumerate"> + <summary> + The command that will be run against the database to return rows for enumeration + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EnumerableTable`1.TransactionIsolationLevel"> + <summary> + The isolation level to use when creating the transaction during enumerations + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EnumerableTable`1.GetItemAsync(System.Data.Common.DbDataReader,System.Threading.CancellationToken)"> + <summary> + Transforms a row from the <paramref name="reader"/> into the item type + to be returned when yielded. + </summary> + <param name="reader">The reader to get the item data from</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A task that returns the transformed item</returns> + <remarks>The <paramref name="reader"/> position is set before this method is invoked</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.EnumerableTable`1.CleanupItemAsync(`0,System.Threading.CancellationToken)"> + <summary> + Invoked when an item is no longer in the enumerator scope, in the enumeration process. + </summary> + <param name="item">The item to cleanup</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A ValueTask that represents the cleanup process</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.EnumerableTable`1.GetAsyncEnumerator(System.Boolean,System.Threading.CancellationToken)"> + <summary> + Gets an <see cref="T:System.Collections.Generic.IAsyncEnumerator`1"/> to enumerate items within the backing store. + </summary> + <param name="closeItems">Cleanup items after each item is enumerated and the enumeration scope has + returned to the enumerator</param> + <param name="cancellationToken">A token to cancel the enumeration</param> + <returns>A <see cref="T:System.Collections.Generic.IAsyncEnumerator`1"/> to enumerate records within the store</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.EventProcessor"> + <summary> + Provides an abstract base implementation of <see cref="T:VNLib.Net.Http.IWebRoot"/> + that breaks down simple processing procedures, routing, and session + loading. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.Current"> + <summary> + Gets the current (ambient) async local event processor + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.Directory"> + <summary> + The filesystem entrypoint path for the site + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.Hostname"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.DefaultFiles"> + <summary> + The name of a default file to search for within a directory if no file is specified (index.html). + This array should be ordered. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.ExcludedExtensions"> + <summary> + File extensions that are denied from being read from the filesystem + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.AllowedAttributes"> + <summary> + File attributes that must be matched for the file to be accessed + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.DissallowedAttributes"> + <summary> + Files that match any attribute flag set will be denied + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.TranslateResourcePath(System.String)"> + <summary> + <para> + Called when the server intends to process a file and requires translation from a + uri path to a usable filesystem path + </para> + <para> + NOTE: This function must be thread-safe! + </para> + </summary> + <param name="requestPath">The path requested by the request </param> + <returns>The translated and filtered filesystem path used to identify the file resource</returns> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.UpstreamServers"> + <summary> + A table of known upstream servers/ports that can be trusted to proxy connections + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.OperationTimeout"> + <summary> + A <see cref="T:System.TimeSpan"/> for how long a connection may remain open before all operations are cancelled + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.Log"> + <summary> + Event log provider + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.EventProcessor.Redirects"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.SetRedirects(System.Collections.Generic.IEnumerable{VNLib.Net.Http.Redirect})"> + <summary> + Initializes 301 redirects table from a collection of redirects + </summary> + <param name="redirs">A collection of redirects</param> + </member> + <member name="F:VNLib.Plugins.Essentials.EventProcessor.Sessions"> + <summary> + An <see cref="T:VNLib.Plugins.Essentials.Sessions.ISessionProvider"/> that connects stateful sessions to + HTTP connections + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.SetSessionProvider(VNLib.Plugins.Essentials.Sessions.ISessionProvider)"> + <summary> + Sets or resets the current <see cref="T:VNLib.Plugins.Essentials.Sessions.ISessionProvider"/> + for all connections + </summary> + <param name="sp">The new <see cref="T:VNLib.Plugins.Essentials.Sessions.ISessionProvider"/></param> + </member> + <member name="F:VNLib.Plugins.Essentials.EventProcessor.Router"> + <summary> + An <see cref="T:VNLib.Plugins.Essentials.Content.IPageRouter"/> to route files to be processed + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.SetPageRouter(VNLib.Plugins.Essentials.Content.IPageRouter)"> + <summary> + Sets or resets the current <see cref="T:VNLib.Plugins.Essentials.Content.IPageRouter"/> + for all connections + </summary> + <param name="router"><see cref="T:VNLib.Plugins.Essentials.Content.IPageRouter"/> to route incomming connections</param> + </member> + <member name="F:VNLib.Plugins.Essentials.EventProcessor.VirtualEndpoints"> + <summary> + A "lookup table" that represents virtual endpoints to be processed when an + incomming connection matches its path parameter + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.AddEndpoint(VNLib.Plugins.IEndpoint[])"> + <summary> + Determines the endpoint type(s) and adds them to the endpoint store(s) as necessary + </summary> + <param name="endpoints">Params array of endpoints to add to the store</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.RemoveEndpoint(VNLib.Plugins.IEndpoint[])"> + <summary> + Removes the specified endpoint from the virtual store and oauthendpoints if eneabled and found + </summary> + <param name="eps">A collection of endpoints to remove from the table</param> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.RemoveVirtualEndpoint(System.String[])"> + <summary> + Stops listening for connections to the specified <see cref="T:VNLib.Plugins.IVirtualEndpoint`1"/> identified by its path + </summary> + <param name="paths">An array of endpoint paths to remove from the table</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.ClientConnectedAsync(VNLib.Net.Http.IHttpEvent)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.ProcessFile(VNLib.Net.Http.IHttpEvent,VNLib.Plugins.Essentials.FileProcessArgs@)"> + <summary> + Accepts the entity to process a file for an the selected <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> + by user code and determines what file-system file to open and respond to the connection with. + </summary> + <param name="entity">The entity to process the file for</param> + <param name="args">The selected <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> to determine what file to process</param> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.ErrorHandler(System.Net.HttpStatusCode,VNLib.Net.Http.IHttpEvent)"> + <summary> + <para> + When an error occurs and is handled by the library, this event is invoked + </para> + <para> + NOTE: This function must be thread-safe! + </para> + </summary> + <param name="errorCode">The error code that was created during processing</param> + <param name="entity">The active IHttpEvent representing the faulted request</param> + <returns>A value indicating if the entity was proccsed by this call</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.ProcessVirtualAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + If virtual endpoints are enabled, checks for the existance of an + endpoint and attmepts to process that endpoint. + </summary> + <param name="entity">The http entity to proccess</param> + <returns>The results to return to the file processor, or null of the entity requires further processing</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.RouteFileAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Determines the best <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> processing response for the given connection. + Alternativley may respond to the entity directly. + </summary> + <param name="entity">The http entity to process</param> + <returns>The results to return to the file processor, this method must return an argument</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.PreProcessEntityAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + For pre-processing a request entity before all endpoint lookups are performed + </summary> + <param name="entity">The http entity to process</param> + <returns>The results to return to the file processor, or null of the entity requires further processing</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.PostProcessFile(VNLib.Plugins.Essentials.HttpEntity,VNLib.Plugins.Essentials.FileProcessArgs@)"> + <summary> + Allows for post processing of a selected <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> for the given entity + </summary> + <param name="entity">The http entity to process</param> + <param name="chosenRoutine">The selected file processing routine for the given request</param> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.FindResourceInRoot(System.String,System.Boolean,System.String@)"> + <summary> + Finds the file specified by the request and the server root the user has requested. + Determines if it exists, has permissions to access it, and allowed file attributes. + Also finds default files and files without extensions + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.EventProcessor.FindResourceInRoot(System.String,System.String@)"> + <summary> + Determines if a requested resource exists within the <see cref="T:VNLib.Plugins.Essentials.EventProcessor"/> and is allowed to be accessed. + </summary> + <param name="resourcePath">The path to the resource</param> + <param name="path">An out parameter that is set to the absolute path to the existing and accessable resource</param> + <returns>True if the resource exists and is allowed to be accessed</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.CollectionsExtensions"> + <summary> + + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.CollectionsExtensions.TryGetNonEmptyValue(System.Collections.Generic.IReadOnlyDictionary{System.String,System.String},System.String,System.String@)"> + <summary> + Gets a value by the specified key if it exsits and the value is not null/empty + </summary> + <param name="dict"></param> + <param name="key">Key associated with the value</param> + <param name="value">Value associated with the key</param> + <returns>True of the key is found and is not noll/empty, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.CollectionsExtensions.IsArgumentSet(System.Collections.Generic.IReadOnlyDictionary{System.String,System.String},System.String,System.ReadOnlySpan{System.Char})"> + <summary> + Determines if an argument was set in a <see cref="T:System.Collections.Generic.IReadOnlyDictionary`2"/> by comparing + the value stored at the key, to the type argument + </summary> + <param name="dict"></param> + <param name="key">The argument's key</param> + <param name="argument">The argument to compare against</param> + <returns> + True if the key was found, and the value at the key is equal to the type parameter. False if the key is null/empty, or the + value does not match the specified type + </returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.CollectionsExtensions.GetValueOrDefault``2(System.Collections.Generic.IDictionary{``0,``1},``0)"> + <summary> + + </summary> + <typeparam name="TKey"></typeparam> + <typeparam name="TValue"></typeparam> + <param name="dict"></param> + <param name="key"></param> + <returns></returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions"> + <summary> + Provides <see cref="T:VNLib.Net.Http.ConnectionInfo"/> extension methods + for common use cases + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.NO_CACHE_RESPONSE_HEADER_VALUE"> + <summary> + Cache-Control header value for disabling cache + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.LastModified(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Gets the <see cref="F:System.Net.HttpRequestHeader.IfModifiedSince"/> header value and converts its value to a datetime value + </summary> + <returns>The if modified-since header date-time, null if the header was not set or the value was invalid</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.LastModified(VNLib.Net.Http.IConnectionInfo,System.DateTimeOffset)"> + <summary> + Sets the last-modified response header value + </summary> + <param name="server"></param> + <param name="value">Time the entity was last modified</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsCors(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Is the connection requesting cors + </summary> + <returns>true if the user-agent specified the cors security header</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsCrossSite(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Determines if the User-Agent specified "cross-site" in the Sec-Site header, OR + the connection spcified an origin header and the origin's host does not match the + requested host + </summary> + <returns>true if the request originated from a site other than the current one</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsUserInvoked(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Is the connection user-agent created, or automatic + </summary> + <param name="server"></param> + <returns>true if sec-user header was set to "?1"</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsNavigation(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Was this request created from normal user navigation + </summary> + <returns>true if sec-mode set to "navigate"</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.NoCache(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Determines if the client specified "no-cache" for the cache control header, signalling they do not wish to cache the entity + </summary> + <returns>True if <see cref="F:System.Net.HttpRequestHeader.CacheControl"/> contains the string "no-cache", false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.SetCache(VNLib.Net.Http.IConnectionInfo,VNLib.Net.Http.CacheType,System.TimeSpan)"> + <summary> + Sets the response cache headers to match the requested caching type. Does not check against request headers + </summary> + <param name="server"></param> + <param name="type">One or more <see cref="T:VNLib.Net.Http.CacheType"/> flags that identify the way the entity can be cached</param> + <param name="maxAge">The max age the entity is valid for</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.SetNoCache(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Sets the Cache-Control response header to <see cref="F:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.NO_CACHE_RESPONSE_HEADER_VALUE"/> + and the pragma response header to 'no-cache' + </summary> + <param name="server"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.EnpointPortsMatch(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Gets a value indicating whether the port number in the request is equivalent to the port number + on the local server. + </summary> + <returns>True if the port number in the <see cref="P:VNLib.Net.Http.ConnectionInfo.RequestUri"/> matches the + <see cref="P:VNLib.Net.Http.ConnectionInfo.LocalEndpoint"/> port false if they do not match + </returns> + <remarks> + Users should call this method to help prevent port based attacks if your + code relies on the port number of the <see cref="P:VNLib.Net.Http.ConnectionInfo.RequestUri"/> + </remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.RefererMatch(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Determines if the host of the current request URI matches the referer header host + </summary> + <returns>True if the request host and the referer host paremeters match, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.ExpireCookie(VNLib.Net.Http.IConnectionInfo,System.String,System.String,System.String,VNLib.Net.Http.CookieSameSite,System.Boolean)"> + <summary> + Expires a client's cookie + </summary> + <param name="server"></param> + <param name="name"></param> + <param name="domain"></param> + <param name="path"></param> + <param name="sameSite"></param> + <param name="secure"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.SetSessionCookie(VNLib.Net.Http.IConnectionInfo,System.String,System.String,System.String,System.String,VNLib.Net.Http.CookieSameSite,System.Boolean,System.Boolean)"> + <summary> + Sets a cookie with an infinite (session life-span) + </summary> + <param name="server"></param> + <param name="name"></param> + <param name="value"></param> + <param name="domain"></param> + <param name="path"></param> + <param name="sameSite"></param> + <param name="httpOnly"></param> + <param name="secure"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.SetCookie(VNLib.Net.Http.IConnectionInfo,System.String,System.String,System.TimeSpan,System.String,System.String,VNLib.Net.Http.CookieSameSite,System.Boolean,System.Boolean)"> + <summary> + Sets a cookie with an infinite (session life-span) + </summary> + <param name="server"></param> + <param name="name"></param> + <param name="value"></param> + <param name="domain"></param> + <param name="path"></param> + <param name="sameSite"></param> + <param name="httpOnly"></param> + <param name="secure"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsBrowser(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Is the current connection a "browser" ? + </summary> + <param name="server"></param> + <returns>true if the user agent string contains "Mozilla" and does not contain "bot", false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsLoopBack(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Determines if the current connection is the loopback/internal network adapter + </summary> + <param name="server"></param> + <returns>True of the connection was made from the local machine</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.DNT(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Did the connection set the dnt header? + </summary> + <returns>true if the connection specified the dnt header, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsBehindUpstreamServer(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Determins if the current connection is behind a trusted upstream server + </summary> + <param name="server"></param> + <returns>True if the connection came from a trusted upstream server, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.GetTrustedIp(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Gets the real IP address of the request if behind a trusted upstream server, otherwise returns the transport remote ip address + </summary> + <param name="server"></param> + <returns>The real ip of the connection</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.GetTrustedIp(VNLib.Net.Http.IConnectionInfo,System.Boolean)"> + <summary> + Gets the real IP address of the request if behind a trusted upstream server, otherwise returns the transport remote ip address + </summary> + <param name="server"></param> + <param name="isTrusted"></param> + <returns>The real ip of the connection</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsSecure(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Gets a value that determines if the connection is using tls, locally + or behind a trusted upstream server that is using tls. + </summary> + <param name="server"></param> + <returns>True if the connection is secure, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.IsLocalConnection(VNLib.Net.Http.IConnectionInfo)"> + <summary> + Was the connection made on a local network to the server? NOTE: Use with caution + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.IConnectionInfoExtensions.GetCookie(VNLib.Net.Http.IConnectionInfo,System.String,System.String@)"> + <summary> + Get a cookie from the current request + </summary> + <param name="server"></param> + <param name="name">Name/ID of cookie</param> + <param name="cookieValue">Is set to cookie if found, or null if not</param> + <returns>True if cookie exists and was retrieved</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions"> + <summary> + Provides extension methods for manipulating <see cref="T:VNLib.Net.Http.HttpEvent"/>s + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseJson``1(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,``0)"> + <summary> + Attempts to serialize the JSON object (with default SR_OPTIONS) to binary and configure the response for a JSON message body + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="code">The <see cref="T:System.Net.HttpStatusCode"/> result of the connection</param> + <param name="response">The JSON object to serialzie and send as response body</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseJson``1(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,``0,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to serialize the JSON object to binary and configure the response for a JSON message body + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="code">The <see cref="T:System.Net.HttpStatusCode"/> result of the connection</param> + <param name="response">The JSON object to serialzie and send as response body</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during serialization</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseJson(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.Object,System.Type)"> + <summary> + Attempts to serialize the JSON object to binary and configure the response for a JSON message body + </summary> + <param name="ev"></param> + <param name="code">The <see cref="T:System.Net.HttpStatusCode"/> result of the connection</param> + <param name="response">The JSON object to serialzie and send as response body</param> + <param name="type">The type to use during de-serialization</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseJson(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.Object,System.Type,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to serialize the JSON object to binary and configure the response for a JSON message body + </summary> + <param name="ev"></param> + <param name="code">The <see cref="T:System.Net.HttpStatusCode"/> result of the connection</param> + <param name="response">The JSON object to serialzie and send as response body</param> + <param name="type">The type to use during de-serialization</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during serialization</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseJson(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.Text.Json.JsonDocument)"> + <summary> + Writes the <see cref="T:System.Text.Json.JsonDocument"/> data to a temporary buffer and sets it as the response + </summary> + <param name="ev"></param> + <param name="code">The <see cref="T:System.Net.HttpStatusCode"/> result of the connection</param> + <param name="data">The <see cref="T:System.Text.Json.JsonDocument"/> data to send to client</param> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse``1(VNLib.Plugins.Essentials.HttpEntity,``0)"> + <summary> + Close as response to a client with an <see cref="F:System.Net.HttpStatusCode.OK"/> and serializes a <see cref="T:VNLib.Plugins.WebMessage"/> as the message response + </summary> + <param name="ev"></param> + <param name="webm">The <see cref="T:VNLib.Plugins.WebMessage"/> to serialize and response to client with</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseAttachment(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.IO.FileInfo)"> + <summary> + Close a response to a connection with a file as an attachment (set content dispostion) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="file">The <see cref="T:System.IO.FileInfo"/> of the desired file to attach</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.IO.FileNotFoundException"></exception> + <exception cref="T:System.UnauthorizedAccessException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + <exception cref="T:System.Security.SecurityException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseAttachment(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.IO.FileStream)"> + <summary> + Close a response to a connection with a file as an attachment (set content dispostion) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="file">The <see cref="T:System.IO.FileStream"/> of the desired file to attach</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseAttachment(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Plugins.Essentials.Storage.Blob)"> + <summary> + Close a response to a connection with a file as an attachment (set content dispostion) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="blob">The <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> of the desired file to attach</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponseAttachment(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream,System.String)"> + <summary> + Close a response to a connection with a file as an attachment (set content dispostion) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="data">The data to straem to the client as an attatcment</param> + <param name="ct">The <see cref="T:VNLib.Net.ContentType"/> that represents the file</param> + <param name="fileName">The name of the file to attach</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.IO.FileInfo)"> + <summary> + Close a response to a connection with a file as the entire response body (not attachment) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="file">The <see cref="T:System.IO.FileInfo"/> of the desired file to attach</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.IO.FileNotFoundException"></exception> + <exception cref="T:System.UnauthorizedAccessException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + <exception cref="T:System.Security.SecurityException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.IO.FileStream)"> + <summary> + Close a response to a connection with a <see cref="T:System.IO.FileStream"/> as the entire response body (not attachment) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="file">The <see cref="T:System.IO.FileStream"/> of the desired file to attach</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Plugins.Essentials.Storage.Blob)"> + <summary> + Close a response to a connection with a <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> as the entire response body (not attachment) + </summary> + <param name="ev"></param> + <param name="code">Status code</param> + <param name="blob">The <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> of the desired file to attach</param> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Net.ContentType,System.ReadOnlySpan{System.Char}@)"> + <summary> + Close a response to a connection with a character buffer using the server wide + <see cref="P:VNLib.Net.Http.ConnectionInfo.Encoding"/> encoding + </summary> + <param name="ev"></param> + <param name="code">The response status code</param> + <param name="type">The <see cref="T:VNLib.Net.ContentType"/> the data represents</param> + <param name="data">The character buffer to send</param> + <remarks>This method will store an encoded copy as a memory stream, so be careful with large buffers</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseResponse(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Net.ContentType,System.ReadOnlySpan{System.Char}@,System.Text.Encoding)"> + <summary> + Close a response to a connection with a character buffer using the specified encoding type + </summary> + <param name="ev"></param> + <param name="code">The response status code</param> + <param name="type">The <see cref="T:VNLib.Net.ContentType"/> the data represents</param> + <param name="data">The character buffer to send</param> + <param name="encoding">The encoding type to use when converting the buffer</param> + <remarks>This method will store an encoded copy as a memory stream, so be careful with large buffers</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.CloseWithRelativeFile(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,System.String)"> + <summary> + Close a response to a connection with a relative file within the current root's directory + </summary> + <param name="entity"></param> + <param name="code">The status code to set the response as</param> + <param name="filePath">The path of the relative file to send</param> + <returns>True if the file was found, false if the file does not exist or cannot be accessed</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.Redirect(VNLib.Plugins.Essentials.HttpEntity,VNLib.Plugins.Essentials.Extensions.RedirectType,System.String)"> + <summary> + Redirects a client using the specified <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> + </summary> + <param name="ev"></param> + <param name="type">The <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> redirection type</param> + <param name="location">Location to direct client to, sets the "Location" header</param> + <remarks>Sets required headers for redirection, disables cache control, and returns the status code to the client</remarks> + <exception cref="T:System.UriFormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.Redirect(VNLib.Plugins.Essentials.HttpEntity,VNLib.Plugins.Essentials.Extensions.RedirectType,System.Uri)"> + <summary> + Redirects a client using the specified <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> + </summary> + <param name="ev"></param> + <param name="type">The <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> redirection type</param> + <param name="location">Location to direct client to, sets the "Location" header</param> + <remarks>Sets required headers for redirection, disables cache control, and returns the status code to the client</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.Redirect(VNLib.Net.Http.IHttpEvent,VNLib.Plugins.Essentials.Extensions.RedirectType,System.String)"> + <summary> + Redirects a client using the specified <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> + </summary> + <param name="ev"></param> + <param name="type">The <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> redirection type</param> + <param name="location">Location to direct client to, sets the "Location" header</param> + <remarks>Sets required headers for redirection, disables cache control, and returns the status code to the client</remarks> + <exception cref="T:System.UriFormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.Redirect(VNLib.Net.Http.IHttpEvent,VNLib.Plugins.Essentials.Extensions.RedirectType,System.Uri)"> + <summary> + Redirects a client using the specified <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> + </summary> + <param name="ev"></param> + <param name="type">The <see cref="T:VNLib.Plugins.Essentials.Extensions.RedirectType"/> redirection type</param> + <param name="location">Location to direct client to, sets the "Location" header</param> + <remarks>Sets required headers for redirection, disables cache control, and returns the status code to the client</remarks> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.TryGetJsonFromArg``1(VNLib.Plugins.Essentials.HttpEntity,System.String,``0@)"> + <summary> + Attempts to read and deserialize a JSON object from the reqeust body (form data or urlencoded) + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="key">Request argument key (name)</param> + <param name="obj"></param> + <returns>true if the argument was found and successfully converted to json</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.TryGetJsonFromArg``1(VNLib.Plugins.Essentials.HttpEntity,System.String,System.Text.Json.JsonSerializerOptions,``0@)"> + <summary> + Attempts to read and deserialize a JSON object from the reqeust body (form data or urlencoded) + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="key">Request argument key (name)</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during deserialization </param> + <param name="obj"></param> + <returns>true if the argument was found and successfully converted to json</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetJsonFromArg(VNLib.Plugins.Essentials.HttpEntity,System.String,System.Text.Json.JsonDocumentOptions@)"> + <summary> + Reads the value stored at the key location in the request body arguments, into a <see cref="T:System.Text.Json.JsonDocument"/> + </summary> + <param name="ev"></param> + <param name="key">Request argument key (name)</param> + <param name="options"><see cref="T:System.Text.Json.JsonDocumentOptions"/> to use during parsing</param> + <returns>A new <see cref="T:System.Text.Json.JsonDocument"/> if the key is found, null otherwise</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetJsonFromFile``1(VNLib.Plugins.Essentials.HttpEntity,System.Text.Json.JsonSerializerOptions,System.Int32)"> + <summary> + If there are file attachements (form data files or content body) and the file is <see cref="F:VNLib.Net.ContentType.Json"/> + file. It will be deserialzied to the specified object + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during deserialization </param> + <returns>Returns the deserialized object if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetJsonFromFile(VNLib.Plugins.Essentials.HttpEntity,System.Int32)"> + <summary> + If there are file attachements (form data files or content body) and the file is <see cref="F:VNLib.Net.ContentType.Json"/> + file. It will be parsed into a new <see cref="T:System.Text.Json.JsonDocument"/> + </summary> + <param name="ev"></param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <see cref="T:System.Text.Json.JsonDocument"/>if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetJsonFromFileAsync``1(VNLib.Plugins.Essentials.HttpEntity,System.Text.Json.JsonSerializerOptions,System.Int32)"> + <summary> + If there are file attachements (form data files or content body) and the file is <see cref="F:VNLib.Net.ContentType.Json"/> + file. It will be deserialzied to the specified object + </summary> + <typeparam name="T"></typeparam> + <param name="ev"></param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during deserialization </param> + <returns>The deserialized object if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetJsonFromFileAsync(VNLib.Plugins.Essentials.HttpEntity,System.Int32)"> + <summary> + If there are file attachements (form data files or content body) and the file is <see cref="F:VNLib.Net.ContentType.Json"/> + file. It will be parsed into a new <see cref="T:System.Text.Json.JsonDocument"/> + </summary> + <param name="ev"></param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <see cref="T:System.Text.Json.JsonDocument"/>if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.ParseFileAsAsync``1(VNLib.Plugins.Essentials.HttpEntity,System.Func{System.IO.Stream,System.Threading.Tasks.Task{``0}},System.Int32)"> + <summary> + If there are file attachements (form data files or content body) the specified parser will be called to parse the + content body asynchronously into a .net object or its default if no attachments are included + </summary> + <param name="ev"></param> + <param name="parser">A function to asynchronously parse the entity body into its object representation</param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <typeparamref name="T"/> if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.ParseFileAsAsync``1(VNLib.Plugins.Essentials.HttpEntity,System.Func{System.IO.Stream,System.String,System.Threading.Tasks.Task{``0}},System.Int32)"> + <summary> + If there are file attachements (form data files or content body) the specified parser will be called to parse the + content body asynchronously into a .net object or its default if no attachments are included + </summary> + <param name="ev"></param> + <param name="parser">A function to asynchronously parse the entity body into its object representation</param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <typeparamref name="T"/> if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.ParseFileAsAsync``1(VNLib.Plugins.Essentials.HttpEntity,System.Func{System.IO.Stream,System.Threading.Tasks.ValueTask{``0}},System.Int32)"> + <summary> + If there are file attachements (form data files or content body) the specified parser will be called to parse the + content body asynchronously into a .net object or its default if no attachments are included + </summary> + <param name="ev"></param> + <param name="parser">A function to asynchronously parse the entity body into its object representation</param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <typeparamref name="T"/> if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.ParseFileAsAsync``1(VNLib.Plugins.Essentials.HttpEntity,System.Func{System.IO.Stream,System.String,System.Threading.Tasks.ValueTask{``0}},System.Int32)"> + <summary> + If there are file attachements (form data files or content body) the specified parser will be called to parse the + content body asynchronously into a .net object or its default if no attachments are included + </summary> + <param name="ev"></param> + <param name="parser">A function to asynchronously parse the entity body into its object representation</param> + <param name="uploadIndex">The index within <see cref="P:VNLib.Plugins.Essentials.HttpEntity.Files"/></param> list of the file to read + <returns>Returns the parsed <typeparamref name="T"/> if found, default otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.HasAuthorization(VNLib.Net.Http.IConnectionInfo,System.String@)"> + <summary> + Gets the bearer token from an authorization header + </summary> + <param name="ci"></param> + <param name="token">The token stored in the user's authorization header</param> + <returns>True if the authorization header was set, has a Bearer token value</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.GetRootDir(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Get a <see cref="T:System.IO.DirectoryInfo"/> instance that points to the current sites filesystem root. + </summary> + <returns></returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.IO.PathTooLongException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.ContentTypeString(VNLib.Net.FileUpload@)"> + <summary> + Returns the MIME string representation of the content type of the uploaded file. + </summary> + <param name="upload"></param> + <returns>The MIME string representation of the content type of the uploaded file.</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.AcceptWebSocket(VNLib.Plugins.Essentials.HttpEntity,VNLib.Plugins.Essentials.WebsocketAcceptedCallback,System.Object,System.String)"> + <summary> + Attemts to upgrade the connection to a websocket, if the setup fails, it sets up the response to the client accordingly. + </summary> + <param name="entity"></param> + <param name="socketOpenedcallback">A delegate that will be invoked when the websocket has been opened by the framework</param> + <param name="subProtocol">The sub-protocol to use on the current websocket</param> + <param name="userState">An object to store in the <see cref="P:VNLib.Plugins.Essentials.WebSocketSession.UserState"/> property when the websocket has been accepted</param> + <returns>True if operation succeeds.</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.EssentialHttpEventExtensions.AcceptWebSocket(VNLib.Net.Http.IHttpEvent,VNLib.Plugins.Essentials.WebsocketAcceptedCallback,System.Object,System.String)"> + <summary> + Attemts to upgrade the connection to a websocket, if the setup fails, it sets up the response to the client accordingly. + </summary> + <param name="entity"></param> + <param name="socketOpenedcallback">A delegate that will be invoked when the websocket has been opened by the framework</param> + <param name="subProtocol">The sub-protocol to use on the current websocket</param> + <param name="userState">An object to store in the <see cref="P:VNLib.Plugins.Essentials.WebSocketSession.UserState"/> property when the websocket has been accepted</param> + <returns>True if operation succeeds.</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"> + <summary> + Wraps a <see cref="T:System.Text.Json.JsonException"/> that is thrown when a JSON request message + was unsuccessfully parsed. + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException.#ctor(System.Text.Json.JsonException)"> + <summary> + Creates a new <see cref="T:VNLib.Plugins.Essentials.Extensions.InvalidJsonRequestException"/> wrapper from a base <see cref="T:System.Text.Json.JsonException"/> + </summary> + <param name="baseExp"></param> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.RedirectType"> + <summary> + Shortened list of <see cref="T:System.Net.HttpStatusCode"/>s for redirecting connections + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.UserExtensions"> + <summary> + Provides extension methods to the Users namespace + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.UserExtensions.SetProfile(VNLib.Plugins.Essentials.Users.IUser,VNLib.Plugins.Essentials.Accounts.AccountData)"> + <summary> + Stores the user's profile to their entry. + <br/> + NOTE: You must validate/filter data before storing + </summary> + <param name="ud"></param> + <param name="profile">The profile object to store on account</param> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.UserExtensions.SetProfile(VNLib.Plugins.Essentials.Users.IUser,System.String)"> + <summary> + Stores the serialized string user's profile to their entry. + <br/> + NOTE: No data validation checks are performed + </summary> + <param name="ud"></param> + <param name="jsonProfile">The JSON serialized "raw" profile data</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.UserExtensions.GetProfile(VNLib.Plugins.Essentials.Users.IUser)"> + <summary> + Recovers the user's stored profile + </summary> + <returns>The user's profile stored in the entry or null if no entry is found</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Extensions.DbExtensions"> + <summary> + Provides basic extension methods for ADO.NET abstract classes + for rapid development + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.AddParameter``1(System.Data.Common.DbCommand,System.String,``0,System.Data.DbType,System.Boolean)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbParameter"/> configured for <see cref="F:System.Data.ParameterDirection.Input"/> with the specified value + and adds it to the command. + </summary> + <param name="cmd"></param> + <param name="name">The parameter name</param> + <param name="value">The value of the parameter</param> + <param name="type">The <see cref="T:System.Data.DbType"/> of the column</param> + <param name="nullable">Are null types allowed in the value parameter</param> + <returns>The created parameter</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.AddParameter``1(System.Data.Common.DbCommand,System.String,``0,System.Data.DbType,System.Int32,System.Boolean)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbParameter"/> configured for <see cref="F:System.Data.ParameterDirection.Input"/> with the specified value + and adds it to the command. + </summary> + <param name="cmd"></param> + <param name="name">The parameter name</param> + <param name="value">The value of the parameter</param> + <param name="type">The <see cref="T:System.Data.DbType"/> of the column</param> + <param name="size">Size of the data value</param> + <param name="nullable">Are null types allowed in the value parameter</param> + <returns>The created parameter</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.AddOutParameter``1(System.Data.Common.DbCommand,System.String,``0,System.Data.DbType,System.Boolean)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbParameter"/> configured for <see cref="F:System.Data.ParameterDirection.Output"/> with the specified value + and adds it to the command. + </summary> + <param name="cmd"></param> + <param name="name">The parameter name</param> + <param name="value">The value of the parameter</param> + <param name="type">The <see cref="T:System.Data.DbType"/> of the column</param> + <param name="nullable">Are null types allowed in the value parameter</param> + <returns>The created parameter</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.AddOutParameter``1(System.Data.Common.DbCommand,System.String,``0,System.Data.DbType,System.Int32,System.Boolean)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbParameter"/> configured for <see cref="F:System.Data.ParameterDirection.Output"/> with the specified value + and adds it to the command. + </summary> + <param name="cmd"></param> + <param name="name">The parameter name</param> + <param name="value">The value of the parameter</param> + <param name="type">The <see cref="T:System.Data.DbType"/> of the column</param> + <param name="size">Size of the data value</param> + <param name="nullable">Are null types allowed in the value parameter</param> + <returns>The created parameter</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.CreateTextCommand(System.Data.Common.DbConnection,System.String)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbCommand"/> for <see cref="F:System.Data.CommandType.Text"/> with the specified command + </summary> + <param name="db"></param> + <param name="cmdText">The command to run against the connection</param> + <returns>The initalized <see cref="T:System.Data.Common.DbCommand"/></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.CreateProcedureCommand(System.Data.Common.DbConnection,System.String)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbCommand"/> for <see cref="F:System.Data.CommandType.StoredProcedure"/> with the specified procedure name + </summary> + <param name="db"></param> + <param name="procedureName">The name of the stored proecedure to execute</param> + <returns>The initalized <see cref="T:System.Data.Common.DbCommand"/></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.CreateTextCommand(System.Data.Common.DbConnection,System.String,System.Data.Common.DbTransaction)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbCommand"/> for <see cref="F:System.Data.CommandType.Text"/> with the specified command + on a given transaction + </summary> + <param name="db"></param> + <param name="cmdText">The command to run against the connection</param> + <param name="transaction">The transaction to execute on</param> + <returns>The initalized <see cref="T:System.Data.Common.DbCommand"/></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.CreateCommand(System.Data.Common.DbConnection,System.Data.Common.DbTransaction,System.Data.CommandType,System.String)"> + <summary> + Shortcut to create a command on a transaction with the specifed command type and command + </summary> + <param name="db"></param> + <param name="transaction">The transaction to complete the operation on</param> + <param name="type">The command type</param> + <param name="command">The command to execute</param> + <returns>The intialized db command</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.CreateProcedureCommand(System.Data.Common.DbConnection,System.String,System.Data.Common.DbTransaction)"> + <summary> + Creates a new <see cref="T:System.Data.Common.DbCommand"/> for <see cref="F:System.Data.CommandType.StoredProcedure"/> with the specified procedure name + </summary> + <param name="db"></param> + <param name="procedureName">The name of the stored proecedure to execute</param> + <param name="transaction">The transaction to execute on</param> + <returns>The initalized <see cref="T:System.Data.Common.DbCommand"/></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.GetAllObjects``1(System.Data.Common.DbDataReader,System.Collections.Generic.ICollection{``0})"> + <summary> + Reads all available rows from the reader, adapts columns to public properties with <see cref="T:VNLib.Plugins.Essentials.Sql.SqlColumnName"/> + attributes, and adds them to the collection + </summary> + <typeparam name="T"></typeparam> + <param name="reader"></param> + <param name="container">The container to write created objects to</param> + <returns>The number of objects created and written to the collection</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.GetAllObjectsAsync``1(System.Data.Common.DbDataReader,System.Collections.Generic.ICollection{``0})"> + <summary> + Reads all available rows from the reader, adapts columns to public properties with <see cref="T:VNLib.Plugins.Essentials.Sql.SqlColumnName"/> + attributes, and adds them to the collection + </summary> + <typeparam name="T"></typeparam> + <param name="reader"></param> + <param name="container">The container to write created objects to</param> + <returns>The number of objects created and written to the collection</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.GetFirstObject``1(System.Data.Common.DbDataReader)"> + <summary> + Reads the first available row from the reader, adapts columns to public properties with <see cref="T:VNLib.Plugins.Essentials.Sql.SqlColumnName"/> + </summary> + <typeparam name="T"></typeparam> + <param name="reader"></param> + <returns>The created object, or default if no rows are available</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.GetFirstObjectAsync``1(System.Data.Common.DbDataReader)"> + <summary> + Reads the first available row from the reader, adapts columns to public properties with <see cref="T:VNLib.Plugins.Essentials.Sql.SqlColumnName"/> + </summary> + <typeparam name="T"></typeparam> + <param name="reader"></param> + <returns>The created object, or default if no rows are available</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.ExecuteNonQuery``1(System.Data.Common.DbCommand,``0)"> + <summary> + Executes a nonquery operation with the specified command using the object properties set with the + <see cref="T:VNLib.Plugins.Essentials.Sql.SqlVariable"/> attributes + </summary> + <typeparam name="T"></typeparam> + <param name="cmd"></param> + <param name="obj">The object containing the <see cref="T:VNLib.Plugins.Essentials.Sql.SqlVariable"/> properties to write to command variables</param> + <returns>The number of rows affected</returns> + <exception cref="T:System.TypeLoadException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.Reflection.AmbiguousMatchException"></exception> + <exception cref="T:System.Reflection.TargetInvocationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Extensions.DbExtensions.ExecuteNonQueryAsync``1(System.Data.Common.DbCommand,``0)"> + <summary> + Executes a nonquery operation with the specified command using the object properties set with the + <see cref="T:VNLib.Plugins.Essentials.Sql.SqlVariable"/> attributes + </summary> + <typeparam name="T"></typeparam> + <param name="cmd"></param> + <param name="obj">The object containing the <see cref="T:VNLib.Plugins.Essentials.Sql.SqlVariable"/> properties to write to command variables</param> + <returns>The number of rows affected</returns> + <exception cref="T:System.TypeLoadException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.Reflection.AmbiguousMatchException"></exception> + <exception cref="T:System.Reflection.TargetInvocationException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.FpRoutine"> + <summary> + Server routine to follow after processing selector + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.Error"> + <summary> + There was an error during processing and the server should immediatly respond with a <see cref="F:System.Net.HttpStatusCode.InternalServerError"/> error code + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.Continue"> + <summary> + The server should continue the file read operation with the current information + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.Redirect"> + <summary> + The server should redirect the conneciton to an alternate location + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.Deny"> + <summary> + The server should immediatly respond with a <see cref="F:System.Net.HttpStatusCode.Forbidden"/> error code + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.ServeOther"> + <summary> + The server should fulfill the reqeest by sending the contents of an alternate file location (if it exists) with the existing connection + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.NotFound"> + <summary> + The server should immediatly respond with a <see cref="F:System.Net.HttpStatusCode.NotFound"/> error code + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.ServeOtherFQ"> + <summary> + Serves another file location that must be a trusted fully qualified location + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FpRoutine.VirtualSkip"> + <summary> + The connection does not require a file to be processed + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.FileProcessArgs"> + <summary> + Specifies operations the file processor will follow during request handling + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FileProcessArgs.Deny"> + <summary> + Signals the file processor should complete with a <see cref="F:VNLib.Plugins.Essentials.FpRoutine.Deny"/> routine + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FileProcessArgs.Continue"> + <summary> + Signals the file processor should continue with intended/normal processing of the request + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FileProcessArgs.Error"> + <summary> + Signals the file processor should complete with a <see cref="F:VNLib.Plugins.Essentials.FpRoutine.Error"/> routine + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FileProcessArgs.NotFound"> + <summary> + Signals the file processor should complete with a <see cref="F:VNLib.Plugins.Essentials.FpRoutine.NotFound"/> routine + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.FileProcessArgs.VirtualSkip"> + <summary> + Signals the file processor should not process the connection + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.FileProcessArgs.Routine"> + <summary> + The routine the file processor should execute + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.FileProcessArgs.Alternate"> + <summary> + An optional alternate path for the given routine + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.#ctor(VNLib.Plugins.Essentials.FpRoutine)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> with the specified routine + and empty <see cref="P:VNLib.Plugins.Essentials.FileProcessArgs.Alternate"/> path + </summary> + <param name="routine">The file processing routine to execute</param> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.#ctor(VNLib.Plugins.Essentials.FpRoutine,System.String)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Essentials.FileProcessArgs"/> with the specified routine + and alternate path + </summary> + <param name="routine"></param> + <param name="alternatePath"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.op_Equality(VNLib.Plugins.Essentials.FileProcessArgs,VNLib.Plugins.Essentials.FileProcessArgs)"> + <summary> + + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + <returns></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.op_Inequality(VNLib.Plugins.Essentials.FileProcessArgs,VNLib.Plugins.Essentials.FileProcessArgs)"> + <summary> + + </summary> + <param name="arg1"></param> + <param name="arg2"></param> + <returns></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.Equals(VNLib.Plugins.Essentials.FileProcessArgs)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.FileProcessArgs.GetHashCode"> + <summary> + <inheritdoc/> + </summary> + <returns></returns> + </member> + <member name="T:VNLib.Plugins.Essentials.HttpEntity"> + <summary> + A container for an <see cref="T:VNLib.Net.Http.HttpEvent"/> with its attached session + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.EventCancellation"> + <summary> + A token that has a scheduled timeout to signal the cancellation of the entity event + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.Entity"> + <summary> + The connection event entity + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.Session"> + <summary> + The session assocaited with the event + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.IsBehindUpstreamServer"> + <summary> + A value that indicates if the connecion came from a trusted upstream server + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.IsLocalConnection"> + <summary> + Determines if the connection came from the local network to the current server + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.IsSecure"> + <summary> + Gets a value that determines if the connection is using tls, locally + or behind a trusted upstream server that is using tls. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.HttpEntity.Server"> + <summary> + The connection info object assocated with the entity + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.TrustedRemoteIp"> + <summary> + User's ip. If the connection is behind a local proxy, returns the users actual IP. Otherwise returns the connection ip. + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.HttpEntity.RequestedRoot"> + <summary> + The requested web root. Provides additional site information + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.HttpEntity.QueryArgs"> + <summary> + If the request has query arguments they are stored in key value format + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.HttpEntity.RequestArgs"> + <summary> + If the request body has form data or url encoded arguments they are stored in key value format + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.HttpEntity.Files"> + <summary> + Contains all files upladed with current request + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.HttpEntity.CloseResponse(System.Net.HttpStatusCode)"> + <summary> + Complete the session and respond to user + </summary> + <param name="code">Status code of operation</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.HttpEntity.CloseResponse(System.Net.HttpStatusCode,VNLib.Net.ContentType,System.IO.Stream)"> + <summary> + Responds to a client with a <see cref="T:System.IO.Stream"/> containing data to be sent to user of a given contentType. + Runtime will dispose of the stream during closing event + </summary> + <param name="code">Response status code</param> + <param name="type">MIME ContentType of data</param> + <param name="stream">Data to be sent to client</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Net.Http.ContentTypeUnacceptableException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Oauth.IOAuth2Provider"> + <summary> + An interface that Oauth2 serice providers must implement + to provide sessions to an <see cref="T:VNLib.Plugins.Essentials.EventProcessor"/> + processor endpoint processor + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Oauth.IOAuth2Provider.MaxTokenLifetime"> + <summary> + Gets a value indicating how long a session may be valid for + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Oauth.O2EndpointBase"> + <summary> + An base class for HttpEntity processors (endpoints) for processing + Oauth2 client requests. Similar to <seealso cref="T:VNLib.Plugins.Essentials.ProtectedWebEndpoint"/> + but for Oauth2 sessions + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Oauth.O2EndpointBase.EndpointProtectionSettings"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.O2EndpointBase.Process(VNLib.Plugins.Essentials.HttpEntity)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.O2EndpointBase.PreProccess(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Runs base pre-processing and ensures "sessions" OAuth2 token + session is loaded + </summary> + <param name="entity">The request entity to process</param> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Oauth.ErrorType"> + <summary> + An OAuth2 specification error code + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.InvalidRequest"> + <summary> + The request is considered invalid and cannot be continued + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.InvalidClient"> + <summary> + + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.InvalidToken"> + <summary> + The supplied token is no longer considered valid + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.UnauthorizedClient"> + <summary> + The token does not have the authorization required, is missing authorization, or is no longer considered acceptable + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.UnsupportedResponseType"> + <summary> + The client accept content type is unacceptable for the requested endpoint and cannot be processed + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.InvalidScope"> + <summary> + The scope of the token does not allow for this operation + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.ServerError"> + <summary> + There was a server related error and the request could not be fulfilled + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Oauth.ErrorType.TemporarilyUnabavailable"> + <summary> + The request could not be processed at this time + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthHttpExtensions.CloseResponseError(VNLib.Plugins.Essentials.HttpEntity,System.Net.HttpStatusCode,VNLib.Plugins.Essentials.Oauth.ErrorType,System.String)"> + <summary> + Closes the current response with a json error message with the message details + </summary> + <param name="ev"></param> + <param name="code">The http status code</param> + <param name="error">The short error</param> + <param name="description">The error description message</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthHttpExtensions.CloseResponseError(VNLib.Net.Http.IHttpEvent,System.Net.HttpStatusCode,VNLib.Plugins.Essentials.Oauth.ErrorType,System.String)"> + <summary> + Closes the current response with a json error message with the message details + </summary> + <param name="ev"></param> + <param name="code">The http status code</param> + <param name="error">The short error</param> + <param name="description">The error description message</param> + </member> + <member name="T:VNLib.Plugins.Essentials.Oauth.OauthSessionCacheExhaustedException"> + <summary> + Raised when the session cache space has been exhausted and cannot + load the new session into cache. + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions"> + <summary> + Represents an active oauth session + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.AppID(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + The ID of the application that granted the this token access + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.RefreshToken(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + The refresh token for this current token + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.Scopes(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + The token's privilage scope + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.Type(VNLib.Plugins.Essentials.Sessions.SessionInfo@)"> + <summary> + The Oauth2 token type + </summary>, + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.HasScope(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.String,System.String)"> + <summary> + Determines if the current session has the required scope type and the + specified permission + </summary> + <param name="session"></param> + <param name="type">The scope type</param> + <param name="permission">The scope permission</param> + <returns>True if the current session has the required scope, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Oauth.OauthSessionExtensions.HasScope(VNLib.Plugins.Essentials.Sessions.SessionInfo@,System.ReadOnlySpan{System.Char})"> + <summary> + Determines if the current session has the required scope type and the + specified permission + </summary> + <param name="session"></param> + <param name="scope">The scope to compare</param> + <returns>True if the current session has the required scope, false otherwise</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.ProtectedWebEndpoint"> + <summary> + Implements <see cref="T:VNLib.Plugins.Essentials.UnprotectedWebEndpoint"/> to provide + authoriation checks before processing + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.ProtectedWebEndpoint.PreProccess(VNLib.Plugins.Essentials.HttpEntity)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.ProtectionSettings"> + <summary> + A structure containing a basic security protocol + for connection pre-checks. Settings are the most + strict by default + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.TlsRequired"> + <summary> + Requires TLS be enabled for all incomming requets (or loopback adapter) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.SessionsRequired"> + <summary> + Checks that sessions are enabled for incomming requests + and that they are not new sessions. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.CrossSiteDenied"> + <summary> + Allows connections that define cross-site sec headers + to be processed or denied, (denied by default + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.RefererMatch"> + <summary> + Enables referr match protection. Requires that if a referer header is + set that it matches the current origin + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.BrowsersOnly"> + <summary> + Requires all connections to have pass an IsBrowser() check + (requires a valid user-agent header that contains Mozilla in + the string) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.VerifySessionCors"> + <summary> + If the connection has a valid session, verifies that the + stored session origin matches the client's origin header. + (confirms the session is coming from the same origin it + was created on) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ProtectionSettings.DisableCaching"> + <summary> + Disables response caching, by setting the cache control headers appropriatly. + Default is enabled + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.ProtectionSettings.#ctor"> + <summary> + Initalizes a new <see cref="T:VNLib.Plugins.Essentials.ProtectionSettings"/> with the most + strict security settings unless overriden + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.ResourceEndpointBase"> + <summary> + Provides a base class for implementing un-authenticated resource endpoints + with basic (configurable) security checks + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.ResourceEndpointBase.EndpointProtectionSettings"> + <summary> + Default protection settings. Protection settings are the most + secure by default, should be loosened an necessary + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Process(VNLib.Plugins.Essentials.HttpEntity)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.PreProccess(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Allows for synchronous Pre-Processing of an entity. The result + will determine if the method processing methods will be invoked, or + a <see cref="F:VNLib.Plugins.VfReturnType.Forbidden"/> error code will be returned + </summary> + <param name="entity">The incomming request to process</param> + <returns> + True if processing should continue, false if the response should be + <see cref="F:VNLib.Plugins.VfReturnType.Forbidden"/>, less than 0 if entity was + responded to. + </returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.PostAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming POST request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.GetAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming GET request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.DeleteAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming DELETE request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.PutAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming PUT request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.PatchAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming PATCH request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.AlternateMethodAsync(VNLib.Plugins.Essentials.HttpEntity,VNLib.Net.Http.HttpMethod)"> + <summary> + Invoked when a request is received for a method other than GET, POST, DELETE, or PUT; + </summary> + <param name="entity">The entity that </param> + <param name="method">The request method</param> + <returns>The results of the processing</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.WebsocketRequestedAsync(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Invoked when the current endpoint received a websocket request + </summary> + <param name="entity">The entity that requested the websocket</param> + <returns>The results of the operation</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Post(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming POST request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Get(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming GET request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Delete(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming DELETE request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Put(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming PUT request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.Patch(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + This method gets invoked when an incoming PATCH request to the endpoint has been requested. + </summary> + <param name="entity">The entity to be processed</param> + <returns>The result of the operation to return to the file processor</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.AlternateMethod(VNLib.Plugins.Essentials.HttpEntity,VNLib.Net.Http.HttpMethod)"> + <summary> + Invoked when a request is received for a method other than GET, POST, DELETE, or PUT; + </summary> + <param name="entity">The entity that </param> + <param name="method">The request method</param> + <returns>The results of the processing</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.ResourceEndpointBase.WebsocketRequested(VNLib.Plugins.Essentials.HttpEntity)"> + <summary> + Invoked when the current endpoint received a websocket request + </summary> + <param name="entity">The entity that requested the websocket</param> + <returns>The results of the operation</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionType"> + <summary> + Flags to specify <see cref="T:VNLib.Plugins.Essentials.Sessions.ISession"/> session types + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionType.Web"> + <summary> + The session is a "basic" or web based session + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionType.OAuth2"> + <summary> + The session is an OAuth2 session type + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.ISession"> + <summary> + Represents a connection oriented session data + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.SessionType"> + <summary> + A value specifying the type of the loaded session + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.Created"> + <summary> + UTC time in when the session was created + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.Privilages"> + <summary> + Privilages associated with user specified during login + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.SessionID"> + <summary> + Key that identifies the current session. (Identical to cookie::sessionid) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.UserID"> + <summary> + User ID associated with session + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.ISession.Invalidate(System.Boolean)"> + <summary> + Marks the session as invalid + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.Token"> + <summary> + Gets or sets the session's authorization token + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.UserIP"> + <summary> + The IP address belonging to the client + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.ISession.RegenID"> + <summary> + Sets the session ID to be regenerated if applicable + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.ISession.IsNew"> + <summary> + A value that indicates this session was newly created + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.ISessionExtensions.InitNewSession(VNLib.Plugins.Essentials.Sessions.ISession,VNLib.Net.Http.IConnectionInfo)"> + <summary> + Initializes a "new" session with initial varaibles from the current connection + for lookup/comparison later + </summary> + <param name="session"></param> + <param name="ci">The <see cref="T:VNLib.Net.Http.ConnectionInfo"/> object containing connection details</param> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.ISessionProvider"> + <summary> + Provides stateful session objects assocated with HTTP connections + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.ISessionProvider.GetSessionAsync(VNLib.Net.Http.IHttpEvent,System.Threading.CancellationToken)"> + <summary> + Gets a session handle for the current connection + </summary> + <param name="entity">The connection to get associated session on</param> + <param name="cancellationToken"></param> + <returns>A task the resolves an <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> instance</returns> + <exception cref="T:System.TimeoutException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Sessions.SessionException"></exception> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionBase"> + <summary> + Provides a base class for the <see cref="T:VNLib.Plugins.Essentials.Sessions.ISession"/> interface for exclusive use within a multithreaded + context + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionBase.Flags"> + <summary> + A <see cref="T:VNLib.Utils.BitField"/> of status flags for the state of the current session. + May be used internally + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.IsModified"> + <summary> + Gets or sets the Modified flag + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.Item(System.String)"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.UserIP"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.SessionType"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.SessionID"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.Created"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.Privilages"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.IsNew"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.UserID"> + <inheritdoc/> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.Token"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.Invalidate(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.RegenID"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.IndexerGet(System.String)"> + <summary> + Invoked when the indexer is is called to + </summary> + <param name="key">The key/index to get the value for</param> + <returns>The value stored at the specified key</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.IndexerSet(System.String,System.String)"> + <summary> + Sets a value requested by the indexer + </summary> + <param name="key">The key to associate the value with</param> + <param name="value">The value to store</param> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionBase.VNLib#Utils#Memory#Caching#ICacheable#Expires"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.System#IEquatable{VNLib#Utils#Memory#Caching#ICacheable}#Equals(VNLib.Utils.Memory.Caching.ICacheable)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.Evicted"> + <summary> + Invoked when the store caching this instance evicts the record. + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionBase.OnEvictedAsync"> + <summary> + Invoked when exclusive access is granted. + </summary> + <returns></returns> + <remarks> + NOTE: Method is executed in a background task, so exceptions should be caught. + </remarks> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionCacheLimitException"> + <summary> + Raised when the maximum number of cache entires has been reached, and the new session cannot be processed + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionException"> + <summary> + A base class for all session exceptions + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"> + <summary> + A handle that holds exclusive access to a <see cref="T:VNLib.Plugins.Essentials.Sessions.ISession"/> + session object + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionHandle.Empty"> + <summary> + An empty <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> instance. (A handle without a session object) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionHandle.SessionData"> + <summary> + The session data object associated with the current session + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionHandle.EntityStatus"> + <summary> + A value indicating if the connection is valid and should continue to be processed + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.#ctor(VNLib.Plugins.Essentials.Sessions.ISession,VNLib.Plugins.Essentials.FileProcessArgs,VNLib.Plugins.Essentials.Sessions.SessionReleaseCallback)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> + </summary> + <param name="sessionData">The session data instance</param> + <param name="callback">A callback that is invoked when the handle is released</param> + <param name="entityStatus"></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.#ctor(VNLib.Plugins.Essentials.Sessions.ISession,VNLib.Plugins.Essentials.Sessions.SessionReleaseCallback)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> + </summary> + <param name="sessionData">The session data instance</param> + <param name="callback">A callback that is invoked when the handle is released</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.ReleaseAsync(VNLib.Net.Http.IHttpEvent)"> + <summary> + Releases the session from use + </summary> + <param name="event">The current connection event object</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.Equals(VNLib.Plugins.Essentials.Sessions.SessionHandle)"> + <summary> + Determines if another <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> is equal to the current handle. + Handles are equal if neither handle is set or if their SessionData object is equal. + </summary> + <param name="other">The other handle to</param> + <returns>true if neither handle is set or if their SessionData object is equal, false otherwise</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.GetHashCode"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.op_Equality(VNLib.Plugins.Essentials.Sessions.SessionHandle,VNLib.Plugins.Essentials.Sessions.SessionHandle)"> + <summary> + Checks if two <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> instances are equal + </summary> + <param name="left"></param> + <param name="right"></param> + <returns></returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionHandle.op_Inequality(VNLib.Plugins.Essentials.Sessions.SessionHandle,VNLib.Plugins.Essentials.Sessions.SessionHandle)"> + <summary> + Checks if two <see cref="T:VNLib.Plugins.Essentials.Sessions.SessionHandle"/> instances are not equal + </summary> + <param name="left"></param> + <param name="right"></param> + <returns></returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Sessions.SessionInfo"> + <summary> + When attached to a connection, provides persistant session storage and inforamtion based + on a connection. + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.IsSet"> + <summary> + A value indicating if the current instance has been initiailzed + with a session. Otherwise properties are undefied + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.SessionID"> + <summary> + Key that identifies the current session. (Identical to cookie::sessionid) + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.UserAgent"> + <summary> + Session stored User-Agent + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.IPMatch"> + <summary> + If the stored IP and current user's IP matches + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.CrossOriginMatch"> + <summary> + If the current connection and stored session have matching cross origin domains + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionInfo.Invalidate(System.Boolean)"> + <summary> + Flags the session as invalid. IMPORTANT: the user's session data is no longer valid and will throw an exception when accessed + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionInfo.RegenID"> + <summary> + Marks the session ID to be regenerated during closing event + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionInfo.GetObject``1(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Sessions.SessionInfo.SetObject``1(System.String,``0)"> + <inheritdoc/> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.CrossOrigin"> + <summary> + Was the original session cross origin? + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.SpecifiedOrigin"> + <summary> + The origin header specified during session creation + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.Created"> + <summary> + Privilages associated with user specified during login + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.IsNew"> + <summary> + Was this session just created on this connection? + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.LoginHash"> + <summary> + Gets or sets the session's login hash, if set to a non-empty/null value, will trigger an upgrade on close + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.Token"> + <summary> + Gets or sets the session's login token, if set to a non-empty/null value, will trigger an upgrade on close + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.UserID"> + <summary> + <para> + Gets or sets the user-id for the current session. + </para> + <para> + Login code usually sets this value and it should be read-only + </para> + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.Privilages"> + <summary> + Privilages associated with user specified during login + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.UserIP"> + <summary> + The IP address belonging to the client + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Sessions.SessionInfo.SecurityProcol"> + <summary> + Was the session Initialy established on a secure connection? + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.SessionType"> + <summary> + A value specifying the type of the backing session + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Sessions.SessionInfo.Item(System.String)"> + <summary> + Accesses the session's general storage + </summary> + <param name="index">Key for specifie data</param> + <returns>Value associated with the key from the session's general storage</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Sql.SqlColumnName"> + <summary> + Property attribute that specifies the property represents an SQL column in the database + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sql.SqlColumnName.#ctor(System.String,System.Boolean,System.Boolean,System.Boolean)"> + <summary> + Specifies the property is an SQL column name + </summary> + <param name="columnName">Name of the SQL column</param> + <param name="primaryKey"></param> + <param name="nullable"></param> + <param name="unique"></param> + </member> + <member name="T:VNLib.Plugins.Essentials.Sql.SqlTableName"> + <summary> + Allows a type to declare itself as a <see cref="T:System.Data.DataTable"/> with the specified name + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Sql.SqlVariable"> + <summary> + Property attribute that specifies the property is to be used for a given command variable + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Sql.SqlVariable.#ctor(System.String,System.Data.DbType,System.Data.ParameterDirection,System.Int32,System.Boolean)"> + <summary> + Specifies the property to be used as an SQL variable + </summary> + <param name="variableName">Sql statement variable this property will substitute</param> + <param name="dataType">The sql data the property will represent</param> + <param name="direction">Data direction during execution</param> + <param name="size">Column size</param> + <param name="isNullable">Is this property allowed to be null</param> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.Blob"> + <summary> + Represents a stream of arbitrary binary data + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.BlobId"> + <summary> + The current blob's unique ID + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.Modified"> + <summary> + A value indicating if the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> has been modified + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.Deleted"> + <summary> + A valid indicating if the blob was flagged for deletiong + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.Name"> + <summary> + The name of the file (does not change the actual file system name) + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.LastWriteTimeUtc"> + <summary> + The UTC time the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> was last modified + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.CreationTimeUtc"> + <summary> + The UTC time the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> was created + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Lock(System.Int64,System.Int64)"> + <summary> + Prevents other processes from reading from or writing to the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> + </summary> + <param name="position">The begining position of the range to lock</param> + <param name="length">The range to be locked</param> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Lock"> + <summary> + Prevents other processes from reading from or writing to the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> + </summary> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Unlock(System.Int64,System.Int64)"> + <summary> + Allows access by other processes to all or part of the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> that was previously locked + </summary> + <param name="position">The begining position of the range to unlock</param> + <param name="length">The range to be unlocked</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Unlock"> + <summary> + Allows access by other processes to the entire <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> + </summary> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.SetLength(System.Int64)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.OnWrite(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Delete"> + <summary> + Marks the file for deletion and will be deleted when the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> is disposed + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.Blob.IsReleased"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.Release"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.FlushChangesAndSetReadonlyAsync"> + <summary> + <para> + If the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> was opened with writing enabled, + and file was modified, changes are flushed to the backing store + and the stream is set to readonly. + </para> + <para> + If calls to this method succeed the stream is placed into a read-only mode + which will cause any calls to Write to throw a <see cref="T:System.NotSupportedException"/> + </para> + </summary> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that may be awaited until the operation completes</returns> + <remarks> + This method may be called to avoid flushing changes to the backing store + when the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> is disposed (i.e. lifetime is manged outside of the desired scope) + </remarks> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.OnClose"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.DisposeAsync"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.Blob.ReleaseAsync"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobExtensions.GetVersion(VNLib.Plugins.Essentials.Storage.Blob)"> + <summary> + Gets the <see cref="T:System.Version"/> stored in the current <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> + </summary> + <returns>The sored version if previously set, thows otherwise</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobExtensions.SetVersion(VNLib.Plugins.Essentials.Storage.Blob,System.Version)"> + <summary> + Sets a <see cref="T:System.Version"/> for the current <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> + </summary> + <param name="blob"></param> + <param name="version">The <see cref="T:System.Version"/> of the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/></param> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobExtensions.IsError(VNLib.Plugins.Essentials.Storage.Blob)"> + <summary> + Gets a value indicating if the last operation left the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> in an undefined state + </summary> + <returns>True if the <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> state is undefined, false otherwise</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.BlobStore"> + <summary> + Stores <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/>s to the local file system backed with a single table <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageManager"/> + that tracks changes + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.BlobStore.RootDir"> + <summary> + The root directory all blob files are stored + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.BlobStore.BlobTable"> + <summary> + The backing store for blob meta-data + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobStore.#ctor(System.IO.DirectoryInfo,VNLib.Plugins.Essentials.Storage.LWStorageManager)"> + <summary> + Creates a new <see cref="T:VNLib.Plugins.Essentials.Storage.BlobStore"/> that accesses files + within the specified root directory. + </summary> + <param name="rootDir">The root directory containing the blob file contents</param> + <param name="blobStoreMan">The db backing store</param> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobStore.OpenBlobAsync(System.String,System.IO.FileAccess,System.IO.FileShare,System.Int32)"> + <summary> + Opens an existing <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> from the current store + </summary> + <param name="fileId">The id of the file being requested</param> + <param name="access">Access level of the file</param> + <param name="share">The sharing option of the underlying file</param> + <param name="bufferSize">The size of the file buffer</param> + <returns>If found, the requested <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/>, null otherwise. Throws exceptions if the file is opened in a non-sharable state</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.UnauthorizedAccessException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Storage.UndefinedBlobStateException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.BlobStore.CreateBlobAsync(System.String,System.IO.FileShare,System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> for the specified file sharing permissions + </summary> + <param name="name">The name of the original file</param> + <param name="share">The blob sharing permissions</param> + <param name="bufferSize"></param> + <returns>The newly created <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/></returns> + <exception cref="T:VNLib.Utils.Extensions.IoExtensions"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.UnauthorizedAccessException"></exception> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.IObjectStorage"> + <summary> + This object will provide methods for storing and retreiving objects by key-value pairing + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.IObjectStorage.GetObject``1(System.String)"> + <summary> + Attempts to retrieve the specified object from storage + </summary> + <typeparam name="T"></typeparam> + <param name="key">Key for storage</param> + <returns>The object in storage, or T.default if object is not found</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.IObjectStorage.SetObject``1(System.String,``0)"> + <summary> + Stores the specified object with the specified key + </summary> + <typeparam name="T"></typeparam> + <param name="key">Key paired with object</param> + <param name="obj">Object to store</param> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.LWDescriptorCreationException"> + <summary> + Raised when an operation to create a new <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> + fails + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWDescriptorCreationException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWDescriptorCreationException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWDescriptorCreationException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"> + <summary> + Represents an open storage object, that when released or disposed, will flush its changes to the underlying table + for which this descriptor represents + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.DescriptorID"> + <summary> + The currnt descriptor's identifier string within its backing table. Usually the primary key. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.UserID"> + <summary> + The identifier of the user for which this descriptor belongs to + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.Created"> + <summary> + The <see cref="T:System.DateTime"/> when the descriptor was created + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.LastModified"> + <summary> + The last time this descriptor was updated + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.GetObject``1(System.String)"> + <inheritdoc/> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.SetObject``1(System.String,``0)"> + <inheritdoc/> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.GetStringValue(System.String)"> + <summary> + Gets a string value from string storage matching a given key + </summary> + <param name="key">Key for storage</param> + <returns>Value associaetd with key if exists, <see cref="F:System.String.Empty"/> otherwise</returns> + <exception cref="T:System.ArgumentNullException">If key is null</exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.SetStringValue(System.String,System.String)"> + <summary> + Creates, overwrites, or removes a string value identified by key. + </summary> + <param name="key">Entry key</param> + <param name="value">String to store or overwrite, set to null or string.Empty to remove a property</param> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentNullException">If key is null</exception> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.Item(System.String)"> + <summary> + Gets or sets a string value from string storage matching a given key + </summary> + <param name="key">Key for storage</param> + <returns>Value associaetd with key if exists, <seealso cref="F:System.String.Empty"/> otherwise</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentNullException">If key is null</exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.WritePendingChanges"> + <summary> + Flushes all pending changes to the backing store. Beware, this is a synchronous, one-way update operation + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.WritePendingChangesAsync"> + <summary> + Flushes all pending changes to the backing store asynchronously + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor.GetResource"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.LWStorageManager"> + <summary> + Provides single table database object storage services + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Storage.LWStorageManager.NewDescriptorIdGenerator"> + <summary> + The generator function that is invoked when a new <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> is to + be created without an explicit id + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.#ctor(System.Func{System.Data.Common.DbConnection},System.String,System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageManager"/> with + </summary> + <param name="factory">A <see cref="T:System.Data.Common.DbConnection"/> factory function that will generate and open connections to a database</param> + <param name="tableName">The name of the table to operate on</param> + <param name="pkCharSize">The maximum number of characters of the DescriptorID and </param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.CreateDescriptorAsync(System.String,System.String,System.Threading.CancellationToken)"> + <summary> + Creates a new <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> fror a given user + </summary> + <param name="userId">Id of user</param> + <param name="descriptorIdOverride">An override to specify the new descriptor's id</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>A new <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> if successfully created, null otherwise</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Storage.LWDescriptorCreationException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.GetDescriptorFromUIDAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to retrieve <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> for a given user-id. The caller is responsible for + consitancy state of the descriptor + </summary> + <param name="userid">User's id</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>The descriptor belonging to the user, or null if not found or error occurs</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.GetDescriptorFromIDAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to retrieve the <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> for the given descriptor id. The caller is responsible for + consitancy state of the descriptor + </summary> + <param name="descriptorId">Unique identifier for the descriptor</param> + <returns>The descriptor belonging to the user, or null if not found or error occurs</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.CleanupTableAsync(System.TimeSpan,System.Threading.CancellationToken)"> + <summary> + Cleanup entries before the specified <see cref="T:System.TimeSpan"/>. Entires are store in UTC time + </summary> + <param name="compareTime">Time before <see cref="P:System.DateTime.UtcNow"/> to compare against</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>The number of entires cleaned</returns>S + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.CleanupTableAsync(System.DateTime,System.Threading.CancellationToken)"> + <summary> + Cleanup entries before the specified <see cref="T:System.DateTime"/>. Entires are store in UTC time + </summary> + <param name="compareTime">UTC time to compare entires against</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>The number of entires cleaned</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.UpdateDescriptorAsync(System.Object,System.IO.Stream)"> + <summary> + Updates a descriptor's data field + </summary> + <param name="descriptorObj">Descriptor to update</param> + <param name="data">Data string to store to descriptor record</param> + <exception cref="T:VNLib.Plugins.Essentials.Storage.LWStorageUpdateFailedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.RemoveDescriptorAsync(System.Object)"> + <summary> + Function to remove the specified descriptor + </summary> + <param name="descriptorObj">The active descriptor to remove from the database</param> + <exception cref="T:VNLib.Plugins.Essentials.Storage.LWStorageRemoveFailedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.GetItemAsync(System.Data.Common.DbDataReader,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Storage.LWStorageManager.CleanupItemAsync(VNLib.Plugins.Essentials.Storage.LWStorageDescriptor,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.LWStorageRemoveFailedException"> + <summary> + The exception raised when an open <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> removal operation fails. The + <see cref="P:System.Exception.InnerException"/> property may contain any nested exceptions that caused the removal to fail. + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.LWStorageUpdateFailedException"> + <summary> + The exception raised when an open <see cref="T:VNLib.Plugins.Essentials.Storage.LWStorageDescriptor"/> update operation fails. The + <see cref="P:System.Exception.InnerException"/> property may contain any nested exceptions that caused the update to fail. + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Storage.UndefinedBlobStateException"> + <summary> + Raised to signal that the requested <see cref="T:VNLib.Plugins.Essentials.Storage.Blob"/> was left in an undefined state + when previously accessed + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.TableManager"> + <summary> + A class that contains basic structures for interacting with an SQL driven database + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.TableManager.TableName"> + <summary> + The name of the table specified during initialized + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.TableManager.GetConnection"> + <summary> + Opens a new <see cref="T:System.Data.Common.DbConnection"/> by invoking the factory callback method + </summary> + <returns>The open connection</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.TimestampedCounter"> + <summary> + Stucture that allows for convient storage of a counter value + and a second precision timestamp into a 64-bit unsigned integer + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.TimestampedCounter.LastModified"> + <summary> + The time the count was last modifed + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.TimestampedCounter.Count"> + <summary> + The last failed login attempt count value + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.TimestampedCounter.#ctor(System.UInt32)"> + <summary> + Initalizes a new flc structure with the current UTC date + and the specified count value + </summary> + <param name="count">FLC current count</param> + </member> + <member name="M:VNLib.Plugins.Essentials.TimestampedCounter.op_Explicit(VNLib.Plugins.Essentials.TimestampedCounter)~System.UInt64"> + <summary> + Compacts and converts the counter value and timestamp into + a 64bit unsigned integer + </summary> + <param name="count">The counter to convert</param> + </member> + <member name="M:VNLib.Plugins.Essentials.TimestampedCounter.op_Explicit(System.UInt64)~VNLib.Plugins.Essentials.TimestampedCounter"> + <summary> + The previously compacted <see cref="T:VNLib.Plugins.Essentials.TimestampedCounter"/> + value to cast back to a counter + </summary> + <param name="value"></param> + </member> + <member name="T:VNLib.Plugins.Essentials.UnprotectedWebEndpoint"> + <summary> + A base class for un-authenticated web (browser) based resource endpoints + to implement. Adds additional security checks + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.UnprotectedWebEndpoint.PreProccess(VNLib.Plugins.Essentials.HttpEntity)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.IUser"> + <summary> + Represents an abstract user account + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.Privilages"> + <summary> + The user's privilage level + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.UserID"> + <summary> + The user's ID + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.Created"> + <summary> + Date the user's account was created + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.PassHash"> + <summary> + The user's password hash if retreived from the backing store, otherwise null + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.Status"> + <summary> + Status of account + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.LocalOnly"> + <summary> + Is the account only usable from local network? + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.Users.IUser.EmailAddress"> + <summary> + The user's email address + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUser.Delete"> + <summary> + Marks the user for deletion on release + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.IUserManager"> + <summary> + A backing store that provides user accounts + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.GetUserFromIDAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to get a user object without their password from the database asynchronously + </summary> + <param name="userId">The id of the user</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>The user's <see cref="T:VNLib.Plugins.Essentials.Users.IUser"/> object, null if the user was not found</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.GetUserFromEmailAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to get a user object without their password from the database asynchronously + </summary> + <param name="emailAddress">The user's email address</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>The user's <see cref="T:VNLib.Plugins.Essentials.Users.IUser"/> object, null if the user was not found</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.GetUserAndPassFromIDAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to get a user object with their password from the database on the current thread + </summary> + <param name="userid">The id of the user</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>The user's <see cref="T:VNLib.Plugins.Essentials.Users.IUser"/> object, null if the user was not found</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.GetUserAndPassFromEmailAsync(System.String,System.Threading.CancellationToken)"> + <summary> + Attempts to get a user object with their password from the database asynchronously + </summary> + <param name="emailAddress">The user's email address</param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>The user's <see cref="T:VNLib.Plugins.Essentials.Users.IUser"/> object, null if the user was not found</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.CreateUserAsync(System.String,System.String,System.UInt64,VNLib.Utils.Memory.PrivateString,System.Threading.CancellationToken)"> + <summary> + Creates a new user in the current user's table and if successful returns the new user object (without password) + </summary> + <param name="userid">The user id</param> + <param name="privilages">A number representing the privilage level of the account</param> + <param name="passHash">Value to store in the password field</param> + <param name="cancellation">A token to cancel the operation</param> + <param name="emailAddress">The account email address</param> + <returns>An object representing a user's account if successful, null otherwise</returns> + <exception cref="T:VNLib.Plugins.Essentials.Users.UserExistsException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:VNLib.Plugins.Essentials.Users.UserCreationFailedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.UpdatePassAsync(VNLib.Plugins.Essentials.Users.IUser,VNLib.Utils.Memory.PrivateString,System.Threading.CancellationToken)"> + <summary> + Updates a password associated with the specified user. If the update fails, the transaction + is rolled back. + </summary> + <param name="user">The user account to update the password of</param> + <param name="newPass">The new password to set</param> + <param name="cancellation">A token to cancel the operation</param> + <returns>The result of the operation, the result should be 1 (aka true)</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.IUserManager.GetUserCountAsync(System.Threading.CancellationToken)"> + <summary> + Gets the number of entries in the current user table + </summary> + <param name="cancellation">A token to cancel the operation</param> + <returns>The number of users in the table, or -1 if the operation failed</returns> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.UserCreationFailedException"> + <summary> + Raised when a user creation operation has failed and could not be created + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.UserDeleteException"> + <summary> + Raised when a user flagged for deletion could not be deleted. See the <see cref="P:System.Exception.InnerException"/> + for the Exception that cause the opertion to fail + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.UserExistsException"> + <summary> + Raised when an <see cref="T:VNLib.Plugins.Essentials.Users.IUserManager"/> operation + fails because the user account already exists + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.UserExistsException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.UserExistsException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.UserExistsException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Essentials.Users.UserExistsException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + <member name="F:VNLib.Plugins.Essentials.Users.UserStatus.Unverified"> + <summary> + Unverified account state + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Users.UserStatus.Active"> + <summary> + Active account state. The account is fully functional + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Users.UserStatus.Suspended"> + <summary> + The account is suspended + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Users.UserStatus.Inactive"> + <summary> + The account is inactive as marked by the system + </summary> + </member> + <member name="F:VNLib.Plugins.Essentials.Users.UserStatus.Locked"> + <summary> + The account has been locked from access + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.Users.UserUpdateException"> + <summary> + Raised when a user-data object was modified and an update operation failed + </summary> + </member> + <member name="T:VNLib.Plugins.Essentials.VirtualEndpoint`1"> + <summary> + Provides a base class for <see cref="T:VNLib.Plugins.IVirtualEndpoint`1"/> entity processors + with checks and a log provider + </summary> + <typeparam name="T">The entity type to process</typeparam> + </member> + <member name="P:VNLib.Plugins.Essentials.VirtualEndpoint`1.Path"> + <inheritdoc/> + </member> + <member name="F:VNLib.Plugins.Essentials.VirtualEndpoint`1.Log"> + <summary> + An <see cref="T:VNLib.Utils.Logging.ILogProvider"/> to write logs to + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.VirtualEndpoint`1.InitPathAndLog(System.String,VNLib.Utils.Logging.ILogProvider)"> + <summary> + Sets the log and path and checks the values + </summary> + <param name="Path">The path this instance represents</param> + <param name="log">The log provider that will be used</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.VirtualEndpoint`1.Process(`0)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Essentials.WebsocketAcceptedCallback"> + <summary> + A callback method to invoke when an HTTP service successfully transfers protocols to + the WebSocket protocol and the socket is ready to be used + </summary> + <param name="session">The open websocket session instance</param> + <returns> + A <see cref="T:System.Threading.Tasks.Task"/> that will be awaited by the HTTP layer. When the task completes, the transport + will be closed and the session disposed + </returns> + </member> + <member name="T:VNLib.Plugins.Essentials.WebSocketSession"> + <summary> + Represents a <see cref="T:System.Net.WebSockets.WebSocket"/> wrapper to manage the lifetime of the captured + connection context and the underlying transport. This session is managed by the parent + <see cref="T:VNLib.Net.Http.HttpServer"/> that it was created on. + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.WebSocketSession.Token"> + <summary> + A cancellation token that can be monitored to reflect the state + of the webscocket + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.WebSocketSession.SocketID"> + <summary> + Id assigned to this instance on creation + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.WebSocketSession.SubProtocol"> + <summary> + Negotiated sub-protocol + </summary> + </member> + <member name="P:VNLib.Plugins.Essentials.WebSocketSession.UserState"> + <summary> + A user-defined state object passed during socket accept handshake + </summary> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.RunAsync(System.IO.Stream)"> + <summary> + Initialzes the created websocket with the specified protocol + </summary> + <param name="transport">Transport stream to use for the websocket</param> + <returns>The accept callback function specified during object initialization</returns> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.ReceiveAsync(System.ArraySegment{System.Byte})"> + <summary> + Asynchronously receives data from the Websocket and copies the data to the specified buffer + </summary> + <param name="buffer">The buffer to store read data</param> + <returns>A task that resolves a <see cref="T:System.Net.WebSockets.WebSocketReceiveResult"/> which contains the status of the operation</returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.ReceiveAsync(System.Memory{System.Byte})"> + <summary> + Asynchronously receives data from the Websocket and copies the data to the specified buffer + </summary> + <param name="buffer">The buffer to store read data</param> + <returns></returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.SendAsync(System.ArraySegment{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean)"> + <summary> + Asynchronously sends the specified buffer to the client of the specified type + </summary> + <param name="buffer">The buffer containing data to send</param> + <param name="type">The message/data type of the packet to send</param> + <param name="endOfMessage">A value that indicates this message is the final message of the transaction</param> + <returns></returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.SendAsync(System.ReadOnlyMemory{System.Byte},System.Net.WebSockets.WebSocketMessageType,System.Boolean)"> + <summary> + Asynchronously sends the specified buffer to the client of the specified type + </summary> + <param name="buffer">The buffer containing data to send</param> + <param name="type">The message/data type of the packet to send</param> + <param name="endOfMessage">A value that indicates this message is the final message of the transaction</param> + <returns></returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.CloseSocketAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String)"> + <summary> + Properly closes a currently connected websocket + </summary> + <param name="status">Set the close status</param> + <param name="reason">Set the close reason</param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Essentials.WebSocketSession.CloseSocketOutputAsync(System.Net.WebSockets.WebSocketCloseStatus,System.String,System.Threading.CancellationToken)"> + <summary> + + </summary> + <param name="status"></param> + <param name="reason"></param> + <param name="cancellation"></param> + <returns></returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.dll Binary files differnew file mode 100644 index 0000000..870b22b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.xml new file mode 100644 index 0000000..20f5473 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Extensions.Loading.xml @@ -0,0 +1,351 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Extensions.Loading</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1"> + <summary> + <para> + Represents a disposable assembly loader wrapper for + exporting a signle type from a loaded assembly + </para> + <para> + If the loaded type implements <see cref="T:System.IDisposable"/> the + dispose method is called when the loader is disposed + </para> + </summary> + <typeparam name="T">The exported type to manage</typeparam> + </member> + <member name="P:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1.Resource"> + <summary> + The instance of the loaded type + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1.LoadAndGetExportedType"> + <summary> + Loads the default assembly and gets the expected export type, + creates a new instance, and calls its parameterless constructor + </summary> + <returns>The desired type instance</returns> + <exception cref="T:System.EntryPointNotFoundException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1.Load(System.String,System.Threading.CancellationToken)"> + <summary> + Creates a new assembly loader for the specified type and + </summary> + <param name="assemblyName">The name of the assmbly within the current plugin directory</param> + <param name="unloadToken">The plugin unload token</param> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute"> + <summary> + Specifies a configuration variable name in the plugin's configuration + containing data specific to the type + </summary> + </member> + <member name="F:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute.ConfigVarName"> + <summary> + + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute.#ctor(System.String)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute"/> + </summary> + <param name="configVarName">The name of the configuration variable for the class</param> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions"> + <summary> + Contains extensions for plugin configuration specifc extensions + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.GetConfigForType``1(VNLib.Plugins.PluginBase)"> + <summary> + Retrieves a top level configuration dictionary of elements for the specified type. + The type must contain a <see cref="T:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute"/> + </summary> + <typeparam name="T">The type to get the configuration of</typeparam> + <param name="plugin"></param> + <returns>A <see cref="T:System.Collections.Generic.Dictionary`2"/> of top level configuration elements for the type</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.GetConfig(VNLib.Plugins.PluginBase,System.String)"> + <summary> + Retrieves a top level configuration dictionary of elements with the specified property name, + from the plugin config first, or falls back to the host config file + </summary> + <param name="plugin"></param> + <param name="propName">The config property name to retrieve</param> + <returns>A <see cref="T:System.Collections.Generic.Dictionary`2"/> of top level configuration elements for the type</returns> + <exception cref="T:System.Collections.Generic.KeyNotFoundException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.TryGetConfig(VNLib.Plugins.PluginBase,System.String)"> + <summary> + Retrieves a top level configuration dictionary of elements with the specified property name, + from the plugin config first, or falls back to the host config file + </summary> + <param name="plugin"></param> + <param name="propName">The config property name to retrieve</param> + <returns>A <see cref="T:System.Collections.Generic.Dictionary`2"/> of top level configuration elements for the type</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.GetConfigForType(VNLib.Plugins.PluginBase,System.Type)"> + <summary> + Retrieves a top level configuration dictionary of elements for the specified type. + The type must contain a <see cref="T:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationNameAttribute"/> + </summary> + <param name="plugin"></param> + <param name="type">The type to get configuration data for</param> + <returns>A <see cref="T:System.Collections.Generic.Dictionary`2"/> of top level configuration elements for the type</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.GetConfig(VNLib.Plugins.PluginBase,System.Object)"> + <summary> + Shortcut extension for <see cref="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.GetConfigForType``1(VNLib.Plugins.PluginBase)"/> to get + config of current class + </summary> + <param name="obj">The object that a configuration can be retrieved for</param> + <param name="plugin">The plugin containing configuration variables</param> + <returns>A <see cref="T:System.Collections.Generic.Dictionary`2"/> of top level configuration elements for the type</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.HasConfigForType``1(VNLib.Plugins.PluginBase)"> + <summary> + Determines if the current plugin configuration contains the require properties to initialize + the type + </summary> + <typeparam name="T"></typeparam> + <param name="plugin"></param> + <returns>True if the plugin config contains the require configuration property</returns> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Configuration.ConfigurationExtensions.TryGetS3Config(VNLib.Plugins.PluginBase)"> + <summary> + Attempts to load the basic S3 configuration variables required + for S3 client access + </summary> + <param name="plugin"></param> + <returns>The S3 configuration object found in the plugin/host configuration</returns> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.AsyncIntervalAttribute"> + <summary> + When added to a method schedules it as a callback on a specified interval when + the plugin is loaded, and stops when unloaded + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.AsyncIntervalAttribute.#ctor(System.Int32)"> + <summary> + Intializes the <see cref="T:VNLib.Plugins.Extensions.Loading.Events.AsyncIntervalAttribute"/> with the specified timeout in milliseconds + </summary> + <param name="milliseconds">The interval in milliseconds</param> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.ConfigurableAsyncIntervalAttribute"> + <summary> + When added to a method schedules it as a callback on a specified interval when + the plugin is loaded, and stops when unloaded + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.ConfigurableAsyncIntervalAttribute.#ctor(System.String,VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType)"> + <summary> + Initializes a <see cref="T:VNLib.Plugins.Extensions.Loading.Events.ConfigurableAsyncIntervalAttribute"/> with the specified + interval property name + </summary> + <param name="configPropName">The configuration property name for the event interval</param> + <param name="resolution">The time resoltion for the event interval</param> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.EventHandle"> + <summary> + Represents a handle to a scheduled event interval that is managed by the plugin but may be cancled by disposing the instance + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.EventHandle.Pause"> + <summary> + Pauses the event timer until the <see cref="T:VNLib.Utils.OpenHandle"/> is released or disposed + then resumes to the inital interval period + </summary> + <returns>A <see cref="T:VNLib.Utils.OpenHandle"/> that restores the timer to its initial state when disposed</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.EventHandle.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.AsyncSchedulableCallback`1"> + <summary> + A deletage to form a method signature for shedulable interval callbacks + </summary> + <typeparam name="T">The state type</typeparam> + <param name="state">The state instance to pass to event handler</param> + <param name="pluginExitToken">The plugin's exit token</param> + <returns>A task the represents the asynchronous work</returns> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.EventManagment"> + <summary> + Provides event schedueling extensions for plugins + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.EventManagment.ScheduleInterval``1(VNLib.Plugins.PluginBase,VNLib.Plugins.Extensions.Loading.Events.AsyncSchedulableCallback{``0},``0,System.TimeSpan)"> + <summary> + Schedules an asynchronous event interval for the current plugin, that is active until canceled or until the plugin unloads + </summary> + <typeparam name="TState">Stateful event argument</typeparam> + <param name="plugin"></param> + <param name="asyncCallback">An asyncrhonous callback method.</param> + <param name="state"></param> + <param name="interval">The event interval</param> + <returns>An <see cref="T:VNLib.Plugins.Extensions.Loading.Events.EventHandle"/> that can manage the interval state</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <remarks>If exceptions are raised during callback execution, they are written to the plugin's default log provider</remarks> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.EventManagment.ScheduleInterval(VNLib.Plugins.PluginBase,VNLib.Plugins.Extensions.Loading.Events.IIntervalScheduleable,System.TimeSpan)"> + <summary> + Registers an <see cref="T:VNLib.Plugins.Extensions.Loading.Events.IIntervalScheduleable"/> type's event handler for + raising timed interval events + </summary> + <param name="plugin"></param> + <param name="scheduleable">The instance to schedule for timeouts</param> + <param name="interval">The timeout interval</param> + <returns>An <see cref="T:VNLib.Plugins.Extensions.Loading.Events.EventHandle"/> that can manage the interval state</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <remarks>If exceptions are raised during callback execution, they are written to the plugin's default log provider</remarks> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.IIntervalScheduleable"> + <summary> + Exposes a type for asynchronous event schelueling + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Events.IIntervalScheduleable.OnIntervalAsync(VNLib.Utils.Logging.ILogProvider,System.Threading.CancellationToken)"> + <summary> + A method that is called when the interval time has elapsed + </summary> + <param name="log">The plugin default log provider</param> + <param name="cancellationToken">A token that may cancel an operations if the plugin becomes unloaded</param> + <returns>A task that resolves when the async operation completes</returns> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType"> + <summary> + The configurable event interval resulution type + </summary> + </member> + <member name="F:VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType.Milliseconds"> + <summary> + Specifies event interval resolution in milliseconds + </summary> + </member> + <member name="F:VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType.Seconds"> + <summary> + Specifies event interval resolution in seconds + </summary> + </member> + <member name="F:VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType.Minutes"> + <summary> + Specifies event interval resolution in minutes + </summary> + </member> + <member name="F:VNLib.Plugins.Extensions.Loading.Events.IntervalResultionType.Hours"> + <summary> + Specifies event interval resolution in hours + </summary> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.LoadingExtensions"> + <summary> + Provides common loading (and unloading when required) extensions for plugins + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.LoadingExtensions.GetPasswords(VNLib.Plugins.PluginBase)"> + <summary> + Gets the plugins ambient <see cref="T:VNLib.Plugins.Essentials.Accounts.PasswordHashing"/> if loaded, or loads it if required. This class will + be unloaded when the plugin us unloaded. + </summary> + <param name="plugin"></param> + <returns>The ambient <see cref="T:VNLib.Plugins.Essentials.Accounts.PasswordHashing"/></returns> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.Collections.Generic.KeyNotFoundException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.LoadingExtensions.LoadAssembly``1(VNLib.Plugins.PluginBase,System.String,System.IO.SearchOption)"> + <summary> + Loads an assembly into the current plugins AppDomain and will unload when disposed + or the plugin is unloaded from the host application. + </summary> + <typeparam name="T">The desired exported type to load from the assembly</typeparam> + <param name="plugin"></param> + <param name="assemblyName">The name of the assembly (ex: 'file.dll') to search for</param> + <param name="dirSearchOption">Directory/file search option</param> + <returns>The <see cref="T:VNLib.Plugins.Extensions.Loading.AssemblyLoader`1"/> managing the loaded assmbly in the current AppDomain</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.IO.FileNotFoundException"></exception> + <exception cref="T:System.EntryPointNotFoundException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.LoadingExtensions.IsDebug(VNLib.Plugins.PluginBase)"> + <summary> + Determintes if the current plugin config has a debug propety set + </summary> + <param name="plugin"></param> + <returns>True if debug mode is enabled, false otherwise</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.LoadingExtensions.ThrowIfUnloaded(VNLib.Plugins.PluginBase)"> + <summary> + Internal exception helper to raise <see cref="T:System.ObjectDisposedException"/> if the plugin has been unlaoded + </summary> + <param name="plugin"></param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions"> + <summary> + Provides advanced QOL features to plugin loading + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route``1(VNLib.Plugins.PluginBase,System.String)"> + <summary> + Constructs and routes the specific endpoint type for the current plugin + </summary> + <typeparam name="T">The <see cref="T:VNLib.Plugins.IEndpoint"/> type</typeparam> + <param name="plugin"></param> + <param name="pluginConfigPathName">The path to the plugin sepcific configuration property</param> + <exception cref="T:System.Reflection.TargetInvocationException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route``1(VNLib.Plugins.PluginBase)"> + <summary> + Constructs and routes the specific endpoint type for the current plugin + </summary> + <typeparam name="T">The <see cref="T:VNLib.Plugins.IEndpoint"/> type</typeparam> + <param name="plugin"></param> + <exception cref="T:System.Reflection.TargetInvocationException"></exception> + </member> + <member name="T:VNLib.Plugins.Extensions.Loading.PluginSecretLoading"> + <summary> + Adds loading extensions for secure/centralized configuration secrets + </summary> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.PluginSecretLoading.TryGetSecretAsync(VNLib.Plugins.PluginBase,System.String)"> + <summary> + <para> + Gets a secret from the "secrets" element. The + </para> + <para> + Secrets elements are merged from the host config and plugin local config 'secrets' element. + before searching. The plugin config takes precedence over the host config. + </para> + </summary> + <param name="plugin"></param> + <param name="secretName">The name of the secret propery to get</param> + <returns>The element from the configuration file with the given name, or null if the configuration or propery does not exist</returns> + <exception cref="T:System.Collections.Generic.KeyNotFoundException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Plugins.Extensions.Loading.PluginSecretLoading.GetSecretFromVaultAsync(VNLib.Plugins.PluginBase,System.ReadOnlySpan{System.Char})"> + <summary> + Gets a secret at the given vault url (in the form of "vault://[mount-name]/[secret-path]?secret=[secret_name]") + </summary> + <param name="plugin"></param> + <param name="vaultPath">The raw vault url to lookup</param> + <returns>The string of the object at the specified vault path</returns> + <exception cref="T:System.UriFormatException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.dll Binary files differnew file mode 100644 index 0000000..06ea301 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.xml new file mode 100644 index 0000000..ddcdff1 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.PluginBase.xml @@ -0,0 +1,136 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.PluginBase</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.PluginBase"> + <summary> + Provides a concrete base class for <see cref="T:VNLib.Plugins.IPlugin"/> instances using the Serilog logging provider. + Accepts the standard plugin <see cref="T:System.Text.Json.JsonDocument"/> configuration constructors + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.UnloadToken"> + <summary> + A cancellation token that is cancelled when the plugin has been unloaded + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.GlobalConfigDomPropertyName"> + <summary> + The property name of the host/global configuration element in the plugin + runtime supplied configuration object. + </summary> + </member> + <member name="F:VNLib.Plugins.PluginBase.Endpoints"> + <summary> + A list of all currently prepared <see cref="T:VNLib.Plugins.IEndpoint"/> endpoints. + Endpoints must be added to this list before <see cref="M:VNLib.Plugins.IPlugin.GetEndpoints"/> is called + by the host app + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.Log"> + <summary> + The logging instance + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.Configuration"> + <summary> + If passed by the host application, the configuration file of the host application and plugin + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.HostConfig"> + <summary> + The configuration data from the host application + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.PluginConfig"> + <summary> + The configuration data from the plugin's config file passed by the host application + </summary> + </member> + <member name="P:VNLib.Plugins.PluginBase.PluginName"> + <summary> + <inheritdoc/> + </summary> + </member> + <member name="M:VNLib.Plugins.PluginBase.InitConfig(System.Text.Json.JsonDocument)"> + <summary> + The host application may invoke this method when the assembly is loaded and this plugin is constructed to pass + a configuration object to the instance. This method populates the configuration objects if applicable. + </summary> + </member> + <member name="M:VNLib.Plugins.PluginBase.InitLog(System.String[])"> + <summary> + Responsible for initalizing the log provider. The host should invoke this method + directly after the configuration is initialized + </summary> + <param name="cmdArgs"></param> + </member> + <member name="M:VNLib.Plugins.PluginBase.HandleCommand(System.String)"> + <summary> + When overriden handles a console command + </summary> + <param name="cmd"></param> + </member> + <member name="M:VNLib.Plugins.PluginBase.ProcessHostCommand(System.String)"> + <summary> + Invoked when the host process has a command message to send + </summary> + <param name="cmd">The command message</param> + </member> + <member name="M:VNLib.Plugins.PluginBase.OnLoad"> + <summary> + Invoked when the host loads the plugin instance + </summary> + </member> + <member name="M:VNLib.Plugins.PluginBase.OnUnLoad"> + <summary> + Invoked when all endpoints have been removed from service. All managed and unmanged resources should be released. + </summary> + </member> + <member name="M:VNLib.Plugins.PluginBase.OnGetEndpoints"> + <summary> + Invoked before <see cref="M:VNLib.Plugins.IPlugin.GetEndpoints"/> called by the host app to get all endpoints + for the current plugin + </summary> + </member> + <member name="M:VNLib.Plugins.PluginBase.Route(VNLib.Plugins.IEndpoint)"> + <summary> + Adds the specified endpoint to be routed when loading is complete + </summary> + <param name="endpoint">The <see cref="T:VNLib.Plugins.IEndpoint"/> to present to the application when loaded</param> + </member> + <member name="T:VNLib.Plugins.VLogProvider"> + <summary> + Provides a concrete <see cref="T:VNLib.Utils.Logging.ILogProvider"/> instance for writing events to a <see cref="T:Serilog.Log"/> sink + </summary> + </member> + <member name="M:VNLib.Plugins.VLogProvider.#ctor(Serilog.LoggerConfiguration)"> + <summary> + Creates a new <see cref="T:Serilog.ILogger"/> from the specified <see cref="T:Serilog.LoggerConfiguration"/> + </summary> + <param name="config">Configuration to generate the logger from</param> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Flush"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.GetLogProvider"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Write(VNLib.Utils.Logging.LogLevel,System.Exception,System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String,System.Object[])"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String,System.ValueType[])"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.VLogProvider.Free"> + <inheritdoc/> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.dll Binary files differnew file mode 100644 index 0000000..b300dd6 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.xml new file mode 100644 index 0000000..2665d86 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.Sessions.Cache.Client.xml @@ -0,0 +1,158 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins.Sessions.Cache.Client</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient"> + <summary> + A client that allows access to sessions located on external servers + </summary> + </member> + <member name="P:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.GetSessionId"> + <summary> + A callback that produces a session-id from the connection (or a new id if needed) + </summary> + </member> + <member name="P:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.NewSessionId"> + <summary> + A callback that produces a new session-id for the connection (and updates the client if necessary) + </summary> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.#ctor(System.Int32,System.Int32,VNLib.Utils.Logging.ILogProvider,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Initializes a new <see cref="T:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient"/> + </summary> + <param name="maxDataSize">The maxium size (in bytes) of blob items to stored on the remote server</param> + <param name="maxCacheItems">The maximum number of sessions to keep in memory</param> + <param name="log">A <see cref="T:VNLib.Utils.Logging.ILogProvider"/> to write log events to</param> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate buffers from</param> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.GetSessionAsync(VNLib.Net.Http.HttpEvent,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.CacheClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.CacheHardClear"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.OnConnected"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.OnError(VNLib.Net.Messaging.FBM.Client.FMBClientErrorEventArgs)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.SessionCacheClient.OnDisconnected"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.ListServersAsync(System.Uri,System.Security.Cryptography.RSA,System.Threading.CancellationToken)"> + <summary> + Contacts the cache broker to get a list of active servers to connect to + </summary> + <param name="brokerAddress">The broker server to connec to</param> + <param name="signature">The signature algorithm used to sign messages to the broker</param> + <param name="cancellationToken"></param> + <returns>The list of active servers</returns> + <exception cref="T:System.Security.SecurityException"></exception> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.ConnectAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.String,System.Security.Cryptography.RSA,System.String,System.String,System.Boolean,System.Threading.CancellationToken)"> + <summary> + Configures a connection to the remote cache server at the specified location + with proper authentication. + </summary> + <param name="client"></param> + <param name="serverUri">The server's address</param> + <param name="sigAlg">The algorithm used to signed the message</param> + <param name="challenge">A challenge to send to the server</param> + <param name="replicaId">A token used to identify the current server's event queue on the remote server</param> + <param name="token">A token to cancel the connection operation</param> + <param name="useTls">Enables the secure websocket protocol</param> + <returns>A Task that completes when the connection has been established</returns> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.ConnectAsync(VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase,System.String,System.Security.Cryptography.RSA,System.String,System.Boolean,System.Threading.CancellationToken)"> + <summary> + Configures a connection to the remote cache server at the specified location + with proper authentication. + </summary> + <param name="client"></param> + <param name="serverUri">The server's address</param> + <param name="sigAlg">The algorithm used to signed the message</param> + <param name="challenge">A challenge to send to the server</param> + <param name="token">A token to cancel the connection operation</param> + <param name="useTls">Enables the secure websocket protocol</param> + <returns>A task that completes when the connection has been established</returns> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.SetSignatureAlg(VNLib.Net.Messaging.FBM.Client.FBMClient,System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char}@)"> + <summary> + Sets the signing algorithm used to sign the connection request to the remote cache server. + </summary> + <param name="client"></param> + <param name="encryptedPem">The encrypted PEM file for the connection algorithm</param> + <param name="password">The password to decrypt the encrypted PEM</param> + <returns>A chaining client</returns> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.DiscoverNodesAsync(VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase,System.Threading.CancellationToken)"> + <summary> + Discovers cache nodes in the broker configured for the current client. + </summary> + <param name="client"></param> + <param name="token">A token to cancel the discovery</param> + <returns>A task the resolves the list of active servers on the broker server</returns> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.DiscoverNodesAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,System.Threading.CancellationToken)"> + <summary> + Discovers cache nodes in the broker configured for the current client. + </summary> + <param name="client"></param> + <param name="token">A token to cancel the discovery </param> + <returns>A task the resolves the list of active servers on the broker server</returns> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.ConnectAndWaitForExitAsync(VNLib.Net.Messaging.FBM.Client.FBMClientWorkerBase,VNLib.Plugins.Sessions.Cache.Client.ActiveServer,System.Threading.CancellationToken)"> + <summary> + Connects the client to a remote cache server + </summary> + <param name="client"></param> + <param name="server">The server to connect to</param> + <param name="token">A token to cancel the connection and/or wait operation</param> + <returns>A task that resolves when cancelled or when the connection is lost to the server</returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.ConnectAndWaitForExitAsync(VNLib.Net.Messaging.FBM.Client.FBMClient,VNLib.Plugins.Sessions.Cache.Client.ActiveServer,System.Threading.CancellationToken)"> + <summary> + Connects the client to a remote cache server + </summary> + <param name="client"></param> + <param name="server">The server to connect to</param> + <param name="token">A token to cancel the connection and/or wait operation</param> + <returns>A task that resolves when cancelled or when the connection is lost to the server</returns> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.CacheHelpers.SelectRandom(System.Collections.Generic.ICollection{VNLib.Plugins.Sessions.Cache.Client.ActiveServer})"> + <summary> + Selects a random server from a collection of active servers + </summary> + <param name="servers"></param> + <returns>A server selected at random</returns> + </member> + <member name="T:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException"> + <summary> + Raised when a request message is too large to send to + the server and the server may close the connection. + </summary> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.String,System.Exception)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Plugins.Sessions.Cache.Client.MessageTooLargeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)"> + <inheritdoc/> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.dll Binary files differnew file mode 100644 index 0000000..11dc80d --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.xml new file mode 100644 index 0000000..47c7a5b --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Plugins.xml @@ -0,0 +1,159 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Plugins</name> + </assembly> + <members> + <member name="T:VNLib.Plugins.ConfigurationInitalizerAttribute"> + <summary> + Set this attribute on an <see cref="T:VNLib.Plugins.IPlugin"/> instance method to define the configuration initializer. + This attribute can only be defined on a single instance method and cannot be overloaded. + <br></br> + A plugin host should invoke this method before <see cref="M:VNLib.Plugins.IPlugin.Load"/> + <br></br> + Method signature <code>public void [methodname] (<see cref="T:System.Text.Json.JsonDocument"/> config)</code> + </summary> + </member> + <member name="T:VNLib.Plugins.ConfigInitializer"> + <summary> + Represents a safe configuration initializer delegate method + </summary> + <param name="config">The configuration object that plugin will use</param> + </member> + <member name="T:VNLib.Plugins.Attributes.ConsoleEventHandlerAttribute"> + <summary> + <para> + Set this attribute on an <see cref="T:VNLib.Plugins.IPlugin"/> instance method to define the console message event handler + This attribute can only be defined on a single instance method and cannot be overloaded. + </para> + <para> + Method signature <code>public void [methodname] (<see cref="T:System.String"/> command)</code> + </para> + </summary> + </member> + <member name="T:VNLib.Plugins.Attributes.ConsoleEventHandler"> + <summary> + Represents a safe console event delegate method + </summary> + <param name="command">The command to be passed to the plugin</param> + </member> + <member name="T:VNLib.Plugins.LogInitializerAttribute"> + <summary> + Set this attribute on an <see cref="T:VNLib.Plugins.IPlugin"/> instance method to define the log initalizer. + This attribute can only be defined on a single instance method and cannot be overloaded. + <br></br> + A plugin host should invoke this method before <see cref="M:VNLib.Plugins.IPlugin.Load"/> but after a <see cref="T:VNLib.Plugins.ConfigurationInitalizerAttribute"/> method + <br></br> + Method signature <code>public void [methodname] (<see cref="T:System.String"/>[] cmdArgs)</code> + </summary> + </member> + <member name="T:VNLib.Plugins.LogInitializer"> + <summary> + Represents a safe logger initializer delegate method + </summary> + <param name="args">The arguments to pass to the log iniializer (usually command line args)</param> + </member> + <member name="T:VNLib.Plugins.IEndpoint"> + <summary> + A base class for all entity processing endpoints to listen for requests + </summary> + </member> + <member name="P:VNLib.Plugins.IEndpoint.Path"> + <summary> + The location path for which to match this handler + </summary> + </member> + <member name="T:VNLib.Plugins.VfReturnType"> + <summary> + Represents the result of a virutal endpoint processing operation + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.ProcessAsFile"> + <summary> + Signals that the virtual endpoint + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.VirtualSkip"> + <summary> + Signals that the virtual endpoint generated a response, and + the connection should be completed + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.Forbidden"> + <summary> + Signals that the virtual endpoint determined that the connection + should be denied. + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.NotFound"> + <summary> + Signals that the resource the virtual endpoint was processing + does not exist. + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.BadRequest"> + <summary> + Signals that the virutal endpoint determined the request was invalid + </summary> + </member> + <member name="F:VNLib.Plugins.VfReturnType.Error"> + <summary> + Signals that the virtual endpoint had an error + </summary> + </member> + <member name="T:VNLib.Plugins.IPlugin"> + <summary> + Allows for applications to define plugin capabilities + </summary> + </member> + <member name="P:VNLib.Plugins.IPlugin.PluginName"> + <summary> + The name of the plugin to referrence (may be used by the host to interact) + </summary> + </member> + <member name="M:VNLib.Plugins.IPlugin.Load"> + <summary> + Performs operations to prepare the plugin for use + </summary> + </member> + <member name="M:VNLib.Plugins.IPlugin.Unload"> + <summary> + Invoked when the plugin is unloaded from the runtime + </summary> + </member> + <member name="M:VNLib.Plugins.IPlugin.GetEndpoints"> + <summary> + Returns all endpoints within the plugin to load into the current root + </summary> + <returns>An enumeration of endpoints to load</returns> + </member> + <member name="T:VNLib.Plugins.IVirtualEndpoint`1"> + <summary> + Represents a virtual page which provides processing on an entity + </summary> + <typeparam name="TEntity">The entity type to process</typeparam> + </member> + <member name="M:VNLib.Plugins.IVirtualEndpoint`1.Process(`0)"> + <summary> + The handler method for processing the specified location. + </summary> + <param name="entity">The current connection/session </param> + <returns>A <see cref="T:VNLib.Plugins.VfReturnType"/> specifying how the caller should continue processing the request</returns> + </member> + <member name="P:VNLib.Plugins.WebMessage.Token"> + <summary> + The encrypted access token for the client to use after a login request + </summary> + </member> + <member name="P:VNLib.Plugins.WebMessage.Result"> + <summary> + The result of the REST operation to send to client + </summary> + </member> + <member name="P:VNLib.Plugins.WebMessage.Success"> + <summary> + A status flag/result of the REST operation + </summary> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.dll Binary files differnew file mode 100644 index 0000000..1cbdf29 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.dll diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.xml b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.xml new file mode 100644 index 0000000..dcf7898 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VNLib.Utils.xml @@ -0,0 +1,5325 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>VNLib.Utils</name> + </assembly> + <members> + <member name="T:VNLib.Utils.Async.AccessSerializer`2"> + <summary> + Provides access arbitration to an exclusive resouce + </summary> + <typeparam name="TKey">The uinique identifier type for the resource</typeparam> + <typeparam name="TResource">The resource type</typeparam> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`2.#ctor(System.Func{`0,`1},System.Action)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Async.AccessSerializer`2"/> with the specified factory and completed callback + </summary> + <param name="factory">Factory function to genereate new <typeparamref name="TResource"/> objects from <typeparamref name="TKey"/> keys</param> + <param name="completedCb">Function to be invoked when the encapsulated objected is no longer in use</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`2.TryWait(`0,System.TimeSpan,VNLib.Utils.ExclusiveResourceHandle{`1}@)"> + <summary> + Attempts to obtain an exclusive lock on the object + </summary> + <param name="key"></param> + <param name="wait">Time to wait for lock</param> + <param name="exObj"></param> + <returns>true if lock was obtained within the timeout, false if the lock was not obtained</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`2.Wait(`0)"> + <summary> + Waits for exclusive access to the resource. + </summary> + <param name="key"></param> + <returns>An <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> encapsulating the resource</returns> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`2.WaitAsync(`0,System.Threading.CancellationToken)"> + <summary> + Asynchronously waits for exclusive access to the resource. + </summary> + <returns>An <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> encapsulating the resource</returns> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`2.Release"> + <summary> + Releases an exclusive lock that is held on an object + </summary> + </member> + <member name="T:VNLib.Utils.Async.AccessSerializer`3"> + <summary> + Provides access arbitration to an <see cref="T:VNLib.Utils.IExclusiveResource"/> + </summary> + <typeparam name="TKey">The uinique identifier type for the resource</typeparam> + <typeparam name="TArg">The type of the optional argument to be passed to the user-implemented factory function</typeparam> + <typeparam name="TResource">The resource type</typeparam> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`3.#ctor(System.Func{`0,`1,`2},System.Action)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Async.AccessSerializer`3"/> with the specified factory and completed callback + </summary> + <param name="factory">Factory function to genereate new <typeparamref name="TResource"/> objects from <typeparamref name="TKey"/> keys</param> + <param name="completedCb">Function to be invoked when the encapsulated objected is no longer in use</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`3.TryWait(`0,`1,System.TimeSpan,VNLib.Utils.ExclusiveResourceHandle{`2}@)"> + <summary> + Attempts to obtain an exclusive lock on the object + </summary> + <param name="key"></param> + <param name="arg">The key identifying the resource</param> + <param name="wait">Time to wait for lock</param> + <param name="exObj"></param> + <returns>true if lock was obtained within the timeout, false if the lock was not obtained</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`3.Wait(`0,`1)"> + <summary> + Waits for exclusive access to the resource. + </summary> + <param name="key">The unique key that identifies the resource</param> + <param name="arg">The state argument to pass to the factory function</param> + <returns>An <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> encapsulating the resource</returns> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`3.WaitAsync(`0,`1,System.Threading.CancellationToken)"> + <summary> + Asynchronously waits for exclusive access to the resource. + </summary> + <param name="key"></param> + <param name="arg">The state argument to pass to the factory function</param> + <param name="cancellationToken"></param> + <returns>An <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> encapsulating the resource</returns> + </member> + <member name="M:VNLib.Utils.Async.AccessSerializer`3.Release"> + <summary> + Releases an exclusive lock that is held on an object + </summary> + </member> + <member name="T:VNLib.Utils.Async.AsyncExclusiveResource`1"> + <summary> + Provides a base class for resources that must be obtained exclusivly in a multi-threaded environment + but allow state update operations (and their exceptions) to be deferred to the next accessor. + </summary> + <typeparam name="TState">The state parameter type passed during updates</typeparam> + </member> + <member name="F:VNLib.Utils.Async.AsyncExclusiveResource`1.MainLock"> + <summary> + Main mutli-threading lock used for primary access synchronization + </summary> + </member> + <member name="P:VNLib.Utils.Async.AsyncExclusiveResource`1.IsDisposed"> + <summary> + A value indicating whether the resource is disposed + </summary> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.WaitOne(System.Int32)"> + <summary> + <inheritdoc/> + <br></br> + <br></br> + If the previous call to <see cref="M:VNLib.Utils.Async.AsyncExclusiveResource`1.UpdateAndRelease(System.Boolean,`0)"/> resulted in an asynchronous update, and exceptions occured, an <see cref="T:VNLib.Utils.Async.AsyncUpdateException"/> + will be thrown enclosing the exception + </summary> + <param name="millisecondsTimeout">Time in milliseconds to wait for exclusive access to the resource</param> + <exception cref="T:VNLib.Utils.Async.AsyncUpdateException"></exception> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.UpdateAndRelease(System.Boolean,`0)"> + <summary> + Requests a resource update and releases the exclusive lock on this resource. If a deferred update operation has any + exceptions during its last operation, they will be thrown here. + </summary> + <param name="defer">Specifies weather the update should be deferred or awaited on the current call</param> + <param name="state">A state parameter to be pased to the update function</param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.UpdateResource(`0,System.Boolean)"> + <summary> + When overrriden in a derived class, is responsible for updating the state of the instance if necessary. + <br></br> + <br></br> + If the result of the update retruns a <see cref="T:System.Threading.Tasks.Task"/> that represents an async update, the next call to <see cref="M:VNLib.Utils.Async.AsyncExclusiveResource`1.WaitOne(System.Int32)"/> will + block until the operation completes and will throw any exceptions that occured + <br></br> + <br></br> + This function should return <see cref="P:System.Threading.Tasks.Task.CompletedTask"/> if the operation completed synchronously + </summary> + <param name="state">State parameter passed when releasing</param> + <param name="defer">true if the caller expects a resource update to run asynchronously, false if the caller expects the result of the update to be awaited</param> + <returns>A <see cref="T:System.Threading.Tasks.Task"/> representing the async state update operation, or null if no async state update operation need's to be monitored</returns> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.WaitOneAsync(System.Threading.CancellationToken)"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.DisposeAsync"> + <summary> + Waits for a pending update to complete, if incomplete + and cleans held resources + </summary> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that represents the async operation </returns> + </member> + <member name="M:VNLib.Utils.Async.AsyncExclusiveResource`1.Check"> + <summary> + Determines if the resource is disposed + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Utils.Async.AsyncExclusiveResource"> + <summary> + <inheritdoc/> + </summary> + </member> + <member name="T:VNLib.Utils.Async.AsyncQueue`1"> + <summary> + Provides a <see cref="T:System.Threading.Channels.Channel`1"/> based asynchronous queue + </summary> + <typeparam name="T">The event object type</typeparam> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.#ctor(System.Int32)"> + <summary> + Initalizes a new multi-threaded bound channel queue, that accepts + the <paramref name="capacity"/> number of items before it will + return asynchronously, or fail to enqueue items + </summary> + <param name="capacity">The maxium number of items to allow in the queue</param> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.#ctor"> + <summary> + Initalizes a new multi-threaded unbound channel queue + </summary> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.#ctor(System.Boolean,System.Boolean,System.Int32)"> + <summary> + Initalizes a new queue that allows specifying concurrency requirements + and a bound/unbound channel capacity + </summary> + <param name="singleWriter">A value that specifies only a single thread be enqueing items?</param> + <param name="singleReader">A value that specifies only a single thread will be dequeing</param> + <param name="capacity">The maxium number of items to enque without failing</param> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.#ctor(System.Threading.Channels.UnboundedChannelOptions)"> + <summary> + Initalizes a new unbound channel based queue + </summary> + <param name="ubOptions">Channel options</param> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.#ctor(System.Threading.Channels.BoundedChannelOptions)"> + <summary> + Initalizes a new bound channel based queue + </summary> + <param name="options">Channel options</param> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.TryEnque(`0)"> + <summary> + Attemts to enqeue an item if the queue has the capacity + </summary> + <param name="item">The item to eqneue</param> + <returns>True if the queue can accept another item, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.EnqueueAsync(`0,System.Threading.CancellationToken)"> + <summary> + Enqueues an item to the end of the queue and notifies a waiter that an item was enqueued + </summary> + <param name="item">The item to enqueue</param> + <param name="cancellationToken"></param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.DequeueAsync(System.Threading.CancellationToken)"> + <summary> + Asynchronously waits for an item to be Enqueued to the end of the queue. + </summary> + <returns>The item at the begining of the queue</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.TryDequeue(`0@)"> + <summary> + Removes the object at the beginning of the queue and stores it to the result parameter. Without waiting for a change + event. + </summary> + <param name="result">The item that was at the begining of the queue</param> + <returns>True if the queue could be read synchronously, false if the lock could not be entered, or the queue contains no items</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncQueue`1.TryPeek(`0@)"> + <summary> + Peeks the object at the beginning of the queue and stores it to the result parameter. Without waiting for a change + event. + </summary> + <param name="result">The item that was at the begining of the queue</param> + <returns>True if the queue could be read synchronously, false if the lock could not be entered, or the queue contains no items</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Utils.Async.AsyncUpdateCallback"> + <summary> + A callback delegate used for updating a <see cref="T:VNLib.Utils.Async.AsyncUpdatableResource"/> + </summary> + <param name="source">The <see cref="T:VNLib.Utils.Async.AsyncUpdatableResource"/> to be updated</param> + <param name="data">The serialized data to be stored/updated</param> + <exception cref="T:VNLib.Utils.ResourceUpdateFailedException"></exception> + </member> + <member name="T:VNLib.Utils.Async.AsyncDeleteCallback"> + <summary> + A callback delegate invoked when a <see cref="T:VNLib.Utils.Async.AsyncUpdatableResource"/> delete is requested + </summary> + <param name="source">The <see cref="T:VNLib.Utils.Async.AsyncUpdatableResource"/> to be deleted</param> + <exception cref="T:VNLib.Utils.ResourceDeleteFailedException"></exception> + </member> + <member name="T:VNLib.Utils.Async.AsyncUpdatableResource"> + <summary> + Implemented by a resource that is backed by an external data store, that when modified or deleted will + be reflected to the backing store. + </summary> + </member> + <member name="M:VNLib.Utils.Async.AsyncUpdatableResource.InitializeAsync(VNLib.Utils.Async.AsyncUpdateCallback,VNLib.Utils.Async.AsyncDeleteCallback,System.Text.Json.JsonSerializerOptions)"> + <summary> + Inializes the callback functions and serializer options to use when serialzing the state data + </summary> + <param name="updateCallback">The function to invoke when the resource has been modified and need to be updated</param> + <param name="deletedCallback">The function to invoke when the resource should be deleted</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use when serializing resource</param> + </member> + <member name="M:VNLib.Utils.Async.AsyncUpdatableResource.ReleaseAsync"> + <summary> + Releases the resource and flushes pending changes to its backing store. + </summary> + <returns>A task that represents the async operation</returns> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Utils.ResourceDeleteFailedException"></exception> + <exception cref="T:VNLib.Utils.ResourceUpdateFailedException"></exception> + </member> + <member name="M:VNLib.Utils.Async.AsyncUpdatableResource.FlushPendingChangesAsync"> + <summary> + <para> + Writes the current state of the the resource to the backing store + immediatly by invoking the specified callback. + </para> + <para> + Only call this method if your store supports multiple state updates + </para> + </summary> + </member> + <member name="M:VNLib.Utils.Async.AsyncUpdatableResource.DisposeAsync"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Async.AsyncUpdateException"> + <summary> + Represents an exception that was raised during an asyncronous update of a resource. The <see cref="P:System.Exception.InnerException"/> stores the + details of the actual exception raised + </summary> + </member> + <member name="M:VNLib.Utils.Async.AsyncUpdateException.#ctor(System.Exception)"> + <summary> + + </summary> + <param name="inner"></param> + </member> + <member name="T:VNLib.Utils.Async.IAsyncExclusiveResource"> + <summary> + <inheritdoc/> + </summary> + </member> + <member name="M:VNLib.Utils.Async.IAsyncExclusiveResource.ReleaseAsync"> + <summary> + Releases the resource from use. Called when a <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> is disposed + </summary> + </member> + <member name="T:VNLib.Utils.Async.IAsyncWaitHandle"> + <summary> + Provides a synchronization handle that can be asynchronously aquired + </summary> + </member> + <member name="M:VNLib.Utils.Async.IAsyncWaitHandle.WaitOneAsync(System.Threading.CancellationToken)"> + <summary> + Waits for exclusive access to the resource until the <see cref="T:System.Threading.CancellationToken"/> expires + </summary> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Async.IWaitHandle"> + <summary> + Provides basic thread synchronization functions similar to <see cref="T:System.Threading.WaitHandle"/> + </summary> + </member> + <member name="M:VNLib.Utils.Async.IWaitHandle.WaitOne"> + <summary> + Waits for exclusive access to the resource indefinitly. If the signal is never received this method never returns + </summary> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + <returns>true if the current thread received the signal</returns> + </member> + <member name="M:VNLib.Utils.Async.IWaitHandle.WaitOne(System.Int32)"> + <summary> + Waits for exclusive access to the resource until the specified number of milliseconds + </summary> + <param name="millisecondsTimeout">Time in milliseconds to wait for exclusive access to the resource</param> + <returns>true if the current thread received the signal, false if the timout expired, and access was not granted</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Async.IWaitHandle.WaitOne(System.TimeSpan)"> + <summary> + Waits for exclusive access to the resource until the specified <see cref="T:System.TimeSpan"/> + </summary> + <returns>true if the current thread received the signal, false if the timout expired, and access was not granted</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="T:VNLib.Utils.BitField"> + <summary> + Represents a field of 64 bits that can be set or cleared using unsigned or signed masks + </summary> + </member> + <member name="P:VNLib.Utils.BitField.Value"> + <summary> + The readonly value of the <see cref="T:VNLib.Utils.BitField"/> + </summary> + </member> + <member name="M:VNLib.Utils.BitField.#ctor(System.UInt64)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.BitField"/> initialized to the specified value + </summary> + <param name="initial">Initial value</param> + </member> + <member name="M:VNLib.Utils.BitField.#ctor(System.Int64)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.BitField"/> initialized to the specified value + </summary> + <param name="initial">Initial value</param> + </member> + <member name="M:VNLib.Utils.BitField.IsSet(System.UInt64)"> + <summary> + Determines if the specified flag is set + </summary> + <param name="mask">The mask to compare against the field value</param> + <returns>True if the flag(s) is currently set, false if flag is not set</returns> + </member> + <member name="M:VNLib.Utils.BitField.IsSet(System.Int64)"> + <summary> + Determines if the specified flag is set + </summary> + <param name="mask">The mask to compare against the field value</param> + <returns>True if the flag(s) is currently set, false if flag is not set</returns> + </member> + <member name="M:VNLib.Utils.BitField.Set(System.UInt64)"> + <summary> + Determines if the specified flag is set + </summary> + <param name="mask">The mask to compare against the field value</param> + <returns>True if the flag(s) is currently set, false if flag is not set</returns> + </member> + <member name="M:VNLib.Utils.BitField.Set(System.Int64)"> + <summary> + Determines if the specified flag is set + </summary> + <param name="mask">The mask to compare against the field value</param> + <returns>True if the flag(s) is currently set, false if flag is not set</returns> + </member> + <member name="M:VNLib.Utils.BitField.Set(System.UInt64,System.Boolean)"> + <summary> + Sets or clears a flag(s) indentified by a mask based on the value + </summary> + <param name="mask">Mask used to identify flags</param> + <param name="value">True to set a flag, false to clear a flag</param> + </member> + <member name="M:VNLib.Utils.BitField.Clear(System.UInt64)"> + <summary> + Clears the flag identified by the specified mask + </summary> + <param name="mask">The mask used to clear the given flag</param> + </member> + <member name="M:VNLib.Utils.BitField.Clear(System.Int64)"> + <summary> + Clears the flag identified by the specified mask + </summary> + <param name="mask">The mask used to clear the given flag</param> + </member> + <member name="M:VNLib.Utils.BitField.ClearAll"> + <summary> + Clears all flags by setting the <see cref="F:VNLib.Utils.BitField.Field"/> property value to 0 + </summary> + </member> + <member name="T:VNLib.Utils.CallbackOpenHandle"> + <summary> + A concrete <see cref="T:VNLib.Utils.OpenHandle"/> for a defered operation or a resource that should be released or unwound + when the instance lifetime has ended. + </summary> + </member> + <member name="M:VNLib.Utils.CallbackOpenHandle.#ctor(System.Action)"> + <summary> + Creates a new generic <see cref="T:VNLib.Utils.OpenHandle"/> with the specified release callback method + </summary> + <param name="release">The callback function to invoke when the <see cref="T:VNLib.Utils.OpenHandle"/> is disposed</param> + </member> + <member name="M:VNLib.Utils.CallbackOpenHandle.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.CallbackOpenResourceHandle`1"> + <summary> + A concrete class that defines an <see cref="T:VNLib.Utils.OpenResourceHandle`1"/> where the release actions + require unknown or unstructured events or operations that can happen in a callback delegate + </summary> + </member> + <member name="M:VNLib.Utils.CallbackOpenResourceHandle`1.#ctor(System.Action,`0)"> + <summary> + Creates a new generic with the specified release callback method + </summary> + <param name="release">The callback function to invoke when the <see cref="T:VNLib.Utils.CallbackOpenResourceHandle`1"/> is disposed</param> + <param name="resource"></param> + </member> + <member name="M:VNLib.Utils.CallbackOpenResourceHandle`1.#ctor(System.Action{`0},`0)"> + <summary> + Creates a new generic <see cref="T:VNLib.Utils.CallbackOpenResourceHandle`1"/> with the specified release callback method + </summary> + <param name="release">The callback function to invoke when the <see cref="T:VNLib.Utils.CallbackOpenResourceHandle`1"/> is disposed</param> + <param name="resource"></param> + </member> + <member name="P:VNLib.Utils.CallbackOpenResourceHandle`1.Resource"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.CallbackOpenResourceHandle`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.ERRNO"> + <summary> + Implements a C style integer error code type. Size is platform dependent + </summary> + </member> + <member name="F:VNLib.Utils.ERRNO.SUCCESS"> + <summary> + Represents a successfull error code (true) + </summary> + </member> + <member name="F:VNLib.Utils.ERRNO.E_FAIL"> + <summary> + Represents a failure error code (false) + </summary> + </member> + <member name="M:VNLib.Utils.ERRNO.#ctor(System.IntPtr)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ERRNO"/> from the specified error value + </summary> + <param name="errno">The value of the error to represent</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(System.Int32)~VNLib.Utils.ERRNO"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ERRNO"/> from an <see cref="T:System.Int32"/> error code. null = 0 = false + </summary> + <param name="errorVal">Error code</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Explicit(System.Nullable{System.Int32})~VNLib.Utils.ERRNO"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ERRNO"/> from an <see cref="T:System.Int32"/> error code. null = 0 = false + </summary> + <param name="errorVal">Error code</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(System.Boolean)~VNLib.Utils.ERRNO"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ERRNO"/> from a booleam, 1 if true, 0 if false + </summary> + <param name="errorVal"></param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(System.IntPtr)~VNLib.Utils.ERRNO"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ERRNO"/> from a pointer value + </summary> + <param name="errno">The pointer value representing an error code</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(VNLib.Utils.ERRNO)~System.Int32"> + <summary> + Error value as integer. Value of supplied error code or if cast from boolean 1 if true, 0 if false + </summary> + <param name="errorVal"><see cref="T:VNLib.Utils.ERRNO"/> to get error code from</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(VNLib.Utils.ERRNO)~System.Boolean"> + <summary> + C style boolean conversion. false if 0, true otherwise + </summary> + <param name="errorVal"></param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(VNLib.Utils.ERRNO)~System.IntPtr"> + <summary> + Creates a new <see cref="T:System.IntPtr"/> from the value if the stored (nint) error code + </summary> + <param name="errno">The <see cref="T:VNLib.Utils.ERRNO"/> contating the pointer value</param> + </member> + <member name="M:VNLib.Utils.ERRNO.op_Implicit(VNLib.Utils.ERRNO)~System.IntPtr"> + <summary> + Creates a new <c>nint</c> from the value if the stored error code + </summary> + <param name="errno">The <see cref="T:VNLib.Utils.ERRNO"/> contating the pointer value</param> + </member> + <member name="M:VNLib.Utils.ERRNO.ToString"> + <summary> + The integer error value of the current instance in radix 10 + </summary> + <returns></returns> + </member> + <member name="M:VNLib.Utils.ERRNO.TryFormat(System.Span{System.Char},System.Int32@,System.ReadOnlySpan{System.Char},System.IFormatProvider)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.ERRNO.ToString(System.String,System.IFormatProvider)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.ExclusiveResourceHandle`1"> + <summary> + While in scope, holds an exclusive lock on the specified object that implements the <see cref="T:VNLib.Utils.IExclusiveResource"/> interface + </summary> + <typeparam name="T"></typeparam> + </member> + <member name="P:VNLib.Utils.ExclusiveResourceHandle`1.Resource"> + <summary> + <inheritdoc/> + <br></br> + <br></br> + This value is lazy inialized and will invoke the factory function on first access. + Accessing this variable is thread safe while the handle is in scope + <br></br> + <br></br> + Exceptions will be propagated during initialziation + </summary> + </member> + <member name="M:VNLib.Utils.ExclusiveResourceHandle`1.#ctor(System.Func{`0},System.Action)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> wrapping the + <see cref="T:VNLib.Utils.IExclusiveResource"/> object to manage its lifecycle and reuse + </summary> + <param name="factory">Factory function that will generate the value when used</param> + <param name="release">Callback function that will be invoked after object gets disposed</param> + </member> + <member name="T:VNLib.Utils.Extensions.CacheExtensions"> + <summary> + Cache collection extensions + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.StoreRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1)"> + <summary> + <para> + Stores a new record. If an old record exists, the records are compared, + if they are not equal, the old record is evicted and the new record is stored + </para> + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T">A cachable object</typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="record">The record to store</param> + <remarks> + Locks on the store parameter to provide mutual exclusion for non thread-safe + data structures. + </remarks> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.StoreRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1,System.TimeSpan)"> + <summary> + <para> + Stores a new record and updates the expiration date. If an old record exists, the records + are compared, if they are not equal, the old record is evicted and the new record is stored + </para> + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T">A cachable object</typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="record">The record to store</param> + <param name="validFor">The new expiration time of the record</param> + <remarks> + Locks on the store parameter to provide mutual exclusion for non thread-safe + data structures. + </remarks> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.TryGetOrEvictRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1@)"> + <summary> + <para> + Returns a stored record if it exists and is not expired. If the record exists + but has expired, it is evicted. + </para> + <para> + If a record is evicted, the return value evaluates to -1 and the value parameter + is set to the old record if the caller wished to inspect the record after the + eviction method completes + </para> + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T">A cachable object</typeparam> + <param name="store"></param> + <param name="key"></param> + <param name="value">The record</param> + <returns> + Gets a value indicating the reults of the operation. 0 if the record is not found, -1 if expired, 1 if + record is valid + </returns> + <remarks> + Locks on the store parameter to provide mutual exclusion for non thread-safe + data structures. + </remarks> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.UpdateRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0,System.TimeSpan)"> + <summary> + Updates the expiration date on a record to the specified time if it exists, regardless + of its validity + </summary> + <typeparam name="K">Diction key type</typeparam> + <typeparam name="T">A cachable object</typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record to update</param> + <param name="extendedTime">The expiration time (time added to <see cref="P:System.DateTime.UtcNow"/>)</param> + <remarks> + Locks on the store parameter to provide mutual exclusion for non thread-safe + data structures. + </remarks> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.EvictRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0)"> + <summary> + Evicts a stored record from the store. If the record is found, the eviction + method is executed + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <returns>True if the record was found and evicted</returns> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.CollectRecords``2(System.Collections.Generic.IDictionary{``0,``1})"> + <summary> + Evicts all expired records from the store + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.CollectRecords``2(System.Collections.Generic.IDictionary{``0,``1},System.DateTime)"> + <summary> + Evicts all expired records from the store + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <param name="store"></param> + <param name="validAfter">A time that specifies the time which expired records should be evicted</param> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.UseRecord``3(System.Collections.Generic.IDictionary{``0,``1},``0,``2,System.Action{``1,``2})"> + <summary> + Allows for mutually exclusive use of a <see cref="T:VNLib.Utils.Memory.Caching.ICacheable"/> record with a + state parameter + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <typeparam name="State"></typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="state">A user-token type state parameter to pass to the use callback method</param> + <param name="useCtx">A callback method that will be passed the record to use within an exclusive context</param> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.UseRecord``2(System.Collections.Generic.IDictionary{``0,``1},``0,System.Action{``1})"> + <summary> + Allows for mutually exclusive use of a <see cref="T:VNLib.Utils.Memory.Caching.ICacheable"/> + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="useCtx">A callback method that will be passed the record to use within an exclusive context</param> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.UseIfValid``3(System.Collections.Generic.IDictionary{``0,``1},``0,``2,System.Action{``1,``2})"> + <summary> + Allows for mutually exclusive use of a <see cref="T:VNLib.Utils.Memory.Caching.ICacheable"/> record with a + state parameter, only if the found record is valid + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <typeparam name="State"></typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="state">A user-token type state parameter to pass to the use callback method</param> + <param name="useCtx">A callback method that will be passed the record to use within an exclusive context</param> + <remarks>If the record is found, but is expired, the record is evicted from the store. The callback is never invoked</remarks> + </member> + <member name="M:VNLib.Utils.Extensions.CacheExtensions.UseIfValid``2(System.Collections.Generic.IDictionary{``0,``1},``0,System.Action{``1})"> + <summary> + Allows for mutually exclusive use of a <see cref="T:VNLib.Utils.Memory.Caching.ICacheable"/> record with a + state parameter, only if the found record is valid + </summary> + <typeparam name="K"></typeparam> + <typeparam name="T"></typeparam> + <param name="store"></param> + <param name="key">The unique key identifying the record</param> + <param name="useCtx">A callback method that will be passed the record to use within an exclusive context</param> + <remarks>If the record is found, but is expired, the record is evicted from the store. The callback is never invoked</remarks> + </member> + <member name="T:VNLib.Utils.Extensions.CollectionExtensions"> + <summary> + Provides collection extension methods + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.CollectionExtensions.Sort``1(VNLib.Utils.Memory.VnList{``0},System.Collections.Generic.IComparer{``0})"> + <summary> + Sorts the elements within the list by the specified <see cref="T:System.Collections.Generic.IComparer`1"/> + instance + </summary> + <typeparam name="T"></typeparam> + <param name="list"></param> + <param name="comparer">The comparer used to sort the items within the list</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.CollectionExtensions.GetValueType``2(VNLib.Utils.IIndexable{``0,System.String},``0)"> + <summary> + Gets a previously-stored base32 encoded value-type from the lookup and returns its initialized structure from + the value stored + </summary> + <typeparam name="TKey">The key type used to index the lookup</typeparam> + <typeparam name="TValue">An unmanaged structure type</typeparam> + <param name="lookup"></param> + <param name="key">The key used to identify the value</param> + <returns>The initialized structure, or default if the lookup returns null/empty string</returns> + </member> + <member name="M:VNLib.Utils.Extensions.CollectionExtensions.SetValueType``2(VNLib.Utils.IIndexable{``0,System.String},``0,``1)"> + <summary> + Serializes a value-type in base32 encoding and stores it at the specified key + </summary> + <typeparam name="TKey">The key type used to index the lookup</typeparam> + <typeparam name="TValue">An unmanaged structure type</typeparam> + <param name="lookup"></param> + <param name="key">The key used to identify the value</param> + <param name="value">The value to serialze</param> + </member> + <member name="M:VNLib.Utils.Extensions.CollectionExtensions.TryForeach``1(System.Collections.Generic.IList{``0},System.Action{``0})"> + <summary> + Executes a handler delegate on every element of the list within a try-catch block + and rethrows exceptions as an <see cref="T:System.AggregateException"/> + </summary> + <typeparam name="T"></typeparam> + <param name="list"></param> + <param name="handler">An <see cref="T:System.Action"/> handler delegate to complete some operation on the elements within the list</param> + <exception cref="T:System.AggregateException"></exception> + </member> + <member name="T:VNLib.Utils.Extensions.IoExtensions"> + <summary> + Provieds extension methods for common IO operations + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.Unlock(System.IO.FileStream)"> + <summary> + Unlocks the entire file + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.Lock(System.IO.FileStream)"> + <summary> + Locks the entire file + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyToAsync(System.IO.Stream,System.IO.Stream,System.Int32,VNLib.Utils.Memory.IUnmangedHeap,System.Threading.CancellationToken)"> + <summary> + Provides an async wrapper for copying data from the current stream to another using an unmanged + buffer. + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="bufferSize">The size of the buffer to use while copying data. (Value will be clamped to the size of the stream if seeking is available)</param> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate the buffer from</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyToAsync(System.IO.Stream,System.IO.Stream,System.Int64,System.Int32,VNLib.Utils.Memory.IUnmangedHeap,System.Threading.CancellationToken)"> + <summary> + Provides an async wrapper for copying data from the current stream to another with a + buffer from the <paramref name="heap"/> + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="bufferSize">The size of the buffer to use while copying data. (Value will be clamped to the size of the stream if seeking is available)</param> + <param name="count">The number of bytes to copy from the current stream to destination stream</param> + <param name="heap">The heap to alloc buffer from</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyTo(System.IO.Stream,System.IO.Stream,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Copies data from one stream to another, using self managed buffers. May allocate up to 2MB. + </summary> + <param name="source">Source stream to read from</param> + <param name="dest">Destination stream to write data to</param> + <param name="heap">The heap to allocate buffers from</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyTo(System.IO.Stream,System.IO.Stream,System.Int64,VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Copies data from one stream to another, using self managed buffers. May allocate up to 2MB. + </summary> + <param name="source">Source stream to read from</param> + <param name="dest">Destination stream to write data to</param> + <param name="count">Number of bytes to read/write</param> + <param name="heap">The heap to allocate buffers from</param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyToAsync(System.IO.Stream,System.IO.Stream,System.Memory{System.Byte},System.Threading.CancellationToken)"> + <summary> + Copies data from the current stream to the destination stream using the supplied memory buffer + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="buffer">The buffer to use when copying data</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.CopyToAsync(System.IO.Stream,System.IO.Stream,System.Memory{System.Byte},System.Int64,System.Threading.CancellationToken)"> + <summary> + Copies data from the current stream to the destination stream using the supplied memory buffer + </summary> + <param name="source"></param> + <param name="dest">The destination data stream to write data to</param> + <param name="buffer">The buffer to use when copying data</param> + <param name="count">The number of bytes to copy from the current stream to destination stream</param> + <param name="token">A token that may cancel asynchronous operations</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that completes when the copy operation has completed</returns> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.OpenFile(System.IO.DirectoryInfo,System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,System.Int32,System.IO.FileOptions)"> + <summary> + Opens a file within the current directory + </summary> + <param name="dir"></param> + <param name="fileName">The name of the file to open</param> + <param name="mode">The <see cref="T:System.IO.FileMode"/> to open the file with</param> + <param name="access">The <see cref="T:System.IO.FileAccess"/> to open the file with</param> + <param name="share"></param> + <param name="bufferSize">The size of the buffer to read/write with</param> + <param name="options"></param> + <returns>The <see cref="T:System.IO.FileStream"/> of the opened file</returns> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.DeleteFile(System.IO.DirectoryInfo,System.String)"> + <summary> + Deletes the speicifed file from the current directory + </summary> + <param name="dir"></param> + <param name="fileName">The name of the file to delete</param> + </member> + <member name="M:VNLib.Utils.Extensions.IoExtensions.FileExists(System.IO.DirectoryInfo,System.String)"> + <summary> + Determines if a file exists within the current directory + </summary> + <param name="dir"></param> + <param name="fileName">The name of the file to search for</param> + <returns>True if the file is found and the user has permission to access the file, false otherwise</returns> + </member> + <member name="T:VNLib.Utils.Extensions.TimeParseType"> + <summary> + Specifies how to parse a timespan value from a <see cref="T:System.Text.Json.JsonDocument"/> element + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.AsJsonObject``1(System.String,System.Text.Json.JsonSerializerOptions)"> + <summary> + Converts a JSON encoded string to an object of the specified type + </summary> + <typeparam name="T">Output type of the object</typeparam> + <param name="value"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during de-serialization</param> + <returns>The new object or default if the string is null or empty</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.AsJsonObject``1(System.ReadOnlySpan{System.Byte}@,System.Text.Json.JsonSerializerOptions)"> + <summary> + Converts a JSON encoded binary data to an object of the specified type + </summary> + <typeparam name="T">Output type of the object</typeparam> + <param name="utf8bin"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during de-serialization</param> + <returns>The new object or default if the string is null or empty</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.AsJsonObject``1(System.ReadOnlyMemory{System.Byte}@,System.Text.Json.JsonSerializerOptions)"> + <summary> + Converts a JSON encoded binary data to an object of the specified type + </summary> + <typeparam name="T">Output type of the object</typeparam> + <param name="utf8bin"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during de-serialization</param> + <returns>The new object or default if the string is null or empty</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.AsJsonObject``1(System.Byte[],System.Text.Json.JsonSerializerOptions)"> + <summary> + Converts a JSON encoded binary data to an object of the specified type + </summary> + <typeparam name="T">Output type of the object</typeparam> + <param name="utf8bin"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during de-serialization</param> + <returns>The new object or default if the string is null or empty</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.AsJsonDocument(System.String,System.Text.Json.JsonDocumentOptions)"> + <summary> + Parses a json encoded string to a json documen + </summary> + <param name="jsonString"></param> + <param name="options"></param> + <returns>If the json string is null, returns null, otherwise the json document around the data</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.GetPropString(System.Text.Json.JsonElement@,System.String)"> + <summary> + Shortcut extension to <see cref="M:System.Text.Json.JsonElement.GetProperty(System.String)"/> and returns a string + </summary> + <param name="element"></param> + <param name="propertyName">The name of the property to get the string value of</param> + <returns>If the property exists, returns the string stored at that property</returns> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.GetPropString(System.Collections.Generic.IReadOnlyDictionary{System.String,System.Text.Json.JsonElement},System.String)"> + <summary> + Shortcut extension to <see cref="M:System.Text.Json.JsonElement.GetProperty(System.String)"/> and returns a string + </summary> + <param name="conf"></param> + <param name="propertyName">The name of the property to get the string value of</param> + <returns>If the property exists, returns the string stored at that property</returns> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.GetPropString(System.Collections.Generic.IDictionary{System.String,System.Text.Json.JsonElement},System.String)"> + <summary> + Shortcut extension to <see cref="M:System.Text.Json.JsonElement.GetProperty(System.String)"/> and returns a string + </summary> + <param name="conf"></param> + <param name="propertyName">The name of the property to get the string value of</param> + <returns>If the property exists, returns the string stored at that property</returns> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.ToJsonString``1(``0,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attemts to serialze an object to a JSON encoded string + </summary> + <param name="obj"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use during serialization</param> + <returns>A JSON encoded string of the serialized object, or null if the object is null</returns> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.Merge(System.Text.Json.JsonDocument,System.Text.Json.JsonDocument,System.String,System.String)"> + <summary> + Merges the current <see cref="T:System.Text.Json.JsonDocument"/> with another <see cref="T:System.Text.Json.JsonDocument"/> to + create a new document of combined properties + </summary> + <param name="initial"></param> + <param name="other">The <see cref="T:System.Text.Json.JsonDocument"/> to combine with the first document</param> + <param name="initalName">The name of the new element containing the initial document data</param> + <param name="secondName">The name of the new element containing the additional document data</param> + <returns>A new document with a parent root containing the combined objects</returns> + </member> + <member name="M:VNLib.Utils.Extensions.JsonExtensions.GetTimeSpan(System.Text.Json.JsonElement@,VNLib.Utils.Extensions.TimeParseType)"> + <summary> + Parses a number value into a <see cref="T:System.TimeSpan"/> of the specified time + </summary> + <param name="el"></param> + <param name="type">The <see cref="T:VNLib.Utils.Extensions.TimeParseType"/> the value represents</param> + <returns>The <see cref="T:System.TimeSpan"/> of the value</returns> + <exception cref="T:System.FormatException"></exception> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="T:VNLib.Utils.Extensions.MemoryExtensions"> + <summary> + Provides memory based extensions to .NET and VNLib memory abstractions + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Lease``1(System.Buffers.ArrayPool{``0},System.Int32,System.Boolean)"> + <summary> + Rents a new array and stores it as a resource within an <see cref="T:VNLib.Utils.OpenResourceHandle`1"/> to return the + array when work is completed + </summary> + <typeparam name="T"></typeparam> + <param name="pool"></param> + <param name="size">The minimum size array to allocate</param> + <param name="zero">Should elements from 0 to size be set to default(T)</param> + <returns>A new <see cref="T:VNLib.Utils.OpenResourceHandle`1"/> encapsulating the rented array</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Rent``1(System.Buffers.ArrayPool{``0},System.Int32,System.Boolean)"> + <summary> + Retreives a buffer that is at least the reqested length, and clears the array from 0-size. + <br></br> + The array may be larger than the requested size, the data outside of the size paramter is not cleared + </summary> + <param name="pool"></param> + <param name="size">The minimum length of the array</param> + <param name="zero">True if contents should be zeroed</param> + <returns>The zeroed array</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ToString``1(``0)"> + <summary> + Copies the characters within the memory handle to a <see cref="T:System.String"/> + </summary> + <returns>The string representation of the buffer</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ToMemory``1(VNLib.Utils.Memory.MemoryHandle{``0})"> + <summary> + Wraps the <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> instance in System.Buffers.MemoryManager + wrapper to provide <see cref="T:System.Memory`1"/> buffers from umanaged handles. + </summary> + <typeparam name="T">The unmanaged data type</typeparam> + <returns>The <see cref="T:System.Buffers.MemoryManager`1"/> wrapper</returns> + <remarks>NOTE: This wrapper now manages the lifetime of the current handle</remarks> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.DirectAlloc``1(VNLib.Utils.Memory.IUnmangedHeap,System.UInt64,System.Boolean)"> + <summary> + Allows direct allocation of a fixed size <see cref="T:System.Buffers.MemoryManager`1"/> from a <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> instance + of the specified number of elements + </summary> + <typeparam name="T">The unmanaged data type</typeparam> + <param name="heap"></param> + <param name="size">The number of elements to allocate on the heap</param> + <param name="zero">Optionally zeros conents of the block when allocated</param> + <returns>The <see cref="T:System.Buffers.MemoryManager`1"/> wrapper around the block of memory</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.DirectAlloc``1(VNLib.Utils.Memory.IUnmangedHeap,System.Int64,System.Boolean)"> + <summary> + Allows direct allocation of a fixed size <see cref="T:System.Buffers.MemoryManager`1"/> from a <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> instance + of the specified number of elements + </summary> + <typeparam name="T">The unmanaged data type</typeparam> + <param name="heap"></param> + <param name="size">The number of elements to allocate on the heap</param> + <param name="zero">Optionally zeros conents of the block when allocated</param> + <returns>The <see cref="T:System.Buffers.MemoryManager`1"/> wrapper around the block of memory</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetOffset``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64)"> + <summary> + Gets an offset pointer from the base postion to the number of bytes specified. Performs bounds checks + </summary> + <param name="memory"></param> + <param name="elements">Number of elements of type to offset</param> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + <returns><typeparamref name="T"/> pointer to the memory offset specified</returns> + [MethodImpl(MethodImplOptions.AggressiveInlining)] + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Resize``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64)"> + <summary> + Resizes the current handle on the heap + </summary> + <param name="memory"></param> + <param name="elements">Positive number of elemnts the current handle should referrence</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ResizeIfSmaller``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64)"> + <summary> + Resizes the target handle only if the handle is smaller than the requested element count + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="count">The number of elements to resize to</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ResizeIfSmaller``1(VNLib.Utils.Memory.MemoryHandle{``0},System.UInt64)"> + <summary> + Resizes the target handle only if the handle is smaller than the requested element count + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="count">The number of elements to resize to</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetOffsetSpan``1(VNLib.Utils.Memory.MemoryHandle{``0},System.UInt64,System.Int32)"> + <summary> + Gets a 64bit friendly span offset for the current <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + </summary> + <typeparam name="T"></typeparam> + <param name="block"></param> + <param name="offset">The offset (in elements) from the begining of the block</param> + <param name="size">The size of the block (in elements)</param> + <returns>The offset span</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetOffsetSpan``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64,System.Int32)"> + <summary> + Gets a 64bit friendly span offset for the current <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + </summary> + <typeparam name="T"></typeparam> + <param name="block"></param> + <param name="offset">The offset (in elements) from the begining of the block</param> + <param name="size">The size of the block (in elements)</param> + <returns>The offset span</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetSubSequence``1(VNLib.Utils.Memory.MemoryHandle{``0},System.UInt64,System.Int32)"> + <summary> + Gets a <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> window within the current block + </summary> + <typeparam name="T"></typeparam> + <param name="block"></param> + <param name="offset">An offset within the handle</param> + <param name="size">The size of the window</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> within the block</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ToPool``1(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Wraps the current instance with a <see cref="T:System.Buffers.MemoryPool`1"/> wrapper + to allow System.Memory buffer rentals. + </summary> + <typeparam name="T">The unmanged data type to provide allocations from</typeparam> + <returns>The new <see cref="T:System.Buffers.MemoryPool`1"/> heap wrapper.</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.StructAlloc``1(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Allocates a structure of the specified type on the current unmanged heap and zero's its memory + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="heap"></param> + <returns>A pointer to the structure ready for use.</returns> + <remarks>Allocations must be freed with <see cref="M:VNLib.Utils.Extensions.MemoryExtensions.StructFree``1(VNLib.Utils.Memory.IUnmangedHeap,``0*)"/></remarks> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.StructFree``1(VNLib.Utils.Memory.IUnmangedHeap,``0*)"> + <summary> + Frees a structure at the specified address from the this heap. + This must be the same heap the structure was allocated from + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="heap"></param> + <param name="structPtr">A pointer to the structure</param> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Alloc``1(VNLib.Utils.Memory.IUnmangedHeap,System.UInt64,System.Boolean)"> + <summary> + Allocates a block of unmanaged memory of the number of elements to store of an unmanged type + </summary> + <typeparam name="T">Unmanaged data type to create a block of</typeparam> + <param name="heap"></param> + <param name="elements">The size of the block (number of elements)</param> + <param name="zero">A flag that zeros the allocated block before returned</param> + <returns>The unmanaged <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Alloc``1(VNLib.Utils.Memory.IUnmangedHeap,System.Int64,System.Boolean)"> + <summary> + Allocates a block of unmanaged memory of the number of elements to store of an unmanged type + </summary> + <typeparam name="T">Unmanaged data type to create a block of</typeparam> + <param name="heap"></param> + <param name="elements">The size of the block (number of elements)</param> + <param name="zero">A flag that zeros the allocated block before returned</param> + <returns>The unmanaged <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AllocAndCopy``1(VNLib.Utils.Memory.IUnmangedHeap,System.ReadOnlySpan{``0})"> + <summary> + Allocates a buffer from the current heap and initialzies it by copying the initial data buffer + </summary> + <typeparam name="T"></typeparam> + <param name="heap"></param> + <param name="initialData">The initial data to set the buffer to</param> + <returns>The initalized <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> block</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.WriteAndResize``1(VNLib.Utils.Memory.MemoryHandle{``0},System.ReadOnlySpan{``0})"> + <summary> + Copies data from the input buffer to the current handle and resizes the handle to the + size of the buffer + </summary> + <typeparam name="T">The unamanged value type</typeparam> + <param name="handle"></param> + <param name="input">The input buffer to copy data from</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.UnsafeAlloc``1(VNLib.Utils.Memory.IUnmangedHeap,System.Int32,System.Boolean)"> + <summary> + Allocates a block of unamanged memory of the number of elements of an unmanaged type, and + returns the <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> that must be used cautiously + </summary> + <typeparam name="T">The unamanged value type</typeparam> + <param name="heap">The heap to allocate block from</param> + <param name="elements">The number of elements to allocate</param> + <param name="zero">A flag to zero the initial contents of the buffer</param> + <returns>The allocated handle of the specified number of elements</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Boolean)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Int16)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.UInt16)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Int32)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.UInt32)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Int64)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append(VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.UInt64)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Append``1(VNLib.Utils.Memory.VnBufferWriter{System.Char}@,``0,System.ReadOnlySpan{System.Char},System.IFormatProvider)"> + <summary> + Formats and appends the value to end of the buffer + </summary> + <param name="buffer"></param> + <param name="value">The value to format and append to the buffer</param> + <param name="format">An optional format argument</param> + <param name="formatProvider"></param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetBytes(System.Text.Encoder,System.Char[],System.Int32,System.Int32,VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Boolean)"> + <summary> + Encodes a set of characters in the input characters span and any characters + in the internal buffer into a sequence of bytes that are stored in the input + byte span. A parameter indicates whether to clear the internal state of the + encoder after the conversion. + </summary> + <param name="enc"></param> + <param name="chars">Character buffer to encode</param> + <param name="offset">The offset in the char buffer to begin encoding chars from</param> + <param name="charCount">The number of characers to encode</param> + <param name="writer">The buffer writer to use</param> + <param name="flush">true to clear the internal state of the encoder after the conversion; otherwise, false.</param> + <returns>The actual number of bytes written at the location indicated by the bytes parameter.</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetBytes(System.Text.Encoder,System.ReadOnlySpan{System.Char},VNLib.Utils.Memory.VnBufferWriter{System.Byte}@,System.Boolean)"> + <summary> + Encodes a set of characters in the input characters span and any characters + in the internal buffer into a sequence of bytes that are stored in the input + byte span. A parameter indicates whether to clear the internal state of the + encoder after the conversion. + </summary> + <param name="enc"></param> + <param name="chars">The character buffer to encode</param> + <param name="writer">The buffer writer to use</param> + <param name="flush">true to clear the internal state of the encoder after the conversion; otherwise, false.</param> + <returns>The actual number of bytes written at the location indicated by the bytes parameter.</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetBytes(System.Text.Encoding,System.ReadOnlySpan{System.Char},VNLib.Utils.Memory.VnBufferWriter{System.Byte}@)"> + <summary> + Encodes a set of characters in the input characters span and any characters + in the internal buffer into a sequence of bytes that are stored in the input + byte span. + </summary> + <param name="encoding"></param> + <param name="chars">The character buffer to encode</param> + <param name="writer">The buffer writer to use</param> + <returns>The actual number of bytes written at the location indicated by the bytes parameter.</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.GetChars(System.Text.Encoding,System.ReadOnlySpan{System.Byte},VNLib.Utils.Memory.VnBufferWriter{System.Char}@)"> + <summary> + Decodes a character buffer in the input characters span and any characters + in the internal buffer into a sequence of bytes that are stored in the input + byte span. + </summary> + <param name="encoding"></param> + <param name="bytes">The binary buffer to decode</param> + <param name="writer">The buffer writer to use</param> + <returns>The actual number of *characters* written at the location indicated by the chars parameter.</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ToPrivate(VNLib.Utils.Memory.VnBufferWriter{System.Char}@)"> + <summary> + Converts the buffer data to a <see cref="T:VNLib.Utils.Memory.PrivateString"/> + </summary> + <returns>A <see cref="T:VNLib.Utils.Memory.PrivateString"/> instance that owns the underlying string memory</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AsSpan``1(VNLib.Utils.Memory.VnBufferWriter{``0}@)"> + <summary> + Gets a <see cref="T:System.Span`1"/> over the modified section of the internal buffer + </summary> + <returns>A <see cref="T:System.Span`1"/> over the modified data</returns> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Slice``1(``0[],System.Int32)"> + <summary> + Slices the current array by the specified starting offset to the end + of the array + </summary> + <typeparam name="T">The array type</typeparam> + <param name="arr"></param> + <param name="start">The start offset of the new array slice</param> + <returns>The sliced array</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.Slice``1(``0[],System.Int32,System.Int32)"> + <summary> + Slices the current array by the specified starting offset to including the + speciifed number of items + </summary> + <typeparam name="T">The array type</typeparam> + <param name="arr"></param> + <param name="start">The start offset of the new array slice</param> + <param name="count">The size of the new array</param> + <returns>The sliced array</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.OverlappedShift``1(System.Span{``0}@,System.Int32,System.Int32,System.Int32)"> + <summary> + Copies an overlapping memory range by shifting it + </summary> + <typeparam name="T"></typeparam> + <param name="buffer"></param> + <param name="start">The starting position of the data to copy from <paramref name="buffer"/></param> + <param name="offset">The starting position within <paramref name="buffer"/> to write the block to</param> + <param name="size">The size of the section to shift</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AsSpan``1(VNLib.Utils.Memory.IMemoryHandle{``0},System.Int32)"> + <summary> + Creates a new sub-sequence over the target handle. (allows for convient sub span) + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="start">Intial offset into the handle</param> + <returns>The sub-sequence of the current handle</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AsSpan``1(VNLib.Utils.Memory.IMemoryHandle{``0},System.Int32,System.Int32)"> + <summary> + Creates a new sub-sequence over the target handle. (allows for convient sub span) + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="start">Intial offset into the handle</param> + <param name="count">The number of elements within the new sequence</param> + <returns>The sub-sequence of the current handle</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AsSpan``1(VNLib.Utils.Memory.UnsafeMemoryHandle{``0}@,System.Int32)"> + <summary> + Creates a new sub-sequence over the target handle. (allows for convient sub span) + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="start">Intial offset into the handle</param> + <returns>The sub-sequence of the current handle</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.AsSpan``1(VNLib.Utils.Memory.UnsafeMemoryHandle{``0}@,System.Int32,System.Int32)"> + <summary> + Creates a new sub-sequence over the target handle. (allows for convient sub span) + </summary> + <typeparam name="T"></typeparam> + <param name="handle"></param> + <param name="start">Intial offset into the handle</param> + <param name="count">The number of elements within the new sequence</param> + <returns>The sub-sequence of the current handle</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.MemoryExtensions.ThrowIfClosed(System.Runtime.InteropServices.SafeHandle)"> + <summary> + Raises an <see cref="T:System.ObjectDisposedException"/> if the current handle + has been disposed or set as invalid + </summary> + <param name="handle"></param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Utils.Extensions.MutexReleaser"> + <summary> + Represents a releaser handle for a <see cref="T:System.Threading.Mutex"/> + that has been entered and will be released. Best if used + within a using() statment + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.MutexReleaser.Dispose"> + <summary> + Releases the held System.Threading.Mutex once. + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.MutexReleaser.ReleaseMutext"> + <summary> + Releases the held System.Threading.Mutex once. + </summary> + </member> + <member name="T:VNLib.Utils.Extensions.SafeMethodNameAttribute"> + <summary> + When applied to a delegate, specifies the name of the native method to load + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.SafeMethodNameAttribute.#ctor(System.String)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Extensions.SafeMethodNameAttribute"/> + </summary> + <param name="nativeMethodName">The name of the native method</param> + </member> + <member name="M:VNLib.Utils.Extensions.SafeMethodNameAttribute.#ctor"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Extensions.SafeMethodNameAttribute"/>, that uses the + delegate name as the native method name + </summary> + </member> + <member name="P:VNLib.Utils.Extensions.SafeMethodNameAttribute.MethodName"> + <summary> + The name of the native method + </summary> + </member> + <member name="T:VNLib.Utils.Extensions.SafeLibraryExtensions"> + <summary> + Contains native library extension methods + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.SafeLibraryExtensions.GetMethod``1(VNLib.Utils.SafeLibraryHandle)"> + <summary> + Loads a native method from the current <see cref="T:VNLib.Utils.SafeLibraryHandle"/> + that has a <see cref="T:VNLib.Utils.Extensions.SafeMethodNameAttribute"/> + </summary> + <typeparam name="T"></typeparam> + <param name="library"></param> + <returns></returns> + <exception cref="T:System.MissingMemberException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.EntryPointNotFoundException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.SafeLibraryExtensions.DangerousGetMethod``1(VNLib.Utils.SafeLibraryHandle)"> + <summary> + Loads a native method from the current <see cref="T:VNLib.Utils.SafeLibraryHandle"/> + that has a <see cref="T:VNLib.Utils.Extensions.SafeMethodNameAttribute"/> + </summary> + <typeparam name="T"></typeparam> + <param name="library"></param> + <returns></returns> + <exception cref="T:System.MissingMemberException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.EntryPointNotFoundException"></exception> + <remarks> + The libraries handle count is left unmodified + </remarks> + </member> + <member name="T:VNLib.Utils.Extensions.SemSlimReleaser"> + <summary> + Represents a releaser handle for a <see cref="T:System.Threading.SemaphoreSlim"/> + that has been entered and will be released. Best if used + within a using() statment + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.SemSlimReleaser.Dispose"> + <summary> + Releases the System.Threading.SemaphoreSlim object once. + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.SemSlimReleaser.Release"> + <summary> + Releases the System.Threading.SemaphoreSlim object once. + </summary> + <returns>The previous count of the <see cref="T:System.Threading.SemaphoreSlim"/></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.Threading.SemaphoreFullException"></exception> + </member> + <member name="T:VNLib.Utils.Extensions.StringExtensions"> + <summary> + Extention methods for string (character buffer) + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.String,System.String,``0,System.StringSplitOptions)"> + <summary> + Split a string based on split value and insert into the specified list + </summary> + <param name="value"></param> + <param name="splitter">The value to split the string on</param> + <param name="output">The list to output data to</param> + <param name="options">String split options</param> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.String,System.Char,``0,System.StringSplitOptions)"> + <summary> + Split a string based on split value and insert into the specified list + </summary> + <param name="value"></param> + <param name="splitter">The value to split the string on</param> + <param name="output">The list to output data to</param> + <param name="options">String split options</param> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.String,System.ReadOnlySpan{System.Char},``0,System.StringSplitOptions)"> + <summary> + Split a string based on split value and insert into the specified list + </summary> + <param name="value"></param> + <param name="splitter">The value to split the string on</param> + <param name="output">The list to output data to</param> + <param name="options">String split options</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.ReadOnlySpan{System.Char}@,System.Char,``0,System.StringSplitOptions)"> + <summary> + Split a string based on split value and insert into the specified list + </summary> + <param name="value"></param> + <param name="splitter">The value to split the string on</param> + <param name="output">The list to output data to</param> + <param name="options">String split options</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char},``0,System.StringSplitOptions)"> + <summary> + Split a <see cref="T:System.ReadOnlySpan`1"/> based on split value and insert into the specified list + </summary> + <param name="value"></param> + <param name="splitter">The value to split the string on</param> + <param name="output">The list to output data to</param> + <param name="options">String split options</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char},System.StringSplitOptions,System.Buffers.ReadOnlySpanAction{System.Char,``0},``0)"> + <summary> + Split a <see cref="T:System.ReadOnlySpan`1"/> based on split value and pass it to the split delegate handler + </summary> + <param name="value"></param> + <param name="splitter">The sequence to split the string on</param> + <param name="options">String split options</param> + <param name="splitCb">The action to invoke when a split segment has been found</param> + <param name="state">The state to pass to the callback handler</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split``1(System.ReadOnlySpan{System.Char}@,System.Char,System.StringSplitOptions,System.Buffers.ReadOnlySpanAction{System.Char,``0},``0)"> + <summary> + Split a <see cref="T:System.ReadOnlySpan`1"/> based on split value and pass it to the split delegate handler + </summary> + <param name="value"></param> + <param name="splitter">The character to split the string on</param> + <param name="options">String split options</param> + <param name="splitCb">The action to invoke when a split segment has been found</param> + <param name="state"></param> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char},System.StringSplitOptions,VNLib.Utils.Extensions.SpanSplitStatelessDelegate)"> + <summary> + Split a <see cref="T:System.ReadOnlySpan`1"/> based on split value and pass it to the split delegate handler + </summary> + <param name="value"></param> + <param name="splitter">The sequence to split the string on</param> + <param name="options">String split options</param> + <param name="splitCb">The action to invoke when a split segment has been found</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Split(System.ReadOnlySpan{System.Char}@,System.Char,System.StringSplitOptions,VNLib.Utils.Extensions.SpanSplitStatelessDelegate)"> + <summary> + Split a <see cref="T:System.ReadOnlySpan`1"/> based on split value and pass it to the split delegate handler + </summary> + <param name="value"></param> + <param name="splitter">The character to split the string on</param> + <param name="options">String split options</param> + <param name="splitCb">The action to invoke when a split segment has been found</param> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.EndOf(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char})"> + <summary> + Gets the index of the end of the found sequence + </summary> + <param name="data"></param> + <param name="search">Sequence to search for within the current sequence</param> + <returns>the index of the end of the sequenc</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.EndOf(System.ReadOnlySpan{System.Char}@,System.Char)"> + <summary> + Gets the index of the end of the found character + </summary> + <param name="data"></param> + <param name="search">Character to search for within the current sequence</param> + <returns>the index of the end of the sequence</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.SliceBeforeParam(System.ReadOnlySpan{System.Char}@,System.Char)"> + <summary> + Slices the current span from the begining of the segment to the first occurrance of the specified character. + If the character is not found, the entire segment is returned + </summary> + <param name="data"></param> + <param name="search">The delimiting character</param> + <returns>The segment of data before the search character, or the entire segment if not found</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.SliceBeforeParam(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char})"> + <summary> + Slices the current span from the begining of the segment to the first occurrance of the specified character sequence. + If the character sequence is not found, the entire segment is returned + </summary> + <param name="data"></param> + <param name="search">The delimiting character sequence</param> + <returns>The segment of data before the search character, or the entire <paramref name="data"/> if the seach sequence is not found</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.SliceAfterParam(System.ReadOnlySpan{System.Char}@,System.Char)"> + <summary> + Gets the remaining segment of data after the specified search character or <see cref="P:System.ReadOnlySpan`1.Empty"/> + if the search character is not found within the current segment + </summary> + <param name="data"></param> + <param name="search">The character to search for within the segment</param> + <returns>The segment of data after the search character or <see cref="P:System.ReadOnlySpan`1.Empty"/> if not found</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.SliceAfterParam(System.ReadOnlySpan{System.Char}@,System.ReadOnlySpan{System.Char})"> + <summary> + Gets the remaining segment of data after the specified search sequence or <see cref="P:System.ReadOnlySpan`1.Empty"/> + if the search sequence is not found within the current segment + </summary> + <param name="data"></param> + <param name="search">The sequence to search for within the segment</param> + <returns>The segment of data after the search sequence or <see cref="P:System.ReadOnlySpan`1.Empty"/> if not found</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.TrimCRLF(System.ReadOnlySpan{System.Char}@)"> + <summary> + Trims any leading or trailing <c>'\r'|'\n'|' '</c>(whitespace) characters from the segment + </summary> + <returns>The trimmed segment</returns> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Replace(System.Span{System.Char}@,System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char})"> + <summary> + Replaces a character sequence within the buffer + </summary> + <param name="buffer">The character buffer to process</param> + <param name="search">The sequence to search for</param> + <param name="replace">The sequence to write in the place of the search parameter</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.Replace(VNLib.Utils.Memory.VnBufferWriter{System.Char}@,System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char})"> + <summary> + Replaces a character sequence within the writer + </summary> + <param name="writer"></param> + <param name="search">The sequence to search for</param> + <param name="replace">The sequence to write in the place of the search parameter</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.StringExtensions.ReplaceInPlace(System.Span{System.Char},System.ReadOnlySpan{System.Char},System.ReadOnlySpan{System.Char})"> + <summary> + Replaces very ocurrance of character sequence within a buffer with another sequence of the same length + </summary> + <param name="buffer"></param> + <param name="search">The sequence to search for</param> + <param name="replace">The sequence to replace the found sequence with</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="T:VNLib.Utils.Extensions.ThreadingExtensions"> + <summary> + Provides extension methods to common threading and TPL library operations + </summary> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.EnterSafeContext``1(VNLib.Utils.OpenResourceHandle{``0},System.Action{``0})"> + <summary> + Allows an <see cref="T:VNLib.Utils.OpenResourceHandle`1"/> to execute within a scope limited context + </summary> + <typeparam name="TResource">The resource type</typeparam> + <param name="rh"></param> + <param name="safeCallback">The function body that will execute with controlled access to the resource</param> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.GetReleaserAsync(System.Threading.SemaphoreSlim,System.Threading.CancellationToken)"> + <summary> + Asynchronously waits to enter the <see cref="T:System.Threading.SemaphoreSlim"/> while observing a <see cref="T:System.Threading.CancellationToken"/> + and getting a releaser handle + </summary> + <param name="semaphore"></param> + <param name="cancellationToken">A token to cancel the operation</param> + <returns>A releaser handle that may be disposed to release the semaphore</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.OperationCanceledException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.GetReleaserAsync(System.Threading.SemaphoreSlim,System.Int32)"> + <summary> + Asynchronously waits to enter the <see cref="T:System.Threading.SemaphoreSlim"/> using a 32-bit signed integer to measure the time intervale + and getting a releaser handle + </summary> + <param name="semaphore"></param> + <param name="timeout">A the maximum amount of time in milliseconds to wait to enter the semaphore</param> + <returns>A releaser handle that may be disposed to release the semaphore</returns> + <exception cref="T:System.TimeoutException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.GetReleaser(System.Threading.SemaphoreSlim)"> + <summary> + Blocks the current thread until it can enter the <see cref="T:System.Threading.SemaphoreSlim"/> + </summary> + <param name="semaphore"></param> + <returns>A releaser handler that releases the semaphore when disposed</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.GetReleaser(System.Threading.SemaphoreSlim,System.Int32)"> + <summary> + Blocks the current thread until it can enter the <see cref="T:System.Threading.SemaphoreSlim"/> + </summary> + <param name="semaphore"></param> + <param name="timeout">A the maximum amount of time in milliseconds to wait to enter the semaphore</param> + <returns>A releaser handler that releases the semaphore when disposed</returns> + <exception cref="T:System.TimeoutException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.Enter(System.Threading.Mutex)"> + <summary> + Blocks the current thread until it can enter the <see cref="T:System.Threading.Mutex"/> + </summary> + <param name="mutex"></param> + <returns>A releaser handler that releases the semaphore when disposed</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.Threading.AbandonedMutexException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.Enter(System.Threading.Mutex,System.Int32)"> + <summary> + Blocks the current thread until it can enter the <see cref="T:System.Threading.SemaphoreSlim"/> + </summary> + <param name="mutex"></param> + <param name="timeout">A the maximum amount of time in milliseconds to wait to enter the semaphore</param> + <returns>A releaser handler that releases the semaphore when disposed</returns> + <exception cref="T:System.TimeoutException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.WaitAsync(System.Threading.WaitHandle,System.Int32)"> + <summary> + Asynchronously waits for a the <see cref="T:System.Threading.WaitHandle"/> to receive a signal. This method spins until + a thread yield will occur, then asynchronously yields. + </summary> + <param name="handle"></param> + <param name="timeoutMs">The timeout interval in milliseconds</param> + <returns> + A task that compeletes when the wait handle receives a signal or times-out, + the result of the awaited task will be <c>true</c> if the signal is received, or + <c>false</c> if the timeout interval expires + </returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.ThreadingExtensions.RegisterUnobserved(System.Threading.CancellationToken,System.Action)"> + <summary> + Registers a callback method that will be called when the token has been cancelled. + This method waits indefinitely for the token to be cancelled. + </summary> + <param name="token"></param> + <param name="callback">The callback method to invoke when the token has been cancelled</param> + <returns>A task that may be unobserved, that completes when the token has been cancelled</returns> + </member> + <member name="M:VNLib.Utils.Extensions.TimerExtensions.Stop(System.Threading.Timer)"> + <summary> + Attempts to stop the timer + </summary> + <returns>True if the timer was successfully modified, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.Extensions.TimerExtensions.Stop(System.Threading.Timer,System.TimeSpan)"> + <summary> + Attempts to stop an active timer and prepare a <see cref="T:VNLib.Utils.OpenHandle"/> configured to restore the state of the timer to the specified timespan + </summary> + <param name="timer"></param> + <param name="resumeTime"><see cref="T:System.TimeSpan"/> representing the amount of time the timer should wait before invoking the callback function</param> + <returns>A new <see cref="T:VNLib.Utils.OpenHandle"/> if the timer was stopped successfully that will resume the timer when closed, null otherwise</returns> + </member> + <member name="M:VNLib.Utils.Extensions.TimerExtensions.Restart(System.Threading.Timer,System.TimeSpan)"> + <summary> + Attempts to reset and start a timer + </summary> + <param name="timer"></param> + <param name="wait"><see cref="T:System.TimeSpan"/> to wait before the timer event is fired</param> + <returns>True if the timer was successfully modified</returns> + </member> + <member name="M:VNLib.Utils.Extensions.TimerExtensions.Restart(System.Threading.Timer,System.Int32)"> + <summary> + Attempts to reset and start a timer + </summary> + <param name="timer"></param> + <param name="waitMilliseconds">Time in milliseconds to wait before the timer event is fired</param> + <returns>True if the timer was successfully modified</returns> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.Conatins(VNLib.Utils.Memory.VnString,System.Char)"> + <summary> + Derermines if the character exists within the instance + </summary> + <param name="str"></param> + <param name="value">The value to find</param> + <returns>True if the character exists within the instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.Conatins(VNLib.Utils.Memory.VnString,System.ReadOnlySpan{System.Char},System.StringComparison)"> + <summary> + Derermines if the sequence exists within the instance + </summary> + <param name="str"></param> + <param name="value">The sequence to find</param> + <param name="stringComparison"></param> + <returns>True if the character exists within the instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.IndexOf(VNLib.Utils.Memory.VnString,System.Char)"> + <summary> + Searches for the first occurrance of the specified character within the current instance + </summary> + <param name="str"></param> + <param name="value">The character to search for within the instance</param> + <returns>The 0 based index of the occurance, -1 if the character was not found</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.IndexOf(VNLib.Utils.Memory.VnString,System.ReadOnlySpan{System.Char})"> + <summary> + Searches for the first occurrance of the specified sequence within the current instance + </summary> + <param name="str"></param> + <param name="search">The sequence to search for</param> + <returns>The 0 based index of the occurance, -1 if the sequence was not found</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.IndexOf(VNLib.Utils.Memory.VnString,System.ReadOnlySpan{System.Char},System.StringComparison)"> + <summary> + Searches for the first occurrance of the specified sequence within the current instance + </summary> + <param name="str"></param> + <param name="search">The sequence to search for</param> + <param name="comparison">The <see cref="T:System.StringComparison"/> type to use in searchr</param> + <returns>The 0 based index of the occurance, -1 if the sequence was not found</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.IndexOf(VNLib.Utils.Memory.VnString,System.ReadOnlySpan{System.Char},System.Int32)"> + <summary> + Searches for the 0 based index of the first occurance of the search parameter after the start index. + </summary> + <param name="str"></param> + <param name="search">The sequence of data to search for</param> + <param name="start">The lower boundry of the search area</param> + <returns>The absolute index of the first occurrance within the instance, -1 if the sequency was not found in the windowed segment</returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.EndOf(VNLib.Utils.Memory.VnString,System.ReadOnlySpan{System.Char})"> + <summary> + Returns the realtive index after the specified sequence within the <see cref="T:VNLib.Utils.Memory.VnString"/> instance + </summary> + <param name="str"></param> + <param name="search">The sequence to search for</param> + <returns>The index after the found sequence within the string, -1 if the sequence was not found within the instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.AbsoluteTrim(VNLib.Utils.Memory.VnString,System.Int32,System.Int32)"> + <summary> + Allows for trimming whitespace characters in a realtive sequence from + within a <see cref="T:VNLib.Utils.Memory.VnString"/> buffer defined by the start and end parameters + and returning the trimmed entry. + </summary> + <param name="data"></param> + <param name="start">The starting position within the sequence to trim</param> + <param name="end">The end of the sequence to trim</param> + <returns>The trimmed <see cref="T:VNLib.Utils.Memory.VnString"/> instance as a child of the original entry</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.AbsoluteTrim(VNLib.Utils.Memory.VnString,System.Int32@,System.Int32@)"> + <summary> + Finds whitespace characters within the sequence defined between start and end parameters + and adjusts the specified window to "trim" whitespace + </summary> + <param name="data"></param> + <param name="start">The starting position within the sequence to trim</param> + <param name="end">The end of the sequence to trim</param> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.AbsoluteTrim(VNLib.Utils.Memory.VnString,System.Int32)"> + <summary> + Allows for trimming whitespace characters in a realtive sequence from + within a <see cref="T:VNLib.Utils.Memory.VnString"/> buffer and returning the trimmed entry. + </summary> + <param name="data"></param> + <param name="start">The starting position within the sequence to trim</param> + <returns>The trimmed <see cref="T:VNLib.Utils.Memory.VnString"/> instance as a child of the original entry</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.IndexOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.RelativeTirm(VNLib.Utils.Memory.VnString)"> + <summary> + Trims leading or trailing whitespace characters and returns a new child instance + without leading or trailing whitespace + </summary> + <returns>A child <see cref="T:VNLib.Utils.Memory.VnString"/> of the current instance without leading or trailing whitespaced</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.Split(VNLib.Utils.Memory.VnString,System.ReadOnlyMemory{System.Char},System.StringSplitOptions)"> + <summary> + Allows for enumeration of segments of data within the specified <see cref="T:VNLib.Utils.Memory.VnString"/> instance that are + split by the search parameter + </summary> + <param name="data"></param> + <param name="search">The sequence of data to delimit segments</param> + <param name="options">The options used to split the string instances</param> + <returns>An iterator to enumerate the split segments</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.TrimCRLF(VNLib.Utils.Memory.VnString)"> + <summary> + Trims any leading or trailing <c>'\r'|'\n'|' '</c>(whitespace) characters from the segment + </summary> + <returns>The trimmed segment</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.GetEnumerator(VNLib.Utils.Memory.VnString)"> + <summary> + Unoptimized character enumerator. You should use <see cref="M:VNLib.Utils.Memory.VnString.AsSpan"/> to enumerate the unerlying data. + </summary> + <returns>The next character in the sequence</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.ToVnString(VNLib.Utils.Memory.MemoryHandle{System.Char},System.Int32)"> + <summary> + Converts the current handle to a <see cref="T:VNLib.Utils.Memory.VnString"/>, a zero-alloc immutable wrapper + for a memory handle + </summary> + <param name="handle"></param> + <param name="length">The number of characters from the handle to reference (length of the string)</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/> wrapper</returns> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.ToVnString(VNLib.Utils.Memory.MemoryHandle{System.Char})"> + <summary> + Converts the current handle to a <see cref="T:VNLib.Utils.Memory.VnString"/>, a zero-alloc immutable wrapper + for a memory handle + </summary> + <param name="handle"></param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/> wrapper</returns> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Extensions.VnStringExtensions.ToVnString(VNLib.Utils.Memory.MemoryHandle{System.Char},System.UInt64,System.Int32)"> + <summary> + Converts the current handle to a <see cref="T:VNLib.Utils.Memory.VnString"/>, a zero-alloc immutable wrapper + for a memory handle + </summary> + <param name="handle"></param> + <param name="offset">The offset in characters that represents the begining of the string</param> + <param name="length">The number of characters from the handle to reference (length of the string)</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/> wrapper</returns> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="T:VNLib.Utils.IExclusiveResource"> + <summary> + An object, that when used in a mulithreading context, guaruntees that the caller has exclusive + access to the instance and relinquishes exclusive access when Release() is called; + </summary> + </member> + <member name="P:VNLib.Utils.IExclusiveResource.IsReleased"> + <summary> + Gets a value indicating if the resource has been released + </summary> + </member> + <member name="M:VNLib.Utils.IExclusiveResource.Release"> + <summary> + Releases the resource from use. Called when a <see cref="T:VNLib.Utils.ExclusiveResourceHandle`1"/> is disposed + </summary> + </member> + <member name="T:VNLib.Utils.IIndexable`2"> + <summary> + Provides an interface that provides an indexer + </summary> + <typeparam name="TKey">The lookup Key</typeparam> + <typeparam name="TValue">The lookup value</typeparam> + </member> + <member name="P:VNLib.Utils.IIndexable`2.Item(`0)"> + <summary> + Gets or sets the value at the specified index in the collection + </summary> + <param name="key">The key to lookup the value at</param> + <returns>The value at the specified key</returns> + </member> + <member name="T:VNLib.Utils.IO.BackingStream`1"> + <summary> + Provides basic stream support sync/async stream operations to a + backing stream with virtual event methods. Provides a pass-through + as best as possbile. + </summary> + </member> + <member name="F:VNLib.Utils.IO.BackingStream`1.BaseStream"> + <summary> + The backing/underlying stream operations are being performed on + </summary> + </member> + <member name="F:VNLib.Utils.IO.BackingStream`1.ForceReadOnly"> + <summary> + A value that will cause all calls to write to throw <see cref="T:System.NotSupportedException"/> + </summary> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.CanRead"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.CanSeek"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.CanWrite"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.Length"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.WriteTimeout"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.ReadTimeout"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.BackingStream`1.Position"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Flush"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Read(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Read(System.Span{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Seek(System.Int64,System.IO.SeekOrigin)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.SetLength(System.Int64)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Write(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Write(System.ReadOnlySpan{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.Close"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.OnClose"> + <summary> + Raised directly after the base stream is closed, when a call to close is made + </summary> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.OnFlush"> + <summary> + Raised directly after the base stream is flushed, when a call to flush is made + </summary> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.OnWrite(System.Int32)"> + <summary> + Raised directly after a successfull write operation. + </summary> + <param name="count">The number of bytes written to the stream</param> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.ReadAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.CopyTo(System.IO.Stream,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.CopyToAsync(System.IO.Stream,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.WriteAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.FlushAsync(System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.BackingStream`1.DisposeAsync"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.IO.FileOperations"> + <summary> + Contains cross-platform optimized filesystem operations. + </summary> + </member> + <member name="M:VNLib.Utils.IO.FileOperations.FileExists(System.String)"> + <summary> + Determines if a file exists. If application is current running in the Windows operating system, Shlwapi.PathFileExists is invoked, + otherwise <see cref="M:System.IO.File.Exists(System.String)"/> is invoked + </summary> + <param name="filePath">the path to the file</param> + <returns>True if the file can be opened, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.IO.FileOperations.GetAttributes(System.String)"> + <summary> + If Windows is detected at load time, gets the attributes for the specified file. + </summary> + <param name="filePath">The path to the existing file</param> + <returns>The attributes of the file </returns> + <exception cref="T:System.IO.PathTooLongException"></exception> + <exception cref="T:System.IO.FileNotFoundException"></exception> + <exception cref="T:System.UnauthorizedAccessException"></exception> + </member> + <member name="T:VNLib.Utils.IO.InMemoryTemplate"> + <summary> + Represents a lazily loaded file stored in memory, with a change mointor + that reloads the template if the file was modified in the filesystem + </summary> + </member> + <member name="P:VNLib.Utils.IO.InMemoryTemplate.TemplateName"> + <summary> + Gets the name of the template + </summary> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.#ctor(System.String,System.Boolean)"> + <summary> + Creates a new in-memory copy of a file that will detect changes and refresh + </summary> + <param name="listenForChanges">Should changes to the template file be moniored for changes, and reloaded as necessary</param> + <param name="path">The path of the file template</param> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.GetTemplateData"> + <summary> + Gets a cached copy of the template data + </summary> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.ReadFile"> + <summary> + Updates the internal copy of the file to its memory representation + </summary> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.ReadFileAsync(System.Threading.CancellationToken)"> + <summary> + Updates the internal copy of the file to its memory representation, asynchronously + </summary> + <param name="cancellationToken"></param> + <returns>A task that completes when the file has been copied into memory</returns> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.OnModifed"> + <summary> + Invoked when the template file has been modifed. Note: This event is raised + while the <see cref="F:VNLib.Utils.IO.InMemoryTemplate.TemplateLock"/> is held. + </summary> + </member> + <member name="M:VNLib.Utils.IO.InMemoryTemplate.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.IO.ISlindingWindowBuffer`1"> + <summary> + Represents a sliding window buffer for reading/wiriting data + </summary> + <typeparam name="T"></typeparam> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.WindowStartPos"> + <summary> + The starting positon of the available data within the buffer + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.WindowEndPos"> + <summary> + The ending position of the available data within the buffer + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.Buffer"> + <summary> + Buffer memory wrapper + </summary> + </member> + <member name="M:VNLib.Utils.IO.ISlindingWindowBuffer`1.Close"> + <summary> + Releases resources used by the current instance + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.Available"> + <summary> + Gets the number of available items within the buffer + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.CurrentWindowSpan"> + <summary> + Gets a window within the buffer of available buffered data + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.CurrentWindow"> + <summary> + Gets a window within the buffer of available buffered data + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.Remianing"> + <summary> + Gets the number of available (remaining) buffer elements + </summary> + </member> + <member name="P:VNLib.Utils.IO.ISlindingWindowBuffer`1.RemainingWindow"> + <summary> + Gets the available buffer window to write data to + </summary> + </member> + <member name="T:VNLib.Utils.IO.IsolatedStorageDirectory"> + <summary> + Represents an open directory within an <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFile"/> store for which files can be created, opened, or deleted. + </summary> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.#ctor(System.IO.IsolatedStorage.IsolatedStorageFile,System.String)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.IO.IsolatedStorageDirectory"/> within the specified file using the directory name. + </summary> + <param name="storage">A configured and open <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFile"/></param> + <param name="dir">The directory name to open or create within the store</param> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.CreateFile(System.String)"> + <summary> + Creates a file by its path name within the currnet directory + </summary> + <param name="fileName">The name of the file</param> + <returns>The open file</returns> + <exception cref="T:System.IO.IsolatedStorage.IsolatedStorageException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.IO.DirectoryNotFoundException"></exception> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.DeleteFile(System.String)"> + <summary> + Removes a file from the current directory + </summary> + <param name="fileName">The path of the file to remove</param> + <exception cref="T:System.IO.IsolatedStorage.IsolatedStorageException"></exception> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.OpenFile(System.String,System.IO.FileMode,System.IO.FileAccess)"> + <summary> + Opens a file that exists within the current directory + </summary> + <param name="fileName">Name with extension of the file</param> + <param name="mode">File mode</param> + <param name="access">File access</param> + <returns>The open <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFileStream"/> from the current directory</returns> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.OpenFile(System.String,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare)"> + <summary> + Opens a file that exists within the current directory + </summary> + <param name="fileName">Name with extension of the file</param> + <param name="mode">File mode</param> + <param name="access">File access</param> + <param name="share">The file shareing mode</param> + <returns>The open <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFileStream"/> from the current directory</returns> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.FileExists(System.String)"> + <summary> + Determiens if the specified file path refers to an existing file within the directory + </summary> + <param name="fileName">The name of the file to search for</param> + <returns>True if the file exists within the current directory</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.IO.IsolatedStorage.IsolatedStorageException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.Remove"> + <summary> + Removes the directory and its contents from the store + </summary> + </member> + <member name="P:VNLib.Utils.IO.IsolatedStorageDirectory.Parent"> + <summary> + The parent <see cref="T:VNLib.Utils.IO.IsolatedStorageDirectory"/> this directory is a child within. null if there are no parent directories + above this dir + </summary> + </member> + <member name="M:VNLib.Utils.IO.IsolatedStorageDirectory.CreateChildDirectory(System.String)"> + <summary> + Creates a child directory within the current directory + </summary> + <param name="directoryName">The name of the child directory</param> + <returns>A new <see cref="T:VNLib.Utils.IO.IsolatedStorageDirectory"/> for which <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFileStream"/>s can be opened/created</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="T:VNLib.Utils.IO.IVnTextReader"> + <summary> + Represents a streaming text reader with internal buffers + </summary> + </member> + <member name="P:VNLib.Utils.IO.IVnTextReader.BaseStream"> + <summary> + The base stream to read data from + </summary> + </member> + <member name="P:VNLib.Utils.IO.IVnTextReader.Encoding"> + <summary> + The character encoding used by the TextReader + </summary> + </member> + <member name="P:VNLib.Utils.IO.IVnTextReader.Available"> + <summary> + Number of available bytes of buffered data within the current buffer window + </summary> + </member> + <member name="P:VNLib.Utils.IO.IVnTextReader.LineTermination"> + <summary> + Gets or sets the line termination used to deliminate a line of data + </summary> + </member> + <member name="P:VNLib.Utils.IO.IVnTextReader.BufferedDataWindow"> + <summary> + The unread/available data within the internal buffer + </summary> + </member> + <member name="M:VNLib.Utils.IO.IVnTextReader.Advance(System.Int32)"> + <summary> + Shifts the sliding buffer window by the specified number of bytes. + </summary> + <param name="count">The number of bytes read from the buffer</param> + </member> + <member name="M:VNLib.Utils.IO.IVnTextReader.FillBuffer"> + <summary> + Reads data from the stream into the remaining buffer space for processing + </summary> + </member> + <member name="M:VNLib.Utils.IO.IVnTextReader.CompactBufferWindow"> + <summary> + Compacts the available buffer space back to the begining of the buffer region + and determines if there is room for more data to be buffered + </summary> + <returns>The remaining buffer space if any</returns> + </member> + <member name="T:VNLib.Utils.IO.SlidingWindowBufferExtensions"> + <summary> + Extention methods for <see cref="T:VNLib.Utils.IO.ISlindingWindowBuffer`1"/> + </summary> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.CompactBufferWindow``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0})"> + <summary> + Shifts/resets the current buffered data window down to the + begining of the buffer if the buffer window is shifted away + from the begining. + </summary> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Reset``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0})"> + <summary> + Resets the buffer window back to the begining of the buffer + </summary> + <typeparam name="T"></typeparam> + <param name="sBuf"></param> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Append``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0},``0)"> + <summary> + Appents the specified data to the end of the buffer + </summary> + <typeparam name="T"></typeparam> + <param name="sBuf"></param> + <param name="val">The value to append to the end of the buffer</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Append``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0},System.ReadOnlyMemory{``0})"> + <summary> + Appents the specified data to the end of the buffer + </summary> + <typeparam name="T"></typeparam> + <param name="sBuf"></param> + <param name="val">The value to append to the end of the buffer</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Append``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0},System.ReadOnlySpan{``0})"> + <summary> + Appents the specified data to the end of the buffer + </summary> + <typeparam name="T"></typeparam> + <param name="sBuf"></param> + <param name="val">The value to append to the end of the buffer</param> + <exception cref="T:System.ArgumentException"></exception> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Advance``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0},System.Int32)"> + <summary> + Advances the end of the buffer window by the specified amount + </summary> + <typeparam name="T">Element type</typeparam> + <param name="sBuf"></param> + <param name="count">The number of elements added to the end of the buffer</param> + </member> + <member name="M:VNLib.Utils.IO.SlidingWindowBufferExtensions.Read``1(VNLib.Utils.IO.ISlindingWindowBuffer{``0},System.Span{``0}@)"> + <summary> + Reads available data from the current window and writes it to the supplied buffer + </summary> + <typeparam name="T">Element type</typeparam> + <param name="sBuf"></param> + <param name="buffer">The output buffer to write data to</param> + <returns>The number of elements written to the buffer</returns> + </member> + <member name="T:VNLib.Utils.IO.TemporayIsolatedFile"> + <summary> + Allows for temporary files to be generated, used, then removed from an <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFile"/> + </summary> + </member> + <member name="M:VNLib.Utils.IO.TemporayIsolatedFile.#ctor(VNLib.Utils.IO.IsolatedStorageDirectory)"> + <summary> + Creates a new temporary filestream within the specified <see cref="T:System.IO.IsolatedStorage.IsolatedStorageFile"/> + </summary> + <param name="storage">The file store to genreate temporary files within</param> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.BaseStream"> + <summary> + Gets the underlying stream that interfaces with the backing store + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.InitializeBuffer(System.Int32)"> + <summary> + Invoked by the constuctor method to allocte the internal buffer with the specified buffer size. + </summary> + <param name="bufferSize">The requested size of the buffer to alloc</param> + <remarks>By default requests the buffer from the <see cref="P:System.Buffers.ArrayPool`1.Shared"/> instance</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.Close"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.Flush"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.Write(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.CanRead"> + <summary> + Always false + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.CanSeek"> + <summary> + Always returns false + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.CanWrite"> + <summary> + Always true + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.Length"> + <summary> + Returns the size of the underlying buffer + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnBufferedStream.Position"> + <summary> + Always throws <see cref="T:System.NotSupportedException"/> + </summary> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.Read(System.Byte[],System.Int32,System.Int32)"> + <summary> + Always throws <see cref="T:System.NotSupportedException"/> + </summary> + <exception cref="T:System.NotSupportedException"></exception> + <returns></returns> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.Seek(System.Int64,System.IO.SeekOrigin)"> + <summary> + Always throws <see cref="T:System.NotSupportedException"/> + </summary> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.SetLength(System.Int64)"> + <summary> + Always throws <see cref="T:System.NotSupportedException"/> + </summary> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.DisposeAsync"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnBufferedStream.FlushAsync(System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.IO.VnMemoryStream"> + <summary> + Provides an unmanaged memory stream. Desigend to help reduce garbage collector load for + high frequency memory operations. + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.ConsumeHandle(VNLib.Utils.Memory.MemoryHandle{System.Byte},System.Int64,System.Boolean)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.IO.VnMemoryStream"/> pointing to the begining of memory, and consumes the handle. + </summary> + <param name="handle"><see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> to consume</param> + <param name="length">Length of the stream</param> + <param name="readOnly">Should the stream be readonly?</param> + <exception cref="T:System.ArgumentException"></exception> + <returns>A <see cref="T:VNLib.Utils.IO.VnMemoryStream"/> wrapper to access the handle data</returns> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.CreateReadonly(VNLib.Utils.IO.VnMemoryStream)"> + <summary> + Converts a writable <see cref="T:VNLib.Utils.IO.VnMemoryStream"/> to readonly to allow shallow copies + </summary> + <param name="stream">The stream to make readonly</param> + <returns>The readonly stream</returns> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.#ctor"> + <summary> + Creates a new memory stream + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.#ctor(VNLib.Utils.Memory.IUnmangedHeap)"> + <summary> + Create a new memory stream where buffers will be allocated from the specified heap + </summary> + <param name="heap"><see cref="T:VNLib.Utils.Memory.PrivateHeap"/> to allocate memory from</param> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.Int64,System.Boolean)"> + <summary> + Creates a new memory stream and pre-allocates the internal + buffer of the specified size on the specified heap to avoid resizing. + </summary> + <param name="heap"><see cref="T:VNLib.Utils.Memory.PrivateHeap"/> to allocate memory from</param> + <param name="bufferSize">Number of bytes (length) of the stream if known</param> + <param name="zero">Zero memory allocations during buffer expansions</param> + <exception cref="T:System.InsufficientMemoryException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.ReadOnlySpan{System.Byte})"> + <summary> + Creates a new memory stream from the data provided + </summary> + <param name="heap"><see cref="T:VNLib.Utils.Memory.PrivateHeap"/> to allocate memory from</param> + <param name="data">Initial data</param> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.#ctor(VNLib.Utils.Memory.MemoryHandle{System.Byte},System.Int64,System.Boolean,System.Boolean)"> + <summary> + WARNING: Dangerous constructor, make sure read-only and owns hanlde are set accordingly + </summary> + <param name="buffer">The buffer to referrence directly</param> + <param name="length">The length property of the stream</param> + <param name="readOnly">Is the stream readonly (should mostly be true!)</param> + <param name="ownsHandle">Does the new stream own the memory -> <paramref name="buffer"/></param> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.LenToPosDiff"> + <summary> + UNSAFE Number of bytes between position and length. Never negative + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.GetReadonlyShallowCopy"> + <summary> + If the current stream is a readonly stream, creates an unsafe shallow copy for reading only. + </summary> + <returns>New stream shallow copy of the internal stream</returns> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.CopyTo(System.IO.Stream,System.Int32)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.CanRead"> + <summary> + <inheritdoc/> + <para> + This propery is always true + </para> + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.CanSeek"> + <summary> + <inheritdoc/> + <para> + This propery is always true + </para> + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.CanWrite"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.Length"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnMemoryStream.Position"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Close"> + <summary> + Closes the stream and frees the internal allocated memory blocks + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Flush"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.FlushAsync(System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Read(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Read(System.Span{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.ReadAsync(System.Memory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.ReadAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Seek(System.Int64,System.IO.SeekOrigin)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.SetLength(System.Int64)"> + <summary> + Resizes the internal buffer to the exact size (in bytes) of the + value argument. A value of 0 will free the entire buffer. A value + greater than zero will resize the buffer (and/or alloc) + </summary> + <param name="value">The size of the stream (and internal buffer)</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Write(System.Byte[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Write(System.ReadOnlySpan{System.Byte})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.WriteAsync(System.Byte[],System.Int32,System.Int32,System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.WriteAsync(System.ReadOnlyMemory{System.Byte},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.WriteByte(System.Byte)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.ToArray"> + <summary> + Allocates and copies internal buffer to new managed byte[] + </summary> + <returns>Copy of internal buffer</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.AsSpan"> + <summary> + Returns a <see cref="T:System.ReadOnlySpan`1"/> window over the data within the entire stream + </summary> + <returns>A <see cref="T:System.ReadOnlySpan`1"/> of the data within the entire stream</returns> + <exception cref="T:System.OverflowException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.Clone"> + <summary> + If the current stream is a readonly stream, creates a shallow copy for reading only. + </summary> + <returns>New stream shallow copy of the internal stream</returns> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnMemoryStream.DisposeAsync"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.IO.VnStreamReader"> + <summary> + Binary based buffered text reader, optimized for reading network streams + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnStreamReader.BaseStream"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnStreamReader.Encoding"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnStreamReader.Available"> + <summary> + Number of available bytes of buffered data within the current buffer window + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnStreamReader.LineTermination"> + <summary> + Gets or sets the line termination used to deliminate a line of data + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.#ctor(System.IO.Stream,System.Text.Encoding,System.Int32)"> + <summary> + Creates a new <see cref="T:System.IO.TextReader"/> that reads encoded data from the base. + Internal buffers will be alloced from <see cref="P:System.Buffers.ArrayPool`1.Shared"/> + </summary> + <param name="baseStream">The underlying stream to read data from</param> + <param name="enc">The <see cref="P:VNLib.Utils.IO.VnStreamReader.Encoding"/> to use when reading from the stream</param> + <param name="bufferSize">The size of the internal binary buffer</param> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.InitializeBuffer(System.Int32)"> + <summary> + Invoked by the constuctor method to allocte the internal buffer with the specified buffer size. + </summary> + <param name="bufferSize">The requested size of the buffer to alloc</param> + <remarks>By default requests the buffer from the <see cref="P:System.Buffers.ArrayPool`1.Shared"/> instance</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.ReadLineAsync"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.FillBufferAsync(System.Threading.CancellationToken)"> + <summary> + Fill the end of the current buffer with data from the stream and update the positions + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.Read(System.Char[],System.Int32,System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.Read(System.Span{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.Close"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamReader.ClearBuffer"> + <summary> + Resets the internal buffer window + </summary> + </member> + <member name="T:VNLib.Utils.IO.VnStreamWriter"> + <summary> + Provides a memory optimized <see cref="T:System.IO.TextWriter"/> implementation. Optimized for writing + to network streams + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnStreamWriter.BaseStream"> + <summary> + Gets the underlying stream that interfaces with the backing store + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnStreamWriter.Encoding"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.IO.VnStreamWriter.LineTermination"> + <summary> + Line termination to use when writing lines to the output + </summary> + </member> + <member name="P:VNLib.Utils.IO.VnStreamWriter.NewLine"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.#ctor(System.IO.Stream,System.Text.Encoding,System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.IO.VnStreamWriter"/> that writes formatted data + to the specified base stream + </summary> + <param name="baseStream">The stream to write data to</param> + <param name="encoding">The <see cref="P:VNLib.Utils.IO.VnStreamWriter.Encoding"/> to use when writing data</param> + <param name="bufferSize">The size of the internal buffer used to buffer binary data before writing to the base stream</param> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.InitializeBuffer(System.Int32)"> + <summary> + Invoked by the constuctor method to allocte the internal buffer with the specified buffer size. + </summary> + <param name="bufferSize">The requested size of the buffer to alloc</param> + <remarks>By default requests the buffer from the <see cref="P:System.Buffers.MemoryPool`1.Shared"/> instance</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Write(System.Byte)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Write(System.Char)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Write(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Write(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Write(System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteAsync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteAsyncSync(System.ReadOnlyMemory{System.Char},System.Threading.CancellationToken)"> + <summary> + Asynchronously writes a character memory region to the text stream + </summary> + <param name="value">The character buffer to write to encode and write to the stream</param> + <param name="cancellationToken">A token to cancel the async operation</param> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that represents the asynchronous write operation</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteLine"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteLine(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteLine(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.WriteLine(System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Flush"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.FlushWriterAsync(System.Threading.CancellationToken)"> + <summary> + Asynchronously flushes the internal buffers to the <see cref="P:VNLib.Utils.IO.VnStreamWriter.BaseStream"/>, and resets the internal buffer state + </summary> + <returns>A <see cref="T:System.Threading.Tasks.ValueTask"/> that represents the asynchronous flush operation</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.FlushAsync"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Reset"> + <summary> + Resets internal properies for resuse + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Close"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.IO.VnStreamWriter.DisposeAsync"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.IO.VnTextReaderExtensions"> + <summary> + Extension methods to help reuse code for used TextReader implementations + </summary> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadLine``1(``0@,System.Span{System.Char})"> + <summary> + Attempts to read a line from the stream and store it in the specified buffer + </summary> + <param name="reader"></param> + <param name="charBuffer">The character buffer to write data to</param> + <returns>Returns the number of bytes read, <see cref="F:VNLib.Utils.IO.VnTextReaderExtensions.E_BUFFER_TOO_SMALL"/> + if the buffer was not large enough, 0 if no data was available</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <remarks>Allows reading lines of data from the stream without allocations</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadLine``1(``0,System.Span{System.Char})"> + <summary> + Attempts to read a line from the stream and store it in the specified buffer + </summary> + <param name="reader"></param> + <param name="charBuffer">The character buffer to write data to</param> + <returns>Returns the number of bytes read, <see cref="F:VNLib.Utils.IO.VnTextReaderExtensions.E_BUFFER_TOO_SMALL"/> + if the buffer was not large enough, 0 if no data was available</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + <remarks>Allows reading lines of data from the stream without allocations</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadRemaining``1(``0@,System.Byte[],System.Int32,System.Int32)"> + <summary> + Fill a buffer with reamining buffered data + </summary> + <param name="reader"></param> + <param name="buffer">Buffer to copy data to</param> + <param name="offset">Offset in buffer to begin writing</param> + <param name="count">Number of bytes to read</param> + <returns>The number of bytes copied to the input buffer</returns> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadRemaining``1(``0,System.Byte[],System.Int32,System.Int32)"> + <summary> + Fill a buffer with reamining buffered data + </summary> + <param name="reader"></param> + <param name="buffer">Buffer to copy data to</param> + <param name="offset">Offset in buffer to begin writing</param> + <param name="count">Number of bytes to read</param> + <returns>The number of bytes copied to the input buffer</returns> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadRemaining``1(``0@,System.Span{System.Byte})"> + <summary> + Fill a buffer with reamining buffered data, up to + the size of the supplied buffer + </summary> + <param name="reader"></param> + <param name="buffer">Buffer to copy data to</param> + <returns>The number of bytes copied to the input buffer</returns> + <remarks>You should use the <see cref="P:VNLib.Utils.IO.IVnTextReader.Available"/> property to know how much remaining data is buffered</remarks> + </member> + <member name="M:VNLib.Utils.IO.VnTextReaderExtensions.ReadRemaining``1(``0,System.Span{System.Byte})"> + <summary> + Fill a buffer with reamining buffered data, up to + the size of the supplied buffer + </summary> + <param name="reader"></param> + <param name="buffer">Buffer to copy data to</param> + <returns>The number of bytes copied to the input buffer</returns> + <remarks>You should use the <see cref="P:VNLib.Utils.IO.IVnTextReader.Available"/> property to know how much remaining data is buffered</remarks> + </member> + <member name="T:VNLib.Utils.Logging.ILogProvider"> + <summary> + Self-contained logging interface that allows for applications events to be written to an + output source + </summary> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.Flush"> + <summary> + Flushes any buffers to the output source + </summary> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String)"> + <summary> + Writes the string to the log with the specified priority log level + </summary> + <param name="level">The log priority level</param> + <param name="value">The message to print</param> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.Write(VNLib.Utils.Logging.LogLevel,System.Exception,System.String)"> + <summary> + Writes the exception and optional string to the log with the specified priority log level + </summary> + <param name="level">The log priority level</param> + <param name="exception">An exception object to write</param> + <param name="value">The message to print</param> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String,System.Object[])"> + <summary> + Writes the template string and params arguments to the log with the specified priority log level + </summary> + <param name="level">The log priority level</param> + <param name="value">The log template string</param> + <param name="args">Variable length array of objects to log with the specified templatre</param> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.Write(VNLib.Utils.Logging.LogLevel,System.String,System.ValueType[])"> + <summary> + Writes the template string and params arguments to the log with the specified priority log level + </summary> + <param name="level">The log priority level</param> + <param name="value">The log template string</param> + <param name="args">Variable length array of objects to log with the specified templatre</param> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.GetLogProvider"> + <summary> + Gets the underlying log source + </summary> + <returns>The underlying log source</returns> + </member> + <member name="M:VNLib.Utils.Logging.ILogProvider.GetLogProvider``1"> + <summary> + Gets the underlying log source + </summary> + <returns>The underlying log source</returns> + </member> + <member name="T:VNLib.Utils.Logging.LoggerExtensions"> + <summary> + Extension helper methods for writing logs to a <see cref="T:VNLib.Utils.Logging.ILogProvider"/> + </summary> + </member> + <member name="P:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.CacheTimerTimeout"> + <summary> + The default time period for the timer's initial timeout state.This is used for catching fault conditions + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.Prepare"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.Release"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.WaitOne(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.WaitOneAsync(System.Threading.CancellationToken)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.CacheTimerElapsed"> + <summary> + Invoked when the timer has elapsed + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.ResumeTimer(System.TimeSpan)"> + <summary> + Resumes a previously stopped timer to the specified timeout period + </summary> + <param name="timeout">The amount of time the timer should wait before invoking the <see cref="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.CacheTimerElapsed"/> method</param> + <returns>The result of the timer reset</returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.CacheableAsyncExclusive`1.DisposeAsync"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ICacheable"> + <summary> + Represents a cacheable entity with an expiration + </summary> + </member> + <member name="P:VNLib.Utils.Memory.Caching.ICacheable.Expires"> + <summary> + A <see cref="T:System.DateTime"/> value that the entry is no longer valid + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ICacheable.Evicted"> + <summary> + Invoked when a collection occurs + </summary> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ICacheHolder"> + <summary> + Exposes basic control of classes that manage private caches + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ICacheHolder.CacheClear"> + <summary> + Clears all held caches without causing application stopping effects. + </summary> + <remarks>This is a safe "light" cache clear</remarks> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ICacheHolder.CacheHardClear"> + <summary> + Performs all necessary actions to clear all held caches immediatly. + </summary> + <remarks>A "hard" cache clear/reset regardless of cost</remarks> + </member> + <member name="T:VNLib.Utils.Memory.Caching.IReusable"> + <summary> + Allows for use within a <see cref="T:VNLib.Utils.Memory.Caching.ReusableStore`1"/>, this object is intended to be reused heavily + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.IReusable.Prepare"> + <summary> + The instance should prepare itself for use (or re-use) + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.IReusable.Release"> + <summary> + The intance is being returned and should determine if it's state is reusabled + </summary> + <returns>true if the instance can/should be reused, false if it should not be reused</returns> + </member> + <member name="T:VNLib.Utils.Memory.Caching.LRUCache`2"> + <summary> + A base class for a Least Recently Used cache + </summary> + <typeparam name="TKey">The key for O(1) lookups</typeparam> + <typeparam name="TValue">The value to store within cache</typeparam> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.#ctor"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.#ctor(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.#ctor(System.Collections.Generic.IEqualityComparer{`0})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0})"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUCache`2.MaxCapacity"> + <summary> + The maximum number of items to store in LRU cache + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.Add(System.Collections.Generic.KeyValuePair{`0,`1})"> + <summary> + Adds a new record to the LRU cache + </summary> + <param name="item">A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> to add to the cache store</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.TryGetValue(`0,`1@)"> + <summary> + Attempts to get a value by the given key. + </summary> + <param name="key">The key identifying the value to store</param> + <param name="value">The value to store</param> + <returns>A value indicating if the value was found in the store</returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.Evicted(System.Collections.Generic.KeyValuePair{`0,`1})"> + <summary> + Invoked when a record is evicted from the cache + </summary> + <param name="evicted">The record that is being evicted</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUCache`2.CacheMiss(`0,`1@)"> + <summary> + Invoked when an entry was requested and was not found in cache. + </summary> + <param name="key">The key identifying the record to lookup</param> + <param name="value">The found value matching the key</param> + <returns>A value indicating if the record was found</returns> + </member> + <member name="T:VNLib.Utils.Memory.Caching.LRUDataStore`2"> + <summary> + A Least Recently Used store base class for E2E O(1) operations + </summary> + <typeparam name="TKey">A key used for O(1) lookups</typeparam> + <typeparam name="TValue">A value to store</typeparam> + </member> + <member name="F:VNLib.Utils.Memory.Caching.LRUDataStore`2.LookupTable"> + <summary> + A lookup table that provides O(1) access times for key-value lookups + </summary> + </member> + <member name="F:VNLib.Utils.Memory.Caching.LRUDataStore`2.List"> + <summary> + A linked list that tracks the least recently used item. + New items (or recently access items) are moved to the end of the list. + The head contains the least recently used item + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.#ctor"> + <summary> + Initializes an empty <see cref="T:VNLib.Utils.Memory.Caching.LRUDataStore`2"/> + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.#ctor(System.Int32)"> + <summary> + Initializes an empty <see cref="T:VNLib.Utils.Memory.Caching.LRUDataStore`2"/> and sets + the lookup table's inital capacity + </summary> + <param name="initialCapacity">LookupTable initial capacity</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.#ctor(System.Collections.Generic.IEqualityComparer{`0})"> + <summary> + Initializes an empty <see cref="T:VNLib.Utils.Memory.Caching.LRUDataStore`2"/> and uses the + specified keycomparison + </summary> + <param name="keyComparer">A <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> used by the Lookuptable to compare keys</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0})"> + <summary> + Initializes an empty <see cref="T:VNLib.Utils.Memory.Caching.LRUDataStore`2"/> and uses the + specified keycomparison, and sets the lookup table's initial capacity + </summary> + <param name="initialCapacity">LookupTable initial capacity</param> + <param name="keyComparer">A <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> used by the Lookuptable to compare keys</param> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUDataStore`2.Item(`0)"> + <summary> + Gets or sets a value within the LRU cache. + </summary> + <param name="key">The key identifying the value</param> + <returns>The value stored at the given key</returns> + <remarks>Items are promoted in the store when accessed</remarks> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUDataStore`2.Keys"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUDataStore`2.Values"> + <inheritdoc/> + <exception cref="T:System.NotImplementedException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUDataStore`2.Count"> + <summary> + Gets the number of items within the LRU store + </summary> + </member> + <member name="P:VNLib.Utils.Memory.Caching.LRUDataStore`2.IsReadOnly"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Add(`0,`1)"> + <summary> + Adds the specified record to the store and places it at the end of the LRU queue + </summary> + <param name="key">The key identifying the record</param> + <param name="value">The value to store at the key</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Remove(System.Collections.Generic.KeyValuePair{`0,`1})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.System#Collections#IEnumerable#GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.ContainsKey(`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Add(System.Collections.Generic.KeyValuePair{`0,`1})"> + <summary> + Adds the specified record to the store and places it at the end of the LRU queue + </summary> + <param name="item">The item to add</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Clear"> + <summary> + Removes all elements from the LRU store + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1})"> + <summary> + Determines if the <see cref="T:System.Collections.Generic.KeyValuePair`2"/> exists in the store + </summary> + <param name="item">The record to search for</param> + <returns>True if the key was found in the store and the value equals the stored value, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.Remove(`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.LRUDataStore`2.TryGetValue(`0,`1@)"> + <summary> + Tries to get a value from the store with its key. Found items are promoted + </summary> + <param name="key">The key identifying the value</param> + <param name="value">The found value</param> + <returns>A value indicating if the element was found in the store</returns> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ObjectRental`1"> + <summary> + Provides concurrent storage for reusable objects to be rented and returned. This class + and its members is thread-safe + </summary> + <typeparam name="T">The data type to reuse</typeparam> + </member> + <member name="F:VNLib.Utils.Memory.Caching.ObjectRental`1.INITIAL_STRUCTURE_SIZE"> + <summary> + The initial data-structure capacity if quota is not defined + </summary> + </member> + <member name="F:VNLib.Utils.Memory.Caching.ObjectRental`1.IsDisposableType"> + <summary> + Is the object type in the current store implement the Idisposable interface? + </summary> + </member> + <member name="F:VNLib.Utils.Memory.Caching.ObjectRental`1.QuotaLimit"> + <summary> + The maximum number of objects that will be cached. + Once this threshold has been reached, objects are + no longer stored + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.#ctor(System.Func{`0},System.Action{`0},System.Action{`0},System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> store with the rent/return callback methods + </summary> + <param name="constructor"></param> + <param name="rentCb">The pre-retnal preperation action</param> + <param name="returnCb">The pre-return cleanup action</param> + <param name="quota"></param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.Rent"> + <summary> + Gets an object from the store, or creates a new one if none are available + </summary> + <returns>An instance of <typeparamref name="T"/> from the store if available or a new instance if none were available</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.Lease"> + <summary> + Leases an object from the store that will be returned to the store when disposed + </summary> + <returns>A new <see cref="T:VNLib.Utils.OpenResourceHandle`1"/> for the leased object</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.Return(`0)"> + <summary> + Returns a rented object back to the rental store for reuse + </summary> + <param name="item">The previously rented item</param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.CacheClear"> + <remarks> + NOTE: If <typeparamref name="T"/> implements <see cref="T:System.IDisposable"/> + interface, this method does nothing + </remarks> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.CacheHardClear"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ObjectRental"> + <summary> + Provides concurrent storage for reusable objects to be rented and returned. This class + and its members is thread-safe + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.Create``1(System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> store + </summary> + <param name="quota">The maximum number of elements that will be cached</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.Create``1(System.Action{``0},System.Action{``0},System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> store with generic rental and return callback handlers + </summary> + <param name="rentCb">Function responsible for preparing an instance to be rented</param> + <param name="returnCb">Function responsible for cleaning up an instance before reuse</param> + <param name="quota">The maximum number of elements that will be cached</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.Create``1(System.Func{``0},System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> store with a generic constructor function + </summary> + <param name="constructor">The function invoked to create a new instance when required</param> + <param name="quota">The maximum number of elements that will be cached</param> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.Create``1(System.Func{``0},System.Action{``0},System.Action{``0},System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> store with generic rental and return callback handlers + </summary> + <param name="constructor">The function invoked to create a new instance when required</param> + <param name="rentCb">Function responsible for preparing an instance to be rented</param> + <param name="returnCb">Function responsible for cleaning up an instance before reuse</param> + <param name="quota">The maximum number of elements that will be cached</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocal``1(System.Func{``0},System.Action{``0},System.Action{``0})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"/> store with generic rental and return callback handlers + </summary> + <typeparam name="TNew"></typeparam> + <param name="constructor">The function invoked to create a new instance when required</param> + <param name="rentCb">Function responsible for preparing an instance to be rented</param> + <param name="returnCb">Function responsible for cleaning up an instance before reuse</param> + <returns>The initialized store</returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocal``1(System.Action{``0},System.Action{``0})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"/> store with generic rental and return callback handlers + </summary> + <param name="rentCb">Function responsible for preparing an instance to be rented</param> + <param name="returnCb">Function responsible for cleaning up an instance before reuse</param> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocal``1"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"/> store + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocal``1(System.Func{``0})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"/> store with a generic constructor function + </summary> + <param name="constructor">The function invoked to create a new instance when required</param> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateReusable``1(System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ReusableStore`1"/> instance with a parameterless constructor + </summary> + <typeparam name="T">The <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</typeparam> + <param name="quota">The maximum number of elements that will be cached</param> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateReusable``1(System.Func{``0},System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ReusableStore`1"/> instance with the specified constructor + </summary> + <typeparam name="T">The <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</typeparam> + <param name="constructor">The constructor function invoked to create new instances of the <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</param> + <param name="quota">The maximum number of elements that will be cached</param> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocalReusable``1"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1"/> instance with a parameterless constructor + </summary> + <typeparam name="T">The <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</typeparam> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ObjectRental.CreateThreadLocalReusable``1(System.Func{``0})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1"/> instance with the specified constructor + </summary> + <typeparam name="T">The <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</typeparam> + <param name="constructor">The constructor function invoked to create new instances of the <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> type</param> + <returns></returns> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ReusableStore`1"> + <summary> + A reusable object store that extends <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/>, that allows for objects to be reused heavily + </summary> + <typeparam name="T">A reusable object</typeparam> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ReusableStore`1.Rent"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ReusableStore`1.Return(`0)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"> + <summary> + Derrives from <see cref="T:VNLib.Utils.Memory.Caching.ObjectRental`1"/> to provide object rental syntax for <see cref="T:System.Threading.ThreadLocal`1"/> + storage + </summary> + <typeparam name="T">The data type to store</typeparam> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1.Rent"> + <summary> + "Rents" or creates an object for the current thread + </summary> + <returns>The new or stored instanced</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1.Return(`0)"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1"> + <summary> + A reusable object store that extends <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalObjectStorage`1"/>, that allows for objects to be reused heavily + in a thread-local cache + </summary> + <typeparam name="T">A reusable object</typeparam> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1.#ctor(System.Func{`0})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1"/> instance + </summary> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1.Rent"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.Caching.ThreadLocalReusableStore`1.Return(`0)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.IMemoryHandle`1"> + <summary> + Represents a handle for safe access to memory managed/unamanged memory + </summary> + <typeparam name="T">The type this handle represents</typeparam> + </member> + <member name="P:VNLib.Utils.Memory.IMemoryHandle`1.IntLength"> + <summary> + The size of the block as an integer + </summary> + <exception cref="T:System.OverflowException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.IMemoryHandle`1.Length"> + <summary> + The number of elements in the block + </summary> + </member> + <member name="P:VNLib.Utils.Memory.IMemoryHandle`1.Span"> + <summary> + Gets the internal block as a span + </summary> + </member> + <member name="T:VNLib.Utils.Memory.IStringSerializeable"> + <summary> + A interface that provides indempodent abstractions for compiling an instance + to its representitive string. + </summary> + </member> + <member name="M:VNLib.Utils.Memory.IStringSerializeable.Compile"> + <summary> + Compiles the current instance into its safe string representation + </summary> + <returns>A string of the desired representation of the current instance</returns> + </member> + <member name="M:VNLib.Utils.Memory.IStringSerializeable.Compile(VNLib.Utils.Memory.VnBufferWriter{System.Char}@)"> + <summary> + Compiles the current instance into its safe string representation, and writes its + contents to the specified buffer writer + </summary> + <param name="writer">The ouput writer to write the serialized representation to</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.IStringSerializeable.Compile(System.Span{System.Char}@)"> + <summary> + Compiles the current instance into its safe string representation, and writes its + contents to the specified buffer writer + </summary> + <param name="buffer">The buffer to write the serialized representation to</param> + <returns>The number of characters written to the buffer</returns> + </member> + <member name="T:VNLib.Utils.Memory.IUnmangedHeap"> + <summary> + Abstraction for handling (allocating, resizing, and freeing) blocks of unmanaged memory from an unmanged heap + </summary> + </member> + <member name="M:VNLib.Utils.Memory.IUnmangedHeap.Alloc(System.UInt64,System.UInt64,System.Boolean)"> + <summary> + Allocates a block of memory from the heap and returns a pointer to the new memory block + </summary> + <param name="size">The size (in bytes) of the element</param> + <param name="elements">The number of elements to allocate</param> + <param name="zero">An optional parameter to zero the block of memory</param> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.IUnmangedHeap.Resize(System.IntPtr@,System.UInt64,System.UInt64,System.Boolean)"> + <summary> + Resizes the allocated block of memory to the new size + </summary> + <param name="block">The block to resize</param> + <param name="elements">The new number of elements</param> + <param name="size">The size (in bytes) of the type</param> + <param name="zero">An optional parameter to zero the block of memory</param> + </member> + <member name="M:VNLib.Utils.Memory.IUnmangedHeap.Free(System.IntPtr@)"> + <summary> + Free's a previously allocated block of memory + </summary> + <param name="block">The memory to be freed</param> + <returns>A value indicating if the free operation succeeded</returns> + </member> + <member name="T:VNLib.Utils.Memory.Memory"> + <summary> + Provides optimized cross-platform maanged/umanaged safe/unsafe memory operations + </summary> + </member> + <member name="F:VNLib.Utils.Memory.Memory.SHARED_HEAP_INIT_SIZE"> + <summary> + Initial shared heap size (bytes) + </summary> + </member> + <member name="F:VNLib.Utils.Memory.Memory.MAX_UNSAFE_POOL_SIZE"> + <summary> + The maximum buffer size requested by <see cref="M:VNLib.Utils.Memory.Memory.UnsafeAlloc``1(System.Int32,System.Boolean)"/> + that will use the array pool before falling back to the <see cref="P:VNLib.Utils.Memory.Memory.Shared"/>. + heap. + </summary> + </member> + <member name="P:VNLib.Utils.Memory.Memory.Shared"> + <summary> + Provides a shared heap instance for the process to allocate memory from. + </summary> + <remarks> + The backing heap + is determined by the OS type and process environment varibles. + </remarks> + </member> + <member name="M:VNLib.Utils.Memory.Memory.InitializeNewHeapForProcess"> + <summary> + Initializes a new <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> determined by compilation/runtime flags + and operating system type for the current proccess. + </summary> + <returns>An <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> for the current process</returns> + <exception cref="T:System.SystemException"></exception> + <exception cref="T:System.DllNotFoundException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Memory.UnsafeZeroMemory``1(System.ReadOnlySpan{``0})"> + <summary> + Zeros a block of memory of umanged type. If Windows is detected at runtime, calls RtlSecureZeroMemory Win32 function + </summary> + <typeparam name="T">Unmanged datatype</typeparam> + <param name="block">Block of memory to be cleared</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.UnsafeZeroMemory``1(System.ReadOnlyMemory{``0})"> + <summary> + Zeros a block of memory of umanged type. If Windows is detected at runtime, calls RtlSecureZeroMemory Win32 function + </summary> + <typeparam name="T">Unmanged datatype</typeparam> + <param name="block">Block of memory to be cleared</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.InitializeBlock``1(System.Span{``0})"> + <summary> + Initializes a block of memory with zeros + </summary> + <typeparam name="T">The unmanaged</typeparam> + <param name="block">The block of memory to initialize</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.InitializeBlock``1(System.Memory{``0})"> + <summary> + Initializes a block of memory with zeros + </summary> + <typeparam name="T">The unmanaged</typeparam> + <param name="block">The block of memory to initialize</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.ZeroStruct``1(System.IntPtr)"> + <summary> + Zeroes a block of memory pointing to the structure + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="block">The pointer to the allocated structure</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.ZeroStruct``1(System.Void*)"> + <summary> + Zeroes a block of memory pointing to the structure + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="structPtr">The pointer to the allocated structure</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.ZeroStruct``1(``0*)"> + <summary> + Zeroes a block of memory pointing to the structure + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="structPtr">The pointer to the allocated structure</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.Copy``1(System.ReadOnlySpan{``0},VNLib.Utils.Memory.MemoryHandle{``0},System.Int64)"> + <summary> + Copies data from source memory to destination memory of an umanged data type + </summary> + <typeparam name="T">Unmanged type</typeparam> + <param name="source">Source data <see cref="T:System.ReadOnlySpan`1"/></param> + <param name="dest">Destination <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></param> + <param name="destOffset">Dest offset</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Memory.Copy``1(System.ReadOnlyMemory{``0},VNLib.Utils.Memory.MemoryHandle{``0},System.Int64)"> + <summary> + Copies data from source memory to destination memory of an umanged data type + </summary> + <typeparam name="T">Unmanged type</typeparam> + <param name="source">Source data <see cref="T:System.ReadOnlyMemory`1"/></param> + <param name="dest">Destination <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></param> + <param name="destOffset">Dest offset</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Memory.Copy``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64,System.Span{``0},System.Int32,System.Int32)"> + <summary> + Copies data from source memory to destination memory of an umanged data type + </summary> + <typeparam name="T">Unmanged type</typeparam> + <param name="source">Source data <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></param> + <param name="sourceOffset">Number of elements to offset source data</param> + <param name="dest">Destination <see cref="T:System.Span`1"/></param> + <param name="destOffset">Dest offset</param> + <param name="count">Number of elements to copy</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Memory.Copy``1(VNLib.Utils.Memory.MemoryHandle{``0},System.Int64,System.Memory{``0},System.Int32,System.Int32)"> + <summary> + Copies data from source memory to destination memory of an umanged data type + </summary> + <typeparam name="T">Unmanged type</typeparam> + <param name="source">Source data <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/></param> + <param name="sourceOffset">Number of elements to offset source data</param> + <param name="dest">Destination <see cref="T:System.Memory`1"/></param> + <param name="destOffset">Dest offset</param> + <param name="count">Number of elements to copy</param> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.Memory.Copy(System.IO.Stream,System.Int64,System.IO.Stream,System.Int64,System.Int64)"> + <summary> + Copies data from one stream to another in specified blocks + </summary> + <param name="source">Source memory</param> + <param name="srcOffset">Source offset</param> + <param name="dest">Destination memory</param> + <param name="destOffst">Destination offset</param> + <param name="count">Number of elements to copy</param> + </member> + <member name="M:VNLib.Utils.Memory.Memory.UnsafeAlloc``1(System.Int32,System.Boolean)"> + <summary> + Allocates a block of unmanaged, or pooled manaaged memory depending on + compilation flags and runtime unamanged allocators. + </summary> + <typeparam name="T">The unamanged type to allocate</typeparam> + <param name="elements">The number of elements of the type within the block</param> + <param name="zero">Flag to zero elements during allocation before the method returns</param> + <returns>A handle to the block of memory</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Utils.Memory.MemoryHandle`1"> + <summary> + Provides a wrapper for using umanged memory handles from an assigned <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> for <see cref="T:System.Runtime.InteropServices.UnmanagedType"/> types + </summary> + <remarks> + Handles are configured to address blocks larger than 2GB, + so some properties may raise exceptions if large blocks are used. + </remarks> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.Base"> + <summary> + New <typeparamref name="T"/>* pointing to the base of the allocated block + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.BasePtr"> + <summary> + New <see cref="T:System.IntPtr"/> pointing to the base of the allocated block + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.Span"> + <summary> + Gets a span over the entire allocated block + </summary> + <returns>A <see cref="T:System.Span`1"/> over the internal data</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.OverflowException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.Length"> + <summary> + Number of elements allocated to the current instance + </summary> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.IntLength"> + <summary> + Number of elements in the memory block casted to an integer + </summary> + <exception cref="T:System.OverflowException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.MemoryHandle`1.ByteLength"> + <summary> + Number of bytes allocated to the current instance + </summary> + <exception cref="T:System.OverflowException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.IntPtr,System.UInt64,System.Boolean)"> + <summary> + Creates a new memory handle, for which is holds ownership, and allocates the number of elements specified on the heap. + </summary> + <param name="heap">The heap to allocate/deallocate memory from</param> + <param name="elements">Number of elements to allocate</param> + <param name="zero">Zero all memory during allocations from heap</param> + <param name="initial">The initial block of allocated memory to wrap</param> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.Resize(System.UInt64)"> + <summary> + Resizes the current handle on the heap + </summary> + <param name="elements">Positive number of elemnts the current handle should referrence</param> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.GetOffset(System.UInt64)"> + <summary> + Gets an offset pointer from the base postion to the number of bytes specified. Performs bounds checks + </summary> + <param name="elements">Number of elements of type to offset</param> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + <returns><typeparamref name="T"/> pointer to the memory offset specified</returns> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.ReleaseHandle"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.Equals(VNLib.Utils.Memory.MemoryHandle{`0})"> + <summary> + Determines if the memory blocks are equal by comparing their base addresses. + </summary> + <param name="other"><see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> to compare</param> + <returns>true if the block of memory is the same, false if the handle's size does not + match or the base addresses do not match even if they point to an overlapping address space</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.GetHashCode"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.MemoryHandle`1.op_Implicit(VNLib.Utils.Memory.MemoryHandle{`0})~System.Span{`0}"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.PrivateBuffersMemoryPool`1"> + <summary> + Provides a <see cref="T:System.Buffers.MemoryPool`1"/> wrapper for using unmanged <see cref="T:VNLib.Utils.Memory.PrivateHeap"/>s + </summary> + <typeparam name="T">Unamanged memory type to provide data memory instances from</typeparam> + </member> + <member name="P:VNLib.Utils.Memory.PrivateBuffersMemoryPool`1.MaxBufferSize"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateBuffersMemoryPool`1.Rent(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateBuffersMemoryPool`1.Rent``1(System.Int32)"> + <summary> + Allocates a new <see cref="T:System.Buffers.MemoryManager`1"/> of a different data type from the pool + </summary> + <typeparam name="DifType">The unmanaged data type to allocate for</typeparam> + <param name="minBufferSize">Minumum size of the buffer</param> + <returns>The memory owner of a different data type</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateBuffersMemoryPool`1.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.PrivateHeap"> + <summary> + <para> + Provides a win32 private heap managed wrapper class + </para> + </summary> + <remarks> + <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> implements <see cref="T:System.Runtime.InteropServices.SafeHandle"/> and tracks allocated blocks by its + referrence counter. Allocations increment the count, and free's decrement the count, so the heap may + be disposed safely + </remarks> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.Create(System.UInt64,System.UInt64,System.Int64)"> + <summary> + Create a new <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> with the specified sizes and flags + </summary> + <param name="initialSize">Intial size of the heap</param> + <param name="maxHeapSize">Maximum size allowed for the heap (disabled = 0, default)</param> + <param name="flags">Defalt heap flags to set globally for all blocks allocated by the heap (default = 0)</param> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.ConsumeExisting(System.IntPtr)"> + <summary> + LIFETIME WARNING. Consumes a valid win32 handle and will manage it's lifetime once constructed. + Locking and memory blocks will attempt to be allocated from this heap handle. + </summary> + <param name="win32HeapHandle">An open and valid handle to a win32 private heap</param> + <returns>A wrapper around the specified heap</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.HeapSize(System.IntPtr@)"> + <summary> + Retrieves the size of a memory block allocated from the current heap. + </summary> + <param name="block">The pointer to a block of memory to get the size of</param> + <returns>The size of the block of memory, (SIZE_T)-1 if the operation fails</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.Validate(System.IntPtr@)"> + <summary> + Validates the specified block of memory within the current heap instance. This function will block hte + </summary> + <param name="block">Pointer to the block of memory to validate</param> + <returns>True if the block is valid, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.Validate"> + <summary> + Validates the current heap instance. The function scans all the memory blocks in the heap and verifies that the heap control structures maintained by + the heap manager are in a consistent state. + </summary> + <returns>If the specified heap or memory block is valid, the return value is nonzero.</returns> + <remarks>This can be a consuming operation which will block all allocations</remarks> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.ReleaseHandle"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.AllocBlock(System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.FreeBlock(System.IntPtr)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateHeap.ReAllocBlock(System.IntPtr,System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.PrivateString"> + <summary> + Provides a wrapper class that will have unsafe access to the memory of + the specified <see cref="T:System.String"/> provided during object creation. + </summary> + <remarks>The value of the memory the protected string points to is undefined when the instance is disposed</remarks> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.#ctor(System.String@,System.Boolean)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.PrivateString"/> over the specified string and the memory it points to. + </summary> + <param name="data">The <see cref="T:System.String"/> instance pointing to the memory to protect</param> + <param name="ownsReferrence">Does the current instance "own" the memory the data parameter points to</param> + <remarks>You should no longer reference the input string directly</remarks> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Equals(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Equals(VNLib.Utils.Memory.PrivateString)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Equals(System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.ToString"> + <summary> + Creates a deep copy of the internal string and returns that copy + </summary> + <returns>A deep copy of the internal string</returns> + </member> + <member name="P:VNLib.Utils.Memory.PrivateString.Length"> + <summary> + String length + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.IsNullOrEmpty(VNLib.Utils.Memory.PrivateString)"> + <summary> + Indicates whether the underlying string is null or an empty string ("") + </summary> + <param name="ps"></param> + <returns>True if the parameter is null, or an empty string (""). False otherwise</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.GetHashCode"> + <summary> + The hashcode of the underlying string + </summary> + <returns></returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Clone"> + <summary> + Creates a new deep copy of the current instance that is an independent <see cref="T:VNLib.Utils.Memory.PrivateString"/> + </summary> + <returns>The new <see cref="T:VNLib.Utils.Memory.PrivateString"/> instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateString.Erase"> + <summary> + Erases the contents of the internal CLR string + </summary> + </member> + <member name="T:VNLib.Utils.Memory.PrivateStringManager"> + <summary> + When inherited by a class, provides a safe string storage that zeros a CLR string memory on disposal + </summary> + </member> + <member name="F:VNLib.Utils.Memory.PrivateStringManager.ProtectedElements"> + <summary> + Strings to be cleared when exiting + </summary> + </member> + <member name="P:VNLib.Utils.Memory.PrivateStringManager.Item(System.Int32)"> + <summary> + Gets or sets a string referrence into the protected elements store + </summary> + <param name="index"></param> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + <returns>Referrence to string associated with the index</returns> + </member> + <member name="M:VNLib.Utils.Memory.PrivateStringManager.#ctor(System.Int32)"> + <summary> + Create a new instance with fixed array size + </summary> + <param name="elements">Number of elements to protect</param> + </member> + <member name="M:VNLib.Utils.Memory.PrivateStringManager.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.PrivateStringManager.Clone"> + <summary> + Creates a deep copy for a new independent <see cref="T:VNLib.Utils.Memory.PrivateStringManager"/> + </summary> + <returns>A new independent <see cref="T:VNLib.Utils.Memory.PrivateStringManager"/> instance</returns> + <remarks>Be careful duplicating large instances, and make sure clones are properly disposed if necessary</remarks> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Utils.Memory.ProcessHeap"> + <summary> + Provides a <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> wrapper for the <see cref="T:System.Runtime.InteropServices.Marshal"/> virtualalloc + global heap methods + </summary> + </member> + <member name="M:VNLib.Utils.Memory.ProcessHeap.#ctor"> + <summary> + Initalizes a new global (cross platform) process heap + </summary> + </member> + <member name="M:VNLib.Utils.Memory.ProcessHeap.Alloc(System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.ProcessHeap.Free(System.IntPtr@)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.ProcessHeap.Free"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.ProcessHeap.Resize(System.IntPtr@,System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="T:VNLib.Utils.Memory.RpMallocPrivateHeap"> + <summary> + A wrapper class for cross platform RpMalloc implementation. + </summary> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.RpMalloc(System.UInt64,System.UIntPtr,System.Boolean)"> + <summary> + <para> + Initializes RpMalloc for the current thread and alloctes a block of memory + </para> + <para> + NOTE: RPMalloc depends on the current OS thread + </para> + </summary> + <param name="elements">The number of elements to allocate</param> + <param name="size">The number of bytes per element type (aligment)</param> + <param name="zero">Zero the block of memory before returning</param> + <returns>A pointer to the block, (zero if failed)</returns> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.RpFree(System.IntPtr@)"> + <summary> + Freeds an <see cref="!:UnsafeThreadLockedMemoryHandle<T>"/> for the current thread + </summary> + <param name="block">The block to free</param> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.#ctor(System.Boolean)"> + <summary> + Initializes a new RpMalloc first class heap to allocate memory blocks from + </summary> + <param name="zeroAll">A global flag to zero all blocks of memory allocated</param> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.ReleaseHandle"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.AllocBlock(System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.FreeBlock(System.IntPtr)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.RpMallocPrivateHeap.ReAllocBlock(System.IntPtr,System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.SubSequence`1"> + <summary> + Represents a subset (or window) of data within a <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + </summary> + <typeparam name="T">The unmanaged type to wrap</typeparam> + </member> + <member name="P:VNLib.Utils.Memory.SubSequence`1.Size"> + <summary> + The number of elements in the current window + </summary> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.#ctor(VNLib.Utils.Memory.MemoryHandle{`0},System.UInt64,System.Int32)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> to the handle to get a window of the block + </summary> + <param name="block"></param> + <param name="offset"></param> + <param name="size"></param> + </member> + <member name="P:VNLib.Utils.Memory.SubSequence`1.Span"> + <summary> + Gets a <see cref="T:System.Span`1"/> that is offset from the base of the handle + </summary> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.Slice(System.UInt32,System.Int32)"> + <summary> + Slices the current sequence into a smaller <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> + </summary> + <param name="offset">The relative offset from the current window offset</param> + <param name="size">The size of the block</param> + <returns>A <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> of the current sequence</returns> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.GetHashCode"> + <summary> + Returns the signed 32-bit hashcode + </summary> + <returns>A signed 32-bit integer that represents the hashcode for the current instance</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.Equals(VNLib.Utils.Memory.SubSequence{`0})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.op_Equality(VNLib.Utils.Memory.SubSequence{`0},VNLib.Utils.Memory.SubSequence{`0})"> + <summary> + Determines if two <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> are equal + </summary> + <param name="left"></param> + <param name="right"></param> + <returns>True if the sequences are equal, false otherwise</returns> + </member> + <member name="M:VNLib.Utils.Memory.SubSequence`1.op_Inequality(VNLib.Utils.Memory.SubSequence{`0},VNLib.Utils.Memory.SubSequence{`0})"> + <summary> + Determines if two <see cref="T:VNLib.Utils.Memory.SubSequence`1"/> are not equal + </summary> + <param name="left"></param> + <param name="right"></param> + <returns>True if the sequences are not equal, false otherwise</returns> + </member> + <member name="T:VNLib.Utils.Memory.SysBufferMemoryManager`1"> + <summary> + Provides an unmanaged System.Buffers integration with zero-cost pinning. Uses <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + as a memory provider which implements a <see cref="T:System.Runtime.InteropServices.SafeHandle"/> + </summary> + <typeparam name="T">Unmanaged memory type</typeparam> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.#ctor(VNLib.Utils.Memory.MemoryHandle{`0})"> + <summary> + Consumes an exisitng <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> to provide <see cref="T:VNLib.Utils.Memory.Memory"/> wrappers. + The handle should no longer be referrenced directly + </summary> + <param name="existingHandle">The existing handle to consume</param> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.UInt64,System.Boolean)"> + <summary> + Allocates a fized size buffer from the specified unmanaged <see cref="T:VNLib.Utils.Memory.PrivateHeap"/> + </summary> + <param name="heap">The heap to perform allocations from</param> + <param name="elements">The number of elements to allocate</param> + <param name="zero">Zero allocations</param> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.GetSpan"> + <inheritdoc/> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.Pin(System.Int32)"> + <summary> + <inheritdoc/> + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.Unpin"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.Resize(System.UInt64)"> + <summary> + Resizes the block of memory on the current heap + </summary> + <param name="elements">The number of elements</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.SysBufferMemoryManager`1.Resize(System.Int64)"> + <summary> + Resizes the block of memory on the current heap + </summary> + <param name="elements">The number of elements</param> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="T:VNLib.Utils.Memory.UnmanagedHeapBase"> + <summary> + Provides a synchronized base methods for accessing unmanaged memory. Implements <see cref="T:System.Runtime.InteropServices.SafeHandle"/> + for safe disposal of heaps + </summary> + </member> + <member name="F:VNLib.Utils.Memory.UnmanagedHeapBase.HeapLock"> + <summary> + The heap synchronization handle + </summary> + </member> + <member name="F:VNLib.Utils.Memory.UnmanagedHeapBase.GlobalZero"> + <summary> + The global heap zero flag + </summary> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.#ctor(System.Boolean,System.Boolean)"> + <summary> + Initalizes the unmanaged heap base class (init synchronization handle) + </summary> + <param name="globalZero">A global flag to zero all blocks of memory during allocation</param> + <param name="ownsHandle">A flag that indicates if the handle is owned by the instance</param> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.Alloc(System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + <remarks>Increments the handle count</remarks> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.Free(System.IntPtr@)"> + <inheritdoc/> + <remarks>Decrements the handle count</remarks> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.Resize(System.IntPtr@,System.UInt64,System.UInt64,System.Boolean)"> + <inheritdoc/> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.ReleaseHandle"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.AllocBlock(System.UInt64,System.UInt64,System.Boolean)"> + <summary> + Allocates a block of memory from the heap + </summary> + <param name="elements">The number of elements within the block</param> + <param name="size">The size of the element type (in bytes)</param> + <param name="zero">A flag to zero the allocated block</param> + <returns>A pointer to the allocated block</returns> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.FreeBlock(System.IntPtr)"> + <summary> + Frees a previously allocated block of memory + </summary> + <param name="block">The block to free</param> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.ReAllocBlock(System.IntPtr,System.UInt64,System.UInt64,System.Boolean)"> + <summary> + Resizes the previously allocated block of memory on the current heap + </summary> + <param name="block">The prevously allocated block</param> + <param name="elements">The new number of elements within the block</param> + <param name="size">The size of the element type (in bytes)</param> + <param name="zero">A flag to indicate if the new region of the block should be zeroed</param> + <returns>A pointer to the same block, but resized, null if the allocation falied</returns> + <remarks> + Heap base relies on the block pointer to remain unchanged if the resize fails so the + block is still valid, and the return value is used to determine if the resize was successful + </remarks> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.GetHashCode"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnmanagedHeapBase.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"> + <summary> + Represents an unsafe handle to managed/unmanaged memory that should be used cautiously + </summary> + <typeparam name="T">Unmanaged memory type</typeparam> + </member> + <member name="P:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Span"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.UnsafeMemoryHandle`1.IntLength"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Length"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.#ctor(System.Int32,System.Boolean)"> + <summary> + Inializes a new <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> using the default + <see cref="T:System.Buffers.ArrayPool`1"/> + </summary> + <param name="elements">The number of elements to store</param> + <param name="zero">Zero initial contents?</param> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.#ctor"> + <summary> + Creates an empty <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> + </summary> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.#ctor(System.Buffers.ArrayPool{`0},System.Int32,System.Boolean)"> + <summary> + Inializes a new <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> using the specified + <see cref="T:System.Buffers.ArrayPool`1"/> or RPMalloc if the native library is loaded + </summary> + <param name="elements">The number of elements to store</param> + <param name="zero">Zero initial contents?</param> + <param name="pool">The explicit pool to alloc buffers from</param> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.IntPtr,System.Int32)"> + <summary> + Intializes a new <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> for an <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> + </summary> + <param name="heap">The heap the initial memory block belongs to</param> + <param name="initial">A pointer to the unmanaged memory block</param> + <param name="elements">The number of elements this block points to</param> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Dispose"> + <summary> + Releases memory back to the pool or heap from which is was allocated. + </summary> + <remarks>After this method is called, this handle points to invalid memory</remarks> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.GetHashCode"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Pin(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Unpin"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Equals(VNLib.Utils.Memory.UnsafeMemoryHandle{`0})"> + <summary> + Determines if the other handle represents the same memory block as the + current handle. + </summary> + <param name="other">The other handle to test</param> + <returns>True if the other handle points to the same block of memory as the current handle</returns> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.Equals(System.Object)"> + <summary> + Override for object equality operator, will cause boxing + for structures + </summary> + <param name="obj">The other object to compare</param> + <returns> + True if the passed object is of type <see cref="T:VNLib.Utils.Memory.UnsafeMemoryHandle`1"/> + and uses the structure equality operator + false otherwise. + </returns> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.op_Implicit(VNLib.Utils.Memory.UnsafeMemoryHandle{`0})~System.Span{`0}"> + <summary> + Casts the handle to it's <see cref="T:System.Span`1"/> representation + </summary> + <param name="handle">the handle to cast</param> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.op_Equality(VNLib.Utils.Memory.UnsafeMemoryHandle{`0},VNLib.Utils.Memory.UnsafeMemoryHandle{`0})"> + <summary> + Equality overload + </summary> + <param name="left"></param> + <param name="right"></param> + <returns>True if handles are equal, flase otherwise</returns> + </member> + <member name="M:VNLib.Utils.Memory.UnsafeMemoryHandle`1.op_Inequality(VNLib.Utils.Memory.UnsafeMemoryHandle{`0},VNLib.Utils.Memory.UnsafeMemoryHandle{`0})"> + <summary> + Equality overload + </summary> + <param name="left"></param> + <param name="right"></param> + <returns>True if handles are equal, flase otherwise</returns> + </member> + <member name="T:VNLib.Utils.Memory.VnBufferWriter`1"> + <summary> + Provides a stack based buffer writer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnBufferWriter`1.Buffer"> + <summary> + The buffer for writing output data to + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnBufferWriter`1.Written"> + <summary> + The number of characters written to the buffer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnBufferWriter`1.Remaining"> + <summary> + The number of characters remaining in the buffer + </summary> + </member> + <member name="M:VNLib.Utils.Memory.VnBufferWriter`1.#ctor(System.Span{`0}@)"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.VnBufferWriter`1"/> assigning the specified buffer + </summary> + <param name="buffer">The buffer to write data to</param> + </member> + <member name="M:VNLib.Utils.Memory.VnBufferWriter`1.ToString"> + <summary> + Returns a compiled string from the characters written to the buffer + </summary> + <returns>A string of the characters written to the buffer</returns> + </member> + <member name="M:VNLib.Utils.Memory.VnBufferWriter`1.Append(System.ReadOnlySpan{`0})"> + <summary> + Appends a sequence to the buffer + </summary> + <param name="data">The data to append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnBufferWriter`1.Append(`0)"> + <summary> + Appends a single item to the buffer + </summary> + <param name="c">The item to append to the buffer</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnBufferWriter`1.Reset"> + <summary> + Resets the writer by setting the <see cref="P:VNLib.Utils.Memory.VnBufferWriter`1.Written"/> + property to 0. + </summary> + </member> + <member name="T:VNLib.Utils.Memory.VnList`1"> + <summary> + Provides an <see cref="T:System.Collections.IList"/> - dynamic list - implementation using CLR managed memory + from the <see cref="T:System.Buffers.ArrayPool`1"/> API. + </summary> + <typeparam name="T">The item type</typeparam> + <remarks>Implements the <see cref="T:VNLib.Utils.Memory.Caching.IReusable"/> cache interface</remarks> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.#ctor"> + <summary> + Initializes a new list, with an underlying buffer intialized to 100 elements + </summary> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.#ctor(System.Int32)"> + <summary> + Initializes a new list, with the specified buffer size + </summary> + <param name="ssize">The initial buffer size</param> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.#ctor(`0[])"> + <summary> + Initializes a new list, with the elements of specified array. The buffer size is initialized to the exact size of the specified array + </summary> + <param name="items">Initial items to store within the list</param> + </member> + <member name="P:VNLib.Utils.Memory.VnList`1.Item(System.Int32)"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.VnList`1.Count"> + <inheritdoc/> + </member> + <member name="P:VNLib.Utils.Memory.VnList`1.IsReadOnly"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Add(`0)"> + <summary> + Adds the specified item to the end of the list. Resizing/allocations may be performed + </summary> + <param name="item">The item to insert at the end of the list</param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.AddRange(`0[])"> + <summary> + Adds an array of items to the list + </summary> + <param name="items">Array of items to add to the list</param> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.AddRange(System.ReadOnlySpan{`0})"> + <summary> + Adds a range items within a span to the end of the list + </summary> + <param name="items">Span of items to add to the list</param> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.AsSpan"> + <summary> + Returns a span over the data within the list + </summary> + <returns>The span over the internal data</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Push(`0)"> + <summary> + Equivalent to <see cref="M:VNLib.Utils.Memory.VnList`1.Add(`0)"/>. Exists for semantic reasons + </summary> + <param name="item">Item to add to end of the list</param> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Pop"> + <summary> + Removes and item from the end of the list. + </summary> + <returns>The item removed from the end of the list, or default if no element exists at the end of the array</returns> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Peek"> + <summary> + Gets the last item in the list without removing it + </summary> + <returns>The last item in the list, or default if the list is empty</returns> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Clear"> + <summary> + <inheritdoc/> + <br></br> + <br></br> + This method does not free the internal memory buffer, until the instance is disposed + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Contains(`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.CopyTo(`0[],System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.System#Collections#IEnumerable#GetEnumerator"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.IndexOf(`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Insert(System.Int32,`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Remove(`0)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.RemoveAt(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.UnsafeGetBuffer"> + <summary> + Returns the underlying buffer used to store data. WARNING: This returns a referrence to the + underlying internal data buffer. Only use this method if you know what you are doing! + </summary> + <returns></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.UnsafeGetSpan"> + <summary> + Gets a <see cref="T:System.Span`1"/> over the active data within the underlying buffer. Modifications + this structure will affect the state of the items within the buffer. + </summary> + <returns>A span over the elements within the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.ToArray"> + <summary> + Copies the content of the internal list to a new array and returns it. The list remains unmodified + </summary> + <returns>The array representation of the internal list</returns> + </member> + <member name="M:VNLib.Utils.Memory.VnList`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.VnString"> + <summary> + Provides an immutable character buffer stored on an unmanged heap. Contains handles to unmanged memory, and should be disposed + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnString.Length"> + <summary> + The number of unicode characters the current instance can reference + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnString.IsEmpty"> + <summary> + Gets a value indicating if the current instance is empty + </summary> + </member> + <member name="M:VNLib.Utils.Memory.VnString.#ctor"> + <summary> + Creates and empty <see cref="T:VNLib.Utils.Memory.VnString"/>, not particularly usefull, just and empty instance. + </summary> + </member> + <member name="M:VNLib.Utils.Memory.VnString.#ctor(System.ReadOnlySpan{System.Char})"> + <summary> + Creates a new <see cref="T:VNLib.Utils.Memory.VnString"/> around a <see cref="T:System.ReadOnlySpan`1"/> or a <see cref="T:System.String"/> of data + </summary> + <param name="data"><see cref="T:System.ReadOnlySpan`1"/> of data to replicate</param> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.FromStream(System.IO.Stream,System.Text.Encoding,System.UInt32)"> + <summary> + Allocates a temporary buffer to read data from the stream until the end of the stream is reached. + Decodes data from the user-specified encoding + </summary> + <param name="stream">Active stream of data to decode to a string</param> + <param name="encoding"><see cref="T:System.Text.Encoding"/> to use for decoding</param> + <param name="bufferSize">The size of the buffer to allocate during copying</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/> instance</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.OverflowException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.ConsumeHandle(VNLib.Utils.Memory.MemoryHandle{System.Char},System.UInt64,System.Int32)"> + <summary> + Creates a new Vnstring from the <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> buffer provided. This function "consumes" + a handle, meaning it now takes ownsership of the the memory it points to. + </summary> + <param name="handle">The <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> to consume</param> + <param name="start">The offset from the begining of the buffer marking the begining of the string</param> + <param name="length">The number of characters this string points to</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/></returns> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.FromStreamAsync(System.IO.Stream,System.Text.Encoding,VNLib.Utils.Memory.IUnmangedHeap,System.Int32)"> + <summary> + Asynchronously reads data from the specified stream and uses the specified encoding + to decode the binary data to a new <see cref="T:VNLib.Utils.Memory.VnString"/> heap character buffer. + </summary> + <param name="stream">The stream to read data from</param> + <param name="encoding">The encoding to use while decoding data</param> + <param name="heap">The <see cref="T:VNLib.Utils.Memory.IUnmangedHeap"/> to allocate buffers from</param> + <param name="bufferSize">The size of the buffer to allocate</param> + <returns>The new <see cref="T:VNLib.Utils.Memory.VnString"/> containing the data</returns> + <exception cref="T:System.IO.IOException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.CharAt(System.Int32)"> + <summary> + Gets the value of the character at the specified index + </summary> + <param name="index">The index of the character to get</param> + <returns>The <see cref="T:System.Char"/> at the specified index within the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Substring(System.Int32,System.Int32)"> + <summary> + Creates a <see cref="T:VNLib.Utils.Memory.VnString"/> that is a window within the current string, + the referrence points to the same memory as the first instnace. + </summary> + <param name="start">The index within the current string to begin the child string</param> + <param name="count">The number of characters (or length) of the child string</param> + <returns>The child <see cref="T:VNLib.Utils.Memory.VnString"/></returns> + <remarks> + Making substrings will reference the parents's underlying <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + and all children will be set in a disposed state when the parent instance is disposed + </remarks> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Substring(System.Int32)"> + <summary> + Creates a <see cref="T:VNLib.Utils.Memory.VnString"/> that is a window within the current string, + the referrence points to the same memory as the first instnace. + </summary> + <param name="start">The index within the current string to begin the child string</param> + <returns>The child <see cref="T:VNLib.Utils.Memory.VnString"/></returns> + <remarks> + Making substrings will reference the parents's underlying <see cref="T:VNLib.Utils.Memory.MemoryHandle`1"/> + and all children will be set in a disposed state when the parent instance is disposed + </remarks> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.AsSpan"> + <summary> + Gets a <see cref="T:System.ReadOnlySpan`1"/> over the internal character buffer + </summary> + <returns></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.ToString"> + <summary> + Gets a <see cref="T:System.String"/> copy of the internal buffer + </summary> + <returns><see cref="T:System.String"/> representation of internal data</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.VnString.Item(System.Int32)"> + <summary> + Gets the value of the character at the specified index + </summary> + <param name="index">The index of the character to get</param> + <returns>The <see cref="T:System.Char"/> at the specified index within the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Equals(System.Object)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Equals(VNLib.Utils.Memory.VnString)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Equals(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Equals(System.Char[])"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Equals(System.ReadOnlySpan{System.Char})"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.CompareTo(System.String)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnString.CompareTo(VNLib.Utils.Memory.VnString)"> + <inheritdoc/> + <exception cref="T:System.ArgumentNullException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.GetHashCode"> + <summary> + Gets a hashcode for the underyling string by using the .NET <see cref="M:System.String.GetHashCode"/> + method on the character representation of the data + </summary> + <returns></returns> + <remarks> + It is safe to compare hashcodes of <see cref="T:VNLib.Utils.Memory.VnString"/> to the <see cref="T:System.String"/> class or + a character span etc + </remarks> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnString.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.VnTable`1"> + <summary> + Provides a Row-Major ordered table for use of storing value-types in umnaged heap memory + </summary> + <typeparam name="T"></typeparam> + </member> + <member name="M:VNLib.Utils.Memory.VnTable`1.#ctor(System.Int32,System.Int32)"> + <summary> + Creates a new 2 dimensional table in unmanaged heap memory, using the <see cref="P:VNLib.Utils.Memory.Memory.Shared"/> heap. + User should dispose of the table when no longer in use + </summary> + <param name="rows">Number of rows in the table</param> + <param name="cols">Number of columns in the table</param> + </member> + <member name="M:VNLib.Utils.Memory.VnTable`1.#ctor(VNLib.Utils.Memory.IUnmangedHeap,System.Int32,System.Int32)"> + <summary> + Creates a new 2 dimensional table in unmanaged heap memory, using the specified heap. + User should dispose of the table when no longer in use + </summary> + <param name="heap"><see cref="T:VNLib.Utils.Memory.PrivateHeap"/> to allocate table memory from</param> + <param name="rows">Number of rows in the table</param> + <param name="cols">Number of columns in the table</param> + </member> + <member name="M:VNLib.Utils.Memory.VnTable`1.Get(System.Int32,System.Int32)"> + <summary> + Gets the value of an item in the table at the given indexes + </summary> + <param name="row">Row address of the item</param> + <param name="col">Column address of item</param> + <returns>The value of the item</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTable`1.Set(`0,System.Int32,System.Int32)"> + <summary> + Sets the value of an item in the table at the given address + </summary> + <param name="item">Value of item to store</param> + <param name="row">Row address of the item</param> + <param name="col">Column address of item</param> + <returns>The value of the item</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="P:VNLib.Utils.Memory.VnTable`1.Item(System.Int32,System.Int32)"> + <summary> + Equivalent to <see cref="M:VNLib.Utils.Memory.VnTable`1.Get(System.Int32,System.Int32)"/> and <see cref="M:VNLib.Utils.Memory.VnTable`1.Set(`0,System.Int32,System.Int32)"/> + </summary> + <param name="row">Row address of item</param> + <param name="col">Column address of item</param> + <returns>The value of the item</returns> + </member> + <member name="P:VNLib.Utils.Memory.VnTable`1.Item(System.UInt32)"> + <summary> + Allows for direct addressing in the table. + </summary> + <param name="index"></param> + <returns></returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTable`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.Memory.VnTempBuffer`1"> + <summary> + A disposable temporary buffer from shared ArrayPool + </summary> + <typeparam name="T">Type of buffer to create</typeparam> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.Buffer"> + <summary> + Referrence to internal buffer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.InitSize"> + <summary> + Inital/desired size of internal buffer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.Length"> + <summary> + Actual length of internal buffer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.IntLength"> + <summary> + Actual length of internal buffer + </summary> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.Span"> + <inheritdoc/> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.#ctor(System.Int32,System.Boolean)"> + <summary> + Allocates a new <see cref="T:VNLib.Utils.Memory.VnTempBuffer`1"/> with a new buffer from shared array-pool + </summary> + <param name="minSize">Minimum size of the buffer</param> + <param name="zero">Set the zero memory flag on close</param> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.#ctor(System.Buffers.ArrayPool{`0},System.Int32,System.Boolean)"> + <summary> + Allocates a new <see cref="T:VNLib.Utils.Memory.VnTempBuffer`1"/> with a new buffer from specified array-pool + </summary> + <param name="pool">The <see cref="T:System.Buffers.ArrayPool`1"/> to allocate from and return to</param> + <param name="minSize">Minimum size of the buffer</param> + <param name="zero">Set the zero memory flag on close</param> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.GetOffsetWrapper(System.Int32,System.Int32)"> + <summary> + Gets an offset wrapper around the current buffer + </summary> + <param name="offset">Offset from begining of current buffer</param> + <param name="count">Number of <typeparamref name="T"/> from offset</param> + <returns>An <see cref="T:System.ArraySegment`1"/> wrapper around the current buffer containing the offset</returns> + </member> + <member name="P:VNLib.Utils.Memory.VnTempBuffer`1.Item(System.Int32)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.AsMemory"> + <summary> + Gets a memory structure around the internal buffer + </summary> + <returns>A memory structure over the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.AsMemory(System.Int32,System.Int32)"> + <summary> + Gets a memory structure around the internal buffer + </summary> + <param name="count">The number of elements included in the result</param> + <param name="start">A value specifying the begining index of the buffer to include</param> + <returns>A memory structure over the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.AsMemory(System.Int32)"> + <summary> + Gets a memory structure around the internal buffer + </summary> + <param name="count">The number of elements included in the result</param> + <returns>A memory structure over the buffer</returns> + <exception cref="T:System.ObjectDisposedException"></exception> + <exception cref="T:System.ArgumentOutOfRangeException"></exception> + </member> + <member name="M:VNLib.Utils.Memory.VnTempBuffer`1.Free"> + <summary> + Returns buffer to shared array-pool + </summary> + </member> + <member name="T:VNLib.Utils.OpenHandle"> + <summary> + Represents a base class for an open resource or operation that is valid while being held, + and is released or unwound when disposed. + </summary> + <remarks> + The <see cref="T:VNLib.Utils.OpenHandle"/> pattern, may throw exceptions when disposed as deferred + release actions are completed + </remarks> + </member> + <member name="T:VNLib.Utils.OpenResourceHandle`1"> + <summary> + <para> + An abstract base class for an <see cref="T:VNLib.Utils.OpenHandle"/> that holds a specific resource and manages its lifetime. + </para> + </summary> + <inheritdoc/> + <typeparam name="TResource">The resource type</typeparam> + </member> + <member name="P:VNLib.Utils.OpenResourceHandle`1.Resource"> + <summary> + The resource held by the open handle + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="T:VNLib.Utils.ResourceDeleteFailedException"> + <summary> + Raised when a resource delete has failed + </summary> + </member> + <member name="T:VNLib.Utils.ResourceUpdateFailedException"> + <summary> + Raised when a resource update has failed + </summary> + </member> + <member name="T:VNLib.Utils.SafeLibraryHandle"> + <summary> + Represents a safe handle to a native library loaded to the current process + </summary> + </member> + <member name="P:VNLib.Utils.SafeLibraryHandle.IsInvalid"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.SafeLibraryHandle.LoadLibrary(System.String,System.Runtime.InteropServices.DllImportSearchPath)"> + <summary> + Finds and loads the specified native libary into the current process by its name at runtime + </summary> + <param name="libPath">The path (or name of libary) to search for</param> + <param name="searchPath"> + The <see cref="T:System.Runtime.InteropServices.DllImportSearchPath"/> used to search for libaries + within the current filesystem + </param> + <returns>The loaded <see cref="T:VNLib.Utils.SafeLibraryHandle"/></returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.DllNotFoundException"></exception> + </member> + <member name="M:VNLib.Utils.SafeLibraryHandle.TryLoadLibrary(System.String,System.Runtime.InteropServices.DllImportSearchPath,VNLib.Utils.SafeLibraryHandle@)"> + <summary> + Attempts to load the specified native libary into the current process by its name at runtime + </summary> + <param name="libPath">The path (or name of libary) to search for</param> + <param name="searchPath"> + The <see cref="T:System.Runtime.InteropServices.DllImportSearchPath"/> used to search for libaries + within the current filesystem + </param> + <param name="lib">The handle to the libary if successfully loaded</param> + <returns>True if the libary was found and loaded into the current process</returns> + </member> + <member name="M:VNLib.Utils.SafeLibraryHandle.GetMethod``1(System.String)"> + <summary> + Loads a native method from the library of the specified name and managed delegate + </summary> + <typeparam name="T">The native method delegate type</typeparam> + <param name="methodName">The name of the native method</param> + <returns>A wapper handle around the native method delegate</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException">If the handle is closed or invalid</exception> + <exception cref="T:System.EntryPointNotFoundException">When the specified entrypoint could not be found</exception> + </member> + <member name="M:VNLib.Utils.SafeLibraryHandle.DangerousGetMethod``1(System.String)"> + <summary> + Gets an delegate wrapper for the specified method without tracking its referrence. + The caller must manage the <see cref="T:VNLib.Utils.SafeLibraryHandle"/> referrence count in order + to not leak resources or cause process corruption + </summary> + <typeparam name="T">The native method delegate type</typeparam> + <param name="methodName">The name of the native method</param> + <returns>A the delegate wrapper on the native method</returns> + <exception cref="T:System.ArgumentNullException"></exception> + <exception cref="T:System.ObjectDisposedException">If the handle is closed or invalid</exception> + <exception cref="T:System.EntryPointNotFoundException">When the specified entrypoint could not be found</exception> + </member> + <member name="M:VNLib.Utils.SafeLibraryHandle.ReleaseHandle"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.SafeMethodHandle`1"> + <summary> + Represents a handle to a <see cref="T:VNLib.Utils.SafeLibraryHandle"/>'s + native method + </summary> + <typeparam name="T">The native method deelgate type</typeparam> + </member> + <member name="P:VNLib.Utils.SafeMethodHandle`1.Method"> + <summary> + A delegate to the native method + </summary> + </member> + <member name="M:VNLib.Utils.SafeMethodHandle`1.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.UpdateCallback"> + <summary> + A callback delegate used for updating a <see cref="T:VNLib.Utils.UpdatableResource"/> + </summary> + <param name="source">The <see cref="T:VNLib.Utils.UpdatableResource"/> to be updated</param> + <param name="data">The serialized data to be stored/updated</param> + <exception cref="T:VNLib.Utils.ResourceUpdateFailedException"></exception> + </member> + <member name="T:VNLib.Utils.DeleteCallback"> + <summary> + A callback delegate invoked when a <see cref="T:VNLib.Utils.UpdatableResource"/> delete is requested + </summary> + <param name="source">The <see cref="T:VNLib.Utils.UpdatableResource"/> to be deleted</param> + <exception cref="T:VNLib.Utils.ResourceDeleteFailedException"></exception> + </member> + <member name="T:VNLib.Utils.UpdatableResource"> + <summary> + Implemented by a resource that is backed by an external data store, that when modified or deleted will + be reflected to the backing store. + </summary> + </member> + <member name="F:VNLib.Utils.UpdatableResource.Deleted"> + <summary> + A value indicating whether the instance should be deleted when released + </summary> + </member> + <member name="F:VNLib.Utils.UpdatableResource.Modified"> + <summary> + A value indicating whether the instance should be updated when released + </summary> + </member> + <member name="M:VNLib.Utils.UpdatableResource.Check"> + <summary> + Checks if the resouce has been disposed and raises an exception if it is + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="P:VNLib.Utils.UpdatableResource.IsReleased"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.UpdatableResource.Initialize(VNLib.Utils.UpdateCallback,VNLib.Utils.DeleteCallback,System.Text.Json.JsonSerializerOptions)"> + <summary> + Inializes the callback functions and serializer options to use when serialzing the state data + </summary> + <param name="updateCallback">The function to invoke when the resource has been modified and need to be updated</param> + <param name="deletedCallback">The function to invoke when the resource should be deleted</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> to use when serializing resource</param> + </member> + <member name="M:VNLib.Utils.UpdatableResource.Release"> + <summary> + <inheritdoc/> + </summary> + <exception cref="T:System.InvalidOperationException"></exception> + <exception cref="T:VNLib.Utils.ResourceDeleteFailedException"></exception> + <exception cref="T:VNLib.Utils.ResourceUpdateFailedException"></exception> + </member> + <member name="M:VNLib.Utils.UpdatableResource.FlushPendingChanges"> + <summary> + Writes the current state of the the resource to the backing store + immediatly by invoking the specified callback. + <br></br> + <br></br> + Only call this method if your store supports multiple state updates + </summary> + </member> + <member name="M:VNLib.Utils.UpdatableResource.Delete"> + <summary> + Marks the resource for deletion from backing store during closing events + </summary> + </member> + <member name="M:VNLib.Utils.UpdatableResource.GetResource"> + <summary> + Returns the JSON serializable resource to be updated during an update + </summary> + <returns>The resource to update</returns> + </member> + <member name="M:VNLib.Utils.UpdatableResource.Free"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.VnDisposeable"> + <summary> + Provides a base class with abstract methods for for disposable objects, with disposed check method + </summary> + </member> + <member name="P:VNLib.Utils.VnDisposeable.Disposed"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.VnDisposeable.Free"> + <summary> + When overriden in a child class, is responsible for freeing resources + </summary> + </member> + <member name="M:VNLib.Utils.VnDisposeable.Check"> + <summary> + Checks if the current object has been disposed. Method will be inlined where possible + </summary> + <exception cref="T:System.ObjectDisposedException"></exception> + </member> + <member name="M:VNLib.Utils.VnDisposeable.SetDisposedState"> + <summary> + Sets the internal state to diposed without calling <see cref="M:VNLib.Utils.VnDisposeable.Free"/> operation. + Usefull if another code-path performs the free operation independant of a dispose opreation. + </summary> + </member> + <member name="M:VNLib.Utils.VnDisposeable.Dispose(System.Boolean)"> + <inheritdoc/> + </member> + <member name="M:VNLib.Utils.VnDisposeable.Dispose"> + <inheritdoc/> + </member> + <member name="T:VNLib.Utils.VnEncoding"> + <summary> + Contains static methods for encoding data + </summary> + </member> + <member name="M:VNLib.Utils.VnEncoding.GetMemoryStream(System.ReadOnlySpan{System.Char}@,System.Text.Encoding)"> + <summary> + Encodes a <see cref="T:System.ReadOnlySpan`1"/> with the specified <see cref="T:System.Text.Encoding"/> to a <see cref="T:VNLib.Utils.IO.VnMemoryStream"/> that must be disposed by the user + </summary> + <param name="data">Data to be encoded</param> + <param name="encoding"><see cref="T:System.Text.Encoding"/> to encode data with</param> + <returns>A <see cref="T:System.IO.Stream"/> contating the encoded data</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONDeserializeFromBinary``1(System.IO.Stream,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to deserialze a json object from a stream of UTF8 data + </summary> + <typeparam name="T">The type of the object to deserialize</typeparam> + <param name="data">Binary data to read from</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to deserializer</param> + <returns>The object decoded from the stream</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONDeserializeFromBinary(System.IO.Stream,System.Type,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to deserialze a json object from a stream of UTF8 data + </summary> + <param name="data">Binary data to read from</param> + <param name="type"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to deserializer</param> + <returns>The object decoded from the stream</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONDeserializeFromBinaryAsync``1(System.IO.Stream,System.Text.Json.JsonSerializerOptions,System.Threading.CancellationToken)"> + <summary> + Attempts to deserialze a json object from a stream of UTF8 data + </summary> + <typeparam name="T">The type of the object to deserialize</typeparam> + <param name="data">Binary data to read from</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to deserializer</param> + <param name="cancellationToken"></param> + <returns>The object decoded from the stream</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONDeserializeFromBinaryAsync(System.IO.Stream,System.Type,System.Text.Json.JsonSerializerOptions,System.Threading.CancellationToken)"> + <summary> + Attempts to deserialze a json object from a stream of UTF8 data + </summary> + <param name="data">Binary data to read from</param> + <param name="type"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to deserializer</param> + <param name="cancellationToken"></param> + <returns>The object decoded from the stream</returns> + <exception cref="T:System.Text.Json.JsonException"></exception> + <exception cref="T:System.NotSupportedException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONSerializeToBinary``1(``0,System.IO.Stream,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to serialize the object to json and write the encoded data to the stream + </summary> + <typeparam name="T">The object type to serialize</typeparam> + <param name="data">The object to serialize</param> + <param name="output">The <see cref="T:System.IO.Stream"/> to write output data to</param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to serializer</param> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.JSONSerializeToBinary(System.Object,System.IO.Stream,System.Type,System.Text.Json.JsonSerializerOptions)"> + <summary> + Attempts to serialize the object to json and write the encoded data to the stream + </summary> + <param name="data">The object to serialize</param> + <param name="output">The <see cref="T:System.IO.Stream"/> to write output data to</param> + <param name="type"></param> + <param name="options"><see cref="T:System.Text.Json.JsonSerializerOptions"/> object to pass to serializer</param> + <exception cref="T:System.Text.Json.JsonException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryToBase32Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char})"> + <summary> + Attempts to convert the specified byte sequence in Base32 encoding + and writing the encoded data to the output buffer. + </summary> + <param name="input">The input buffer to convert</param> + <param name="output">The ouput buffer to write encoded data to</param> + <returns>The number of characters written, false if no data was written or output buffer was too small</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryToBase32Chars(System.ReadOnlySpan{System.Byte},VNLib.Utils.Memory.VnBufferWriter{System.Char}@)"> + <summary> + Attempts to convert the specified byte sequence in Base32 encoding + and writing the encoded data to the output buffer. + </summary> + <param name="input">The input buffer to convert</param> + <param name="writer">A <see cref="T:VNLib.Utils.Memory.VnBufferWriter`1"/> to write encoded chars to</param> + <returns>The number of characters written, false if no data was written or output buffer was too small</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryFromBase32Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte})"> + <summary> + Attempts to decode the Base32 encoded string + </summary> + <param name="input">The Base32 encoded data to decode</param> + <param name="output">The output buffer to write decoded data to</param> + <returns>The number of bytes written to the output</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryFromBase32Chars(System.ReadOnlySpan{System.Char},VNLib.Utils.Memory.VnBufferWriter{System.Byte}@)"> + <summary> + Attempts to decode the Base32 encoded string + </summary> + <param name="input">The Base32 encoded data to decode</param> + <param name="writer">A <see cref="T:VNLib.Utils.Memory.VnBufferWriter`1"/> to write decoded bytes to</param> + <returns>The number of bytes written to the output</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.Base32CalcMaxBufferSize(System.Int32)"> + <summary> + Calculates the maximum buffer size required to encode a binary block to its Base32 + character encoding + </summary> + <param name="bufferSize">The binary buffer size used to calculate the base32 buffer size</param> + <returns>The maximum size (including padding) of the character buffer required to encode the binary data</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.ToBase32String(System.ReadOnlySpan{System.Byte},System.Boolean)"> + <summary> + Converts the binary buffer to a base32 character string with optional padding characters + </summary> + <param name="binBuffer">The buffer to encode</param> + <param name="withPadding">Should padding be included in the result</param> + <returns>The base32 encoded string representation of the specified buffer</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.FromBase32String``1(System.ReadOnlySpan{System.Char})"> + <summary> + Converts the base32 character buffer to its structure representation + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="base32">The base32 character buffer</param> + <returns>The new structure of the base32 data</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.FromBase32String(System.ReadOnlySpan{System.Char})"> + <summary> + Gets a byte array of the base32 decoded data + </summary> + <param name="base32">The character array to decode</param> + <returns>The byte[] of the decoded binary data, or null if the supplied character array was empty</returns> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.ToBase32String``1(``0,System.Boolean)"> + <summary> + Converts a structure to its base32 representation and returns the string of its value + </summary> + <typeparam name="T">The structure type</typeparam> + <param name="value">The structure to encode</param> + <param name="withPadding">A value indicating if padding should be used</param> + <returns>The base32 string representation of the structure</returns> + <exception cref="T:System.ArgumentException"></exception> + <exception cref="T:System.OutOfMemoryException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.PercentEncodeCalcBufferSize(System.ReadOnlySpan{System.Byte},System.ReadOnlySpan{System.Byte}@)"> + <summary> + Deterimes the size of the buffer needed to encode a utf8 encoded + character buffer into its url-safe percent/hex encoded representation + </summary> + <param name="utf8Bytes">The buffer to examine</param> + <param name="allowedChars">A sequence of characters that are excluded from encoding</param> + <returns>The size of the buffer required to encode</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.PercentEncode(System.ReadOnlySpan{System.Byte},System.Span{System.Byte},System.ReadOnlySpan{System.Byte}@)"> + <summary> + Percent encodes the buffer for utf8 encoded characters to its percent/hex encoded + utf8 character representation + </summary> + <param name="utf8Bytes">The buffer of utf8 encoded characters to encode</param> + <param name="utf8Output">The buffer to write the encoded characters to</param> + <param name="allowedChars">A sequence of characters that are excluded from encoding</param> + <returns>The number of characters encoded and written to the output buffer</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.PercentDecode(System.ReadOnlySpan{System.Byte},System.Span{System.Byte})"> + <summary> + Decodes a percent (url/hex) encoded utf8 encoded character buffer to its utf8 + encoded binary value + </summary> + <param name="utf8Encoded">The buffer containg characters to be decoded</param> + <param name="utf8Output">The buffer to write deocded values to</param> + <returns>The nuber of bytes written to the output buffer</returns> + <exception cref="T:System.FormatException"></exception> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryFromBase64Chars(System.ReadOnlySpan{System.Char},System.Span{System.Byte})"> + <summary> + Tries to convert the specified span containing a string representation that is + encoded with base-64 digits into a span of 8-bit unsigned integers. + </summary> + <param name="base64">Base64 character data to recover</param> + <param name="buffer">The binary output buffer to write converted characters to</param> + <returns>The number of bytes written, or <see cref="F:VNLib.Utils.ERRNO.E_FAIL"/> of the conversion was unsucessful</returns> + </member> + <member name="M:VNLib.Utils.VnEncoding.TryToBase64Chars(System.ReadOnlySpan{System.Byte},System.Span{System.Char},System.Base64FormattingOptions)"> + <summary> + Tries to convert the 8-bit unsigned integers inside the specified read-only span + into their equivalent string representation that is encoded with base-64 digits. + You can optionally specify whether to insert line breaks in the return value. + </summary> + <param name="buffer">The binary buffer to convert characters from</param> + <param name="base64">The base64 output buffer</param> + <param name="options"> + One of the enumeration values that specify whether to insert line breaks in the + return value. The default value is System.Base64FormattingOptions.None. + </param> + <returns>The number of characters encoded, or <see cref="F:VNLib.Utils.ERRNO.E_FAIL"/> if conversion was unsuccessful</returns> + </member> + </members> +</doc> diff --git a/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VaultSharp.dll b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VaultSharp.dll Binary files differnew file mode 100644 index 0000000..7350df1 --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/SessionCacheServer/VaultSharp.dll diff --git a/Plugins/SessionCacheServer/liveplugin/applog.txt b/Plugins/SessionCacheServer/liveplugin/applog.txt new file mode 100644 index 0000000..bc0f81e --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/applog.txt @@ -0,0 +1,546 @@ +2022-10-13 15:44:58.651 -04:00 [INF] Application Loading virtual hosts +2022-10-13 15:44:58.681 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 15:44:58.695 -04:00 [INF] Application Starting listeners... +2022-10-13 15:44:58.710 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 15:44:58.711 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 15:44:59.639 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 15:44:59.640 -04:00 [VRB] Application Plugins loaded +2022-10-13 15:44:59.641 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 15:45:10.882 -04:00 [INF] Application Stopping server +2022-10-13 15:46:18.977 -04:00 [INF] Application Loading virtual hosts +2022-10-13 15:46:19.005 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 15:46:19.017 -04:00 [INF] Application Starting listeners... +2022-10-13 15:46:19.032 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 15:46:19.034 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 15:46:19.663 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 15:46:19.663 -04:00 [VRB] Application Plugins loaded +2022-10-13 15:46:19.664 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 15:48:42.217 -04:00 [INF] Application Stopping server +2022-10-13 15:50:12.458 -04:00 [INF] Application Loading virtual hosts +2022-10-13 15:50:12.489 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 15:50:12.502 -04:00 [INF] Application Starting listeners... +2022-10-13 15:50:12.518 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 15:50:12.520 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 15:50:13.399 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 15:50:13.399 -04:00 [VRB] Application Plugins loaded +2022-10-13 15:50:13.401 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 15:50:48.292 -04:00 [INF] Application Stopping server +2022-10-13 15:51:11.580 -04:00 [INF] Application Loading virtual hosts +2022-10-13 15:51:11.610 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 15:51:11.623 -04:00 [INF] Application Starting listeners... +2022-10-13 15:51:11.639 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 15:51:11.640 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 15:51:12.222 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 15:51:12.223 -04:00 [VRB] Application Plugins loaded +2022-10-13 15:51:12.224 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 15:53:10.183 -04:00 [INF] Application Stopping server +2022-10-13 15:53:24.211 -04:00 [INF] Application Loading virtual hosts +2022-10-13 15:53:24.241 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 15:53:24.254 -04:00 [INF] Application Starting listeners... +2022-10-13 15:53:24.269 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 15:53:24.271 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 15:53:25.189 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 15:53:25.189 -04:00 [VRB] Application Plugins loaded +2022-10-13 15:53:25.191 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 15:54:29.044 -04:00 [INF] Application Stopping server +2022-10-13 16:38:19.896 -04:00 [INF] Application Loading virtual hosts +2022-10-13 16:38:19.927 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 16:38:19.941 -04:00 [INF] Application Starting listeners... +2022-10-13 16:38:19.957 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 16:38:19.959 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 16:38:20.781 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 16:38:20.782 -04:00 [VRB] Application Plugins loaded +2022-10-13 16:38:20.784 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 16:38:27.112 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-13 16:40:25.992 -04:00 [INF] Application Stopping server +2022-10-13 16:42:04.971 -04:00 [INF] Application Loading virtual hosts +2022-10-13 16:42:05.001 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 16:42:05.015 -04:00 [INF] Application Starting listeners... +2022-10-13 16:42:05.031 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 16:42:05.033 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 16:42:05.801 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 16:42:05.801 -04:00 [VRB] Application Plugins loaded +2022-10-13 16:42:05.803 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 16:42:12.678 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-13 17:03:14.891 -04:00 [INF] Application Stopping server +2022-10-13 17:04:59.434 -04:00 [INF] Application Loading virtual hosts +2022-10-13 17:04:59.465 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 17:04:59.478 -04:00 [INF] Application Starting listeners... +2022-10-13 17:04:59.495 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 17:04:59.497 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 17:05:00.307 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 17:05:00.308 -04:00 [VRB] Application Plugins loaded +2022-10-13 17:05:00.310 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 17:05:02.147 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-13 17:08:00.960 -04:00 [INF] Application Stopping server +2022-10-13 17:09:34.712 -04:00 [INF] Application Loading virtual hosts +2022-10-13 17:09:34.743 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 17:09:34.758 -04:00 [INF] Application Starting listeners... +2022-10-13 17:09:34.775 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 17:09:34.777 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 17:09:35.563 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 17:09:35.564 -04:00 [VRB] Application Plugins loaded +2022-10-13 17:09:35.565 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 17:09:36.829 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-13 17:10:35.360 -04:00 [INF] Application Stopping server +2022-10-13 17:11:08.148 -04:00 [INF] Application Loading virtual hosts +2022-10-13 17:11:08.178 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-13 17:11:08.191 -04:00 [INF] Application Starting listeners... +2022-10-13 17:11:08.207 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-13 17:11:08.209 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-13 17:11:08.653 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-13 17:11:08.653 -04:00 [VRB] Application Plugins loaded +2022-10-13 17:11:08.655 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-13 17:11:13.112 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-14 11:24:55.775 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-15 18:21:08.101 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-15 18:21:42.686 -04:00 [VRB] Application Client 192.168.2.36 made a websocket request +2022-10-15 22:11:06.984 -04:00 [INF] Application Stopping server +2022-10-21 18:07:30.131 -04:00 [INF] Application Loading virtual hosts +2022-10-21 18:07:30.161 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-21 18:07:30.174 -04:00 [INF] Application Starting listeners... +2022-10-21 18:07:30.189 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-21 18:07:30.191 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-21 18:07:31.028 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-21 18:07:31.028 -04:00 [VRB] Application Plugins loaded +2022-10-21 18:07:31.030 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-21 18:08:07.585 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-21 18:08:08.437 -04:00 [INF] Application Stopping server +2022-10-23 19:57:57.517 -04:00 [INF] Application Loading virtual hosts +2022-10-23 19:57:57.546 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 19:57:57.559 -04:00 [INF] Application Starting listeners... +2022-10-23 19:57:57.574 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 19:57:57.576 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 19:57:58.460 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 19:57:58.461 -04:00 [VRB] Application Plugins loaded +2022-10-23 19:57:58.462 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 19:57:59.719 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-23 20:30:51.298 -04:00 [DBG] Application Collection Gen0 1 Gen1 1 Gen2 1 +2022-10-23 20:30:51.301 -04:00 [DBG] Application Compacted false Last Size 23843kb, Pause % 0 +2022-10-23 20:30:51.302 -04:00 [DBG] Application High watermark 30114720kb Current Load 17065008kb +2022-10-23 20:30:51.303 -04:00 [DBG] Application Fargmented kb 16166 Concurrent true +2022-10-23 20:30:51.304 -04:00 [DBG] Application Pending finalizers 371 Pinned Objects 0 +2022-10-23 20:31:05.203 -04:00 [DBG] Application Collection Gen0 1 Gen1 1 Gen2 1 +2022-10-23 20:31:05.205 -04:00 [DBG] Application Compacted false Last Size 23843kb, Pause % 0 +2022-10-23 20:31:05.207 -04:00 [DBG] Application High watermark 30114720kb Current Load 17065008kb +2022-10-23 20:31:05.208 -04:00 [DBG] Application Fargmented kb 16166 Concurrent true +2022-10-23 20:31:05.209 -04:00 [DBG] Application Pending finalizers 371 Pinned Objects 0 +2022-10-23 20:31:49.587 -04:00 [INF] Application Stopping server +2022-10-23 21:14:34.173 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:14:34.203 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:14:34.254 -04:00 [INF] Application Starting listeners... +2022-10-23 21:14:34.309 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:14:34.311 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:14:35.009 -04:00 [ERR] Application +System.ArgumentException: Cannot bind to the target method because its signature is not compatible with that of the delegate type. + at System.Reflection.RuntimeMethodInfo.CreateDelegateInternal(Type delegateType, Object firstArgument, DelegateBindingFlags bindingFlags) + at System.Reflection.RuntimeMethodInfo.CreateDelegate(Type delegateType, Object target) + at System.Reflection.MethodInfo.CreateDelegate[T](Object target) + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.<>c__DisplayClass2_0`1.<ScheduleIntervals>b__1(MethodInfo m) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 88 + at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext() + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.ScheduleIntervals[T](PluginBase plugin, T instance, Type epType, IReadOnlyDictionary`2 endpointLocalConfig) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 96 + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route[T](PluginBase plugin, String pluginConfigPathName) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 53 + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route[T](PluginBase plugin) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 77 + at VNLib.Plugins.Essentials.Sessions.Server.SessionServerEntrypoint.OnLoad() in F:\Programming\Web Plugins\Sessions\Plugins\SessionCacheServer\SessionServerEntrypoint.cs:line 97 + at VNLib.Plugins.PluginBase.VNLib.Plugins.IPlugin.Load() in F:\Programming\Web Plugins\PluginBase\PluginBase.cs:line 150 + at VNLib.Plugins.Runtime.LivePlugin.LoadPlugin() in F:\Programming\VNLib\VNLib.Plugins.Runtime\LivePlugin.cs:line 134 + at VNLib.Plugins.Runtime.WebPluginLoader.InitLoaderAsync() in F:\Programming\VNLib\VNLib.Plugins.Runtime\WebPluginLoader.cs:line 178 + at VNLib.WebServer.Entry.<>c__DisplayClass38_1.<<LoadPlugins>g__Load|2>d.MoveNext() in F:\Programming\VNLIb.WebServer\Entry.cs:line 721 +2022-10-23 21:14:35.048 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:14:35.048 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:14:35.050 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:14:37.058 -04:00 [INF] Application Stopping server +2022-10-23 21:15:31.012 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:15:31.039 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:15:31.052 -04:00 [INF] Application Starting listeners... +2022-10-23 21:15:31.067 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:15:31.068 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:15:31.707 -04:00 [ERR] Application +System.ArgumentException: Cannot bind to the target method because its signature is not compatible with that of the delegate type. + at System.Reflection.RuntimeMethodInfo.CreateDelegateInternal(Type delegateType, Object firstArgument, DelegateBindingFlags bindingFlags) + at System.Reflection.RuntimeMethodInfo.CreateDelegate(Type delegateType, Object target) + at System.Reflection.MethodInfo.CreateDelegate[T](Object target) + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.<>c__DisplayClass2_0`1.<ScheduleIntervals>b__1(MethodInfo m) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 88 + at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext() + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.ScheduleIntervals[T](PluginBase plugin, T instance, Type epType, IReadOnlyDictionary`2 endpointLocalConfig) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 96 + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route[T](PluginBase plugin, String pluginConfigPathName) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 53 + at VNLib.Plugins.Extensions.Loading.Routing.RoutingExtensions.Route[T](PluginBase plugin) in F:\Programming\Web Plugins\Extensions\VNLib.Plugins.Extensions.Loading\RoutingExtensions.cs:line 77 + at VNLib.Plugins.Essentials.Sessions.Server.SessionServerEntrypoint.OnLoad() in F:\Programming\Web Plugins\Sessions\Plugins\SessionCacheServer\SessionServerEntrypoint.cs:line 97 + at VNLib.Plugins.PluginBase.VNLib.Plugins.IPlugin.Load() in F:\Programming\Web Plugins\PluginBase\PluginBase.cs:line 150 + at VNLib.Plugins.Runtime.LivePlugin.LoadPlugin() in F:\Programming\VNLib\VNLib.Plugins.Runtime\LivePlugin.cs:line 134 + at VNLib.Plugins.Runtime.WebPluginLoader.InitLoaderAsync() in F:\Programming\VNLib\VNLib.Plugins.Runtime\WebPluginLoader.cs:line 178 + at VNLib.WebServer.Entry.<>c__DisplayClass38_1.<<LoadPlugins>g__Load|2>d.MoveNext() in F:\Programming\VNLIb.WebServer\Entry.cs:line 721 +2022-10-23 21:15:31.734 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:15:31.734 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:15:31.736 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:15:33.681 -04:00 [INF] Application Stopping server +2022-10-23 21:29:28.376 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:29:28.405 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:29:28.418 -04:00 [INF] Application Starting listeners... +2022-10-23 21:29:28.433 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:29:28.434 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:29:29.063 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:29:29.064 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:29:29.065 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:29:33.366 -04:00 [INF] Application Stopping server +2022-10-23 21:30:52.001 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:30:52.029 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:30:52.042 -04:00 [INF] Application Starting listeners... +2022-10-23 21:30:52.058 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:30:52.059 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:30:52.400 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:30:52.400 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:30:52.402 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:30:55.145 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-23 21:32:55.670 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-23 21:33:12.447 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-23 21:37:16.479 -04:00 [INF] Application Stopping server +2022-10-23 21:45:07.512 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:45:07.541 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:45:07.553 -04:00 [INF] Application Starting listeners... +2022-10-23 21:45:07.569 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:45:07.570 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:45:08.188 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:45:08.188 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:45:08.190 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:45:08.528 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-23 21:45:18.656 -04:00 [INF] Application Stopping server +2022-10-23 21:46:17.247 -04:00 [INF] Application Loading virtual hosts +2022-10-23 21:46:17.274 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-23 21:46:17.288 -04:00 [INF] Application Starting listeners... +2022-10-23 21:46:17.303 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-23 21:46:17.305 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-23 21:46:17.592 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-23 21:46:17.593 -04:00 [VRB] Application Plugins loaded +2022-10-23 21:46:17.594 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-23 21:46:19.362 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-23 21:46:25.128 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-23 21:48:05.275 -04:00 [INF] Application Stopping server +2022-10-24 01:09:44.544 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:09:44.575 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:09:44.589 -04:00 [INF] Application Starting listeners... +2022-10-24 01:09:44.607 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:09:44.609 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:09:45.247 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:09:45.248 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:09:45.250 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:09:51.624 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:09:58.401 -04:00 [INF] Application Stopping server +2022-10-24 01:15:04.797 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:15:04.826 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:15:04.839 -04:00 [INF] Application Starting listeners... +2022-10-24 01:15:04.855 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:15:04.857 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:15:05.157 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:15:05.158 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:15:05.160 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:15:37.434 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:16:29.768 -04:00 [INF] Application Stopping server +2022-10-24 01:44:38.786 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:44:38.814 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:44:38.827 -04:00 [INF] Application Starting listeners... +2022-10-24 01:44:38.843 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:44:38.845 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:44:39.197 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:44:39.198 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:44:39.200 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:44:43.345 -04:00 [INF] Application Stopping server +2022-10-24 01:44:49.053 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:44:49.081 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:44:49.094 -04:00 [INF] Application Starting listeners... +2022-10-24 01:44:49.109 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:44:49.111 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:44:49.400 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:44:49.400 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:44:49.402 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:44:54.105 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:45:13.290 -04:00 [INF] Application Stopping server +2022-10-24 01:45:15.079 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:45:15.108 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:45:15.120 -04:00 [INF] Application Starting listeners... +2022-10-24 01:45:15.136 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:45:15.137 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:45:15.232 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:45:15.430 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:45:15.430 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:45:15.432 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:45:36.587 -04:00 [INF] Application Stopping server +2022-10-24 01:49:11.831 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:49:11.859 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:49:11.871 -04:00 [INF] Application Starting listeners... +2022-10-24 01:49:11.886 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:49:11.887 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:49:12.191 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:49:12.192 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:49:12.193 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:49:15.690 -04:00 [INF] Application Stopping server +2022-10-24 01:49:20.226 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:49:20.253 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:49:20.266 -04:00 [INF] Application Starting listeners... +2022-10-24 01:49:20.280 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:49:20.282 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:49:20.571 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:49:20.572 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:49:20.573 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:49:22.778 -04:00 [INF] Application Stopping server +2022-10-24 01:49:25.119 -04:00 [INF] Application Loading virtual hosts +2022-10-24 01:49:25.146 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 01:49:25.159 -04:00 [INF] Application Starting listeners... +2022-10-24 01:49:25.174 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 01:49:25.176 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 01:49:25.281 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:49:25.508 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 01:49:25.509 -04:00 [VRB] Application Plugins loaded +2022-10-24 01:49:25.510 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 01:49:26.285 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 01:49:27.183 -04:00 [INF] Application Stopping server +2022-10-24 17:49:18.940 -04:00 [INF] Application Loading virtual hosts +2022-10-24 17:49:18.969 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 17:49:18.982 -04:00 [INF] Application Starting listeners... +2022-10-24 17:49:18.999 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 17:49:19.001 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 17:49:19.676 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 17:49:19.676 -04:00 [VRB] Application Plugins loaded +2022-10-24 17:49:19.678 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 17:49:22.298 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 17:49:34.547 -04:00 [INF] Application Stopping server +2022-10-24 17:49:42.010 -04:00 [INF] Application Loading virtual hosts +2022-10-24 17:49:42.038 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 17:49:42.051 -04:00 [INF] Application Starting listeners... +2022-10-24 17:49:42.067 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 17:49:42.070 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 17:49:42.330 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 17:49:42.330 -04:00 [VRB] Application Plugins loaded +2022-10-24 17:49:42.332 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 17:49:42.378 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 17:50:22.628 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 17:51:08.605 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 17:51:37.659 -04:00 [INF] Application Stopping server +2022-10-24 21:59:26.878 -04:00 [INF] Application Loading virtual hosts +2022-10-24 21:59:26.908 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 21:59:26.921 -04:00 [INF] Application Starting listeners... +2022-10-24 21:59:26.938 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 21:59:26.940 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 21:59:27.600 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 21:59:27.601 -04:00 [VRB] Application Plugins loaded +2022-10-24 21:59:27.602 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 22:00:57.040 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 22:01:21.770 -04:00 [INF] Application Stopping server +2022-10-24 22:01:28.518 -04:00 [INF] Application Loading virtual hosts +2022-10-24 22:01:28.546 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 22:01:28.558 -04:00 [INF] Application Starting listeners... +2022-10-24 22:01:28.574 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 22:01:28.576 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 22:01:28.885 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 22:01:28.886 -04:00 [VRB] Application Plugins loaded +2022-10-24 22:01:28.888 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 22:01:30.114 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 22:01:46.239 -04:00 [INF] Application Stopping server +2022-10-24 22:07:18.896 -04:00 [INF] Application Loading virtual hosts +2022-10-24 22:07:18.926 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 22:07:18.938 -04:00 [INF] Application Starting listeners... +2022-10-24 22:07:18.955 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 22:07:18.957 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 22:07:19.217 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 22:07:19.218 -04:00 [VRB] Application Plugins loaded +2022-10-24 22:07:19.219 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 22:07:20.236 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 22:07:41.989 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 22:07:59.048 -04:00 [INF] Application Stopping server +2022-10-24 22:07:59.062 -04:00 [FTL] Application UNHANDLED APPDOMAIN EXCEPTION + System.UnhandledExceptionEventArgs +2022-10-24 22:07:59.062 -04:00 [FTL] Application UNHANDLED APPDOMAIN EXCEPTION + System.UnhandledExceptionEventArgs +2022-10-24 22:09:47.002 -04:00 [INF] Application Loading virtual hosts +2022-10-24 22:09:47.031 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-24 22:09:47.044 -04:00 [INF] Application Starting listeners... +2022-10-24 22:09:47.059 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-24 22:09:47.061 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-24 22:09:47.326 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-24 22:09:47.327 -04:00 [VRB] Application Plugins loaded +2022-10-24 22:09:47.328 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-24 22:09:53.236 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-24 22:10:23.428 -04:00 [INF] Application Stopping server +2022-10-25 00:29:37.254 -04:00 [INF] Application Loading virtual hosts +2022-10-25 00:29:37.283 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-25 00:29:37.295 -04:00 [INF] Application Starting listeners... +2022-10-25 00:29:37.311 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-25 00:29:37.312 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-25 00:29:37.639 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-25 00:29:37.639 -04:00 [VRB] Application Plugins loaded +2022-10-25 00:29:37.641 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-25 00:29:45.238 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-25 00:33:12.565 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-25 00:33:57.147 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-25 00:36:32.820 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-25 00:37:26.295 -04:00 [INF] Application Stopping server +2022-10-25 00:37:48.227 -04:00 [INF] Application Loading virtual hosts +2022-10-25 00:37:48.255 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-25 00:37:48.268 -04:00 [INF] Application Starting listeners... +2022-10-25 00:37:48.283 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-25 00:37:48.285 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-25 00:37:48.606 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-25 00:37:48.607 -04:00 [VRB] Application Plugins loaded +2022-10-25 00:37:48.609 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-25 00:38:13.117 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-25 00:39:39.799 -04:00 [INF] Application Stopping server +2022-10-26 15:26:17.035 -04:00 [INF] Application Loading virtual hosts +2022-10-26 15:26:17.081 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-26 15:26:17.134 -04:00 [INF] Application Starting listeners... +2022-10-26 15:26:17.196 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-26 15:26:17.198 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-26 15:26:17.963 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-26 15:26:17.964 -04:00 [VRB] Application Plugins loaded +2022-10-26 15:26:17.966 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-26 15:27:52.240 -04:00 [INF] Application Stopping server +2022-10-26 17:07:38.941 -04:00 [INF] Application Loading virtual hosts +2022-10-26 17:07:38.970 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-26 17:07:38.983 -04:00 [INF] Application Starting listeners... +2022-10-26 17:07:38.999 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-26 17:07:39.002 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-26 17:07:39.375 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-26 17:07:39.376 -04:00 [VRB] Application Plugins loaded +2022-10-26 17:07:39.377 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-26 17:07:42.997 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-26 17:12:40.160 -04:00 [INF] Application Stopping server +2022-10-27 00:51:32.152 -04:00 [INF] Application Loading virtual hosts +2022-10-27 00:51:32.181 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 00:51:32.194 -04:00 [INF] Application Starting listeners... +2022-10-27 00:51:32.210 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 00:51:32.212 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 00:51:32.893 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 00:51:32.894 -04:00 [VRB] Application Plugins loaded +2022-10-27 00:51:32.895 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 00:51:34.542 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 13:02:14.075 -04:00 [INF] Application Stopping server +2022-10-27 13:29:25.940 -04:00 [INF] Application Loading virtual hosts +2022-10-27 13:29:25.983 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 13:29:26.038 -04:00 [INF] Application Starting listeners... +2022-10-27 13:29:26.112 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 13:29:26.114 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 13:29:26.866 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 13:29:26.866 -04:00 [VRB] Application Plugins loaded +2022-10-27 13:29:26.868 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 13:29:30.724 -04:00 [INF] Application Stopping server +2022-10-27 13:29:35.984 -04:00 [INF] Application Loading virtual hosts +2022-10-27 13:29:36.012 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 13:29:36.025 -04:00 [INF] Application Starting listeners... +2022-10-27 13:29:36.040 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 13:29:36.041 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 13:29:36.415 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 13:29:36.416 -04:00 [VRB] Application Plugins loaded +2022-10-27 13:29:36.417 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 13:29:40.106 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 13:32:57.852 -04:00 [INF] Application Stopping server +2022-10-27 13:58:49.339 -04:00 [INF] Application Loading virtual hosts +2022-10-27 13:58:49.369 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 13:58:49.382 -04:00 [INF] Application Starting listeners... +2022-10-27 13:58:49.398 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 13:58:49.400 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 13:58:50.073 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 13:58:50.074 -04:00 [VRB] Application Plugins loaded +2022-10-27 13:58:50.076 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 13:59:00.393 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 13:59:35.185 -04:00 [INF] Application Stopping server +2022-10-27 14:01:41.352 -04:00 [INF] Application Loading virtual hosts +2022-10-27 14:01:41.381 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 14:01:41.393 -04:00 [INF] Application Starting listeners... +2022-10-27 14:01:41.411 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 14:01:41.413 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 14:01:42.081 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 14:01:42.081 -04:00 [VRB] Application Plugins loaded +2022-10-27 14:01:42.083 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 14:01:58.680 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 14:03:26.940 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 15:08:25.128 -04:00 [INF] Application Stopping server +2022-10-27 15:11:11.078 -04:00 [INF] Application Loading virtual hosts +2022-10-27 15:11:11.108 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 15:11:11.123 -04:00 [INF] Application Starting listeners... +2022-10-27 15:11:11.141 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 15:11:11.143 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 15:11:11.775 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 15:11:11.776 -04:00 [VRB] Application Plugins loaded +2022-10-27 15:11:11.778 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 15:11:21.528 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 15:11:32.130 -04:00 [INF] Application Stopping server +2022-10-27 15:18:00.328 -04:00 [INF] Application Loading virtual hosts +2022-10-27 15:18:00.356 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 15:18:00.368 -04:00 [INF] Application Starting listeners... +2022-10-27 15:18:00.384 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 15:18:00.385 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 15:18:01.032 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 15:18:01.032 -04:00 [VRB] Application Plugins loaded +2022-10-27 15:18:01.034 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 15:18:05.635 -04:00 [INF] Application Stopping server +2022-10-27 15:18:09.505 -04:00 [INF] Application Loading virtual hosts +2022-10-27 15:18:09.533 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 15:18:09.545 -04:00 [INF] Application Starting listeners... +2022-10-27 15:18:09.560 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 15:18:09.562 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 15:18:09.918 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 15:18:09.919 -04:00 [VRB] Application Plugins loaded +2022-10-27 15:18:09.920 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 15:18:12.159 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 16:29:43.031 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 16:29:54.094 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-27 16:29:54.096 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-27 16:36:57.884 -04:00 [INF] Application Stopping server +2022-10-27 16:42:37.533 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:42:37.562 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:42:37.574 -04:00 [INF] Application Starting listeners... +2022-10-27 16:42:37.589 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:42:37.591 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:42:38.259 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:42:38.259 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:42:38.260 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:42:45.152 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 16:42:50.625 -04:00 [INF] Application Stopping server +2022-10-27 16:45:12.521 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:45:12.550 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:45:12.563 -04:00 [INF] Application Starting listeners... +2022-10-27 16:45:12.578 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:45:12.580 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:45:13.233 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:45:13.233 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:45:13.235 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:45:21.537 -04:00 [INF] Application Stopping server +2022-10-27 16:45:24.051 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:45:24.078 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:45:24.090 -04:00 [INF] Application Starting listeners... +2022-10-27 16:45:24.105 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:45:24.107 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:45:24.429 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:45:24.430 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:45:24.432 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:45:45.755 -04:00 [INF] Application Stopping server +2022-10-27 16:45:49.358 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:45:49.387 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:45:49.400 -04:00 [INF] Application Starting listeners... +2022-10-27 16:45:49.415 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:45:49.417 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:45:49.734 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:45:49.734 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:45:49.736 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:45:55.745 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 16:46:07.274 -04:00 [INF] Application Stopping server +2022-10-27 16:46:59.871 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:46:59.900 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:46:59.913 -04:00 [INF] Application Starting listeners... +2022-10-27 16:46:59.931 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:46:59.932 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:47:00.311 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:47:00.312 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:47:00.313 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:47:06.832 -04:00 [INF] Application Stopping server +2022-10-27 16:47:11.770 -04:00 [INF] Application Loading virtual hosts +2022-10-27 16:47:11.799 -04:00 [INF] Application Found virtual host * on 0.0.0.0:2557, with TLS false, upstream servers [] +2022-10-27 16:47:11.811 -04:00 [INF] Application Starting listeners... +2022-10-27 16:47:11.826 -04:00 [DBG] Application Loading plugins. Hot-reload enabled true +2022-10-27 16:47:11.827 -04:00 [VRB] Application Found plugin file SessionCacheServer.dll +2022-10-27 16:47:12.197 -04:00 [VRB] Application Waiting for enabled plugins to load +2022-10-27 16:47:12.197 -04:00 [VRB] Application Plugins loaded +2022-10-27 16:47:12.199 -04:00 [VRB] Application Main thread waiting for exit signal +2022-10-27 16:47:19.766 -04:00 [VRB] Application Client 192.168.2.95 made a websocket request +2022-10-27 16:47:55.368 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-27 16:47:55.376 -04:00 [VRB] Application Client 10.10.40.96 made a websocket request +2022-10-27 22:24:13.987 -04:00 [INF] Application Stopping server diff --git a/Plugins/SessionCacheServer/liveplugin/syslog.txt b/Plugins/SessionCacheServer/liveplugin/syslog.txt new file mode 100644 index 0000000..9b9dafe --- /dev/null +++ b/Plugins/SessionCacheServer/liveplugin/syslog.txt @@ -0,0 +1,220 @@ +2022-10-13 15:44:58.692 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 15:44:58.710 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 15:45:10.884 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 15:45:10.899 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:46:19.015 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 15:46:19.032 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 15:48:42.218 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 15:50:12.500 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 15:50:12.518 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 15:50:48.296 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 15:51:11.621 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 15:51:11.639 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 15:53:10.185 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:53:10.185 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:53:10.185 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 15:53:24.251 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 15:53:24.270 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 15:54:29.045 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:54:29.045 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:54:29.045 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 15:54:29.046 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 16:38:19.939 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 16:38:19.957 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 16:40:25.993 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 16:40:25.993 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 16:40:25.993 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 16:42:05.012 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 16:42:05.032 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 17:03:14.892 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:03:14.892 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:03:14.892 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 17:04:59.476 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 17:04:59.496 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 17:08:00.961 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:08:00.961 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:08:00.962 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 17:09:34.754 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 17:09:34.775 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-13 17:10:35.362 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:10:35.362 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-13 17:10:35.362 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-13 17:11:08.188 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-13 17:11:08.208 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-14 11:40:53.259 -04:00 [VRB] System Failed to receive transport data within a timeout period Read was canceled on underlying PipeReader. +2022-10-14 11:41:03.300 -04:00 [VRB] System Failed to receive transport data within a timeout period Read was canceled on underlying PipeReader. +2022-10-15 22:11:06.987 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-21 18:07:30.171 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-21 18:07:30.189 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-21 18:08:08.440 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 19:57:57.557 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 19:57:57.574 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 20:31:49.590 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:14:34.251 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:14:34.310 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:14:37.061 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:15:31.050 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:15:31.067 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:15:33.683 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:29:28.416 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:29:28.434 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:29:33.371 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:30:52.040 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:30:52.058 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:37:16.480 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-23 21:37:16.480 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-23 21:37:16.481 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:45:07.551 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:45:07.569 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:45:18.658 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-23 21:45:18.658 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-23 21:46:17.286 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-23 21:46:17.303 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-23 21:48:05.276 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-23 21:48:05.276 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-23 21:48:05.276 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:09:44.587 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:09:44.607 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:09:58.403 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:09:58.404 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:15:04.837 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:15:04.855 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:15:10.878 -04:00 [DBG] System Connecion reset by client +2022-10-24 01:16:29.769 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:16:29.769 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:16:29.770 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:44:38.825 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:44:38.843 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:44:43.356 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:44:49.092 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:44:49.110 -04:00 [INF] System HTTP server 11429296 listening for connections +2022-10-24 01:45:13.292 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:45:13.292 -04:00 [INF] System HTTP server 11429296 exiting +2022-10-24 01:45:13.307 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:45:15.118 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:45:15.136 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:45:23.262 -04:00 [DBG] System Connecion reset by client +2022-10-24 01:45:36.589 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:49:11.869 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:49:11.886 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:49:15.692 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:49:15.693 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:49:20.263 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:49:20.281 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:49:22.780 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 01:49:22.780 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 01:49:25.157 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 01:49:25.174 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 01:49:27.185 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 17:49:18.980 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 17:49:18.999 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 17:49:34.548 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 17:49:34.549 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 17:49:42.049 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 17:49:42.068 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 17:49:51.675 -04:00 [DBG] System Connecion reset by client +2022-10-24 17:51:38.005 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 21:59:26.919 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 21:59:26.938 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 22:01:21.771 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 22:01:21.771 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-24 22:01:21.771 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 22:01:28.556 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 22:01:28.575 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 22:01:38.074 -04:00 [DBG] System Connecion reset by client +2022-10-24 22:01:46.240 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 22:07:18.936 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 22:07:18.955 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 22:07:55.743 -04:00 [DBG] System Connecion reset by client +2022-10-24 22:07:59.049 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-24 22:09:47.042 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-24 22:09:47.060 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-24 22:10:09.606 -04:00 [DBG] System Connecion reset by client +2022-10-24 22:10:23.430 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-25 00:29:37.293 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-25 00:29:37.311 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-25 00:30:33.162 -04:00 [VRB] System Failed to receive transport data within a timeout period Read was canceled on underlying PipeReader. +2022-10-25 00:31:56.655 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:31:56.671 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:33:27.220 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:34:46.074 -04:00 [VRB] System Failed to receive transport data within a timeout period Read was canceled on underlying PipeReader. +2022-10-25 00:35:12.047 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:37:26.296 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-25 00:37:26.296 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-25 00:37:26.297 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-25 00:37:48.266 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-25 00:37:48.284 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-25 00:38:23.739 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:38:23.740 -04:00 [DBG] System Connecion reset by client +2022-10-25 00:39:39.800 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-26 15:26:17.131 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-26 15:26:17.196 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-26 15:27:52.245 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-26 17:07:38.981 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-26 17:07:39.000 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-26 17:12:40.164 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-26 17:12:40.164 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-26 17:12:40.164 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 00:51:32.192 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 00:51:32.210 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 13:02:14.076 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 13:02:14.076 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 13:02:14.076 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 13:29:26.035 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 13:29:26.112 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 13:29:30.726 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 13:29:30.726 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 13:29:36.023 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 13:29:36.040 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 13:31:49.835 -04:00 [DBG] System Connecion reset by client +2022-10-27 13:31:49.844 -04:00 [DBG] System Connecion reset by client +2022-10-27 13:32:57.854 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 13:58:49.380 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 13:58:49.399 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 13:59:14.674 -04:00 [DBG] System Connecion reset by client +2022-10-27 13:59:35.188 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 14:01:41.391 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 14:01:41.411 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 14:03:02.181 -04:00 [DBG] System Connecion reset by client +2022-10-27 14:03:02.181 -04:00 [DBG] System Connecion reset by client +2022-10-27 15:07:59.390 -04:00 [DBG] System Connecion reset by client +2022-10-27 15:08:25.183 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 15:11:11.120 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 15:11:11.141 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 15:11:32.131 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 15:18:00.366 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 15:18:00.384 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 15:18:05.644 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 15:18:09.543 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 15:18:09.561 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:27:34.363 -04:00 [DBG] System Connecion reset by client +2022-10-27 16:27:34.363 -04:00 [DBG] System Connecion reset by client +2022-10-27 16:36:57.886 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:36:57.886 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:36:57.886 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:42:37.572 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:42:37.590 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:42:50.627 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:42:50.629 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:45:12.560 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:45:12.579 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:45:21.541 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:45:24.088 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:45:24.105 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:45:45.757 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:45:45.757 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:45:45.759 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:45:49.398 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:45:49.415 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:46:07.275 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:46:07.275 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:46:07.277 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 16:46:59.911 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:46:59.931 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 16:47:06.875 -04:00 [VRB] System Failed to receive transport data within a timeout period A task was canceled. +2022-10-27 16:47:06.878 -04:00 [INF] System HTTP server 33711845 exiting +2022-10-27 16:47:11.809 -04:00 [DBG] System Suggestion: Setting accept threads to 24 +2022-10-27 16:47:11.826 -04:00 [INF] System HTTP server 33711845 listening for connections +2022-10-27 22:24:13.989 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 22:24:13.989 -04:00 [VRB] System Failed to receive transport data within a timeout period The operation was canceled. +2022-10-27 22:24:13.989 -04:00 [INF] System HTTP server 33711845 exiting diff --git a/Plugins/SessionProvider/GlobalCache.cs b/Plugins/SessionProvider/GlobalCache.cs new file mode 100644 index 0000000..ff16f47 --- /dev/null +++ b/Plugins/SessionProvider/GlobalCache.cs @@ -0,0 +1,141 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +//using VNLib.Data.Caching; +//using VNLib.Net.Messaging.FBM.Client; +//using VNLib.Net.Messaging.FBM.Client.Exceptions; + + +namespace VNLib.Plugins.Essentials.Sessions +{ + /*internal class GlobalCache : IGlobalCacheProvider + { + private readonly FBMClient Client; + private readonly TimeSpan OperationTimeout; + + public GlobalCache(FBMClient cacheProvider, TimeSpan cancellation) + { + this.Client = cacheProvider; + this.OperationTimeout = cancellation; + } + + //If the wait handle will block, the client is connected + bool IGlobalCacheProvider.IsConnected => !Client.ConnectionStatusHandle.WaitOne(0); + + async Task IGlobalCacheProvider.DeleteAsync(string key) + { + if (OperationTimeout > TimeSpan.Zero && OperationTimeout < TimeSpan.MaxValue) + { + CancellationTokenSource cts = new(OperationTimeout); + try + { + //Delete value + await Client.DeleteObjectAsync(key, cts.Token); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + catch (OperationCanceledException) + { + throw new TimeoutException("The operation has been cancelled, due to a timeout"); + } + finally + { + cts.Dispose(); + } + } + else + { + try + { + //Delete value + await Client.DeleteObjectAsync(key); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + } + } + + async Task<T> IGlobalCacheProvider.GetAsync<T>(string key) + { + if (OperationTimeout > TimeSpan.Zero && OperationTimeout < TimeSpan.MaxValue) + { + CancellationTokenSource cts = new(OperationTimeout); + try + { + //Try to get the value + return await Client.GetObjectAsync<T>(key, cts.Token); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + catch (OperationCanceledException) + { + throw new TimeoutException("The operation has been cancelled, due to a timeout"); + } + finally + { + cts.Dispose(); + } + } + else + { + try + { + //Try to get the value + return await Client.GetObjectAsync<T>(key); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + } + } + + async Task IGlobalCacheProvider.SetAsync<T>(string key, T value) + { + if (OperationTimeout > TimeSpan.Zero && OperationTimeout < TimeSpan.MaxValue) + { + CancellationTokenSource cts = new(OperationTimeout); + try + { + await Client.AddOrUpdateObjectAsync(key, null, value, cts.Token); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + catch (OperationCanceledException) + { + throw new TimeoutException("The operation has been cancelled, due to a timeout"); + } + finally + { + cts.Dispose(); + } + } + else + { + try + { + await Client.AddOrUpdateObjectAsync(key, null, value); + } + catch (FBMException fbm) + { + //Catch fbm excpetions and wrap them in global cache exception + throw new GlobalCacheException("Failed to delete cache record, see inner exception", fbm); + } + } + } + }*/ +} diff --git a/Plugins/SessionProvider/LocalizedLogProvider.cs b/Plugins/SessionProvider/LocalizedLogProvider.cs new file mode 100644 index 0000000..2bd9bc4 --- /dev/null +++ b/Plugins/SessionProvider/LocalizedLogProvider.cs @@ -0,0 +1,48 @@ +using System; + +using VNLib.Utils.Logging; + +namespace VNLib.Plugins.Essentials.Sessions +{ + internal sealed class LocalizedLogProvider : ILogProvider + { + private readonly ILogProvider Log; + private readonly string LogPrefix; + + public LocalizedLogProvider(ILogProvider log, string prefix) + { + Log = log; + LogPrefix = prefix; + } + + public void Flush() + { + Log.Flush(); + } + + public object GetLogProvider() + { + return Log.GetLogProvider(); + } + + public void Write(LogLevel level, string value) + { + Log.Write(level, $"[{LogPrefix}]: {value}"); + } + + public void Write(LogLevel level, Exception exception, string value = "") + { + Log.Write(level, exception, $"[{LogPrefix}]: {value}"); + } + + public void Write(LogLevel level, string value, params object[] args) + { + Log.Write(level, $"[{LogPrefix}]: {value}", args); + } + + public void Write(LogLevel level, string value, params ValueType[] args) + { + Log.Write(level, $"[{LogPrefix}]: {value}", args); + } + } +} diff --git a/Plugins/SessionProvider/SessionClientEntryPoint.cs b/Plugins/SessionProvider/SessionClientEntryPoint.cs new file mode 100644 index 0000000..07be1ef --- /dev/null +++ b/Plugins/SessionProvider/SessionClientEntryPoint.cs @@ -0,0 +1,123 @@ +using System; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; + +using VNLib.Net.Http; +using VNLib.Utils.Logging; +using VNLib.Plugins.Extensions.Loading; + +namespace VNLib.Plugins.Essentials.Sessions +{ + /// <summary> + /// The implementation type for dynamic loading of unified session providers + /// </summary> + public sealed class SessionClientEntryPoint : PluginBase, ISessionProvider + { + public override string PluginName => "Essentials.Sessions"; + + + private readonly List<AssemblyLoader<IRuntimeSessionProvider>> ProviderLoaders = new(); + + private IRuntimeSessionProvider[] ProviderArray = Array.Empty<IRuntimeSessionProvider>(); + + + ValueTask<SessionHandle> ISessionProvider.GetSessionAsync(IHttpEvent entity, CancellationToken token) + { + //Loop through providers + for (int i = 0; i < ProviderArray.Length; i++) + { + //Check if provider can process the entity + if (ProviderArray[i].CanProcess(entity)) + { + //Get session + return ProviderArray[i].GetSessionAsync(entity, token); + } + } + + //Return empty session + return new ValueTask<SessionHandle>(SessionHandle.Empty); + } + + protected override void OnLoad() + { + try + { + Log.Verbose("Loading all specified session providers"); + + //Get all provider names + IEnumerable<string> providerAssemblyNames = PluginConfig.GetProperty("provider_assemblies") + .EnumerateArray() + .Where(s => s.GetString() != null) + .Select(s => s.GetString()!); + + + foreach(string asm in providerAssemblyNames) + { + Log.Verbose("Loading {dll} session provider", asm); + + //Attempt to load provider + AssemblyLoader<IRuntimeSessionProvider> prov = this.LoadAssembly<IRuntimeSessionProvider>(asm); + + //Create localized log + LocalizedLogProvider log = new(Log, $"{Path.GetFileName(asm)}"); + + //Try to load the websessions + prov.Resource.Load(this, log); + + //Add provider to list + ProviderLoaders.Add(prov); + } + + if(ProviderLoaders.Count > 0) + { + //Create array for searching for providers + ProviderArray = ProviderLoaders.Select(s => s.Resource).ToArray(); + + Log.Information("Loaded {count} session providers", ProviderArray.Length); + } + else + { + Log.Information("No session providers loaded"); + } + + Log.Information("Plugin loaded"); + } + catch (KeyNotFoundException knf) + { + //Dispose providers + ProviderLoaders.ForEach(s => s.Dispose()); + + Log.Warn("Plugin configuration was missing required variables {var}", knf.Message); + } + catch + { + //Dispose providers + ProviderLoaders.ForEach(s => s.Dispose()); + throw; + } + } + + protected override void OnUnLoad() + { + //Clear array + ProviderArray = Array.Empty<IRuntimeSessionProvider>(); + + //Cleanup assemblies + ProviderLoaders.ForEach(p => p.Dispose()); + ProviderLoaders.Clear(); + + Log.Information("Plugin unloaded"); + } + + protected override void ProcessHostCommand(string cmd) + { + if (!this.IsDebug()) + { + return; + } + } + } +} diff --git a/Plugins/SessionProvider/SessionProvider.csproj b/Plugins/SessionProvider/SessionProvider.csproj new file mode 100644 index 0000000..d20a524 --- /dev/null +++ b/Plugins/SessionProvider/SessionProvider.csproj @@ -0,0 +1,56 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net6.0</TargetFramework> + <RootNamespace>VNLib.Plugins.Essentials.Sessions</RootNamespace> + <AssemblyName>SessionProvider</AssemblyName> + <PackageId>SessionProvider</PackageId> + <Authors>Vaughn Nugent</Authors> + <Product>SessionProvider</Product> + <Copyright>Copyright © 2022 Vaughn Nugent</Copyright> + <Version>1.0.3.1</Version> + <PackageProjectUrl>www.vaughnnugent.com/resources</PackageProjectUrl> + <Platforms>AnyCPU;x64</Platforms> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="ErrorProne.NET.CoreAnalyzers" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + <PackageReference Include="ErrorProne.NET.Structs" Version="0.1.2"> + <PrivateAssets>all</PrivateAssets> + <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> + </PackageReference> + </ItemGroup> + + <!-- Resolve nuget dll files and store them in the output dir --> + <PropertyGroup> + <EnableDynamicLoading>true</EnableDynamicLoading> + <AssemblyVersion>1.0.2.1</AssemblyVersion> + <FileVersion>1.0.2.1</FileVersion> + <Nullable>enable</Nullable> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <Deterministic>False</Deterministic> + </PropertyGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\..\VNLib\Utils\src\VNLib.Utils.csproj" /> + <ProjectReference Include="..\..\..\Extensions\VNLib.Plugins.Extensions.Loading\VNLib.Plugins.Extensions.Loading.csproj" /> + <ProjectReference Include="..\..\Libs\VNLib.Plugins.Essentials.Sessions.Runtime\VNLib.Plugins.Essentials.Sessions.Runtime.csproj" /> + </ItemGroup> + + <ItemGroup> + <None Update="SessionProvider.json"> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + </ItemGroup> + + <Target Name="PostBuild" AfterTargets="PostBuildEvent"> + <Exec Command="start xcopy "$(TargetDir)" "F:\Programming\Web Plugins\DevPlugins\$(TargetName)" /E /Y /R" /> + </Target> + +</Project> diff --git a/README.md b/README.md new file mode 100644 index 0000000..2442cb3 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# VNLib.Plugins.Essentials.Sessions + +All HTTP session related libraries and plugins
\ No newline at end of file |