blob: 2e06627a93d56231c485dbf8d5081115ef24d7f0 [file] [log] [blame]
Matt Spinler09d64002019-09-11 14:29:46 -05001#include "extensions/openpower-pels/data_interface.hpp"
Matt Spinlerf60ac272019-12-11 13:47:50 -06002#include "extensions/openpower-pels/host_interface.hpp"
Matt Spinlerd96fa602022-12-15 11:11:26 -06003#include "extensions/openpower-pels/journal.hpp"
Matt Spinlerf60ac272019-12-11 13:47:50 -06004
5#include <fcntl.h>
6
Matt Spinlerf60ac272019-12-11 13:47:50 -06007#include <sdeventplus/source/io.hpp>
Matt Spinler09d64002019-09-11 14:29:46 -05008
Patrick Williams2544b412022-10-04 08:41:06 -05009#include <filesystem>
10
Matt Spinler09d64002019-09-11 14:29:46 -050011#include <gmock/gmock.h>
12
13namespace openpower
14{
15namespace pels
16{
17
18class MockDataInterface : public DataInterfaceBase
19{
20 public:
Matt Spinler784b02e2023-04-25 11:07:55 -050021 MockDataInterface()
22 {
23 ON_CALL(*this, checkDumpStatus)
24 .WillByDefault(
25 ::testing::Return(std::vector<bool>({false, false, false})));
26 }
27
Matt Spinlerf60ac272019-12-11 13:47:50 -060028 MOCK_METHOD(std::string, getMachineTypeModel, (), (const override));
29 MOCK_METHOD(std::string, getMachineSerialNumber, (), (const override));
30 MOCK_METHOD(std::string, getServerFWVersion, (), (const override));
31 MOCK_METHOD(std::string, getBMCFWVersion, (), (const override));
Matt Spinler677381b2020-01-23 10:04:29 -060032 MOCK_METHOD(std::string, getBMCFWVersionID, (), (const override));
Matt Spinler24a85582020-01-27 16:40:21 -060033 MOCK_METHOD(bool, getHostPELEnablement, (), (const override));
Matt Spinler4aa23a12020-02-03 15:05:09 -060034 MOCK_METHOD(std::string, getBMCState, (), (const override));
35 MOCK_METHOD(std::string, getChassisState, (), (const override));
36 MOCK_METHOD(std::string, getHostState, (), (const override));
Matt Spinler075e5ba2020-02-21 15:46:00 -060037 MOCK_METHOD(std::string, getMotherboardCCIN, (), (const override));
Matt Spinler60c4e792020-03-13 13:45:36 -050038 MOCK_METHOD(void, getHWCalloutFields,
Matt Spinler9b90e2a2020-04-14 10:59:04 -050039 (const std::string&, std::string&, std::string&, std::string&),
Matt Spinler60c4e792020-03-13 13:45:36 -050040 (const override));
Matt Spinler9b90e2a2020-04-14 10:59:04 -050041 MOCK_METHOD(std::string, getLocationCode, (const std::string&),
42 (const override));
Matt Spinler1ab66962020-10-29 13:21:44 -050043 MOCK_METHOD(std::vector<std::string>, getSystemNames, (), (const override));
Matt Spinler5fb24c12020-06-04 11:21:33 -050044 MOCK_METHOD(std::string, expandLocationCode, (const std::string&, uint16_t),
45 (const override));
Matt Spinlerbad056b2023-01-25 14:16:57 -060046 MOCK_METHOD(std::vector<std::string>, getInventoryFromLocCode,
Matt Spinler2f9225a2020-08-05 12:58:49 -050047 (const std::string&, uint16_t, bool), (const override));
Matt Spinler34a904c2020-08-05 14:53:28 -050048 MOCK_METHOD(void, assertLEDGroup, (const std::string&, bool),
49 (const override));
Matt Spinler993168d2021-04-07 16:05:03 -050050 MOCK_METHOD(void, setFunctional, (const std::string&, bool),
51 (const override));
Ben Tynere32b7e72021-05-18 12:38:40 -050052 MOCK_METHOD(std::vector<uint8_t>, getSystemIMKeyword, (), (const override));
Sumit Kumar3b8ed7f2021-05-18 12:38:35 -050053 MOCK_METHOD(bool, getQuiesceOnError, (), (const override));
Sumit Kumar76198a22021-07-15 05:59:57 -050054 MOCK_METHOD(void, setCriticalAssociation, (const std::string&),
55 (const override));
Sumit Kumar9d43a722021-08-24 09:46:19 -050056 MOCK_METHOD(std::vector<bool>, checkDumpStatus,
57 (const std::vector<std::string>&), (const override));
Sumit Kumar2c36fdd2021-09-21 03:12:11 -050058 MOCK_METHOD(std::string, getBootState, (), (const override));
Jayanth Othayothecaa2fc2021-11-05 02:02:52 -050059 MOCK_METHOD(void, createGuardRecord,
60 (const std::vector<uint8_t>&, const std::string&,
61 const std::string&),
62 (const override));
Sumit Kumar3e274432021-09-14 06:37:56 -050063 MOCK_METHOD(void, createProgressSRC,
64 (const uint64_t&, const std::vector<uint8_t>&),
65 (const override));
Sumit Kumar027bf282022-01-24 11:25:19 -060066 MOCK_METHOD(std::vector<uint32_t>, getLogIDWithHwIsolation, (),
67 (const override));
Vijay Lobo875b6c72021-10-20 17:38:56 -050068 MOCK_METHOD(std::vector<uint8_t>, getRawProgressSRC, (), (const override));
Matt Spinler34a904c2020-08-05 14:53:28 -050069
Matt Spinlerf60ac272019-12-11 13:47:50 -060070 void changeHostState(bool newState)
71 {
Matt Spinler4aa23a12020-02-03 15:05:09 -060072 setHostUp(newState);
Matt Spinlerf60ac272019-12-11 13:47:50 -060073 }
74
75 void setHMCManaged(bool managed)
76 {
77 _hmcManaged = managed;
78 }
Matt Spinler0dd22c82023-05-04 15:28:12 -050079
80 void fruPresent(const std::string& locationCode)
81 {
82 setFruPresent(locationCode);
83 }
Matt Spinlerf60ac272019-12-11 13:47:50 -060084};
85
86/**
87 * @brief The mock HostInterface class
Matt Spinler5342d9a2019-12-12 11:03:39 -060088 *
89 * This replaces the PLDM calls with a FIFO for the asynchronous
90 * responses.
Matt Spinlerf60ac272019-12-11 13:47:50 -060091 */
92class MockHostInterface : public HostInterface
93{
94 public:
Matt Spinler5342d9a2019-12-12 11:03:39 -060095 /**
96 * @brief Constructor
97 *
98 * @param[in] event - The sd_event object
99 * @param[in] dataIface - The DataInterface class
100 */
Matt Spinlerf60ac272019-12-11 13:47:50 -0600101 MockHostInterface(sd_event* event, DataInterfaceBase& dataIface) :
102 HostInterface(event, dataIface)
103 {
Matt Spinler5342d9a2019-12-12 11:03:39 -0600104 char templ[] = "/tmp/cmdfifoXXXXXX";
105 std::filesystem::path dir = mkdtemp(templ);
106 _fifo = dir / "fifo";
Matt Spinlerf60ac272019-12-11 13:47:50 -0600107 }
108
Matt Spinler5342d9a2019-12-12 11:03:39 -0600109 /**
110 * @brief Destructor
111 */
Matt Spinlerf60ac272019-12-11 13:47:50 -0600112 virtual ~MockHostInterface()
113 {
Matt Spinler5342d9a2019-12-12 11:03:39 -0600114 std::filesystem::remove_all(_fifo.parent_path());
Matt Spinlerf60ac272019-12-11 13:47:50 -0600115 }
116
117 MOCK_METHOD(CmdStatus, sendNewLogCmd, (uint32_t, uint32_t), (override));
118
Matt Spinler5342d9a2019-12-12 11:03:39 -0600119 /**
120 * @brief Cancels waiting for a command response
121 */
122 virtual void cancelCmd() override
123 {
124 _inProgress = false;
125 _source = nullptr;
126 }
127
128 /**
129 * @brief Returns the amount of time to wait before retrying after
130 * a failed send command.
131 *
132 * @return milliseconds - The amount of time to wait
133 */
134 virtual std::chrono::milliseconds getSendRetryDelay() const override
135 {
136 return std::chrono::milliseconds(2);
137 }
138
139 /**
140 * @brief Returns the amount of time to wait before retrying after
141 * a command receive.
142 *
143 * @return milliseconds - The amount of time to wait
144 */
145 virtual std::chrono::milliseconds getReceiveRetryDelay() const override
146 {
147 return std::chrono::milliseconds(2);
148 }
149
150 /**
Matt Spinler41293cb2019-12-12 13:11:09 -0600151 * @brief Returns the amount of time to wait before retrying if the
152 * host firmware's PEL storage was full and it can't store
153 * any more logs until it is freed up somehow.
154 *
155 * @return milliseconds - The amount of time to wait
156 */
157 virtual std::chrono::milliseconds getHostFullRetryDelay() const override
158 {
Matt Spinler6aae6a02020-02-07 12:46:07 -0600159 return std::chrono::milliseconds(400);
Matt Spinler41293cb2019-12-12 13:11:09 -0600160 }
161
162 /**
Matt Spinlere5f75082022-01-24 16:09:51 -0600163 * @brief Returns the amount of time to wait after the host is up
164 * before sending commands.
165 *
166 * @return milliseconds - The amount of time to wait
167 */
168 virtual std::chrono::milliseconds getHostUpDelay() const override
169 {
170 return std::chrono::milliseconds(0);
171 }
172
173 /**
Matt Spinler5342d9a2019-12-12 11:03:39 -0600174 * @brief Returns the number of commands processed
175 */
176 size_t numCmdsProcessed() const
177 {
178 return _cmdsProcessed;
179 }
180
181 /**
182 * @brief Writes the data passed in to the FIFO
183 *
184 * @param[in] hostResponse - use a 0 to indicate success
185 *
186 * @return CmdStatus - success or failure
187 */
188 CmdStatus send(uint8_t hostResponse)
189 {
190 // Create a FIFO once.
191 if (!std::filesystem::exists(_fifo))
192 {
193 if (mkfifo(_fifo.c_str(), 0622))
194 {
195 ADD_FAILURE() << "Failed mkfifo " << _fifo << strerror(errno);
196 exit(-1);
197 }
198 }
199
200 // Open it and register the reponse callback to
201 // be used on FD activity.
202 int fd = open(_fifo.c_str(), O_NONBLOCK | O_RDWR);
203 EXPECT_TRUE(fd >= 0) << "Unable to open FIFO";
204
Patrick Williams5fb575a2023-10-20 11:18:21 -0500205 auto callback = [this](sdeventplus::source::IO& source, int fd,
206 uint32_t events) {
Lakshmi Yadlapati0387a742024-07-01 17:04:37 -0500207 this->receive(source, fd, events, nullptr);
Matt Spinler5342d9a2019-12-12 11:03:39 -0600208 };
209
210 try
211 {
212 _source = std::make_unique<sdeventplus::source::IO>(
213 _event, fd, EPOLLIN,
214 std::bind(callback, std::placeholders::_1,
215 std::placeholders::_2, std::placeholders::_3));
216 }
Patrick Williams66491c62021-10-06 12:23:37 -0500217 catch (const std::exception& e)
Matt Spinler5342d9a2019-12-12 11:03:39 -0600218 {
219 ADD_FAILURE() << "Event exception: " << e.what();
220 close(fd);
221 return CmdStatus::failure;
222 }
223
224 // Write the fake host reponse to the FIFO
225 auto bytesWritten = write(fd, &hostResponse, sizeof(hostResponse));
226 EXPECT_EQ(bytesWritten, sizeof(hostResponse));
227
228 _inProgress = true;
229
230 return CmdStatus::success;
231 }
232
Matt Spinlerf60ac272019-12-11 13:47:50 -0600233 protected:
Matt Spinler5342d9a2019-12-12 11:03:39 -0600234 /**
235 * @brief Reads the data written to the fifo and then calls
236 * the subscriber's callback.
237 *
238 * Nonzero data indicates a command failure (for testing bad path).
239 *
240 * @param[in] source - The event source object
241 * @param[in] fd - The file descriptor used
242 * @param[in] events - The event bits
243 */
Patrick Williamsd26fa3e2021-04-21 15:22:23 -0500244 void receive(sdeventplus::source::IO& /*source*/, int /*fd*/,
Lakshmi Yadlapati0387a742024-07-01 17:04:37 -0500245 uint32_t events, pldm_transport* /*transport*/) override
Matt Spinlerf60ac272019-12-11 13:47:50 -0600246 {
Matt Spinler5342d9a2019-12-12 11:03:39 -0600247 if (!(events & EPOLLIN))
248 {
249 return;
250 }
251
252 _inProgress = false;
253
254 int newFD = open(_fifo.c_str(), O_NONBLOCK | O_RDONLY);
255 ASSERT_TRUE(newFD >= 0) << "Failed to open FIFO";
256
257 // Read the host success/failure response from the FIFO.
258 uint8_t data;
259 auto bytesRead = read(newFD, &data, sizeof(data));
260 EXPECT_EQ(bytesRead, sizeof(data));
261
262 close(newFD);
263
264 ResponseStatus status = ResponseStatus::success;
265 if (data != 0)
266 {
267 status = ResponseStatus::failure;
268 }
269
Matt Spinlera44efe42020-03-03 10:30:16 -0600270 callResponseFunc(status);
Matt Spinler5342d9a2019-12-12 11:03:39 -0600271
Matt Spinlerf60ac272019-12-11 13:47:50 -0600272 // Keep account of the number of commands responses for testing.
273 _cmdsProcessed++;
274 }
275
276 private:
Matt Spinler5342d9a2019-12-12 11:03:39 -0600277 /**
278 * @brief The event source for the fifo
279 */
280 std::unique_ptr<sdeventplus::source::IO> _source;
281
282 /**
283 * @brief the path to the fifo
284 */
285 std::filesystem::path _fifo;
286
287 /**
288 * @brief The number of commands processed
289 */
Matt Spinlerf60ac272019-12-11 13:47:50 -0600290 size_t _cmdsProcessed = 0;
Matt Spinler09d64002019-09-11 14:29:46 -0500291};
292
Matt Spinlerd96fa602022-12-15 11:11:26 -0600293class MockJournal : public JournalBase
294{
295 public:
296 MockJournal() {}
297
298 MOCK_METHOD(std::vector<std::string>, getMessages,
299 (const std::string&, size_t), (const override));
Matt Spinler9d921092022-12-15 11:54:49 -0600300
301 MOCK_METHOD(void, sync, (), (const override));
Matt Spinlerd96fa602022-12-15 11:11:26 -0600302};
303
Matt Spinler09d64002019-09-11 14:29:46 -0500304} // namespace pels
305} // namespace openpower