internal static string GetEndpointAddress(this BindingScheme scheme, IConnectionOptions options, bool isMex = false)
{
string transport = string.Empty;
string serverHostName = options.HostName;
switch (scheme)
{
case BindingScheme.NAMED_PIPE:
transport = "net.pipe";
break;
case BindingScheme.TCP:
transport = "net.tcp";
serverHostName = $"{options.HostName}:{options.TCPPort}";
break;
}
if (isMex)
{
return($"{transport}://{serverHostName}/Codex/{options.ProcessID}/mex");
}
else
{
return($"{transport}://{serverHostName}/Codex/{options.ProcessID}/IPCService");
}
}
private static async Task <WebSocket> WebSocketFactory(Uri url, IConnectionOptions options, CancellationToken cancellationToken)
{
var ws = new System.Net.WebSockets.Managed.ClientWebSocket();
await ws.ConnectAsync(url, cancellationToken);
return(ws);
}
internal static Binding GetBinding(this BindingScheme scheme, IConnectionOptions options)
{
Binding binding = null;
switch (scheme)
{
case BindingScheme.TCP:
{
binding = new NetTcpBinding(SecurityMode.None);
NetTcpBinding tcpBinding = ((NetTcpBinding)binding);
tcpBinding.MaxBufferPoolSize = Constants.MAX_MSG_SIZE;
tcpBinding.MaxReceivedMessageSize = Constants.MAX_MSG_SIZE;
break;
}
case BindingScheme.NAMED_PIPE:
{
binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
NetNamedPipeBinding npBinding = ((NetNamedPipeBinding)binding);
npBinding.MaxBufferPoolSize = Constants.MAX_MSG_SIZE;
npBinding.MaxReceivedMessageSize = Constants.MAX_MSG_SIZE;
break;
}
}
if (binding != null)
{
binding.CloseTimeout = options.CloseTimeout;
binding.OpenTimeout = options.OpenTimeout;
binding.ReceiveTimeout = options.ReceiveTimeout;
binding.SendTimeout = options.SendTimeout;
}
return(binding);
}
public static ConnectionInformation ToConnectionInformation(this IConnectionOptions options)
{
return(new ConnectionInformation()
{
Identity = options.Identity,
Password = options.Password,
ServerUri = options.Uri,
Instance = options.Instance ?? $"{Environment.MachineName.ToLowerInvariant()}-cli",
Presence = new Presence
{
Status = options.PresenceStatus != null
? Enum.Parse <PresenceStatus>(options.PresenceStatus, true)
: PresenceStatus.Available,
RoutingRule = options.PresenceRoutingRule != null
? Enum.Parse <RoutingRule>(options.PresenceRoutingRule, true)
: RoutingRule.Instance,
},
Receipt = new Receipt()
{
Events = options.ReceiptEvents != null
? options.ReceiptEvents.Split(',').Select(e => Enum.Parse <Event>(e, true)).ToArray()
: new[] { Event.Accepted, Event.Received, Event.Consumed }
}
});
}
public static AudioEncoding[] GetAudioEncodings(this IConnectionOptions options)
{
if (options.AudioCodec == AudioCodec.Any)
{
return(((AudioEncoding[])Enum.GetValues(typeof(AudioEncoding))).ToArray());
}
return(new[] { options.AudioCodec.ToEncoding() });
}
internal static async Task <Connection> Create(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null)
{
var ws = await(connectionOptions.WebSocketFactory ?? DefaultWebSocketFactory)(
new Uri(url),
connectionOptions,
default).ConfigureAwait(false);
return(new Connection(url, connectionOptions.SlowMo, ws, loggerFactory));
}
private static async Task <WebSocket> CreateDefaultWebSocket(Uri url, IConnectionOptions options, CancellationToken cancellationToken)
{
var result = new ClientWebSocket();
result.Options.KeepAliveInterval = TimeSpan.Zero;
await result.ConnectAsync(url, cancellationToken).ConfigureAwait(false);
return(result);
}
public NotesRepository(IConnectionOptions connectionOptions)
{
var connectionString = connectionOptions.GetNotesDatabaseConnectionString();
var mongoUrl = MongoUrl.Create(connectionString);
var mongoClient = new MongoClient(mongoUrl);
var database = mongoClient.GetDatabase(mongoUrl.DatabaseName);
_persistedNotes = database.GetCollection <Note>(NoteCollectionName);
}
internal static async Task <Connection> Create(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null)
{
var transport = connectionOptions.Transport ?? new WebSocketTransport();
connectionOptions.WebSocketFactory = connectionOptions.WebSocketFactory ?? DefaultWebSocketFactory;
await transport.InitializeAsync(url, connectionOptions).ConfigureAwait(false);
return(new Connection(url, connectionOptions.SlowMo, transport, loggerFactory));
}
public Connection(WebSocket socket, WorkSession session, ImmutableArray <ICommandHandler> handlers, ArrayPool <byte> bufferPool, IConnectionOptions options = null)
{
_socket = socket;
_session = session;
_handlers = handlers;
_messageWriter = new FastUtf8JsonWriter(bufferPool);
_options = options ?? new MirrorSharpOptions();
_bufferPool = bufferPool;
_inputBuffer = bufferPool.Rent(InputBufferSize);
}
internal static async Task <Connection> Create(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null, CancellationToken cancellationToken = default)
{
#pragma warning disable 618
var transport = connectionOptions.Transport;
#pragma warning restore 618
if (transport == null)
{
var transportFactory = connectionOptions.TransportFactory ?? WebSocketTransport.DefaultTransportFactory;
transport = await transportFactory(new Uri(url), connectionOptions, cancellationToken);
}
return(new Connection(url, connectionOptions.SlowMo, transport, loggerFactory));
}
/// <summary>
/// Create A factory implementation of <typeparamref name="TConnection"/>
/// </summary>
/// <typeparam name="TConnection">Connection Type</typeparam>
/// <param name="options">Connection Option</param>
/// <returns>Factory Implementation SqlDbClient </returns>
public static async Task <SqlClient> ConnectAsync <TConnection>(IConnectionOptions options) where TConnection : ISqlClient, new()
{
ISqlClient impl = new TConnection
{
Options = options
};
if (await impl.ConnectAsync())
{
return(new SqlClient(impl));
}
throw new System.OperationCanceledException("Unable to connect to Database");
}
public IConnection CreateConnection(IConnectionOptions options)
{
var factory = new ConnectionFactory
{
DispatchConsumersAsync = true,
HostName = options.Host,
Password = options.Password ?? ConnectionFactory.DefaultPass,
UserName = options.User ?? ConnectionFactory.DefaultUser,
VirtualHost = options.VirtualHost ?? ConnectionFactory.DefaultVHost
};
return(factory.CreateConnection());
}
/// <summary>
/// Initialize the Transport
/// </summary>
/// <param name="url">Chromium URL</param>
/// <param name="connectionOptions">Connection options</param>
/// <param name="loggerFactory">Logger factory</param>
public virtual async Task InitializeAsync(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null)
{
_client = await connectionOptions.WebSocketFactory(
new Uri(url),
connectionOptions,
default).ConfigureAwait(false);
_queueRequests = connectionOptions.EnqueueTransportMessages;
if (_startReading)
{
StartReading();
}
}
internal static async Task <Connection> Create(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null)
{
var transport = connectionOptions.Transport;
if (transport == null)
{
var ws = await(connectionOptions.WebSocketFactory ?? DefaultWebSocketFactory)(
new Uri(url),
connectionOptions,
default).ConfigureAwait(false);
transport = new WebSocketTransport(ws, connectionOptions.EnqueueTransportMessages);
}
return(new Connection(url, connectionOptions.SlowMo, transport, loggerFactory));
}
internal static List <Uri> GetBaseAddresses(this IConnectionOptions options)
{
List <Uri> baseAddresses = new List <Uri>();
if (options.Scheme.IsBindingScheme(BindingScheme.NAMED_PIPE))
{
baseAddresses.Add(new Uri(BindingScheme.NAMED_PIPE.GetEndpointAddress(options, false)));
}
if (options.Scheme.IsBindingScheme(BindingScheme.TCP))
{
baseAddresses.Add(new Uri(BindingScheme.TCP.GetEndpointAddress(options, false)));
}
return(baseAddresses);
}
/// <summary>
/// WebSocket factory to support Windows 7 and Windows Server 2008.
/// https://github.com/hardkoded/puppeteer-sharp/issues/1368#issuecomment-580946444
/// The minimum Windows versions supporting the WebSocket library are Windows 8 and Windows Server 2012.
/// <see href="https://github.com/hardkoded/puppeteer-sharp#prerequisites"/>.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="socketOptions">The socket options.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The WebSocket factory.</returns>
private static async Task <WebSocket> WebSocketFactory(Uri uri, IConnectionOptions socketOptions, CancellationToken cancellationToken)
{
var client = SystemClientWebSocket.CreateClientWebSocket();
if (client is System.Net.WebSockets.Managed.ClientWebSocket managed)
{
managed.Options.KeepAliveInterval = TimeSpan.FromSeconds(0);
await managed.ConnectAsync(uri, cancellationToken);
}
else
{
var coreSocket = client as ClientWebSocket;
coreSocket.Options.KeepAliveInterval = TimeSpan.FromSeconds(0);
await coreSocket.ConnectAsync(uri, cancellationToken);
}
return(client);
}
public static ConnectionInformation ToConnectionInformation(this IConnectionOptions options)
{
Presence presence = null;
if (options.PresenceStatus != null)
{
presence = new Presence()
{
Status = Enum.Parse <PresenceStatus>(options.PresenceStatus, true),
RoutingRule = options.PresenceRoutingRule != null
? Enum.Parse <RoutingRule>(options.PresenceRoutingRule, true)
: RoutingRule.Instance,
};
}
Receipt receipt = null;
if (options.ReceiptEvents != null)
{
receipt = new Receipt()
{
Events = options
.ReceiptEvents
.Split(',')
.Select(e => Enum.Parse <Event>(e, true))
.ToArray()
};
}
return(new ConnectionInformation()
{
Identity = options.Identity,
Password = options.Password,
Key = options.Key,
Token = options.Token,
Issuer = options.Issuer,
CertificateThumbprint = options.CertificateThumbprint,
DomainRole = options.DomainRole,
ServerUri = options.Uri,
Instance = options.Instance ?? $"{Environment.MachineName.ToLowerInvariant()}-cli",
Presence = presence,
Receipt = receipt
});
}
/// <summary>
/// converts the configuration to a service stack redis Uri
/// </summary>
/// <param name="options">connection options</param>
/// <returns>redis uri</returns>
public static ConfigurationOptions ToStackExchange(this IConnectionOptions options)
{
options = Arguments.EnsureNotNull(options, nameof(options));
var port = options.Endpoint.Port;
if (options.Endpoint.Port == -1)
{
port = Defaults.Port;
}
var cfg = new ConfigurationOptions();
cfg.EndPoints.Add(options.Endpoint.Host, port);
cfg.ClientName = options.Credential?.UserName;
cfg.Password = options.Credential?.Password;
return(cfg);
}
/// <summary>
/// converts the configuration to stack exchange config
/// </summary>
/// <param name="options">connection options</param>
/// <returns>redis uri</returns>
public static Uri ToServiceStackUri(this IConnectionOptions options)
{
options = Arguments.EnsureNotNull(options, nameof(options));
var ub = new UriBuilder($"redis://{options.Endpoint.Host}")
{
Port = options.Endpoint.Port,
};
if (ub.Port == -1)
{
ub.Port = Defaults.Port;
}
ub.Query = options.Endpoint.Query;
if (options.Credential != null)
{
ub.UserName = options.Credential.UserName;
ub.Password = options.Credential.Password;
}
return(ub.Uri);
}
protected SqlClientBase(IConnectionOptions options)
{
Options = options ?? throw new System.ArgumentNullException(nameof(options), "Connection option is empty");
}
public JogoBusiness(IConnectionOptions conOpt) : base(conOpt)
{
}
public IdentityStorage(string connectionUri, IConnectionOptions options)
: base(connectionUri, options)
{
}
private static async Task <IConnectionTransport> CreateAspNetTransport(Uri url, IConnectionOptions connectionOptions, CancellationToken cancellationToken)
{
var webSocketFactory = connectionOptions.WebSocketFactory ?? DefaultWebSocketFactory;
var webSocket = await webSocketFactory(url, connectionOptions, cancellationToken);
return(new AspNetWebSocketTransport(webSocket, connectionOptions.EnqueueTransportMessages));
}
public override async Task InitializeAsync(string url, IConnectionOptions connectionOptions, ILoggerFactory loggerFactory = null)
{
await base.InitializeAsync(url, connectionOptions, loggerFactory).ConfigureAwait(false);
HostingEnvironment.QueueBackgroundWorkItem((cts) => GetResponseAsync());
}
public MSSqlClient(IConnectionOptions options) : base(options)
{
}
private static async Task <IConnectionTransport> CreateDefaultTransport(Uri url, IConnectionOptions connectionOptions, CancellationToken cancellationToken)
{
var webSocketFactory = connectionOptions.WebSocketFactory ?? DefaultWebSocketFactory;
var webSocket = await webSocketFactory(url, connectionOptions, cancellationToken).ConfigureAwait(false);
return(new WebSocketTransport(webSocket, DefaultTransportScheduler, connectionOptions.EnqueueTransportMessages));
}
public override void ProcessQuery(CancellationToken cancellationToken, Query query, Action <IDataReader, CancellationToken> action, IConnectionOptions connectionOptions)
{
CreateAndExecuteQueryCommand(connectionOptions, query, command => {
using (IDataReader reader = command.ExecuteReader(CommandBehavior.Default)) {
action(reader, cancellationToken);
}
});
}
/// <summary>
/// Регистрация различных БД
/// </summary>
/// <param name="dbType">Тип БД</param>
/// <param name="connectionOptions">Строка подключения</param>
public static void RegisterConnectionOptions(DbTypeEnum dbType, IConnectionOptions connectionOptions)
{
DataBases.Add(dbType, connectionOptions);
}
public BusinessBase(IConnectionOptions conOpt)
{
this.repo = (Repository)Activator.CreateInstance(typeof(Repository), conOpt);
}
