/// <summary>
/// Returns true if new InternalClient is created. Returns false if InternalClient with ClientID is found
/// </summary>
/// <param name="ClientID"></param>
/// <param name="ClientName"></param>
/// <returns></returns>
public static bool CreateInternalClient(string ClientID, string ClientName)
{
try
{
using (var db = new LiteDatabase(AppKeys.GetDataContextString()))
{
var clients = db.GetCollection <InternalClient>("clients");
var newclient = clients.Find(x => x.clientID == ClientID).FirstOrDefault();
if (newclient == null)
{
newclient = new InternalClient();
newclient.clientID = ClientID;
newclient.clientName = ClientName;
clients.Insert(newclient);
clients.EnsureIndex(x => x.clientID);
return(true);
}
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine("An Error has happened in the CreateInternalClient Method : {0}", ex.ToString());
return(false);
}
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportType">The transportType used (Http1 or Amqp)</param>
/// <returns>InternalClient</returns>
public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, TransportType transportType)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
#if !NETMF
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("certificate must be present in DeviceAuthenticationWithX509Certificate");
}
if (!connectionStringBuilder.Certificate.HasPrivateKey)
{
throw new ArgumentException("certificate in DeviceAuthenticationWithX509Certificate must have a private key");
}
InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportType));
dc.Certificate = connectionStringBuilder.Certificate;
return(dc);
}
#endif
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportType, null));
}
internal void StartLoginServer()
{
bool success = false;
//NOTIFY LOGIN SERVER
while (success == false)
{
try
{
Console.WriteLine("Connect to authentication server: {0}:{1}", _host_2, _port_2);
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect(_host_2, _port_2);
InterNetwork = new InternalClient(sock);
InterNetwork.WORLD_NOTIFYCATION();
success = true;
}
catch (SocketException)
{
Console.WriteLine("Cannot create connection with authentication server");
WriteError("NetworkManager", "Cannot create connection with authentication server");
Thread.Sleep(60000);
}
catch (Exception ex)
{
WriteError("NetworkManager", "A unknown exception occurred: {0} {1}", ex.Source, ex.Message);
Thread.Sleep(60000);
}
}
}
private static IInternalClient GetApi(CommandLineConfig config)
{
if (config.MomentumApiBaseUri == null)
{
throw new System.Exception("You must specify a MomentumApiBaseUri");
}
var tokenProviderOptions = new LogicTokenProviderOptions
{
AuthorizationScope = config.TokenProvider.AuthorizationScope,
ClientId = config.TokenProvider.ClientId,
ClientSecret = config.TokenProvider.ClientSecret,
AuthorizationTokenIssuer = config.TokenProvider.AuthorizationTokenIssuer,
};
if (config.TokenProvider.AuthorizationTokenIssuer != null)
{
tokenProviderOptions.AuthorizationTokenIssuer = config.TokenProvider.AuthorizationTokenIssuer;
}
var httpClient = new HttpClient();
var tokenProviderFactory = new LogicTokenProviderFactory(tokenProviderOptions);
var tokenProvider = tokenProviderFactory.GetProvider(httpClient);
var client = new InternalClient(new TokenCredentials(tokenProvider))
{
BaseUri = config.MomentumApiBaseUri,
};
Log.Information("Created API with Base URI {BaseUri}", client.BaseUri);
return(client);
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportSettings">Prioritized list of transportTypes and their settings</param>
/// <param name="options">The options that allow configuration of the device client instance during initialization.</param>
/// <returns>InternalClient</returns>
public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod,
ITransportSettings[] transportSettings, ClientOptions options = default)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
// Make sure client options is initialized with the correct transport setting.
EnsureOptionsIsSetup(connectionStringBuilder.Certificate, ref options);
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present.");
}
InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportSettings), options);
dc.Certificate = connectionStringBuilder.Certificate;
return(dc);
}
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportSettings, null, options));
}
public static void UpdatInternalClientByParameter(InternalClientProperties Property, object Value, string ClientID)
{
InternalClient client = null;
using (var db = new LiteDatabase(AppKeys.GetDataContextString()))
{
var clients = db.GetCollection <InternalClient>("clients");
client = clients.Find(x => x.clientID == ClientID).FirstOrDefault();
if (client != null)
{
var value = new object();
if (Property == InternalClientProperties.ClientStyles)
{
value = (List <InternalClientStyle>)Value;
}
else
{
value = Value.ToString();
}
client.GetType().GetProperty(Property.ToString()).SetValue(client, value);
clients.Update(client);
}
}
}
private void OnLoggedOn(SteamKit.SteamUser.LoggedOnCallback callback)
{
if (callback.Result == EResult.OK)
{
SuggestedCellId = callback.CellID;
_clientReadyEvent.Set();
}
else
{
if (callback.Result == EResult.AccountLogonDenied || callback.Result == EResult.AccountLoginDeniedNeedTwoFactor)
{
if (callback.Result == EResult.AccountLogonDenied)
{
EmailAuthCode = _codesProvider.GetEmailAuthenticationCode(Credentials);
}
else
{
TwoFactorCode = _codesProvider.GetTwoFactorAuthenticationCode(Credentials);
}
InternalClient.Connect();
}
else
{
FaultException = new SteamLogonException(callback.Result);
_clientFaultedEvent.Set();
}
}
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportSettings">Prioritized list of transportTypes and their settings</param>
/// <param name="options">The options that allow configuration of the device client instance during initialization.</param>
/// <returns>InternalClient</returns>
public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod,
ITransportSettings[] transportSettings, ClientOptions options = default)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("certificate must be present in DeviceAuthenticationWithX509Certificate");
}
InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportSettings), options);
dc.Certificate = connectionStringBuilder.Certificate;
return(dc);
}
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportSettings, null, options));
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportType">The transportType used (Http1, Amqp or Mqtt), <see cref="TransportType"/></param>
/// <param name="options">The options that allow configuration of the device client instance during initialization.</param>
/// <returns>InternalClient</returns>
public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, TransportType transportType, ClientOptions options = default)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
if (transportType != TransportType.Amqp_Tcp_Only &&
transportType != TransportType.Mqtt_Tcp_Only &&
authenticationMethod is DeviceAuthenticationWithX509Certificate &&
((DeviceAuthenticationWithX509Certificate)authenticationMethod).ChainCertificates != null)
{
throw new ArgumentException("Certificate chains are only supported on Amqp_Tcp_Only and Mqtt_Tcp_Only");
}
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
// Make sure client options is initialized with the correct transport setting.
EnsureOptionsIsSetup(connectionStringBuilder.Certificate, ref options);
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present.");
}
#pragma warning disable CA2000 // This is returned to client so cannot be disposed here.
InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportType), options);
#pragma warning restore CA2000
dc.Certificate = connectionStringBuilder.Certificate;
// Install all the intermediate certificates in the chain if specified.
if (connectionStringBuilder.ChainCertificates != null)
{
try
{
CertificateInstaller.EnsureChainIsInstalled(connectionStringBuilder.ChainCertificates);
}
catch (Exception ex)
{
if (Logging.IsEnabled)
{
Logging.Error(null, $"{nameof(CertificateInstaller)} failed to read or write to cert store due to: {ex}");
}
throw new UnauthorizedException($"Failed to provide certificates in the chain - {ex.Message}", ex);
}
}
return(dc);
}
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportType, null, options));
}
/// <inheritdoc/>
/// <exception cref="ArgumentNullException"></exception>
public Task StartAsync(IManagedMqttClientOptions options)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
return(InternalClient.StartAsync(options));
}
/// <inheritdoc/>
/// <exception cref="ArgumentNullException"></exception>
public Task PublishAsync(ManagedMqttApplicationMessage applicationMessage)
{
if (applicationMessage is null)
{
throw new ArgumentNullException(nameof(applicationMessage));
}
return(InternalClient.PublishAsync(applicationMessage));
}
/// <inheritdoc/>
/// <exception cref="ArgumentNullException"></exception>
public Task <MqttClientPublishResult> PublishAsync(MqttApplicationMessage applicationMessage, CancellationToken cancellationToken)
{
if (applicationMessage is null)
{
throw new ArgumentNullException(nameof(applicationMessage));
}
return(InternalClient.PublishAsync(applicationMessage, cancellationToken));
}
private DeviceClient(InternalClient internalClient)
{
this.internalClient = internalClient ?? throw new ArgumentNullException(nameof(internalClient));
if (this.internalClient.IotHubConnectionString?.ModuleId != null)
{
throw new ArgumentException("A module ID was specified in the connection string - please use ModuleClient for modules.");
}
}
public async Task PublishMessage <T>(T messagePayload, string topic) where T : class
{
var appMessage = new MqttApplicationMessageBuilder()
.WithContentType(typeof(T).Name)
.WithPayload(JsonConvert.SerializeObject(messagePayload))
.WithTopic(topic)
.Build();
await InternalClient.PublishAsync(appMessage, CancellationToken.None);
}
internal ModuleClient(InternalClient internalClient, ICertificateValidator certValidator)
{
this.internalClient = internalClient ?? throw new ArgumentNullException(nameof(internalClient));
this.certValidator = certValidator ?? throw new ArgumentNullException(nameof(certValidator));
if (string.IsNullOrWhiteSpace(this.internalClient.IotHubConnectionString?.ModuleId))
{
throw new ArgumentException("A valid module ID should be specified to create a ModuleClient");
}
}
public override void SetUp()
{
base.SetUp();
client = new InternalClient(endpoint);
var topology = new Topology(new int[0]);
var configuration = new Configuration(topology)
{
CurrentNodePort = port, OtherShardsPorts = new int[0]
};
container.Configure(c => c.For <IConfiguration>().Use(configuration));
}
private DeviceClient(InternalClient internalClient)
{
InternalClient = internalClient ?? throw new ArgumentNullException(nameof(internalClient));
if (InternalClient.IotHubConnectionString?.ModuleId != null)
{
throw new ArgumentException("A module Id was specified in the connection string - please use ModuleClient for modules.");
}
if (Logging.IsEnabled)
{
Logging.Associate(this, this, internalClient, nameof(DeviceClient));
}
}
/// <summary>
/// Клиент распределенного кеша
/// </summary>
/// <param name="options">Настройки работы клиента</param>
/// <param name="comparer">Функция сравнения ключей</param>
/// <param name="cache">Внешний кеш. Если не задат то будет использоваться свой внутренний кеш, уникальный на каждый экземпляр этого класса. При заданном значении сторонний код берет на себя переодический вызов ICache.TryFlush</param>
public DistributedCacheClient(DistributedCacheClientOptions options, IEqualityComparer <Tk> comparer, ICache <Tk, T> cache = null)
{
_batchInterval = options.BatchInterval;
_batchBlock = new BatchBlock <Tk>(options.BatchSize, new GroupingDataflowBlockOptions()
{
BoundedCapacity = options.MaxRequestedMessagesCount
});
_cache = new ClientCache <Tk, T>(_batchBlock, options.RepeatRequestInterval, comparer, cache);
_client = null;
_streamFactory = new ChunkedStreamFactory(
() => new ByteBuffer(System.Buffers.ArrayPool <byte> .Shared.Rent(MESSAGE_BUFFER)),
chunk => System.Buffers.ArrayPool <byte> .Shared.Return(((ByteBuffer)chunk).SwapBuffer()));
}
internal ModuleClient(InternalClient internalClient, ICertificateValidator certValidator)
{
InternalClient = internalClient ?? throw new ArgumentNullException(nameof(internalClient));
_certValidator = certValidator ?? throw new ArgumentNullException(nameof(certValidator));
if (string.IsNullOrWhiteSpace(InternalClient.IotHubConnectionString?.ModuleId))
{
throw new ArgumentException("A valid module Id should be specified to create a ModuleClient");
}
if (Logging.IsEnabled)
{
Logging.Associate(this, this, internalClient, nameof(ModuleClient));
}
}
private void OnDisconnected(SteamKit.SteamClient.DisconnectedCallback callback)
{
_clientReadyEvent.Reset();
if (_cancellationTokenSource.IsCancellationRequested || callback.UserInitiated)
{
return;
}
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
InternalClient.Connect();
});
}
private InternalClient CreateClient()
{
if (this.internalClient != null)
{
return(this.internalClient);
}
var tokenProvider = this.tokenProviderFactory.GetProvider(this.httpClient);
this.internalClient = new InternalClient(new TokenCredentials(tokenProvider))
{
BaseUri = this.options.CprServiceUri,
};
return(this.internalClient);
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportType">The transportType used (Http1, Amqp or Mqtt), <see cref="TransportType"/></param>
/// <param name="options">The options that allow configuration of the device client instance during initialization.</param>
/// <returns>InternalClient</returns>
public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, TransportType transportType, ClientOptions options = default)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("certificate must be present in DeviceAuthenticationWithX509Certificate");
}
// If the file upload transport settings hasn't been specified, we will create one using the client certificate on the connection string
if (options?.FileUploadTransportSettings == null)
{
var fileUploadTransportSettings = new Http1TransportSettings {
ClientCertificate = connectionStringBuilder.Certificate
};
if (options == null)
{
options = new ClientOptions {
FileUploadTransportSettings = fileUploadTransportSettings
};
}
else
{
options.FileUploadTransportSettings = fileUploadTransportSettings;
}
}
InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportType), options);
dc.Certificate = connectionStringBuilder.Certificate;
return(dc);
}
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportType, null, options));
}
private void GetClientUserData()
{
if (DataTable.Rows.Count.Equals(0))
{
Client = null;
return;
}
var row = DataTable.Rows[0];
Client.Id = row["id_cliente"].ToString();
Client.FirstName = row["nombre_cliente"].ToString();
Client.LastName = row["apellido_cliente"].ToString();
Client.Dni = row["DNI"].ToString();
Client.Profile.ProfileId = 3;
Client.Profile.ProfileName = row["Rol"].ToString();
}
Task <IIpcResult> IClient.Send(IIpcOperation operation)
{
Contract.Requires(operation != null);
if (InternalClient != null)
{
if (global::BuildXL.Ipc.ExternalApi.Commands.Command.Deserialize(operation.Payload) is RegisterFilesForBuildManifestCommand)
{
// Override for RegisterFileForBuildManifestCommand (Always true)
return(Task.FromResult(SendFn(operation)));
}
else
{
return(InternalClient.Send(operation));
}
}
return(Task.FromResult(SendFn(operation)));
}
/// <summary>
/// Create a InternalClient from individual parameters
/// </summary>
/// <param name="hostname">The fully-qualified DNS hostname of IoT hub</param>
/// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param>
/// <param name="authenticationMethod">The authentication method that is used</param>
/// <param name="transportSettings">Prioritized list of transportTypes and their settings</param>
/// <param name="options">The options that allow configuration of the device client instance during initialization.</param>
/// <returns>InternalClient</returns>
internal static InternalClient Create(
string hostname,
string gatewayHostname,
IAuthenticationMethod authenticationMethod,
ITransportSettings[] transportSettings,
ClientOptions options = default)
{
if (hostname == null)
{
throw new ArgumentNullException(nameof(hostname));
}
if (authenticationMethod == null)
{
throw new ArgumentNullException(nameof(authenticationMethod));
}
if (!string.IsNullOrWhiteSpace(options?.ModelId) &&
transportSettings.Any(x => x.GetTransportType() == TransportType.Http1))
{
throw new InvalidOperationException("Plug and Play is not supported over the HTTP transport.");
}
var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod);
// Make sure client options is initialized with the correct transport setting.
EnsureOptionsIsSetup(connectionStringBuilder.Certificate, ref options);
if (authenticationMethod is DeviceAuthenticationWithX509Certificate)
{
if (connectionStringBuilder.Certificate == null)
{
throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present.");
}
InternalClient dc = CreateFromConnectionString(
connectionStringBuilder.ToString(),
PopulateCertificateInTransportSettings(connectionStringBuilder, transportSettings),
options);
dc.Certificate = connectionStringBuilder.Certificate;
return(dc);
}
return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportSettings, null, options));
}
public static bool UpdateInternalClient(InternalClient Client)
{
try
{
using (var db = new LiteDatabase(AppKeys.GetDataContextString()))
{
var clients = db.GetCollection <InternalClient>("clients");
var dbclient = clients.Find(x => x.clientID == Client.clientID).FirstOrDefault();
//if there is no clientID and no clientName it's not a valid client to update from
if (!string.IsNullOrEmpty(Client.clientID) && !string.IsNullOrEmpty(Client.clientName))
{
//if it is not in the database add it
if (dbclient == null)
{
dbclient = new InternalClient();
dbclient.clientID = Client.clientID;
dbclient.clientName = Client.clientName;
clients.Insert(dbclient);
clients.EnsureIndex(x => x.clientID);
}
//never update the client ID or client name after the item has been created.
dbclient.EtsyID = Client.EtsyID;
dbclient.EtsyUserName = Client.EtsyUserName;
dbclient.AccessToken = Client.AccessToken;
dbclient.AccessSecretKey = Client.AccessSecretKey;
dbclient.ClientStyles = Client.ClientStyles;
dbclient.ClientDesigns = Client.ClientDesigns;
dbclient.EtsyShopIDs = Client.EtsyShopIDs;
clients.Update(dbclient);
return(true);
}
}
}
catch (Exception ex)
{
Console.WriteLine("An Error has happened in the GetInternalClientByID Method : {0}", ex.ToString());
return(false);
}
return(false);
}
internal InternalClient CreateClient()
{
lock (ClientLocker)
{
if (this._internalClient != null)
{
return(this._internalClient);
}
var tokenProvider = this._tokenProviderFactory.GetProvider(this.HttpClient);
this._internalClient = new InternalClient(new TokenCredentials(tokenProvider))
{
BaseUri = this._options.DocumentGenerationServiceUri ?? new Uri("https://gateway.kmdlogic.io/document-generation/v2"),
};
return(this._internalClient);
}
}
/// <summary>
/// Asks the underlying client to connect to Steam and perform a login with the given <see cref="Credentials"/>.
/// </summary>
/// <param name="cancellationToken">Cancellation token.</param>
/// <exception cref="SteamClientFaultedException">Client is faulted.</exception>
public async Task ConnectAsync(CancellationToken cancellationToken)
{
if (_isClientRunning)
{
return;
}
InternalClient.Connect();
var readyTask = _clientReadyEvent.WaitAsync(cancellationToken);
var faultedTask = _clientFaultedEvent.WaitAsync();
var task = await Task.WhenAny(readyTask, faultedTask);
if (task == faultedTask)
{
throw new SteamClientFaultedException(FaultException);
}
}
/// <summary>
/// Запуск локального кеша. Необходимо выполнить до начала работы с кешем. Завершение операции может быть только при отмене или исключительной ситуации что является завершением работы локального кеша
/// </summary>
/// <param name="connection_string">Строка подключения имеет формат "dc://host_or_ip/cache_endpoint"</param>
/// <param name="keepalive_interval">Интервал времени для проверки подключения с сервером, по умолчанию равен 90 сек</param>
/// <param name="reconnect_interval">Время ожидания между подключениями в случае потери соединения, по умолчанию равен 3 сек</param>
/// <param name="reconnect_count">Количество переподключений при разрыве связи. По истечению метод будет завершен с ошибкой, по умолчанию равен 60</param>
/// <param name="connect_timeout">Время ожидания подключения к серверу</param>
/// <param name="token">Токен отмены выполнения</param>
/// <returns></returns>
public async Task StartAsync(string connection_string, CancellationToken token, TimeSpan?keepalive_interval = null, TimeSpan?reconnect_interval = null, int?reconnect_count = null, TimeSpan?connect_timeout = null)
{
if (_client != null)
{
throw new InvalidOperationException();
}
var conn = DistributedCacheConnectionString.Parse(connection_string.Split(',').First(),
keepalive_interval ?? TimeSpan.FromSeconds(90), reconnect_interval ?? TimeSpan.FromSeconds(3), reconnect_count ?? 60, connect_timeout ?? TimeSpan.FromSeconds(10));
var builder = new UriBuilder("ws", conn.Host, conn.Port, conn.Path);
_client = new InternalClient(builder.Uri, conn.ConnectionOptions.KeepaliveInterval, conn.ConnectionOptions.ReconnectInterval, conn.ConnectionOptions.ConnectTimeout, conn.ConnectionOptions.ReconnectCount);
await _client.ConnectAsync(token);
var cache = _cache.StartAsync(_batchInterval, token);
var bacth = StartBatching(token);
var receive = StartReceive(token);
await Task.WhenAny(cache, bacth, receive);
}
public DiscordClient()
{
m_processID = Process.GetCurrentProcess().Id;
m_frameQueue = new Queue <Frame>();
m_messageQueue = new Queue <IMessage>();
m_commandQueue = new Queue <ICommand>();
m_state = e_RPCState.Disconnected;
switch (Environment.OSVersion.Platform)
{
case PlatformID.Unix:
{
m_internalClient = new UnixClient(this);
break;
}
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
{
m_internalClient = new WindowsClient(this);
break;
}
default:
{
Debug.Assert(false);
break;
}
}
m_nounce = 0;
}