Line data Source code
1 : /*
2 : ___________________________________________
3 : | _ ___ _ |
4 : | | | |__ \ | | |
5 : | | |__ ) |__ _ __ _ ___ _ __ | |_ |
6 : | | '_ \ / // _` |/ _` |/ _ \ '_ \| __| | HTTP/2 AGENT FOR MOCK TESTING
7 : | | | | |/ /| (_| | (_| | __/ | | | |_ | Version 0.0.z
8 : | |_| |_|____\__,_|\__, |\___|_| |_|\__| | https://github.com/testillano/h2agent
9 : | __/ | |
10 : | |___/ |
11 : |___________________________________________|
12 :
13 : Licensed under the MIT License <http://opensource.org/licenses/MIT>.
14 : SPDX-License-Identifier: MIT
15 : Copyright (c) 2021 Eduardo Ramos
16 :
17 : Permission is hereby granted, free of charge, to any person obtaining a copy
18 : of this software and associated documentation files (the "Software"), to deal
19 : in the Software without restriction, including without limitation the rights
20 : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
21 : copies of the Software, and to permit persons to whom the Software is
22 : furnished to do so, subject to the following conditions:
23 :
24 : The above copyright notice and this permission notice shall be included in all
25 : copies or substantial portions of the Software.
26 :
27 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
30 : AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
31 : LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
32 : OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 : SOFTWARE.
34 : */
35 :
36 : #include <memory>
37 :
38 : #include <ert/tracing/Logger.hpp>
39 :
40 : #include <FileManager.hpp>
41 :
42 : namespace h2agent
43 : {
44 : namespace model
45 : {
46 :
47 :
48 50 : void FileManager::enableMetrics(ert::metrics::Metrics *metrics, const std::string &source) {
49 :
50 50 : metrics_ = metrics;
51 :
52 50 : if (metrics_) {
53 147 : ert::metrics::labels_t familyLabels = {{"source", source}};
54 :
55 196 : ert::metrics::counter_family_t& cf = metrics->addCounterFamily("h2agent_file_manager_operations_counter", "File system operations counter in h2agent_file_manager", familyLabels);
56 147 : observed_open_operation_counter_ = &(cf.Add({{"operation", "open"}}));
57 147 : observed_close_operation_counter_ = &(cf.Add({{"operation", "close"}}));
58 147 : observed_write_operation_counter_ = &(cf.Add({{"operation", "write"}}));
59 147 : observed_empty_operation_counter_ = &(cf.Add({{"operation", "empty"}}));
60 147 : observed_delayed_close_operation_counter_ = &(cf.Add({{"operation", "delayedClose"}}));
61 147 : observed_instant_close_operation_counter_ = &(cf.Add({{"operation", "instantClose"}}));
62 196 : observed_error_open_operation_counter_ = &(cf.Add({{"result", "failed"}, {"operation", "open"}}));
63 49 : }
64 442 : }
65 :
66 29 : void FileManager::incrementObservedOpenOperationCounter() {
67 29 : if (metrics_) observed_open_operation_counter_->Increment();
68 29 : }
69 :
70 29 : void FileManager::incrementObservedCloseOperationCounter() {
71 29 : if (metrics_) observed_close_operation_counter_->Increment();
72 29 : }
73 :
74 7 : void FileManager::incrementObservedWriteOperationCounter() {
75 7 : if (metrics_) observed_write_operation_counter_->Increment();
76 7 : }
77 :
78 9 : void FileManager::incrementObservedEmptyOperationCounter() {
79 9 : if (metrics_) observed_empty_operation_counter_->Increment();
80 9 : }
81 :
82 1 : void FileManager::incrementObservedDelayedCloseOperationCounter() {
83 1 : if (metrics_) observed_delayed_close_operation_counter_->Increment();
84 1 : }
85 :
86 6 : void FileManager::incrementObservedInstantCloseOperationCounter() {
87 6 : if (metrics_) observed_instant_close_operation_counter_->Increment();
88 6 : }
89 :
90 5 : void FileManager::incrementObservedErrorOpenOperationCounter() {
91 5 : if (metrics_) observed_error_open_operation_counter_->Increment();
92 5 : }
93 :
94 5 : void FileManager::write(const std::string &path, const std::string &data, bool textOrBinary, unsigned int closeDelayUs) {
95 :
96 5 : std::shared_ptr<SafeFile> safeFile;
97 :
98 5 : auto it = get(path);
99 5 : if (it != end()) {
100 1 : safeFile = it->second;
101 : }
102 : else {
103 4 : std::ios_base::openmode mode = std::ofstream::out | std::ios_base::app; // for text files
104 4 : if (!textOrBinary) mode |= std::ios::binary;
105 :
106 4 : safeFile = std::make_shared<SafeFile>(this, path, io_context_, mode);
107 4 : add(path, safeFile);
108 : }
109 :
110 5 : safeFile->write(data, closeDelayUs);
111 5 : }
112 :
113 12 : bool FileManager::read(const std::string &path, std::string &data, bool textOrBinary) {
114 :
115 : bool result;
116 :
117 12 : std::shared_ptr<SafeFile> safeFile;
118 12 : std::ios_base::openmode mode = std::ifstream::in; // for text files
119 :
120 12 : auto it = get(path);
121 12 : if (it != end()) {
122 7 : safeFile = it->second;
123 : }
124 : else {
125 5 : if (!textOrBinary) mode |= std::ios::binary;
126 :
127 5 : safeFile = std::make_shared<SafeFile>(this, path, io_context_, mode);
128 5 : add(path, safeFile);
129 : }
130 :
131 12 : data = safeFile->read(result, mode, read_cache_);
132 :
133 12 : return result;
134 12 : }
135 :
136 5 : void FileManager::empty(const std::string &path) {
137 :
138 5 : std::shared_ptr<SafeFile> safeFile;
139 :
140 5 : auto it = get(path);
141 5 : if (it != end()) {
142 4 : safeFile = it->second;
143 : }
144 : else {
145 1 : safeFile = std::make_shared<SafeFile>(this, path, io_context_);
146 1 : add(path, safeFile);
147 : }
148 :
149 5 : safeFile->empty();
150 5 : }
151 :
152 1 : bool FileManager::clear()
153 : {
154 1 : bool result = (map_.size() > 0); // something deleted
155 :
156 1 : map_.clear(); // shared_ptr dereferenced too
157 :
158 1 : return result;
159 : }
160 :
161 4 : nlohmann::json FileManager::getConfigurationJson() const {
162 :
163 4 : nlohmann::json result;
164 4 : result["readCache"] = read_cache_ ? "enabled":"disabled";
165 :
166 4 : return result;
167 : } // LCOV_EXCL_LINE
168 :
169 2 : std::string FileManager::configurationAsJsonString() const {
170 :
171 2 : return (getConfigurationJson().dump());
172 : }
173 :
174 2 : nlohmann::json FileManager::getJson() const {
175 :
176 2 : nlohmann::json result;
177 :
178 2 : read_guard_t guard(rw_mutex_);
179 :
180 4 : for (auto it = begin(); it != end(); it++) {
181 2 : result.push_back(it->second->getJson());
182 : };
183 :
184 4 : return result;
185 2 : }
186 :
187 1 : std::string FileManager::asJsonString() const {
188 :
189 3 : return ((size() != 0) ? getJson().dump() : "[]");
190 : }
191 :
192 :
193 : }
194 : }
195 :
|
