foundationdb/fdbclient/ProcessClass.cpp

/*
 * ProcessClass.cpp
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2013-2026 Apple Inc. and the FoundationDB project authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "fdbclient/ProcessClass.h"

#include <cstdio>

ProcessClass::ProcessClass(std::string s, ClassSource source) : _source(source) {
	if (s == "storage")
		_class = StorageClass;
	else if (s == "transaction")
		_class = TransactionClass;
	else if (s == "resolution")
		_class = ResolutionClass;
	else if (s == "commit_proxy")
		_class = CommitProxyClass;
	else if (s == "proxy") {
		_class = CommitProxyClass;
		printf("WARNING: 'proxy' machine class is deprecated and will be automatically converted "
		       "'commit_proxy' machine class. Please use 'grv_proxy' or 'commit_proxy' specifically\n");
	} else if (s == "grv_proxy") {
		_class = GrvProxyClass;
	} else if (s == "master") {
		_class = MasterClass;
	} else if (s == "test") {
		_class = TesterClass;
	} else if (s == "unset") {
		_class = UnsetClass;
	} else if (s == "stateless") {
		_class = StatelessClass;
	} else if (s == "log") {
		_class = LogClass;
	} else if (s == "router") {
		_class = LogRouterClass;
	} else if (s == "cluster_controller") {
		_class = ClusterControllerClass;
	} else if (s == "fast_restore") {
		ASSERT(false); // deprecated
	} else if (s == "data_distributor") {
		_class = DataDistributorClass;
	} else if (s == "coordinator") {
		_class = CoordinatorClass;
	} else if (s == "ratekeeper") {
		_class = RatekeeperClass;
	} else if (s == "consistency_scan") {
		_class = ConsistencyScanClass;
	} else if (s == "blob_manager") {
		_class = BlobManagerClass;
	} else if (s == "blob_worker") {
		_class = BlobWorkerClass;
	} else if (s == "backup") {
		_class = BackupClass;
	} else if (s == "encrypt_key_proxy") {
		_class = EncryptKeyProxyClass;
	} else if (s == "sim_http_server") {
		_class = SimHTTPServerClass;
	} else {
		_class = InvalidClass;
	}
}

ProcessClass::ProcessClass(std::string classStr, std::string sourceStr) {
	if (classStr == "storage")
		_class = StorageClass;
	else if (classStr == "transaction")
		_class = TransactionClass;
	else if (classStr == "resolution")
		_class = ResolutionClass;
	else if (classStr == "commit_proxy")
		_class = CommitProxyClass;
	else if (classStr == "proxy") {
		_class = CommitProxyClass;
		printf("WARNING: 'proxy' machine class is deprecated and will be automatically converted "
		       "'commit_proxy' machine class. Please use 'grv_proxy' or 'commit_proxy' specifically\n");
	} else if (classStr == "grv_proxy") {
		_class = GrvProxyClass;
	} else if (classStr == "master") {
		_class = MasterClass;
	} else if (classStr == "test") {
		_class = TesterClass;
	} else if (classStr == "unset") {
		_class = UnsetClass;
	} else if (classStr == "stateless") {
		_class = StatelessClass;
	} else if (classStr == "log") {
		_class = LogClass;
	} else if (classStr == "router") {
		_class = LogRouterClass;
	} else if (classStr == "cluster_controller") {
		_class = ClusterControllerClass;
	} else if (classStr == "fast_restore") {
		ASSERT(false); // deprecated
	} else if (classStr == "data_distributor") {
		_class = DataDistributorClass;
	} else if (classStr == "coordinator") {
		_class = CoordinatorClass;
	} else if (classStr == "ratekeeper") {
		_class = RatekeeperClass;
	} else if (classStr == "consistency_scan") {
		_class = ConsistencyScanClass;
	} else if (classStr == "blob_manager") {
		_class = BlobManagerClass;
	} else if (classStr == "blob_worker") {
		_class = BlobWorkerClass;
	} else if (classStr == "backup") {
		_class = BackupClass;
	} else if (classStr == "encrypt_key_proxy") {
		_class = EncryptKeyProxyClass;
	} else if (classStr == "sim_http_server") {
		_class = SimHTTPServerClass;
	} else {
		_class = InvalidClass;
	}

	if (sourceStr == "command_line")
		_source = CommandLineSource;
	else if (sourceStr == "configure_auto")
		_source = AutoSource;
	else if (sourceStr == "set_class")
		_source = DBSource;
	else
		_source = InvalidSource;
}

std::string ProcessClass::toString() const {
	switch (_class) {
	case UnsetClass:
		return "unset";
	case StorageClass:
		return "storage";
	case TransactionClass:
		return "transaction";
	case ResolutionClass:
		return "resolution";
	case CommitProxyClass:
		return "commit_proxy";
	case GrvProxyClass:
		return "grv_proxy";
	case MasterClass:
		return "master";
	case TesterClass:
		return "test";
	case StatelessClass:
		return "stateless";
	case LogClass:
		return "log";
	case LogRouterClass:
		return "router";
	case ClusterControllerClass:
		return "cluster_controller";
	case FastRestoreClass:
		ASSERT(false);
		return "fast_restore";
	case DataDistributorClass:
		return "data_distributor";
	case CoordinatorClass:
		return "coordinator";
	case RatekeeperClass:
		return "ratekeeper";
	case ConsistencyScanClass:
		return "consistency_scan";
	case BlobManagerClass:
		return "blob_manager";
	case BlobWorkerClass:
		return "blob_worker";
	case BackupClass:
		return "backup";
	case EncryptKeyProxyClass:
		return "encrypt_key_proxy";
	case SimHTTPServerClass:
		return "sim_http_server";
	default:
		return "invalid";
	}
}

std::string ProcessClass::sourceString() const {
	switch (_source) {
	case CommandLineSource:
		return "command_line";
	case AutoSource:
		return "configure_auto";
	case DBSource:
		return "set_class";
	default:
		return "invalid";
	}
}

bool ProcessClass::canBecomeStorageServer() const {
	switch (_class) {
	case StorageClass:
	case UnsetClass:
	case TransactionClass:
	case LogClass:
		return true;
	default:
		return false;
	}
}