Tasks may use a bridge to communicate with an application running outside the event loop. More...
#include <bridgetask.h>
Inheritance diagram for BridgeTask:
Collaboration diagram for BridgeTask:
Public Member Functions | |
| BridgeTask (Task *agent=nullptr) | |
| Create a bridge to the given agent task. More... | |
| double | start () override |
| Will add the agent task to the EventLoop. More... | |
| void | taskFinished (Task *task) override |
| If the agent dies, a special message will be sent to notify the client. | |
| void | setAgent (Task *agent) |
| void | die () |
| Terminate the bridge task. | |
| virtual void | sendMsgToClient (const std::string &msg)=0 |
| The agent will call this to pass messages to the client. | |
| void | sendMsgToClient (const std::string &method, const std::string &jsonobj) |
| Format a message to the client. More... | |
 Public Member Functions inherited from Task | |
| Task (const std::string &task_name) | |
| Create a task with the given name. More... | |
| virtual | ~Task () |
| virtual double | timerEvent () |
| void | resetTimer (double s) |
| Run timerEvent after s seconds instead of previous value. | |
| bool | finishedOK () const |
| Return true if the task has finished normally. More... | |
| bool | wasKilled () const |
| Return true if the task is finished and was aborted by another task. More... | |
| bool | wasError () const |
| Return true if the task terminated with an error. More... | |
| bool | wasTimeout () const |
| Return true if the task terminated with a timeout. More... | |
| bool | hasStarted () const |
| void | killChildTaskWhenFinished () |
| virtual SocketConnection * | newClient (int, const char *, uint16_t, ServerSocket *) |
| virtual bool | adoptConnection (Socket *conn) |
| virtual void | connAdded (SocketConnection *) |
| virtual void | connRemoved (SocketConnection *) |
| virtual void | serverAdded (ServerSocket *) |
| virtual void | serverRemoved (ServerSocket *) |
| std::string | result () const |
| To get the "result" of the task after it has finished. | |
| std::set< Socket * > | getMyConnections () const |
| Return all current connections. | |
| bool | isActive (Socket *conn) const |
| Return true if the connection still exists. | |
| void | wakeUp () |
| Restart all idle connections. | |
| bool | wakeUpConnection (SocketConnection *s) |
| If s is idle, restart it and return true. Otherwise return false. | |
| void | cancelConnection (SocketConnection *s) |
| Terminate and remove a connection. | |
| std::string | message () const |
| Return the current (outgoing) message. | |
| bool | startObserving (Task *to) |
| void | executeHandler (Task *receiver, const std::string &message) |
| double | elapsed () const |
| Return number of seconds since the task was started. More... | |
| virtual Task * | createWorkerTask (unsigned int wno) |
| virtual void | finishWorkerTask (unsigned int) |
| virtual void | newWorkerChannel (SocketReceiver *, unsigned int) |
| virtual void | workerMessage (SocketReceiver *, const char *buf, size_t len) |
| Called if parent/worker sends a message through a SocketReceiver: | |
| virtual PollState | connectionReady (SocketConnection *) |
| virtual PollState | msgFromConnection (SocketConnection *, const std::string &) |
| uint64_t | bytesSent () const |
| Number of bytes sent through SocketConnection objects owned by me. | |
| uint64_t | bytesReceived () const |
| Number of bytes received through SocketConnection objects owned by me. | |
| void | resetByteCount () |
| Reset the values for the methods Task::bytesSent and Task::bytesReceived. | |
| void | notifyBytesSent (uint64_t n) |
| Notify the task that data has been sent on its behalf. More... | |
| void | notifyBytesReceived (uint64_t n) |
| Notify the task that data has been received on its behalf. More... | |
| Public Member Functions inherited from Logger | |
| Logger (std::string label) | |
| std::string | label () const |
| Return the object's log label. | |
| void | resetLabel (const std::string &new_label) |
| Modify the object's log label. | |
Static Public Member Functions | |
| static std::string | msgToAgent (const std::string &method, const std::string &jsonobj="{}") |
| Format a message to the agent. More... | |
| static bool | isAgentTerminatedMessage (const std::string &msg) |
| static std::string | agentTerminatedMessage (const std::string &err_msg) |
| Format a message to signal that the Agent is gone. | |
| Static Public Member Functions inherited from Logger | |
| static void | setLogFile (std::ostream &stream) |
| Set global log destination. More... | |
| static void | reopenLogFile (const std::string &filename) |
| If current log is a file (ofstream), reopen it with new filename: | |
| static void | setLogLimit (unsigned int loglines=0, unsigned int warnlines=0, unsigned int errlines=0) |
| Set max number of lines of info/warn/err log. More... | |
| static void | sayTime (std::ostream &stream) |
| Write current local time to the given stream. | |
| static bool | inError () |
| Return true if any error has been logged (globally since start) | |
| static std::ostream & | err_log (const std::string &label) |
| Write a line of error log. More... | |
| static std::ostream & | warn_log (const std::string &label) |
| Write a line of warning log. More... | |
| static std::ostream & | log (const std::string &label) |
| Write a line of info log. More... | |
| static void | flushLogFile () |
| static void | pauseLogging () |
| Disable all log output until next call to Logger::setLogFile. | |
| static double | secondsSince (const TimePoint &t) |
| static double | secondsTo (const TimePoint &t) |
| static int64_t | msSince (const TimePoint &t) |
| static int64_t | msTo (const TimePoint &t) |
| static bool | hasExpired (const TimePoint &t) |
| Return true if current time is after the given TimePoint. | |
| static TimePoint | timeNow () |
| Return current time. | |
| static TimePoint | timeAfter (double s) |
| Return current time plus s seconds. | |
| static TimePoint | timeMax () |
| Return a very distant time. | |
| static std::chrono::microseconds | toUs (double t) |
| Convert s (seconds) to std::chrono::microseconds. | |
| static std::string | dateString (time_t t=0) |
| Return local time, formatted as 2023-10-14T09:38:47+0200. | |
| static std::string | dateString2 (time_t t=0) |
| Return local time, formatted as Sat, 14 Oct 2023 09:38:47. | |
| static std::string | createHashKey (unsigned int length=20) |
| Return a random string. More... | |
Protected Member Functions | |
| void | sendMsgToAgent (const std::string &msg) |
| Send message to the agent. | |
| void | sendMsgToAgent (const std::string &method, const std::string &jsonobj) |
| Format and send message to the agent. | |
| Protected Member Functions inherited from Task | |
| bool | addConnection (SocketConnection *conn) |
| bool | addConnected (SocketConnection *conn) |
| bool | addServer (ServerSocket *conn) |
| As Task::addConnected, but with a server connection. | |
| bool | parseListen (const TaskConfig &tc, const std::string &log_label) |
| virtual bool | tlsSetKey (ServerSocket *conn, const std::string &crt_path, const std::string &key_path, const std::string &password) |
| Use SSL certificate for a listening socket. | |
| void | setResult (const std::string &res) |
| virtual void | setError (const std::string &msg) |
| virtual void | setTimeout () |
| void | setMessage (const std::string &msg) |
| virtual void | taskMessage (Task *task) |
| virtual void | handleExecution (Task *sender, const std::string &message) |
| Callback to execute code on behalf of another Task. | |
| bool | terminated () const |
| Return true if task is finished. More... | |
| void | addNewTask (Task *task, Task *parent=nullptr) |
| Insert another Task for execution by the EventLoop. | |
| void | addNewThread (Task *task, const std::string &name="ThreadLoop", std::ostream *log_file=nullptr, Task *parent=nullptr) |
| Run task in a new thread. | |
| void | getMyTasks (std::set< Task * > &tset) |
| Add all my child tasks to the given set. | |
| void | abortMyTasks () |
| Terminate all my child tasks. | |
| void | abortTask (Task *task) |
| Terminate a task. | |
| void | abortAllTasks () |
| Terminate all tasks and exit the EventLoop. | |
| int | runProcess (const char *const argv[]) |
| virtual void | processFinished (int pid, int wstatus) |
| Will be called to notify when an external process has terminated. | |
| WorkerProcess * | createWorker (std::ostream *log_file=nullptr, unsigned int channels=1, unsigned int wno=0) |
| Run task returned by this->createWorkerTask in a child process. Return nullptr on failure. | |
| WorkerProcess * | createWorker (const std::string &log_file_name, unsigned int channels=1, unsigned int wno=0) |
| Run task returned by this->createWorkerTask in a child process. Return nullptr on failure. | |
| Protected Member Functions inherited from Logger | |
| std::ostream & | errno_log () const |
| Write a line of error log after a failed system call has set the global errno to a non-zero value. More... | |
| std::ostream & | err_log () const |
| Write a line of error log. More... | |
| std::ostream & | warn_log () const |
| Write a line of warning log. More... | |
| std::ostream & | log () const |
| Write a line of info log. More... | |
| std::ostream & | dbg_log () const |
| Write a line of debug log. More... | |
Detailed Description
Tasks may use a bridge to communicate with an application running outside the event loop.
This class provides an abstract interface for a bridge which facilitates communication between a task and code running outside the event loop. The code might run in another process or thread. The actual means of communication might be sockets or pipes, or shared variables in the case of threads, or something else entirely.
The task running in the event loop is called the agent, and the outside aplication is called the client.
To use this class, you must
- derive from this class
- implement the sendMessageToClient method
- implement a way for the client to send messages back, and pass those messages through the sendMsgToAgent method
- if you override the start() method, call BridgeTask::start() first
- create an agent object and a bridge object
- add the bridge object to the event loop The agent task will be aborted when the bridge task is finished. If you need timers (e.g. for polling), you must override the start() method below and your start() method must call BridgeTask::start().
When there is a message from the client to the agent, the agent's Task::handleExecution method will be called with two parameters: the bridge object and a message.
Typically, the agent's Task::handleExecution method checks if the first parameter can be cast to a BridgeTask pointer. If so, the second parameter is a message from the client. When the first message from the client arrives, the agent stores the pointer to the bridge in case it needs to send messages back.
Constructor & Destructor Documentation
◆ BridgeTask()
|
inline |
Create a bridge to the given agent task.
If the agent task isn't available yet, it must be added using BridgeTask::setAgent before the bridge is added to the EventLoop.
Member Function Documentation
◆ isAgentTerminatedMessage()
|
inlinestatic |
Return true if msg is formatted as a note that the agent has terminated and that there will be no more messages.
◆ msgToAgent()
|
inlinestatic |
Format a message to the agent.
Recommended way to format messages to the agent: a method name, and "arguments" stored in a JSON object.
Note! The method name must not contain any special chararcters.
◆ sendMsgToClient()
|
inline |
Format a message to the client.
Recommended way to format messages to the client: an event (or method) name, and "arguments" stored in a JSON object.
Note! The method name must not contain any special chararcters.
◆ setAgent()
|
inline |
If the agent task was created after the bridge, it must be added using this method before the bridge is added to the EventLoop.
◆ start()
|
overridevirtual |
Will add the agent task to the EventLoop.
Note! If you override this method, it should be called explicitly by the overriding method!
Reimplemented from Task.
Reimplemented in WebsocketBridge, UnixDomainBridge, ThreadBridge, and SynchronousBridge.
The documentation for this class was generated from the following files:
- src/framework/bridgetask.h
- src/framework/bridgetask.cpp
