Skip to content

fix: old provider not shutting down when the new provider fails to initialize #98

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
NeaguGeorgiana23 wants to merge 5 commits into
base: main
Choose a base branch
from
+124 −122
Open

fix: old provider not shutting down when the new provider fails to initialize #98

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
c5c4a7a
Fix old provider not shutting down when the new provider fails to ini…
NeaguGeorgiana23 May 12, 2026
e09a802
Fix linter errors.
NeaguGeorgiana23 May 12, 2026
74db796
Fix linter errors.
NeaguGeorgiana23 May 12, 2026
af3cd35
Fix linter errors.
NeaguGeorgiana23 May 12, 2026
775754f
Fix linter errors.
NeaguGeorgiana23 May 12, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
68 changes: 31 additions & 37 deletions openfeature/provider_repository.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
#include "openfeature/provider_repository.h"

#include <algorithm>
#include <iostream>

#include "absl/status/statusor.h"
Expand Down Expand Up @@ -30,9 +31,9 @@ ProviderRepository::GetFeatureProviderStatusManager(
return default_manager_;
}

auto it = provider_manager_.find(std::string(domain));
if (it != provider_manager_.end()) {
return it->second;
auto provider_manager_it = provider_manager_.find(std::string(domain));
if (provider_manager_it != provider_manager_.end()) {
return provider_manager_it->second;
}

return default_manager_;
Expand All @@ -49,32 +50,30 @@ std::shared_ptr<FeatureProvider> ProviderRepository::GetProvider(
return nullptr;
}

void ProviderRepository::SetProvider(std::shared_ptr<FeatureProvider> provider,
const EvaluationContext& ctx,
bool wait_for_init) {
void ProviderRepository::SetProvider(
const std::shared_ptr<FeatureProvider>& provider,
const EvaluationContext& ctx, bool wait_for_init) {
if (!provider) {
std::cerr << "Provider cannot be null" << std::endl;
std::cerr << "Provider cannot be null\n";
return;
}
PrepareAndInitializeProvider(std::nullopt, std::move(provider), ctx,
wait_for_init);
PrepareAndInitializeProvider(std::nullopt, provider, ctx, wait_for_init);
}

void ProviderRepository::SetProvider(std::string_view domain,
std::shared_ptr<FeatureProvider> provider,
const EvaluationContext& ctx,
bool wait_for_init) {
void ProviderRepository::SetProvider(
std::string_view domain, const std::shared_ptr<FeatureProvider>& provider,
const EvaluationContext& ctx, bool wait_for_init) {
if (!provider) {
std::cerr << "Provider cannot be null" << std::endl;
std::cerr << "Provider cannot be null\n";
return;
}

if (domain.empty()) {
SetProvider(std::move(provider), ctx, wait_for_init);
SetProvider(provider, ctx, wait_for_init);
return;
}

PrepareAndInitializeProvider(std::string(domain), std::move(provider), ctx,
PrepareAndInitializeProvider(std::string(domain), provider, ctx,
wait_for_init);
}

Expand All @@ -90,7 +89,7 @@ ProviderStatus ProviderRepository::GetProviderStatus(

void ProviderRepository::Shutdown() {
{
std::lock_guard<std::mutex> lock(threads_mutex_);
std::scoped_lock lock(threads_mutex_);
for (std::thread& thread : initialization_threads_) {
if (thread.joinable()) {
thread.join();
Expand Down Expand Up @@ -128,9 +127,9 @@ void ProviderRepository::Shutdown() {
}

void ProviderRepository::PrepareAndInitializeProvider(
const std::optional<std::string> domain,
std::shared_ptr<FeatureProvider> new_provider, const EvaluationContext& ctx,
bool wait_for_init) {
const std::optional<std::string>& domain,
const std::shared_ptr<FeatureProvider>& new_provider,
const EvaluationContext& ctx, bool wait_for_init) {
std::shared_ptr<FeatureProviderStatusManager> new_status_manager;
std::shared_ptr<FeatureProviderStatusManager> old_status_manager;

Expand All @@ -144,7 +143,7 @@ void ProviderRepository::PrepareAndInitializeProvider(
FeatureProviderStatusManager::Create(new_provider);
if (!manager.ok()) {
std::cerr << "Failed to create FeatureProviderStatusManager: "
<< manager.status() << std::endl;
<< manager.status() << "\n";
return;
}
new_status_manager = std::move(manager.value());
Expand All @@ -154,9 +153,9 @@ void ProviderRepository::PrepareAndInitializeProvider(

if (domain) {
// Setting a named provider.
auto it = provider_manager_.find(domain.value());
if (it != provider_manager_.end()) {
old_status_manager = it->second;
auto provider_manager_it = provider_manager_.find(domain.value());
if (provider_manager_it != provider_manager_.end()) {
old_status_manager = provider_manager_it->second;
}
provider_manager_[domain.value()] = new_status_manager;
} else {
Expand All @@ -169,7 +168,7 @@ void ProviderRepository::PrepareAndInitializeProvider(
if (wait_for_init) {
InitializeProvider(new_status_manager, old_status_manager, ctx);
} else {
std::lock_guard<std::mutex> lock(threads_mutex_);
std::scoped_lock lock(threads_mutex_);
initialization_threads_.emplace_back(
[this, new_status_manager, old_status_manager, ctx] {
InitializeProvider(new_status_manager, old_status_manager, ctx);
Expand All @@ -178,20 +177,18 @@ void ProviderRepository::PrepareAndInitializeProvider(
}

void ProviderRepository::InitializeProvider(
std::shared_ptr<FeatureProviderStatusManager> new_status_manager,
std::shared_ptr<FeatureProviderStatusManager> old_status_manager,
const std::shared_ptr<FeatureProviderStatusManager>& new_status_manager,
const std::shared_ptr<FeatureProviderStatusManager>& old_status_manager,
const EvaluationContext& ctx) {
if (new_status_manager->GetStatus() == ProviderStatus::kNotReady) {
new_status_manager->Init(ctx);
}

if (new_status_manager->GetStatus() == ProviderStatus::kReady) {
ShutdownOldProvider(old_status_manager);
}
ShutdownOldProvider(old_status_manager);
}

void ProviderRepository::ShutdownOldProvider(
std::shared_ptr<FeatureProviderStatusManager> old_status_manager) {
const std::shared_ptr<FeatureProviderStatusManager>& old_status_manager) {
if (old_status_manager) {
std::shared_lock<std::shared_mutex> lock(repo_mutex_);

Expand Down Expand Up @@ -221,12 +218,9 @@ bool ProviderRepository::IsStatusManagerRegistered(
if (default_manager_ == manager) {
return true;
}
for (const auto& pair : provider_manager_) {
if (pair.second == manager) {
return true;
}
}
return false;
return std::any_of(
provider_manager_.begin(), provider_manager_.end(),
[&manager](const auto& pair) { return pair.second == manager; });
}

} // namespace openfeature
20 changes: 10 additions & 10 deletions openfeature/provider_repository.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,13 +43,13 @@ class ProviderRepository {
std::string_view domain = "") const;

// Set the default provider.
void SetProvider(std::shared_ptr<FeatureProvider> provider,
const EvaluationContext& ctx, bool waitForInit);
void SetProvider(const std::shared_ptr<FeatureProvider>& provider,
const EvaluationContext& ctx, bool wait_for_init);

// Add a provider for a domain.
void SetProvider(std::string_view domain,
std::shared_ptr<FeatureProvider> provider,
const EvaluationContext& ctx, bool waitForInit);
const std::shared_ptr<FeatureProvider>& provider,
const EvaluationContext& ctx, bool wait_for_init);

// Fetch the status of a provider for a domain.
// If the domain is not set, return the default provider status.
Expand All @@ -63,17 +63,17 @@ class ProviderRepository {

private:
void PrepareAndInitializeProvider(
const std::optional<std::string> domain,
std::shared_ptr<FeatureProvider> new_provider,
const EvaluationContext& ctx, bool waitForInit);
const std::optional<std::string>& domain,
const std::shared_ptr<FeatureProvider>& new_provider,
const EvaluationContext& ctx, bool wait_for_init);

void InitializeProvider(
std::shared_ptr<FeatureProviderStatusManager> new_status_manager,
std::shared_ptr<FeatureProviderStatusManager> old_status_manager,
const std::shared_ptr<FeatureProviderStatusManager>& new_status_manager,
const std::shared_ptr<FeatureProviderStatusManager>& old_status_manager,
const EvaluationContext& ctx);

void ShutdownOldProvider(
std::shared_ptr<FeatureProviderStatusManager> old_status_manager);
const std::shared_ptr<FeatureProviderStatusManager>& old_status_manager);

std::shared_ptr<FeatureProviderStatusManager>
GetExistingStatusManagerForProvider(
Expand Down
Loading