/** * Sets socket operations timeout. This timeout is used to limit connection time and * write-to-socket time. * <p> * Note that when running Ignite on Amazon EC2, socket timeout must be set to a value * significantly greater than the default (e.g. to {@code 30000}). * <p> * If not specified, default is {@link #DFLT_SOCK_TIMEOUT} or {@link #DFLT_SOCK_TIMEOUT_CLIENT}. * <p> * When this property is explicitly set {@link IgniteConfiguration#getFailureDetectionTimeout()} is ignored. * * @param sockTimeout Socket connection timeout. * @return {@code this} for chaining. */ @IgniteSpiConfiguration(optional = true) public TcpDiscoverySpi setSocketTimeout(long sockTimeout) { this.sockTimeout = sockTimeout; failureDetectionTimeoutEnabled(false); return this; }
/** * Sets timeout for receiving acknowledgement for sent message. * <p> * If acknowledgement is not received within this timeout, sending is considered as failed * and SPI tries to repeat message sending. * <p> * If not specified, default is {@link #DFLT_ACK_TIMEOUT} or {@link #DFLT_ACK_TIMEOUT_CLIENT}. * <p> * When this property is explicitly set {@link IgniteConfiguration#getFailureDetectionTimeout()} is ignored. * * @param ackTimeout Acknowledgement timeout. * @return {@code this} for chaining. */ @IgniteSpiConfiguration(optional = true) public TcpDiscoverySpi setAckTimeout(long ackTimeout) { this.ackTimeout = ackTimeout; failureDetectionTimeoutEnabled(false); return this; }
/** * Number of times node tries to (re)establish connection to another node. * <p> * Note that SPI implementation will increase {@link #ackTimeout} by factor 2 * on every retry. * <p> * If not specified, default is {@link #DFLT_RECONNECT_CNT}. * <p> * When this property is explicitly set {@link IgniteConfiguration#getFailureDetectionTimeout()} is ignored. * * @param reconCnt Number of retries during message sending. * @see #setAckTimeout(long) * @return {@code this} for chaining. */ @IgniteSpiConfiguration(optional = true) public TcpDiscoverySpi setReconnectCount(int reconCnt) { this.reconCnt = reconCnt; failureDetectionTimeoutEnabled(false); return this; }
/** * Sets maximum timeout for receiving acknowledgement for sent message. * <p> * If acknowledgement is not received within this timeout, sending is considered as failed * and SPI tries to repeat message sending. Every time SPI retries messing sending, ack * timeout will be increased. If no acknowledgement is received and {@code maxAckTimeout} * is reached, then the process of message sending is considered as failed. * <p> * If not specified, default is {@link #DFLT_MAX_ACK_TIMEOUT}. * <p> * Affected server nodes only. * <p> * When this property is explicitly set {@link IgniteConfiguration#getFailureDetectionTimeout()} is ignored. * * @param maxAckTimeout Maximum acknowledgement timeout. * @return {@code this} for chaining. */ @IgniteSpiConfiguration(optional = true) public TcpDiscoverySpi setMaxAckTimeout(long maxAckTimeout) { this.maxAckTimeout = maxAckTimeout; failureDetectionTimeoutEnabled(false); return this; }
/** * @return Connection recovery timeout that is not greater than failureDetectionTimeout if enabled. */ long getEffectiveConnectionRecoveryTimeout() { if (failureDetectionTimeoutEnabled() && failureDetectionTimeout() < connRecoveryTimeout) return failureDetectionTimeout(); return connRecoveryTimeout; }
/** {@inheritDoc} */ @Override protected void onMessageExchanged() { if (spi.failureDetectionTimeoutEnabled() && locNode != null) locNode.lastExchangeTime(U.currentTimeMillis()); }
/** * Gets effective or resulting socket timeout with considering failure detection timeout * * @param srvrOperation {@code True} if socket connect to server node, * {@code False} if socket connect to client node. * @return Resulting socket timeout. */ public long getEffectiveSocketTimeout(boolean srvrOperation) { if (failureDetectionTimeoutEnabled()) return srvrOperation ? failureDetectionTimeout() : clientFailureDetectionTimeout(); else return sockTimeout; }
/** {@inheritDoc} */ @Override public void onTimeout() { if (done.compareAndSet(false, true)) { // Close socket - timeout occurred. U.closeQuiet(sock); LT.warn(log, "Socket write has timed out (consider increasing " + (failureDetectionTimeoutEnabled() ? "'IgniteConfiguration.failureDetectionTimeout' configuration property) [" + "failureDetectionTimeout=" + failureDetectionTimeout() : "'sockTimeout' configuration property) [sockTimeout=" + sockTimeout) + ", rmtAddr=" + sock.getRemoteSocketAddress() + ", rmtPort=" + sock.getPort() + ", sockTimeout=" + sockTimeout + ']'); stats.onSocketTimeout(); } }
/** * Wait random delay before trying to reconnect. Delay will grow exponentially every time client is forced to * reconnect, but only if all these reconnections happened in small period of time (2 minutes). Maximum delay * could be configured with {@link IgniteSpiAdapter#clientFailureDetectionTimeout()}, default value is * {@link IgniteConfiguration#DFLT_CLIENT_FAILURE_DETECTION_TIMEOUT}. * * @throws InterruptedException If thread is interrupted. */ private void throttleClientReconnect() throws InterruptedException { if (U.currentTimeMillis() - lastReconnectTimestamp > CLIENT_THROTTLE_RECONNECT_RESET_TIMEOUT) currentReconnectDelay = 0; // Skip pause on first reconnect. else if (currentReconnectDelay == 0) currentReconnectDelay = 200; else { long maxDelay = spi.failureDetectionTimeoutEnabled() ? spi.clientFailureDetectionTimeout() : IgniteConfiguration.DFLT_CLIENT_FAILURE_DETECTION_TIMEOUT; currentReconnectDelay = Math.min(maxDelay, (int)(currentReconnectDelay * 1.5)); } if (currentReconnectDelay != 0) { ThreadLocalRandom random = ThreadLocalRandom.current(); Thread.sleep(random.nextLong(currentReconnectDelay / 2, currentReconnectDelay)); } lastReconnectTimestamp = U.currentTimeMillis(); }
/** * Initializes connection check frequency. Used only when failure detection timeout is enabled. */ private void initConnectionCheckThreshold() { if (spi.failureDetectionTimeoutEnabled()) connCheckThreshold = spi.failureDetectionTimeout(); else connCheckThreshold = Math.min(spi.getSocketTimeout(), spi.metricsUpdateFreq); if (log.isInfoEnabled()) log.info("Connection check threshold is calculated: " + connCheckThreshold); }
/** * */ SocketWriter() { super(spi.ignite().name(), "tcp-client-disco-sock-writer", log); sockTimeout = spi.failureDetectionTimeoutEnabled() ? spi.failureDetectionTimeout() : spi.getSocketTimeout(); }
/** * @throws Exception In case of error. */ @Test public void testFailureDetectionTimeoutDisabled() throws Exception { for (int i = 2; i < spis.size(); i++) { assertFalse(((TcpDiscoverySpi)spis.get(i)).failureDetectionTimeoutEnabled()); assertEquals(0, ((TcpDiscoverySpi)spis.get(i)).failureDetectionTimeout()); assertFalse(0 == ((TcpDiscoverySpi)spis.get(i)).clientFailureDetectionTimeout()); } }
/** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } return cfg; }
/** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(gridName); cfg.setClientMode(client); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } return cfg; }
/** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) ((TcpDiscoverySpi)cfg.getDiscoverySpi()).failureDetectionTimeoutEnabled(false); TcpCommunicationSpi commSpi = new TestCommunicationSpi(); cfg.setCommunicationSpi(commSpi); cfg.setClientMode(client); return cfg; }
/** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } DataStorageConfiguration memCfg = new DataStorageConfiguration().setDefaultDataRegionConfiguration( new DataRegionConfiguration() .setMaxSize(DataStorageConfiguration.DFLT_DATA_REGION_MAX_SIZE * 10) .setName("dfltPlc")); cfg.setDataStorageConfiguration(memCfg); cfg.setClientMode(client); return cfg; }
/** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } DataStorageConfiguration memCfg = new DataStorageConfiguration().setDefaultDataRegionConfiguration( new DataRegionConfiguration().setMaxSize(100L * 1024 * 1024)); cfg.setDataStorageConfiguration(memCfg); CacheConfiguration ccfg0 = ccfg == null ? new CacheConfiguration(DEFAULT_CACHE_NAME) .setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL) : ccfg; cfg.setCacheConfiguration(ccfg0); return cfg; }
/** * @throws Exception in case of error. */ @Test public void testFailureDetectionTimeoutEnabled() throws Exception { startServerNodes(1); startClientNodes(1); checkNodes(1, 1); assertTrue(((TcpDiscoverySpi)(G.ignite("server-0").configuration().getDiscoverySpi())). failureDetectionTimeoutEnabled()); assertEquals(failureDetectionTimeout(), ((TcpDiscoverySpi)(G.ignite("server-0").configuration().getDiscoverySpi())).failureDetectionTimeout()); assertTrue(((TcpDiscoverySpi)(G.ignite("client-0").configuration().getDiscoverySpi())). failureDetectionTimeoutEnabled()); assertEquals(failureDetectionTimeout(), ((TcpDiscoverySpi)(G.ignite("client-0").configuration().getDiscoverySpi())).failureDetectionTimeout()); }
/** {@inheritDoc} */ @SuppressWarnings("unchecked") @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } TcpCommunicationSpi commSpi = new TestCommunicationSpi(); cfg.setCommunicationSpi(commSpi); CacheConfiguration ccfg = defaultCacheConfiguration(); ccfg.setName(CACHE); ccfg.setCacheMode(CacheMode.PARTITIONED); ccfg.setBackups(1); ccfg.setNearConfiguration(null); cfg.setCacheConfiguration(ccfg); return cfg; }
/** {@inheritDoc} */ @SuppressWarnings("unchecked") @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); if (isDebug()) { TcpDiscoverySpi discoSpi = new TcpDiscoverySpi(); discoSpi.failureDetectionTimeoutEnabled(false); cfg.setDiscoverySpi(discoSpi); } CacheConfiguration ccfg0 = defaultCacheConfiguration(); ccfg0.setName("cache0"); ccfg0.setCacheMode(CacheMode.PARTITIONED); ccfg0.setBackups(1); ccfg0.setNearConfiguration(null); CacheConfiguration ccfg1 = defaultCacheConfiguration(); ccfg1.setName("cache1"); ccfg1.setCacheMode(CacheMode.PARTITIONED); ccfg1.setBackups(1); ccfg1.setNearConfiguration(null); cfg.setCacheConfiguration(ccfg0, ccfg1); return cfg; }