SNode.C
Loading...
Searching...
No Matches
SocketContext.cpp
Go to the documentation of this file.
1/*
2 * SNode.C - A Slim Toolkit for Network Communication
3 * Copyright (C) Volker Christian <me@vchrist.at>
4 * 2020, 2021, 2022, 2023, 2024, 2025
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20/*
21 * MIT License
22 *
23 * Permission is hereby granted, free of charge, to any person obtaining a copy
24 * of this software and associated documentation files (the "Software"), to deal
25 * in the Software without restriction, including without limitation the rights
26 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
27 * copies of the Software, and to permit persons to whom the Software is
28 * furnished to do so, subject to the following conditions:
29 *
30 * The above copyright notice and this permission notice shall be included in
31 * all copies or substantial portions of the Software.
32 *
33 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
34 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
35 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
36 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
37 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
38 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
39 * THE SOFTWARE.
40 */
41
42#include "core/socket/stream/SocketContext.h"
43
44#include "core/socket/stream/SocketConnection.h"
45
46#ifndef DOXYGEN_SHOULD_SKIP_THIS
47
48#include "log/Logger.h"
49
50#include <cerrno>
51#include <ctime>
52#include <iomanip>
53#include <sstream>
54struct tm;
55
56#endif /* DOXYGEN_SHOULD_SKIP_THIS */
57
58namespace core::socket::stream {
59
61 : socketConnection(socketConnection)
62 , onlineSinceTimePoint(std::chrono::system_clock::now()) {
63 }
64
66 // delete newSocketContext;
67 }
68
70 LOG(DEBUG) << socketConnection->getConnectionName() << " SocketContext: switch";
71 this->newSocketContext = newSocketContext;
72 }
73
75 return socketConnection;
76 }
77
78 void SocketContext::sendToPeer(const char* chunk, std::size_t chunkLen) const {
80 }
81
82 bool SocketContext::streamToPeer(pipe::Source* source) const {
84 }
85
88 }
89
90 void SocketContext::readFromPeer(std::size_t available) {
91 const std::size_t consumed = onReceivedFromPeer();
92
93 if (available != 0 && consumed == 0) {
94 LOG(TRACE) << socketConnection->getConnectionName() << ": Data available: " << available << " but nothing read";
95
96 close();
97
98 delete newSocketContext; // delete of nullptr is valid since C++14!
99 newSocketContext = nullptr;
100 } else if (newSocketContext != nullptr) { // Perform a pending SocketContextSwitch
101 SocketConnection* socketConnection = this->socketConnection;
102 SocketContext* newSocketContext = this->newSocketContext;
103 detach();
104
105 socketConnection->setSocketContext(newSocketContext);
106 }
107 }
108
109 std::size_t SocketContext::readFromPeer(char* chunk, std::size_t chunklen) const {
110 std::size_t ret = 0;
111
112 if (newSocketContext == nullptr) {
113 ret = socketConnection->readFromPeer(chunk, chunklen);
114 } else {
116 << " ReadFromPeer: New SocketContext != nullptr: SocketContextSwitch still in progress";
117 }
118
119 return ret;
120 }
121
122 void SocketContext::setTimeout(const utils::Timeval& timeout) {
124 }
125
128 }
129
130 std::size_t SocketContext::getTotalSent() const {
132 }
133
134 std::size_t SocketContext::getTotalQueued() const {
136 }
137
138 std::size_t SocketContext::getTotalRead() const {
140 }
141
142 std::size_t SocketContext::getTotalProcessed() const {
144 }
145
146 std::string SocketContext::getOnlineSince() const {
148 }
149 std::string SocketContext::getOnlineDuration() const {
151 }
152
155 }
156
157 void SocketContext::shutdownWrite(bool forceClose) {
159 }
160
161 void SocketContext::onWriteError(int errnum) {
162 errno = errnum;
163
164 PLOG(DEBUG) << socketConnection->getConnectionName() << " SocketContext: onWriteError";
166 }
167
168 void SocketContext::onReadError(int errnum) {
169 errno = errnum;
170
171 if (errno == 0) {
172 LOG(DEBUG) << socketConnection->getConnectionName() << " SocketContext: EOF received";
173 } else {
174 PLOG(DEBUG) << socketConnection->getConnectionName() << " SocketContext: onReadError";
175 }
177 }
178
182
184 }
185
188
189 LOG(DEBUG) << socketConnection->getConnectionName() << " SocketContext: detach";
190 LOG(DEBUG) << " Online Since: " << getOnlineSince();
191 LOG(DEBUG) << " Online Duration: " << getOnlineDuration();
192 LOG(DEBUG) << " Total Sent: " << getTotalQueued();
193 LOG(DEBUG) << " Total Processed: " << getTotalProcessed();
194
195 delete this;
196 }
197
198 std::string SocketContext::timePointToString(const std::chrono::time_point<std::chrono::system_clock>& timePoint) {
199 const std::time_t time = std::chrono::system_clock::to_time_t(timePoint);
200 std::tm* tm_ptr = std::gmtime(&time);
201
202 char buffer[100];
203 std::string onlineSince = "Formatting error";
204
205 // Format: "2025-02-02 14:30:00"
206 if (std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", tm_ptr) > 0) {
207 onlineSince = std::string(buffer) + " UTC";
208 }
209
210 return onlineSince;
211 }
212
213 std::string SocketContext::durationToString(const std::chrono::time_point<std::chrono::system_clock>& bevore,
214 const std::chrono::time_point<std::chrono::system_clock>& later) {
215 using seconds_duration_type = std::chrono::duration<std::chrono::seconds::rep>::rep;
216
217 const seconds_duration_type totalSeconds = std::chrono::duration_cast<std::chrono::seconds>(later - bevore).count();
218
219 // Compute days, hours, minutes, and seconds
220 const seconds_duration_type days = totalSeconds / 86400; // 86400 seconds in a day
221 seconds_duration_type remainder = totalSeconds % 86400;
222 const seconds_duration_type hours = remainder / 3600;
223 remainder = remainder % 3600;
224 const seconds_duration_type minutes = remainder / 60;
225 const seconds_duration_type seconds = remainder % 60;
226
227 // Format the components into a string using stringstream
228 std::ostringstream oss;
229 if (days > 0) {
230 oss << days << " day" << (days == 1 ? "" : "s") << ", ";
231 }
232 oss << std::setw(2) << std::setfill('0') << hours << ":" << std::setw(2) << std::setfill('0') << minutes << ":" << std::setw(2)
233 << std::setfill('0') << seconds;
234
235 return oss.str();
236 }
237
238} // namespace core::socket::stream
virtual std::size_t onReceivedFromPeer()=0
virtual void sendToPeer(const char *chunk, std::size_t chunkLen)=0
virtual void setTimeout(const utils::Timeval &timeout)=0
const std::string & getConnectionName() const
void setSocketContext(SocketContext *socketContext)
virtual std::size_t getTotalRead() const =0
virtual std::size_t getTotalQueued() const =0
virtual void shutdownWrite(bool forceClose)=0
virtual std::size_t readFromPeer(char *chunk, std::size_t chunkLen)=0
virtual std::size_t getTotalSent() const =0
virtual bool streamToPeer(core::pipe::Source *source)=0
virtual std::size_t getTotalProcessed() const =0
std::string getOnlineSince() const override
SocketConnection * getSocketConnection() const
virtual void switchSocketContext(SocketContext *newSocketContext)
std::size_t getTotalProcessed() const override
SocketContext(core::socket::stream::SocketConnection *socketConnection)
static std::string timePointToString(const std::chrono::time_point< std::chrono::system_clock > &timePoint)
std::size_t readFromPeer(char *chunk, std::size_t chunklen) const final
void onReadError(int errnum) override
void sendToPeer(const char *chunk, std::size_t chunkLen) const final
static std::string durationToString(const std::chrono::time_point< std::chrono::system_clock > &bevore, const std::chrono::time_point< std::chrono::system_clock > &later=std::chrono::system_clock::now())
std::size_t getTotalSent() const override
void shutdownWrite(bool forceClose=false)
core::socket::stream::SocketContext * newSocketContext
void onWriteError(int errnum) override
std::size_t getTotalQueued() const override
bool streamToPeer(core::pipe::Source *source) const
core::socket::stream::SocketConnection * socketConnection
std::string getOnlineDuration() const override
void readFromPeer(std::size_t available)
std::chrono::time_point< std::chrono::system_clock > onlineSinceTimePoint
void setTimeout(const utils::Timeval &timeout) final
std::size_t getTotalRead() const override