log_node_param_helper_test.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License").
5  * You may not use this file except in compliance with the License.
6  * A copy of the License is located at
7  *
8  * http://aws.amazon.com/apache2.0
9  *
10  * or in the "license" file accompanying this file. This file is distributed
11  * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
12  * express or implied. See the License for the specific language governing
13  * permissions and limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18 #include <cloudwatch_logger/log_node_param_helper.h>
19 #include <aws_common/sdk_utils/parameter_reader.h>
20 #include <aws_common/sdk_utils/aws_error.h>
21 
22 using namespace Aws::Client;
23 using namespace Aws::CloudWatchLogs::Utils;
24 using ::testing::Eq;
25 using ::testing::A;
26 using ::testing::InSequence;
27 using ::testing::SetArgReferee;
28 using ::testing::DoAll;
29 using ::testing::Return;
30 using ::testing::Invoke;
31 using Aws::AwsError;
32 
33 class ParameterReaderMock : public ParameterReaderInterface
34 {
35 public:
36  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, std::vector<std::string> &));
37  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, double &));
38  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, int &));
39  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, bool &));
40  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, Aws::String &));
41  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, std::string &));
42  MOCK_CONST_METHOD2(ReadParam, Aws::AwsError(const ParameterPath &, std::map<std::string, std::string> &));
43 };
44 
45 class LogNodeParamHelperFixture : public ::testing::Test
46 {
47 protected:
48  std::shared_ptr<ParameterReaderMock> param_reader_ = std::make_shared<ParameterReaderMock>();
49 };
50 
51 TEST_F(LogNodeParamHelperFixture, TestReadPublishFrequency)
52 {
53  double expected_param_value = 42.0;
54 
55  {
56  InSequence read_param_seq;
57 
58  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishFrequencyKey)), A<double&>()))
59  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
60 
61  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishFrequencyKey)), A<double&>()))
62  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
63 
64  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishFrequencyKey)), A<double&>()))
65  .WillOnce(
66  DoAll(SetArgReferee<1>(expected_param_value), Return(AwsError::AWS_ERR_OK))
67  );
68  }
69 
70  double param = -1;
71  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadPublishFrequency(param_reader_, param));
72  EXPECT_EQ(kNodePublishFrequencyDefaultValue, param);
73 
74  param = -1;
75  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadPublishFrequency(param_reader_, param));
76  EXPECT_EQ(kNodePublishFrequencyDefaultValue, param);
77 
78  param = -1;
79  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadPublishFrequency(param_reader_, param));
80  EXPECT_EQ(expected_param_value, param);
81 }
82 
83 TEST_F(LogNodeParamHelperFixture, TestReadLogGroup)
84 {
85  std::string expected_param_value = "MTc4MGNjOTc3ZTA1OTY";
86 
87  {
88  InSequence read_param_seq;
89 
90  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogGroupNameKey)), A<std::string &>()))
91  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
92 
93  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogGroupNameKey)), A<std::string &>()))
94  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
95 
96  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogGroupNameKey)), A<std::string &>()))
97  .WillOnce(
98  DoAll(SetArgReferee<1>(expected_param_value), Return(AwsError::AWS_ERR_OK))
99  );
100  }
101 
102  std::string param = "";
103  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadLogGroup(param_reader_, param));
104  EXPECT_STREQ(kNodeLogGroupNameDefaultValue, param.c_str());
105 
106  param = "";
107  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadLogGroup(param_reader_, param));
108  EXPECT_STREQ(kNodeLogGroupNameDefaultValue, param.c_str());
109 
110  param = "";
111  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadLogGroup(param_reader_, param));
112  EXPECT_STREQ(expected_param_value.c_str(), param.c_str());
113 }
114 
115 TEST_F(LogNodeParamHelperFixture, TestReadLogStream)
116 {
117  std::string expected_param_value = "MGQyNTU3N2I3NzU1ZGIyNWQzMTZhYmVh";
118 
119  {
120  InSequence read_param_seq;
121 
122  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogStreamNameKey)), A<std::string &>()))
123  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
124 
125  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogStreamNameKey)), A<std::string &>()))
126  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
127 
128  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamLogStreamNameKey)), A<std::string &>()))
129  .WillOnce(
130  DoAll(SetArgReferee<1>(expected_param_value), Return(AwsError::AWS_ERR_OK))
131  );
132  }
133 
134  std::string param = "";
135  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadLogStream(param_reader_, param));
136  EXPECT_STREQ(kNodeLogStreamNameDefaultValue, param.c_str());
137 
138  param = "";
139  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadLogStream(param_reader_, param));
140  EXPECT_STREQ(kNodeLogStreamNameDefaultValue, param.c_str());
141 
142  param = "";
143  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadLogStream(param_reader_, param));
144  EXPECT_STREQ(expected_param_value.c_str(), param.c_str());
145 }
146 
147 TEST_F(LogNodeParamHelperFixture, TestReadSubscribeToRosout)
148 {
149  bool expected_param_value = ! kNodeSubscribeToRosoutDefaultValue;
150 
151  {
152  InSequence read_param_seq;
153 
154  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamSubscribeToRosoutKey)), A<bool &>()))
155  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
156 
157  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamSubscribeToRosoutKey)), A<bool &>()))
158  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
159 
160  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamSubscribeToRosoutKey)), A<bool &>()))
161  .WillOnce(
162  DoAll(SetArgReferee<1>(expected_param_value), Return(AwsError::AWS_ERR_OK))
163  );
164  }
165 
166  bool param = ! kNodeSubscribeToRosoutDefaultValue;
167  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadSubscribeToRosout(param_reader_, param));
168  EXPECT_EQ(kNodeSubscribeToRosoutDefaultValue, param);
169 
170  param = ! kNodeSubscribeToRosoutDefaultValue;;
171  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadSubscribeToRosout(param_reader_, param));
172  EXPECT_EQ(kNodeSubscribeToRosoutDefaultValue, param);
173 
174  param = ! kNodeSubscribeToRosoutDefaultValue;
175  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadSubscribeToRosout(param_reader_, param));
176  EXPECT_EQ(expected_param_value, param);
177 }
178 
179 TEST_F(LogNodeParamHelperFixture, TestReadReadMinLogVerbosity)
180 {
181  {
182  InSequence read_param_seq;
183 
184  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
185  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
186 
187  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
188  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
189 
190  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
191  .WillOnce(
192  DoAll(SetArgReferee<1>("DEBUG"), Return(AwsError::AWS_ERR_OK))
193  );
194 
195  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
196  .WillOnce(
197  DoAll(SetArgReferee<1>("INFO"), Return(AwsError::AWS_ERR_OK))
198  );
199 
200  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
201  .WillOnce(
202  DoAll(SetArgReferee<1>("WARN"), Return(AwsError::AWS_ERR_OK))
203  );
204 
205  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
206  .WillOnce(
207  DoAll(SetArgReferee<1>("ERROR"), Return(AwsError::AWS_ERR_OK))
208  );
209 
210  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
211  .WillOnce(
212  DoAll(SetArgReferee<1>("FATAL"), Return(AwsError::AWS_ERR_OK))
213  );
214 
215  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamMinLogVerbosityKey)), A<std::string &>()))
216  .WillOnce(
217  DoAll(SetArgReferee<1>("xNDlhZmJmNGM"), Return(AwsError::AWS_ERR_OK))
218  );
219  }
220 
221  int8_t param = rosgraph_msgs::Log::FATAL + 1 ;
222  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadMinLogVerbosity(param_reader_, param));
223  EXPECT_EQ(kNodeMinLogVerbosityDefaultValue, param);
224 
225  param = rosgraph_msgs::Log::FATAL + 1 ;
226  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadMinLogVerbosity(param_reader_, param));
227  EXPECT_EQ(kNodeMinLogVerbosityDefaultValue, param);
228 
229  param = rosgraph_msgs::Log::FATAL + 1 ;
230  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadMinLogVerbosity(param_reader_, param));
231  EXPECT_EQ(rosgraph_msgs::Log::DEBUG, param);
232 
233  param = rosgraph_msgs::Log::FATAL + 1 ;
234  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadMinLogVerbosity(param_reader_, param));
235  EXPECT_EQ(rosgraph_msgs::Log::INFO, param);
236 
237  param = rosgraph_msgs::Log::FATAL + 1 ;
238  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadMinLogVerbosity(param_reader_, param));
239  EXPECT_EQ(rosgraph_msgs::Log::WARN, param);
240 
241  param = rosgraph_msgs::Log::FATAL + 1 ;
242  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadMinLogVerbosity(param_reader_, param));
243  EXPECT_EQ(rosgraph_msgs::Log::ERROR, param);
244 
245  param = rosgraph_msgs::Log::FATAL + 1 ;
246  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadMinLogVerbosity(param_reader_, param));
247  EXPECT_EQ(rosgraph_msgs::Log::FATAL, param);
248 
249  param = rosgraph_msgs::Log::FATAL + 1 ;
250  EXPECT_EQ(AwsError::AWS_ERR_PARAM, ReadMinLogVerbosity(param_reader_, param));
251  EXPECT_EQ(kNodeMinLogVerbosityDefaultValue, param);
252 }
253 
254 TEST_F(LogNodeParamHelperFixture, TestPublishTopicNames)
255 {
256  {
257  InSequence read_param_seq;
258 
259  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishTopicNamesKey)), A<bool &>()))
260  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
261 
262  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishTopicNamesKey)), A<bool &>()))
263  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
264 
265  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishTopicNamesKey)), A<bool &>()))
266  .WillOnce(DoAll(SetArgReferee<1>(true), Return(AwsError::AWS_ERR_OK)));
267 
268  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamPublishTopicNamesKey)), A<bool &>()))
269  .WillOnce(DoAll(SetArgReferee<1>(false), Return(AwsError::AWS_ERR_OK)));
270  }
271 
272  bool param = false;
273  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadPublishTopicNames(param_reader_, param));
274  EXPECT_EQ(kNodePublishTopicNamesDefaultValue, param);
275 
276  param = false;
277  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadPublishTopicNames(param_reader_, param));
278  EXPECT_EQ(kNodePublishTopicNamesDefaultValue, param);
279 
280  param = false;
281  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadPublishTopicNames(param_reader_, param));
282  EXPECT_EQ(true, param);
283 
284  param = true;
285  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadPublishTopicNames(param_reader_, param));
286  EXPECT_EQ(false, param);
287 }
288 
289 AwsError MockReadParamAddStringToList(const ParameterPath & param_path, std::vector<std::string> & out)
290 {
291  (void)param_path;
292  out.emplace_back("String1");
293  return AwsError::AWS_ERR_OK;
294 }
295 
296 TEST_F(LogNodeParamHelperFixture, TestReadIgnoreNodesSet)
297 {
298 
299  {
300  InSequence read_param_seq;
301 
302  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamIgnoreNodesKey)), A<std::vector<std::string>&>()))
303  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
304 
305  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamIgnoreNodesKey)), A<std::vector<std::string>&>()))
306  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
307 
308  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamIgnoreNodesKey)), A<std::vector<std::string>&>()))
309  .WillOnce(Invoke(MockReadParamAddStringToList));
310  }
311 
312  std::unordered_set<std::string> param;
313  EXPECT_EQ(AwsError::AWS_ERR_FAILURE, ReadIgnoreNodesSet(param_reader_, param));
314  EXPECT_EQ(0, param.size());
315 
316  EXPECT_EQ(AwsError::AWS_ERR_NOT_FOUND, ReadIgnoreNodesSet(param_reader_, param));
317  EXPECT_EQ(0, param.size());
318 
319  EXPECT_EQ(AwsError::AWS_ERR_OK, ReadIgnoreNodesSet(param_reader_, param));
320  EXPECT_EQ(1, param.count("String1"));
321 }
328 TEST_F(LogNodeParamHelperFixture, Test_Delete_Stale_Data_True)
329 {
330  {
331  InSequence read_param_seq;
332 
333  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
334  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
335 
336  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
337  .WillOnce(
338  DoAll(SetArgReferee<1>(true), Return(AwsError::AWS_ERR_OK))
339  );
340 
341  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
342  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
343  }
344 
345  Aws::FileManagement::FileManagerStrategyOptions options_{"test", "log_tests/", ".log", 1024*1024, 1024*1024, true};
346  ASSERT_TRUE(options_.delete_stale_data);
347 
348  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
349  ASSERT_FALSE(options_.delete_stale_data);
350 
351  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
352  ASSERT_TRUE(options_.delete_stale_data);
353 
354  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
355  ASSERT_FALSE(options_.delete_stale_data);
356 }
365 TEST_F(LogNodeParamHelperFixture, Test_Delete_Stale_Data_Not_Defined)
366 {
367  {
368  InSequence read_param_seq;
369 
370  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
371  .WillOnce(
372  DoAll(SetArgReferee<1>(true), Return(AwsError::AWS_ERR_OK))
373  );
374 
375  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
376  .WillOnce(Return(AwsError::AWS_ERR_FAILURE));
377 
378  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
379  .WillOnce(
380  DoAll(SetArgReferee<1>(true), Return(AwsError::AWS_ERR_OK))
381  );
382 
383  EXPECT_CALL(*param_reader_, ReadParam(Eq(ParameterPath(kNodeParamDeleteStaleData)), A<bool &>()))
384  .WillOnce(Return(AwsError::AWS_ERR_NOT_FOUND));
385  }
386 
387  Aws::FileManagement::FileManagerStrategyOptions options_{"test", "log_tests/", ".log", 1024*1024, 1024*1024};
388  ASSERT_FALSE(options_.delete_stale_data);
389 
390  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
391  ASSERT_TRUE(options_.delete_stale_data);
392 
393  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
394  ASSERT_FALSE(options_.delete_stale_data);
395 
396  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
397  ASSERT_TRUE(options_.delete_stale_data);
398 
399  ReadOption(param_reader_, kNodeParamDeleteStaleData, Aws::FileManagement::kDefaultFileManagerStrategyOptions.delete_stale_data, options_.delete_stale_data);
400  ASSERT_FALSE(options_.delete_stale_data);
401 }
402 
403 int main(int argc, char ** argv)
404 {
405  testing::InitGoogleTest(&argc, argv);
406  return RUN_ALL_TESTS();
407 }
Aws::CloudWatchLogs::Utils::ReadIgnoreNodesSet
Aws::AwsError ReadIgnoreNodesSet(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, std::unordered_set< std::string > &ignore_nodes)
Definition: log_node_param_helper.cpp:227
param
bool param(const std::string &param_name, T &param_val, const T &default_val)
log_node_param_helper.h
TEST_F
TEST_F(LogNodeParamHelperFixture, TestReadPublishFrequency)
Definition: log_node_param_helper_test.cpp:51
Aws::CloudWatchLogs::Utils::ReadSubscribeToRosout
Aws::AwsError ReadSubscribeToRosout(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, bool &subscribe_to_rosout)
Definition: log_node_param_helper.cpp:99
Aws::CloudWatchLogs::Utils::ReadMinLogVerbosity
Aws::AwsError ReadMinLogVerbosity(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, int8_t &min_log_verbosity)
Definition: log_node_param_helper.cpp:128
Aws::CloudWatchLogs::Utils::ReadPublishFrequency
Aws::AwsError ReadPublishFrequency(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, double &publish_frequency)
Definition: log_node_param_helper.cpp:27
Aws::CloudWatchLogs::Utils::kNodeParamMinLogVerbosityKey
constexpr char kNodeParamMinLogVerbosityKey[]
Definition: log_node_param_helper.h:37
Aws::CloudWatchLogs::Utils::kNodeParamPublishFrequencyKey
constexpr char kNodeParamPublishFrequencyKey[]
Definition: log_node_param_helper.h:33
Aws::CloudWatchLogs::Utils::kNodeMinLogVerbosityDefaultValue
constexpr int8_t kNodeMinLogVerbosityDefaultValue
Definition: log_node_param_helper.h:59
MockReadParamAddStringToList
AwsError MockReadParamAddStringToList(const ParameterPath &param_path, std::vector< std::string > &out)
Definition: log_node_param_helper_test.cpp:289
Aws::CloudWatchLogs::Utils::kNodeParamSubscribeToRosoutKey
constexpr char kNodeParamSubscribeToRosoutKey[]
Definition: log_node_param_helper.h:34
Aws::FileManagement::kDefaultFileManagerStrategyOptions
static const FileManagerStrategyOptions kDefaultFileManagerStrategyOptions
main
int main(int argc, char **argv)
Definition: log_node_param_helper_test.cpp:403
Aws::CloudWatchLogs::Utils::ReadLogStream
Aws::AwsError ReadLogStream(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, std::string &log_stream)
Definition: log_node_param_helper.cpp:76
Aws::CloudWatchLogs::Utils::kNodeSubscribeToRosoutDefaultValue
constexpr bool kNodeSubscribeToRosoutDefaultValue
Definition: log_node_param_helper.h:61
Aws::CloudWatchLogs::Utils::ReadPublishTopicNames
Aws::AwsError ReadPublishTopicNames(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, bool &publish_topic_names)
Definition: log_node_param_helper.cpp:173
Aws::CloudWatchLogs::Utils::kNodePublishTopicNamesDefaultValue
constexpr bool kNodePublishTopicNamesDefaultValue
Definition: log_node_param_helper.h:62
Aws::CloudWatchLogs::Utils::kNodePublishFrequencyDefaultValue
constexpr double kNodePublishFrequencyDefaultValue
Definition: log_node_param_helper.h:60
Aws::CloudWatchLogs::Utils::ReadLogGroup
Aws::AwsError ReadLogGroup(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, std::string &log_group)
Definition: log_node_param_helper.cpp:53
parameter_reader.h
Aws::CloudWatchLogs::Utils::kNodeParamLogGroupNameKey
constexpr char kNodeParamLogGroupNameKey[]
Definition: log_node_param_helper.h:35
Aws::CloudWatchLogs::Utils::kNodeParamDeleteStaleData
constexpr char kNodeParamDeleteStaleData[]
Definition: log_node_param_helper.h:54
aws_error.h
Aws::CloudWatchLogs::Utils::kNodeParamPublishTopicNamesKey
constexpr char kNodeParamPublishTopicNamesKey[]
Definition: log_node_param_helper.h:38
Aws::CloudWatchLogs::Utils::kNodeLogStreamNameDefaultValue
constexpr char kNodeLogStreamNameDefaultValue[]
Definition: log_node_param_helper.h:58
Aws::CloudWatchLogs::Utils::kNodeParamIgnoreNodesKey
constexpr char kNodeParamIgnoreNodesKey[]
Definition: log_node_param_helper.h:39
Aws::CloudWatchLogs::Utils::ReadOption
void ReadOption(const std::shared_ptr< Aws::Client::ParameterReaderInterface > &parameter_reader, const std::string &option_key, const std::string &default_value, std::string &option_value)
Definition: log_node_param_helper.cpp:346
Aws::CloudWatchLogs::Utils::kNodeParamLogStreamNameKey
constexpr char kNodeParamLogStreamNameKey[]
Definition: log_node_param_helper.h:32
Aws::CloudWatchLogs::Utils::kNodeLogGroupNameDefaultValue
constexpr char kNodeLogGroupNameDefaultValue[]
Definition: log_node_param_helper.h:57

cloudwatch_logger
Author(s): AWS RoboMaker
autogenerated on Sat Mar 6 2021 03:55:46