/** * Copyright (C) 2015 MongoDB Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License, version 3, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . * * As a special exception, the copyright holders give permission to link the * code of portions of this program with the OpenSSL library under certain * conditions as described in each individual source file and distribute * linked combinations including the program with the OpenSSL library. You * must comply with the GNU Affero General Public License in all respects * for all of the code used other than as permitted herein. If you modify * file(s) with this exception, you may extend this exception to your * version of the file(s), but you are not obligated to do so. If you do not * wish to do so, delete this exception statement from your version. If you * delete this exception statement from all source files in the program, * then also delete it in the license file. */ #define MONGO_LOG_DEFAULT_COMPONENT ::mongo::logger::LogComponent::kSharding #include "mongo/platform/basic.h" #include "mongo/db/s/sharding_state.h" #include "mongo/db/s/operation_sharding_state.h" #include "mongo/db/s/sharded_connection_info.h" #include "mongo/db/server_options.h" #include "mongo/util/log.h" namespace mongo { namespace { const auto getShardingState = ServiceContext::declareDecoration(); } // namespace ShardingState::ShardingState() = default; ShardingState::~ShardingState() = default; ShardingState* ShardingState::get(ServiceContext* serviceContext) { return &getShardingState(serviceContext); } ShardingState* ShardingState::get(OperationContext* operationContext) { return ShardingState::get(operationContext->getServiceContext()); } void ShardingState::setInitialized(ShardId shardId, OID clusterId) { stdx::unique_lock ul(_mutex); invariant(_getInitializationState() == InitializationState::kNew); _shardId = std::move(shardId); _clusterId = std::move(clusterId); _initializationStatus = Status::OK(); _initializationState.store(static_cast(InitializationState::kInitialized)); } void ShardingState::setInitialized(Status failedStatus) { invariant(!failedStatus.isOK()); log() << "Failed to initialize sharding components" << causedBy(failedStatus); stdx::unique_lock ul(_mutex); invariant(_getInitializationState() == InitializationState::kNew); _initializationStatus = std::move(failedStatus); _initializationState.store(static_cast(InitializationState::kError)); } boost::optional ShardingState::initializationStatus() { stdx::unique_lock ul(_mutex); if (_getInitializationState() == InitializationState::kNew) return boost::none; return _initializationStatus; } bool ShardingState::enabled() const { return _getInitializationState() == InitializationState::kInitialized; } Status ShardingState::canAcceptShardedCommands() const { if (serverGlobalParams.clusterRole != ClusterRole::ShardServer) { return {ErrorCodes::NoShardingEnabled, "Cannot accept sharding commands if not started with --shardsvr"}; } else if (!enabled()) { return {ErrorCodes::ShardingStateNotInitialized, "Cannot accept sharding commands if sharding state has not " "been initialized with a shardIdentity document"}; } else { return Status::OK(); } } ShardId ShardingState::shardId() { invariant(enabled()); stdx::lock_guard lk(_mutex); return _shardId; } OID ShardingState::clusterId() { invariant(enabled()); stdx::lock_guard lk(_mutex); return _clusterId; } bool ShardingState::needCollectionMetadata(OperationContext* opCtx, const std::string& ns) { if (!enabled()) return false; Client* client = opCtx->getClient(); // Shard version information received from mongos may either by attached to the Client or // directly to the OperationContext. return ShardedConnectionInfo::get(client, false) || OperationShardingState::get(opCtx).hasShardVersion(); } void ShardingState::clearForTests() { _initializationState.store(static_cast(InitializationState::kNew)); } } // namespace mongo