public void UpdateStatus(DataStoreStatus newStatus)
{
if (_status.Update(newStatus, out _))
{
_taskExecutor.ScheduleEvent(newStatus, StatusChanged);
}
}
private void OnDataStoreStatusChanged(object sender, DataStoreStatus newStatus)
{
if (newStatus.Available && newStatus.RefreshNeeded)
{
// The store has just transitioned from unavailable to available, and we can't guarantee that
// all of the latest data got cached, so let's restart the stream to refresh all the data.
_log.Warn("Restarting stream to refresh data after data store outage");
_es.Restart(false);
}
}
internal DataStoreUpdatesImpl(TaskExecutor taskExecutor, Logger log)
{
_taskExecutor = taskExecutor;
var initialStatus = new DataStoreStatus
{
Available = true,
RefreshNeeded = false
};
_status = new StateMonitor <DataStoreStatus, DataStoreStatus>(initialStatus, MaybeUpdate, log);
}
public void UpdateStatus(DataStoreStatus newStatus)
{
lock (_stateLock)
{
if (newStatus.Equals(_currentStatus))
{
return;
}
_currentStatus = newStatus;
}
_taskExecutor.ScheduleEvent(this, newStatus, StatusChanged);
}
internal void UpdateAvailability(bool available)
{
if (_lastAvailable.GetAndSet(available) == available)
{
return; // no change
}
var status = new DataStoreStatus
{
Available = available,
RefreshNeeded = available && _refreshOnRecovery
};
if (available)
{
_log.Warn("Persistent store is available again");
}
_statusUpdater(status);
// If the store has just become unavailable, start a poller to detect when it comes back.
// If it has become available, stop any polling we are currently doing.
lock (_pollerLock)
{
if (available)
{
_pollCanceller?.Cancel();
_pollCanceller = null;
}
else
{
_log.Warn("Detected persistent store unavailability; updates will be cached until it recovers");
if (_pollCanceller is null)
{
// Start polling until the store starts working again
_pollCanceller = _taskExecutor.StartRepeatingTask(
PollInterval,
PollInterval,
() =>
{
if (_statusPollFn())
{
UpdateAvailability(true);
}
return(Task.FromResult(true)); // return value doesn't matter here
}
);
}
}
}
}
public void UpdateStatusBroadcastsNewStatus()
{
var statuses = new EventSink <DataStoreStatus>();
updates.StatusChanged += statuses.Add;
var expectedStatus = new DataStoreStatus
{
Available = false,
RefreshNeeded = true
};
updates.UpdateStatus(expectedStatus);
var newStatus = statuses.ExpectValue();
Assert.Equal(expectedStatus, newStatus);
statuses.ExpectNoValue();
}
public void DataStoreStatusProviderSendsStatusUpdates()
{
var dataStoreFactory = new CapturingDataStoreFactory(Components.InMemoryDataStore);
var config = BasicConfig()
.DataStore(dataStoreFactory)
.Build();
using (var client = new LdClient(config))
{
var statuses = new EventSink <DataStoreStatus>();
client.DataStoreStatusProvider.StatusChanged += statuses.Add;
var newStatus = new DataStoreStatus {
Available = false
};
dataStoreFactory.DataStoreUpdates.UpdateStatus(newStatus);
Assert.Equal(newStatus, statuses.ExpectValue());
}
}
public void Listeners()
{
var statuses = new EventSink <DataStoreStatus>();
_dataStoreStatusProvider.StatusChanged += statuses.Add;
var unwantedStatuses = new EventSink <DataStoreStatus>();
_dataStoreStatusProvider.StatusChanged += unwantedStatuses.Add;
_dataStoreStatusProvider.StatusChanged -= unwantedStatuses.Add; // testing that a listener can be removed
var status = new DataStoreStatus {
Available = false, RefreshNeeded = false
};
_dataStoreUpdates.UpdateStatus(status);
Assert.Equal(status, statuses.ExpectValue());
unwantedStatuses.ExpectNoValue();
}
public void DataStoreStatusProviderReturnsLatestStatus()
{
var dataStoreFactory = new CapturingDataStoreFactory(Components.InMemoryDataStore);
var config = BasicConfig()
.DataStore(dataStoreFactory)
.Build();
using (var client = new LdClient(config))
{
Assert.Equal(new DataStoreStatus {
Available = true
},
client.DataStoreStatusProvider.Status);
var newStatus = new DataStoreStatus {
Available = false
};
dataStoreFactory.DataStoreUpdates.UpdateStatus(newStatus);
Assert.Equal(newStatus, client.DataStoreStatusProvider.Status);
}
}
public void Status()
{
Assert.Equal(new DataStoreStatus {
Available = true, RefreshNeeded = false
},
_dataStoreStatusProvider.Status);
var status1 = new DataStoreStatus {
Available = false, RefreshNeeded = false
};
_dataStoreUpdates.UpdateStatus(status1);
Assert.Equal(status1, _dataStoreStatusProvider.Status);
var status2 = new DataStoreStatus {
Available = false, RefreshNeeded = true
};
_dataStoreUpdates.UpdateStatus(status2);
Assert.Equal(status2, _dataStoreStatusProvider.Status);
}
public void DataStoreStatusProviderReturnsLatestStatus()
{
var dataStoreFactory = new CapturingDataStoreFactory(Components.InMemoryDataStore);
var config = Configuration.Builder("")
.DataSource(Components.ExternalUpdatesOnly)
.DataStore(dataStoreFactory)
.Events(Components.NoEvents)
.Build();
using (var client = new LdClient(config))
{
Assert.Equal(new DataStoreStatus {
Available = true
},
client.DataStoreStatusProvider.Status);
var newStatus = new DataStoreStatus {
Available = false
};
dataStoreFactory.DataStoreUpdates.UpdateStatus(newStatus);
Assert.Equal(newStatus, client.DataStoreStatusProvider.Status);
}
}
private DataStoreStatus?MaybeUpdate(DataStoreStatus lastValue, DataStoreStatus newValue) => newValue.Equals(lastValue) ? (DataStoreStatus?)null : newValue;
