rogue
Loading...
Searching...
No Matches
StreamReader.cpp
Go to the documentation of this file.
1
17#include "rogue/Directives.h"
18
20
21#include <fcntl.h>
22#include <inttypes.h>
23#include <stdint.h>
24#include <unistd.h>
25
26#include <memory>
27#include <string>
28#include <thread>
29
30#include "rogue/GeneralError.h"
31#include "rogue/GilRelease.h"
32#include "rogue/Logging.h"
36
39
40#ifndef NO_PYTHON
41 #include <boost/python.hpp>
42namespace bp = boost::python;
43#endif
44
46ruf::StreamReaderPtr ruf::StreamReader::create() {
47 ruf::StreamReaderPtr s = std::make_shared<ruf::StreamReader>();
48 return (s);
49}
50
52void ruf::StreamReader::setup_python() {
53#ifndef NO_PYTHON
54 bp::class_<ruf::StreamReader, ruf::StreamReaderPtr, bp::bases<ris::Master>, boost::noncopyable>("StreamReader",
55 bp::init<>())
56 .def("open", &ruf::StreamReader::open)
57 .def("close", &ruf::StreamReader::close)
58 .def("isOpen", &ruf::StreamReader::isOpen)
59 .def("closeWait", &ruf::StreamReader::closeWait)
60 .def("isActive", &ruf::StreamReader::isActive);
61#endif
62}
63
65ruf::StreamReader::StreamReader() {
66 // Members default-init in header; dtor is safe before open().
67}
68
70ruf::StreamReader::~StreamReader() {
71 close();
72}
73
75void ruf::StreamReader::open(std::string file) {
77 std::unique_lock<std::mutex> lock(mtx_);
78 intClose(lock);
79
80 // Determine if we read a group of files
81 if (file.substr(file.find_last_of('.')) == ".1") {
82 fdIdx_ = 1;
83 baseName_ = file.substr(0, file.find_last_of('.'));
84 } else {
85 fdIdx_ = 0;
86 baseName_ = file;
87 }
88
89 if ((fd_ = ::open(file.c_str(), O_RDONLY)) < 0)
90 throw(rogue::GeneralError::create("StreamReader::open", "Failed to open data file: %s", file.c_str()));
91
92 active_ = true;
93 threadEn_ = true;
94 try {
95 readThread_ = new std::thread(&StreamReader::runThread, this);
96 } catch (...) {
97 active_ = false;
98 threadEn_ = false;
99 ::close(fd_);
100 fd_ = -1;
101 throw;
102 }
103
104 // Set a thread name
105#ifndef __MACH__
106 pthread_setname_np(readThread_->native_handle(), "StreamReader");
107#endif
108}
109
111bool ruf::StreamReader::nextFile() {
112 std::unique_lock<std::mutex> lock(mtx_);
113 std::string name;
114
115 if (fd_ >= 0) {
116 ::close(fd_);
117 fd_ = -1;
118 } else {
119 return (false);
120 }
121 if (fdIdx_ == 0) return (false);
122
123 fdIdx_++;
124 name = baseName_ + "." + std::to_string(fdIdx_);
125
126 if ((fd_ = ::open(name.c_str(), O_RDONLY)) < 0) return (false);
127 return (true);
128}
129
131void ruf::StreamReader::close() {
132 rogue::GilRelease noGil;
133 std::unique_lock<std::mutex> lock(mtx_);
134 intClose(lock);
135}
136
138bool ruf::StreamReader::isOpen() {
139 return (fd_ >= 0);
140}
141
143void ruf::StreamReader::intClose(std::unique_lock<std::mutex>& lock) {
144 std::thread* thread = readThread_;
145 readThread_ = NULL;
146 if (thread != NULL) {
147 threadEn_ = false;
148 // The read thread takes mtx_ in nextFile() and on exit, so release
149 // it for the join or close() deadlocks against an active reader.
150 lock.unlock();
151 thread->join();
152 lock.lock();
153 delete thread;
154 }
155 if (fd_ >= 0) ::close(fd_);
156}
157
159void ruf::StreamReader::closeWait() {
160 rogue::GilRelease noGil;
161 std::unique_lock<std::mutex> lock(mtx_);
162 while (active_) cond_.wait_for(lock, std::chrono::microseconds(1000));
163 intClose(lock);
164}
165
167bool ruf::StreamReader::isActive() {
168 rogue::GilRelease noGil;
169 return (active_);
170}
171
173void ruf::StreamReader::runThread() {
174 int32_t ret;
175 uint32_t size;
176 uint32_t meta;
177 uint16_t flags;
178 uint8_t error;
179 uint8_t chan;
180 uint32_t bSize;
181 bool err;
182 ris::FramePtr frame;
183 ris::Frame::BufferIterator it;
184 char* bData;
185 Logging log("streamReader");
186
187 ret = 0;
188 err = false;
189 do {
190 // Read size of each frame
191 while (threadEn_ && (fd_ >= 0) && (read(fd_, &size, 4) == 4)) {
192 if (size == 0) {
193 log.warning("Bad size read %" PRIu32, size);
194 err = true;
195 break;
196 }
197
198 // Read flags
199 if (read(fd_, &meta, 4) != 4) {
200 log.warning("Failed to read flags");
201 err = true;
202 break;
203 }
204
205 // Skip next step if frame is empty
206 if (size <= 4) continue;
207 size -= 4;
208
209 // Extract meta data
210 flags = meta & 0xFFFF;
211 error = (meta >> 16) & 0xFF;
212 chan = (meta >> 24) & 0xFF;
213
214 // Request frame
215 frame = reqFrame(size, true);
216 frame->setFlags(flags);
217 frame->setError(error);
218 frame->setChannel(chan);
219 it = frame->beginBuffer();
220
221 while ((err == false) && (size > 0)) {
222 bSize = size;
223
224 // Adjust to buffer size, if necessary
225 if (bSize > (*it)->getSize()) bSize = (*it)->getSize();
226
227 if ((ret = read(fd_, (*it)->begin(), bSize)) != bSize) {
228 log.warning("Short read. Ret = %" PRId32 " Req = %" PRIu32 " after %" PRIu32 " bytes",
229 ret,
230 bSize,
231 frame->getPayload());
232 ::close(fd_);
233 fd_ = -1;
234 frame->setError(0x1);
235 err = true;
236 } else {
237 (*it)->setPayload(bSize);
238 ++it; // Next buffer
239 }
240 size -= bSize;
241 }
242 sendFrame(frame);
243 }
244 } while (threadEn_ && (err == false) && nextFile());
245
246 std::unique_lock<std::mutex> lock(mtx_);
247 if (fd_ >= 0) ::close(fd_);
248 fd_ = -1;
249 active_ = false;
250 cond_.notify_all();
251}
static GeneralError create(std::string src, const char *fmt,...)
Creates a formatted error instance.
RAII helper that releases the Python GIL for a scope.
Definition GilRelease.h:36
Structured Rogue logging helper.
Definition Logging.h:59
std::shared_ptr< rogue::interfaces::stream::Frame > FramePtr
Shared pointer alias for Frame.
Definition Frame.h:549
std::shared_ptr< rogue::utilities::fileio::StreamReader > StreamReaderPtr