Represents an address of a member in the cluster.
Represents an address of a member in the cluster.
 public ClientListenerInvocation(IClientMessage message, DistributedEventHandler handler,
     DecodeStartListenerResponse responseDecoder, Address address)
     : base(message, address)
 {
     _responseDecoder = responseDecoder;
     _handler = handler;
 }
 public static int CalculateDataSize(string name, string serviceName, Address target)
 {
     var dataSize = ClientMessage.HeaderSize;
     dataSize += ParameterUtil.CalculateDataSize(name);
     dataSize += ParameterUtil.CalculateDataSize(serviceName);
     dataSize += AddressCodec.CalculateDataSize(target);
     return dataSize;
 }
예제 #3
0
 public Member(Address address, string uuid, IDictionary<string, string> attributes, bool liteMember)
 {
     this.address = address;
     this.uuid = uuid;
     _liteMember = liteMember;
     foreach (var kv in attributes)
     {
         _attributes.TryAdd(kv.Key, kv.Value);
     }
 }
예제 #4
0
 public Member(Address address, string uuid, IDictionary<string, string> attributes, bool liteMember)
 {
     _logger = Logger.GetLogger(typeof (Member) + ":" + address);
     _address = address;
     _uuid = uuid;
     _liteMember = liteMember;
     foreach (var kv in attributes)
     {
         _attributes.TryAdd(kv.Key, kv.Value);
     }
 }
 public static ClientMessage EncodeRequest(string name, string serviceName, Address target)
 {
     var requiredDataSize = RequestParameters.CalculateDataSize(name, serviceName, target);
     var clientMessage = ClientMessage.CreateForEncode(requiredDataSize);
     clientMessage.SetMessageType((int) RequestType);
     clientMessage.SetRetryable(Retryable);
     clientMessage.Set(name);
     clientMessage.Set(serviceName);
     AddressCodec.Encode(target, clientMessage);
     clientMessage.UpdateFrameLength();
     return clientMessage;
 }
        public static void Encode(ClientMessage clientMessage, Hazelcast.IO.Address address)
        {
            clientMessage.Add(BeginFrame.Copy());

            var initialFrame = new Frame(new byte[InitialFrameSize]);

            EncodeInt(initialFrame.Content, PortFieldOffset, address.Port);
            clientMessage.Add(initialFrame);

            StringCodec.Encode(clientMessage, address.Host);

            clientMessage.Add(EndFrame.Copy());
        }
