server_builder.cc | Explore in Territory

//
//
// Copyright 2015-2016 gRPC 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 <limits.h>
#include <stdint.h>
#include <string.h>

#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <grpc/grpc.h>
#include <grpc/impl/compression_types.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
#include <grpc/support/workaround_list.h>
#include <grpcpp/completion_queue.h>
#include <grpcpp/impl/server_builder_option.h>
#include <grpcpp/impl/server_builder_plugin.h>
#include <grpcpp/impl/service_type.h>
#include <grpcpp/resource_quota.h>
#include <grpcpp/security/authorization_policy_provider.h>
#include <grpcpp/security/server_credentials.h>
#include <grpcpp/server.h>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include <grpcpp/server_interface.h>
#include <grpcpp/support/channel_arguments.h>
#include <grpcpp/support/server_interceptor.h>

#include "src/core/lib/gpr/string.h"
#include "src/core/lib/gpr/useful.h"
#include "src/cpp/server/external_connection_acceptor_impl.h"

namespace grpc {

static std::vector<std::unique_ptr<ServerBuilderPlugin> (*)()>*
    g_plugin_factory_list;
static gpr_once once_init_plugin_list = …;

static void do_plugin_list_init(void) { … }

ServerBuilder::ServerBuilder()
    : … { … }

ServerBuilder::~ServerBuilder() { … }

std::unique_ptr<grpc::ServerCompletionQueue> ServerBuilder::AddCompletionQueue(
    bool is_frequently_polled) { … }

ServerBuilder& ServerBuilder::RegisterService(Service* service) { … }

ServerBuilder& ServerBuilder::RegisterService(const std::string& host,
                                              Service* service) { … }

ServerBuilder& ServerBuilder::RegisterAsyncGenericService(
    AsyncGenericService* service) { … }

ServerBuilder& ServerBuilder::RegisterCallbackGenericService(
    CallbackGenericService* service) { … }

ServerBuilder& ServerBuilder::SetContextAllocator(
    std::unique_ptr<grpc::ContextAllocator> context_allocator) { … }

std::unique_ptr<grpc::experimental::ExternalConnectionAcceptor>
ServerBuilder::experimental_type::AddExternalConnectionAcceptor(
    experimental_type::ExternalConnectionType type,
    std::shared_ptr<ServerCredentials> creds) { … }

void ServerBuilder::experimental_type::SetAuthorizationPolicyProvider(
    std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
        provider) { … }

void ServerBuilder::experimental_type::EnableCallMetricRecording(
    experimental::ServerMetricRecorder* server_metric_recorder) { … }

ServerBuilder& ServerBuilder::SetOption(
    std::unique_ptr<ServerBuilderOption> option) { … }

ServerBuilder& ServerBuilder::SetSyncServerOption(
    ServerBuilder::SyncServerOption option, int val) { … }

ServerBuilder& ServerBuilder::SetCompressionAlgorithmSupportStatus(
    grpc_compression_algorithm algorithm, bool enabled) { … }

ServerBuilder& ServerBuilder::SetDefaultCompressionLevel(
    grpc_compression_level level) { … }

ServerBuilder& ServerBuilder::SetDefaultCompressionAlgorithm(
    grpc_compression_algorithm algorithm) { … }

ServerBuilder& ServerBuilder::SetResourceQuota(
    const grpc::ResourceQuota& resource_quota) { … }

ServerBuilder& ServerBuilder::AddListeningPort(
    const std::string& addr_uri, std::shared_ptr<ServerCredentials> creds,
    int* selected_port) { … }

ChannelArguments ServerBuilder::BuildChannelArgs() { … }

std::unique_ptr<grpc::Server> ServerBuilder::BuildAndStart() { … }

void ServerBuilder::InternalAddPluginFactory(
    std::unique_ptr<ServerBuilderPlugin> (*CreatePlugin)()) { … }

ServerBuilder& ServerBuilder::EnableWorkaround(grpc_workaround_list id) { … }

}  // namespace grpc
chromium/third_party/grpc/src/src/cpp/server/server_builder.cc
