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
|
// Copyright (C) 2014-2016 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef VSOMEIP_ROUTING_MANAGER_BASE
#define VSOMEIP_ROUTING_MANAGER_BASE
#include <mutex>
#include <unordered_set>
#include <vsomeip/constants.hpp>
#include "routing_manager.hpp"
#include "routing_manager_host.hpp"
#include "types.hpp"
#include "serviceinfo.hpp"
#include "event.hpp"
#include "eventgroupinfo.hpp"
#include "../../message/include/serializer.hpp"
#include "../../message/include/deserializer.hpp"
#include "../../configuration/include/configuration.hpp"
#include "../../endpoints/include/endpoint_host.hpp"
#ifdef USE_DLT
#include "../../tracing/include/trace_connector.hpp"
#endif
#ifdef USE_DLT
namespace tc {
class trace_connector;
} // namespace tc
#endif
namespace vsomeip {
class serializer;
class routing_manager_base : public routing_manager,
public endpoint_host,
public std::enable_shared_from_this<routing_manager_base>{
public:
routing_manager_base(routing_manager_host *_host);
virtual ~routing_manager_base();
virtual boost::asio::io_service & get_io();
virtual client_t get_client() const;
virtual void init();
virtual bool offer_service(client_t _client, service_t _service,
instance_t _instance, major_version_t _major,
minor_version_t _minor);
virtual void stop_offer_service(client_t _client, service_t _service,
instance_t _instance, major_version_t _major, minor_version_t _minor);
virtual void request_service(client_t _client, service_t _service,
instance_t _instance, major_version_t _major,
minor_version_t _minor, bool _use_exclusive_proxy);
virtual void release_service(client_t _client, service_t _service,
instance_t _instance);
virtual void register_event(client_t _client, service_t _service, instance_t _instance,
event_t _event, const std::set<eventgroup_t> &_eventgroups, bool _is_field,
std::chrono::milliseconds _cycle, bool _change_resets_cycle,
epsilon_change_func_t _epsilon_change_func,
bool _is_provided, bool _is_shadow = false, bool _is_cache_placeholder = false);
virtual void unregister_event(client_t _client, service_t _service, instance_t _instance,
event_t _event, bool _is_provided);
virtual std::shared_ptr<event> get_event(service_t _service,
instance_t _instance, event_t _event) const;
virtual std::set<std::shared_ptr<event>> find_events(service_t _service,
instance_t _instance, eventgroup_t _eventgroup) const;
virtual void subscribe(client_t _client, service_t _service,
instance_t _instance, eventgroup_t _eventgroup,
major_version_t _major,
subscription_type_e _subscription_type);
virtual void unsubscribe(client_t _client, service_t _service,
instance_t _instance, eventgroup_t _eventgroup);
virtual void notify(service_t _service, instance_t _instance,
event_t _event, std::shared_ptr<payload> _payload, bool _force);
virtual void notify_one(service_t _service, instance_t _instance,
event_t _event, std::shared_ptr<payload> _payload,
client_t _client, bool _force);
virtual bool send(client_t _client, std::shared_ptr<message> _message,
bool _flush);
virtual bool send(client_t _client, const byte_t *_data, uint32_t _size,
instance_t _instance, bool _flush, bool _reliable) = 0;
// Endpoint host ~> will be implemented by routing_manager_impl/_proxy/
virtual void on_connect(std::shared_ptr<endpoint> _endpoint) = 0;
virtual void on_disconnect(std::shared_ptr<endpoint> _endpoint) = 0;
virtual void on_message(const byte_t *_data, length_t _length,
endpoint *_receiver, const boost::asio::ip::address &_destination
= boost::asio::ip::address()) = 0;
virtual void on_error(const byte_t *_data, length_t _length,
endpoint *_receiver) = 0;
virtual void on_clientendpoint_error(client_t _client);
protected:
std::shared_ptr<serviceinfo> find_service(service_t _service, instance_t _instance) const;
std::shared_ptr<serviceinfo> create_service_info(service_t _service,
instance_t _instance, major_version_t _major,
minor_version_t _minor, ttl_t _ttl, bool _is_local_service);
void clear_service_info(service_t _service, instance_t _instance, bool _reliable);
services_t get_services() const;
bool is_available(service_t _service, instance_t _instance, major_version_t _major);
client_t find_local_client(service_t _service, instance_t _instance);
std::shared_ptr<endpoint> create_local(client_t _client);
std::shared_ptr<endpoint> find_or_create_local(client_t _client);
void remove_local(client_t _client);
std::shared_ptr<endpoint> find_local(client_t _client);
std::shared_ptr<endpoint> find_local(service_t _service,
instance_t _instance);
std::unordered_set<client_t> get_connected_clients();
std::shared_ptr<event> find_event(service_t _service, instance_t _instance,
event_t _event) const;
std::shared_ptr<eventgroupinfo> find_eventgroup(service_t _service,
instance_t _instance, eventgroup_t _eventgroup) const;
std::set<client_t> find_local_clients(service_t _service,
instance_t _instance, eventgroup_t _eventgroup);
void remove_eventgroup_info(service_t _service, instance_t _instance,
eventgroup_t _eventgroup);
bool send_local_notification(client_t _client,
const byte_t *_data, uint32_t _size, instance_t _instance,
bool _flush = true, bool _reliable = false);
bool send_local(
std::shared_ptr<endpoint> &_target, client_t _client,
const byte_t *_data, uint32_t _size, instance_t _instance,
bool _flush, bool _reliable, uint8_t _command) const;
bool insert_subscription(service_t _service, instance_t _instance,
eventgroup_t _eventgroup, client_t _client);
routing_manager_host *host_;
boost::asio::io_service &io_;
client_t client_;
std::shared_ptr<configuration> configuration_;
std::shared_ptr<serializer> serializer_;
std::shared_ptr<deserializer> deserializer_;
std::mutex serialize_mutex_;
std::mutex local_services_mutex_;
std::map<service_t, std::map<instance_t, std::tuple< major_version_t, minor_version_t, client_t> > > local_services_;
// Eventgroups
mutable std::mutex eventgroups_mutex_;
std::map<service_t,
std::map<instance_t,
std::map<eventgroup_t, std::shared_ptr<eventgroupinfo> > > > eventgroups_;
mutable std::mutex events_mutex_;
std::map<service_t,
std::map<instance_t, std::map<event_t, std::shared_ptr<event> > > > events_;
std::mutex eventgroup_clients_mutex_;
std::map<service_t,
std::map<instance_t, std::map<eventgroup_t, std::set<client_t> > > > eventgroup_clients_;
#ifdef USE_DLT
std::shared_ptr<tc::trace_connector> tc_;
#endif
private:
services_t services_;
mutable std::mutex services_mutex_;
std::map<client_t, std::shared_ptr<endpoint> > local_endpoints_;
mutable std::mutex local_endpoint_mutex_;
};
} // namespace vsomeip
#endif //VSOMEIP_ROUTING_MANAGER_BASE
|
