/// <summary> /// Constructor. /// </summary> /// <param name="cfg">Configuration.</param> /// <param name="name">Grid name.</param> /// <param name="proc">Interop processor.</param> /// <param name="marsh">Marshaller.</param> /// <param name="lifecycleHandlers">Lifecycle beans.</param> /// <param name="cbs">Callbacks.</param> public Ignite(IgniteConfiguration cfg, string name, IPlatformTargetInternal proc, Marshaller marsh, IList <LifecycleHandlerHolder> lifecycleHandlers, UnmanagedCallbacks cbs) : base(proc) { Debug.Assert(cfg != null); Debug.Assert(proc != null); Debug.Assert(marsh != null); Debug.Assert(lifecycleHandlers != null); Debug.Assert(cbs != null); _cfg = cfg; _name = name; _proc = proc; _marsh = marsh; _lifecycleHandlers = lifecycleHandlers; _cbs = cbs; marsh.Ignite = this; _prj = new ClusterGroupImpl(Target.OutObjectInternal((int)Op.GetClusterGroup), null); _binary = new Binary.Binary(marsh); _binaryProc = new BinaryProcessor(DoOutOpObject((int)Op.GetBinaryProcessor)); cbs.Initialize(this); // Set reconnected task to completed state for convenience. _clientReconnectTaskCompletionSource.SetResult(false); SetCompactFooter(); _pluginProcessor = new PluginProcessor(this); _nearCacheManager = new NearCacheManager(this); }
internal void DoShutdown() { Clients.TryRemove(_instanceName, out _); DisposeAll(_onClientShutdownDisposables); // Statistics.Destroy(); ExecutionService.Shutdown(); ConnectionManager.Shutdown(); ProxyManager.Destroy(); InvocationService.Shutdown(); NearCacheManager.Shutdown(); ListenerService.Dispose(); SerializationService.Destroy(); CredentialsFactory.Dispose(); }
internal ClientContext(ISerializationService serializationService, IClientClusterService clusterService, IClientPartitionService partitionService, IClientInvocationService invocationService, IClientExecutionService executionService, IClientListenerService listenerService, NearCacheManager nearCacheManager, ProxyManager proxyManager, ClientConfig clientConfig) { _serializationService = serializationService; _clusterService = clusterService; _partitionService = partitionService; _invocationService = invocationService; _executionService = executionService; _listenerService = listenerService; _proxyManager = proxyManager; _clientConfig = clientConfig; _nearCacheManager = nearCacheManager; }
private HazelcastClient(ClientConfig config) { _config = config; var groupConfig = config.GetGroupConfig(); _instanceName = "hz.client_" + _id + (groupConfig != null ? "_" + groupConfig.GetName() : string.Empty); _lifecycleService = new LifecycleService(this); try { //TODO make partition strategy parametric var partitioningStrategy = new DefaultPartitioningStrategy(); _serializationService = new SerializationServiceBuilder().SetManagedContext(new HazelcastClientManagedContext(this, config.GetManagedContext())) .SetConfig(config.GetSerializationConfig()) .SetPartitioningStrategy(partitioningStrategy) .SetVersion(SerializationService.SerializerVersion) .Build(); } catch (Exception e) { throw ExceptionUtil.Rethrow(e); } _proxyManager = new ProxyManager(this); //TODO EXECUTION SERVICE _executionService = new ClientExecutionService(_instanceName, config.GetExecutorPoolSize()); _clusterService = new ClientClusterService(this); _loadBalancer = config.GetLoadBalancer() ?? new RoundRobinLB(); _addressProvider = new AddressProvider(_config); _connectionManager = new ClientConnectionManager(this); _invocationService = CreateInvocationService(); _listenerService = new ClientListenerService(this); _userContext = new ConcurrentDictionary <string, object>(); _partitionService = new ClientPartitionService(this); _lockReferenceIdGenerator = new ClientLockReferenceIdGenerator(); _statistics = new Statistics(this); _nearCacheManager = new NearCacheManager(this); _credentialsFactory = InitCredentialsFactory(config); }
private HazelcastClient(Configuration config) { Configuration = config; HazelcastProperties = new HazelcastProperties(config.Properties); if (config.InstanceName != null) { _instanceName = config.InstanceName; } else { _instanceName = "hz.client_" + _id; } LifecycleService = new LifecycleService(this); try { //TODO make partition strategy parametric var partitioningStrategy = new DefaultPartitioningStrategy(); SerializationService = new SerializationServiceBuilder().SetConfig(config.SerializationConfig) .SetPartitioningStrategy(partitioningStrategy) .SetVersion(IO.Serialization.SerializationService.SerializerVersion).Build(); } catch (Exception e) { throw ExceptionUtil.Rethrow(e); } ProxyManager = new ProxyManager(this); //TODO EXECUTION SERVICE ExecutionService = new ExecutionService(_instanceName); LoadBalancer = config.LoadBalancer ?? new RoundRobinLB(); PartitionService = new PartitionService(this); AddressProvider = new AddressProvider(Configuration.NetworkConfig, HazelcastProperties); ConnectionManager = new ConnectionManager(this); InvocationService = new InvocationService(this); ListenerService = new ListenerService(this); ClusterService = new ClusterService(this); LockReferenceIdGenerator = new ClientLockReferenceIdGenerator(); // Statistics = new Statistics(this); NearCacheManager = new NearCacheManager(this); CredentialsFactory = config.SecurityConfig.AsCredentialsFactory() ?? new StaticCredentialsFactory(new UsernamePasswordCredentials()); }
/// <summary> /// Initializes a new instance of the <see cref="HazelcastClient"/> class. /// </summary> /// <param name="options">The client configuration.</param> /// <param name="cluster">A cluster.</param> /// <param name="serializationService">A serialization service.</param> /// <param name="loggerFactory">A logger factory.</param> public HazelcastClient(HazelcastOptions options, Cluster cluster, SerializationService serializationService, ILoggerFactory loggerFactory) { _options = options ?? throw new ArgumentNullException(nameof(options)); Cluster = cluster ?? throw new ArgumentNullException(nameof(cluster)); SerializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService)); _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); _logger = loggerFactory.CreateLogger <IHazelcastClient>(); _distributedOjects = new DistributedObjectFactory(Cluster, serializationService, loggerFactory); _nearCacheManager = new NearCacheManager(cluster, serializationService, loggerFactory, options.NearCache); if (options.Metrics.Enabled) { _metricsPublisher = new MetricsPublisher(cluster, options.Metrics, loggerFactory); _metricsPublisher.AddSource(new ClientMetricSource(cluster, loggerFactory)); _metricsPublisher.AddSource(_nearCacheManager); } // wire components WireComponents(); }
private HazelcastClient(ClientConfig config) { ClientConfig = config; if (config.InstanceName != null) { _instanceName = config.InstanceName; } else { _instanceName = "hz.client_" + _id; } LifecycleService = new LifecycleService(this); try { //TODO make partition strategy parametric var partitioningStrategy = new DefaultPartitioningStrategy(); SerializationService = new SerializationServiceBuilder().SetConfig(config.GetSerializationConfig()) .SetPartitioningStrategy(partitioningStrategy) .SetVersion(IO.Serialization.SerializationService.SerializerVersion).Build(); } catch (Exception e) { throw ExceptionUtil.Rethrow(e); } ProxyManager = new ProxyManager(this); //TODO EXECUTION SERVICE ExecutionService = new ExecutionService(_instanceName, config.GetExecutorPoolSize()); LoadBalancer = config.GetLoadBalancer() ?? new RoundRobinLB(); PartitionService = new PartitionService(this); AddressProvider = new AddressProvider(ClientConfig); ConnectionManager = new ConnectionManager(this); InvocationService = new InvocationService(this); ListenerService = new ListenerService(this); ClusterService = new ClusterService(this); LockReferenceIdGenerator = new ClientLockReferenceIdGenerator(); // Statistics = new Statistics(this); NearCacheManager = new NearCacheManager(this); CredentialsFactory = InitCredentialsFactory(config); }
/// <summary> /// Initializes a new instance of the <see cref="HazelcastClient"/> class. /// </summary> /// <param name="options">The client configuration.</param> /// <param name="cluster">A cluster.</param> /// <param name="serializationService">A serialization service.</param> /// <param name="loggerFactory">A logger factory.</param> public HazelcastClient(HazelcastOptions options, Cluster cluster, ISerializationService serializationService, ILoggerFactory loggerFactory) { _options = options ?? throw new ArgumentNullException(nameof(options)); Cluster = cluster ?? throw new ArgumentNullException(nameof(cluster)); SerializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService)); _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); _logger = loggerFactory.CreateLogger <IHazelcastClient>(); _distributedObjectFactory = new DistributedObjectFactory(Cluster, serializationService, loggerFactory); Cluster.Connections.OnConnectingToNewCluster = cancellationToken => _distributedObjectFactory.CreateAllAsync(cancellationToken); _nearCacheManager = new NearCacheManager(cluster, serializationService, loggerFactory, options.NearCache); // wire events // this way, the cluster does not need to know about the hazelcast client, // and we don't have circular dependencies everywhere - cleaner cluster.ClusterEvents.OnObjectLifecycleEvent = OnObjectLifecycleEvent; cluster.ClusterEvents.OnPartitionLost = OnPartitionLost; cluster.ClusterEvents.OnMemberLifecycleEvent = OnMemberLifecycleEvent; cluster.ClusterEvents.OnClientLifecycleEvent = OnClientLifecycleEvent; cluster.ClusterEvents.OnPartitionsUpdated = OnPartitionsUpdated; cluster.ClusterEvents.OnConnectionAdded = OnConnectionAdded; cluster.ClusterEvents.OnConnectionRemoved = OnConnectionRemoved; cluster.ClusterEvents.OnConnectionRemoved = OnConnectionRemoved; cluster.Connections.OnFirstConnection = async cancellationToken => { foreach (var subscriber in options.Subscribers) { await subscriber.SubscribeAsync(this, cancellationToken).CAF(); } }; // every async operations using this client will need a proper async context AsyncContext.Ensure(); }
/// <summary> /// Initializes a new instance of the <see cref="HazelcastClient"/> class. /// </summary> /// <param name="options">The client configuration.</param> /// <param name="cluster">A cluster.</param> /// <param name="serializationService">A serialization service.</param> /// <param name="loggerFactory">A logger factory.</param> public HazelcastClient(HazelcastOptions options, Cluster cluster, SerializationService serializationService, ILoggerFactory loggerFactory) { _options = options ?? throw new ArgumentNullException(nameof(options)); Cluster = cluster ?? throw new ArgumentNullException(nameof(cluster)); SerializationService = serializationService ?? throw new ArgumentNullException(nameof(serializationService)); _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); _logger = loggerFactory.CreateLogger <IHazelcastClient>(); _distributedOjects = new DistributedObjectFactory(Cluster, serializationService, loggerFactory); _nearCacheManager = new NearCacheManager(cluster, serializationService, loggerFactory, options.NearCache); // wire events - clean // NOTE: each event that is a Func<..., ValueTask> *must* be invoked // through the special FuncExtensions.AwaitEach() method, see notes in // FuncExtensions.cs // when an object is created/destroyed, OnObject... triggers the user-level events cluster.ClusterEvents.ObjectCreated = OnObjectCreated; cluster.ClusterEvents.ObjectDestroyed = OnObjectDestroyed; // when client/cluster state changes, OnStateChanged triggers user-level events cluster.State.StateChanged += OnStateChanged; // when partitions are updated, OnPartitionUpdated triggers the user-level event cluster.Events.PartitionsUpdated += OnPartitionsUpdated; // when a partition is lost, OnPartitionLost triggers the user-level event cluster.ClusterEvents.PartitionLost = OnPartitionLost; // when members are updated, Connections.OnMembersUpdated queues the added // members so that a connection is opened to each of them. cluster.Events.MembersUpdated += cluster.Connections.OnMembersUpdated; // when members are updated, OnMembersUpdated triggers the user-level event cluster.Events.MembersUpdated += OnMembersUpdated; // when a connection is created, Events.OnConnectionCreated wires the connection // ReceivedEvent event to Events.OnReceivedEvent, in order to handle events cluster.Connections.ConnectionCreated += cluster.Events.OnConnectionCreated; // when connecting to a new cluster, DistributedObjects.OnConnectingToNewCluster // re-creates all the known distributed object so far on the new cluster cluster.Connections.ConnectionOpened += _distributedOjects.OnConnectionOpened; // when a connection is added, OnConnectionOpened triggers the user-level event // and, if it is the first connection, subscribes to events according to the // subscribers defined in options. cluster.Connections.ConnectionOpened += OnConnectionOpened; // when a connection is opened, Events.OnConnectionOpened ensures that the // cluster connection (handling member/partition views) is set, and installs // subscriptions on this new connection. cluster.Connections.ConnectionOpened += cluster.Events.OnConnectionOpened; // when a connection is closed, client.OnConnectionClosed triggers the user-level event cluster.Connections.ConnectionClosed += OnConnectionClosed; // when a connection is closed, Events.OnConnectionClosed clears subscriptions // (cannot unsubscribe since the connection is closed) and ensures that the // cluster connection (handling member/partition views) is set. cluster.Connections.ConnectionClosed += cluster.Events.OnConnectionClosed; }