-Subproject commit 67383cc060dd9f90d398eed5a00e31eb70845dd8
+Subproject commit 47fbf8c6ae1fb4fca171ac86e98821a67fd32031
#include "assert.h"
#include "Formatter.h"
-#include "JSONFormatter.h"
-#include "TableFormatter.h"
-#include "XMLFormatter.h"
-#include "HTMLFormatter.h"
#include "common/escape.h"
#include <iostream>
va_end(ap);
}
-} // namespace ceph
+// -----------------------
+
+JSONFormatter::JSONFormatter(bool p)
+: m_pretty(p), m_is_pending_string(false)
+{
+ reset();
+}
+
+void JSONFormatter::flush(std::ostream& os)
+{
+ finish_pending_string();
+ os << m_ss.str();
+ if (m_pretty)
+ os << "\n";
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void JSONFormatter::reset()
+{
+ m_stack.clear();
+ m_ss.clear();
+ m_ss.str("");
+ m_pending_string.clear();
+ m_pending_string.str("");
+}
+
+void JSONFormatter::print_comma(json_formatter_stack_entry_d& entry)
+{
+ if (entry.size) {
+ if (m_pretty) {
+ m_ss << ",\n";
+ for (unsigned i = 1; i < m_stack.size(); i++)
+ m_ss << " ";
+ } else {
+ m_ss << ",";
+ }
+ } else if (m_pretty) {
+ m_ss << "\n";
+ for (unsigned i = 1; i < m_stack.size(); i++)
+ m_ss << " ";
+ }
+ if (m_pretty && entry.is_array)
+ m_ss << " ";
+}
+
+void JSONFormatter::print_quoted_string(const std::string& s)
+{
+ int len = escape_json_attr_len(s.c_str(), s.size());
+ char escaped[len];
+ escape_json_attr(s.c_str(), s.size(), escaped);
+ m_ss << '\"' << escaped << '\"';
+}
+
+void JSONFormatter::print_name(const char *name)
+{
+ finish_pending_string();
+ if (m_stack.empty())
+ return;
+ struct json_formatter_stack_entry_d& entry = m_stack.back();
+ print_comma(entry);
+ if (!entry.is_array) {
+ if (m_pretty) {
+ m_ss << " ";
+ }
+ m_ss << "\"" << name << "\"";
+ if (m_pretty)
+ m_ss << ": ";
+ else
+ m_ss << ':';
+ }
+ ++entry.size;
+}
+
+void JSONFormatter::open_section(const char *name, bool is_array)
+{
+ print_name(name);
+ if (is_array)
+ m_ss << '[';
+ else
+ m_ss << '{';
+
+ json_formatter_stack_entry_d n;
+ n.is_array = is_array;
+ m_stack.push_back(n);
+}
+
+void JSONFormatter::open_array_section(const char *name)
+{
+ open_section(name, true);
+}
+
+void JSONFormatter::open_array_section_in_ns(const char *name, const char *ns)
+{
+ std::ostringstream oss;
+ oss << name << " " << ns;
+ open_section(oss.str().c_str(), true);
+}
+
+void JSONFormatter::open_object_section(const char *name)
+{
+ open_section(name, false);
+}
+
+void JSONFormatter::open_object_section_in_ns(const char *name, const char *ns)
+{
+ std::ostringstream oss;
+ oss << name << " " << ns;
+ open_section(oss.str().c_str(), false);
+}
+
+void JSONFormatter::close_section()
+{
+ assert(!m_stack.empty());
+ finish_pending_string();
+
+ struct json_formatter_stack_entry_d& entry = m_stack.back();
+ if (m_pretty && entry.size) {
+ m_ss << "\n";
+ for (unsigned i = 1; i < m_stack.size(); i++)
+ m_ss << " ";
+ }
+ m_ss << (entry.is_array ? ']' : '}');
+ m_stack.pop_back();
+}
+
+void JSONFormatter::finish_pending_string()
+{
+ if (m_is_pending_string) {
+ print_quoted_string(m_pending_string.str());
+ m_pending_string.str(std::string());
+ m_is_pending_string = false;
+ }
+}
+
+void JSONFormatter::dump_unsigned(const char *name, uint64_t u)
+{
+ print_name(name);
+ m_ss << u;
+}
+
+void JSONFormatter::dump_int(const char *name, int64_t s)
+{
+ print_name(name);
+ m_ss << s;
+}
+
+void JSONFormatter::dump_float(const char *name, double d)
+{
+ print_name(name);
+ char foo[30];
+ snprintf(foo, sizeof(foo), "%lf", d);
+ m_ss << foo;
+}
+
+void JSONFormatter::dump_string(const char *name, const std::string& s)
+{
+ print_name(name);
+ print_quoted_string(s);
+}
+
+std::ostream& JSONFormatter::dump_stream(const char *name)
+{
+ print_name(name);
+ m_is_pending_string = true;
+ return m_pending_string;
+}
+
+void JSONFormatter::dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap)
+{
+ char buf[LARGE_SIZE];
+ vsnprintf(buf, LARGE_SIZE, fmt, ap);
+
+ print_name(name);
+ if (quoted) {
+ print_quoted_string(std::string(buf));
+ } else {
+ m_ss << std::string(buf);
+ }
+}
+
+int JSONFormatter::get_len() const
+{
+ return m_ss.str().size();
+}
+
+void JSONFormatter::write_raw_data(const char *data)
+{
+ m_ss << data;
+}
+
+const char *XMLFormatter::XML_1_DTD =
+ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+
+XMLFormatter::XMLFormatter(bool pretty)
+: m_pretty(pretty)
+{
+ reset();
+}
+
+void XMLFormatter::flush(std::ostream& os)
+{
+ finish_pending_string();
+ os << m_ss.str();
+ if (m_pretty)
+ os << "\n";
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void XMLFormatter::reset()
+{
+ m_ss.clear();
+ m_ss.str("");
+ m_pending_string.clear();
+ m_pending_string.str("");
+ m_sections.clear();
+ m_pending_string_name.clear();
+}
+
+void XMLFormatter::open_object_section(const char *name)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void XMLFormatter::open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
+{
+ open_section_in_ns(name, NULL, &attrs);
+}
+
+void XMLFormatter::open_object_section_in_ns(const char *name, const char *ns)
+{
+ open_section_in_ns(name, ns, NULL);
+}
+
+void XMLFormatter::open_array_section(const char *name)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void XMLFormatter::open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
+{
+ open_section_in_ns(name, NULL, &attrs);
+}
+
+void XMLFormatter::open_array_section_in_ns(const char *name, const char *ns)
+{
+ open_section_in_ns(name, ns, NULL);
+}
+
+void XMLFormatter::close_section()
+{
+ assert(!m_sections.empty());
+ finish_pending_string();
+
+ std::string section = m_sections.back();
+ m_sections.pop_back();
+ print_spaces();
+ m_ss << "</" << section << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+void XMLFormatter::dump_unsigned(const char *name, uint64_t u)
+{
+ std::string e(name);
+ print_spaces();
+ m_ss << "<" << e << ">" << u << "</" << e << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+void XMLFormatter::dump_int(const char *name, int64_t u)
+{
+ std::string e(name);
+ print_spaces();
+ m_ss << "<" << e << ">" << u << "</" << e << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+void XMLFormatter::dump_float(const char *name, double d)
+{
+ std::string e(name);
+ print_spaces();
+ m_ss << "<" << e << ">" << d << "</" << e << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+void XMLFormatter::dump_string(const char *name, const std::string& s)
+{
+ std::string e(name);
+ print_spaces();
+ m_ss << "<" << e << ">" << escape_xml_str(s.c_str()) << "</" << e << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+void XMLFormatter::dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs)
+{
+ std::string e(name);
+ std::string attrs_str;
+ get_attrs_str(&attrs, attrs_str);
+ print_spaces();
+ m_ss << "<" << e << attrs_str << ">" << escape_xml_str(s.c_str()) << "</" << e << ">";
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+std::ostream& XMLFormatter::dump_stream(const char *name)
+{
+ print_spaces();
+ m_pending_string_name = name;
+ m_ss << "<" << m_pending_string_name << ">";
+ return m_pending_string;
+}
+
+void XMLFormatter::dump_format_va(const char* name, const char *ns, bool quoted, const char *fmt, va_list ap)
+{
+ char buf[LARGE_SIZE];
+ vsnprintf(buf, LARGE_SIZE, fmt, ap);
+
+ std::string e(name);
+ print_spaces();
+ if (ns) {
+ m_ss << "<" << e << " xmlns=\"" << ns << "\">" << buf << "</" << e << ">";
+ } else {
+ m_ss << "<" << e << ">" << escape_xml_str(buf) << "</" << e << ">";
+ }
+
+ if (m_pretty)
+ m_ss << "\n";
+}
+
+int XMLFormatter::get_len() const
+{
+ return m_ss.str().size();
+}
+
+void XMLFormatter::write_raw_data(const char *data)
+{
+ m_ss << data;
+}
+
+void XMLFormatter::get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str)
+{
+ std::stringstream attrs_ss;
+
+ for (std::list<std::pair<std::string, std::string> >::const_iterator iter = attrs->attrs.begin();
+ iter != attrs->attrs.end(); ++iter) {
+ std::pair<std::string, std::string> p = *iter;
+ attrs_ss << " " << p.first << "=" << "\"" << p.second << "\"";
+ }
+
+ attrs_str = attrs_ss.str();
+}
+
+void XMLFormatter::open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs)
+{
+ print_spaces();
+ std::string attrs_str;
+
+ if (attrs) {
+ get_attrs_str(attrs, attrs_str);
+ }
+
+ if (ns) {
+ m_ss << "<" << name << attrs_str << " xmlns=\"" << ns << "\">";
+ } else {
+ m_ss << "<" << name << attrs_str << ">";
+ }
+ if (m_pretty)
+ m_ss << "\n";
+ m_sections.push_back(name);
+}
+
+void XMLFormatter::finish_pending_string()
+{
+ if (!m_pending_string_name.empty()) {
+ m_ss << escape_xml_str(m_pending_string.str().c_str())
+ << "</" << m_pending_string_name << ">";
+ m_pending_string_name.clear();
+ m_pending_string.str(std::string());
+ if (m_pretty) {
+ m_ss << "\n";
+ }
+ }
+}
+
+void XMLFormatter::print_spaces()
+{
+ finish_pending_string();
+ if (m_pretty) {
+ std::string spaces(m_sections.size(), ' ');
+ m_ss << spaces;
+ }
+}
+
+std::string XMLFormatter::escape_xml_str(const char *str)
+{
+ int len = escape_xml_attr_len(str);
+ std::vector<char> escaped(len, '\0');
+ escape_xml_attr(str, &escaped[0]);
+ return std::string(&escaped[0]);
+}
+
+TableFormatter::TableFormatter(bool keyval) : m_keyval(keyval)
+{
+ reset();
+}
+
+void TableFormatter::flush(std::ostream& os)
+{
+ finish_pending_string();
+ std::vector<size_t> column_size = m_column_size;
+ std::vector<std::string> column_name = m_column_name;
+
+ std::set<int> need_header_set;
+
+ // auto-sizing columns
+ for (size_t i = 0; i < m_vec.size(); i++) {
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ column_size.resize(m_vec[i].size());
+ column_name.resize(m_vec[i].size());
+ if (i > 0) {
+ if (m_vec[i - 1][j] != m_vec[i][j]) {
+ // changing row labels require to show the header
+ need_header_set.insert(i);
+ column_name[i] = m_vec[i][j].first;
+ }
+ } else {
+ column_name[i] = m_vec[i][j].first;
+ }
+
+ if (m_vec[i][j].second.length() > column_size[j])
+ column_size[j] = m_vec[i][j].second.length();
+ if (m_vec[i][j].first.length() > column_size[j])
+ column_size[j] = m_vec[i][j].first.length();
+ }
+ }
+
+ bool need_header = false;
+ if ((column_size.size() == m_column_size.size())) {
+ for (size_t i = 0; i < column_size.size(); i++) {
+ if (column_size[i] != m_column_size[i]) {
+ need_header = true;
+ break;
+ }
+ }
+ } else {
+ need_header = true;
+ }
+
+ if (need_header) {
+ // first row always needs a header if there wasn't one before
+ need_header_set.insert(0);
+ }
+
+ m_column_size = column_size;
+ for (size_t i = 0; i < m_vec.size(); i++) {
+ if (i == 0) {
+ if (need_header_set.count(i)) {
+ // print the header
+ if (!m_keyval) {
+ os << "+";
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ for (size_t v = 0; v < m_column_size[j] + 3; v++)
+ os << "-";
+ os << "+";
+ }
+ os << "\n";
+ os << "|";
+
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ os << " ";
+ std::stringstream fs;
+ fs << boost::format("%%-%is") % (m_column_size[j] + 2);
+ os << boost::format(fs.str()) % m_vec[i][j].first;
+ os << "|";
+ }
+ os << "\n";
+ os << "+";
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ for (size_t v = 0; v < m_column_size[j] + 3; v++)
+ os << "-";
+ os << "+";
+ }
+ os << "\n";
+ }
+ }
+ }
+ // print body
+ if (!m_keyval)
+ os << "|";
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ if (!m_keyval)
+ os << " ";
+ std::stringstream fs;
+
+ if (m_keyval) {
+ os << "key::";
+ os << m_vec[i][j].first;
+ os << "=";
+ os << "\"";
+ os << m_vec[i][j].second;
+ os << "\" ";
+ } else {
+ fs << boost::format("%%-%is") % (m_column_size[j] + 2);
+ os << boost::format(fs.str()) % m_vec[i][j].second;
+ os << "|";
+ }
+ }
+
+ os << "\n";
+ if (!m_keyval) {
+ if (i == (m_vec.size() - 1)) {
+ // print trailer
+ os << "+";
+ for (size_t j = 0; j < m_vec[i].size(); j++) {
+ for (size_t v = 0; v < m_column_size[j] + 3; v++)
+ os << "-";
+ os << "+";
+ }
+ os << "\n";
+ }
+ }
+ m_vec[i].clear();
+ }
+ m_vec.clear();
+}
+
+void TableFormatter::reset()
+{
+ m_ss.clear();
+ m_ss.str("");
+ m_section_cnt.clear();
+ m_column_size.clear();
+ m_section_open = 0;
+}
+
+void TableFormatter::open_object_section(const char *name)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_object_section_in_ns(const char *name, const char *ns)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_array_section(const char *name)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_array_section_in_ns(const char *name, const char *ns)
+{
+ open_section_in_ns(name, NULL, NULL);
+}
+
+void TableFormatter::open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs)
+{
+ m_section.push_back(name);
+ m_section_open++;
+}
+
+void TableFormatter::close_section()
+{
+ //
+ m_section_open--;
+ if (m_section.size()) {
+ m_section_cnt[m_section.back()] = 0;
+ m_section.pop_back();
+ }
+}
+
+size_t TableFormatter::m_vec_index(const char *name)
+{
+ std::string key(name);
+
+ size_t i = m_vec.size();
+ if (i)
+ i--;
+
+ // make sure there are vectors to push back key/val pairs
+ if (!m_vec.size())
+ m_vec.resize(1);
+
+ if (m_vec.size()) {
+ if (m_vec[i].size()) {
+ if (m_vec[i][0].first == key) {
+ // start a new column if a key is repeated
+ m_vec.resize(m_vec.size() + 1);
+ i++;
+ }
+ }
+ }
+
+ return i;
+}
+
+std::string TableFormatter::get_section_name(const char* name)
+{
+ std::string t_name = name;
+ for (size_t i = 0; i < m_section.size(); i++) {
+ t_name.insert(0, ":");
+ t_name.insert(0, m_section[i]);
+ }
+ if (m_section_open) {
+ std::stringstream lss;
+ lss << t_name;
+ lss << "[";
+ lss << m_section_cnt[t_name]++;
+ lss << "]";
+ return lss.str();
+ } else {
+ return t_name;
+ }
+}
+
+void TableFormatter::dump_unsigned(const char *name, uint64_t u)
+{
+ finish_pending_string();
+ size_t i = m_vec_index(name);
+ m_ss << u;
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void TableFormatter::dump_int(const char *name, int64_t u)
+{
+ finish_pending_string();
+ size_t i = m_vec_index(name);
+ m_ss << u;
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void TableFormatter::dump_float(const char *name, double d)
+{
+ finish_pending_string();
+ size_t i = m_vec_index(name);
+ m_ss << d;
+
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void TableFormatter::dump_string(const char *name, const std::string& s)
+{
+ finish_pending_string();
+ size_t i = m_vec_index(name);
+ m_ss << s;
+
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void TableFormatter::dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs)
+{
+ finish_pending_string();
+ size_t i = m_vec_index(name);
+
+ std::string attrs_str;
+ get_attrs_str(&attrs, attrs_str);
+ m_ss << attrs_str << s;
+
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+void TableFormatter::dump_format_va(const char* name, const char *ns, bool quoted, const char *fmt, va_list ap)
+{
+ finish_pending_string();
+ char buf[LARGE_SIZE];
+ vsnprintf(buf, LARGE_SIZE, fmt, ap);
+
+ size_t i = m_vec_index(name);
+ if (ns) {
+ m_ss << ns << "." << buf;
+ } else
+ m_ss << buf;
+
+ m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
+ m_ss.clear();
+ m_ss.str("");
+}
+
+std::ostream& TableFormatter::dump_stream(const char *name)
+{
+ finish_pending_string();
+ // we don't support this
+ m_pending_name = name;
+ return m_ss;
+}
+
+int TableFormatter::get_len() const
+{
+ // we don't know the size until flush is called
+ return 0;
+}
+
+void TableFormatter::write_raw_data(const char *data) {
+ // not supported
+}
+
+void TableFormatter::get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str)
+{
+ std::stringstream attrs_ss;
+
+ for (std::list<std::pair<std::string, std::string> >::const_iterator iter = attrs->attrs.begin();
+ iter != attrs->attrs.end(); ++iter) {
+ std::pair<std::string, std::string> p = *iter;
+ attrs_ss << " " << p.first << "=" << "\"" << p.second << "\"";
+ }
+
+ attrs_str = attrs_ss.str();
+}
+
+void TableFormatter::finish_pending_string()
+{
+ if (m_pending_name.length()) {
+ std::string ss = m_ss.str();
+ m_ss.clear();
+ m_ss.str("");
+ std::string pending_name = m_pending_name;
+ m_pending_name = "";
+ dump_string(pending_name.c_str(), ss);
+ }
+}
+}
+
}
};
+ class JSONFormatter : public Formatter {
+ public:
+ JSONFormatter(bool p = false);
+
+ void flush(std::ostream& os);
+ void reset();
+ virtual void open_array_section(const char *name);
+ void open_array_section_in_ns(const char *name, const char *ns);
+ void open_object_section(const char *name);
+ void open_object_section_in_ns(const char *name, const char *ns);
+ void close_section();
+ void dump_unsigned(const char *name, uint64_t u);
+ void dump_int(const char *name, int64_t u);
+ void dump_float(const char *name, double d);
+ void dump_string(const char *name, const std::string& s);
+ std::ostream& dump_stream(const char *name);
+ void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap);
+ int get_len() const;
+ void write_raw_data(const char *data);
+
+ private:
+
+ struct json_formatter_stack_entry_d {
+ int size;
+ bool is_array;
+ json_formatter_stack_entry_d() : size(0), is_array(false) { }
+ };
+
+ bool m_pretty;
+ void open_section(const char *name, bool is_array);
+ void print_quoted_string(const std::string& s);
+ void print_name(const char *name);
+ void print_comma(json_formatter_stack_entry_d& entry);
+ void finish_pending_string();
+
+ std::stringstream m_ss, m_pending_string;
+ std::list<json_formatter_stack_entry_d> m_stack;
+ bool m_is_pending_string;
+ };
+
+ class XMLFormatter : public Formatter {
+ public:
+ static const char *XML_1_DTD;
+ XMLFormatter(bool pretty = false);
+
+ void flush(std::ostream& os);
+ void reset();
+ void open_array_section(const char *name);
+ void open_array_section_in_ns(const char *name, const char *ns);
+ void open_object_section(const char *name);
+ void open_object_section_in_ns(const char *name, const char *ns);
+ void close_section();
+ void dump_unsigned(const char *name, uint64_t u);
+ void dump_int(const char *name, int64_t u);
+ void dump_float(const char *name, double d);
+ void dump_string(const char *name, const std::string& s);
+ std::ostream& dump_stream(const char *name);
+ void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap);
+ int get_len() const;
+ void write_raw_data(const char *data);
+
+ /* with attrs */
+ void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs);
+ void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs);
+ void dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs);
+ private:
+ void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
+ void finish_pending_string();
+ void print_spaces();
+ static std::string escape_xml_str(const char *str);
+ void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
+
+ std::stringstream m_ss, m_pending_string;
+ std::deque<std::string> m_sections;
+ bool m_pretty;
+ std::string m_pending_string_name;
+ };
+
+ class TableFormatter : public Formatter {
+ public:
+ TableFormatter(bool keyval = false);
+
+ void flush(std::ostream& os);
+ void reset();
+ virtual void open_array_section(const char *name);
+ void open_array_section_in_ns(const char *name, const char *ns);
+ void open_object_section(const char *name);
+ void open_object_section_in_ns(const char *name, const char *ns);
+
+ void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs);
+ void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs);
+
+ void close_section();
+ void dump_unsigned(const char *name, uint64_t u);
+ void dump_int(const char *name, int64_t u);
+ void dump_float(const char *name, double d);
+ void dump_string(const char *name, const std::string& s);
+ void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap);
+ void dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs);
+ std::ostream& dump_stream(const char *name);
+
+ int get_len() const;
+ void write_raw_data(const char *data);
+ void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
+
+ private:
+ void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
+ std::vector< std::vector<std::pair<std::string, std::string> > > m_vec;
+ std::stringstream m_ss;
+ size_t m_vec_index(const char* name);
+ std::string get_section_name(const char* name);
+ void finish_pending_string();
+ std::string m_pending_name;
+ bool m_keyval;
+
+ int m_section_open;
+ std::vector< std::string > m_section;
+ std::map<std::string, int> m_section_cnt;
+ std::vector<size_t> m_column_size;
+ std::vector< std::string > m_column_name;
+ };
+
+
}
#endif
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2011 New Dream Network
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#define LARGE_SIZE 1024
-
-#include "include/int_types.h"
-
-#include "assert.h"
-#include "Formatter.h"
-#include "JSONFormatter.h"
-#include "common/escape.h"
-
-#include <iostream>
-#include <sstream>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
-#include <string>
-#include <set>
-#include <boost/format.hpp>
-
-// -----------------------
-namespace ceph {
-
-JSONFormatter::JSONFormatter(bool p)
-: m_pretty(p), m_is_pending_string(false)
-{
- reset();
-}
-
-void JSONFormatter::flush(std::ostream& os)
-{
- finish_pending_string();
- os << m_ss.str();
- if (m_pretty)
- os << "\n";
- m_ss.clear();
- m_ss.str("");
-}
-
-void JSONFormatter::reset()
-{
- m_stack.clear();
- m_ss.clear();
- m_ss.str("");
- m_pending_string.clear();
- m_pending_string.str("");
-}
-
-void JSONFormatter::print_comma(json_formatter_stack_entry_d& entry)
-{
- if (entry.size) {
- if (m_pretty) {
- m_ss << ",\n";
- for (unsigned i = 1; i < m_stack.size(); i++)
- m_ss << " ";
- } else {
- m_ss << ",";
- }
- } else if (m_pretty) {
- m_ss << "\n";
- for (unsigned i = 1; i < m_stack.size(); i++)
- m_ss << " ";
- }
- if (m_pretty && entry.is_array)
- m_ss << " ";
-}
-
-void JSONFormatter::print_quoted_string(const std::string& s)
-{
- int len = escape_json_attr_len(s.c_str(), s.size());
- char escaped[len];
- escape_json_attr(s.c_str(), s.size(), escaped);
- m_ss << '\"' << escaped << '\"';
-}
-
-void JSONFormatter::print_name(const char *name)
-{
- finish_pending_string();
- if (m_stack.empty())
- return;
- struct json_formatter_stack_entry_d& entry = m_stack.back();
- print_comma(entry);
- if (!entry.is_array) {
- if (m_pretty) {
- m_ss << " ";
- }
- m_ss << "\"" << name << "\"";
- if (m_pretty)
- m_ss << ": ";
- else
- m_ss << ':';
- }
- ++entry.size;
-}
-
-void JSONFormatter::open_section(const char *name, bool is_array)
-{
- print_name(name);
- if (is_array)
- m_ss << '[';
- else
- m_ss << '{';
-
- json_formatter_stack_entry_d n;
- n.is_array = is_array;
- m_stack.push_back(n);
-}
-
-void JSONFormatter::open_array_section(const char *name)
-{
- open_section(name, true);
-}
-
-void JSONFormatter::open_array_section_in_ns(const char *name, const char *ns)
-{
- std::ostringstream oss;
- oss << name << " " << ns;
- open_section(oss.str().c_str(), true);
-}
-
-void JSONFormatter::open_object_section(const char *name)
-{
- open_section(name, false);
-}
-
-void JSONFormatter::open_object_section_in_ns(const char *name, const char *ns)
-{
- std::ostringstream oss;
- oss << name << " " << ns;
- open_section(oss.str().c_str(), false);
-}
-
-void JSONFormatter::close_section()
-{
- assert(!m_stack.empty());
- finish_pending_string();
-
- struct json_formatter_stack_entry_d& entry = m_stack.back();
- if (m_pretty && entry.size) {
- m_ss << "\n";
- for (unsigned i = 1; i < m_stack.size(); i++)
- m_ss << " ";
- }
- m_ss << (entry.is_array ? ']' : '}');
- m_stack.pop_back();
-}
-
-void JSONFormatter::finish_pending_string()
-{
- if (m_is_pending_string) {
- print_quoted_string(m_pending_string.str());
- m_pending_string.str(std::string());
- m_is_pending_string = false;
- }
-}
-
-void JSONFormatter::dump_unsigned(const char *name, uint64_t u)
-{
- print_name(name);
- m_ss << u;
-}
-
-void JSONFormatter::dump_int(const char *name, int64_t s)
-{
- print_name(name);
- m_ss << s;
-}
-
-void JSONFormatter::dump_float(const char *name, double d)
-{
- print_name(name);
- char foo[30];
- snprintf(foo, sizeof(foo), "%lf", d);
- m_ss << foo;
-}
-
-void JSONFormatter::dump_string(const char *name, const std::string& s)
-{
- print_name(name);
- print_quoted_string(s);
-}
-
-std::ostream& JSONFormatter::dump_stream(const char *name)
-{
- print_name(name);
- m_is_pending_string = true;
- return m_pending_string;
-}
-
-void JSONFormatter::dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap)
-{
- char buf[LARGE_SIZE];
- vsnprintf(buf, LARGE_SIZE, fmt, ap);
-
- print_name(name);
- if (quoted) {
- print_quoted_string(std::string(buf));
- } else {
- m_ss << std::string(buf);
- }
-}
-
-int JSONFormatter::get_len() const
-{
- return m_ss.str().size();
-}
-
-void JSONFormatter::write_raw_data(const char *data)
-{
- m_ss << data;
-}
-
-} // namespace ceph
common/simple_spin.cc \
common/Thread.cc \
common/Formatter.cc \
- common/XMLFormatter.cc \
common/HTMLFormatter.cc \
- common/JSONFormatter.cc \
- common/TableFormatter.cc \
common/HeartbeatMap.cc \
common/config.cc \
common/utf8.c \
common/DecayCounter.h \
common/Finisher.h \
common/Formatter.h \
- common/JSONFormatter.h \
- common/TableFormatter.h \
- common/XMLFormatter.h \
common/HTMLFormatter.h \
common/perf_counters.h \
common/OutputDataSocket.h \
+++ /dev/null
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2011 New Dream Network
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
- * Foundation. See file COPYING.
- *
- */
-
-#define LARGE_SIZE 1024
-
-#include "include/int_types.h"
-
-#include "assert.h"
-#include "Formatter.h"
-#include "TableFormatter.h"
-#include "common/escape.h"
-
-#include <iostream>
-#include <sstream>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
-#include <string>
-#include <set>
-#include <boost/format.hpp>
-
-// -----------------------
-namespace ceph {
-TableFormatter::TableFormatter(bool keyval) : m_keyval(keyval)
-{
- reset();
-}
-
-void TableFormatter::flush(std::ostream& os)
-{
- finish_pending_string();
- std::vector<size_t> column_size = m_column_size;
- std::vector<std::string> column_name = m_column_name;
-
- std::set<int> need_header_set;
-
- // auto-sizing columns
- for (size_t i = 0; i < m_vec.size(); i++) {
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- column_size.resize(m_vec[i].size());
- column_name.resize(m_vec[i].size());
- if (i > 0) {
- if (m_vec[i - 1][j] != m_vec[i][j]) {
- // changing row labels require to show the header
- need_header_set.insert(i);
- column_name[i] = m_vec[i][j].first;
- }
- } else {
- column_name[i] = m_vec[i][j].first;
- }
-
- if (m_vec[i][j].second.length() > column_size[j])
- column_size[j] = m_vec[i][j].second.length();
- if (m_vec[i][j].first.length() > column_size[j])
- column_size[j] = m_vec[i][j].first.length();
- }
- }
-
- bool need_header = false;
- if ((column_size.size() == m_column_size.size())) {
- for (size_t i = 0; i < column_size.size(); i++) {
- if (column_size[i] != m_column_size[i]) {
- need_header = true;
- break;
- }
- }
- } else {
- need_header = true;
- }
-
- if (need_header) {
- // first row always needs a header if there wasn't one before
- need_header_set.insert(0);
- }
-
- m_column_size = column_size;
- for (size_t i = 0; i < m_vec.size(); i++) {
- if (i == 0) {
- if (need_header_set.count(i)) {
- // print the header
- if (!m_keyval) {
- os << "+";
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- for (size_t v = 0; v < m_column_size[j] + 3; v++)
- os << "-";
- os << "+";
- }
- os << "\n";
- os << "|";
-
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- os << " ";
- std::stringstream fs;
- fs << boost::format("%%-%is") % (m_column_size[j] + 2);
- os << boost::format(fs.str()) % m_vec[i][j].first;
- os << "|";
- }
- os << "\n";
- os << "+";
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- for (size_t v = 0; v < m_column_size[j] + 3; v++)
- os << "-";
- os << "+";
- }
- os << "\n";
- }
- }
- }
- // print body
- if (!m_keyval)
- os << "|";
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- if (!m_keyval)
- os << " ";
- std::stringstream fs;
-
- if (m_keyval) {
- os << "key::";
- os << m_vec[i][j].first;
- os << "=";
- os << "\"";
- os << m_vec[i][j].second;
- os << "\" ";
- } else {
- fs << boost::format("%%-%is") % (m_column_size[j] + 2);
- os << boost::format(fs.str()) % m_vec[i][j].second;
- os << "|";
- }
- }
-
- os << "\n";
- if (!m_keyval) {
- if (i == (m_vec.size() - 1)) {
- // print trailer
- os << "+";
- for (size_t j = 0; j < m_vec[i].size(); j++) {
- for (size_t v = 0; v < m_column_size[j] + 3; v++)
- os << "-";
- os << "+";
- }
- os << "\n";
- }
- }
- m_vec[i].clear();
- }
- m_vec.clear();
-}
-
-void TableFormatter::reset()
-{
- m_ss.clear();
- m_ss.str("");
- m_section_cnt.clear();
- m_column_size.clear();
- m_section_open = 0;
-}
-
-void TableFormatter::open_object_section(const char *name)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_object_section_in_ns(const char *name, const char *ns)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_array_section(const char *name)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_array_section_in_ns(const char *name, const char *ns)
-{
- open_section_in_ns(name, NULL, NULL);
-}
-
-void TableFormatter::open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs)
-{
- m_section.push_back(name);
- m_section_open++;
-}
-
-void TableFormatter::close_section()
-{
- //
- m_section_open--;
- if (m_section.size()) {
- m_section_cnt[m_section.back()] = 0;
- m_section.pop_back();
- }
-}
-
-size_t TableFormatter::m_vec_index(const char *name)
-{
- std::string key(name);
-
- size_t i = m_vec.size();
- if (i)
- i--;
-
- // make sure there are vectors to push back key/val pairs
- if (!m_vec.size())
- m_vec.resize(1);
-
- if (m_vec.size()) {
- if (m_vec[i].size()) {
- if (m_vec[i][0].first == key) {
- // start a new column if a key is repeated
- m_vec.resize(m_vec.size() + 1);
- i++;
- }
- }
- }
-
- return i;
-}
-
-std::string TableFormatter::get_section_name(const char* name)
-{
- std::string t_name = name;
- for (size_t i = 0; i < m_section.size(); i++) {
- t_name.insert(0, ":");
- t_name.insert(0, m_section[i]);
- }
- if (m_section_open) {
- std::stringstream lss;
- lss << t_name;
- lss << "[";
- lss << m_section_cnt[t_name]++;
- lss << "]";
- return lss.str();
- } else {
- return t_name;
- }
-}
-
-void TableFormatter::dump_unsigned(const char *name, uint64_t u)
-{
- finish_pending_string();
- size_t i = m_vec_index(name);
- m_ss << u;
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-void TableFormatter::dump_int(const char *name, int64_t u)
-{
- finish_pending_string();
- size_t i = m_vec_index(name);
- m_ss << u;
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-void TableFormatter::dump_float(const char *name, double d)
-{
- finish_pending_string();
- size_t i = m_vec_index(name);
- m_ss << d;
-
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-void TableFormatter::dump_string(const char *name, const std::string& s)
-{
- finish_pending_string();
- size_t i = m_vec_index(name);
- m_ss << s;
-
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-void TableFormatter::dump_string_with_attrs(const char *name, const std::string& s, const FormatterAttrs& attrs)
-{
- finish_pending_string();
- size_t i = m_vec_index(name);
-
- std::string attrs_str;
- get_attrs_str(&attrs, attrs_str);
- m_ss << attrs_str << s;
-
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-void TableFormatter::dump_format_va(const char* name, const char *ns, bool quoted, const char *fmt, va_list ap)
-{
- finish_pending_string();
- char buf[LARGE_SIZE];
- vsnprintf(buf, LARGE_SIZE, fmt, ap);
-
- size_t i = m_vec_index(name);
- if (ns) {
- m_ss << ns << "." << buf;
- } else
- m_ss << buf;
-
- m_vec[i].push_back(std::make_pair(get_section_name(name), m_ss.str()));
- m_ss.clear();
- m_ss.str("");
-}
-
-std::ostream& TableFormatter::dump_stream(const char *name)
-{
- finish_pending_string();
- // we don't support this
- m_pending_name = name;
- return m_ss;
-}
-
-int TableFormatter::get_len() const
-{
- // we don't know the size until flush is called
- return 0;
-}
-
-void TableFormatter::write_raw_data(const char *data) {
- // not supported
-}
-
-void TableFormatter::get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str)
-{
- std::stringstream attrs_ss;
-
- for (std::list<std::pair<std::string, std::string> >::const_iterator iter = attrs->attrs.begin();
- iter != attrs->attrs.end(); ++iter) {
- std::pair<std::string, std::string> p = *iter;
- attrs_ss << " " << p.first << "=" << "\"" << p.second << "\"";
- }
-
- attrs_str = attrs_ss.str();
-}
-
-void TableFormatter::finish_pending_string()
-{
- if (m_pending_name.length()) {
- std::string ss = m_ss.str();
- m_ss.clear();
- m_ss.str("");
- std::string pending_name = m_pending_name;
- m_pending_name = "";
- dump_string(pending_name.c_str(), ss);
- }
-}
-
-} // namespace ceph
#include "common/safe_io.h"
#include "common/version.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include <errno.h>
#include <fcntl.h>
#include "common/signal.h"
#include "common/ceph_argparse.h"
#include "common/errno.h"
-#include "common/JSONFormatter.h"
#include "msg/Messenger.h"
#include "mon/MonClient.h"
#include "common/debug.h"
#include "common/errno.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "messages/MClientRequestForward.h"
#include "messages/MMDSMap.h"
#include "common/config.h"
#include "common/cmdparse.h"
#include "common/errno.h"
-#include "common/JSONFormatter.h"
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#include "common/errno.h"
#include "common/perf_counters.h"
#include "common/admin_socket.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "include/color.h"
#include "include/ceph_fs.h"
#include "include/assert.h"
#include "include/stringify.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#define dout_subsys ceph_subsys_paxos
#undef dout_prefix
#include "common/perf_counters.h"
#include <errno.h>
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
-
#include "MonitorDBStore.h"
#include "mon/MonOpRequest.h"
#include "common/blkdev.h"
#include "common/linux_version.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#if defined(__FreeBSD__)
#define O_DSYNC O_SYNC
#include "common/perf_counters.h"
#include "common/sync_filesystem.h"
#include "common/fd.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "HashIndex.h"
#include "DBObjectMap.h"
#include "KeyValueDB.h"
#include "common/Timer.h"
#include "common/WorkQueue.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/Mutex.h"
#include "HashIndex.h"
#include "common/safe_io.h"
#include "common/perf_counters.h"
#include "common/sync_filesystem.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#ifdef HAVE_KINETIC
#include "KineticStore.h"
#include "common/WorkQueue.h"
#include "common/Finisher.h"
#include "common/fd.h"
-#include "common/JSONFormatter.h"
#include "common/Mutex.h"
#include "GenericObjectMap.h"
#include "include/unordered_map.h"
#include "include/memory.h"
#include "common/errno.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "MemStore.h"
#include "include/compat.h"
#include "common/ceph_argparse.h"
#include "common/version.h"
#include "common/io_priority.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "os/ObjectStore.h"
#include "common/config.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/TextTable.h"
#include "include/ceph_features.h"
#include "include/str_map.h"
#include "include/util.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
-#include "common/XMLFormatter.h"
#include "common/Throttle.h"
#if defined(__linux__)
#include "common/config.h"
#include "common/ceph_argparse.h"
#include "common/Formatter.h"
-#include "common/XMLFormatter.h"
-#include "common/JSONFormatter.h"
#include "common/errno.h"
#include "global/global_init.h"
#include <include/types.h>
#include <common/Formatter.h>
-#include <common/XMLFormatter.h>
#include "rgw_xml.h"
#include "rgw_cors.h"
#include "include/types.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/ceph_json.h"
#include "rgw_common.h"
#include "common/utf8.h"
#include "common/OutputDataSocket.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "rgw_log.h"
#include "rgw_acl.h"
#include <limits.h>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
-#include "common/XMLFormatter.h"
#include "common/HTMLFormatter.h"
#include "common/utf8.h"
#include "include/str_list.h"
#include "common/ceph_crypto.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/utf8.h"
#include "common/ceph_json.h"
#include <unistd.h>
#include "common/ceph_json.h"
-#include "common/JSONFormatter.h"
#include "rgw_common.h"
#include "rgw_swift.h"
#include "rgw_swift_auth.h"
#include "common/ceph_crypto.h"
#include "common/Clock.h"
-#include "common/JSONFormatter.h"
#include "auth/Crypto.h"
-Subproject commit dcdb0dd29232ece43f093c99220b0eea7ead51ff
+Subproject commit fa98456ccbd860120127ac2e91a2088fb222606e
#include <fstream>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "bencher.h"
#include "rados_backend.h"
#include <fstream>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "bencher.h"
#include "rados_backend.h"
#include <fstream>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "bencher.h"
#include "rados_backend.h"
#include <fstream>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "bencher.h"
#include "rbd_backend.h"
#include <fstream>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "bencher.h"
#include "rados_backend.h"
#include "gtest/gtest.h"
-#include "common/TableFormatter.h"
+#include "common/Formatter.h"
#include <iostream>
#include <sstream>
#include <string>
#include "include/stringify.h"
#include "common/ceph_argparse.h"
-#include "common/JSONFormatter.h"
#include "global/global_init.h"
#include "global/global_context.h"
#include "include/ceph_features.h"
#include "common/ceph_argparse.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/errno.h"
#include "msg/Message.h"
#include "include/assert.h"
*/
#include "test/unit.h"
-#include "common/JSONFormatter.h"
-#include "common/XMLFormatter.h"
+#include "common/Formatter.h"
#include "common/HTMLFormatter.h"
#include <sstream>
#include "global/global_context.h"
#include "common/Mutex.h"
#include "common/Cond.h"
-#include "common/JSONFormatter.h"
#include <string>
#include <climits>
#include "auth/AuthAuthorizeHandler.h"
#include "include/uuid.h"
#include "include/assert.h"
-#include "common/JSONFormatter.h"
#include "messages/MOSDBoot.h"
#include "messages/MOSDAlive.h"
#include "common/code_environment.h"
#include "common/ceph_argparse.h"
#include "common/Finisher.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "global/global_init.h"
#include "rgw/rgw_common.h"
#include "rgw/rgw_rados.h"
#include "common/ceph_argparse.h"
#include "global/global_init.h"
-#include "common/JSONFormatter.h"
+#include "common/Formatter.h"
#include "common/debug.h"
#include "common/errno.h"
#include "client/Inode.h"
#include <stdlib.h>
#include <string>
-#include "common/JSONFormatter.h"
+#include "common/Formatter.h"
#include "common/errno.h"
#include "global/global_init.h"
#include <stdlib.h>
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "common/errno.h"
#include "common/ceph_argparse.h"
#include <fstream>
#include "common/errno.h"
-#include "common/JSONFormatter.h"
#include "mds/mdstypes.h"
#include "mds/events/EUpdate.h"
#include "mds/LogEvent.h"
#include "common/ceph_argparse.h"
#include "common/errno.h"
-#include "common/JSONFormatter.h"
#include "osdc/Journaler.h"
#include "mds/mdstypes.h"
#include "mds/LogEvent.h"
#include "common/ceph_argparse.h"
#include "common/errno.h"
-#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
#include "mds/SessionMap.h"
#include "mds/InoTable.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/Formatter.h"
-#include "common/JSONFormatter.h"
-#include "common/XMLFormatter.h"
#include "common/obj_bencher.h"
#include "mds/inode_backtrace.h"
#include "auth/Crypto.h"
projects / ceph.git / commitdiff