1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2015 Red Hat
8 * This is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License version 2.1, as published by the Free Software
11 * Foundation. See file COPYING.
17 #include "include/types.h"
19 #include "include/encoding.h"
20 #include "include/ceph_features.h"
21 #include "common/ceph_argparse.h"
22 #include "common/Formatter.h"
23 #include "common/errno.h"
24 #include "msg/Message.h"
25 #include "include/assert.h"
28 #define TYPE_STRAYDATA(t)
29 #define TYPE_NONDETERMINISTIC(t)
30 #define TYPE_FEATUREFUL(t)
31 #define TYPE_FEATUREFUL_STRAYDATA(t)
32 #define TYPE_FEATUREFUL_NONDETERMINISTIC(t)
33 #define TYPE_FEATUREFUL_NOCOPY(t)
34 #define TYPE_NOCOPY(t)
39 #undef TYPE_NONDETERMINISTIC
41 #undef TYPE_FEATUREFUL
42 #undef TYPE_FEATUREFUL_STRAYDATA
43 #undef TYPE_FEATUREFUL_NONDETERMINISTIC
44 #undef TYPE_FEATUREFUL_NOCOPY
47 #define MB(m) ((m) * 1024 * 1024)
49 void usage(ostream &out)
51 out << "usage: ceph-dencoder [commands ...]" << std::endl;
53 out << " version print version string (to stdout)\n";
55 out << " import <encfile> read encoded data from encfile\n";
56 out << " export <outfile> write encoded data to outfile\n";
58 out << " set_features <num> set feature bits used for encoding\n";
59 out << " get_features print feature bits (int) to stdout\n";
61 out << " list_types list supported types\n";
62 out << " type <classname> select in-memory type\n";
63 out << " skip <num> skip <num> leading bytes before decoding\n";
64 out << " decode decode into in-memory object\n";
65 out << " encode encode in-memory object\n";
66 out << " dump_json dump in-memory object as json (to stdout)\n";
67 out << " hexdump print encoded data in hex\n";
69 out << " copy copy object (via operator=)\n";
70 out << " copy_ctor copy object (via copy ctor)\n";
72 out << " count_tests print number of generated test objects (to stdout)\n";
73 out << " select_test <n> select generated test object as in-memory object\n";
74 out << " is_deterministic exit w/ success if type encodes deterministically\n";
77 virtual ~Dencoder() {}
78 virtual string decode(bufferlist bl, uint64_t seek) = 0;
79 virtual void encode(bufferlist& out, uint64_t features) = 0;
80 virtual void dump(ceph::Formatter *f) = 0;
82 cerr << "copy operator= not supported" << std::endl;
84 virtual void copy_ctor() {
85 cerr << "copy ctor not supported" << std::endl;
87 virtual void generate() = 0;
88 virtual int num_generated() = 0;
89 virtual string select_generated(unsigned n) = 0;
90 virtual bool is_deterministic() = 0;
91 //virtual void print(ostream& out) = 0;
95 class DencoderBase : public Dencoder {
100 bool nondeterministic;
103 DencoderBase(bool stray_okay, bool nondeterministic)
105 stray_okay(stray_okay),
106 nondeterministic(nondeterministic) {}
107 ~DencoderBase() override {
111 string decode(bufferlist bl, uint64_t seek) override {
112 bufferlist::iterator p = bl.begin();
115 ::decode(*m_object, p);
117 catch (buffer::error& e) {
120 if (!stray_okay && !p.end()) {
122 ss << "stray data at end of buffer, offset " << p.get_off();
128 void encode(bufferlist& out, uint64_t features) override = 0;
130 void dump(ceph::Formatter *f) override {
133 void generate() override {
134 T::generate_test_instances(m_list);
136 int num_generated() override {
137 return m_list.size();
139 string select_generated(unsigned i) override {
140 // allow 0- or 1-based (by wrapping)
143 if ((i == 0) || (i > m_list.size()))
144 return "invalid id for generated object";
145 m_object = *(std::next(m_list.begin(), i-1));
149 bool is_deterministic() override {
150 return !nondeterministic;
155 class DencoderImplNoFeatureNoCopy : public DencoderBase<T> {
157 DencoderImplNoFeatureNoCopy(bool stray_ok, bool nondeterministic)
158 : DencoderBase<T>(stray_ok, nondeterministic) {}
159 void encode(bufferlist& out, uint64_t features) override {
161 ::encode(*this->m_object, out);
166 class DencoderImplNoFeature : public DencoderImplNoFeatureNoCopy<T> {
168 DencoderImplNoFeature(bool stray_ok, bool nondeterministic)
169 : DencoderImplNoFeatureNoCopy<T>(stray_ok, nondeterministic) {}
170 void copy() override {
172 *n = *this->m_object;
173 delete this->m_object;
176 void copy_ctor() override {
177 T *n = new T(*this->m_object);
178 delete this->m_object;
184 class DencoderImplFeaturefulNoCopy : public DencoderBase<T> {
186 DencoderImplFeaturefulNoCopy(bool stray_ok, bool nondeterministic)
187 : DencoderBase<T>(stray_ok, nondeterministic) {}
188 void encode(bufferlist& out, uint64_t features) override {
190 ::encode(*(this->m_object), out, features);
195 class DencoderImplFeatureful : public DencoderImplFeaturefulNoCopy<T> {
197 DencoderImplFeatureful(bool stray_ok, bool nondeterministic)
198 : DencoderImplFeaturefulNoCopy<T>(stray_ok, nondeterministic) {}
199 void copy() override {
201 *n = *this->m_object;
202 delete this->m_object;
205 void copy_ctor() override {
206 T *n = new T(*this->m_object);
207 delete this->m_object;
213 class MessageDencoderImpl : public Dencoder {
218 MessageDencoderImpl() {
221 ~MessageDencoderImpl() override {
225 string decode(bufferlist bl, uint64_t seek) override {
226 bufferlist::iterator p = bl.begin();
229 Message *n = decode_message(g_ceph_context, 0, p);
231 throw std::runtime_error("failed to decode");
232 if (n->get_type() != m_object->get_type()) {
234 ss << "decoded type " << n->get_type() << " instead of expected " << m_object->get_type();
235 throw std::runtime_error(ss.str());
238 m_object = static_cast<T *>(n);
240 catch (buffer::error& e) {
245 ss << "stray data at end of buffer, offset " << p.get_off();
251 void encode(bufferlist& out, uint64_t features) override {
253 encode_message(m_object, features, out);
256 void dump(ceph::Formatter *f) override {
259 void generate() override {
260 //T::generate_test_instances(m_list);
262 int num_generated() override {
263 return m_list.size();
265 string select_generated(unsigned i) override {
266 // allow 0- or 1-based (by wrapping)
269 if ((i == 0) || (i > m_list.size()))
270 return "invalid id for generated object";
272 m_object = *(std::next(m_list.begin(), i-1));
275 bool is_deterministic() override {
279 //void print(ostream& out) {
280 //out << m_object << std::endl;
286 int main(int argc, const char **argv)
289 map<string,Dencoder*> dencoders;
292 #define T_STRINGIFY(x) T_STR(x)
293 #define TYPE(t) dencoders[T_STRINGIFY(t)] = new DencoderImplNoFeature<t>(false, false);
294 #define TYPE_STRAYDATA(t) dencoders[T_STRINGIFY(t)] = new DencoderImplNoFeature<t>(true, false);
295 #define TYPE_NONDETERMINISTIC(t) dencoders[T_STRINGIFY(t)] = new DencoderImplNoFeature<t>(false, true);
296 #define TYPE_FEATUREFUL(t) dencoders[T_STRINGIFY(t)] = new DencoderImplFeatureful<t>(false, false);
297 #define TYPE_FEATUREFUL_STRAYDATA(t) dencoders[T_STRINGIFY(t)] = new DencoderImplFeatureful<t>(true, false);
298 #define TYPE_FEATUREFUL_NONDETERMINISTIC(t) dencoders[T_STRINGIFY(t)] = new DencoderImplFeatureful<t>(false, true);
299 #define TYPE_FEATUREFUL_NOCOPY(t) dencoders[T_STRINGIFY(t)] = new DencoderImplFeaturefulNoCopy<t>(false, false);
300 #define TYPE_NOCOPY(t) dencoders[T_STRINGIFY(t)] = new DencoderImplNoFeatureNoCopy<t>(false, false);
301 #define MESSAGE(t) dencoders[T_STRINGIFY(t)] = new MessageDencoderImpl<t>;
304 #undef TYPE_STRAYDATA
305 #undef TYPE_NONDETERMINISTIC
307 #undef TYPE_FEATUREFUL
308 #undef TYPE_FEATUREFUL_STRAYDATA
309 #undef TYPE_FEATUREFUL_NONDETERMINISTIC
310 #undef TYPE_FEATUREFUL_NOCOPY
314 vector<const char*> args;
315 argv_to_vec(argc, argv, args);
318 Dencoder *den = NULL;
319 uint64_t features = CEPH_FEATURES_SUPPORTED_DEFAULT;
324 cerr << "-h for help" << std::endl;
327 for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ++i) {
330 if (*i == string("help") || *i == string("-h") || *i == string("--help")) {
333 } else if (*i == string("version")) {
334 cout << CEPH_GIT_NICE_VER << std::endl;
335 } else if (*i == string("list_types")) {
336 for (map<string,Dencoder*>::iterator p = dencoders.begin();
337 p != dencoders.end();
339 cout << p->first << std::endl;
341 } else if (*i == string("type")) {
343 if (i == args.end()) {
344 cerr << "expecting type" << std::endl;
348 if (!dencoders.count(cname)) {
349 cerr << "class '" << cname << "' unknown" << std::endl;
352 den = dencoders[cname];
354 } else if (*i == string("skip")) {
356 if (i == args.end()) {
357 cerr << "expecting byte count" << std::endl;
361 } else if (*i == string("get_features")) {
362 cout << CEPH_FEATURES_SUPPORTED_DEFAULT << std::endl;
364 } else if (*i == string("set_features")) {
366 if (i == args.end()) {
367 cerr << "expecting features" << std::endl;
370 features = atoll(*i);
371 } else if (*i == string("encode")) {
373 cerr << "must first select type with 'type <name>'" << std::endl;
376 den->encode(encbl, features | CEPH_FEATURE_RESERVED); // hack for OSDMap
377 } else if (*i == string("decode")) {
379 cerr << "must first select type with 'type <name>'" << std::endl;
382 err = den->decode(encbl, skip);
383 } else if (*i == string("copy_ctor")) {
385 cerr << "must first select type with 'type <name>'" << std::endl;
389 } else if (*i == string("copy")) {
391 cerr << "must first select type with 'type <name>'" << std::endl;
395 } else if (*i == string("dump_json")) {
397 cerr << "must first select type with 'type <name>'" << std::endl;
400 JSONFormatter jf(true);
401 jf.open_object_section("object");
407 } else if (*i == string("hexdump")) {
409 } else if (*i == string("import")) {
411 if (i == args.end()) {
412 cerr << "expecting filename" << std::endl;
416 if (*i == string("-")) {
418 // Read up to 1mb if stdin specified
419 r = encbl.read_fd(STDIN_FILENO, MB(1));
421 r = encbl.read_file(*i, &err);
424 cerr << "error reading " << *i << ": " << err << std::endl;
428 } else if (*i == string("export")) {
430 if (i == args.end()) {
431 cerr << "expecting filename" << std::endl;
434 int fd = ::open(*i, O_WRONLY|O_CREAT|O_TRUNC, 0644);
436 cerr << "error opening " << *i << " for write: " << cpp_strerror(errno) << std::endl;
439 int r = encbl.write_fd(fd);
441 cerr << "error writing " << *i << ": " << cpp_strerror(errno) << std::endl;
446 } else if (*i == string("count_tests")) {
448 cerr << "must first select type with 'type <name>'" << std::endl;
451 cout << den->num_generated() << std::endl;
452 } else if (*i == string("select_test")) {
454 cerr << "must first select type with 'type <name>'" << std::endl;
458 if (i == args.end()) {
459 cerr << "expecting instance number" << std::endl;
463 err = den->select_generated(n);
464 } else if (*i == string("is_deterministic")) {
466 cerr << "must first select type with 'type <name>'" << std::endl;
469 if (den->is_deterministic())
474 cerr << "unknown option '" << *i << "'" << std::endl;
478 cerr << "error: " << err << std::endl;