예제 #7
0
 private bool Equals(Address other)
 {
     return _port == other._port && string.Equals(_host, other._host) && _type == other._type;
 }
        internal virtual void ListenMembershipEvents(Address ownerConnectionAddress)
        {
            Logger.Finest("Starting to listen for membership events from " + ownerConnectionAddress);
            _initialListFetched = new ManualResetEventSlim();
            try
            {
                var clientMessage = ClientAddMembershipListenerCodec.EncodeRequest(false);
                DistributedEventHandler handler = m => ClientAddMembershipListenerCodec.AbstractEventHandler
                    .Handle(m, HandleMember, HandleMemberCollection, HandleMemberAttributeChange);

                try
                {
                    var connection = _connectionManager.GetConnection(ownerConnectionAddress);
                    if (connection == null)
                    {
                        throw new InvalidOperationException(
                                "Can not load initial members list because owner connection is null. Address "
                                        + ownerConnectionAddress);
                    }
                    var invocationService = (ClientInvocationService)_client.GetInvocationService();
                    var response = ThreadUtil.GetResult(invocationService.InvokeListenerOnConnection(clientMessage, handler,
                        m => ClientAddMembershipListenerCodec.DecodeResponse(m).response, connection));
                    //registraiton id is ignored as this listener will never be removed
                    var registirationId = ClientAddMembershipListenerCodec.DecodeResponse(response).response;
                    WaitInitialMemberListFetched();
                }
                catch (Exception e)
                {
                    throw ExceptionUtil.Rethrow(e);
                }

            }
            catch (Exception e)
            {
                if (_client.GetLifecycleService().IsRunning())
                {
                    if (Logger.IsFinestEnabled())
                    {
                        Logger.Warning("Error while registering to cluster events! -> " + ownerConnectionAddress, e);
                    }
                    else
                    {
                        Logger.Warning("Error while registering to cluster events! -> " + ownerConnectionAddress +
                                       ", Error: " + e);
                    }
                }
            }
        }
        /// <exception cref="System.IO.IOException"></exception>
        public ClientConnection(ClientConnectionManager clientConnectionManager,
            ClientInvocationService invocationService,
            int id,
            Address address,
            ClientNetworkConfig clientNetworkConfig)
        {
            _clientConnectionManager = clientConnectionManager;
            _id = id;

            var isa = address.GetInetSocketAddress();
            var socketOptions = clientNetworkConfig.GetSocketOptions();
            var socketFactory = socketOptions.GetSocketFactory() ?? new DefaultSocketFactory();
            _clientSocket = socketFactory.CreateSocket();

            try
            {
                _clientSocket = new Socket(isa.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                _clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);

                var lingerOption = new LingerOption(true, 5);
                if (socketOptions.GetLingerSeconds() > 0)
                {
                    lingerOption.LingerTime = socketOptions.GetLingerSeconds();
                }
                _clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
                _clientSocket.NoDelay = socketOptions.IsTcpNoDelay();

                _clientSocket.ReceiveTimeout = socketOptions.GetTimeout() > 0 ? socketOptions.GetTimeout() : -1;

                var bufferSize = socketOptions.GetBufferSize() * 1024;
                if (bufferSize < 0)
                {
                    bufferSize = BufferSize;
                }

                _clientSocket.SendBufferSize = bufferSize;
                _clientSocket.ReceiveBufferSize = bufferSize;

                var connectionTimeout = clientNetworkConfig.GetConnectionTimeout() > -1
                    ? clientNetworkConfig.GetConnectionTimeout()
                    : ConnectionTimeout;
                var socketResult = _clientSocket.BeginConnect(address.GetHost(), address.GetPort(), null, null);

                if (!socketResult.AsyncWaitHandle.WaitOne(connectionTimeout, true) || !_clientSocket.Connected)
                {
                    // NOTE, MUST CLOSE THE SOCKET
                    _clientSocket.Close();
                    throw new IOException("Failed to connect to " + address);
                }
                _sendBuffer = ByteBuffer.Allocate(BufferSize);
                _receiveBuffer = ByteBuffer.Allocate(BufferSize);

                _builder = new ClientMessageBuilder(invocationService.HandleClientMessage);

                var networkStream = new NetworkStream(_clientSocket, false);
                if (clientNetworkConfig.GetSSLConfig().IsEnabled())
                {
                    var sslStream = new SslStream(networkStream, false,
                        (sender, certificate, chain, sslPolicyErrors) =>
                            RemoteCertificateValidationCallback(sender, certificate, chain, sslPolicyErrors,
                                clientNetworkConfig), null);
                    var certificateName = clientNetworkConfig.GetSSLConfig().GetCertificateName() ?? "";
                    sslStream.AuthenticateAsClient(certificateName);
                    _stream = sslStream;
                }
                else
                {
                    _stream = networkStream;
                }
                _live = new AtomicBoolean(true);
            }
            catch (Exception e)
            {
                _clientSocket.Close();
                if (_stream != null)
                {
                    _stream.Close();
                }
                throw new IOException("Cannot connect! Socket error:" + e.Message);
            }
        }
 /// <exception cref="System.Exception" />
 private bool Connect(ICollection<IPEndPoint> triedAddresses)
 {
     ICollection<IPEndPoint> socketAddresses = GetEndpoints();
     foreach (var inetSocketAddress in socketAddresses)
     {
         try
         {
             triedAddresses.Add(inetSocketAddress);
             var address = new Address(inetSocketAddress);
             if (Logger.IsFinestEnabled())
             {
                 Logger.Finest("Trying to connect to " + address);
             }
             var connection = _connectionManager.GetOrConnect(address, ManagerAuthenticator);
             FireConnectionEvent(LifecycleEvent.LifecycleState.ClientConnected);
             _ownerConnectionAddress = connection.GetAddress();
             return true;
         }
         catch (Exception e)
         {
             var level = e is AuthenticationException ? LogLevel.Warning : LogLevel.Finest;
             Logger.Log(level, "Exception during initial connection to " + inetSocketAddress, e);
         }
     }
     return false;
 }
 public override IFuture<IClientMessage> InvokeListenerOnTarget(IClientMessage request, Address target,
     DistributedEventHandler handler,
     DecodeStartListenerResponse responseDecoder)
 {
     return Invoke(new ClientListenerInvocation(request, handler, responseDecoder, target), target);
 }
        private void InvokeInternal(ClientInvocation invocation, Address address = null,
            ClientConnection connection = null, bool bypassHeartbeat = false)
        {
            try
            {
                if (connection == null)
                {
                    if (address == null)
                    {
                        address = GetRandomAddress();
                    }
                    connection = GetConnection(address);
                    if (connection == null)
                    {
                        //Create an async conneciion and send the invocation afterward.
                        _clientConnectionManager.GetOrConnectAsync(address).ContinueWith(t =>
                            {
                                if (t.IsFaulted)
                                {
                                    HandleInvocationException(invocation, t.Exception.Flatten().InnerExceptions.First());
                                }
                                else
                                {
                                    InvokeInternal(invocation, address, t.Result);
                                }
                            })
                            .ContinueWith(t =>
                                {
                                    HandleInvocationException(invocation, t.Exception.Flatten().InnerExceptions.First());
                                }, TaskContinuationOptions.OnlyOnFaulted |
                                   TaskContinuationOptions.ExecuteSynchronously);
                        return;
                    }
                }
                //Sending Invocation via connection
                UpdateInvocation(invocation, connection);
                ValidateInvocation(invocation, connection, bypassHeartbeat);

                if (!TrySend(invocation, connection))
                {
                    //Sending failed.
                    if (_client.GetConnectionManager().Live)
                    {
                        throw new TargetDisconnectedException(connection.GetAddress(), "Error writing to socket.");
                    }
                    throw new HazelcastException("Client is shut down.");
                }
                //Successfully sended.
            }
            catch (Exception e)
            {
                HandleInvocationException(invocation, e);
            }
        }
