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
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_CLS_JOURNAL_TYPES_H
#define CEPH_CLS_JOURNAL_TYPES_H
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include <iosfwd>
#include <list>
#include <string>
namespace ceph {
class Formatter;
}
namespace cls {
namespace journal {
static const uint64_t JOURNAL_MAX_RETURN = 256;
struct ObjectPosition {
uint64_t object_number;
uint64_t tag_tid;
uint64_t entry_tid;
ObjectPosition() : object_number(0), tag_tid(0), entry_tid(0) {}
ObjectPosition(uint64_t _object_number, uint64_t _tag_tid,
uint64_t _entry_tid)
: object_number(_object_number), tag_tid(_tag_tid), entry_tid(_entry_tid) {}
inline bool operator==(const ObjectPosition& rhs) const {
return (object_number == rhs.object_number &&
tag_tid == rhs.tag_tid &&
entry_tid == rhs.entry_tid);
}
inline bool operator!=(const ObjectPosition& rhs) const {
return !(*this == rhs);
}
void encode(ceph::buffer::list& bl) const;
void decode(ceph::buffer::list::const_iterator& iter);
void dump(ceph::Formatter *f) const;
inline bool operator<(const ObjectPosition &rhs) const {
if (object_number != rhs.object_number) {
return object_number < rhs.object_number;
} else if (tag_tid != rhs.tag_tid) {
return tag_tid < rhs.tag_tid;
}
return entry_tid < rhs.entry_tid;
}
static void generate_test_instances(std::list<ObjectPosition *> &o);
};
typedef std::list<ObjectPosition> ObjectPositions;
struct ObjectSetPosition {
// stored in most-recent -> least recent committed entry order
ObjectPositions object_positions;
ObjectSetPosition() {}
ObjectSetPosition(const ObjectPositions &_object_positions)
: object_positions(_object_positions) {}
void encode(ceph::buffer::list& bl) const;
void decode(ceph::buffer::list::const_iterator& iter);
void dump(ceph::Formatter *f) const;
inline bool operator==(const ObjectSetPosition &rhs) const {
return (object_positions == rhs.object_positions);
}
static void generate_test_instances(std::list<ObjectSetPosition *> &o);
};
enum ClientState {
CLIENT_STATE_CONNECTED = 0,
CLIENT_STATE_DISCONNECTED = 1
};
struct Client {
std::string id;
ceph::buffer::list data;
ObjectSetPosition commit_position;
ClientState state;
Client() : state(CLIENT_STATE_CONNECTED) {}
Client(const std::string& _id, const ceph::buffer::list &_data,
const ObjectSetPosition &_commit_position = ObjectSetPosition(),
ClientState _state = CLIENT_STATE_CONNECTED)
: id(_id), data(_data), commit_position(_commit_position), state(_state) {}
inline bool operator==(const Client &rhs) const {
return (id == rhs.id &&
data.contents_equal(rhs.data) &&
commit_position == rhs.commit_position &&
state == rhs.state);
}
inline bool operator<(const Client &rhs) const {
return (id < rhs.id);
}
void encode(ceph::buffer::list& bl) const;
void decode(ceph::buffer::list::const_iterator& iter);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<Client *> &o);
};
struct Tag {
static const uint64_t TAG_CLASS_NEW = static_cast<uint64_t>(-1);
uint64_t tid;
uint64_t tag_class;
ceph::buffer::list data;
Tag() : tid(0), tag_class(0) {}
Tag(uint64_t tid, uint64_t tag_class, const ceph::buffer::list &data)
: tid(tid), tag_class(tag_class), data(data) {}
inline bool operator==(const Tag &rhs) const {
return (tid == rhs.tid &&
tag_class == rhs.tag_class &&
data.contents_equal(rhs.data));
}
inline bool operator<(const Tag &rhs) const {
return (tid < rhs.tid);
}
void encode(ceph::buffer::list& bl) const;
void decode(ceph::buffer::list::const_iterator& iter);
void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<Tag *> &o);
};
WRITE_CLASS_ENCODER(ObjectPosition);
WRITE_CLASS_ENCODER(ObjectSetPosition);
WRITE_CLASS_ENCODER(Client);
WRITE_CLASS_ENCODER(Tag);
std::ostream &operator<<(std::ostream &os, const ClientState &state);
std::ostream &operator<<(std::ostream &os,
const ObjectPosition &object_position);
std::ostream &operator<<(std::ostream &os,
const ObjectSetPosition &object_set_position);
std::ostream &operator<<(std::ostream &os,
const Client &client);
std::ostream &operator<<(std::ostream &os, const Tag &tag);
} // namespace journal
} // namespace cls
#endif // CEPH_CLS_JOURNAL_TYPES_H
|
