1 /* 2 * 3 * Copyright 2015 gRPC authors. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 19 #ifndef GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H 20 #define GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H 21 22 #include <list> 23 #include <vector> 24 25 #include <grpc/compression.h> 26 #include <grpc/grpc.h> 27 #include <grpcpp/resource_quota.h> 28 #include <grpcpp/support/config.h> 29 30 namespace grpc { 31 class SecureChannelCredentials; 32 namespace testing { 33 class ChannelArgumentsTest; 34 } // namespace testing 35 36 /// Options for channel creation. The user can use generic setters to pass 37 /// key value pairs down to C channel creation code. For gRPC related options, 38 /// concrete setters are provided. 39 class ChannelArguments { 40 public: 41 ChannelArguments(); 42 ~ChannelArguments(); 43 44 ChannelArguments(const ChannelArguments& other); 45 ChannelArguments& operator=(ChannelArguments other) { 46 Swap(other); 47 return *this; 48 } 49 50 void Swap(ChannelArguments& other); 51 52 /// Dump arguments in this instance to \a channel_args. Does not take 53 /// ownership of \a channel_args. 54 /// 55 /// Note that the underlying arguments are shared. Changes made to either \a 56 /// channel_args or this instance would be reflected on both. 57 void SetChannelArgs(grpc_channel_args* channel_args) const; 58 59 // gRPC specific channel argument setters 60 /// Set target name override for SSL host name checking. This option should 61 /// be used with caution in production. 62 void SetSslTargetNameOverride(const std::string& name); 63 // TODO(yangg) add flow control options 64 /// Set the compression algorithm for the channel. 65 void SetCompressionAlgorithm(grpc_compression_algorithm algorithm); 66 67 /// Set the grpclb fallback timeout (in ms) for the channel. If this amount 68 /// of time has passed but we have not gotten any non-empty \a serverlist from 69 /// the balancer, we will fall back to use the backend address(es) returned by 70 /// the resolver. 71 void SetGrpclbFallbackTimeout(int fallback_timeout); 72 73 /// For client channel's, the socket mutator operates on 74 /// "channel" sockets. For server's, the socket mutator operates 75 /// only on "listen" sockets. 76 /// TODO(apolcyn): allow socket mutators to also operate 77 /// on server "channel" sockets, and adjust the socket mutator 78 /// object to be more speficic about which type of socket 79 /// it should operate on. 80 void SetSocketMutator(grpc_socket_mutator* mutator); 81 82 /// Set the string to prepend to the user agent. 83 void SetUserAgentPrefix(const std::string& user_agent_prefix); 84 85 /// Set the buffer pool to be attached to the constructed channel. 86 void SetResourceQuota(const grpc::ResourceQuota& resource_quota); 87 88 /// Set the max receive and send message sizes. 89 void SetMaxReceiveMessageSize(int size); 90 void SetMaxSendMessageSize(int size); 91 92 /// Set LB policy name. 93 /// Note that if the name resolver returns only balancer addresses, the 94 /// grpclb LB policy will be used, regardless of what is specified here. 95 void SetLoadBalancingPolicyName(const std::string& lb_policy_name); 96 97 /// Set service config in JSON form. 98 /// Primarily meant for use in unit tests. 99 void SetServiceConfigJSON(const std::string& service_config_json); 100 101 // Generic channel argument setter. Only for advanced use cases. 102 /// Set an integer argument \a value under \a key. 103 void SetInt(const std::string& key, int value); 104 105 // Generic channel argument setter. Only for advanced use cases. 106 /// Set a pointer argument \a value under \a key. Ownership is not 107 /// transferred. 108 void SetPointer(const std::string& key, void* value); 109 110 /// Set a pointer argument \a value under \a key, transferring ownership of 111 /// \a value to the \a ChannelArguments object. The \a vtable::Delete function 112 /// is responsible for \a value cleanup/destruction when called. 113 void SetPointerWithVtable(const std::string& key, void* value, 114 const grpc_arg_pointer_vtable* vtable); 115 116 /// Set a textual argument \a value under \a key. 117 void SetString(const std::string& key, const std::string& value); 118 119 /// Return (by value) a C \a grpc_channel_args structure which points to 120 /// arguments owned by this \a ChannelArguments instance c_channel_args()121 grpc_channel_args c_channel_args() const { 122 grpc_channel_args out; 123 out.num_args = args_.size(); 124 out.args = args_.empty() ? nullptr : const_cast<grpc_arg*>(&args_[0]); 125 return out; 126 } 127 128 private: 129 friend class grpc::SecureChannelCredentials; 130 friend class grpc::testing::ChannelArgumentsTest; 131 132 /// Default pointer argument operations. 133 struct PointerVtableMembers { CopyPointerVtableMembers134 static void* Copy(void* in) { return in; } DestroyPointerVtableMembers135 static void Destroy(void* /*in*/) {} ComparePointerVtableMembers136 static int Compare(void* a, void* b) { 137 if (a < b) return -1; 138 if (a > b) return 1; 139 return 0; 140 } 141 }; 142 143 // Returns empty string when it is not set. 144 std::string GetSslTargetNameOverride() const; 145 146 std::vector<grpc_arg> args_; 147 std::list<std::string> strings_; 148 }; 149 150 } // namespace grpc 151 152 #endif // GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H 153