Goby3 3.3.0
2025.07.10
Loading...
Searching...
No Matches
interface.h
Go to the documentation of this file.
1// Copyright 2011-2025:
2// GobySoft, LLC (2013-)
3// Massachusetts Institute of Technology (2007-2014)
4// Community contributors (see AUTHORS file)
5// File authors:
6// Toby Schneider <toby@gobysoft.org>
7//
8//
9// This file is part of the Goby Underwater Autonomy Project Libraries
10// ("The Goby Libraries").
11//
12// The Goby Libraries are free software: you can redistribute them and/or modify
13// them under the terms of the GNU Lesser General Public License as published by
14// the Free Software Foundation, either version 2.1 of the License, or
15// (at your option) any later version.
16//
17// The Goby Libraries are distributed in the hope that they will be useful,
18// but WITHOUT ANY WARRANTY; without even the implied warranty of
19// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20// GNU Lesser General Public License for more details.
21//
22// You should have received a copy of the GNU Lesser General Public License
23// along with Goby. If not, see <http://www.gnu.org/licenses/>.
24
25#ifndef GOBY_MIDDLEWARE_APPLICATION_INTERFACE_H
26#define GOBY_MIDDLEWARE_APPLICATION_INTERFACE_H
27
28#include <chrono>
29#include <csignal>
30#include <iostream>
31#include <sys/types.h>
32#include <unistd.h>
33
34#include <boost/format.hpp>
35
36#include "goby/exception.h"
40#include "goby/time.h"
42#include "goby/util/geodesy.h"
43
44namespace goby
45{
52template <typename App>
54
61template <typename App,
62 typename Configurator = middleware::ProtobufConfigurator<typename App::ConfigType>>
63int run(int argc, char* argv[])
64{
65 return run<App>(Configurator(argc, argv));
66}
67
68namespace middleware
69{
70
71namespace julia
72{
73template <typename App> class ApplicationWrapper;
74}
75
77template <typename Config> class Application
78{
79 public:
81 virtual ~Application()
82 {
83 goby::glog.is_debug2() && goby::glog << "Application: destructing cleanly" << std::endl;
84 }
85
86 using ConfigType = Config;
87
88 protected:
90 virtual void pre_initialize(){};
91
93 virtual void initialize(){};
94
96 virtual void post_initialize(){};
97
99 virtual void run() = 0;
100
102 virtual void pre_finalize(){};
103
105 virtual void finalize(){};
106
108 virtual void post_finalize(){};
109
113 void quit(int return_value = 0)
114 {
115 alive_ = false;
116 return_value_ = return_value;
117 }
118
120 const Config& app_cfg() { return *app_cfg_; }
121
124 {
125 if (geodesy_)
126 return *geodesy_;
127 else
128 throw(goby::Exception("No lat_origin and lon_origin defined for requested UTMGeodesy"));
129 }
130
132 bool has_geodesy() { return geodesy_ ? true : false; }
133
134 std::string app_name() { return app3_base_configuration_->name(); }
135
136 bool app_alive() { return alive_; }
137
138 boost::units::quantity<boost::units::si::frequency>
139 choose_loop_freq(boost::units::quantity<boost::units::si::frequency> compiled_loop_freq)
140 {
141 if (app3_base_configuration_->has_loop_frequency())
142 return app3_base_configuration_->loop_frequency_with_units();
143 else
144 return compiled_loop_freq;
145 }
146
147 protected:
149
150 private:
151 template <typename App>
152 friend int ::goby::run(
154
155 template <typename App> friend class goby::middleware::julia::ApplicationWrapper;
156
157 // main loop that exits on quit(); returns the desired return value
158 int __run();
159
160 void run_one() { run(); }
161
162 void configure_logger();
163 void configure_glog_file();
164 void check_rotate_glog_file();
165
166 private:
167 // sets configuration (before Application construction)
168 static std::unique_ptr<Config> app_cfg_;
169 static std::unique_ptr<protobuf::AppConfig> app3_base_configuration_;
170
171 bool alive_;
172 int return_value_;
173
174 // static here allows fout_ to live until program exit to log glog output
175 static std::unique_ptr<std::ofstream> fout_;
176
177 goby::time::SteadyClock::time_point next_log_rotate_time_;
178
179 std::unique_ptr<goby::util::UTMGeodesy> geodesy_;
180};
181} // namespace middleware
182
183} // namespace goby
184
185template <typename Config>
186std::unique_ptr<std::ofstream> goby::middleware::Application<Config>::fout_;
187
188template <typename Config> std::unique_ptr<Config> goby::middleware::Application<Config>::app_cfg_;
189
190template <typename Config>
191std::unique_ptr<goby::middleware::protobuf::AppConfig>
193
194template <typename Config> goby::middleware::Application<Config>::Application() : alive_(true)
195{
196 using goby::glog;
197
198 configure_logger();
199 if (app3_base_configuration_->has_geodesy())
200 configure_geodesy({app3_base_configuration_->geodesy().lat_origin_with_units(),
201 app3_base_configuration_->geodesy().lon_origin_with_units()});
202
203 if (!app3_base_configuration_->IsInitialized())
204 throw(middleware::ConfigException("Invalid base configuration"));
205
206 glog.is_debug2() && glog << "Application: constructed with PID: " << getpid() << std::endl;
207 glog.is_debug1() && glog << "App name is " << app3_base_configuration_->name() << std::endl;
208 glog.is_debug2() && glog << "Configuration is: " << app_cfg_->DebugString() << std::endl;
209}
210
211template <typename Config> void goby::middleware::Application<Config>::configure_logger()
212{
213 using goby::glog;
214
215 // set up the logger
216 glog.set_name(app3_base_configuration_->name());
218 app3_base_configuration_->glog_config().tty_verbosity()),
219 &std::cout);
220
221 if (app3_base_configuration_->glog_config().show_gui())
223
224 if (app3_base_configuration_->glog_config().has_file_log())
225 configure_glog_file();
226
227 if (app3_base_configuration_->glog_config().show_dccl_log())
229}
230
232{
233 using goby::glog;
234 if (app3_base_configuration_->glog_config().has_file_log() &&
235 app3_base_configuration_->glog_config().file_log().has_log_rotate_sec() &&
236 goby::time::SteadyClock::now() > next_log_rotate_time_)
237 {
238 glog.remove_stream(fout_.get());
239 configure_glog_file();
240 }
241}
242
244{
245 const auto& file_log = app3_base_configuration_->glog_config().file_log();
246 std::string file_format_str;
247
248 std::string file_name_format = file_log.file_name();
249
250 if (!file_log.has_file_name() && file_log.omit().file_timestamp())
251 file_name_format = "%2%.txt";
252
253 if (file_log.has_file_dir() && !file_log.file_dir().empty())
254 {
255 auto file_dir = file_log.file_dir();
256 if (file_dir.back() != '/')
257 file_dir += "/";
258 file_format_str = file_dir + file_name_format;
259 }
260 else
261 {
262 file_format_str = file_name_format;
263 }
264
265 boost::format file_format(file_format_str);
266
267 if (!file_log.omit().file_timestamp())
268 {
269 if (file_format_str.find("%1") == std::string::npos)
270 glog.is_die() &&
271 glog << "file_name string must contain \"%1%\" which is expanded to the current "
272 "application start time (e.g. 20190201T184925), unless omit.file_timestamp "
273 "== true. Erroneous file_name is: "
274 << file_format_str << std::endl;
275 }
276
277 file_format.exceptions(boost::io::all_error_bits ^
278 (boost::io::too_many_args_bit | boost::io::too_few_args_bit));
279
280 std::string file_name =
281 (file_format % goby::time::file_str() % app3_base_configuration_->name()).str();
282 glog.is_verbose() && glog << "logging output to file: " << file_name << std::endl;
283
284 fout_.reset(new std::ofstream(file_name.c_str()));
285
286 if (!fout_->is_open())
287 glog.is_die() && glog << "cannot write glog output to requested file: " << file_name
288 << std::endl;
289
290 if (!file_log.omit().latest_symlink())
291 {
292 std::string file_symlink =
293 (file_format % "latest" % app3_base_configuration_->name()).str();
294 remove(file_symlink.c_str());
295 int result = symlink(realpath(file_name.c_str(), NULL), file_symlink.c_str());
296 if (result != 0)
297 glog.is_warn() &&
298 glog << "Cannot create symlink to latest file. Continuing onwards anyway"
299 << std::endl;
300 }
301
302 glog.add_stream(file_log.verbosity(), fout_.get());
303
304 if (file_log.has_log_rotate_sec())
305 next_log_rotate_time_ =
306 goby::time::SteadyClock::now() + std::chrono::seconds(file_log.log_rotate_sec());
307}
308
309template <typename Config>
315
316template <typename Config> int goby::middleware::Application<Config>::__run()
317{
318 // block SIGWINCH (change window size) in all threads
319 sigset_t signal_mask;
320 sigemptyset(&signal_mask);
321 sigaddset(&signal_mask, SIGWINCH);
322 pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
323
324 this->pre_initialize();
325 this->initialize();
326 this->post_initialize();
327 // continue to run while we are alive (quit() has not been called)
328 while (alive_)
329 {
330 this->run_one();
331 this->check_rotate_glog_file();
332 }
333 this->pre_finalize();
334 this->finalize();
335 this->post_finalize();
336 return return_value_;
337}
338
339template <typename App>
341{
342 int return_value = 0;
343 try
344 {
345 try
346 {
347 cfgtor.validate();
348 }
350 {
351 cfgtor.handle_config_error(e);
352 return 1;
353 }
354
355 // simply print the configuration and exit
356 if (cfgtor.app_configuration().debug_cfg())
357 {
358 std::cout << cfgtor.str() << std::endl;
359 exit(EXIT_SUCCESS);
360 }
361
362 // set configuration
363 App::app_cfg_.reset(new typename App::ConfigType(cfgtor.cfg()));
364 App::app3_base_configuration_.reset(
366
367 // set up simulation time
368 if (App::app3_base_configuration_->simulation().time().use_sim_time())
369 {
372 App::app3_base_configuration_->simulation().time().warp_factor();
373 if (App::app3_base_configuration_->simulation().time().has_reference_microtime())
375 std::chrono::system_clock::time_point(std::chrono::microseconds(
376 App::app3_base_configuration_->simulation().time().reference_microtime()));
377 }
378
379 // instantiate the application (with the configuration already set)
380 App app;
381 return_value = app.__run();
382 }
383 catch (std::exception& e)
384 {
385 // some other exception
386 std::cerr << "Application:: uncaught exception: " << e.what() << std::endl;
387 throw;
388 }
389
390 goby::glog.is_debug2() && goby::glog << "goby::run: exiting cleanly with code: " << return_value
391 << std::endl;
392 return return_value;
393}
394
395#endif
simple exception class for goby applications
Definition exception.h:35
Base class for Goby applications. Generally you will want to use SingleThreadApplication or MultiThre...
Definition interface.h:78
const util::UTMGeodesy & geodesy()
Accesses the geodetic conversion tool if lat_origin and lon_origin were provided.
Definition interface.h:123
virtual void pre_finalize()
Called just before finalize.
Definition interface.h:102
virtual void post_initialize()
Called just after initialize.
Definition interface.h:96
virtual void initialize()
Perform any initialize tasks that couldn't be done in the constructor.
Definition interface.h:93
virtual void pre_initialize()
Called just before initialize.
Definition interface.h:90
virtual void run()=0
Runs once.
bool has_geodesy()
Returns if the geodesy tool is configured with a datum.
Definition interface.h:132
virtual void finalize()
Perform any final cleanup actions just before the destructor is called.
Definition interface.h:105
void quit(int return_value=0)
Requests a clean exit.
Definition interface.h:113
void configure_geodesy(goby::util::UTMGeodesy::LatLonPoint datum)
Definition interface.h:310
boost::units::quantity< boost::units::si::frequency > choose_loop_freq(boost::units::quantity< boost::units::si::frequency > compiled_loop_freq)
Definition interface.h:139
virtual void post_finalize()
Called just after finalize.
Definition interface.h:108
const Config & app_cfg()
Accesses configuration object passed at launch.
Definition interface.h:120
indicates a problem with the runtime command line or .cfg file configuration (or –help was given)
Defines the interface to a "configurator", a class that can read command line parameters (argc,...
virtual void validate() const
Override to validate the configuration.
virtual void handle_config_error(middleware::ConfigException &e) const
Override to customize how ConfigException errors are handled.
virtual const protobuf::AppConfig & app_configuration() const
Subset of the configuration used to configure the Application itself.
const Config & cfg() const
The configuration object produced from the command line parameters.
virtual std::string str() const =0
Override to output the configuration object as a string.
void remove_stream(std::ostream *os=nullptr)
void set_name(const std::string &s)
Set the name of the application that the logger is serving.
void add_stream(logger::Verbosity verbosity=logger::VERBOSE, std::ostream *os=nullptr)
Attach a stream object (e.g. std::cout, std::ofstream, ...) to the logger with desired verbosity.
std::string str(TimeType value=SystemClock::now< TimeType >())
Returns the provided time (or current time if omitted) as a human-readable string.
Definition convert.h:187
std::string file_str(TimeType value=SystemClock::now< TimeType >())
Returns the provided time (or current time if omitted) as an ISO string suitable for file names (no s...
Definition convert.h:200
The global namespace for the Goby project.
util::FlexOstream glog
Access the Goby logger through this object.
int run(const goby::middleware::ConfiguratorInterface< typename App::ConfigType > &cfgtor)
Run a Goby application using the provided Configurator.
Definition interface.h:340
static void setup_dlog()
Enable dlog output to glog using same verbosity settings as glog.
static bool using_sim_time
Enables simulation time if true (if false, none of the remaining parameters are used)
Definition simulation.h:38
static std::chrono::system_clock::time_point reference_time
Reference time when calculating SystemClock::now(). If this is unset, the default is 1 January of the...
Definition simulation.h:42
static int warp_factor
Warp factor to speed up (or slow time) the time values returned by SteadyClock::now() and SystemClock...
Definition simulation.h:40
std::chrono::time_point< SteadyClock > time_point
static time_point now() noexcept
Returns the current steady time unless SimulatorSettings::using_sim_time == true in which case a simu...