5 #ifndef GCOMM_GMCAST_MESSAGE_HPP
6 #define GCOMM_GMCAST_MESSAGE_HPP
8 #include "gcomm/types.hpp"
9 #include "gcomm/uuid.hpp"
10 #include "gmcast_node.hpp"
27 F_GROUP_NAME = 1 << 0,
29 F_NODE_ADDRESS = 1 << 2,
31 F_HANDSHAKE_UUID = 1 << 4,
36 F_SEGMENT_RELAY = 1 << 6
43 T_HANDSHAKE_RESPONSE = 2,
46 T_TOPOLOGY_CHANGE = 5,
60 gu::byte_t segment_id_;
72 static const char* type_to_string (Type t)
74 static const char* str[T_MAX] =
87 if (T_MAX > t)
return str[t];
89 return "UNDEFINED PACKET TYPE";
92 Message(
const Message& msg) :
93 version_ (msg.version_),
96 segment_id_ (msg.segment_id_),
97 handshake_uuid_ (msg.handshake_uuid_),
98 source_uuid_ (msg.source_uuid_),
99 node_address_ (msg.node_address_),
100 group_name_ (msg.group_name_),
101 node_list_ (msg.node_list_)
121 const UUID& handshake_uuid,
122 const UUID& source_uuid,
127 flags_ (F_HANDSHAKE_UUID),
128 segment_id_ (segment_id),
129 handshake_uuid_ (handshake_uuid),
130 source_uuid_ (source_uuid),
135 if (type_ != T_HANDSHAKE)
136 gu_throw_fatal <<
"Invalid message type " << type_to_string(type_)
137 <<
" in handshake constructor";
143 const UUID& source_uuid,
149 segment_id_ (segment_id),
151 source_uuid_ (source_uuid),
156 if (type_ != T_OK && type_ != T_FAIL && type_ != T_KEEPALIVE)
157 gu_throw_fatal <<
"Invalid message type " << type_to_string(type_)
158 <<
" in ok/fail/keepalive constructor";
165 const UUID& source_uuid,
172 segment_id_ (segment),
174 source_uuid_ (source_uuid),
179 if (type_ < T_USER_BASE)
180 gu_throw_fatal <<
"Invalid message type " << type_to_string(type_)
181 <<
" in user message constructor";
189 const std::string& node_address,
190 const std::string& group_name,
195 flags_ (F_GROUP_NAME | F_NODE_ADDRESS | F_HANDSHAKE_UUID),
196 segment_id_ (segment_id),
197 handshake_uuid_ (handshake_uuid),
198 source_uuid_ (source_uuid),
199 node_address_ (node_address),
200 group_name_ (group_name),
204 if (type_ != T_HANDSHAKE_RESPONSE)
205 gu_throw_fatal <<
"Invalid message type " << type_to_string(type_)
206 <<
" in handshake response constructor";
213 const std::string& group_name,
214 const NodeList& nodes)
218 flags_ (F_GROUP_NAME | F_NODE_LIST),
221 source_uuid_ (source_uuid),
223 group_name_ (group_name),
226 if (type_ != T_TOPOLOGY_CHANGE)
227 gu_throw_fatal <<
"Invalid message type " << type_to_string(type_)
228 <<
" in topology change constructor";
234 size_t serialize(gu::byte_t* buf,
const size_t buflen,
235 const size_t offset)
const
239 gu_trace (off = gu::serialize1(version_, buf, buflen, offset));
240 gu_trace (off = gu::serialize1(static_cast<gu::byte_t>(type_),buf,buflen,off));
241 gu_trace (off = gu::serialize1(flags_, buf, buflen, off));
242 gu_trace (off = gu::serialize1(segment_id_, buf, buflen, off));
243 gu_trace (off = source_uuid_.serialize(buf, buflen, off));
245 if (flags_ & F_HANDSHAKE_UUID)
247 gu_trace(off = handshake_uuid_.serialize(buf, buflen, off));
250 if (flags_ & F_NODE_ADDRESS)
252 gu_trace (off = node_address_.serialize(buf, buflen, off));
255 if (flags_ & F_GROUP_NAME)
257 gu_trace (off = group_name_.serialize(buf, buflen, off));
260 if (flags_ & F_NODE_LIST)
262 gu_trace(off = node_list_.serialize(buf, buflen, off));
267 size_t read_v0(
const gu::byte_t* buf,
const size_t buflen,
const size_t offset)
272 gu_trace (off = gu::unserialize1(buf, buflen, offset, t));
273 type_ =
static_cast<Type
>(t);
277 case T_HANDSHAKE_RESPONSE:
280 case T_TOPOLOGY_CHANGE:
285 gu_throw_error(EINVAL) <<
"invalid message type "
286 <<
static_cast<int>(type_);
288 gu_trace (off = gu::unserialize1(buf, buflen, off, flags_));
289 gu_trace (off = gu::unserialize1(buf, buflen, off, segment_id_));
290 gu_trace (off = source_uuid_.unserialize(buf, buflen, off));
292 if (flags_ & F_HANDSHAKE_UUID)
294 gu_trace(off = handshake_uuid_.unserialize(buf, buflen, off));
297 if (flags_ & F_NODE_ADDRESS)
299 gu_trace (off = node_address_.unserialize(buf, buflen, off));
302 if (flags_ & F_GROUP_NAME)
304 gu_trace (off = group_name_.unserialize(buf, buflen, off));
307 if (flags_ & F_NODE_LIST)
309 gu_trace(off = node_list_.unserialize(buf, buflen, off));
315 size_t unserialize(
const gu::byte_t* buf,
const size_t buflen,
const size_t offset)
319 gu_trace (off = gu::unserialize1(buf, buflen, offset, version_));
323 gu_trace (
return read_v0(buf, buflen, off));
325 gu_throw_error(EPROTONOSUPPORT) <<
"Unsupported/unrecognized gmcast protocol version: " << version_;
329 size_t serial_size()
const
332 + source_uuid_.serial_size()
333 + (flags_ & F_HANDSHAKE_UUID ? handshake_uuid_.serial_size() : 0)
335 + (flags_ & F_NODE_ADDRESS ? node_address_.serial_size() : 0)
337 + (flags_ & F_GROUP_NAME ? group_name_.serial_size() : 0)
339 + (flags_ & F_NODE_LIST ? node_list_.serial_size() : 0);
342 int version()
const {
return version_; }
344 Type type()
const {
return type_; }
346 void set_flags(uint8_t f) { flags_ = f; }
347 uint8_t flags()
const {
return flags_; }
348 uint8_t segment_id()
const {
return segment_id_; }
350 const UUID& handshake_uuid()
const {
return handshake_uuid_; }
352 const UUID& source_uuid()
const {
return source_uuid_; }
354 const std::string& node_address()
const {
return node_address_.to_string(); }
356 const std::string& group_name()
const {
return group_name_.to_string(); }
358 const NodeList& node_list()
const {
return node_list_; }
361 #endif // GCOMM_GMCAST_MESSAGE_HPP
Definition: gmcast_message.hpp:53
Definition: gmcast_message.hpp:22