forked from rdkcentral/Thunder
-
Notifications
You must be signed in to change notification settings - Fork 0
/
IController.h
389 lines (315 loc) · 18 KB
/
IController.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
/*
* If not stated otherwise in this file or this component's LICENSE file the
* following copyright and licenses apply:
*
* Copyright 2020 Metrological
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "Module.h"
#include "IShell.h"
// @stubgen:include <plugins/IShell.h>
// @stubgen:include <plugins/ISubSystem.h>
// @stubgen:include <com/IIteratorType.h>
namespace Thunder {
namespace Exchange {
namespace Controller {
// @json 1.0.0
struct EXTERNAL ISystem : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_SYSTEM };
// @alt:deprecated harakiri
// @brief Reboots the device
// @details Depending on the device this call may not generate a response.
virtual Core::hresult Reboot() = 0;
// @brief Removes contents of a directory from the persistent storage
// @param path: Path to the directory within the persisent storage
virtual Core::hresult Delete(const string& path) = 0;
// @brief Creates a clone of given plugin with a new callsign
// @param callsign: Callsign of the plugin
// @param newcallsign: Callsign for the cloned plugin
virtual Core::hresult Clone(const string& callsign, const string& newcallsign, string& response /* @out */) = 0;
// @brief Destroy given plugin
// @param callsign: Callsign of the plugin
virtual Core::hresult Destroy(const string& callsign) = 0;
// @property
// @brief Environment variable value
virtual Core::hresult Environment(const string& variable /* @index */, string& value /* @out */ ) const = 0;
};
// @json 1.0.0
struct EXTERNAL IDiscovery : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_DISCOVERY };
struct Data {
struct DiscoveryResult {
string Locator /* @brief Locator for the discovery */;
uint32_t Latency /* @brief Latency for the discovery */;
Core::OptionalType<string> Model /* @brief Model */;
bool Secure /* @brief Secure or not */;
};
using IDiscoveryResultsIterator = RPC::IIteratorType<Data::DiscoveryResult, RPC::ID_CONTROLLER_DISCOVERY_DISCOVERYRESULTS_ITERATOR>;
};
// @brief Starts SSDP network discovery
// @param ttl: Time to live, parameter for SSDP discovery
virtual Core::hresult StartDiscovery(const Core::OptionalType<uint8_t>& ttl /* @default:1 @restrict:1..255 */) = 0;
// @property
// @brief SSDP network discovery results
virtual Core::hresult DiscoveryResults(Data::IDiscoveryResultsIterator*& results /* @out */) const = 0;
};
// @json 1.0.0 @uncompliant:extended
struct EXTERNAL IConfiguration : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_CONFIGURATION };
// @alt storeconfig
// @brief Stores all configuration to the persistent memory
virtual Core::hresult Persist() = 0;
// @property
// @brief Service configuration
virtual Core::hresult Configuration(const Core::OptionalType<string>& callsign /* @index */, string& configuration /* @out @opaque */) const = 0;
virtual Core::hresult Configuration(const string& callsign /* @index */, const string& configuration /* @opaque */) = 0;
};
// @json 1.0.0
struct EXTERNAL ILifeTime : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_LIFETIME };
// @event
struct EXTERNAL INotification : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_LIFETIME_NOTIFICATION };
// @brief Notifies of a plugin state change
// @param callsign: Plugin callsign
// @param state: New state of the plugin
// @param reason: Reason for state change
virtual void StateChange(const string& callsign, const PluginHost::IShell::state& state, const PluginHost::IShell::reason& reason) = 0;
};
virtual Core::hresult Register(INotification* sink) = 0;
virtual Core::hresult Unregister(INotification* sink) = 0;
// @brief Activates a plugin
// @details Use this method to activate a plugin, i.e. move from Deactivated, via Activating to Activated state.
// If a plugin is in Activated state, it can handle JSON-RPC requests that are coming in.
// The plugin is loaded into memory only if it gets activated.
// @param callsign: Callsign of plugin to be activated
virtual Core::hresult Activate(const string& callsign) = 0;
// @brief Deactivates a plugin
// @details Use this method to deactivate a plugin, i.e. move from Activated, via Deactivating to Deactivated state.
// If a plugin is deactivated, the actual plugin (.so) is no longer loaded into the memory of the process.
// In a Deactivated state the plugin will not respond to any JSON-RPC requests.
// @param callsign: Callsign of plugin to be deactivated
virtual Core::hresult Deactivate(const string& callsign) = 0;
// @brief Makes a plugin unavailable for interaction
// @details Use this method to mark a plugin as unavailable, i.e. move from Deactivated to Unavailable state.
// It can not be started unless it is first deactivated (what triggers a state transition).
// @param callsign: Callsign of plugin to be set as unavailable
virtual Core::hresult Unavailable(const string& callsign) = 0;
// @brief Hibernates a plugin
// @param callsign: Callsign of plugin to be hibernated
// @details Use *activate* to wake up a hibernated plugin.
// In a Hibernated state the plugin will not respond to any JSON-RPC requests.
// @param timeout: Allowed time
// @retval ERROR_INPROC The plugin is running in-process and thus cannot be hibernated
virtual Core::hresult Hibernate(const string& callsign, const uint32_t timeout) = 0;
// @brief Suspends a plugin
// @details This is a more intelligent method, compared to *deactivate*, to move a plugin to a suspended state
// depending on its current state. Depending on the *startmode* flag this method will deactivate the plugin
// or only suspend the plugin.
// @param callsign: Callsign of plugin to be suspended
virtual Core::hresult Suspend(const string& callsign) = 0;
// @brief Resumes a plugin
// @details This is a more intelligent method, compared to *activate*, to move a plugin to a resumed state
// depending on its current state. If required it will activate and move to the resumed state,
// regardless of the flags in the config (i.e. *startmode*, *resumed*)
// @param callsign: Callsign of plugin to be resumed
virtual Core::hresult Resume(const string& callsign) = 0;
};
struct EXTERNAL IShells : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_SHELLS };
struct EXTERNAL INotification : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_SHELLS_NOTIFICATION };
virtual void Created(const string& callsign, PluginHost::IShell* plugin /* @in */) = 0;
virtual void Destroy(const string& callsign, PluginHost::IShell* plugin /* @in */) = 0;
};
virtual Core::hresult Register(INotification* sink) = 0;
virtual Core::hresult Unregister(INotification* sink) = 0;
};
// @json 1.0.0 @uncompliant:collapsed
struct EXTERNAL ISubsystems : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_SUBSYSTEMS };
struct Subsystem {
PluginHost::ISubSystem::subsystem Subsystem /* @brief Name of the subsystem*/;
bool Active /* @brief Denotes if the subsystem is currently active */;
};
using ISubsystemsIterator = RPC::IIteratorType<Subsystem, RPC::ID_CONTROLLER_SUBSYSTEMS_ITERATOR>;
// @event @uncompliant:collapsed
struct EXTERNAL INotification : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_SUBSYSTEMS_NOTIFICATION };
// @brief Notifies a subsystem change
// @param subsystems: Subsystems that have changed
virtual void SubsystemChange(ISubsystemsIterator* const subsystems /* @in */) = 0;
};
// @property
// @brief Subsystems status
virtual Core::hresult Subsystems(ISubsystemsIterator*& subsystems /* @out */) const = 0;
};
// @json 1.0.0
struct EXTERNAL IEvents : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_EVENTS };
// @event
struct EXTERNAL INotification : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_EVENTS_NOTIFICATION };
// @text all
// @brief Notifies all events forwarded by the framework
// @details The Controller plugin is an aggregator of all the events triggered by a specific plugin.
// All notifications send by any plugin are forwarded over the Controller socket as an event.
// @param event: Name of the message
// @param callsign: Origin of the message
// @param params: Contents of the message
virtual void ForwardMessage(const string& event, const Core::OptionalType<string>& callsign, const Core::OptionalType<string>& params /* @opaque */) = 0;
};
};
// @json 1.0.0
struct EXTERNAL IMetadata : virtual public Core::IUnknown {
enum { ID = RPC::ID_CONTROLLER_METADATA };
struct Data {
struct Version {
string Hash /* @brief SHA256 hash identifying the source code @restrict:64..64 */;
uint8_t Major /* @brief Major number */;
uint8_t Minor /* @brief Minor number */;
uint8_t Patch /* @brief Patch number */;
};
struct BuildInfo {
enum systemtype : uint8_t {
SYSTEM_WINDOWS /* @text:Windows */,
SYSTEM_LINUX /* @text:Linux */,
SYSTEM_MACOS /* @text:MacOS */
};
enum buildtype : uint8_t {
DEBUG,
DEBUG_OPTIMIZED,
RELEASE_WITH_DEBUG_INFO,
RELEASE,
PRODUCTION
};
enum extensiontype : uint8_t {
WARNING_REPORTING = 1,
BLUETOOTH = 2,
HIBERBATE = 4,
PROCESS_CONTAINERS = 8
};
systemtype SystemType /* @brief System type */;
buildtype BuildType /* @brief Build type */;
Core::OptionalType<extensiontype> Extensions /* @bitmask */;
bool Messaging /* @brief Denotes whether Messaging is enabled*/;
bool ExceptionCatching /* @brief Denotes whether there is an exception */;
bool DeadlockDetection /* @brief Denotes whether deadlock detection is enabled */;
bool WCharSupport /* Denotes whether there is wchar support */;
uint8_t InstanceIDBits /* @brief Core instance bits */;
Core::OptionalType<uint8_t> TraceLevel /* @brief Trace level */;
uint8_t ThreadPoolCount /* Number of configured threads on the threadpool */;
};
struct CallStack {
Core::instance_id Address /* @brief Memory address */;
string Module /* @brief Module name */;
Core::OptionalType<string> Function /* @brief Function name */;
Core::OptionalType<uint32_t> Line /* @brief Line number */;
};
struct Thread {
Core::instance_id Id /* @brief Thread ID */;
string Job /* @brief Job name */;
uint32_t Runs /* @brief Number of runs */;
};
struct Proxy {
uint32_t Interface /* @brief Interface ID */;
string Name /* @brief The fully qualified name of the interface */;
Core::instance_id Instance /* @brief Instance ID */;
uint32_t Count /* @brief Reference count */;
};
struct Link {
enum state : uint8_t {
CLOSED,
WEBSERVER /* @text WebServer */,
WEBSOCKET /* @text WebSocket */,
RAWSOCKET /* @text RawSocket */,
COMRPC /* @text COMRPC */,
SUSPENDED
};
string Remote /* @brief IP address (or FQDN) of the other side of the connection */;
state State /* @brief State of the link */;
Core::OptionalType<string> Name /* @brief Name of the connection */;
uint32_t Id /* @brief A unique number identifying the connection */;
bool Activity /* @brief Denotes if there was any activity on this connection */;
};
struct Service {
enum state : uint16_t {
UNAVAILABLE = PluginHost::IShell::UNAVAILABLE,
DEACTIVATED = PluginHost::IShell::DEACTIVATED,
DEACTIVATION = PluginHost::IShell::DEACTIVATION,
ACTIVATED = PluginHost::IShell::ACTIVATED,
ACTIVATION = PluginHost::IShell::ACTIVATION,
DESTROYED = PluginHost::IShell::DESTROYED,
PRECONDITION = PluginHost::IShell::PRECONDITION,
HIBERNATED = PluginHost::IShell::HIBERNATED,
SUSPENDED = 0x100,
RESUMED
};
string Callsign /* @brief Plugin callsign */;
string Locator /* @brief Shared library path */;
string ClassName /* @brief Plugin class name */;
string Module /* @brief Module name */;
state State /* @brief Current state */;
PluginHost::IShell::startmode StartMode /* @brief Startup mode */;
bool Resumed /* @brief Determines if the plugin is to be activated in resumed or suspended mode */;
Data::Version Version /* @brief Version */;
Core::OptionalType<string> Communicator /* @brief Communicator */;
Core::OptionalType<string> PersistentPathPostfix /* @brief Postfix of persistent path */;
Core::OptionalType<string> VolatilePathPostfix /* @brief Postfix of volatile path */;
Core::OptionalType<string> SystemRootPath /* @brief Path of system root */;
Core::OptionalType<string> Precondition /* @opaque @brief Activation conditons */;
Core::OptionalType<string> Termination /* @opaque @brief Deactivation conditions */;
Core::OptionalType<string> Control /* @opaque @brief Conditions controlled by this service */;
string Configuration /* @opaque @brief Plugin configuration */;
uint16_t Observers /* @brief Number or observers */;
Core::OptionalType<uint32_t> ProcessedRequests /* @brief Number of API requests that have been processed by the plugin */;
Core::OptionalType<uint32_t> ProcessedObjects /* @brief Number of objects that have been processed by the plugin */;
};
using ICallStackIterator = RPC::IIteratorType<Data::CallStack, RPC::ID_CONTROLLER_METADATA_CALLSTACK_ITERATOR>;
using IThreadsIterator = RPC::IIteratorType<Data::Thread, RPC::ID_CONTROLLER_METADATA_THREADS_ITERATOR>;
using IPendingRequestsIterator = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
using ILinksIterator = RPC::IIteratorType<Data::Link, RPC::ID_CONTROLLER_METADATA_LINKS_ITERATOR>;
using IProxiesIterator = RPC::IIteratorType<Data::Proxy, RPC::ID_CONTROLLER_METADATA_PROXIES_ITERATOR>;
using IServicesIterator = RPC::IIteratorType<Data::Service, RPC::ID_CONTROLLER_METADATA_SERVICES_ITERATOR>;
};
// @property @alt:deprecated status
// @brief Services metadata
// @details If callsign is omitted, metadata of all services is returned.
virtual Core::hresult Services(const Core::OptionalType<string>& callsign /* @index */, Data::IServicesIterator*& services /* @out @extract */) const = 0;
// @property
// @brief Connections list
virtual Core::hresult Links(Data::ILinksIterator*& links /* @out */) const = 0;
// @property
// @brief Proxies list
virtual Core::hresult Proxies(const uint32_t linkID /* @index */, Data::IProxiesIterator*& proxies /* @out */) const = 0;
// @property
// @brief Framework version
virtual Core::hresult Version(Data::Version& version /* @out */) const = 0;
// @property
// @brief Workerpool threads
virtual Core::hresult Threads(Data::IThreadsIterator*& threads /* @out */) const = 0;
// @property
// @brief Pending requests
virtual Core::hresult PendingRequests(Data::IPendingRequestsIterator*& requests /* @out */) const = 0;
// @property
// @brief Thread callstack
virtual Core::hresult CallStack(const uint8_t thread /* @index */, Data::ICallStackIterator*& callstack /* @out */) const = 0;
// @property
// @brief Build information
virtual Core::hresult BuildInfo(Data::BuildInfo& buildInfo /* @out */) const = 0;
};
} // namespace Controller
} // namespace Exchange
}