예제 #13
0
 public Member(Address address, string uuid)
     : this(address, uuid, new Dictionary<string, string>(), false)
 {
 }
 public abstract IFuture<IClientMessage> InvokeOnTarget(IClientMessage request, Address target);
 public static void Encode(Address address, ClientMessage clientMessage)
 {
     clientMessage.Set(address.GetHost()).Set(address.GetPort());
 }
 public static int CalculateDataSize(Address address)
 {
     var dataSize = ParameterUtil.CalculateDataSize(address.GetHost());
     dataSize += Bits.IntSizeInBytes;
     return dataSize;
 }
 private void ConnectToOne()
 {
     _ownerConnectionAddress = null;
     var networkConfig = GetClientConfig().GetNetworkConfig();
     var connAttemptLimit = networkConfig.GetConnectionAttemptLimit();
     var connectionAttemptPeriod = networkConfig.GetConnectionAttemptPeriod();
     var connectionAttemptLimit = connAttemptLimit == 0 ? int.MaxValue : connAttemptLimit;
     var attempt = 0;
     ICollection<IPEndPoint> triedAddresses = new HashSet<IPEndPoint>();
     while (attempt < connectionAttemptLimit)
     {
         if (!_client.GetLifecycleService().IsRunning())
         {
             if (Logger.IsFinestEnabled())
             {
                 Logger.Finest("Giving up on retrying to connect to cluster since client is shutdown");
             }
             break;
         }
         attempt++;
         var nextTry = Clock.CurrentTimeMillis() + connectionAttemptPeriod;
         var isConnected = Connect(triedAddresses);
         if (isConnected)
         {
             return;
         }
         var remainingTime = nextTry - Clock.CurrentTimeMillis();
         Logger.Warning(
             string.Format("Unable to get alive cluster connection, try in {0} ms later, attempt {1} of {2}.",
                 Math.Max(0, remainingTime), attempt, connectionAttemptLimit));
         if (remainingTime > 0)
         {
             try
             {
                 Thread.Sleep((int) remainingTime);
             }
             catch (Exception)
             {
                 break;
             }
         }
     }
     throw new InvalidOperationException("Unable to connect to any address in the config! " +
                                         "The following addresses were tried:" +
                                         string.Join(", ", triedAddresses));
 }
 public TargetDisconnectedException(Address address) : base("Target[" + address + "] disconnected.")
 {
 }
        /// <exception cref="System.IO.IOException"></exception>
        public ClientConnection GetOrConnect(Address address, Authenticator authenticator)
        {
            if (address == null)
            {
                throw new ArgumentException("address");
            }
            lock (_connectionMutex)
            {
                ClientConnection connection;
                if (!_addresses.ContainsKey(address))
                {
                    connection = InitializeConnection(address, authenticator);
                    FireConnectionListenerEvent(f => f.ConnectionAdded(connection));
                    _addresses.TryAdd(connection.GetAddress(), connection);
                    Logger.Finest("Active list of connections: " + string.Join(", ", _addresses.Values));
                }
                else
                    connection = _addresses[address];

                if (connection == null)
                {
                    Logger.Severe("CONNECTION Cannot be NULL here");
                }
                return connection;
            }
        }
