private synchronized void publishNow() { if (!isRunning()) return; CalculatedStatus calculatedStatus = calculateStatus(); boolean connected = calculatedStatus.connected; Long lastUpTime = connectionLastUp.get(); Long lastDownTime = connectionLastDown.get(); long serviceFailedStabilizationDelay = getConnectionFailedStabilizationDelay().toMilliseconds(); long serviceRecoveredStabilizationDelay = getConnectionRecoveredStabilizationDelay().toMilliseconds(); long now = System.currentTimeMillis(); if (connected) { if (lastPublished == LastPublished.FAILED) { // only publish if consistently up for serviceRecoveredStabilizationDelay long currentRecoveryPeriod = getTimeDiff(now, currentRecoveryStartTime); long sinceLastDownPeriod = getTimeDiff(now, lastDownTime); if (currentRecoveryPeriod > serviceRecoveredStabilizationDelay && sinceLastDownPeriod > serviceRecoveredStabilizationDelay) { String description = calculatedStatus.getDescription(); LOG.warn( "{} connectivity-check for {}, publishing recovered: {}", new Object[] {this, entity, description}); entity.emit(CONNECTION_RECOVERED, new HASensors.FailureDescriptor(entity, description)); lastPublished = LastPublished.RECOVERED; currentFailureStartTime = null; } else { long nextAttemptTime = Math.max( serviceRecoveredStabilizationDelay - currentRecoveryPeriod, serviceRecoveredStabilizationDelay - sinceLastDownPeriod); schedulePublish(nextAttemptTime); } } } else { if (lastPublished != LastPublished.FAILED) { // only publish if consistently down for serviceFailedStabilizationDelay long currentFailurePeriod = getTimeDiff(now, currentFailureStartTime); long sinceLastUpPeriod = getTimeDiff(now, lastUpTime); if (currentFailurePeriod > serviceFailedStabilizationDelay && sinceLastUpPeriod > serviceFailedStabilizationDelay) { String description = calculatedStatus.getDescription(); LOG.warn( "{} connectivity-check for {}, publishing failed: {}", new Object[] {this, entity, description}); entity.emit(CONNECTION_FAILED, new HASensors.FailureDescriptor(entity, description)); lastPublished = LastPublished.FAILED; currentRecoveryStartTime = null; } else { long nextAttemptTime = Math.max( serviceFailedStabilizationDelay - currentFailurePeriod, serviceFailedStabilizationDelay - sinceLastUpPeriod); schedulePublish(nextAttemptTime); } } } }
private synchronized void checkHealth() { CalculatedStatus status = calculateStatus(); boolean connected = status.connected; long now = System.currentTimeMillis(); if (connected) { connectionLastUp.set(now); if (lastPublished == LastPublished.FAILED) { if (currentRecoveryStartTime == null) { LOG.info( "{} connectivity-check for {}, now recovering: {}", new Object[] {this, entity, status.getDescription()}); currentRecoveryStartTime = now; schedulePublish(); } else { if (LOG.isTraceEnabled()) LOG.trace( "{} connectivity-check for {}, continuing recovering: {}", new Object[] {this, entity, status.getDescription()}); } } else { if (currentFailureStartTime != null) { LOG.info( "{} connectivity-check for {}, now healthy: {}", new Object[] {this, entity, status.getDescription()}); currentFailureStartTime = null; } else { if (LOG.isTraceEnabled()) LOG.trace( "{} connectivity-check for {}, still healthy: {}", new Object[] {this, entity, status.getDescription()}); } } } else { connectionLastDown.set(now); if (lastPublished != LastPublished.FAILED) { if (currentFailureStartTime == null) { LOG.info( "{} connectivity-check for {}, now failing: {}", new Object[] {this, entity, status.getDescription()}); currentFailureStartTime = now; schedulePublish(); } else { if (LOG.isTraceEnabled()) LOG.trace( "{} connectivity-check for {}, continuing failing: {}", new Object[] {this, entity, status.getDescription()}); } } else { if (currentRecoveryStartTime != null) { LOG.info( "{} connectivity-check for {}, now failing: {}", new Object[] {this, entity, status.getDescription()}); currentRecoveryStartTime = null; } else { if (LOG.isTraceEnabled()) LOG.trace( "{} connectivity-check for {}, still failed: {}", new Object[] {this, entity, status.getDescription()}); } } } }