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   /// Set a mutator for the underlying socket.
74   void SetSocketMutator(grpc_socket_mutator* mutator);
75 
76   /// Set the string to prepend to the user agent.
77   void SetUserAgentPrefix(const std::string& user_agent_prefix);
78 
79   /// Set the buffer pool to be attached to the constructed channel.
80   void SetResourceQuota(const grpc::ResourceQuota& resource_quota);
81 
82   /// Set the max receive and send message sizes.
83   void SetMaxReceiveMessageSize(int size);
84   void SetMaxSendMessageSize(int size);
85 
86   /// Set LB policy name.
87   /// Note that if the name resolver returns only balancer addresses, the
88   /// grpclb LB policy will be used, regardless of what is specified here.
89   void SetLoadBalancingPolicyName(const std::string& lb_policy_name);
90 
91   /// Set service config in JSON form.
92   /// Primarily meant for use in unit tests.
93   void SetServiceConfigJSON(const std::string& service_config_json);
94 
95   // Generic channel argument setter. Only for advanced use cases.
96   /// Set an integer argument \a value under \a key.
97   void SetInt(const std::string& key, int value);
98 
99   // Generic channel argument setter. Only for advanced use cases.
100   /// Set a pointer argument \a value under \a key. Ownership is not
101   /// transferred.
102   void SetPointer(const std::string& key, void* value);
103 
104   /// Set a pointer argument \a value under \a key, transferring ownership of
105   /// \a value to the \a ChannelArguments object. The \a vtable::Delete function
106   /// is responsible for \a value cleanup/destruction when called.
107   void SetPointerWithVtable(const std::string& key, void* value,
108                             const grpc_arg_pointer_vtable* vtable);
109 
110   /// Set a textual argument \a value under \a key.
111   void SetString(const std::string& key, const std::string& value);
112 
113   /// Return (by value) a C \a grpc_channel_args structure which points to
114   /// arguments owned by this \a ChannelArguments instance
c_channel_args()115   grpc_channel_args c_channel_args() const {
116     grpc_channel_args out;
117     out.num_args = args_.size();
118     out.args = args_.empty() ? nullptr : const_cast<grpc_arg*>(&args_[0]);
119     return out;
120   }
121 
122  private:
123   friend class grpc::SecureChannelCredentials;
124   friend class grpc::testing::ChannelArgumentsTest;
125 
126   /// Default pointer argument operations.
127   struct PointerVtableMembers {
CopyPointerVtableMembers128     static void* Copy(void* in) { return in; }
DestroyPointerVtableMembers129     static void Destroy(void* /*in*/) {}
ComparePointerVtableMembers130     static int Compare(void* a, void* b) {
131       if (a < b) return -1;
132       if (a > b) return 1;
133       return 0;
134     }
135   };
136 
137   // Returns empty string when it is not set.
138   std::string GetSslTargetNameOverride() const;
139 
140   std::vector<grpc_arg> args_;
141   std::list<std::string> strings_;
142 };
143 
144 }  // namespace grpc
145 
146 #endif  // GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H
147