예제 #20
0
 public Member(Address address)
     : this(address, null)
 {
 }
 public Task<ClientConnection> GetOrConnectAsync(Address address)
 {
     lock (_pendingConnections)
     {
         if (!_pendingConnections.ContainsKey(address))
         {
             var task = _client.GetClientExecutionService().Submit(() => GetOrConnect(address));
             task.ContinueWith(t =>
             {
                 if (t.IsFaulted)
                 {
                     if (Logger.IsFinestEnabled())
                     {
                         Logger.Finest("Exception in async pending connection:", t.Exception);
                     }
                 }
                 lock (_pendingConnections)
                 {
                     _pendingConnections.Remove(address);
                 }
             });
             _pendingConnections[address] = task;
         }
         return _pendingConnections[address];
     }
 }
        protected IFuture<IClientMessage> Invoke(ClientInvocation invocation, Address address = null)
        {
            try
            {
                if (address == null)
                {
                    address = GetRandomAddress();
                }

                // try to get an existing connection, if not establish a new connection asyncronously
                var connection = GetConnection(address);
                if (connection != null)
                {
                    Send(connection, invocation);
                }
                else
                {
                    _clientConnectionManager.GetOrConnectAsync(address).ContinueWith(t =>
                    {
                        if (t.IsFaulted)
                        {
                            var innerException = t.Exception.InnerExceptions.First();
                            HandleException(invocation, innerException);
                        }
                        else
                        {
                            try
                            {
                                Send(t.Result, invocation);
                            }
                            catch (Exception e)
                            {
                                HandleException(invocation, e);
                            }
                        }
                    });
                }
            }
            catch (Exception e)
            {
                HandleException(invocation, e);
            }
            return invocation.Future;
        }
 protected IFuture<IClientMessage> Invoke(ClientInvocation invocation, Address address = null)
 {
     InvokeInternal(invocation, address);
     return invocation.Future;
 }
 /// <summary>
 /// Gets an existing connection for the given address
 /// </summary>
 /// <param name="address"></param>
 /// <returns></returns>
 public ClientConnection GetConnection(Address address)
 {
     ClientConnection connection;
     return _addresses.TryGetValue(address, out connection) ? connection : null;
 }
 private ClientConnection GetConnection(Address address)
 {
     EnsureOwnerConnectionAvailable();
     return _client.GetConnectionManager().GetConnection(address);
 }
 /// <summary>
 /// Gets the connection for the address. If there is no connection, a new one will be created
 /// </summary>
 /// <param name="target"></param>
 /// <returns></returns>
 public ClientConnection GetOrConnect(Address target)
 {
     return GetOrConnect(target, ClusterAuthenticator);
 }
 public abstract IFuture<IClientMessage> InvokeListenerOnTarget(IClientMessage request, Address target,
     DistributedEventHandler handler,
     DecodeStartListenerResponse responseDecoder);
        private ClientConnection InitializeConnection(Address address, Authenticator authenticator)
        {
            CheckLive();
            ClientConnection connection = null;
            var id = _nextConnectionId;
            try
            {
                if (Logger.IsFinestEnabled())
                {
                    Logger.Finest("Creating new connection for " + address + " with id " + id);
                }

                connection = new ClientConnection(this, (ClientInvocationService) _client.GetInvocationService(), id, address, _networkConfig);

                connection.Init(_socketInterceptor);
                authenticator(connection);
                Interlocked.Increment(ref _nextConnectionId);
                Logger.Finest("Authenticated to " + connection);
                return connection;
            }
            catch (Exception e)
            {
                if (Logger.IsFinestEnabled())
                {
                    Logger.Finest("Error connecting to " + address + " with id " + id, e);
                }

                if (connection != null)
                {
                    connection.Close();
                }
                throw ExceptionUtil.Rethrow(e, typeof (IOException), typeof (SocketException),
                    typeof (TargetDisconnectedException));
            }
        }
 public override IFuture<IClientMessage> InvokeOnTarget(IClientMessage request, Address target)
 {
     return SendToOwner(new ClientInvocation(request));
 }
 public override IFuture<IClientMessage> InvokeOnTarget(IClientMessage request, Address target)
 {
     return Invoke(new ClientInvocation(request, target), target);
 }
 public Task<ClientConnection> GetOrConnectAsync(Address address)
 {
     lock (_pendingConnections)
     {
         if (!_pendingConnections.ContainsKey(address))
         {
             var task = _client.GetClientExecutionService().Submit(() => GetOrConnect(address));
             task.ContinueWith(t =>
             {
                 lock (_pendingConnections)
                 {
                     _pendingConnections.Remove(address);
                 }
             });
             _pendingConnections[address] = task;
         }
         return _pendingConnections[address];
     }
 }