public void Read(BinaryReader reader) { if (reader == null) throw new ArgumentNullException("reader"); Config = ClusterConfig.Read(reader); }
public async Task GetClusterList() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int readyClusters = 10; int deletingCluster = 4; int newClusters = 2; int removeClusters = 1; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, deletingCluster, ClusterStatus.Deleting); await this.AddClusters(tx, dictionary, newClusters, ClusterStatus.New); await this.AddClusters(tx, dictionary, removeClusters, ClusterStatus.Remove); await tx.CommitAsync(); } IEnumerable<ClusterView> actual = await target.GetClusterListAsync(); Assert.AreEqual(readyClusters, actual.Count()); }
// todo : Schedule class public void AssignTo(Estimation estimation) { if (estimation == null) { this.Time.Estimated = null; _assignedTo = new ClusterConfig(null, null); _state = TaskState.NotAssigned; } else AssignTo(estimation.ClusterName, estimation.Cores, estimation.Time); }
public void Read(BinaryReader reader) { if (reader == null) throw new ArgumentNullException("reader"); byte stepMode = reader.ReadByte(); if (!Enum.IsDefined(typeof(StepMode), stepMode)) throw new InvalidDataException("Unknown step mode: " + stepMode); Config = ClusterConfig.GetCompatibility((StepMode)stepMode, reader.ReadInt32(), reader.ReadByte() > 0); }
public async Task BalanceClusters() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.BalanceClustersAsync(config.MinimumClusterCount); ConditionalResult<IReliableDictionary<int, Cluster>> result = await stateManager.TryGetAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Assert.IsTrue(result.HasValue); Assert.AreEqual(config.MinimumClusterCount, await result.Value.GetCountAsync()); Assert.IsTrue(result.Value.All(x => x.Value.Status == ClusterStatus.New)); }
public async Task TestBalanceClusters() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; await target.BalanceClustersAsync(config.MinimumClusterCount); var result = await stateManager.TryGetAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Assert.IsTrue(result.HasValue); Assert.AreEqual(config.MinimumClusterCount, await result.Value.GetCountAsync()); Assert.IsTrue(result.Value.All(x => x.Value.Status == ClusterStatus.New)); }
public async Task Accepts_RequestVersion_Null() { var services = CreateServices(); var validator = services.GetRequiredService <IConfigValidator>(); var cluster = new ClusterConfig { ClusterId = "cluster1", HttpRequest = new ForwarderRequestConfig { Version = null, } }; var errors = await validator.ValidateClusterAsync(cluster); Assert.Empty(errors); }
public virtual Task ConfigureAsync(ClusterConfig clusterConfig, PoolConfig poolConfig) { Contract.RequiresNonNull(poolConfig, nameof(poolConfig)); this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; coinProperties = BitcoinProperties.GetCoinProperties(poolConfig.Coin.Type, poolConfig.Coin.Algorithm); logger = LogUtil.GetPoolScopedLogger(typeof(BitcoinPayoutHandler), poolConfig); var jsonSerializerSettings = ctx.Resolve <JsonSerializerSettings>(); daemon = new DaemonClient(jsonSerializerSettings); daemon.Configure(poolConfig.Daemons); return(Task.FromResult(true)); }
public void Configure(ClusterConfig clusterConfig, PoolConfig poolConfig) { this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; extraConfig = poolConfig.PaymentProcessing.Extra.SafeExtensionDataAs <EthereumPoolPaymentProcessingConfigExtra>(); logger = LogUtil.GetPoolScopedLogger(typeof(EthereumPayoutHandler), poolConfig); // configure standard daemon var jsonSerializerSettings = ctx.Resolve <JsonSerializerSettings>(); var daemonEndpoints = poolConfig.Daemons .Where(x => string.IsNullOrEmpty(x.Category)) .ToArray(); daemon = new DaemonClient(jsonSerializerSettings); daemon.Configure(daemonEndpoints); }
public async Task SetAvailableDestinationsPolicy_Works(string policy) { var services = CreateServices(); var validator = services.GetRequiredService <IConfigValidator>(); var cluster = new ClusterConfig { ClusterId = "cluster1", HealthCheck = new HealthCheckConfig { AvailableDestinationsPolicy = policy } }; var errors = await validator.ValidateClusterAsync(cluster); Assert.Empty(errors); }
public async Task HttpClient_HeaderEncoding_Valid() { var services = CreateServices(); var validator = services.GetRequiredService <IConfigValidator>(); var cluster = new ClusterConfig { ClusterId = "cluster1", HttpClient = new HttpClientConfig { RequestHeaderEncoding = "utf-8" } }; var errors = await validator.ValidateClusterAsync(cluster); Assert.Equal(0, errors.Count); }
/// <summary> /// Initializes a new instance of the <see cref="CqlConnection" /> class. /// </summary> /// <param name="connectionString"> The connection string. </param> public CqlConnection(string connectionString) { //get the cluster config, or add one if none exists ClusterConfig config = Configs.GetOrAdd(connectionString, connString => { //create new config var cc = new ClusterConfig(connString); //get if a similar already exists, or add it otherwise return(Configs.GetOrAdd(cc.ToString(), cc)); }); //fetch the cluster, or create one Cluster cluster = Clusters.GetOrAdd(config, conf => new Cluster(conf)); //set the connection provider to the cluster _cluster = cluster; }
private void ValidateHealthChecks(IList <Exception> errors, ClusterConfig cluster) { var availableDestinationsPolicy = cluster.HealthCheck?.AvailableDestinationsPolicy; if (string.IsNullOrEmpty(availableDestinationsPolicy)) { // The default. availableDestinationsPolicy = HealthCheckConstants.AvailableDestinations.HealthyAndUnknown; } if (!_availableDestinationsPolicies.ContainsKey(availableDestinationsPolicy)) { errors.Add(new ArgumentException($"No matching {nameof(IAvailableDestinationsPolicy)} found for the available destinations policy '{availableDestinationsPolicy}' set on the cluster.'{cluster.ClusterId}'.")); } ValidateActiveHealthCheck(errors, cluster); ValidatePassiveHealthCheck(errors, cluster); }
public override async Task ConfigureAsync(ClusterConfig clusterConfig, PoolConfig poolConfig, CancellationToken ct) { await base.ConfigureAsync(clusterConfig, poolConfig, ct); poolExtraConfig = poolConfig.Extra.SafeExtensionDataAs <EquihashPoolConfigExtra>(); // detect network var blockchainInfoResponse = await rpcClient.ExecuteAsync <BlockchainInfo>(logger, BitcoinCommands.GetBlockchainInfo, ct); network = Network.GetNetwork(blockchainInfoResponse.Response.Chain.ToLower()); chainConfig = poolConfig.Template.As <EquihashCoinTemplate>().GetNetwork(network.ChainName); // detect z_shieldcoinbase support var response = await rpcClient.ExecuteAsync <JObject>(logger, EquihashCommands.ZShieldCoinbase, ct); supportsNativeShielding = response.Error.Code != (int)BitcoinRPCErrorCode.RPC_METHOD_NOT_FOUND; }
public virtual Task ConfigureAsync(ClusterConfig cc, PoolConfig pc, CancellationToken ct) { Contract.RequiresNonNull(pc, nameof(pc)); poolConfig = pc; clusterConfig = cc; extraPoolConfig = pc.Extra.SafeExtensionDataAs <BitcoinDaemonEndpointConfigExtra>(); extraPoolPaymentProcessingConfig = pc.PaymentProcessing.Extra.SafeExtensionDataAs <BitcoinPoolPaymentProcessingConfigExtra>(); logger = LogUtil.GetPoolScopedLogger(typeof(BitcoinPayoutHandler), pc); var jsonSerializerSettings = ctx.Resolve <JsonSerializerSettings>(); rpcClient = new RpcClient(pc.Daemons.First(), jsonSerializerSettings, messageBus, pc.Id); return(Task.FromResult(true)); }
public virtual async Task ConfigureAsync(ClusterConfig clusterConfig, PoolConfig poolConfig, CancellationToken ct) { Contract.RequiresNonNull(poolConfig, nameof(poolConfig)); logger = LogUtil.GetPoolScopedLogger(typeof(ErgoPayoutHandler), poolConfig); this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; extraPoolPaymentProcessingConfig = poolConfig.PaymentProcessing.Extra.SafeExtensionDataAs <ErgoPaymentProcessingConfigExtra>(); ergoClient = ErgoClientFactory.CreateClient(poolConfig, clusterConfig, null); // detect chain var info = await ergoClient.GetNodeInfoAsync(ct); network = ErgoConstants.RegexChain.Match(info.Name).Groups[1].Value.ToLower(); }
/// <summary> /// Converts the <see cref="sourceValue" /> parameter to the <see cref="destinationType" /> parameter using <see cref="formatProvider" /// /> and <see cref="ignoreCase" /> /// </summary> /// <param name="sourceValue">the value to convert into an instance of <see cref="ClusterConfig" />.</param> /// <returns> /// an instance of <see cref="ClusterConfig" />, or <c>null</c> if there is no suitable conversion. /// </returns> public static object ConvertFrom(dynamic sourceValue) { if (null == sourceValue) { return(null); } try { ClusterConfig.FromJsonString(typeof(string) == sourceValue.GetType() ? sourceValue : sourceValue.ToJsonString()); } catch { // Unable to use JSON pattern } try { return(new ClusterConfig { AuthorizedPublicKeyList = sourceValue.AuthorizedPublicKeyList, Build = BuildInfoTypeConverter.ConvertFrom(sourceValue.Build), CaCertificateList = sourceValue.CaCertificateList, CertificationSigningInfo = CertificationSigningInfoTypeConverter.ConvertFrom(sourceValue.CertificationSigningInfo), ClientAuth = ClientAuthTypeConverter.ConvertFrom(sourceValue.ClientAuth), ClusterArch = sourceValue.ClusterArch, EnabledFeatureList = sourceValue.EnabledFeatureList, EncryptionStatus = sourceValue.EncryptionStatus, ExternalConfigurations = ExternalConfigurationsTypeConverter.ConvertFrom(sourceValue.ExternalConfigurations), GpuDriverVersion = sourceValue.GpuDriverVersion, IsAvailable = sourceValue.IsAvailable, ManagementServerList = sourceValue.ManagementServerList, OperationMode = sourceValue.OperationMode, RedundancyFactor = sourceValue.RedundancyFactor, ServiceList = sourceValue.ServiceList, SoftwareMap = sourceValue.SoftwareMap, SslKey = SslKeyTypeConverter.ConvertFrom(sourceValue.SslKey), SupportedInformationVerbosity = sourceValue.SupportedInformationVerbosity, Timezone = sourceValue.Timezone, }); } catch { } return(null); }
public virtual void Init(TBlockTemplate blockTemplate, string jobId, PoolConfig poolConfig, ClusterConfig clusterConfig, IMasterClock clock, IDestination poolAddressDestination, BitcoinNetworkType networkType, BitcoinExtraNonceProvider extraNonceProvider, bool isPoS, double shareMultiplier, IHashAlgorithm coinbaseHasher, IHashAlgorithm headerHasher, IHashAlgorithm blockHasher) { Contract.RequiresNonNull(blockTemplate, nameof(blockTemplate)); Contract.RequiresNonNull(poolConfig, nameof(poolConfig)); Contract.RequiresNonNull(clusterConfig, nameof(clusterConfig)); Contract.RequiresNonNull(clock, nameof(clock)); Contract.RequiresNonNull(poolAddressDestination, nameof(poolAddressDestination)); Contract.RequiresNonNull(extraNonceProvider, nameof(extraNonceProvider)); Contract.RequiresNonNull(coinbaseHasher, nameof(coinbaseHasher)); Contract.RequiresNonNull(headerHasher, nameof(headerHasher)); Contract.RequiresNonNull(blockHasher, nameof(blockHasher)); Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(jobId), $"{nameof(jobId)} must not be empty"); this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; this.clock = clock; this.poolAddressDestination = poolAddressDestination; this.networkType = networkType; BlockTemplate = blockTemplate; JobId = jobId; Difficulty = new Target(new NBitcoin.BouncyCastle.Math.BigInteger(BlockTemplate.Target, 16)).Difficulty; extraNoncePlaceHolderLength = extraNonceProvider.PlaceHolder.Length; this.isPoS = isPoS; this.shareMultiplier = shareMultiplier; this.coinbaseHasher = coinbaseHasher; this.headerHasher = headerHasher; this.blockHasher = blockHasher; blockTargetValue = BigInteger.Parse(BlockTemplate.Target, NumberStyles.HexNumber); previousBlockHashReversedHex = BlockTemplate.PreviousBlockhash .HexToByteArray() .ReverseByteOrder() .ToHexString(); BuildMerkleBranches(); BuildCoinbase(); }
public async Task BalancedStrategyManyRequests() { using (ShimsContext.Create()) { //create cluster var config = new ClusterConfig { NewConnectionTreshold = 20 }; var cluster = new Cluster(config); //create nodes var n = new Node(IPAddress.Parse("127.0.0.1"), cluster); var n2 = new Node(IPAddress.Parse("127.0.0.2"), cluster); var n3 = new Node(IPAddress.Parse("127.0.0.3"), cluster); var n4 = new Node(IPAddress.Parse("127.0.0.4"), cluster); var nodes = new Ring(new List <Node> { n, n2, n3, n4 }, "RandomPartitioner"); ShimAllConnections(); var logger = cluster.LoggerManager.GetLogger("BalancedStrategyManyRequestsTest"); IConnectionStrategy strategy = new BalancedConnectionStrategy(nodes, config); const int nr = 80; for (int i = 0; i < nr; i++) { Connection connection; using (logger.ThreadBinding()) connection = strategy.GetOrCreateConnection(PartitionKey.None); await connection.SendRequestAsync(new QueryFrame("", CqlConsistency.Any), logger, 10); } Assert.AreEqual(nodes.Sum(nd => nd.ConnectionCount), 8); Assert.IsTrue(nodes.All(nd => nd.ConnectionCount == 2)); Assert.IsTrue(nodes.SelectMany(nd => nd).All(c => c.Load == (80 * 10) / 4 / 2)); } }
public void SelectServer_ReturnsServerFroMappingTable() { var first = new ServerConfig { Ip = "192.168.0.1", Port = 5000 }; ClusterConfig config = new ClusterConfig { Servers = new[] { first } }; ServerProvider provider = new ServerProvider(config); ServerConfig selectedServer = provider.SelectServer(GetHashCode()); Assert.Equal(selectedServer, first); }
// Note this performs all validation steps without short circuiting in order to report all possible errors. public ValueTask <IList <Exception> > ValidateClusterAsync(ClusterConfig cluster) { _ = cluster ?? throw new ArgumentNullException(nameof(cluster)); var errors = new List <Exception>(); if (string.IsNullOrEmpty(cluster.ClusterId)) { errors.Add(new ArgumentException("Missing Cluster Id.")); } errors.AddRange(_transformBuilder.ValidateCluster(cluster)); ValidateLoadBalancing(errors, cluster); ValidateSessionAffinity(errors, cluster); ValidateProxyHttpClient(errors, cluster); ValidateProxyHttpRequest(errors, cluster); ValidateHealthChecks(errors, cluster); return(new ValueTask <IList <Exception> >(errors)); }
public NotificationService( ClusterConfig clusterConfig, IEnumerable <Meta <INotificationSender, NotificationSenderMetadataAttribute> > notificationSenders) { Contract.RequiresNonNull(clusterConfig, nameof(clusterConfig)); Contract.RequiresNonNull(notificationSenders, nameof(notificationSenders)); this.clusterConfig = clusterConfig; this.notificationSenders = notificationSenders; adminEmail = clusterConfig.Notifications?.Admin?.EmailAddress; adminPhone = null; queueSub = queue.GetConsumingEnumerable() .ToObservable(TaskPoolScheduler.Default) .Select(notification => Observable.FromAsync(() => SendNotificationAsync(notification))) .Concat() .Subscribe(); }
/// <summary> /// Adds BFF access token metadata to a cluster configuration /// </summary> /// <param name="config"></param> /// <param name="tokenType"></param> /// <returns></returns> public static ClusterConfig WithAccessToken(this ClusterConfig config, TokenType tokenType) { Dictionary <string, string> metadata; if (config.Metadata != null) { metadata = new Dictionary <string, string>(config.Metadata); } else { metadata = new(); } metadata.TryAdd(Constants.Yarp.TokenTypeMetadata, tokenType.ToString()); return(config with { Metadata = metadata }); }
public virtual Task ConfigureAsync(ClusterConfig clusterConfig, PoolConfig poolConfig) { Contract.RequiresNonNull(poolConfig, nameof(poolConfig)); this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; extraPoolConfig = poolConfig.Extra.SafeExtensionDataAs <BitcoinDaemonEndpointConfigExtra>(); extraPoolPaymentProcessingConfig = poolConfig.PaymentProcessing.Extra.SafeExtensionDataAs <BitcoinPoolPaymentProcessingConfigExtra>(); logger = LogUtil.GetPoolScopedLogger(typeof(BitcoinPayoutHandler), poolConfig); var jsonSerializerSettings = ctx.Resolve <JsonSerializerSettings>(); daemon = new DaemonClient(jsonSerializerSettings, messageBus, clusterConfig.ClusterName ?? poolConfig.PoolName, poolConfig.Id); daemon.Configure(poolConfig.Daemons); return(Task.FromResult(true)); }
public HealthProbeWorkerTests() { // Set up all the parameter needed for healthProberWorker. Provide <IMonotonicTimer, MonotonicTimer>(); Provide <ILogger, Logger <HealthProbeWorker> >(); Mock <IProxyHttpClientFactoryFactory>() .Setup(f => f.CreateFactory()) .Returns(new Mock <IProxyHttpClientFactory>().Object); // Set up clusters. We are going to fake multiple service for us to probe. _clusterManager = Provide <IClusterManager, ClusterManager>(); _clusterConfig = new ClusterConfig( healthCheckOptions: new ClusterConfig.ClusterHealthCheckOptions( enabled: true, interval: TimeSpan.FromSeconds(1), timeout: TimeSpan.FromSeconds(1), port: 8000, path: "/example"), loadBalancingOptions: default,
public async Task HttpClient_HeaderEncoding_Invalid() { var services = CreateServices(); var validator = services.GetRequiredService <IConfigValidator>(); var cluster = new ClusterConfig { ClusterId = "cluster1", HttpClient = new HttpClientConfig { RequestHeaderEncoding = "base64" } }; var errors = await validator.ValidateClusterAsync(cluster); Assert.Equal(1, errors.Count); Assert.Equal("Invalid header encoding 'base64'.", errors[0].Message); }
public async Task EnableSessionAffinity_Works() { var services = CreateServices(); var validator = services.GetRequiredService <IConfigValidator>(); var cluster = new ClusterConfig { ClusterId = "cluster1", SessionAffinity = new SessionAffinityConfig { Enabled = true, AffinityKeyName = "SomeKey" } }; var errors = await validator.ValidateClusterAsync(cluster); Assert.Empty(errors); }
public void ConfigureAsync(ClusterConfig clusterConfig, PoolConfig poolConfig) { this.poolConfig = poolConfig; this.clusterConfig = clusterConfig; extraConfig = poolConfig.PaymentProcessing.Extra.SafeExtensionDataAs <AionPoolPaymentExtraConfig>(); logger = LogUtil.GetPoolScopedLogger(typeof(AionPayoutHandler), poolConfig); // configure standard daemon var jsonSerializerSettings = ctx.Resolve <JsonSerializerSettings>(); var daemonEndpoints = poolConfig.Daemons .Where(x => string.IsNullOrEmpty(x.Category)) .ToArray(); daemon = new DaemonClient(jsonSerializerSettings, messageBus, clusterConfig.ClusterName ?? poolConfig.PoolName, poolConfig.Id); daemon.Configure(daemonEndpoints); rewardsCalculator = new AionRewardsCalculator(); }
public ICluster GetCluster(ClusterConfig clusterConfig) { clusterConfig.CheckArgumentNotNull("clusterConfig"); clusterConfig.Endpoints.CheckArgumentNotNull("clusterConfig.Endpoints"); TransportConfig transportConfig = clusterConfig.Transport ?? new TransportConfig(); IRecoveryService recoveryService = GetRecoveryService(transportConfig.Recoverable); KeyspaceConfig keyspaceConfig = clusterConfig.DefaultKeyspace ?? new KeyspaceConfig(); // create endpoints IEndpointSnitch snitch = ServiceActivator <Factory> .Create <IEndpointSnitch>(clusterConfig.Endpoints.Snitch, _logger); IEnumerable <IPAddress> endpoints = clusterConfig.Endpoints.Servers.Select(Network.Find).Where(x => null != x).ToArray(); if (!endpoints.Any()) { throw new ArgumentException("Expecting at least one valid endpoint"); } // create required services IEndpointStrategy endpointsManager = ServiceActivator <EndpointStrategy.Factory> .Create <IEndpointStrategy>(clusterConfig.Endpoints.Strategy, endpoints, snitch, _logger, clusterConfig.Endpoints); IConnectionFactory connectionFactory = ServiceActivator <Transport.Factory> .Create <IConnectionFactory>(transportConfig.Type, transportConfig, keyspaceConfig, _logger, _instrumentation); IPartitioner partitioner = ServiceActivator <Partitioner.Factory> .Create <IPartitioner>(clusterConfig.Partitioner); // create the cluster now ICluster cluster = ServiceActivator <Cluster.Factory> .Create <ICluster>(clusterConfig.Type, endpointsManager, _logger, connectionFactory, recoveryService, partitioner, clusterConfig); IDiscoveryService discoveryService = ServiceActivator <Discovery.Factory> .Create <IDiscoveryService>(clusterConfig.Endpoints.Discovery.Type, clusterConfig.Endpoints.Discovery, _logger, cluster); discoveryService.OnTopologyUpdate += endpointsManager.Update; cluster.OnClosed += discoveryService.SafeDispose; return(cluster); }
public void GetAvailableDestinations_HealthChecksDisabled_ReturnAll(HealthCheckConfig config) { var cluster = new ClusterConfig() { ClusterId = "cluster1", HealthCheck = config }; var allDestinations = new[] { new DestinationState("d1") { Health = { Active = DestinationHealth.Healthy } }, new DestinationState("d2") { Health = { Active = DestinationHealth.Unhealthy, Passive = DestinationHealth.Healthy } }, new DestinationState("d3") { Health = { Passive = DestinationHealth.Healthy } }, new DestinationState("d4"), new DestinationState("d5") { Health = { Active = DestinationHealth.Healthy, Passive = DestinationHealth.Unhealthy } }, new DestinationState("d6") { Health = { Active = DestinationHealth.Unhealthy, Passive = DestinationHealth.Unhealthy } } }; var policy = new HealthyAndUnknownDestinationsPolicy(); var availableDestinations = policy.GetAvailalableDestinations(cluster, allDestinations); Assert.Equal(6, availableDestinations.Count); Assert.Same(allDestinations[0], availableDestinations[0]); Assert.Same(allDestinations[1], availableDestinations[1]); Assert.Same(allDestinations[2], availableDestinations[2]); Assert.Same(allDestinations[3], availableDestinations[3]); Assert.Same(allDestinations[4], availableDestinations[4]); Assert.Same(allDestinations[5], availableDestinations[5]); }
public static (ClusterConfig, GrpcCoreRemoteConfig) CreateClusterConfig(IClusterSettings clusterSettings, IClusterProvider clusterProvider, IIdentityLookup identityLookup, IDescriptorProvider descriptorProvider, ILogger _logger) { //var portStr = Environment.GetEnvironmentVariable("PROTOPORT") ?? $"{RemoteConfigBase.AnyFreePort}"; var clusterName = clusterSettings.ClusterName; var hostip = Environment.GetEnvironmentVariable("PROTOHOST"); var host = clusterSettings.ClusterHost; var advertisedHost = clusterSettings.ClusterHost; var port = clusterSettings.ClusterPort; if ("protohost".Equals(host)) { host = hostip; advertisedHost = hostip; _logger.LogDebug($"Using PROTOHOST"); } _logger.LogDebug($"BindTo to {host} port {port}"); _logger.LogDebug($"WithAdvertisedHost to {advertisedHost}"); FileDescriptor[] descriptors = descriptorProvider.GetDescriptors(); // TOOD: This doesn't seem to work. Why? List <ChannelOption> options = new List <ChannelOption>() { new ChannelOption(ChannelOptions.MaxSendMessageLength, (100 * 1024 * 1024)), new ChannelOption(ChannelOptions.MaxReceiveMessageLength, (100 * 1024 * 1024)) }; GrpcCoreRemoteConfig remoteConfig = GrpcCoreRemoteConfig.BindTo(host, port) .WithEndpointWriterMaxRetries(0) .WithRemoteDiagnostics(true) .WithAdvertisedHost(advertisedHost) .WithProtoMessages(descriptors) .WithChannelOptions(options); var clusterConfig = ClusterConfig.Setup(clusterName, clusterProvider, identityLookup); return(clusterConfig, remoteConfig); }
private ClusterInfo GetClusterInfo(string id, int destinationCount, int?failureThreshold = null) { var metadata = failureThreshold != null ? new Dictionary <string, string> { { ConsecutiveFailuresHealthPolicyOptions.ThresholdMetadataName, failureThreshold.ToString() } } : null; var clusterConfig = new ClusterConfig( new Cluster { Id = id, HealthCheck = new HealthCheckOptions() { Active = new ActiveHealthCheckOptions { Enabled = true, Policy = "policy", Path = "/api/health/", }, }, Metadata = metadata, }, null); var clusterInfo = new ClusterInfo(id); clusterInfo.Config = clusterConfig; for (var i = 0; i < destinationCount; i++) { var destinationConfig = new DestinationConfig(new Destination { Address = $"https://localhost:1000{i}/{id}/", Health = $"https://localhost:2000{i}/{id}/" }); var destinationId = $"destination{i}"; clusterInfo.Destinations.GetOrAdd(destinationId, id => new DestinationInfo(id) { Config = destinationConfig }); } clusterInfo.ProcessDestinationChanges(); return(clusterInfo); }
private void StartAdminApi(ClusterConfig clusterConfig) { var address = clusterConfig.Api?.ListenAddress != null ? (clusterConfig.Api.ListenAddress != "*" ? IPAddress.Parse(clusterConfig.Api.ListenAddress) : IPAddress.Any) : IPAddress.Parse("127.0.0.1"); var port = clusterConfig.Api?.AdminPort ?? 4001; webHostAdmin = new WebHostBuilder() .Configure(app => { app.Run(HandleRequestAdmin); }) .UseKestrel(options => { options.Listen(address, port); }) .Build(); webHostAdmin.Start(); logger.Info(() => $"Admin API Online @ {address}:{port}"); }
public NotificationService( ClusterConfig clusterConfig, JsonSerializerSettings serializerSettings) { Contract.RequiresNonNull(clusterConfig, nameof(clusterConfig)); this.clusterConfig = clusterConfig; this.serializerSettings = serializerSettings; poolConfigs = clusterConfig.Pools.ToDictionary(x => x.Id, x => x); adminEmail = clusterConfig.Notifications?.Admin?.EmailAddress; adminPhone = null; queueSub = queue.GetConsumingEnumerable() .ToObservable(TaskPoolScheduler.Default) .Select(notification => Observable.FromAsync(() => SendNotificationAsync(notification))) .Concat() .Subscribe(); }
public override void Configure(PoolConfig poolConfig, ClusterConfig clusterConfig) { poolAddressBase58Prefix = LibCryptonote.DecodeAddress(poolConfig.Address); if (poolAddressBase58Prefix == 0) { logger.ThrowLogPoolStartupException("Unable to decode pool-address)", LogCat); } // extract standard daemon endpoints daemonEndpoints = poolConfig.Daemons .Where(x => string.IsNullOrEmpty(x.Category)) .ToArray(); // extract wallet daemon endpoints walletDaemonEndpoints = poolConfig.Daemons .Where(x => x.Category?.ToLower() == MoneroConstants.WalletDaemonCategory) .ToArray(); base.Configure(poolConfig, clusterConfig); }
private void StartMetrics(ClusterConfig clusterConfig) { var address = clusterConfig.Api?.ListenAddress != null ? (clusterConfig.Api.ListenAddress != "*" ? IPAddress.Parse(clusterConfig.Api.ListenAddress) : IPAddress.Any) : IPAddress.Parse("127.0.0.1"); var port = clusterConfig.Api?.MetricsPort ?? 4002; webHostMetrics = new WebHostBuilder() .Configure(app => { app.UseMetricServer(); }) .UseKestrel(options => { options.Listen(address, port); }) .Build(); webHostMetrics.Start(); logger.Info(() => $"Prometheus Metrics Online @ {address}:{port}/metrics"); }
public async Task JoinClusterSuccessful() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService( null, new MockMailer(), new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int id = 5; string email = "*****@*****.**"; Cluster cluster = new Cluster("test", ClusterStatus.Ready, 0, 0, "", new[] {80}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } await target.JoinClusterAsync(id, email); using (ITransaction tx = stateManager.CreateTransaction()) { Cluster actual = (await dictionary.TryGetValueAsync(tx, id)).Value; Assert.AreEqual(1, actual.Users.Count(x => x.Email == email)); } }
private void RaiseConfigChanged(ClusterConfig config) { var ccc = this.ClusterConfigChanged; // we got a new config, notify the pool to reload itself if (ccc != null) ccc(config); // trigger the event so Start stops blocking if (this.mre != null) this.mre.Set(); }
public async Task TargetClusterCapacityDecreaseAtMinCount() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int clusterCount = config.MinimumClusterCount + 1; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters( tx, dictionary, clusterCount, () => this.CreateCluster( ClusterStatus.Ready, new List<ClusterUser>( Enumerable.Repeat( new ClusterUser(), (int) Math.Floor((double) config.MaximumUsersPerCluster*config.UserCapacityLowPercentThreshold))))); await tx.CommitAsync(); } int expected = config.MinimumClusterCount; int actual = await target.GetTargetClusterCapacityAsync(); Assert.AreEqual(expected, actual); }
public async Task ProcessClustersAsyncDelete() { int key = 1; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterConfig config = new ClusterConfig(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = (name) => Task.FromResult(ClusterOperationStatus.ClusterNotFound) }; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Cluster original = this.CreateCluster(ClusterStatus.Deleting); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.SetAsync(tx, key, original); } ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.ProcessClustersAsync(); using (ITransaction tx = stateManager.CreateTransaction()) { ConditionalResult<Cluster> actual = await dictionary.TryGetValueAsync(tx, key); Assert.IsFalse(actual.HasValue); } }
private InternalState InitBasic(ClusterConfig config, ISaslAuthenticationProvider auth) { if (log.IsInfoEnabled) log.Info("No vbucket. Server count: " + (config.nodes == null ? 0 : config.nodes.Length)); // no vbucket config, use the node list and the ports var portType = this.configuration.Port; var tmp = config == null ? Enumerable.Empty<IMemcachedNode>() : (from node in config.nodes let ip = new IPEndPoint(IPAddress.Parse(node.hostname), (portType == BucketPortType.Proxy ? node.ports.proxy : node.ports.direct)) where node.status == "healthy" select (IMemcachedNode)(new BinaryNode(ip, this.configuration.SocketPool, auth))); return new InternalState { CurrentNodes = tmp.ToArray(), Locator = this.configuration.CreateNodeLocator() ?? new KetamaNodeLocator(), OpFactory = new Enyim.Caching.Memcached.Protocol.Binary.BinaryOperationFactory() }; }
public async Task JoinClusterUserAlreadyExists() { ClusterConfig config = new ClusterConfig() {MaximumUsersPerCluster = 2}; MockReliableStateManager stateManager = new MockReliableStateManager(); MockMailer mockMailer = new MockMailer(); ClusterService target = new ClusterService( null, mockMailer, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int idWithUser = 5; string email = "*****@*****.**"; Cluster clusterWithUser = new Cluster( "test", ClusterStatus.Ready, 0, 0, "", new[] {80, 81}, new[] {new ClusterUser(email, 80)}, DateTimeOffset.UtcNow); int idWithoutUser = 6; Cluster clusterWithoutUser = new Cluster( "test2", ClusterStatus.Ready, 0, 0, "", new[] {80, 81}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, idWithUser, clusterWithUser); await dictionary.AddAsync(tx, idWithoutUser, clusterWithoutUser); await tx.CommitAsync(); } try { await target.JoinClusterAsync(idWithoutUser, email); Assert.Fail("JoinClusterFailedException not thrown."); } catch (JoinClusterFailedException result) { Assert.AreEqual(JoinClusterFailedReason.UserAlreadyJoined, result.Reason); } }
public async Task JoinClusterNotReady() { ClusterConfig config = new ClusterConfig() {MaximumUsersPerCluster = 2}; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int id = 5; Cluster cluster = new Cluster( "test", ClusterStatus.Creating, 0, 0, "", new[] {80}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } try { await target.JoinClusterAsync(id, "email"); Assert.Fail("JoinClusterFailedException not thrown."); } catch (JoinClusterFailedException result) { Assert.AreEqual(JoinClusterFailedReason.ClusterNotReady, result.Reason); } }
public async Task BalanceClustersIncreaseBelowMin() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int readyCount = (int) Math.Floor(config.MinimumClusterCount/5D); int newCount = readyCount; int creatingCount = readyCount; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyCount, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, newCount, ClusterStatus.New); await this.AddClusters(tx, dictionary, creatingCount, ClusterStatus.Creating); await this.AddClusters(tx, dictionary, config.MinimumClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(readyCount*4); Assert.AreEqual( config.MinimumClusterCount, dictionary.Count( x => x.Value.Status == ClusterStatus.Ready || x.Value.Status == ClusterStatus.New || x.Value.Status == ClusterStatus.Creating)); }
public async Task JoinClusterEmailData() { ClusterConfig config = new ClusterConfig(); DateTimeOffset clusterCreated = DateTimeOffset.UtcNow; string expectedEmail = "*****@*****.**"; string expectedClusterAddress = "test.azure.com"; int expectedUserPort = 543; string expectedLinkAddress = "http://domain.com/app"; string expectedLinkText = "title"; string expectedLinkDesc = "desc"; string actualEmail = null; string actualClusterAddress = null; int actualUserPort = 0; HyperlinkView actualExplorerLink = null; HyperlinkView actualAppLink = null; MockMailer mailer = new MockMailer(); MockApplicationDeployService appDeploy = new MockApplicationDeployService() { GetApplicationDeploymentsAsyncFunc = (c, p) => Task.FromResult<IEnumerable<ApplicationView>>(new[] { new ApplicationView(new HyperlinkView(expectedLinkAddress, expectedLinkText, expectedLinkDesc)) }) }; mailer.SendJoinMailFunc = (receipientAddress, clusterAddress, userPort, timeRemaining, clusterExpiration, links) => { actualEmail = receipientAddress; actualClusterAddress = clusterAddress; actualUserPort = userPort; actualExplorerLink = links.ElementAt(0); actualAppLink = links.ElementAt(1); return Task.FromResult(true); }; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService( null, mailer, appDeploy, stateManager, this.CreateServiceParameters(), config); int id = 5; Cluster cluster = new Cluster("test", ClusterStatus.Ready, 0, 0, expectedClusterAddress, new[] { expectedUserPort }, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } await target.JoinClusterAsync(id, expectedEmail); Assert.AreEqual(expectedEmail, actualEmail); Assert.AreEqual(expectedClusterAddress + ":19000", actualClusterAddress); Assert.AreEqual(expectedUserPort, actualUserPort); Assert.AreEqual(expectedLinkAddress, actualAppLink.Address); Assert.AreEqual(expectedLinkText, actualAppLink.Text); Assert.AreEqual(expectedLinkDesc, actualAppLink.Description); Assert.AreEqual("http://" + expectedClusterAddress + ":19080/Explorer/index.html", actualExplorerLink.Address); }
private void ReconfigurePool(ClusterConfig config) { // kill the timer first this.isTimerActive = false; if (this.resurrectTimer != null) this.resurrectTimer.Change(Timeout.Infinite, Timeout.Infinite); if (config == null) { if (log.IsInfoEnabled) log.Info("Config is empty, all nodes are down."); Interlocked.Exchange(ref this.state, InternalState.Empty); return; } // these should be disposed after we've been reinitialized var oldNodes = this.state == null ? null : this.state.CurrentNodes; // default bucket does not require authentication // membase 1.6 tells us if a bucket needs authentication, // so let's try to use the config's password var password = config.authType == "sasl" ? config.saslPassword : this.bucketPassword; var authenticator = this.bucketName == null ? null : new PlainTextAuthenticator(null, this.bucketName, password); try { var state = (config == null || config.vBucketServerMap == null) ? this.InitBasic(config, authenticator) : this.InitVBucket(config, authenticator); var nodes = state.CurrentNodes; state.Locator.Initialize(nodes); // we need to subscribe the failed event, // so we can periodically check the dead // nodes, since we do not get a config // update every time a node dies for (var i = 0; i < nodes.Length; i++) nodes[i].Failed += this.NodeFail; Interlocked.Exchange(ref this.state, state); } catch (Exception e) { log.Error("Failed to initialize the pool.", e); Interlocked.Exchange(ref this.state, InternalState.Empty); } // kill the old nodes if (oldNodes != null) for (var i = 0; i < oldNodes.Length; i++) try { oldNodes[i].Failed -= this.NodeFail; oldNodes[i].Dispose(); } catch { } }
private InternalState InitVBucket(ClusterConfig config, ISaslAuthenticationProvider auth) { // we have a vbucket config, which has its own server list // it's supposed to be the same as the cluster config's list, // but the order is significicant (because of the bucket indexes), // so we we'll use this for initializing the locator var vbsm = config.vBucketServerMap; if (log.IsInfoEnabled) log.Info("Has vbucket. Server count: " + (vbsm.serverList == null ? 0 : vbsm.serverList.Length)); var epa = (from server in vbsm.serverList select ConfigurationHelper.ResolveToEndPoint(server)).ToArray(); var epaLength = epa.Length; for (var i = 0; i < vbsm.vBucketMap.Length; i++) { var vb = vbsm.vBucketMap[i]; if (vb == null || vb.Length == 0) throw new InvalidOperationException("Server sent an empty vbucket definition at index " + i); if (vb[0] >= epaLength || vb[0] < 0) throw new InvalidOperationException(String.Format("VBucket line {0} has a master index {1} out of range of the server list ({2})", i, vb[0], epaLength)); } var buckets = vbsm.vBucketMap.Select(a => new VBucket(a[0], a.Skip(1).ToArray())).ToArray(); var bucketNodeMap = buckets.ToLookup(vb => { try { return epa[vb.Master]; } catch (Exception e) { log.Error(e); throw; } } ); var vbnl = new VBucketNodeLocator(vbsm.hashAlgorithm, buckets); return new InternalState { CurrentNodes = epa.Select(ip => (IMemcachedNode)new BinaryNode(ip, this.configuration.SocketPool, auth)).ToArray(), Locator = vbnl, OpFactory = new VBucketAwareOperationFactory(vbnl) }; }
public async Task ProcessRemove() { bool calledActual = false; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { nameActual = name; calledActual = true; return Task.FromResult(true); } }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Remove); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, actual.Status); }
//public VBucketNodeLocator ForwardLocator { get { return this.state.ForwardLocator; } } private void InitNodes(ClusterConfig config) { if (log.IsInfoEnabled) log.Info("Received new configuration."); // we cannot overwrite the config while the timer is is running lock (this.DeadSync) this.ReconfigurePool(config); }
public async Task ProcessCreatingClusterFailed() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = name => Task.FromResult(ClusterOperationStatus.CreateFailed) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Creating); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Remove, actual.Status); Assert.AreEqual(0, actual.Ports.Count()); Assert.AreEqual(0, actual.Users.Count()); }
public async Task ProcessClustersAsyncSaveChanges() { int key = 1; string nameTemplate = "Test:{0}"; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterConfig config = new ClusterConfig(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = name => { return Task.FromResult(String.Format(nameTemplate, name)); } }; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Cluster original = this.CreateCluster(ClusterStatus.New); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.SetAsync(tx, key, original); } ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.ProcessClustersAsync(); using (ITransaction tx = stateManager.CreateTransaction()) { Cluster actual = (await dictionary.TryGetValueAsync(tx, key)).Value; Assert.AreNotEqual(original, actual); } }
public async Task ProcessCreatingClusterSuccess() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = name => Task.FromResult(ClusterOperationStatus.Ready) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Creating); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Ready, actual.Status); Assert.IsTrue(actual.CreatedOn.ToUniversalTime() <= DateTimeOffset.UtcNow); actual.Ports.SequenceEqual(await clusterOperator.GetClusterPortsAsync("")); }
/// <summary> /// When cluster config changes, update the static config /// list of bootstrap URIs with known working nodes from cluster config /// </summary> public void UpdateNodes(ClusterConfig config) { var currentUri = this.urls[this.urlIndex]; //last known good Uri var serverConfigUris = config.nodes.Where(n => n.Status == "healthy") //healthy nodes from config .Select(n => new UriBuilder( currentUri.Scheme, n.HostName, currentUri.Port, currentUri.PathAndQuery).Uri).ToList(); serverConfigUris.ForEach(u => statusPool[u] = true); var newConfigUris = serverConfigUris.Union(this.urls).ToArray(); //allow any client supplied URIs to remain Interlocked.Exchange(ref this.urls, newConfigUris); Interlocked.Exchange(ref this.urlIndex, 0); Interlocked.Exchange(ref this.realUrls, this.urls.Distinct().ToDictionary(u => u, u => (Uri)null)); }
public async Task ProcessNewCluster() { bool calledActual = false; string nameTemplate = "Test:{0}"; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = name => { nameActual = name; calledActual = true; return Task.FromResult(String.Format(nameTemplate, name)); } }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.New); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Creating, actual.Status); Assert.AreEqual(String.Format(nameTemplate, nameActual), actual.Address); }
public void AssignTo(string clusterName, int[] cores, TimeSpan time) { this.Time.Estimated = time; _assignedTo = new ClusterConfig(clusterName, cores); _state = TaskState.Assigned; }
private void ReconfigurePool(ClusterConfig config) { if (log.IsDebugEnabled) { if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "cbp_thread"; } } // kill the timer first this.isTimerActive = false; if (this.resurrectTimer != null) this.resurrectTimer.Change(Timeout.Infinite, Timeout.Infinite); if (config == null) { if (log.IsInfoEnabled) log.Info("Config is empty, all nodes are down."); return; //continue to use current state and wait for config update } var currentState = this.state; // these should be disposed after we've been reinitialized var oldNodes = currentState == null ? null : currentState.CurrentNodes; // default bucket does not require authentication // Couchbase 1.6 tells us if a bucket needs authentication, // so let's try to use the config's password var password = config.authType == "sasl" ? config.saslPassword : this.configuration.BucketPassword; var authenticator = this.configuration.Bucket == null ? null : new PlainTextAuthenticator(null, this.configuration.Bucket, password); try { var state = (config == null || config.vBucketServerMap == null) ? this.InitBasic(config, authenticator) : this.InitVBucket(config, authenticator); var nodes = state.CurrentNodes; state.Locator.Initialize(nodes); // we need to subscribe the failed event, // so we can periodically check the dead // nodes, since we do not get a config // update every time a node dies foreach (IMemcachedNode node in nodes) { node.Failed += this.NodeFail; } Interlocked.Exchange(ref this.state, state); } catch (Exception e) { log.Error("Failed to initialize the pool.", e); Interlocked.Exchange(ref this.state, InternalState.Empty); } //Clean up the old nodes CloseNodes(oldNodes); }
private InternalState InitBasic(ClusterConfig config, ISaslAuthenticationProvider auth) { if (log.IsInfoEnabled) log.Info("No vbucket. Server count: " + (config.nodes == null ? 0 : config.nodes.Length)); // the cluster can return host names in the server list, so // we ha ve to make sure they are converted to IP addresses var nodes = config == null ? Enumerable.Empty<IMemcachedNode>() : (from node in config.nodes let ip = new IPEndPoint(GetFirstAddress(node.HostName), node.Port) where node.Status == "healthy" select CreateNode(ip, auth, node.ConfigurationData)); return new InternalState { CurrentNodes = nodes.ToArray(), Locator = configuration.CreateNodeLocator() ?? new KetamaNodeLocator(), OpFactory = BasicCouchbaseOperationFactory.Instance }; }
private InternalState InitVBucket(ClusterConfig config, ISaslAuthenticationProvider auth) { // we have a vbucket config, which has its own server list // it's supposed to be the same as the cluster config's list, // but the order is significicant (because of the bucket indexes), // so we we'll use this for initializing the locator var vbsm = config.vBucketServerMap; if (log.IsInfoEnabled) log.Info("Has vbucket. Server count: " + (vbsm.serverList == null ? 0 : vbsm.serverList.Length)); // parse the ip addresses of the servers in the vbucket map // make sure we have a propert vbucket map ValidateVBucketMap(vbsm, vbsm.serverList.Length); // create vbuckets from the int[][] arrays var buckets = vbsm.vBucketMap.Select(a => new VBucket(a[0], a.Skip(1).ToArray())).ToArray(); var locator = new VBucketNodeLocator(vbsm.hashAlgorithm, buckets); // create a (host=>node) lookup from the node info objects, // so we can pass the extra config data to the factory method // (the vbucket map only contains 'host:port' strings) // this expects that all nodes listed in the vbucket map are listed in the config.nodes member as well var realNodes = config.nodes.ToDictionary(node => node.HostName + ":" + node.Port); var nodes = new List<IMemcachedNode>(); foreach (var hostSpec in vbsm.serverList) { ClusterNode node; if (!realNodes.TryGetValue(hostSpec, out node)) throw new InvalidOperationException(String.Format("VBucket map contains a node {0} whihc was not found in the cluster info's node list.", hostSpec)); var ip = GetFirstAddress(node.HostName); var endpoint = new IPEndPoint(ip, node.Port); nodes.Add(this.CreateNode(endpoint, auth, node.ConfigurationData)); } return new InternalState { CurrentNodes = nodes.ToArray(), Locator = locator, OpFactory = new VBucketAwareOperationFactory(locator), IsVbucket = true }; }
public async Task ProcessDeletingSuccessful() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = domain => Task.FromResult(ClusterOperationStatus.ClusterNotFound) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Deleting); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Deleted, actual.Status); }
public async Task ProcessRemoveTimeLimit() { ClusterConfig config = new ClusterConfig() { MaximumClusterUptime = TimeSpan.FromHours(2) }; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = new Cluster( "test", ClusterStatus.Ready, 0, 0, String.Empty, new int[0], new ClusterUser[0], DateTimeOffset.UtcNow - config.MaximumClusterUptime); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Remove, actual.Status); }