Esempio n. 1
0
        public IConfigurationSession OpenConfigurationSession(IClientAuthenticationCredential credentials)
        {
            this.credentials = credentials;
            try
            {
                _session = new OutProcConfigurationSession(_serviceURI, _channel, credentials, _channelFormatter);
                _session.IsDatabaseSession       = isDatabaseClient;
                _session.IsDistributorSession    = isDistributorClient;
                _session.IsConfigurationSession  = isConfigurationClient;
                ServerAuthenticationCredenital   = _session.Authenticate(credentials);
                _session.Channel.IsAuthenticated = ServerAuthenticationCredenital.IsAuthenticated;
                _session.SessionType             = _sessionType;

                if (ServerAuthenticationCredenital.IsAuthenticated)
                {
                    DetermineSecondaryConfigurationServer();
                    _session.SessionId = ServerAuthenticationCredenital.SessionId;
                    return(_session);
                }
                else
                {
                    throw new Alachisoft.NosDB.Common.Security.SecurityException(ErrorCodes.Security.USER_NOT_REGISTERED, new string[1] {
                        credentials.UserName
                    });
                }
            }
            catch (Exception ex)
            {
                _channel.Disconnect();
                throw;
            }
        }
Esempio n. 2
0
        public void ChannelDisconnected(IRequestResponseChannel channel, string reason)
        {
            if (_channelDisconnctedListener != null)
            {
                _channelDisconnctedListener.ChannelDisconnected(channel, reason);
            }

            if (!_autoReconnect)
            {
                return;
            }

            int  retries   = 3;
            bool connected = false;

            if (channel != null)
            {
                while (0 < retries--)
                {
                    try
                    {
                        lock (_mutex)
                        {
                            if (_channel.RetryConnect())
                            {
                                IServerAuthenticationCredential serverAuthCred = _session.Authenticate(credentials);
                                if (serverAuthCred != null && serverAuthCred.IsAuthenticated)
                                {
                                    _session.Channel.IsAuthenticated = serverAuthCred.IsAuthenticated;
                                    _session.SessionId = serverAuthCred.SessionId;
                                }
                                connected = true;

                                break;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (retries == 2)
                        {
                            Thread.Sleep(30000);
                        }
                        else if (retries == 1)
                        {
                            Thread.Sleep(60000);
                        }
                    }
                }

                if (!connected)
                {
                    retries = 3;
                    TraceProvider traceProvider = EnableTracing ? new TraceProvider() : null;
                    if (_secondConfiguratioServer != null)
                    {
                        string disconnectedServer = channel.PeerAddress.ip;
                        string failOverServer     = null;

                        if (string.Compare(disconnectedServer, _firstConfiguratioServer, true) == 0)
                        {
                            failOverServer = _secondConfiguratioServer;
                        }
                        else
                        {
                            failOverServer = _firstConfiguratioServer;
                        }

                        _channel = new DualChannel(failOverServer, _port, null, SessionTypes.Management, traceProvider,
                                                   _channelFormatter);

                        while (0 < retries--)
                        {
                            try
                            {
                                if (_channel.Connect(true))
                                {
                                    _session.Channel = _channel;
                                    //
                                    //Connection re-established and needs to be authenticated
                                    IServerAuthenticationCredential serverAuthCred = _session.Authenticate(credentials);
                                    if (serverAuthCred != null && serverAuthCred.IsAuthenticated)
                                    {
                                        _session.Channel.IsAuthenticated = serverAuthCred.IsAuthenticated;
                                        _session.SessionId = serverAuthCred.SessionId;
                                    }
                                    break;
                                }
                            }
                            catch (ChannelException ex)
                            {
                                if (LoggerManager.Instance.CONDBLogger != null && LoggerManager.Instance.CONDBLogger.IsErrorEnabled)
                                {
                                    LoggerManager.Instance.CONDBLogger.Error("Error: OutProcConfigClient.ChannelDisconnected()", ex.ToString());
                                }
                            }
                        }
                    }
                }
            }
        }