diff options
59 files changed, 1092 insertions, 884 deletions
diff --git a/cmake/modules/BuildSPDK.cmake b/cmake/modules/BuildSPDK.cmake index 0a6acc8d059..d6ce97e1d2e 100644 --- a/cmake/modules/BuildSPDK.cmake +++ b/cmake/modules/BuildSPDK.cmake @@ -68,12 +68,14 @@ macro(build_spdk) add_dependencies(${spdk_lib} spdk-ext) endforeach() - set_target_properties(spdk::env_dpdk PROPERTIES - INTERFACE_LINK_LIBRARIES "dpdk::dpdk;rt") - set_target_properties(spdk::lvol PROPERTIES - INTERFACE_LINK_LIBRARIES spdk::util) - set_target_properties(spdk::util PROPERTIES - INTERFACE_LINK_LIBRARIES ${UUID_LIBRARIES}) set(SPDK_INCLUDE_DIR "${source_dir}/include") + add_library(spdk::spdk INTERFACE IMPORTED) + add_dependencies(spdk::spdk + ${SPDK_LIBRARIES}) + # workaround for https://review.spdk.io/gerrit/c/spdk/spdk/+/6798 + set_target_properties(spdk::spdk PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES ${SPDK_INCLUDE_DIR} + INTERFACE_LINK_LIBRARIES + "-Wl,--whole-archive $<JOIN:${spdk_libs}, > -Wl,--no-whole-archive;dpdk::dpdk;rt;${UUID_LIBRARIES}") unset(source_dir) endmacro() diff --git a/doc/cephfs/createfs.rst b/doc/cephfs/createfs.rst index 537a46b25d5..8af1d9a44f4 100644 --- a/doc/cephfs/createfs.rst +++ b/doc/cephfs/createfs.rst @@ -6,19 +6,22 @@ Creating pools ============== A Ceph file system requires at least two RADOS pools, one for data and one for metadata. -When configuring these pools, you might consider: - -- Using a higher replication level for the metadata pool, as any data loss in - this pool can render the whole file system inaccessible. -- Using lower-latency storage such as SSDs for the metadata pool, as this will - directly affect the observed latency of file system operations on clients. +There are important considerations when planning these pools: + +- We recommend configuring *at least* 3 replicas for the metadata pool, + as data loss in this pool can render the entire file system inaccessible. + Configuring 4 would not be extreme, especially since the metadata pool's + capacity requirements are quite modest. +- We recommend the fastest feasible low-latency storage devices (NVMe, Optane, + or at the very least SAS/SATA SSD) for the metadata pool, as this will + directly affect the latency of client file system operations. - The data pool used to create the file system is the "default" data pool and - the location for storing all inode backtrace information, used for hard link - management and disaster recovery. For this reason, all inodes created in - CephFS have at least one object in the default data pool. If erasure-coded - pools are planned for the file system, it is usually better to use a - replicated pool for the default data pool to improve small-object write and - read performance for updating backtraces. Separately, another erasure-coded + the location for storing all inode backtrace information, which is used for hard link + management and disaster recovery. For this reason, all CephFS inodes + have at least one object in the default data pool. If erasure-coded + pools are planned for file system data, it is best to configure the default as + a replicated pool to improve small-object write and + read performance when updating backtraces. Separately, another erasure-coded data pool can be added (see also :ref:`ecpool`) that can be used on an entire hierarchy of directories and files (see also :ref:`file-layouts`). @@ -31,7 +34,7 @@ might run the following commands: $ ceph osd pool create cephfs_data $ ceph osd pool create cephfs_metadata -Generally, the metadata pool will have at most a few gigabytes of data. For +The metadata pool will typically hold at most a few gigabytes of data. For this reason, a smaller PG count is usually recommended. 64 or 128 is commonly used in practice for large clusters. @@ -94,7 +97,7 @@ You may use Erasure Coded pools as CephFS data pools as long as they have overwr ceph osd pool set my_ec_pool allow_ec_overwrites true -Note that EC overwrites are only supported when using OSDS with the BlueStore backend. +Note that EC overwrites are only supported when using OSDs with the BlueStore backend. You may not use Erasure Coded pools as CephFS metadata pools, because CephFS metadata is stored using RADOS *OMAP* data structures, which EC pools cannot store. diff --git a/doc/governance.rst b/doc/governance.rst index 8612bcc0c6a..4aaaf4d6269 100644 --- a/doc/governance.rst +++ b/doc/governance.rst @@ -52,6 +52,7 @@ the CLT itself. Current CLT members are: + * Adam King <adking@redhat.com> * Casey Bodley <cbodley@redhat.com> * Dan van der Ster <daniel.vanderster@cern.ch> * David Galloway <dgallowa@redhat.com> @@ -73,7 +74,6 @@ Current CLT members are: * Patrick Donnelly <pdonnell@redhat.com> * Sage Weil <sage@redhat.com> * Sam Just <sjust@redhat.com> - * Sebastian Wagner <sewagner@redhat.com> * Xie Xingguo <xie.xingguo@zte.com.cn> * Yehuda Sadeh <yehuda@redhat.com> * Yuri Weinstein <yweinste@redhat.com> diff --git a/doc/man/8/radosgw-admin.rst b/doc/man/8/radosgw-admin.rst index 57d7fcfc902..042d1f3391e 100644 --- a/doc/man/8/radosgw-admin.rst +++ b/doc/man/8/radosgw-admin.rst @@ -997,11 +997,11 @@ Rename a bucket:: Move a bucket from the old global tenant space to a specified tenant:: - $ radosgw-admin bucket link --bucket=/foo --uid=12345678$12345678' + $ radosgw-admin bucket link --bucket=/foo --uid='12345678$12345678' Link bucket to specified user and change object ACLs:: - $ radosgw-admin bucket chown --bucket=/foo --uid=12345678$12345678' + $ radosgw-admin bucket chown --bucket=/foo --uid='12345678$12345678' Show the logs of a bucket from April 1st, 2012:: diff --git a/qa/suites/rgw/crypt/2-kms/kmip.yaml b/qa/suites/rgw/crypt/2-kms/kmip.yaml index 4b2a13f4278..0057d954e32 100644 --- a/qa/suites/rgw/crypt/2-kms/kmip.yaml +++ b/qa/suites/rgw/crypt/2-kms/kmip.yaml @@ -3,9 +3,9 @@ overrides: conf: client: rgw crypt s3 kms backend: kmip - rgw crypt kmip ca path: /home/ubuntu/cephtest/ca/kmiproot.crt - rgw crypt kmip client cert: /home/ubuntu/cephtest/ca/kmip-client.crt - rgw crypt kmip client key: /home/ubuntu/cephtest/ca/kmip-client.key + rgw crypt kmip ca path: /etc/ceph/kmiproot.crt + rgw crypt kmip client cert: /etc/ceph/kmip-client.crt + rgw crypt kmip client key: /etc/ceph/kmip-client.key rgw crypt kmip kms key template: pykmip-$keyid rgw: client.0: diff --git a/qa/tasks/rgw.py b/qa/tasks/rgw.py index 693d3d4d6d7..3d2542981b1 100644 --- a/qa/tasks/rgw.py +++ b/qa/tasks/rgw.py @@ -150,6 +150,35 @@ def start_rgw(ctx, config, clients): '--rgw_crypt_kmip_addr', "{}:{}".format(*ctx.pykmip.endpoints[pykmip_role]), ]) + clientcert = ctx.ssl_certificates.get('kmip-client') + servercert = ctx.ssl_certificates.get('kmip-server') + clientca = ctx.ssl_certificates.get('kmiproot') + + clientkey = clientcert.key + clientcert = clientcert.certificate + serverkey = servercert.key + servercert = servercert.certificate + rootkey = clientca.key + rootcert = clientca.certificate + + cert_path = '/etc/ceph/' + ctx.cluster.only(client).run(args=['sudo', 'cp', clientcert, cert_path]) + ctx.cluster.only(client).run(args=['sudo', 'cp', clientkey, cert_path]) + ctx.cluster.only(client).run(args=['sudo', 'cp', servercert, cert_path]) + ctx.cluster.only(client).run(args=['sudo', 'cp', serverkey, cert_path]) + ctx.cluster.only(client).run(args=['sudo', 'cp', rootkey, cert_path]) + ctx.cluster.only(client).run(args=['sudo', 'cp', rootcert, cert_path]) + + clientcert = cert_path + 'kmip-client.crt' + clientkey = cert_path + 'kmip-client.key' + servercert = cert_path + 'kmip-server.crt' + serverkey = cert_path + 'kmip-server.key' + rootkey = cert_path + 'kmiproot.key' + rootcert = cert_path + 'kmiproot.crt' + + ctx.cluster.only(client).run(args=['sudo', 'chmod', '600', clientcert, clientkey, servercert, serverkey, rootkey, rootcert]) + ctx.cluster.only(client).run(args=['sudo', 'chown', 'ceph', clientcert, clientkey, servercert, serverkey, rootkey, rootcert]) + rgw_cmd.extend([ '--foreground', run.Raw('|'), diff --git a/src/blk/CMakeLists.txt b/src/blk/CMakeLists.txt index aaebc3c99f0..37b9c0a410c 100644 --- a/src/blk/CMakeLists.txt +++ b/src/blk/CMakeLists.txt @@ -35,7 +35,8 @@ if(HAVE_LIBAIO) endif(HAVE_LIBAIO) if(WITH_SPDK) - target_link_libraries(blk PRIVATE ${SPDK_LIBRARIES}) + target_link_libraries(blk + PRIVATE spdk::spdk) endif() if(WITH_ZBD) diff --git a/src/ceph-volume/ceph_volume/tests/util/test_disk.py b/src/ceph-volume/ceph_volume/tests/util/test_disk.py index 44f19e036fa..6b178eabdbb 100644 --- a/src/ceph-volume/ceph_volume/tests/util/test_disk.py +++ b/src/ceph-volume/ceph_volume/tests/util/test_disk.py @@ -331,6 +331,15 @@ class TestGetDevices(object): result = disk.get_devices(_sys_block_path=block_path) assert result[sda_path]['rotational'] == '1' + def test_is_ceph_rbd(self, tmpfile, tmpdir, patched_get_block_devs_lsblk): + rbd_path = '/dev/rbd0' + patched_get_block_devs_lsblk.return_value = [[rbd_path, rbd_path, 'disk']] + block_path = self.setup_path(tmpdir) + block_rbd_path = os.path.join(block_path, 'rbd0') + os.makedirs(block_rbd_path) + result = disk.get_devices(_sys_block_path=block_path) + assert rbd_path not in result + class TestSizeCalculations(object): diff --git a/src/ceph-volume/ceph_volume/util/disk.py b/src/ceph-volume/ceph_volume/util/disk.py index 88db0513817..8a47061ef91 100644 --- a/src/ceph-volume/ceph_volume/util/disk.py +++ b/src/ceph-volume/ceph_volume/util/disk.py @@ -361,6 +361,13 @@ def is_partition(dev): return False +def is_ceph_rbd(dev): + """ + Boolean to determine if a given device is a ceph RBD device, like /dev/rbd0 + """ + return dev.startswith(('/dev/rbd')) + + class BaseFloatUnit(float): """ Base class to support float representations of size values. Suffix is @@ -764,6 +771,10 @@ def get_devices(_sys_block_path='/sys/block'): sysdir = os.path.join(_sys_block_path, devname) metadata = {} + # If the device is ceph rbd it gets excluded + if is_ceph_rbd(diskname): + continue + # If the mapper device is a logical volume it gets excluded if is_mapper_device(diskname): if lvm.get_device_lvs(diskname): diff --git a/src/crimson/admin/admin_socket.cc b/src/crimson/admin/admin_socket.cc index 1593123eb00..de7db209d2e 100644 --- a/src/crimson/admin/admin_socket.cc +++ b/src/crimson/admin/admin_socket.cc @@ -21,6 +21,7 @@ #include "crimson/net/Socket.h" using namespace crimson::common; +using namespace std::literals; namespace { seastar::logger& logger() diff --git a/src/crimson/admin/admin_socket.h b/src/crimson/admin/admin_socket.h index a7540a6071f..8bf9fd4d301 100644 --- a/src/crimson/admin/admin_socket.h +++ b/src/crimson/admin/admin_socket.h @@ -22,8 +22,6 @@ #include "include/buffer.h" #include "crimson/net/Fwd.h" -using namespace std::literals; - class MCommand; namespace crimson::admin { diff --git a/src/crimson/admin/osd_admin.cc b/src/crimson/admin/osd_admin.cc index e8320458834..97c7f9a2992 100644 --- a/src/crimson/admin/osd_admin.cc +++ b/src/crimson/admin/osd_admin.cc @@ -24,6 +24,7 @@ seastar::logger& logger() } } // namespace +using namespace std::literals; using std::string_view; using std::unique_ptr; using crimson::osd::OSD; diff --git a/src/crimson/os/alienstore/alien_store.h b/src/crimson/os/alienstore/alien_store.h index 3c4dfa154ae..7a3db432f87 100644 --- a/src/crimson/os/alienstore/alien_store.h +++ b/src/crimson/os/alienstore/alien_store.h @@ -134,7 +134,6 @@ private: // number of cores that are PREVENTED from being scheduled // to run alien store threads. static constexpr int N_CORES_FOR_SEASTAR = 3; - constexpr static unsigned MAX_KEYS_PER_OMAP_GET_CALL = 32; mutable std::unique_ptr<crimson::os::ThreadPool> tp; const std::string type; const std::string path; diff --git a/src/crimson/osd/main.cc b/src/crimson/osd/main.cc index a7afaee66a3..69eaf52097e 100644 --- a/src/crimson/osd/main.cc +++ b/src/crimson/osd/main.cc @@ -28,6 +28,7 @@ #include "osd.h" +using namespace std::literals; namespace bpo = boost::program_options; using config_t = crimson::common::ConfigProxy; using std::string; diff --git a/src/include/neorados/RADOS.hpp b/src/include/neorados/RADOS.hpp index 244442bcf60..fa1ac92ae51 100644 --- a/src/include/neorados/RADOS.hpp +++ b/src/include/neorados/RADOS.hpp @@ -60,8 +60,6 @@ #include "common/ceph_time.h" namespace neorados { -using namespace std::literals; - class Object; class IOContext; } @@ -186,7 +184,7 @@ private: std::aligned_storage_t<impl_size> impl; }; -inline constexpr std::string_view all_nspaces("\001"sv); +inline constexpr std::string_view all_nspaces("\001"); enum class cmpxattr_op : std::uint8_t { eq = 1, diff --git a/src/mgr/ActivePyModules.h b/src/mgr/ActivePyModules.h index 2547c256538..0469c4755e9 100644 --- a/src/mgr/ActivePyModules.h +++ b/src/mgr/ActivePyModules.h @@ -56,14 +56,14 @@ class ActivePyModules Objecter &objecter; Client &client; Finisher &finisher; - TTLCache<string, PyObject*> ttl_cache; + TTLCache<std::string, PyObject*> ttl_cache; public: Finisher cmd_finisher; private: DaemonServer &server; PyModuleRegistry &py_module_registry; - map<std::string,ProgressEvent> progress_events; + std::map<std::string,ProgressEvent> progress_events; mutable ceph::mutex lock = ceph::make_mutex("ActivePyModules::lock"); diff --git a/src/mgr/CMakeLists.txt b/src/mgr/CMakeLists.txt index a53d1d8c2a0..b11c40c42bc 100644 --- a/src/mgr/CMakeLists.txt +++ b/src/mgr/CMakeLists.txt @@ -34,6 +34,7 @@ if(WITH_MGR) mgr_commands.cc $<TARGET_OBJECTS:mgr_cap_obj>) add_executable(ceph-mgr ${mgr_srcs}) + target_compile_definitions(ceph-mgr PRIVATE PY_SSIZE_T_CLEAN) if(WITH_LIBCEPHSQLITE) target_link_libraries(ceph-mgr cephsqlite SQLite3::SQLite3) endif() diff --git a/src/mgr/TTLCache.h b/src/mgr/TTLCache.h index a6d5ddf2e2d..d29b787bbf6 100644 --- a/src/mgr/TTLCache.h +++ b/src/mgr/TTLCache.h @@ -10,8 +10,6 @@ #include "PyUtil.h" -using namespace std; - template <class Key, class Value> class Cache { private: std::atomic<uint64_t> hits, misses; @@ -20,7 +18,7 @@ template <class Key, class Value> class Cache { unsigned int capacity; Cache(unsigned int size = UINT16_MAX) : hits{0}, misses{0}, capacity{size} {}; std::map<Key, Value> content; - std::vector<string> allowed_keys = {"osd_map", "pg_dump", "pg_stats"}; + std::vector<std::string> allowed_keys = {"osd_map", "pg_dump", "pg_stats"}; void mark_miss() { misses++; diff --git a/src/neorados/RADOS.cc b/src/neorados/RADOS.cc index 1784a939dac..93f02b1ae70 100644 --- a/src/neorados/RADOS.cc +++ b/src/neorados/RADOS.cc @@ -37,6 +37,8 @@ #include "neorados/RADOSImpl.h" #include "include/neorados/RADOS.hpp" +using namespace std::literals; + namespace bc = boost::container; namespace bs = boost::system; namespace ca = ceph::async; diff --git a/src/osd/scrubber/scrub_machine.h b/src/osd/scrubber/scrub_machine.h index d9132eedca8..d4fc0f8359a 100644 --- a/src/osd/scrubber/scrub_machine.h +++ b/src/osd/scrubber/scrub_machine.h @@ -20,8 +20,6 @@ #include "scrub_machine_lstnr.h" #include "osd/scrubber_common.h" -using namespace std::string_literals; - class PG; // holding a pointer to that one - just for testing class PgScrubber; namespace Scrub { diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc index 80262c20cd9..6d10387fb35 100644 --- a/src/rgw/rgw_admin.cc +++ b/src/rgw/rgw_admin.cc @@ -8307,7 +8307,13 @@ next: } auto num_shards = g_conf()->rgw_md_log_max_shards; - ret = crs.run(dpp(), create_admin_meta_log_trim_cr(dpp(), static_cast<rgw::sal::RadosStore*>(store), &http, num_shards)); + auto mltcr = create_admin_meta_log_trim_cr( + dpp(), static_cast<rgw::sal::RadosStore*>(store), &http, num_shards); + if (!mltcr) { + cerr << "Cluster misconfigured! Unable to trim." << std::endl; + return -EIO; + } + ret = crs.run(dpp(), mltcr); if (ret < 0) { cerr << "automated mdlog trim failed with " << cpp_strerror(ret) << std::endl; return -ret; diff --git a/src/rgw/rgw_object_expirer.cc b/src/rgw/rgw_object_expirer.cc index e2e82ad58b1..1fd940533c5 100644 --- a/src/rgw/rgw_object_expirer.cc +++ b/src/rgw/rgw_object_expirer.cc @@ -55,7 +55,7 @@ int main(const int argc, const char **argv) { auto args = argv_to_vec(argc, argv); if (args.empty()) { - cerr << argv[0] << ": -h or --help for usage" << std::endl; + std::cerr << argv[0] << ": -h or --help for usage" << std::endl; exit(1); } if (ceph_argparse_need_usage(args)) { diff --git a/src/rgw/rgw_object_expirer_core.h b/src/rgw/rgw_object_expirer_core.h index 68b65653ba4..c02ca5ea9df 100644 --- a/src/rgw/rgw_object_expirer_core.h +++ b/src/rgw/rgw_object_expirer_core.h @@ -32,8 +32,6 @@ #include "rgw_sal.h" #include "rgw_sal_rados.h" -using namespace std; - class RGWSI_RADOS; class RGWSI_Zone; class RGWBucketInfo; @@ -50,27 +48,27 @@ public: int objexp_hint_add(const DoutPrefixProvider *dpp, const ceph::real_time& delete_at, - const string& tenant_name, - const string& bucket_name, - const string& bucket_id, + const std::string& tenant_name, + const std::string& bucket_name, + const std::string& bucket_id, const rgw_obj_index_key& obj_key); int objexp_hint_list(const DoutPrefixProvider *dpp, - const string& oid, + const std::string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time, const int max_entries, - const string& marker, - list<cls_timeindex_entry>& entries, /* out */ - string *out_marker, /* out */ + const std::string& marker, + std::list<cls_timeindex_entry>& entries, /* out */ + std::string *out_marker, /* out */ bool *truncated); /* out */ int objexp_hint_trim(const DoutPrefixProvider *dpp, - const string& oid, + const std::string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time, - const string& from_marker, - const string& to_marker); + const std::string& from_marker, + const std::string& to_marker); }; class RGWObjectExpirer { @@ -95,8 +93,8 @@ protected: void stop(); CephContext *get_cct() const override; - unsigned get_subsys() const; - std::ostream& gen_prefix(std::ostream& out) const; + unsigned get_subsys() const override; + std::ostream& gen_prefix(std::ostream& out) const override; }; OEWorker *worker{nullptr}; @@ -114,9 +112,9 @@ public: int hint_add(const DoutPrefixProvider *dpp, const ceph::real_time& delete_at, - const string& tenant_name, - const string& bucket_name, - const string& bucket_id, + const std::string& tenant_name, + const std::string& bucket_name, + const std::string& bucket_id, const rgw_obj_index_key& obj_key) { return exp_store.objexp_hint_add(dpp, delete_at, tenant_name, bucket_name, bucket_id, obj_key); @@ -132,8 +130,8 @@ public: const std::string& shard, const utime_t& from, const utime_t& to, - const string& from_marker, - const string& to_marker); + const std::string& from_marker, + const std::string& to_marker); bool process_single_shard(const DoutPrefixProvider *dpp, const std::string& shard, diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc index 680da9f4fc4..d90b4bcae91 100644 --- a/src/rgw/rgw_rados.cc +++ b/src/rgw/rgw_rados.cc @@ -52,8 +52,6 @@ #include "common/Clock.h" -using namespace librados; - #include <string> #include <iostream> #include <vector> @@ -101,6 +99,8 @@ using namespace librados; #define dout_context g_ceph_context #define dout_subsys ceph_subsys_rgw +using namespace std; +using namespace librados; static string shadow_ns = "shadow"; static string default_bucket_index_pool_suffix = "rgw.buckets.index"; @@ -611,10 +611,16 @@ public: } int process(const DoutPrefixProvider *dpp) override { list<RGWCoroutinesStack*> stacks; + auto metatrimcr = create_meta_log_trim_cr(this, static_cast<rgw::sal::RadosStore*>(store), &http, + cct->_conf->rgw_md_log_max_shards, + trim_interval); + if (!metatrimcr) { + ldpp_dout(dpp, -1) << "Bailing out of trim thread!" << dendl; + return -EINVAL; + } auto meta = new RGWCoroutinesStack(store->ctx(), &crs); - meta->call(create_meta_log_trim_cr(this, static_cast<rgw::sal::RadosStore*>(store), &http, - cct->_conf->rgw_md_log_max_shards, - trim_interval)); + meta->call(metatrimcr); + stacks.push_back(meta); if (store->svc()->zone->sync_module_exports_data()) { diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc index f646d94357d..947ba8909f9 100644 --- a/src/rgw/rgw_sal_dbstore.cc +++ b/src/rgw/rgw_sal_dbstore.cc @@ -28,6 +28,8 @@ #define dout_subsys ceph_subsys_rgw +using namespace std; + namespace rgw::sal { int DBUser::list_buckets(const DoutPrefixProvider *dpp, const string& marker, diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h index 49c1bc4340b..c5b85095041 100644 --- a/src/rgw/rgw_sal_dbstore.h +++ b/src/rgw/rgw_sal_dbstore.h @@ -110,7 +110,7 @@ protected: virtual int complete_flush_stats(const DoutPrefixProvider *dpp, optional_yield y) override; virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries, bool* is_truncated, RGWUsageIter& usage_iter, - map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; + std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override; /* Placeholders */ @@ -205,7 +205,7 @@ protected: virtual int try_refresh_info(const DoutPrefixProvider *dpp, ceph::real_time *pmtime) override; virtual int read_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries, bool *is_truncated, RGWUsageIter& usage_iter, - map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; + std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override; virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override; virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override; @@ -219,12 +219,12 @@ protected: const std::string& oid, std::optional<std::string> upload_id, ACLOwner owner={}, ceph::real_time mtime=ceph::real_clock::now()) override; virtual int list_multiparts(const DoutPrefixProvider *dpp, - const string& prefix, - string& marker, - const string& delim, + const std::string& prefix, + std::string& marker, + const std::string& delim, const int& max_uploads, - vector<std::unique_ptr<MultipartUpload>>& uploads, - map<string, bool> *common_prefixes, + std::vector<std::unique_ptr<MultipartUpload>>& uploads, + std::map<std::string, bool> *common_prefixes, bool *is_truncated) override; virtual int abort_multiparts(const DoutPrefixProvider* dpp, CephContext* cct) override; @@ -620,13 +620,13 @@ protected: const rgw_placement_rule *ptail_placement_rule; uint64_t olh_epoch; std::unique_ptr<rgw::sal::Object> head_obj; - string upload_id; - string oid; /* object->name() + "." + "upload_id" + "." + part_num */ + std::string upload_id; + std::string oid; /* object->name() + "." + "upload_id" + "." + part_num */ std::unique_ptr<rgw::sal::Object> meta_obj; DB::Object op_target; DB::Object::Write parent_op; int part_num; - string part_num_str; + std::string part_num_str; uint64_t total_data_size = 0; /* for total data being uploaded */ bufferlist head_data; bufferlist tail_part_data; @@ -671,7 +671,7 @@ public: * multiple db handles (for eg., one for each tenant), * use dbsm->getDB(tenant) */ DB *db; - string luarocks_path; + std::string luarocks_path; DBZone zone; RGWSyncModuleInstanceRef sync_module; RGWLC* lc; @@ -728,13 +728,13 @@ public: virtual RGWLC* get_rgwlc(void) override; virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return NULL; } - virtual int log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info) override; + virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info) override; virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) override; - virtual int register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type, - const map<string, string>& meta) override; + virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type, + const std::map<std::string, std::string>& meta) override; virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) override; virtual void get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota) override; - virtual int set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled) override; + virtual int set_buckets_enabled(const DoutPrefixProvider *dpp, std::vector<rgw_bucket>& buckets, bool enabled) override; virtual uint64_t get_new_req_id() override { return 0; } virtual int get_sync_policy_handler(const DoutPrefixProvider *dpp, std::optional<rgw_zone_id> zone, @@ -742,20 +742,20 @@ public: RGWBucketSyncPolicyHandlerRef *phandler, optional_yield y) override; virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override; - virtual void wakeup_meta_sync_shards(set<int>& shard_ids) override { return; } - virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, map<int, set<string> >& shard_ids) override { return; } + virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override { return; } + virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, std::map<int, std::set<std::string>>& shard_ids) override { return; } virtual int clear_usage(const DoutPrefixProvider *dpp) override { return 0; } virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries, bool *is_truncated, RGWUsageIter& usage_iter, - map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; + std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override; virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override; virtual int get_config_key_val(std::string name, bufferlist* bl) override; virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) override; - virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<std::string>& keys, bool* truncated) override; + virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) override; virtual void meta_list_keys_complete(void* handle) override; virtual std::string meta_get_marker(void *handle) override; - virtual int meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y) override; + virtual int meta_remove(const DoutPrefixProvider *dpp, std::string& metadata_key, optional_yield y) override; virtual const RGWSyncModuleInstanceRef& get_sync_module() { return sync_module; } virtual std::string get_host_id() { return ""; } @@ -772,11 +772,11 @@ public: optional_yield y, const std::string& path_prefix, const std::string& tenant, - vector<std::unique_ptr<RGWRole>>& roles) override; + std::vector<std::unique_ptr<RGWRole>>& roles) override; virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override; virtual int get_oidc_providers(const DoutPrefixProvider *dpp, const std::string& tenant, - vector<std::unique_ptr<RGWOIDCProvider>>& providers) override; + std::vector<std::unique_ptr<RGWOIDCProvider>>& providers) override; virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, std::unique_ptr<rgw::sal::Object> _head_obj, @@ -814,7 +814,7 @@ public: void setDB(DB * st) { db = st; } DB *getDB(void) { return db; } - DB *getDB(string tenant) { return dbsm->getDB(tenant, false); } + DB *getDB(std::string tenant) { return dbsm->getDB(tenant, false); } }; } } // namespace rgw::sal diff --git a/src/rgw/rgw_trim_mdlog.cc b/src/rgw/rgw_trim_mdlog.cc index cb4b28bb475..4ddde03363d 100644 --- a/src/rgw/rgw_trim_mdlog.cc +++ b/src/rgw/rgw_trim_mdlog.cc @@ -677,9 +677,48 @@ class MetaPeerTrimPollCR : public MetaTrimPollCR { {} }; +namespace { +bool sanity_check_endpoints(const DoutPrefixProvider *dpp, rgw::sal::RadosStore* store) { + bool retval = true; + auto current = store->svc()->mdlog->get_period_history()->get_current(); + const auto& period = current.get_period(); + for (const auto& [_, zonegroup] : period.get_map().zonegroups) { + if (zonegroup.endpoints.empty()) { + ldpp_dout(dpp, -1) + << __PRETTY_FUNCTION__ << ":" << __LINE__ + << " WARNING: Cluster is is misconfigured! " + << " Zonegroup " << zonegroup.get_name() + << " (" << zonegroup.get_id() << ") in Realm " + << period.get_realm_name() << " ( " << period.get_realm() << ") " + << " has no endpoints!" << dendl; + } + for (const auto& [_, zone] : zonegroup.zones) { + if (zone.endpoints.empty()) { + ldpp_dout(dpp, -1) + << __PRETTY_FUNCTION__ << ":" << __LINE__ + << " ERROR: Cluster is is misconfigured! " + << " Zone " << zone.name << " (" << zone.id << ") in Zonegroup " + << zonegroup.get_name() << " ( " << zonegroup.get_id() + << ") in Realm " << period.get_realm_name() + << " ( " << period.get_realm() << ") " + << " has no endpoints! Trimming is impossible." << dendl; + retval = false; + } + } + } + return retval; +} +} + RGWCoroutine* create_meta_log_trim_cr(const DoutPrefixProvider *dpp, rgw::sal::RadosStore* store, RGWHTTPManager *http, int num_shards, utime_t interval) { + if (!sanity_check_endpoints(dpp, store)) { + ldpp_dout(dpp, -1) + << __PRETTY_FUNCTION__ << ":" << __LINE__ + << " ERROR: Cluster is is misconfigured! Refusing to trim." << dendl; + return nullptr; + } if (store->svc()->zone->is_meta_master()) { return new MetaMasterTrimPollCR(dpp, store, http, num_shards, interval); } @@ -705,6 +744,12 @@ RGWCoroutine* create_admin_meta_log_trim_cr(const DoutPrefixProvider *dpp, rgw:: RGWHTTPManager *http, int num_shards) { + if (!sanity_check_endpoints(dpp, store)) { + ldpp_dout(dpp, -1) + << __PRETTY_FUNCTION__ << ":" << __LINE__ + << " ERROR: Cluster is is misconfigured! Refusing to trim." << dendl; + return nullptr; + } if (store->svc()->zone->is_meta_master()) { return new MetaMasterAdminTrimCR(dpp, store, http, num_shards); } diff --git a/src/rgw/rgw_zone.h b/src/rgw/rgw_zone.h index a84d492e1f5..9e89cbf150a 100644 --- a/src/rgw/rgw_zone.h +++ b/src/rgw/rgw_zone.h @@ -1271,6 +1271,7 @@ public: const rgw_zone_id& get_master_zone() const { return master_zone; } const std::string& get_master_zonegroup() const { return master_zonegroup; } const std::string& get_realm() const { return realm_id; } + const std::string& get_realm_name() const { return realm_name; } const RGWPeriodMap& get_map() const { return period_map; } RGWPeriodConfig& get_config() { return period_config; } const RGWPeriodConfig& get_config() const { return period_config; } diff --git a/src/rgw/store/dbstore/common/dbstore.h b/src/rgw/store/dbstore/common/dbstore.h index 9bb61dca7a9..2fe323d75ff 100644 --- a/src/rgw/store/dbstore/common/dbstore.h +++ b/src/rgw/store/dbstore/common/dbstore.h @@ -24,8 +24,6 @@ #include "rgw/rgw_obj_manifest.h" #include "rgw/rgw_multi.h" -using namespace std; - namespace rgw { namespace store { class DB; @@ -44,9 +42,9 @@ struct DBOpBucketInfo { obj_version bucket_version; ceph::real_time mtime; // used for list query - string min_marker; - string max_marker; - list<RGWBucketEnt> list_entries; + std::string min_marker; + std::string max_marker; + std::list<RGWBucketEnt> list_entries; }; struct DBOpObjectInfo { @@ -67,15 +65,15 @@ struct DBOpObjectInfo { uint64_t versioned_epoch; /* from state.manifest (RGWObjManifest) */ - map<uint64_t, RGWObjManifestPart> objs; + std::map<uint64_t, RGWObjManifestPart> objs; uint64_t head_size{0}; rgw_placement_rule head_placement_rule; uint64_t max_head_size{0}; - string prefix; + std::string prefix; rgw_bucket_placement tail_placement; /* might be different than the original bucket, as object might have been copied across pools */ - map<uint64_t, RGWObjManifestRule> rules; - string tail_instance; /* tail object's instance */ + std::map<uint64_t, RGWObjManifestRule> rules; + std::string tail_instance; /* tail object's instance */ /* Obj's omap <key,value> store */ @@ -86,9 +84,9 @@ struct DBOpObjectInfo { std::list<RGWUploadPartInfo> mp_parts; bufferlist head_data; - string min_marker; - string max_marker; - list<rgw_bucket_dir_entry> list_entries; + std::string min_marker; + std::string max_marker; + std::list<rgw_bucket_dir_entry> list_entries; /* Below used to update mp_parts obj name * from meta object to src object on completion */ rgw_obj_key new_obj_key; @@ -97,34 +95,34 @@ struct DBOpObjectInfo { struct DBOpObjectDataInfo { RGWObjState state; uint64_t part_num; - string multipart_part_str; + std::string multipart_part_str; uint64_t offset; uint64_t size; bufferlist data{}; }; struct DBOpLCHeadInfo { - string index; + std::string index; rgw::sal::Lifecycle::LCHead head; }; struct DBOpLCEntryInfo { - string index; + std::string index; rgw::sal::Lifecycle::LCEntry entry; // used for list query - string min_marker; - list<rgw::sal::Lifecycle::LCEntry> list_entries; + std::string min_marker; + std::list<rgw::sal::Lifecycle::LCEntry> list_entries; }; struct DBOpInfo { - string name; // Op name + std::string name; // Op name /* Support only single access_key for now. So store * it separately as primary access_key_id & secret to * be able to query easily. * * XXX: Swift keys and subuser not supported for now */ DBOpUserInfo user; - string query_str; + std::string query_str; DBOpBucketInfo bucket; DBOpObjectInfo obj; DBOpObjectDataInfo obj_data; @@ -137,19 +135,19 @@ struct DBOpParams { CephContext *cct; /* Tables */ - string user_table; - string bucket_table; - string object_table; + std::string user_table; + std::string bucket_table; + std::string object_table; /* Ops*/ DBOpInfo op; /* Below are subject to change */ - string objectdata_table; - string quota_table; - string lc_head_table; - string lc_entry_table; - string obj; + std::string objectdata_table; + std::string quota_table; + std::string lc_head_table; + std::string lc_entry_table; + std::string obj; }; /* Used for prepared schemas. @@ -163,11 +161,11 @@ struct DBOpParams { * to get the right index of each param. */ struct DBOpUserPrepareInfo { - string user_id = ":user_id"; - string tenant = ":tenant"; - string ns = ":ns"; - string display_name = ":display_name"; - string user_email = ":user_email"; + std::string user_id = ":user_id"; + std::string tenant = ":tenant"; + std::string ns = ":ns"; + std::string display_name = ":display_name"; + std::string user_email = ":user_email"; /* Support only single access_key for now. So store * it separately as primary access_key_id & secret to * be able to query easily. @@ -175,169 +173,169 @@ struct DBOpUserPrepareInfo { * In future, when need to support & query from multiple * access keys, better to maintain them in a separate table. */ - string access_keys_id = ":access_keys_id"; - string access_keys_secret = ":access_keys_secret"; - string access_keys = ":access_keys"; - string swift_keys = ":swift_keys"; - string subusers = ":subusers"; - string suspended = ":suspended"; - string max_buckets = ":max_buckets"; - string op_mask = ":op_mask"; - string user_caps = ":user_caps"; - string admin = ":admin"; - string system = ":system"; - string placement_name = ":placement_name"; - string placement_storage_class = ":placement_storage_class"; - string placement_tags = ":placement_tags"; - string bucket_quota = ":bucket_quota"; - string temp_url_keys = ":temp_url_keys"; - string user_quota = ":user_quota"; - string type = ":type"; - string mfa_ids = ":mfa_ids"; - string assumed_role_arn = ":assumed_role_arn"; - string user_attrs = ":user_attrs"; - string user_ver = ":user_vers"; - string user_ver_tag = ":user_ver_tag"; + std::string access_keys_id = ":access_keys_id"; + std::string access_keys_secret = ":access_keys_secret"; + std::string access_keys = ":access_keys"; + std::string swift_keys = ":swift_keys"; + std::string subusers = ":subusers"; + std::string suspended = ":suspended"; + std::string max_buckets = ":max_buckets"; + std::string op_mask = ":op_mask"; + std::string user_caps = ":user_caps"; + std::string admin = ":admin"; + std::string system = ":system"; + std::string placement_name = ":placement_name"; + std::string placement_storage_class = ":placement_storage_class"; + std::string placement_tags = ":placement_tags"; + std::string bucket_quota = ":bucket_quota"; + std::string temp_url_keys = ":temp_url_keys"; + std::string user_quota = ":user_quota"; + std::string type = ":type"; + std::string mfa_ids = ":mfa_ids"; + std::string assumed_role_arn = ":assumed_role_arn"; + std::string user_attrs = ":user_attrs"; + std::string user_ver = ":user_vers"; + std::string user_ver_tag = ":user_ver_tag"; }; struct DBOpBucketPrepareInfo { - string bucket_name = ":bucket_name"; - string tenant = ":tenant"; - string marker = ":marker"; - string bucket_id = ":bucket_id"; - string size = ":size"; - string size_rounded = ":size_rounded"; - string creation_time = ":creation_time"; - string count = ":count"; - string placement_name = ":placement_name"; - string placement_storage_class = ":placement_storage_class"; + std::string bucket_name = ":bucket_name"; + std::string tenant = ":tenant"; + std::string marker = ":marker"; + std::string bucket_id = ":bucket_id"; + std::string size = ":size"; + std::string size_rounded = ":size_rounded"; + std::string creation_time = ":creation_time"; + std::string count = ":count"; + std::string placement_name = ":placement_name"; + std::string placement_storage_class = ":placement_storage_class"; /* ownerid - maps to DBOpUserPrepareInfo */ - string flags = ":flags"; - string zonegroup = ":zonegroup"; - string has_instance_obj = ":has_instance_obj"; - string quota = ":quota"; - string requester_pays = ":requester_pays"; - string has_website = ":has_website"; - string website_conf = ":website_conf"; - string swift_versioning = ":swift_versioning"; - string swift_ver_location = ":swift_ver_location"; - string mdsearch_config = ":mdsearch_config"; - string new_bucket_instance_id = ":new_bucket_instance_id"; - string obj_lock = ":obj_lock"; - string sync_policy_info_groups = ":sync_policy_info_groups"; - string bucket_attrs = ":bucket_attrs"; - string bucket_ver = ":bucket_vers"; - string bucket_ver_tag = ":bucket_ver_tag"; - string mtime = ":mtime"; - string min_marker = ":min_marker"; - string max_marker = ":max_marker"; + std::string flags = ":flags"; + std::string zonegroup = ":zonegroup"; + std::string has_instance_obj = ":has_instance_obj"; + std::string quota = ":quota"; + std::string requester_pays = ":requester_pays"; + std::string has_website = ":has_website"; + std::string website_conf = ":website_conf"; + std::string swift_versioning = ":swift_versioning"; + std::string swift_ver_location = ":swift_ver_location"; + std::string mdsearch_config = ":mdsearch_config"; + std::string new_bucket_instance_id = ":new_bucket_instance_id"; + std::string obj_lock = ":obj_lock"; + std::string sync_policy_info_groups = ":sync_policy_info_groups"; + std::string bucket_attrs = ":bucket_attrs"; + std::string bucket_ver = ":bucket_vers"; + std::string bucket_ver_tag = ":bucket_ver_tag"; + std::string mtime = ":mtime"; + std::string min_marker = ":min_marker"; + std::string max_marker = ":max_marker"; }; struct DBOpObjectPrepareInfo { - string obj_name = ":obj_name"; - string obj_instance = ":obj_instance"; - string obj_ns = ":obj_ns"; - string acls = ":acls"; - string index_ver = ":index_ver"; - string tag = ":tag"; - string flags = ":flags"; - string versioned_epoch = ":versioned_epoch"; - string obj_category = ":obj_category"; - string etag = ":etag"; - string owner = ":owner"; - string owner_display_name = ":owner_display_name"; - string storage_class = ":storage_class"; - string appendable = ":appendable"; - string content_type = ":content_type"; - string index_hash_source = ":index_hash_source"; - string obj_size = ":obj_size"; - string accounted_size = ":accounted_size"; - string mtime = ":mtime"; - string epoch = ":epoch"; - string obj_tag = ":obj_tag"; - string tail_tag = ":tail_tag"; - string write_tag = ":write_tag"; - string fake_tag = ":fake_tag"; - string shadow_obj = ":shadow_obj"; - string has_data = ":has_data"; - string is_olh = ":is_ols"; - string olh_tag = ":olh_tag"; - string pg_ver = ":pg_ver"; - string zone_short_id = ":zone_short_id"; - string obj_version = ":obj_version"; - string obj_version_tag = ":obj_version_tag"; - string obj_attrs = ":obj_attrs"; - string head_size = ":head_size"; - string max_head_size = ":max_head_size"; - string prefix = ":prefix"; - string tail_instance = ":tail_instance"; - string head_placement_rule_name = ":head_placement_rule_name"; - string head_placement_storage_class = ":head_placement_storage_class"; - string tail_placement_rule_name = ":tail_placement_rule_name"; - string tail_placement_storage_class = ":tail_placement_storage_class"; - string manifest_part_objs = ":manifest_part_objs"; - string manifest_part_rules = ":manifest_part_rules"; - string omap = ":omap"; - string is_multipart = ":is_multipart"; - string mp_parts = ":mp_parts"; - string head_data = ":head_data"; - string min_marker = ":min_marker"; - string max_marker = ":max_marker"; + std::string obj_name = ":obj_name"; + std::string obj_instance = ":obj_instance"; + std::string obj_ns = ":obj_ns"; + std::string acls = ":acls"; + std::string index_ver = ":index_ver"; + std::string tag = ":tag"; + std::string flags = ":flags"; + std::string versioned_epoch = ":versioned_epoch"; + std::string obj_category = ":obj_category"; + std::string etag = ":etag"; + std::string owner = ":owner"; + std::string owner_display_name = ":owner_display_name"; + std::string storage_class = ":storage_class"; + std::string appendable = ":appendable"; + std::string content_type = ":content_type"; + std::string index_hash_source = ":index_hash_source"; + std::string obj_size = ":obj_size"; + std::string accounted_size = ":accounted_size"; + std::string mtime = ":mtime"; + std::string epoch = ":epoch"; + std::string obj_tag = ":obj_tag"; + std::string tail_tag = ":tail_tag"; + std::string write_tag = ":write_tag"; + std::string fake_tag = ":fake_tag"; + std::string shadow_obj = ":shadow_obj"; + std::string has_data = ":has_data"; + std::string is_olh = ":is_ols"; + std::string olh_tag = ":olh_tag"; + std::string pg_ver = ":pg_ver"; + std::string zone_short_id = ":zone_short_id"; + std::string obj_version = ":obj_version"; + std::string obj_version_tag = ":obj_version_tag"; + std::string obj_attrs = ":obj_attrs"; + std::string head_size = ":head_size"; + std::string max_head_size = ":max_head_size"; + std::string prefix = ":prefix"; + std::string tail_instance = ":tail_instance"; + std::string head_placement_rule_name = ":head_placement_rule_name"; + std::string head_placement_storage_class = ":head_placement_storage_class"; + std::string tail_placement_rule_name = ":tail_placement_rule_name"; + std::string tail_placement_storage_class = ":tail_placement_storage_class"; + std::string manifest_part_objs = ":manifest_part_objs"; + std::string manifest_part_rules = ":manifest_part_rules"; + std::string omap = ":omap"; + std::string is_multipart = ":is_multipart"; + std::string mp_parts = ":mp_parts"; + std::string head_data = ":head_data"; + std::string min_marker = ":min_marker"; + std::string max_marker = ":max_marker"; /* Below used to update mp_parts obj name * from meta object to src object on completion */ - string new_obj_name = ":new_obj_name"; - string new_obj_instance = ":new_obj_instance"; - string new_obj_ns = ":new_obj_ns"; + std::string new_obj_name = ":new_obj_name"; + std::string new_obj_instance = ":new_obj_instance"; + std::string new_obj_ns = ":new_obj_ns"; }; struct DBOpObjectDataPrepareInfo { - string part_num = ":part_num"; - string offset = ":offset"; - string data = ":data"; - string size = ":size"; - string multipart_part_str = ":multipart_part_str"; + std::string part_num = ":part_num"; + std::string offset = ":offset"; + std::string data = ":data"; + std::string size = ":size"; + std::string multipart_part_str = ":multipart_part_str"; }; struct DBOpLCEntryPrepareInfo { - string index = ":index"; - string bucket_name = ":bucket_name"; - string start_time = ":start_time"; - string status = ":status"; - string min_marker = ":min_marker"; + std::string index = ":index"; + std::string bucket_name = ":bucket_name"; + std::string start_time = ":start_time"; + std::string status = ":status"; + std::string min_marker = ":min_marker"; }; struct DBOpLCHeadPrepareInfo { - string index = ":index"; - string start_date = ":start_date"; - string marker = ":marker"; + std::string index = ":index"; + std::string start_date = ":start_date"; + std::string marker = ":marker"; }; struct DBOpPrepareInfo { DBOpUserPrepareInfo user; - string query_str = ":query_str"; + std::string query_str = ":query_str"; DBOpBucketPrepareInfo bucket; DBOpObjectPrepareInfo obj; DBOpObjectDataPrepareInfo obj_data; DBOpLCHeadPrepareInfo lc_head; DBOpLCEntryPrepareInfo lc_entry; - string list_max_count = ":list_max_count"; + std::string list_max_count = ":list_max_count"; }; struct DBOpPrepareParams { /* Tables */ - string user_table; - string bucket_table; - string object_table; + std::string user_table; + std::string bucket_table; + std::string object_table; /* Ops */ DBOpPrepareInfo op; /* below subject to change */ - string objectdata_table; - string quota_table; - string lc_head_table; - string lc_entry_table; + std::string objectdata_table; + std::string quota_table; + std::string lc_head_table; + std::string lc_entry_table; }; struct DBOps { @@ -374,13 +372,13 @@ class ObjectOp { class GetObjectDataOp *GetObjectData; class DeleteObjectDataOp *DeleteObjectData; - virtual int InitializeObjectOps(string db_name, const DoutPrefixProvider *dpp) { return 0; } + virtual int InitializeObjectOps(std::string db_name, const DoutPrefixProvider *dpp) { return 0; } virtual int FreeObjectOps(const DoutPrefixProvider *dpp) { return 0; } }; class DBOp { private: - const string CreateUserTableQ = + const std::string CreateUserTableQ = /* Corresponds to rgw::sal::User * * For now only UserID is made Primary key. @@ -426,7 +424,7 @@ class DBOp { UserVersionTag TEXT, \ PRIMARY KEY (UserID) \n);"; - const string CreateBucketTableQ = + const std::string CreateBucketTableQ = /* Corresponds to rgw::sal::Bucket * * For now only BucketName is made Primary key. @@ -481,7 +479,7 @@ class DBOp { FOREIGN KEY (OwnerID) \ REFERENCES '{}' (UserID) ON DELETE CASCADE ON UPDATE CASCADE \n);"; - const string CreateObjectTableQ = + const std::string CreateObjectTableQ = /* Corresponds to rgw::sal::Object * * For now only BucketName, ObjName is made Primary key. @@ -548,11 +546,11 @@ class DBOp { ObjAttrs BLOB, \ HeadSize INTEGER, \ MaxHeadSize INTEGER, \ - Prefix String, \ - TailInstance String, \ - HeadPlacementRuleName String, \ + Prefix std::string, \ + TailInstance std::string, \ + HeadPlacementRuleName std::string, \ HeadPlacementRuleStorageClass String, \ - TailPlacementRuleName String, \ + TailPlacementRuleName std::string, \ TailPlacementStorageClass String, \ ManifestPartObjs BLOB, \ ManifestPartRules BLOB, \ @@ -564,7 +562,7 @@ class DBOp { FOREIGN KEY (BucketName) \ REFERENCES '{}' (BucketName) ON DELETE CASCADE ON UPDATE CASCADE \n);"; - const string CreateObjectDataTableQ = + const std::string CreateObjectDataTableQ = /* Extra field 'MultipartPartStr' added which signifies multipart * <uploadid + partnum>. For regular object, it is '0.0' * @@ -588,7 +586,7 @@ class DBOp { FOREIGN KEY (BucketName, ObjName, ObjInstance) \ REFERENCES '{}' (BucketName, ObjName, ObjInstance) ON DELETE CASCADE ON UPDATE CASCADE \n);"; - const string CreateQuotaTableQ = + const std::string CreateQuotaTableQ = "CREATE TABLE IF NOT EXISTS '{}' ( \ QuotaID INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE , \ MaxSizeSoftThreshold INTEGER , \ @@ -598,7 +596,7 @@ class DBOp { Enabled Boolean , \ CheckOnRaw Boolean \n);"; - const string CreateLCEntryTableQ = + const std::string CreateLCEntryTableQ = "CREATE TABLE IF NOT EXISTS '{}' ( \ LCIndex TEXT NOT NULL , \ BucketName TEXT NOT NULL , \ @@ -608,22 +606,22 @@ class DBOp { FOREIGN KEY (BucketName) \ REFERENCES '{}' (BucketName) ON DELETE CASCADE ON UPDATE CASCADE \n);"; - const string CreateLCHeadTableQ = + const std::string CreateLCHeadTableQ = "CREATE TABLE IF NOT EXISTS '{}' ( \ LCIndex TEXT NOT NULL , \ Marker TEXT , \ StartDate INTEGER , \ PRIMARY KEY (LCIndex) \n);"; - const string DropQ = "DROP TABLE IF EXISTS '{}'"; - const string ListAllQ = "SELECT * from '{}'"; + const std::string DropQ = "DROP TABLE IF EXISTS '{}'"; + const std::string ListAllQ = "SELECT * from '{}'"; public: DBOp() {} virtual ~DBOp() {} std::mutex mtx; // to protect prepared stmt - string CreateTableSchema(string type, DBOpParams *params) { + std::string CreateTableSchema(std::string type, DBOpParams *params) { if (!type.compare("User")) return fmt::format(CreateUserTableQ.c_str(), params->user_table.c_str()); @@ -655,10 +653,10 @@ class DBOp { return NULL; } - string DeleteTableSchema(string table) { + std::string DeleteTableSchema(std::string table) { return fmt::format(DropQ.c_str(), table.c_str()); } - string ListTableSchema(string table) { + std::string ListTableSchema(std::string table) { return fmt::format(ListAllQ.c_str(), table.c_str()); } @@ -680,7 +678,7 @@ class InsertUserOp : virtual public DBOp { * For now using INSERT or REPLACE. If required of updating existing * record, will use another query. */ - const string Query = "INSERT OR REPLACE INTO '{}' \ + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (UserID, Tenant, NS, DisplayName, UserEmail, \ AccessKeysID, AccessKeysSecret, AccessKeys, SwiftKeys,\ SubUsers, Suspended, MaxBuckets, OpMask, UserCaps, Admin, \ @@ -693,7 +691,7 @@ class InsertUserOp : virtual public DBOp { public: virtual ~InsertUserOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.user_table.c_str(), params.op.user.user_id.c_str(), params.op.user.tenant, params.op.user.ns, params.op.user.display_name, params.op.user.user_email, @@ -714,13 +712,13 @@ class InsertUserOp : virtual public DBOp { class RemoveUserOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where UserID = {}"; public: virtual ~RemoveUserOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.user_table.c_str(), params.op.user.user_id.c_str()); } @@ -730,7 +728,7 @@ class GetUserOp: virtual public DBOp { private: /* If below query columns are updated, make sure to update the indexes * in list_user() cbk in sqliteDB.cc */ - const string Query = "SELECT \ + const std::string Query = "SELECT \ UserID, Tenant, NS, DisplayName, UserEmail, \ AccessKeysID, AccessKeysSecret, AccessKeys, SwiftKeys,\ SubUsers, Suspended, MaxBuckets, OpMask, UserCaps, Admin, \ @@ -738,7 +736,7 @@ class GetUserOp: virtual public DBOp { BucketQuota, TempURLKeys, UserQuota, Type, MfaIDs, AssumedRoleARN, \ UserAttrs, UserVersion, UserVersionTag from '{}' where UserID = {}"; - const string QueryByEmail = "SELECT \ + const std::string QueryByEmail = "SELECT \ UserID, Tenant, NS, DisplayName, UserEmail, \ AccessKeysID, AccessKeysSecret, AccessKeys, SwiftKeys,\ SubUsers, Suspended, MaxBuckets, OpMask, UserCaps, Admin, \ @@ -746,7 +744,7 @@ class GetUserOp: virtual public DBOp { BucketQuota, TempURLKeys, UserQuota, Type, MfaIDs, AssumedRoleARN, \ UserAttrs, UserVersion, UserVersionTag from '{}' where UserEmail = {}"; - const string QueryByAccessKeys = "SELECT \ + const std::string QueryByAccessKeys = "SELECT \ UserID, Tenant, NS, DisplayName, UserEmail, \ AccessKeysID, AccessKeysSecret, AccessKeys, SwiftKeys,\ SubUsers, Suspended, MaxBuckets, OpMask, UserCaps, Admin, \ @@ -754,7 +752,7 @@ class GetUserOp: virtual public DBOp { BucketQuota, TempURLKeys, UserQuota, Type, MfaIDs, AssumedRoleARN, \ UserAttrs, UserVersion, UserVersionTag from '{}' where AccessKeysID = {}"; - const string QueryByUserID = "SELECT \ + const std::string QueryByUserID = "SELECT \ UserID, Tenant, NS, DisplayName, UserEmail, \ AccessKeysID, AccessKeysSecret, AccessKeys, SwiftKeys,\ SubUsers, Suspended, MaxBuckets, OpMask, UserCaps, Admin, \ @@ -766,7 +764,7 @@ class GetUserOp: virtual public DBOp { public: virtual ~GetUserOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { if (params.op.query_str == "email") { return fmt::format(QueryByEmail.c_str(), params.user_table.c_str(), params.op.user.user_email.c_str()); @@ -789,7 +787,7 @@ class GetUserOp: virtual public DBOp { class InsertBucketOp: virtual public DBOp { private: - const string Query = + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (BucketName, Tenant, Marker, BucketID, Size, SizeRounded, CreationTime, \ Count, PlacementName, PlacementStorageClass, OwnerID, Flags, Zonegroup, \ @@ -804,7 +802,7 @@ class InsertBucketOp: virtual public DBOp { public: virtual ~InsertBucketOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.bucket_table.c_str(), params.op.bucket.bucket_name, params.op.bucket.tenant, params.op.bucket.marker, params.op.bucket.bucket_id, @@ -826,7 +824,7 @@ class InsertBucketOp: virtual public DBOp { class UpdateBucketOp: virtual public DBOp { private: // Updates Info, Mtime, Version - const string InfoQuery = + const std::string InfoQuery = "UPDATE '{}' SET Tenant = {}, Marker = {}, BucketID = {}, CreationTime = {}, \ Count = {}, PlacementName = {}, PlacementStorageClass = {}, OwnerID = {}, Flags = {}, \ Zonegroup = {}, HasInstanceObj = {}, Quota = {}, RequesterPays = {}, HasWebsite = {}, \ @@ -834,17 +832,17 @@ class UpdateBucketOp: virtual public DBOp { NewBucketInstanceID = {}, ObjectLock = {}, SyncPolicyInfoGroups = {}, \ BucketVersion = {}, Mtime = {} WHERE BucketName = {}"; // Updates Attrs, OwnerID, Mtime, Version - const string AttrsQuery = + const std::string AttrsQuery = "UPDATE '{}' SET OwnerID = {}, BucketAttrs = {}, Mtime = {}, BucketVersion = {} \ WHERE BucketName = {}"; // Updates OwnerID, CreationTime, Mtime, Version - const string OwnerQuery = + const std::string OwnerQuery = "UPDATE '{}' SET OwnerID = {}, CreationTime = {}, Mtime = {}, BucketVersion = {} WHERE BucketName = {}"; public: virtual ~UpdateBucketOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { if (params.op.query_str == "info") { return fmt::format(InfoQuery.c_str(), params.bucket_table.c_str(), params.op.bucket.tenant, params.op.bucket.marker, params.op.bucket.bucket_id, @@ -878,13 +876,13 @@ class UpdateBucketOp: virtual public DBOp { class RemoveBucketOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where BucketName = {}"; public: virtual ~RemoveBucketOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.bucket_table.c_str(), params.op.bucket.bucket_name.c_str()); } @@ -892,7 +890,7 @@ class RemoveBucketOp: virtual public DBOp { class GetBucketOp: virtual public DBOp { private: - const string Query = "SELECT \ + const std::string Query = "SELECT \ BucketName, BucketTable.Tenant, Marker, BucketID, Size, SizeRounded, CreationTime, \ Count, BucketTable.PlacementName, BucketTable.PlacementStorageClass, OwnerID, Flags, Zonegroup, \ HasInstanceObj, Quota, RequesterPays, HasWebsite, WebsiteConf, \ @@ -904,7 +902,7 @@ class GetBucketOp: virtual public DBOp { public: virtual ~GetBucketOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { //return fmt::format(Query.c_str(), params.op.bucket.bucket_name.c_str(), // params.bucket_table.c_str(), params.user_table.c_str()); return fmt::format(Query.c_str(), @@ -917,7 +915,7 @@ class ListUserBucketsOp: virtual public DBOp { private: // once we have stats also stored, may have to update this query to join // these two tables. - const string Query = "SELECT \ + const std::string Query = "SELECT \ BucketName, Tenant, Marker, BucketID, Size, SizeRounded, CreationTime, \ Count, PlacementName, PlacementStorageClass, OwnerID, Flags, Zonegroup, \ HasInstanceObj, Quota, RequesterPays, HasWebsite, WebsiteConf, \ @@ -929,7 +927,7 @@ class ListUserBucketsOp: virtual public DBOp { public: virtual ~ListUserBucketsOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.bucket_table.c_str(), params.op.user.user_id.c_str(), params.op.bucket.min_marker.c_str(), params.op.list_max_count.c_str()); @@ -938,7 +936,7 @@ class ListUserBucketsOp: virtual public DBOp { class PutObjectOp: virtual public DBOp { private: - const string Query = + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (ObjName, ObjInstance, ObjNS, BucketName, ACLs, IndexVer, Tag, \ Flags, VersionedEpoch, ObjCategory, Etag, Owner, OwnerDisplayName, \ @@ -956,7 +954,7 @@ class PutObjectOp: virtual public DBOp { public: virtual ~PutObjectOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.object_table.c_str(), params.op.obj.obj_name, params.op.obj.obj_instance, params.op.obj.obj_ns, @@ -987,13 +985,13 @@ class PutObjectOp: virtual public DBOp { class DeleteObjectOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where BucketName = {} and ObjName = {} and ObjInstance = {}"; public: virtual ~DeleteObjectOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.object_table.c_str(), params.op.bucket.bucket_name.c_str(), params.op.obj.obj_name.c_str(), @@ -1003,7 +1001,7 @@ class DeleteObjectOp: virtual public DBOp { class GetObjectOp: virtual public DBOp { private: - const string Query = + const std::string Query = "SELECT \ ObjName, ObjInstance, ObjNS, BucketName, ACLs, IndexVer, Tag, \ Flags, VersionedEpoch, ObjCategory, Etag, Owner, OwnerDisplayName, \ @@ -1019,7 +1017,7 @@ class GetObjectOp: virtual public DBOp { public: virtual ~GetObjectOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.object_table.c_str(), params.op.bucket.bucket_name.c_str(), @@ -1032,7 +1030,7 @@ class ListBucketObjectsOp: virtual public DBOp { private: // once we have stats also stored, may have to update this query to join // these two tables. - const string Query = + const std::string Query = "SELECT \ ObjName, ObjInstance, ObjNS, BucketName, ACLs, IndexVer, Tag, \ Flags, VersionedEpoch, ObjCategory, Etag, Owner, OwnerDisplayName, \ @@ -1047,7 +1045,7 @@ class ListBucketObjectsOp: virtual public DBOp { public: virtual ~ListBucketObjectsOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { /* XXX: Include prefix, delim */ return fmt::format(Query.c_str(), params.object_table.c_str(), @@ -1060,16 +1058,16 @@ class ListBucketObjectsOp: virtual public DBOp { class UpdateObjectOp: virtual public DBOp { private: // Updates Omap - const string OmapQuery = + const std::string OmapQuery = "UPDATE '{}' SET Omap = {}, Mtime = {} \ where BucketName = {} and ObjName = {} and ObjInstance = {}"; - const string AttrsQuery = + const std::string AttrsQuery = "UPDATE '{}' SET ObjAttrs = {}, Mtime = {} \ where BucketName = {} and ObjName = {} and ObjInstance = {}"; - const string MPQuery = + const std::string MPQuery = "UPDATE '{}' SET MPPartsList = {}, Mtime = {} \ where BucketName = {} and ObjName = {} and ObjInstance = {}"; - const string MetaQuery = + const std::string MetaQuery = "UPDATE '{}' SET \ ObjNS = {}, ACLs = {}, IndexVer = {}, Tag = {}, Flags = {}, VersionedEpoch = {}, \ ObjCategory = {}, Etag = {}, Owner = {}, OwnerDisplayName = {}, \ @@ -1088,7 +1086,7 @@ class UpdateObjectOp: virtual public DBOp { public: virtual ~UpdateObjectOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { if (params.op.query_str == "omap") { return fmt::format(OmapQuery.c_str(), params.object_table.c_str(), params.op.obj.omap.c_str(), @@ -1147,7 +1145,7 @@ class UpdateObjectOp: virtual public DBOp { class PutObjectDataOp: virtual public DBOp { private: - const string Query = + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (ObjName, ObjInstance, ObjNS, BucketName, MultipartPartStr, PartNum, Offset, Size, Data) \ VALUES ({}, {}, {}, {}, {}, {}, {}, {}, {})"; @@ -1155,7 +1153,7 @@ class PutObjectDataOp: virtual public DBOp { public: virtual ~PutObjectDataOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.objectdata_table.c_str(), params.op.obj.obj_name, params.op.obj.obj_instance, @@ -1171,7 +1169,7 @@ class PutObjectDataOp: virtual public DBOp { class UpdateObjectDataOp: virtual public DBOp { private: - const string Query = + const std::string Query = "UPDATE '{}' \ SET ObjName = {}, ObjInstance = {}, ObjNS = {} \ WHERE ObjName = {} and ObjInstance = {} and ObjNS = {} and \ @@ -1180,7 +1178,7 @@ class UpdateObjectDataOp: virtual public DBOp { public: virtual ~UpdateObjectDataOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.objectdata_table.c_str(), params.op.obj.new_obj_name, params.op.obj.new_obj_instance, @@ -1192,7 +1190,7 @@ class UpdateObjectDataOp: virtual public DBOp { }; class GetObjectDataOp: virtual public DBOp { private: - const string Query = + const std::string Query = "SELECT \ ObjName, ObjInstance, ObjNS, BucketName, MultipartPartStr, PartNum, Offset, Size, Data \ from '{}' where BucketName = {} and ObjName = {} and ObjInstance = {} ORDER BY MultipartPartStr, PartNum"; @@ -1200,7 +1198,7 @@ class GetObjectDataOp: virtual public DBOp { public: virtual ~GetObjectDataOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.objectdata_table.c_str(), params.op.bucket.bucket_name.c_str(), @@ -1211,13 +1209,13 @@ class GetObjectDataOp: virtual public DBOp { class DeleteObjectDataOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where BucketName = {} and ObjName = {} and ObjInstance = {}"; public: virtual ~DeleteObjectDataOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.objectdata_table.c_str(), params.op.bucket.bucket_name.c_str(), @@ -1228,7 +1226,7 @@ class DeleteObjectDataOp: virtual public DBOp { class InsertLCEntryOp: virtual public DBOp { private: - const string Query = + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (LCIndex, BucketName, StartTime, Status) \ VALUES ({}, {}, {}, {})"; @@ -1236,7 +1234,7 @@ class InsertLCEntryOp: virtual public DBOp { public: virtual ~InsertLCEntryOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_entry_table.c_str(), params.op.lc_entry.index, params.op.lc_entry.bucket_name, params.op.lc_entry.start_time, params.op.lc_entry.status); @@ -1245,13 +1243,13 @@ class InsertLCEntryOp: virtual public DBOp { class RemoveLCEntryOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where LCIndex = {} and BucketName = {}"; public: virtual ~RemoveLCEntryOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_entry_table.c_str(), params.op.lc_entry.index, params.op.lc_entry.bucket_name); } @@ -1259,17 +1257,17 @@ class RemoveLCEntryOp: virtual public DBOp { class GetLCEntryOp: virtual public DBOp { private: - const string Query = "SELECT \ + const std::string Query = "SELECT \ LCIndex, BucketName, StartTime, Status \ from '{}' where LCIndex = {} and BucketName = {}"; - const string NextQuery = "SELECT \ + const std::string NextQuery = "SELECT \ LCIndex, BucketName, StartTime, Status \ from '{}' where LCIndex = {} and BucketName > {} ORDER BY BucketName ASC"; public: virtual ~GetLCEntryOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { if (params.op.query_str == "get_next_entry") { return fmt::format(NextQuery.c_str(), params.lc_entry_table.c_str(), params.op.lc_entry.index, params.op.lc_entry.bucket_name); @@ -1282,14 +1280,14 @@ class GetLCEntryOp: virtual public DBOp { class ListLCEntriesOp: virtual public DBOp { private: - const string Query = "SELECT \ + const std::string Query = "SELECT \ LCIndex, BucketName, StartTime, Status \ FROM '{}' WHERE LCIndex = {} AND BucketName > {} ORDER BY BucketName ASC LIMIT {}"; public: virtual ~ListLCEntriesOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_entry_table.c_str(), params.op.lc_entry.index.c_str(), params.op.lc_entry.min_marker.c_str(), params.op.list_max_count.c_str()); @@ -1298,7 +1296,7 @@ class ListLCEntriesOp: virtual public DBOp { class InsertLCHeadOp: virtual public DBOp { private: - const string Query = + const std::string Query = "INSERT OR REPLACE INTO '{}' \ (LCIndex, Marker, StartDate) \ VALUES ({}, {}, {})"; @@ -1306,7 +1304,7 @@ class InsertLCHeadOp: virtual public DBOp { public: virtual ~InsertLCHeadOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_head_table.c_str(), params.op.lc_head.index, params.op.lc_head.marker, params.op.lc_head.start_date); @@ -1315,13 +1313,13 @@ class InsertLCHeadOp: virtual public DBOp { class RemoveLCHeadOp: virtual public DBOp { private: - const string Query = + const std::string Query = "DELETE from '{}' where LCIndex = {}"; public: virtual ~RemoveLCHeadOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_head_table.c_str(), params.op.lc_head.index); } @@ -1329,14 +1327,14 @@ class RemoveLCHeadOp: virtual public DBOp { class GetLCHeadOp: virtual public DBOp { private: - const string Query = "SELECT \ + const std::string Query = "SELECT \ LCIndex, Marker, StartDate \ from '{}' where LCIndex = {}"; public: virtual ~GetLCHeadOp() {} - string Schema(DBOpPrepareParams ¶ms) { + std::string Schema(DBOpPrepareParams ¶ms) { return fmt::format(Query.c_str(), params.lc_head_table.c_str(), params.op.lc_head.index); } @@ -1365,14 +1363,14 @@ WRITE_CLASS_ENCODER(DBOLHInfo) class DB { private: - const string db_name; + const std::string db_name; rgw::sal::Store* store; - const string user_table; - const string bucket_table; - const string quota_table; - const string lc_head_table; - const string lc_entry_table; - static map<string, class ObjectOp*> objectmap; + const std::string user_table; + const std::string bucket_table; + const std::string quota_table; + const std::string lc_head_table; + const std::string lc_entry_table; + static std::map<std::string, class ObjectOp*> objectmap; protected: void *db; @@ -1386,8 +1384,8 @@ class DB { // objects if any. std::mutex mtx; - public: - DB(string db_name, CephContext *_cct) : db_name(db_name), + public: + DB(std::string db_name, CephContext *_cct) : db_name(db_name), user_table(db_name+".user.table"), bucket_table(db_name+".bucket.table"), quota_table(db_name+".quota.table"), @@ -1409,19 +1407,19 @@ class DB { {} virtual ~DB() {} - const string getDBname() { return db_name; } - const string getDBfile() { return db_name + ".db"; } - const string getUserTable() { return user_table; } - const string getBucketTable() { return bucket_table; } - const string getQuotaTable() { return quota_table; } - const string getLCHeadTable() { return lc_head_table; } - const string getLCEntryTable() { return lc_entry_table; } - const string getObjectTable(string bucket) { + const std::string getDBname() { return db_name; } + const std::string getDBfile() { return db_name + ".db"; } + const std::string getUserTable() { return user_table; } + const std::string getBucketTable() { return bucket_table; } + const std::string getQuotaTable() { return quota_table; } + const std::string getLCHeadTable() { return lc_head_table; } + const std::string getLCEntryTable() { return lc_entry_table; } + const std::string getObjectTable(std::string bucket) { return db_name+"."+bucket+".object.table"; } - const string getObjectDataTable(string bucket) { + const std::string getObjectDataTable(std::string bucket) { return db_name+"."+bucket+".objectdata.table"; } - map<string, class ObjectOp*> getObjectMap(); + std::map<std::string, class ObjectOp*> getObjectMap(); struct DBOps dbops; // DB operations, make it private? @@ -1436,18 +1434,18 @@ class DB { CephContext *ctx() { return cct; } const DoutPrefixProvider *get_def_dpp() { return &dp; } - int Initialize(string logfile, int loglevel); + int Initialize(std::string logfile, int loglevel); int Destroy(const DoutPrefixProvider *dpp); int LockInit(const DoutPrefixProvider *dpp); int LockDestroy(const DoutPrefixProvider *dpp); int Lock(const DoutPrefixProvider *dpp); int Unlock(const DoutPrefixProvider *dpp); - int InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params); - int ProcessOp(const DoutPrefixProvider *dpp, string Op, DBOpParams *params); - DBOp* getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params); - int objectmapInsert(const DoutPrefixProvider *dpp, string bucket, class ObjectOp* ptr); - int objectmapDelete(const DoutPrefixProvider *dpp, string bucket); + int InitializeParams(const DoutPrefixProvider *dpp, std::string Op, DBOpParams *params); + int ProcessOp(const DoutPrefixProvider *dpp, std::string Op, DBOpParams *params); + DBOp* getDBOp(const DoutPrefixProvider *dpp, std::string Op, struct DBOpParams *params); + int objectmapInsert(const DoutPrefixProvider *dpp, std::string bucket, class ObjectOp* ptr); + int objectmapDelete(const DoutPrefixProvider *dpp, std::string bucket); virtual uint64_t get_blob_limit() { return 0; }; virtual void *openDB(const DoutPrefixProvider *dpp) { return NULL; } @@ -1464,10 +1462,10 @@ class DB { int get_user(const DoutPrefixProvider *dpp, const std::string& query_str, const std::string& query_str_val, - RGWUserInfo& uinfo, map<string, bufferlist> *pattrs, + RGWUserInfo& uinfo, std::map<std::string, bufferlist> *pattrs, RGWObjVersionTracker *pobjv_tracker); int store_user(const DoutPrefixProvider *dpp, - RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs, + RGWUserInfo& uinfo, bool exclusive, std::map<std::string, bufferlist> *pattrs, RGWObjVersionTracker *pobjv_tracker, RGWUserInfo* pold_info); int remove_user(const DoutPrefixProvider *dpp, RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv_tracker); @@ -1477,11 +1475,11 @@ class DB { obj_version* pbucket_version); int create_bucket(const DoutPrefixProvider *dpp, const RGWUserInfo& owner, rgw_bucket& bucket, - const string& zonegroup_id, + const std::string& zonegroup_id, const rgw_placement_rule& placement_rule, - const string& swift_ver_location, + const std::string& swift_ver_location, const RGWQuotaInfo * pquota_info, - map<std::string, bufferlist>& attrs, + std::map<std::string, bufferlist>& attrs, RGWBucketInfo& info, obj_version *pobjv, obj_version *pep_objv, @@ -1495,15 +1493,15 @@ class DB { int remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info); int list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user, - const string& marker, - const string& end_marker, + const std::string& marker, + const std::string& end_marker, uint64_t max, bool need_stats, RGWUserBuckets *buckets, bool *is_truncated); int update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str, RGWBucketInfo& info, bool exclusive, - const rgw_user* powner_id, map<std::string, bufferlist>* pattrs, + const rgw_user* powner_id, std::map<std::string, bufferlist>* pattrs, ceph::real_time* pmtime, RGWObjVersionTracker* pobjv); uint64_t get_max_head_size() { return ObjHeadSize; } @@ -1512,17 +1510,17 @@ class DB { // db raw obj string is of format - // "<bucketname>_<objname>_<objinstance>_<multipart-part-str>_<partnum>" - const string raw_obj_oid = "{0}_{1}_{2}_{3}_{4}"; + const std::string raw_obj_oid = "{0}_{1}_{2}_{3}_{4}"; - inline string to_oid(const string& bucket, const string& obj_name, const string& obj_instance, - string mp_str, uint64_t partnum) { - string s = fmt::format(raw_obj_oid.c_str(), bucket, obj_name, obj_instance, mp_str, partnum); + inline std::string to_oid(const std::string& bucket, const std::string& obj_name, const std::string& obj_instance, + std::string mp_str, uint64_t partnum) { + std::string s = fmt::format(raw_obj_oid.c_str(), bucket, obj_name, obj_instance, mp_str, partnum); return s; } - inline int from_oid(const string& oid, string& bucket, string& obj_name, - string& obj_instance, - string& mp_str, uint64_t& partnum) { - vector<std::string> result; + inline int from_oid(const std::string& oid, std::string& bucket, std::string& obj_name, + std::string& obj_instance, + std::string& mp_str, uint64_t& partnum) { + std::vector<std::string> result; boost::split(result, oid, boost::is_any_of("_")); bucket = result[0]; obj_name = result[1]; @@ -1536,22 +1534,22 @@ class DB { struct raw_obj { DB* db; - string bucket_name; - string obj_name; - string obj_instance; - string obj_ns; - string multipart_part_str; + std::string bucket_name; + std::string obj_name; + std::string obj_instance; + std::string obj_ns; + std::string multipart_part_str; uint64_t part_num; - string obj_table; - string obj_data_table; + std::string obj_table; + std::string obj_data_table; raw_obj(DB* _db) { db = _db; } - raw_obj(DB* _db, string& _bname, string& _obj_name, string& _obj_instance, - string& _obj_ns, string _mp_part_str, int _part_num) { + raw_obj(DB* _db, std::string& _bname, std::string& _obj_name, std::string& _obj_instance, + std::string& _obj_ns, std::string _mp_part_str, int _part_num) { db = _db; bucket_name = _bname; obj_name = _obj_name; @@ -1564,7 +1562,7 @@ class DB { obj_data_table = bucket_name+".objectdata.table"; } - raw_obj(DB* _db, string& oid) { + raw_obj(DB* _db, std::string& oid) { int r; db = _db; @@ -1609,11 +1607,11 @@ class DB { public: struct Params { - string prefix; - string delim; + std::string prefix; + std::string delim; rgw_obj_key marker; rgw_obj_key end_marker; - string ns; + std::string ns; bool enforce_ns; RGWAccessListFilter* access_list_filter; RGWBucketListNameFilter force_check_filter; @@ -1633,8 +1631,8 @@ class DB { /* XXX: Handle ordered and unordered separately. * For now returning only ordered entries */ int list_objects(const DoutPrefixProvider *dpp, int64_t max, - vector<rgw_bucket_dir_entry> *result, - map<string, bool> *common_prefixes, bool *is_truncated); + std::vector<rgw_bucket_dir_entry> *result, + std::map<std::string, bool> *common_prefixes, bool *is_truncated); rgw_obj_key& get_next_marker() { return next_marker; } @@ -1678,7 +1676,7 @@ class DB { const char *if_match; const char *if_nomatch; - ConditionParams() : + ConditionParams() : mod_ptr(NULL), unmod_ptr(NULL), high_precision_time(false), mod_zone_id(0), mod_pg_ver(0), if_match(NULL), if_nomatch(NULL) {} } conds; @@ -1686,7 +1684,7 @@ class DB { struct Params { ceph::real_time *lastmod; uint64_t *obj_size; - map<string, bufferlist> *attrs; + std::map<std::string, bufferlist> *attrs; rgw_obj *target_obj; Params() : lastmod(nullptr), obj_size(nullptr), attrs(nullptr), @@ -1705,15 +1703,15 @@ class DB { struct Write { DB::Object *target; RGWObjState obj_state; - string mp_part_str = "0.0"; // multipart num + std::string mp_part_str = "0.0"; // multipart num struct MetaParams { ceph::real_time *mtime; - map<std::string, bufferlist>* rmattrs; + std::map<std::string, bufferlist>* rmattrs; const bufferlist *data; RGWObjManifest *manifest; - const string *ptag; - list<rgw_obj_index_key> *remove_objs; + const std::string *ptag; + std::list<rgw_obj_index_key> *remove_objs; ceph::real_time set_mtime; rgw_user owner; RGWObjCategory category; @@ -1723,7 +1721,7 @@ class DB { std::optional<uint64_t> olh_epoch; ceph::real_time delete_at; bool canceled; - const string *user_data; + const std::string *user_data; rgw_zone_set *zones_trace; bool modify_tail; bool completeMultipart; @@ -1737,16 +1735,16 @@ class DB { explicit Write(DB::Object *_target) : target(_target) {} - void set_mp_part_str(string _mp_part_str) { mp_part_str = _mp_part_str;} + void set_mp_part_str(std::string _mp_part_str) { mp_part_str = _mp_part_str;} int prepare(const DoutPrefixProvider* dpp); int write_data(const DoutPrefixProvider* dpp, bufferlist& data, uint64_t ofs); int _do_write_meta(const DoutPrefixProvider *dpp, uint64_t size, uint64_t accounted_size, - map<string, bufferlist>& attrs, + std::map<std::string, bufferlist>& attrs, bool assume_noent, bool modify_tail); int write_meta(const DoutPrefixProvider *dpp, uint64_t size, - uint64_t accounted_size, map<string, bufferlist>& attrs); + uint64_t accounted_size, std::map<std::string, bufferlist>& attrs); /* Below are used to update mp data rows object name * from meta to src object name on multipart upload * completion @@ -1762,9 +1760,9 @@ class DB { int versioning_status; ACLOwner obj_owner; /* needed for creation of deletion marker */ uint64_t olh_epoch; - string marker_version_id; + std::string marker_version_id; uint32_t bilog_flags; - list<rgw_obj_index_key> *remove_objs; + std::list<rgw_obj_index_key> *remove_objs; ceph::real_time expiration_time; ceph::real_time unmod_since; ceph::real_time mtime; /* for setting delete marker mtime */ @@ -1778,7 +1776,7 @@ class DB { struct DeleteResult { bool delete_marker; - string version_id; + std::string version_id; DeleteResult() : delete_marker(false) {} } result; @@ -1806,8 +1804,8 @@ class DB { RGWBucketInfo& get_bucket_info() { return bucket_info; } int InitializeParamsfromObject(const DoutPrefixProvider *dpp, DBOpParams* params); - int set_attrs(const DoutPrefixProvider *dpp, map<string, bufferlist>& setattrs, - map<string, bufferlist>* rmattrs); + int set_attrs(const DoutPrefixProvider *dpp, std::map<std::string, bufferlist>& setattrs, + std::map<std::string, bufferlist>* rmattrs); int obj_omap_set_val_by_key(const DoutPrefixProvider *dpp, const std::string& key, bufferlist& val, bool must_exist); int obj_omap_get_vals_by_keys(const DoutPrefixProvider *dpp, const std::string& oid, const std::set<std::string>& keys, diff --git a/src/rgw/store/dbstore/common/dbstore_log.h b/src/rgw/store/dbstore/common/dbstore_log.h index 9bd4a227480..4b1373bfccb 100644 --- a/src/rgw/store/dbstore/common/dbstore_log.h +++ b/src/rgw/store/dbstore/common/dbstore_log.h @@ -4,15 +4,13 @@ #ifndef DB_STORE_LOG_H #define DB_STORE_LOG_H -#include <errno.h> -#include <stdlib.h> +#include <cerrno> +#include <cstdlib> #include <string> -#include <stdio.h> +#include <cstdio> #include <iostream> #include <fstream> -#include "common/dout.h" - -using namespace std; +#include "common/dout.h" #define dout_subsys ceph_subsys_rgw #undef dout_prefix diff --git a/src/rgw/store/dbstore/dbstore_main.cc b/src/rgw/store/dbstore/dbstore_main.cc index 0055191908b..34762b52d90 100644 --- a/src/rgw/store/dbstore/dbstore_main.cc +++ b/src/rgw/store/dbstore/dbstore_main.cc @@ -8,6 +8,7 @@ #include <dbstore.h> #include <dbstore_log.h> +using namespace std; using namespace rgw::store; using DB = rgw::store::DB; diff --git a/src/rgw/store/dbstore/dbstore_mgr.cc b/src/rgw/store/dbstore/dbstore_mgr.cc index 61e11d99637..9da98a487dc 100644 --- a/src/rgw/store/dbstore/dbstore_mgr.cc +++ b/src/rgw/store/dbstore/dbstore_mgr.cc @@ -4,6 +4,8 @@ #include "dbstore_mgr.h" #include "common/dbstore_log.h" +using namespace std; + /* Given a tenant, find and return the DBStore handle. * If not found and 'create' set to true, create one * and return diff --git a/src/rgw/store/dbstore/dbstore_mgr.h b/src/rgw/store/dbstore/dbstore_mgr.h index d3053e6ac7c..850f97a42e2 100644 --- a/src/rgw/store/dbstore/dbstore_mgr.h +++ b/src/rgw/store/dbstore/dbstore_mgr.h @@ -4,27 +4,26 @@ #pragma once #include <map> -#include <errno.h> -#include <stdlib.h> +#include <cerrno> +#include <cstdlib> #include <string> -#include <stdio.h> +#include <cstdio> #include <iostream> +#include <vector> + #include "common/ceph_context.h" #include "common/dbstore.h" #include "sqlite/sqliteDB.h" -using namespace std; using namespace rgw::store; using DB = rgw::store::DB; /* XXX: Should be a dbstore config option */ -const static string default_tenant = "default_ns"; - -using namespace std; +const static std::string default_tenant = "default_ns"; class DBStoreManager { private: - map<string, DB*> DBStoreHandles; + std::map<std::string, DB*> DBStoreHandles; DB *default_db = NULL; CephContext *cct; @@ -33,9 +32,9 @@ public: cct = _cct; default_db = createDB(default_tenant); }; - DBStoreManager(string logfile, int loglevel): DBStoreHandles() { + DBStoreManager(std::string logfile, int loglevel): DBStoreHandles() { /* No ceph context. Create one with log args provided */ - vector<const char*> args; + std::vector<const char*> args; cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_DAEMON, CINIT_FLAG_NO_MON_CONFIG, 1)->get(); cct->_log->set_log_file(logfile); @@ -50,9 +49,9 @@ public: * being deleted while using it. */ DB* getDB () { return default_db; }; - DB* getDB (string tenant, bool create); - DB* createDB (string tenant); - void deleteDB (string tenant); + DB* getDB (std::string tenant, bool create); + DB* createDB (std::string tenant); + void deleteDB (std::string tenant); void deleteDB (DB* db); void destroyAllHandles(); }; diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.cc b/src/rgw/store/dbstore/sqlite/sqliteDB.cc index f24eb68b2e2..6675af2922e 100644 --- a/src/rgw/store/dbstore/sqlite/sqliteDB.cc +++ b/src/rgw/store/dbstore/sqlite/sqliteDB.cc @@ -3,6 +3,8 @@ #include "sqliteDB.h" +using namespace std; + #define SQL_PREPARE(dpp, params, sdb, stmt, ret, Op) \ do { \ string schema; \ diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.h b/src/rgw/store/dbstore/sqlite/sqliteDB.h index 5bf7dfdd16f..dd56ab1f9ec 100644 --- a/src/rgw/store/dbstore/sqlite/sqliteDB.h +++ b/src/rgw/store/dbstore/sqlite/sqliteDB.h @@ -10,7 +10,6 @@ #include <sqlite3.h> #include "rgw/store/dbstore/common/dbstore.h" -using namespace std; using namespace rgw::store; class SQLiteDB : public DB, virtual public DBOp { @@ -20,15 +19,15 @@ class SQLiteDB : public DB, virtual public DBOp { protected: CephContext *cct; - public: + public: sqlite3_stmt *stmt = NULL; DBOpPrepareParams PrepareParams; - SQLiteDB(sqlite3 *dbi, string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) { + SQLiteDB(sqlite3 *dbi, std::string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) { db = (void*)dbi; InitPrepareParams(get_def_dpp(), PrepareParams); } - SQLiteDB(string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) { + SQLiteDB(std::string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) { InitPrepareParams(get_def_dpp(), PrepareParams); } ~SQLiteDB() {} @@ -48,7 +47,7 @@ class SQLiteDB : public DB, virtual public DBOp { int Reset(const DoutPrefixProvider *dpp, sqlite3_stmt *stmt); /* default value matches with sqliteDB style */ - int createTables(const DoutPrefixProvider *dpp); + int createTables(const DoutPrefixProvider *dpp) override; int createBucketTable(const DoutPrefixProvider *dpp, DBOpParams *params); int createUserTable(const DoutPrefixProvider *dpp, DBOpParams *params); int createObjectTable(const DoutPrefixProvider *dpp, DBOpParams *params); @@ -79,7 +78,7 @@ class SQLObjectOp : public ObjectOp { SQLObjectOp(sqlite3 **sdbi, CephContext *_cct) : sdb(sdbi), cct(_cct) {}; ~SQLObjectOp() {} - int InitializeObjectOps(string db_name, const DoutPrefixProvider *dpp); + int InitializeObjectOps(std::string db_name, const DoutPrefixProvider *dpp); int FreeObjectOps(const DoutPrefixProvider *dpp); }; @@ -89,7 +88,7 @@ class SQLInsertUser : public SQLiteDB, public InsertUserOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertUser(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLInsertUser(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLInsertUser() { if (stmt) sqlite3_finalize(stmt); @@ -105,7 +104,7 @@ class SQLRemoveUser : public SQLiteDB, public RemoveUserOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveUser(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLRemoveUser(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLRemoveUser() { if (stmt) sqlite3_finalize(stmt); @@ -124,7 +123,7 @@ class SQLGetUser : public SQLiteDB, public GetUserOp { sqlite3_stmt *userid_stmt = NULL; // Prepared statement to query by user_id public: - SQLGetUser(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetUser(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLGetUser() { if (stmt) sqlite3_finalize(stmt); @@ -146,7 +145,7 @@ class SQLInsertBucket : public SQLiteDB, public InsertBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertBucket(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLInsertBucket(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLInsertBucket() { if (stmt) sqlite3_finalize(stmt); @@ -164,7 +163,7 @@ class SQLUpdateBucket : public SQLiteDB, public UpdateBucketOp { sqlite3_stmt *owner_stmt = NULL; // Prepared statement public: - SQLUpdateBucket(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLUpdateBucket(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLUpdateBucket() { if (info_stmt) sqlite3_finalize(info_stmt); @@ -184,7 +183,7 @@ class SQLRemoveBucket : public SQLiteDB, public RemoveBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveBucket(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLRemoveBucket(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLRemoveBucket() { if (stmt) sqlite3_finalize(stmt); @@ -200,7 +199,7 @@ class SQLGetBucket : public SQLiteDB, public GetBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetBucket(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetBucket(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLGetBucket() { if (stmt) sqlite3_finalize(stmt); @@ -216,7 +215,7 @@ class SQLListUserBuckets : public SQLiteDB, public ListUserBucketsOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLListUserBuckets(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLListUserBuckets(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLListUserBuckets() { if (stmt) sqlite3_finalize(stmt); @@ -232,8 +231,8 @@ class SQLPutObject : public SQLiteDB, public PutObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLPutObject(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLPutObject(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLPutObject(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLPutObject(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLPutObject() { if (stmt) @@ -250,8 +249,8 @@ class SQLDeleteObject : public SQLiteDB, public DeleteObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLDeleteObject(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLDeleteObject(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLDeleteObject(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLDeleteObject(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLDeleteObject() { if (stmt) @@ -268,8 +267,8 @@ class SQLGetObject : public SQLiteDB, public GetObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetObject(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLGetObject(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLGetObject(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetObject(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLGetObject() { if (stmt) @@ -289,8 +288,8 @@ class SQLUpdateObject : public SQLiteDB, public UpdateObjectOp { sqlite3_stmt *mp_stmt = NULL; // Prepared statement public: - SQLUpdateObject(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLUpdateObject(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLUpdateObject(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLUpdateObject(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLUpdateObject() { if (omap_stmt) @@ -312,8 +311,8 @@ class SQLListBucketObjects : public SQLiteDB, public ListBucketObjectsOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLListBucketObjects(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLListBucketObjects(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLListBucketObjects(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLListBucketObjects(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLListBucketObjects() { if (stmt) @@ -330,8 +329,8 @@ class SQLPutObjectData : public SQLiteDB, public PutObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLPutObjectData(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLPutObjectData(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLPutObjectData(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLPutObjectData(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLPutObjectData() { if (stmt) @@ -348,8 +347,8 @@ class SQLUpdateObjectData : public SQLiteDB, public UpdateObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLUpdateObjectData(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLUpdateObjectData(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLUpdateObjectData(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLUpdateObjectData(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLUpdateObjectData() { if (stmt) @@ -366,8 +365,8 @@ class SQLGetObjectData : public SQLiteDB, public GetObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetObjectData(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLGetObjectData(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLGetObjectData(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetObjectData(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLGetObjectData() { if (stmt) @@ -384,8 +383,8 @@ class SQLDeleteObjectData : public SQLiteDB, public DeleteObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLDeleteObjectData(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} - SQLDeleteObjectData(sqlite3 **sdbi, string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} + SQLDeleteObjectData(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLDeleteObjectData(sqlite3 **sdbi, std::string db_name, CephContext *cct) : SQLiteDB(*sdbi, db_name, cct), sdb(sdbi) {} ~SQLDeleteObjectData() { if (stmt) @@ -402,7 +401,7 @@ class SQLInsertLCEntry : public SQLiteDB, public InsertLCEntryOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertLCEntry(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLInsertLCEntry(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLInsertLCEntry() { if (stmt) sqlite3_finalize(stmt); @@ -418,7 +417,7 @@ class SQLRemoveLCEntry : public SQLiteDB, public RemoveLCEntryOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveLCEntry(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLRemoveLCEntry(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLRemoveLCEntry() { if (stmt) sqlite3_finalize(stmt); @@ -435,7 +434,7 @@ class SQLGetLCEntry : public SQLiteDB, public GetLCEntryOp { sqlite3_stmt *next_stmt = NULL; // Prepared statement public: - SQLGetLCEntry(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetLCEntry(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLGetLCEntry() { if (stmt) sqlite3_finalize(stmt); @@ -453,7 +452,7 @@ class SQLListLCEntries : public SQLiteDB, public ListLCEntriesOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLListLCEntries(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLListLCEntries(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLListLCEntries() { if (stmt) sqlite3_finalize(stmt); @@ -469,7 +468,7 @@ class SQLInsertLCHead : public SQLiteDB, public InsertLCHeadOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertLCHead(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLInsertLCHead(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLInsertLCHead() { if (stmt) sqlite3_finalize(stmt); @@ -485,7 +484,7 @@ class SQLRemoveLCHead : public SQLiteDB, public RemoveLCHeadOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveLCHead(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLRemoveLCHead(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLRemoveLCHead() { if (stmt) sqlite3_finalize(stmt); @@ -501,7 +500,7 @@ class SQLGetLCHead : public SQLiteDB, public GetLCHeadOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetLCHead(void **db, string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} + SQLGetLCHead(void **db, std::string db_name, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), db_name, cct), sdb((sqlite3 **)db) {} ~SQLGetLCHead() { if (stmt) sqlite3_finalize(stmt); diff --git a/src/script/backport-create-issue b/src/script/backport-create-issue index fdd0d453448..b3e1a6da660 100755 --- a/src/script/backport-create-issue +++ b/src/script/backport-create-issue @@ -122,7 +122,7 @@ def connect_to_redmine(a): def releases(): return ('argonaut', 'bobtail', 'cuttlefish', 'dumpling', 'emperor', 'firefly', 'giant', 'hammer', 'infernalis', 'jewel', 'kraken', - 'luminous', 'mimic', 'nautilus', 'octopus', 'pacific') + 'luminous', 'mimic', 'nautilus', 'octopus', 'pacific', 'quincy') def populate_status_dict(r): for status in r.issue_status.all(): diff --git a/src/script/backport-resolve-issue b/src/script/backport-resolve-issue index 2501f103ec2..7d27ac2ebb5 100755 --- a/src/script/backport-resolve-issue +++ b/src/script/backport-resolve-issue @@ -324,7 +324,7 @@ def read_from_file(fs): def releases(): return ('argonaut', 'bobtail', 'cuttlefish', 'dumpling', 'emperor', 'firefly', 'giant', 'hammer', 'infernalis', 'jewel', 'kraken', - 'luminous', 'mimic', 'nautilus', 'octopus', 'pacific') + 'luminous', 'mimic', 'nautilus', 'octopus', 'pacific', 'quincy') def report_params(a): global dry_run @@ -352,7 +352,7 @@ def ver_to_release(): return {'v9.2': 'infernalis', 'v10.2': 'jewel', 'v11.2': 'kraken', 'v12.2': 'luminous', 'v13.2': 'mimic', 'v14.2': 'nautilus', 'v15.2': 'octopus', 'v16.0': 'pacific', 'v16.1': 'pacific', - 'v16.2': 'pacific'} + 'v16.2': 'pacific', 'v17.0': 'quincy'} def usage(): logging.error("Redmine credentials are required to perform this operation. " diff --git a/src/script/build-integration-branch b/src/script/build-integration-branch index d92821b2f1f..b4f2a6121d7 100755 --- a/src/script/build-integration-branch +++ b/src/script/build-integration-branch @@ -33,7 +33,7 @@ postfix = "-" + time.strftime(TIME_FORMAT, time.localtime()) current_branch = check_output('git rev-parse --abbrev-ref HEAD', shell=True).strip().decode() -if current_branch in 'mimic nautilus octopus pacific'.split(): +if current_branch in 'mimic nautilus octopus pacific quincy'.split(): postfix += '-' + current_branch print(f"Adding current branch name '-{current_branch}' as a postfix") diff --git a/src/script/ceph-backport.sh b/src/script/ceph-backport.sh index 2721cfda853..7c4410051f7 100755 --- a/src/script/ceph-backport.sh +++ b/src/script/ceph-backport.sh @@ -1084,6 +1084,7 @@ function try_known_milestones { nautilus) mn="12" ;; octopus) mn="13" ;; pacific) mn="14" ;; + quincy) mn="15" ;; esac echo "$mn" } diff --git a/src/test/bufferlist.cc b/src/test/bufferlist.cc index 99e954ff597..1b604f7bde4 100644 --- a/src/test/bufferlist.cc +++ b/src/test/bufferlist.cc @@ -1853,13 +1853,14 @@ TEST(BufferList, rebuild_aligned_size_and_memory) { * scenario where the first bptr is both size and memory aligned and * the second is 0-length */ bl.clear(); - bufferptr ptr1(buffer::create_aligned(4096, 4096)); - bl.append(ptr1); - bufferptr ptr(10); - /* bl.back().length() must be 0 */ - bl.append(ptr, 0, 0); + bl.append(bufferptr{buffer::create_aligned(4096, 4096)}); + bufferptr ptr(buffer::create_aligned(42, 4096)); + /* bl.back().length() must be 0. offset set to 42 guarantees + * the entire list is unaligned. */ + bl.append(ptr, 42, 0); EXPECT_EQ(bl.get_num_buffers(), 2); EXPECT_EQ(bl.back().length(), 0); + EXPECT_FALSE(bl.is_aligned(4096)); /* rebuild_aligned() calls rebuild_aligned_size_and_memory(). * we assume the rebuild always happens. */ EXPECT_TRUE(bl.rebuild_aligned(4096)); diff --git a/src/test/erasure-code/ErasureCodeExample.h b/src/test/erasure-code/ErasureCodeExample.h index 1185b38d736..4226361c47e 100644 --- a/src/test/erasure-code/ErasureCodeExample.h +++ b/src/test/erasure-code/ErasureCodeExample.h @@ -35,15 +35,13 @@ #define MINIMUM_TO_RECOVER 2u -using namespace std; - class ErasureCodeExample final : public ErasureCode { public: ~ErasureCodeExample() override {} int create_rule(const std::string &name, CrushWrapper &crush, - ostream *ss) const override { + std::ostream *ss) const override { return crush.add_simple_rule(name, "default", "host", "", "indep", pg_pool_t::TYPE_ERASURE, ss); } @@ -70,7 +68,7 @@ public: c2c[CODING_CHUNK] > c2c[SECOND_DATA_CHUNK]) c2c.erase(CODING_CHUNK); } - set <int> available_chunks; + std::set <int> available_chunks; for (std::map<int, int>::const_iterator i = c2c.begin(); i != c2c.end(); ++i) @@ -116,7 +114,7 @@ public: // to chunk boundaries // const bufferptr &ptr = out.front(); - for (set<int>::iterator j = want_to_encode.begin(); + for (auto j = want_to_encode.begin(); j != want_to_encode.end(); ++j) { bufferlist tmp; @@ -136,7 +134,7 @@ public: int _decode(const std::set<int> &want_to_read, const std::map<int, bufferlist> &chunks, - std::map<int, bufferlist> *decoded) { + std::map<int, bufferlist> *decoded) override { // // All chunks have the same size // diff --git a/src/test/erasure-code/TestErasureCodeExample.cc b/src/test/erasure-code/TestErasureCodeExample.cc index 826f3bef177..b488a604b61 100644 --- a/src/test/erasure-code/TestErasureCodeExample.cc +++ b/src/test/erasure-code/TestErasureCodeExample.cc @@ -1,4 +1,4 @@ -// -*- mode:C; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- // vim: ts=8 sw=2 smarttab /* * Ceph distributed storage system @@ -11,7 +11,7 @@ * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. - * + * */ #include <stdlib.h> @@ -20,6 +20,8 @@ #include "global/global_context.h" #include "gtest/gtest.h" +using namespace std; + TEST(ErasureCodeExample, chunk_size) { ErasureCodeExample example; diff --git a/src/test/erasure-code/ceph_erasure_code_benchmark.cc b/src/test/erasure-code/ceph_erasure_code_benchmark.cc index 2bcb5f3cd3b..c86e58697c0 100644 --- a/src/test/erasure-code/ceph_erasure_code_benchmark.cc +++ b/src/test/erasure-code/ceph_erasure_code_benchmark.cc @@ -35,6 +35,15 @@ #include "erasure-code/ErasureCode.h" #include "ceph_erasure_code_benchmark.h" +using std::endl; +using std::cerr; +using std::cout; +using std::map; +using std::set; +using std::string; +using std::stringstream; +using std::vector; + namespace po = boost::program_options; int ErasureCodeBench::setup(int argc, char** argv) { @@ -175,7 +184,7 @@ int ErasureCodeBench::encode() } utime_t begin_time = ceph_clock_now(); for (int i = 0; i < max_iterations; i++) { - map<int,bufferlist> encoded; + std::map<int,bufferlist> encoded; code = erasure_code->encode(want_to_encode, in, &encoded); if (code) return code; diff --git a/src/test/erasure-code/ceph_erasure_code_benchmark.h b/src/test/erasure-code/ceph_erasure_code_benchmark.h index c65f716b1e1..59149a74c16 100644 --- a/src/test/erasure-code/ceph_erasure_code_benchmark.h +++ b/src/test/erasure-code/ceph_erasure_code_benchmark.h @@ -19,8 +19,16 @@ #define CEPH_ERASURE_CODE_BENCHMARK_H #include <string> +#include <map> +#include <vector> -using namespace std; +#include <boost/intrusive_ptr.hpp> + +#include "include/buffer.h" + +#include "common/ceph_context.h" + +#include "erasure-code/ErasureCodeInterface.h" class ErasureCodeBench { int in_size; @@ -29,21 +37,21 @@ class ErasureCodeBench { int k; int m; - string plugin; + std::string plugin; bool exhaustive_erasures; - vector<int> erased; - string workload; + std::vector<int> erased; + std::string workload; - ErasureCodeProfile profile; + ceph::ErasureCodeProfile profile; bool verbose; boost::intrusive_ptr<CephContext> cct; public: int setup(int argc, char** argv); int run(); - int decode_erasures(const map<int,bufferlist> &all_chunks, - const map<int,bufferlist> &chunks, + int decode_erasures(const std::map<int, ceph::buffer::list> &all_chunks, + const std::map<int, ceph::buffer::list> &chunks, unsigned i, unsigned want_erasures, ErasureCodeInterfaceRef erasure_code); diff --git a/src/test/kv_store_bench.h b/src/test/kv_store_bench.h index 733594b70c5..689c769ce52 100644 --- a/src/test/kv_store_bench.h +++ b/src/test/kv_store_bench.h @@ -25,9 +25,6 @@ #include <cfloat> #include <iostream> -using namespace std; -using ceph::bufferlist; - /** * stores pairings from op type to time taken for that op (for latency), and to * time that op completed to the nearest second (for throughput). @@ -69,7 +66,7 @@ struct timed_args { StopWatch sw; //kv_bench_data data; KvStoreBench * kvsb; - bufferlist val; + ceph::buffer::list val; int err; char op; @@ -86,7 +83,7 @@ struct timed_args { {} }; -typedef pair<string, bufferlist> (KvStoreBench::*next_gen_t)(bool new_elem); +typedef std::pair<std::string, ceph::buffer::list> (KvStoreBench::*next_gen_t)(bool new_elem); class KvStoreBench { @@ -107,13 +104,13 @@ protected: int cache_size; //number of index entries to store in cache double cache_refresh; //cache_size / cache_refresh entries are read each time //the index is read - string client_name; + std::string client_name; bool verbose;//if true, display debug output //internal - map<int, char> probs;//map of numbers from 1 to 100 to chars representing + std::map<int, char> probs;//map of numbers from 1 to 100 to chars representing //operation types - used to generate random operations - set<string> key_set;//set of keys already in the data set + std::set<std::string> key_set;//set of keys already in the data set KeyValueStructure * kvs; kv_bench_data data;//stores throughput and latency from completed tests ceph::mutex data_lock = ceph::make_mutex("data lock"); @@ -123,8 +120,8 @@ protected: ceph::make_mutex("KvStoreBench::ops_in_flight_lock"); //these are used for cleanup and setup purposes - they are NOT passed to kvs! librados::Rados rados; - string rados_id; - string pool_name; + std::string rados_id; + std::string pool_name; bool io_ctx_ready; librados::IoCtx io_ctx; @@ -153,7 +150,7 @@ public: /** * Returns a string of random characters of length len */ - string random_string(int len); + std::string random_string(int len); /** * Inserts entries random keys and values asynchronously. @@ -164,20 +161,20 @@ public: * calls test_random_insertions, then does ops randomly chosen operations * asynchronously, with max_ops_in_flight operations at a time. */ - int test_teuthology_aio(next_gen_t distr, const map<int, char> &probs); + int test_teuthology_aio(next_gen_t distr, const std::map<int, char> &probs); /** * calls test_random_insertions, then does ops randomly chosen operations * synchronously. */ - int test_teuthology_sync(next_gen_t distr, const map<int, char> &probs); + int test_teuthology_sync(next_gen_t distr, const std::map<int, char> &probs); /** * returns a key-value pair. If new_elem is true, the key is randomly * generated. If it is false, the key is selected from the keys currently in * the key set. */ - pair<string, bufferlist> rand_distr(bool new_elem); + std::pair<std::string, ceph::buffer::list> rand_distr(bool new_elem); /** * Called when aio operations complete. Updates data. diff --git a/src/test/librados_test_stub/NeoradosTestStub.cc b/src/test/librados_test_stub/NeoradosTestStub.cc index 882e80820c7..c46660c6cd1 100644 --- a/src/test/librados_test_stub/NeoradosTestStub.cc +++ b/src/test/librados_test_stub/NeoradosTestStub.cc @@ -22,12 +22,14 @@ #include <boost/system/system_error.hpp> namespace bs = boost::system; +using namespace std::literals; using namespace std::placeholders; namespace neorados { namespace detail { -struct Client { +class Client { +public: ceph::mutex mutex = ceph::make_mutex("NeoradosTestStub::Client"); librados::TestRadosClient* test_rados_client; diff --git a/src/test/objectstore/allocator_replay_test.cc b/src/test/objectstore/allocator_replay_test.cc index 811cc92cdea..401eaa42703 100644 --- a/src/test/objectstore/allocator_replay_test.cc +++ b/src/test/objectstore/allocator_replay_test.cc @@ -18,8 +18,14 @@ using namespace std; void usage(const string &name) { - cerr << "Usage: " << name << " <log_to_replay> <raw_duplicate|free_dump|try_alloc count want alloc_unit>" - << std::endl; + cerr << "Usage: " << name << " <log_to_replay> <raw_duplicate|free_dump|try_alloc count want alloc_unit|replay_alloc alloc_list_file>" << std::endl; +} + +void usage_replay_alloc(const string &name) { + cerr << "Detailed replay_alloc usage: " << name << " <allocator_dump_JSON> replay_alloc <alloc_list_file> [number of replays]" << std::endl; + cerr << "The number of replays defaults to 1." << std::endl; + cerr << "The \"alloc_list_file\" parameter should be a file with allocation requests, one per line." << std::endl; + cerr << "Allocation request format (space separated, optional parameters are 0 if not given): want unit [max] [hint]" << std::endl; } int replay_and_check_for_duplicate(char* fname) @@ -389,5 +395,99 @@ int main(int argc, char **argv) << ", unit:" << alloc_unit << std::endl; return 0; }); + } else if (strcmp(argv[2], "replay_alloc") == 0) { + if (argc < 4) { + std::cerr << "Error: insufficient arguments for \"replay_alloc\" option." + << std::endl; + usage_replay_alloc(argv[0]); + return 1; + } + return replay_free_dump_and_apply(argv[1], + [&](Allocator *a, const string &aname) { + ceph_assert(a); + std::cout << "Fragmentation:" << a->get_fragmentation() + << std::endl; + std::cout << "Fragmentation score:" << a->get_fragmentation_score() + << std::endl; + std::cout << "Free:" << std::hex << a->get_free() << std::dec + << std::endl; + { + /* replay a set of allocation requests */ + char s[4096]; + + FILE *f_alloc_list = fopen(argv[3], "r"); + if (!f_alloc_list) { + std::cerr << "error: unable to open " << argv[3] << std::endl; + return -1; + } + + /* Replay user specified number of times to simulate extended activity + * Defaults to 1 replay. + */ + auto replay_count = 1; + if (argc == 5) { + replay_count = atoi(argv[4]); + } + + for (auto i = 0; i < replay_count; ++i) { + while (fgets(s, sizeof(s), f_alloc_list) != nullptr) { + /* parse allocation request */ + uint64_t want = 0, unit = 0, max = 0, hint = 0; + + if (std::sscanf(s, "%ji %ji %ji %ji", &want, &unit, &max, &hint) < 2) + { + cerr << "Error: malformed allocation request:" << std::endl; + cerr << s << std::endl; + /* do not attempt to allocate a malformed request */ + continue; + } + + /* timestamp for allocation start */ + auto t0 = ceph::mono_clock::now(); + + /* allocate */ + PExtentVector extents; + auto r = a->allocate(want, unit, max, hint, &extents); + if (r < 0) { + /* blind replays of allocations may run out of space, provide info for easy confirmation */ + std::cerr << "Error: allocation failure code: " << r + << " requested want/unit/max/hint (hex): " << std::hex + << want << "/" << unit << "/" << max << "/" << hint + << std::dec << std::endl; + std::cerr << "Fragmentation:" << a->get_fragmentation() + << std::endl; + std::cerr << "Fragmentation score:" << a->get_fragmentation_score() + << std::endl; + std::cerr << "Free:" << std::hex << a->get_free() << std::dec + << std::endl; + /* return 0 if the allocator ran out of space */ + if (r == -ENOSPC) { + return 0; + } + return -1; + } + + /* Outputs the allocation's duration in nanoseconds and the allocation request parameters */ + std::cout << "Duration (ns): " << (ceph::mono_clock::now() - t0).count() + << " want/unit/max/hint (hex): " << std::hex + << want << "/" << unit << "/" << max << "/" << hint + << std::dec << std::endl; + + /* Do not release. */ + //alloc->release(extents); + extents.clear(); + } + fseek(f_alloc_list, 0, SEEK_SET); + } + fclose(f_alloc_list); + std::cout << "Fragmentation:" << a->get_fragmentation() + << std::endl; + std::cout << "Fragmentation score:" << a->get_fragmentation_score() + << std::endl; + std::cout << "Free:" << std::hex << a->get_free() << std::dec + << std::endl; + } + return 0; + }); } } diff --git a/src/test/osd/RadosModel.h b/src/test/osd/RadosModel.h index a429476749d..7f4de6162fe 100644 --- a/src/test/osd/RadosModel.h +++ b/src/test/osd/RadosModel.h @@ -30,8 +30,6 @@ #ifndef RADOSMODEL_H #define RADOSMODEL_H -using namespace std; - class RadosTestContext; class TestOpStat; @@ -90,7 +88,7 @@ public: } void handle_error(uint64_t cookie, int err) override { std::lock_guard l{lock}; - cout << "watch handle_error " << err << std::endl; + std::cout << "watch handle_error " << err << std::endl; } void start() { std::lock_guard l{lock}; @@ -143,7 +141,7 @@ public: { return; } - virtual string getType() = 0; + virtual std::string getType() = 0; virtual bool finished() { return true; @@ -165,29 +163,29 @@ public: ceph::mutex state_lock = ceph::make_mutex("Context Lock"); ceph::condition_variable wait_cond; // snap => {oid => desc} - map<int, map<string,ObjectDesc> > pool_obj_cont; - set<string> oid_in_use; - set<string> oid_not_in_use; - set<string> oid_flushing; - set<string> oid_not_flushing; - set<string> oid_redirect_not_in_use; - set<string> oid_redirect_in_use; - set<string> oid_set_chunk_tgt_pool; + std::map<int, std::map<std::string,ObjectDesc> > pool_obj_cont; + std::set<std::string> oid_in_use; + std::set<std::string> oid_not_in_use; + std::set<std::string> oid_flushing; + std::set<std::string> oid_not_flushing; + std::set<std::string> oid_redirect_not_in_use; + std::set<std::string> oid_redirect_in_use; + std::set<std::string> oid_set_chunk_tgt_pool; SharedPtrRegistry<int, int> snaps_in_use; int current_snap; - string pool_name; + std::string pool_name; librados::IoCtx io_ctx; librados::Rados rados; int next_oid; - string prefix; + std::string prefix; int errors; int max_in_flight; int seq_num; - map<int,uint64_t> snaps; + std::map<int,uint64_t> snaps; uint64_t seq; const char *rados_id; bool initialized; - map<string, TestWatchContext*> watches; + std::map<std::string, TestWatchContext*> watches; const uint64_t max_size; const uint64_t min_stride_size; const uint64_t max_stride_size; @@ -196,15 +194,15 @@ public: const bool no_sparse; bool pool_snaps; bool write_fadvise_dontneed; - string low_tier_pool_name; + std::string low_tier_pool_name; librados::IoCtx low_tier_io_ctx; int snapname_num; - map<string,string > redirect_objs; + std::map<std::string, std::string> redirect_objs; bool enable_dedup; - string chunk_algo; - string chunk_size; + std::string chunk_algo; + std::string chunk_size; - RadosTestContext(const string &pool_name, + RadosTestContext(const std::string &pool_name, int max_in_flight, uint64_t max_size, uint64_t min_stride_size, @@ -213,10 +211,10 @@ public: bool no_sparse, bool pool_snaps, bool write_fadvise_dontneed, - const string &low_tier_pool_name, + const std::string &low_tier_pool_name, bool enable_dedup, - string chunk_algo, - string chunk_size, + std::string chunk_algo, + std::string chunk_size, const char *id = 0) : pool_obj_cont(), current_snap(0), @@ -313,7 +311,7 @@ public: char hostname_cstr[100]; gethostname(hostname_cstr, 100); - stringstream hostpid; + std::stringstream hostpid; hostpid << hostname_cstr << getpid() << "-"; prefix = hostpid.str(); ceph_assert(!initialized); @@ -331,7 +329,7 @@ public: void loop(TestOpGenerator *gen) { ceph_assert(initialized); - list<TestOp*> inflight; + std::list<TestOp*> inflight; std::unique_lock state_locker{state_lock}; TestOp *next = gen->next(*this); @@ -351,19 +349,19 @@ public: } state_lock.lock(); while (1) { - for (list<TestOp*>::iterator i = inflight.begin(); + for (auto i = inflight.begin(); i != inflight.end();) { if ((*i)->finished()) { - cout << (*i)->num << ": done (" << (inflight.size()-1) << " left)" << std::endl; + std::cout << (*i)->num << ": done (" << (inflight.size()-1) << " left)" << std::endl; delete *i; inflight.erase(i++); } else { ++i; } } - + if (inflight.size() >= (unsigned) max_in_flight || (!next && !inflight.empty())) { - cout << " waiting on " << inflight.size() << std::endl; + std::cout << " waiting on " << inflight.size() << std::endl; wait_cond.wait(state_locker); } else { break; @@ -383,28 +381,27 @@ public: wait_cond.notify_all(); } - TestWatchContext *get_watch_context(const string &oid) { + TestWatchContext *get_watch_context(const std::string &oid) { return watches.count(oid) ? watches[oid] : 0; } - TestWatchContext *watch(const string &oid) { + TestWatchContext *watch(const std::string &oid) { ceph_assert(!watches.count(oid)); return (watches[oid] = new TestWatchContext); } - void unwatch(const string &oid) { + void unwatch(const std::string &oid) { ceph_assert(watches.count(oid)); delete watches[oid]; watches.erase(oid); } - ObjectDesc get_most_recent(const string &oid) { + ObjectDesc get_most_recent(const std::string &oid) { ObjectDesc new_obj; - for (map<int, map<string,ObjectDesc> >::reverse_iterator i = - pool_obj_cont.rbegin(); + for (auto i = pool_obj_cont.rbegin(); i != pool_obj_cont.rend(); ++i) { - map<string,ObjectDesc>::iterator j = i->second.find(oid); + std::map<std::string,ObjectDesc>::iterator j = i->second.find(oid); if (j != i->second.end()) { new_obj = j->second; break; @@ -413,10 +410,10 @@ public: return new_obj; } - void rm_object_attrs(const string &oid, const set<string> &attrs) + void rm_object_attrs(const std::string &oid, const std::set<std::string> &attrs) { ObjectDesc new_obj = get_most_recent(oid); - for (set<string>::const_iterator i = attrs.begin(); + for (std::set<std::string>::const_iterator i = attrs.begin(); i != attrs.end(); ++i) { new_obj.attrs.erase(*i); @@ -426,7 +423,7 @@ public: pool_obj_cont[current_snap].insert_or_assign(oid, new_obj); } - void remove_object_header(const string &oid) + void remove_object_header(const std::string &oid) { ObjectDesc new_obj = get_most_recent(oid); new_obj.header = bufferlist(); @@ -436,7 +433,7 @@ public: } - void update_object_header(const string &oid, const bufferlist &bl) + void update_object_header(const std::string &oid, const bufferlist &bl) { ObjectDesc new_obj = get_most_recent(oid); new_obj.header = bl; @@ -446,11 +443,11 @@ public: pool_obj_cont[current_snap].insert_or_assign(oid, new_obj); } - void update_object_attrs(const string &oid, const map<string, ContDesc> &attrs) + void update_object_attrs(const std::string &oid, const std::map<std::string, ContDesc> &attrs) { ObjectDesc new_obj = get_most_recent(oid); - for (map<string, ContDesc>::const_iterator i = attrs.begin(); - i != attrs.end(); + for (auto i = attrs.cbegin(); + i != attrs.cend(); ++i) { new_obj.attrs[i->first] = i->second; } @@ -461,7 +458,7 @@ public: } void update_object(ContentsGenerator *cont_gen, - const string &oid, const ContDesc &contents) + const std::string &oid, const ContDesc &contents) { ObjectDesc new_obj = get_most_recent(oid); new_obj.exists = true; @@ -472,54 +469,52 @@ public: pool_obj_cont[current_snap].insert_or_assign(oid, new_obj); } - void update_object_full(const string &oid, const ObjectDesc &contents) + void update_object_full(const std::string &oid, const ObjectDesc &contents) { pool_obj_cont[current_snap].insert_or_assign(oid, contents); pool_obj_cont[current_snap][oid].dirty = true; } - void update_object_undirty(const string &oid) + void update_object_undirty(const std::string &oid) { ObjectDesc new_obj = get_most_recent(oid); new_obj.dirty = false; pool_obj_cont[current_snap].insert_or_assign(oid, new_obj); } - void update_object_version(const string &oid, uint64_t version, + void update_object_version(const std::string &oid, uint64_t version, int snap = -1) { - for (map<int, map<string,ObjectDesc> >::reverse_iterator i = - pool_obj_cont.rbegin(); + for (auto i = pool_obj_cont.rbegin(); i != pool_obj_cont.rend(); ++i) { if (snap != -1 && snap < i->first) continue; - map<string,ObjectDesc>::iterator j = i->second.find(oid); + std::map<std::string,ObjectDesc>::iterator j = i->second.find(oid); if (j != i->second.end()) { if (version) j->second.version = version; - cout << __func__ << " oid " << oid - << " v " << version << " " << j->second.most_recent() - << " " << (j->second.dirty ? "dirty" : "clean") - << " " << (j->second.exists ? "exists" : "dne") - << std::endl; + std::cout << __func__ << " oid " << oid + << " v " << version << " " << j->second.most_recent() + << " " << (j->second.dirty ? "dirty" : "clean") + << " " << (j->second.exists ? "exists" : "dne") + << std::endl; break; } } } - void remove_object(const string &oid) + void remove_object(const std::string &oid) { ceph_assert(!get_watch_context(oid)); ObjectDesc new_obj; pool_obj_cont[current_snap].insert_or_assign(oid, new_obj); } - bool find_object(const string &oid, ObjectDesc *contents, int snap = -1) const + bool find_object(const std::string &oid, ObjectDesc *contents, int snap = -1) const { - for (map<int, map<string,ObjectDesc> >::const_reverse_iterator i = - pool_obj_cont.rbegin(); - i != pool_obj_cont.rend(); + for (auto i = pool_obj_cont.crbegin(); + i != pool_obj_cont.crend(); ++i) { if (snap != -1 && snap < i->first) continue; if (i->second.count(oid) != 0) { @@ -530,16 +525,15 @@ public: return false; } - void update_object_redirect_target(const string &oid, const string &target) + void update_object_redirect_target(const std::string &oid, const std::string &target) { redirect_objs[oid] = target; } - void update_object_chunk_target(const string &oid, uint64_t offset, const ChunkDesc &info) + void update_object_chunk_target(const std::string &oid, uint64_t offset, const ChunkDesc &info) { - for (map<int, map<string,ObjectDesc> >::const_reverse_iterator i = - pool_obj_cont.rbegin(); - i != pool_obj_cont.rend(); + for (auto i = pool_obj_cont.crbegin(); + i != pool_obj_cont.crend(); ++i) { if (i->second.count(oid) != 0) { ObjectDesc obj_desc = i->second.find(oid)->second; @@ -551,7 +545,7 @@ public: return; } - bool object_existed_at(const string &oid, int snap = -1) const + bool object_existed_at(const std::string &oid, int snap = -1) const { ObjectDesc contents; bool found = find_object(oid, &contents, snap); @@ -560,17 +554,15 @@ public: void remove_snap(int snap) { - map<int, map<string,ObjectDesc> >::iterator next_iter = pool_obj_cont.find(snap); + std::map<int, std::map<std::string,ObjectDesc> >::iterator next_iter = pool_obj_cont.find(snap); ceph_assert(next_iter != pool_obj_cont.end()); - map<int, map<string,ObjectDesc> >::iterator current_iter = next_iter++; + std::map<int, std::map<std::string,ObjectDesc> >::iterator current_iter = next_iter++; ceph_assert(current_iter != pool_obj_cont.end()); - map<string,ObjectDesc> ¤t = current_iter->second; - map<string,ObjectDesc> &next = next_iter->second; - for (map<string,ObjectDesc>::iterator i = current.begin(); - i != current.end(); - ++i) { + std::map<std::string,ObjectDesc> ¤t = current_iter->second; + std::map<std::string,ObjectDesc> &next = next_iter->second; + for (auto i = current.begin(); i != current.end(); ++i) { if (next.count(i->first) == 0) { - next.insert(pair<string,ObjectDesc>(i->first, i->second)); + next.insert(std::pair<std::string,ObjectDesc>(i->first, i->second)); } } pool_obj_cont.erase(current_iter); @@ -585,7 +577,7 @@ public: seq = snap; } - void roll_back(const string &oid, int snap) + void roll_back(const std::string &oid, int snap) { ceph_assert(!get_watch_context(oid)); ObjectDesc contents; @@ -595,15 +587,14 @@ public: pool_obj_cont.rbegin()->second.insert_or_assign(oid, contents); } - void update_object_tier_flushed(const string &oid, int snap) + void update_object_tier_flushed(const std::string &oid, int snap) { - for (map<int, map<string,ObjectDesc> >::reverse_iterator i = - pool_obj_cont.rbegin(); + for (auto i = pool_obj_cont.rbegin(); i != pool_obj_cont.rend(); ++i) { if (snap != -1 && snap < i->first) continue; - map<string,ObjectDesc>::iterator j = i->second.find(oid); + std::map<std::string,ObjectDesc>::iterator j = i->second.find(oid); if (j != i->second.end()) { j->second.flushed = true; break; @@ -611,20 +602,19 @@ public: } } - bool check_oldest_snap_flushed(const string &oid, int snap) + bool check_oldest_snap_flushed(const std::string &oid, int snap) { - for (map<int, map<string,ObjectDesc> >::reverse_iterator i = - pool_obj_cont.rbegin(); + for (auto i = pool_obj_cont.rbegin(); i != pool_obj_cont.rend(); ++i) { if (snap != -1 && snap < i->first) continue; - map<string,ObjectDesc>::iterator j = i->second.find(oid); + std::map<std::string,ObjectDesc>::iterator j = i->second.find(oid); if (j != i->second.end() && !j->second.flushed) { - cout << __func__ << " oid " << oid - << " v " << j->second.version << " " << j->second.most_recent() - << " " << (j->second.flushed ? "flushed" : "unflushed") - << " " << i->first << std::endl; + std::cout << __func__ << " oid " << oid + << " v " << j->second.version << " " << j->second.most_recent() + << " " << (j->second.flushed ? "flushed" : "unflushed") + << " " << i->first << std::endl; return false; } } @@ -654,7 +644,7 @@ public: std::vector<librados::ObjectItem> result; int r = chunk_pool_ctx.object_list(c, shard_end, 12, {}, &result, &c); if (r < 0) { - cerr << "error object_list : " << cpp_strerror(r) << std::endl; + std::cerr << "error object_list : " << cpp_strerror(r) << std::endl; return false; } @@ -691,7 +681,7 @@ public: break; } if (src_refcount > dst_refcount) { - cerr << " src_object " << pp + std::cerr << " src_object " << pp << ": src_refcount " << src_refcount << ", dst_object " << oid << ": dst_refcount " << dst_refcount @@ -712,11 +702,11 @@ void write_callback(librados::completion_t comp, void *arg); /// entries if @c no_omap is not specified in context class RemoveAttrsOp : public TestOp { public: - string oid; + std::string oid; librados::ObjectWriteOperation op; librados::AioCompletion *comp; RemoveAttrsOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), oid(oid), comp(NULL) {} @@ -724,7 +714,7 @@ public: void _begin() override { ContDesc cont; - set<string> to_remove; + std::set<std::string> to_remove; { std::lock_guard l{context->state_lock}; ObjectDesc obj; @@ -740,7 +730,7 @@ public: if (rand() % 30) { ContentsGenerator::iterator iter = context->attr_gen.get_iterator(cont); - for (map<string, ContDesc>::iterator i = obj.attrs.begin(); + for (auto i = obj.attrs.begin(); i != obj.attrs.end(); ++i, ++iter) { if (!(*iter % 3)) { @@ -762,7 +752,7 @@ public: if (!context->no_omap) { op.omap_clear(); } - for (map<string, ContDesc>::iterator i = obj.attrs.begin(); + for (auto i = obj.attrs.begin(); i != obj.attrs.end(); ++i) { op.rmxattr(i->first.c_str()); @@ -773,8 +763,8 @@ public: context->rm_object_attrs(oid, to_remove); } - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); @@ -796,7 +786,7 @@ public: return done; } - string getType() override + std::string getType() override { return "RemoveAttrsOp"; } @@ -806,12 +796,12 @@ public: /// entries if @c no_omap is not specified in context class SetAttrsOp : public TestOp { public: - string oid; + std::string oid; librados::ObjectWriteOperation op; librados::AioCompletion *comp; SetAttrsOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), oid(oid), comp(NULL) @@ -828,8 +818,8 @@ public: context->oid_not_in_use.erase(oid); } - map<string, bufferlist> omap_contents; - map<string, ContDesc> omap; + std::map<std::string, bufferlist> omap_contents; + std::map<std::string, ContDesc> omap; bufferlist header; ContentsGenerator::iterator keygen = context->attr_gen.get_iterator(cont); op.create(false); @@ -840,7 +830,7 @@ public: ++keygen; } for (int i = 0; i < 20; ++i) { - string key; + std::string key; while (!*keygen) ++keygen; while (*keygen && key.size() < 40) { key.push_back((*keygen % 20) + 'a'); @@ -865,8 +855,8 @@ public: context->update_object_attrs(oid, omap); } - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); context->io_ctx.aio_operate(context->prefix+oid, comp, &op); @@ -877,7 +867,7 @@ public: std::lock_guard l{context->state_lock}; int r; if ((r = comp->get_return_value())) { - cerr << "err " << r << std::endl; + std::cerr << "err " << r << std::endl; ceph_abort(); } done = true; @@ -892,7 +882,7 @@ public: return done; } - string getType() override + std::string getType() override { return "SetAttrsOp"; } @@ -900,9 +890,9 @@ public: class WriteOp : public TestOp { public: - const string oid; + const std::string oid; ContDesc cont; - set<librados::AioCompletion *> waiting; + std::set<librados::AioCompletion *> waiting; librados::AioCompletion *rcompletion = nullptr; // numbers of async ops submitted uint64_t waiting_on = 0; @@ -917,7 +907,7 @@ public: WriteOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, bool do_append, bool do_excl, TestOpStat *stat = 0) @@ -930,10 +920,10 @@ public: void _begin() override { assert(!done); - stringstream acc; + std::stringstream acc; std::lock_guard state_locker{context->state_lock}; acc << context->prefix << "OID: " << oid << " snap " << context->current_snap << std::endl; - string prefix = acc.str(); + std::string prefix = acc.str(); cont = ContDesc(context->seq_num, context->current_snap, context->seq_num, prefix); @@ -968,7 +958,7 @@ public: context->oid_in_use.insert(oid); context->oid_not_in_use.erase(oid); - map<uint64_t, uint64_t> ranges; + std::map<uint64_t, uint64_t> ranges; cont_gen->get_ranges_map(cont, ranges); std::cout << num << ": seq_num " << context->seq_num << " ranges " << ranges << std::endl; @@ -987,7 +977,7 @@ public: << " from " << offset << " to " << len + offset << " tid " << tid << std::endl; auto cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(tid++)); librados::AioCompletion *completion = context->rados.aio_create_completion((void*) cb_arg, &write_callback); @@ -1007,8 +997,8 @@ public: bufferlist contbl; encode(cont, contbl); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>( + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>( this, new TestOp::CallbackInfo(tid++)); librados::AioCompletion *completion = context->rados.aio_create_completion( @@ -1023,7 +1013,7 @@ public: context->prefix+oid, completion, &write_op); cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>( + new std::pair<TestOp*, TestOp::CallbackInfo*>( this, new TestOp::CallbackInfo(tid++)); rcompletion = context->rados.aio_create_completion( @@ -1043,10 +1033,10 @@ public: std::lock_guard state_locker{context->state_lock}; uint64_t tid = info->id; - cout << num << ": finishing write tid " << tid << " to " << context->prefix + oid << std::endl; + std::cout << num << ": finishing write tid " << tid << " to " << context->prefix + oid << std::endl; if (tid <= last_acked_tid) { - cerr << "Error: finished tid " << tid + std::cerr << "Error: finished tid " << tid << " when last_acked_tid was " << last_acked_tid << std::endl; ceph_abort(); } @@ -1056,25 +1046,23 @@ public: waiting_on--; if (waiting_on == 0) { uint64_t version = 0; - for (set<librados::AioCompletion *>::iterator i = waiting.begin(); - i != waiting.end(); - ) { + for (auto i = waiting.begin(); i != waiting.end();) { ceph_assert((*i)->is_complete()); if (int err = (*i)->get_return_value()) { - cerr << "Error: oid " << oid << " write returned error code " - << err << std::endl; + std::cerr << "Error: oid " << oid << " write returned error code " + << err << std::endl; } if ((*i)->get_version64() > version) version = (*i)->get_version64(); (*i)->release(); waiting.erase(i++); } - + context->update_object_version(oid, version); if (rcompletion->get_version64() != version) { - cerr << "Error: racing read on " << oid << " returned version " - << rcompletion->get_version64() << " rather than version " - << version << std::endl; + std::cerr << "Error: racing read on " << oid << " returned version " + << rcompletion->get_version64() << " rather than version " + << version << std::endl; ceph_abort_msg("racing read got wrong version"); } @@ -1101,7 +1089,7 @@ public: return done; } - string getType() override + std::string getType() override { return "WriteOp"; } @@ -1109,9 +1097,9 @@ public: class WriteSameOp : public TestOp { public: - string oid; + std::string oid; ContDesc cont; - set<librados::AioCompletion *> waiting; + std::set<librados::AioCompletion *> waiting; librados::AioCompletion *rcompletion; uint64_t waiting_on; uint64_t last_acked_tid; @@ -1122,7 +1110,7 @@ public: WriteSameOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid), rcompletion(NULL), waiting_on(0), @@ -1133,9 +1121,9 @@ public: { std::lock_guard state_locker{context->state_lock}; done = 0; - stringstream acc; + std::stringstream acc; acc << context->prefix << "OID: " << oid << " snap " << context->current_snap << std::endl; - string prefix = acc.str(); + std::string prefix = acc.str(); cont = ContDesc(context->seq_num, context->current_snap, context->seq_num, prefix); @@ -1147,7 +1135,7 @@ public: context->oid_in_use.insert(oid); context->oid_not_in_use.erase(oid); - map<uint64_t, uint64_t> ranges; + std::map<uint64_t, uint64_t> ranges; cont_gen->get_ranges_map(cont, ranges); std::cout << num << ": seq_num " << context->seq_num << " ranges " << ranges << std::endl; @@ -1166,7 +1154,7 @@ public: << " from " << offset << " to " << offset + len << " tid " << tid << std::endl; auto cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(tid++)); librados::AioCompletion *completion = context->rados.aio_create_completion((void*) cb_arg, @@ -1183,8 +1171,8 @@ public: bufferlist contbl; encode(cont, contbl); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>( + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>( this, new TestOp::CallbackInfo(tid++)); librados::AioCompletion *completion = context->rados.aio_create_completion( @@ -1197,7 +1185,7 @@ public: context->prefix+oid, completion, &write_op); cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>( + new std::pair<TestOp*, TestOp::CallbackInfo*>( this, new TestOp::CallbackInfo(tid++)); rcompletion = context->rados.aio_create_completion( @@ -1217,10 +1205,10 @@ public: std::lock_guard state_locker{context->state_lock}; uint64_t tid = info->id; - cout << num << ": finishing writesame tid " << tid << " to " << context->prefix + oid << std::endl; + std::cout << num << ": finishing writesame tid " << tid << " to " << context->prefix + oid << std::endl; if (tid <= last_acked_tid) { - cerr << "Error: finished tid " << tid + std::cerr << "Error: finished tid " << tid << " when last_acked_tid was " << last_acked_tid << std::endl; ceph_abort(); } @@ -1230,12 +1218,10 @@ public: waiting_on--; if (waiting_on == 0) { uint64_t version = 0; - for (set<librados::AioCompletion *>::iterator i = waiting.begin(); - i != waiting.end(); - ) { + for (auto i = waiting.begin(); i != waiting.end();) { ceph_assert((*i)->is_complete()); if (int err = (*i)->get_return_value()) { - cerr << "Error: oid " << oid << " writesame returned error code " + std::cerr << "Error: oid " << oid << " writesame returned error code " << err << std::endl; } if ((*i)->get_version64() > version) @@ -1248,9 +1234,9 @@ public: ceph_assert(rcompletion->is_complete()); ceph_assert(rcompletion->get_return_value() == 1); if (rcompletion->get_version64() != version) { - cerr << "Error: racing read on " << oid << " returned version " - << rcompletion->get_version64() << " rather than version " - << version << std::endl; + std::cerr << "Error: racing read on " << oid << " returned version " + << rcompletion->get_version64() << " rather than version " + << version << std::endl; ceph_abort_msg("racing read got wrong version"); } rcompletion->release(); @@ -1277,7 +1263,7 @@ public: return done; } - string getType() override + std::string getType() override { return "WriteSameOp"; } @@ -1285,11 +1271,11 @@ public: class DeleteOp : public TestOp { public: - string oid; + std::string oid; DeleteOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid) {} @@ -1325,7 +1311,7 @@ public: r = context->io_ctx.remove(context->prefix+oid); } if (r && !(r == -ENOENT && !present)) { - cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; + std::cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; ceph_abort(); } @@ -1335,7 +1321,7 @@ public: context->kick(); } - string getType() override + std::string getType() override { return "DeleteOp"; } @@ -1343,9 +1329,9 @@ public: class ReadOp : public TestOp { public: - vector<librados::AioCompletion *> completions; + std::vector<librados::AioCompletion *> completions; librados::ObjectReadOperation op; - string oid; + std::string oid; ObjectDesc old_value; int snap; bool balance_reads; @@ -1353,28 +1339,28 @@ public: std::shared_ptr<int> in_use; - vector<bufferlist> results; - vector<int> retvals; - vector<std::map<uint64_t, uint64_t>> extent_results; - vector<bool> is_sparse_read; + std::vector<bufferlist> results; + std::vector<int> retvals; + std::vector<std::map<uint64_t, uint64_t>> extent_results; + std::vector<bool> is_sparse_read; uint64_t waiting_on; - vector<bufferlist> checksums; - vector<int> checksum_retvals; + std::vector<bufferlist> checksums; + std::vector<int> checksum_retvals; - map<string, bufferlist> attrs; + std::map<std::string, bufferlist> attrs; int attrretval; - set<string> omap_requested_keys; - map<string, bufferlist> omap_returned_values; - set<string> omap_keys; - map<string, bufferlist> omap; + std::set<std::string> omap_requested_keys; + std::map<std::string, bufferlist> omap_returned_values; + std::set<std::string> omap_keys; + std::map<std::string, bufferlist> omap; bufferlist header; - map<string, bufferlist> xattrs; + std::map<std::string, bufferlist> xattrs; ReadOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, bool balance_reads, bool localize_reads, TestOpStat *stat = 0) @@ -1464,11 +1450,9 @@ public: context->io_ctx.snap_set_read(context->snaps[snap]); } _do_read(op, 0); - for (map<string, ContDesc>::iterator i = old_value.attrs.begin(); - i != old_value.attrs.end(); - ++i) { + for (auto i = old_value.attrs.begin(); i != old_value.attrs.end(); ++i) { if (rand() % 2) { - string key = i->first; + std::string key = i->first; if (rand() % 2) key.push_back((rand() % 26) + 'a'); omap_requested_keys.insert(key); @@ -1520,34 +1504,34 @@ public: context->oid_in_use.erase(oid); context->oid_not_in_use.insert(oid); int retval = completions[0]->get_return_value(); - for (vector<librados::AioCompletion *>::iterator it = completions.begin(); + for (auto it = completions.begin(); it != completions.end(); ++it) { ceph_assert((*it)->is_complete()); uint64_t version = (*it)->get_version64(); int err = (*it)->get_return_value(); if (err != retval) { - cerr << num << ": Error: oid " << oid << " read returned different error codes: " + std::cerr << num << ": Error: oid " << oid << " read returned different error codes: " << retval << " and " << err << std::endl; ceph_abort(); } if (err) { if (!(err == -ENOENT && old_value.deleted())) { - cerr << num << ": Error: oid " << oid << " read returned error code " + std::cerr << num << ": Error: oid " << oid << " read returned error code " << err << std::endl; ceph_abort(); } } else if (version != old_value.version) { - cerr << num << ": oid " << oid << " version is " << version - << " and expected " << old_value.version << std::endl; + std::cerr << num << ": oid " << oid << " version is " << version + << " and expected " << old_value.version << std::endl; ceph_assert(version == old_value.version); } } if (!retval) { - map<string, bufferlist>::iterator iter = xattrs.find("_header"); + std::map<std::string, bufferlist>::iterator iter = xattrs.find("_header"); bufferlist headerbl; if (iter == xattrs.end()) { if (old_value.has_contents()) { - cerr << num << ": Error: did not find header attr, has_contents: " + std::cerr << num << ": Error: did not find header attr, has_contents: " << old_value.has_contents() << std::endl; ceph_assert(!old_value.has_contents()); @@ -1567,19 +1551,19 @@ public: auto p = headerbl.cbegin(); decode(to_check, p); if (to_check != old_value.most_recent()) { - cerr << num << ": oid " << oid << " found incorrect object contents " << to_check + std::cerr << num << ": oid " << oid << " found incorrect object contents " << to_check << ", expected " << old_value.most_recent() << std::endl; context->errors++; } for (unsigned i = 0; i < results.size(); i++) { if (is_sparse_read[i]) { if (!old_value.check_sparse(extent_results[i], results[i])) { - cerr << num << ": oid " << oid << " contents " << to_check << " corrupt" << std::endl; + std::cerr << num << ": oid " << oid << " contents " << to_check << " corrupt" << std::endl; context->errors++; } } else { if (!old_value.check(results[i])) { - cerr << num << ": oid " << oid << " contents " << to_check << " corrupt" << std::endl; + std::cerr << num << ": oid " << oid << " contents " << to_check << " corrupt" << std::endl; context->errors++; } @@ -1595,7 +1579,7 @@ public: } } if (checksum_retvals[i] != 0 || checksum != results[i].crc32c(-1)) { - cerr << num << ": oid " << oid << " checksum " << checksums[i] + std::cerr << num << ": oid " << oid << " checksum " << checksums[i] << " incorrect, expecting " << results[i].crc32c(-1) << std::endl; context->errors++; @@ -1608,34 +1592,34 @@ public: // Attributes if (!context->no_omap) { if (!(old_value.header == header)) { - cerr << num << ": oid " << oid << " header does not match, old size: " + std::cerr << num << ": oid " << oid << " header does not match, old size: " << old_value.header.length() << " new size " << header.length() << std::endl; ceph_assert(old_value.header == header); } if (omap.size() != old_value.attrs.size()) { - cerr << num << ": oid " << oid << " omap.size() is " << omap.size() + std::cerr << num << ": oid " << oid << " omap.size() is " << omap.size() << " and old is " << old_value.attrs.size() << std::endl; ceph_assert(omap.size() == old_value.attrs.size()); } if (omap_keys.size() != old_value.attrs.size()) { - cerr << num << ": oid " << oid << " omap.size() is " << omap_keys.size() + std::cerr << num << ": oid " << oid << " omap.size() is " << omap_keys.size() << " and old is " << old_value.attrs.size() << std::endl; ceph_assert(omap_keys.size() == old_value.attrs.size()); } } if (xattrs.size() != old_value.attrs.size()) { - cerr << num << ": oid " << oid << " xattrs.size() is " << xattrs.size() - << " and old is " << old_value.attrs.size() << std::endl; + std::cerr << num << ": oid " << oid << " xattrs.size() is " << xattrs.size() + << " and old is " << old_value.attrs.size() << std::endl; ceph_assert(xattrs.size() == old_value.attrs.size()); } - for (map<string, ContDesc>::iterator iter = old_value.attrs.begin(); + for (auto iter = old_value.attrs.begin(); iter != old_value.attrs.end(); ++iter) { bufferlist bl = context->attr_gen.gen_bl( iter->second); if (!context->no_omap) { - map<string, bufferlist>::iterator omap_iter = omap.find(iter->first); + std::map<std::string, bufferlist>::iterator omap_iter = omap.find(iter->first); ceph_assert(omap_iter != omap.end()); ceph_assert(bl.length() == omap_iter->second.length()); bufferlist::iterator k = bl.begin(); @@ -1645,7 +1629,7 @@ public: ceph_assert(*l == *k); } } - map<string, bufferlist>::iterator xattr_iter = xattrs.find(iter->first); + auto xattr_iter = xattrs.find(iter->first); ceph_assert(xattr_iter != xattrs.end()); ceph_assert(bl.length() == xattr_iter->second.length()); bufferlist::iterator k = bl.begin(); @@ -1656,7 +1640,7 @@ public: } } if (!context->no_omap) { - for (set<string>::iterator i = omap_requested_keys.begin(); + for (std::set<std::string>::iterator i = omap_requested_keys.begin(); i != omap_requested_keys.end(); ++i) { if (!omap_returned_values.count(*i)) @@ -1664,7 +1648,7 @@ public: if (!old_value.attrs.count(*i)) ceph_assert(!omap_returned_values.count(*i)); } - for (map<string, bufferlist>::iterator i = omap_returned_values.begin(); + for (auto i = omap_returned_values.begin(); i != omap_returned_values.end(); ++i) { ceph_assert(omap_requested_keys.count(i->first)); @@ -1674,8 +1658,7 @@ public: } } } - for (vector<librados::AioCompletion *>::iterator it = completions.begin(); - it != completions.end(); ++it) { + for (auto it = completions.begin(); it != completions.end(); ++it) { (*it)->release(); } context->kick(); @@ -1687,7 +1670,7 @@ public: return done; } - string getType() override + std::string getType() override { return "ReadOp"; } @@ -1704,17 +1687,17 @@ public: void _begin() override { uint64_t snap; - string snapname; + std::string snapname; if (context->pool_snaps) { - stringstream ss; + std::stringstream ss; ss << context->prefix << "snap" << ++context->snapname_num; snapname = ss.str(); int ret = context->io_ctx.snap_create(snapname.c_str()); if (ret) { - cerr << "snap_create returned " << ret << std::endl; + std::cerr << "snap_create returned " << ret << std::endl; ceph_abort(); } ceph_assert(!context->io_ctx.snap_lookup(snapname.c_str(), &snap)); @@ -1727,10 +1710,10 @@ public: context->add_snap(snap); if (!context->pool_snaps) { - vector<uint64_t> snapset(context->snaps.size()); + std::vector<uint64_t> snapset(context->snaps.size()); int j = 0; - for (map<int,uint64_t>::reverse_iterator i = context->snaps.rbegin(); + for (auto i = context->snaps.rbegin(); i != context->snaps.rend(); ++i, ++j) { snapset[j] = i->second; @@ -1740,13 +1723,13 @@ public: int r = context->io_ctx.selfmanaged_snap_set_write_ctx(context->seq, snapset); if (r) { - cerr << "r is " << r << " snapset is " << snapset << " seq is " << context->seq << std::endl; + std::cerr << "r is " << r << " snapset is " << snapset << " seq is " << context->seq << std::endl; ceph_abort(); } } } - string getType() override + std::string getType() override { return "SnapCreateOp"; } @@ -1770,16 +1753,16 @@ public: context->remove_snap(to_remove); if (context->pool_snaps) { - string snapname; + std::string snapname; ceph_assert(!context->io_ctx.snap_get_name(snap, &snapname)); ceph_assert(!context->io_ctx.snap_remove(snapname.c_str())); } else { ceph_assert(!context->io_ctx.selfmanaged_snap_remove(snap)); - vector<uint64_t> snapset(context->snaps.size()); + std::vector<uint64_t> snapset(context->snaps.size()); int j = 0; - for (map<int,uint64_t>::reverse_iterator i = context->snaps.rbegin(); + for (auto i = context->snaps.rbegin(); i != context->snaps.rend(); ++i, ++j) { snapset[j] = i->second; @@ -1787,24 +1770,24 @@ public: int r = context->io_ctx.selfmanaged_snap_set_write_ctx(context->seq, snapset); if (r) { - cerr << "r is " << r << " snapset is " << snapset << " seq is " << context->seq << std::endl; + std::cerr << "r is " << r << " snapset is " << snapset << " seq is " << context->seq << std::endl; ceph_abort(); } } } - string getType() override + std::string getType() override { return "SnapRemoveOp"; } }; class WatchOp : public TestOp { - string oid; + std::string oid; public: WatchOp(int n, RadosTestContext *context, - const string &_oid, + const std::string &_oid, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(_oid) @@ -1843,7 +1826,7 @@ public: } if (r) { - cerr << "r is " << r << std::endl; + std::cerr << "r is " << r << std::endl; ceph_abort(); } @@ -1854,7 +1837,7 @@ public: } } - string getType() override + std::string getType() override { return "WatchOp"; } @@ -1862,19 +1845,19 @@ public: class RollbackOp : public TestOp { public: - string oid; + std::string oid; int roll_back_to; librados::ObjectWriteOperation zero_write_op1; librados::ObjectWriteOperation zero_write_op2; librados::ObjectWriteOperation op; - vector<librados::AioCompletion *> comps; + std::vector<librados::AioCompletion *> comps; std::shared_ptr<int> in_use; int last_finished; int outstanding; RollbackOp(int n, RadosTestContext *context, - const string &_oid, + const std::string &_oid, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(_oid), roll_back_to(-1), @@ -1907,7 +1890,7 @@ public: roll_back_to); - cout << "rollback oid " << oid << " to " << roll_back_to << std::endl; + std::cout << "rollback oid " << oid << " to " << roll_back_to << std::endl; bool existed_before = context->object_existed_at(oid); bool existed_after = context->object_existed_at(oid, roll_back_to); @@ -1930,8 +1913,8 @@ public: } if (existed_before) { - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comps[0] = context->rados.aio_create_completion((void*) cb_arg, @@ -1940,8 +1923,8 @@ public: context->prefix+oid, comps[0], &zero_write_op1); } { - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(1)); comps[1] = context->rados.aio_create_completion((void*) cb_arg, @@ -1950,8 +1933,8 @@ public: context->prefix+oid, comps[1], &op); } if (existed_after) { - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(2)); comps[2] = context->rados.aio_create_completion((void*) cb_arg, @@ -1965,14 +1948,14 @@ public: { std::lock_guard l{context->state_lock}; uint64_t tid = info->id; - cout << num << ": finishing rollback tid " << tid + std::cout << num << ": finishing rollback tid " << tid << " to " << context->prefix + oid << std::endl; ceph_assert((int)(info->id) > last_finished); last_finished = info->id; int r; if ((r = comps[last_finished]->get_return_value()) != 0) { - cerr << "err " << r << std::endl; + std::cerr << "err " << r << std::endl; ceph_abort(); } if (--outstanding == 0) { @@ -1990,7 +1973,7 @@ public: return done; } - string getType() override + std::string getType() override { return "RollBackOp"; } @@ -1998,7 +1981,7 @@ public: class CopyFromOp : public TestOp { public: - string oid, oid_src; + std::string oid, oid_src; ObjectDesc src_value; librados::ObjectWriteOperation op; librados::ObjectReadOperation rd_op; @@ -2011,8 +1994,8 @@ public: int r; CopyFromOp(int n, RadosTestContext *context, - const string &oid, - const string &oid_src, + const std::string &oid, + const std::string &oid_src, TestOpStat *stat) : TestOp(n, context, stat), oid(oid), oid_src(oid_src), @@ -2044,19 +2027,19 @@ public: context->update_object_full(oid, src_value); } - string src = context->prefix+oid_src; + std::string src = context->prefix+oid_src; op.copy_from(src.c_str(), context->io_ctx, src_value.version, 0); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); context->io_ctx.aio_operate(context->prefix+oid, comp, &op); // queue up a racing read, too. - pair<TestOp*, TestOp::CallbackInfo*> *read_cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *read_cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(1)); comp_racing_read = context->rados.aio_create_completion((void*) read_cb_arg, &write_callback); rd_op.stat(NULL, NULL, NULL); @@ -2077,12 +2060,12 @@ public: if (info->id == 0) { // copy_from ceph_assert(comp->is_complete()); - cout << num << ": finishing copy_from to " << context->prefix + oid << std::endl; + std::cout << num << ": finishing copy_from to " << context->prefix + oid << std::endl; if ((r = comp->get_return_value())) { if (r == -ENOENT && src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else { - cerr << "Error: oid " << oid << " copy_from " << oid_src << " returned error code " + std::cerr << "Error: oid " << oid << " copy_from " << oid_src << " returned error code " << r << std::endl; ceph_abort(); } @@ -2094,10 +2077,10 @@ public: } else if (info->id == 1) { // racing read ceph_assert(comp_racing_read->is_complete()); - cout << num << ": finishing copy_from racing read to " << context->prefix + oid << std::endl; + std::cout << num << ": finishing copy_from racing read to " << context->prefix + oid << std::endl; if ((r = comp_racing_read->get_return_value())) { if (!(r == -ENOENT && src_value.deleted())) { - cerr << "Error: oid " << oid << " copy_from " << oid_src << " returned error code " + std::cerr << "Error: oid " << oid << " copy_from " << oid_src << " returned error code " << r << std::endl; } } else { @@ -2120,7 +2103,7 @@ public: return done == 2; } - string getType() override + std::string getType() override { return "CopyFromOp"; } @@ -2128,9 +2111,9 @@ public: class ChunkReadOp : public TestOp { public: - vector<librados::AioCompletion *> completions; + std::vector<librados::AioCompletion *> completions; librados::ObjectReadOperation op; - string oid; + std::string oid; ObjectDesc old_value; ObjectDesc tgt_value; int snap; @@ -2139,23 +2122,23 @@ public: std::shared_ptr<int> in_use; - vector<bufferlist> results; - vector<int> retvals; - vector<bool> is_sparse_read; + std::vector<bufferlist> results; + std::vector<int> retvals; + std::vector<bool> is_sparse_read; uint64_t waiting_on; - vector<bufferlist> checksums; - vector<int> checksum_retvals; + std::vector<bufferlist> checksums; + std::vector<int> checksum_retvals; uint32_t offset = 0; uint32_t length = 0; - string tgt_oid; - string tgt_pool_name; + std::string tgt_oid; + std::string tgt_pool_name; uint32_t tgt_offset = 0; ChunkReadOp(int n, RadosTestContext *context, - const string &oid, - const string &tgt_pool_name, + const std::string &oid, + const std::string &tgt_pool_name, bool balance_reads, bool localize_reads, TestOpStat *stat = 0) @@ -2292,13 +2275,13 @@ public: ceph_assert(completions[i]->is_complete()); int err = completions[i]->get_return_value(); if (err != retval) { - cerr << num << ": Error: oid " << oid << " read returned different error codes: " + std::cerr << num << ": Error: oid " << oid << " read returned different error codes: " << retval << " and " << err << std::endl; ceph_abort(); } if (err) { if (!(err == -ENOENT && old_value.deleted())) { - cerr << num << ": Error: oid " << oid << " read returned error code " + std::cerr << num << ": Error: oid " << oid << " read returned error code " << err << std::endl; ceph_abort(); } @@ -2326,7 +2309,7 @@ public: } if (checksum_retvals[1] != 0) { - cerr << num << ": oid " << oid << " checksum retvals " << checksums[0] + std::cerr << num << ": oid " << oid << " checksum retvals " << checksums[0] << " error " << std::endl; context->errors++; } @@ -2334,7 +2317,7 @@ public: checksum[0] = results[0].crc32c(-1); if (checksum[0] != checksum[1]) { - cerr << num << ": oid " << oid << " checksum src " << checksum[0] + std::cerr << num << ": oid " << oid << " checksum src " << checksum[0] << " chunksum tgt " << checksum[1] << " incorrect, expecting " << results[0].crc32c(-1) << std::endl; @@ -2343,8 +2326,7 @@ public: if (context->errors) ceph_abort(); } } - for (vector<librados::AioCompletion *>::iterator it = completions.begin(); - it != completions.end(); ++it) { + for (auto it = completions.begin(); it != completions.end(); ++it) { (*it)->release(); } context->kick(); @@ -2356,7 +2338,7 @@ public: return done; } - string getType() override + std::string getType() override { return "ChunkReadOp"; } @@ -2364,7 +2346,7 @@ public: class CopyOp : public TestOp { public: - string oid, oid_src, tgt_pool_name; + std::string oid, oid_src, tgt_pool_name; librados::ObjectWriteOperation op; librados::ObjectReadOperation rd_op; librados::AioCompletion *comp; @@ -2373,9 +2355,9 @@ public: int r; CopyOp(int n, RadosTestContext *context, - const string &oid_src, - const string &oid, - const string &tgt_pool_name, + const std::string &oid_src, + const std::string &oid, + const std::string &tgt_pool_name, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid), oid_src(oid_src), tgt_pool_name(tgt_pool_name), @@ -2388,14 +2370,14 @@ public: context->oid_in_use.insert(oid_src); context->oid_not_in_use.erase(oid_src); - string src = context->prefix+oid_src; + std::string src = context->prefix+oid_src; context->find_object(oid_src, &src_value); op.copy_from(src.c_str(), context->io_ctx, src_value.version, 0); - cout << "copy op oid " << oid_src << " to " << oid << " tgt_pool_name " << tgt_pool_name << std::endl; + std::cout << "copy op oid " << oid_src << " to " << oid << " tgt_pool_name " << tgt_pool_name << std::endl; - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); if (tgt_pool_name == context->low_tier_pool_name) { @@ -2411,10 +2393,10 @@ public: if (info->id == 0) { ceph_assert(comp->is_complete()); - cout << num << ": finishing copy op to oid " << oid << std::endl; + std::cout << num << ": finishing copy op to oid " << oid << std::endl; if ((r = comp->get_return_value())) { - cerr << "Error: oid " << oid << " write returned error code " - << r << std::endl; + std::cerr << "Error: oid " << oid << " write returned error code " + << r << std::endl; ceph_abort(); } } @@ -2431,7 +2413,7 @@ public: return done == 1; } - string getType() override + std::string getType() override { return "CopyOp"; } @@ -2439,7 +2421,7 @@ public: class SetChunkOp : public TestOp { public: - string oid, oid_tgt; + std::string oid, oid_tgt; ObjectDesc src_value, tgt_value; librados::ObjectReadOperation op; librados::AioCompletion *comp; @@ -2452,8 +2434,8 @@ public: std::shared_ptr<int> in_use; SetChunkOp(int n, RadosTestContext *context, - const string &oid, - const string &oid_tgt, + const std::string &oid, + const std::string &oid_tgt, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid), oid_tgt(oid_tgt), @@ -2463,8 +2445,8 @@ public: snap(0) {} - pair<uint64_t, uint64_t> get_rand_off_len(uint32_t max_len) { - pair<uint64_t, uint64_t> r (0, 0); + std::pair<uint64_t, uint64_t> get_rand_off_len(uint32_t max_len) { + std::pair<uint64_t, uint64_t> r (0, 0); r.first = rand() % max_len; r.second = rand() % max_len; r.first = r.first - (r.first % 512); @@ -2501,7 +2483,7 @@ public: } else { max_len = src_value.most_recent_gen()->get_length(src_value.most_recent()); } - pair<uint64_t, uint64_t> off_len; // first: offset, second: length + std::pair<uint64_t, uint64_t> off_len; // first: offset, second: length if (snap >= 0) { context->io_ctx.snap_set_read(context->snaps[snap]); off_len = get_rand_off_len(max_len); @@ -2516,12 +2498,12 @@ public: length = off_len.second; tgt_offset = offset; - string target_oid; + std::string target_oid; if (!src_value.deleted() && oid_tgt.empty()) { bufferlist bl; int r = context->io_ctx.read(context->prefix+oid, bl, length, offset); ceph_assert(r > 0); - string fp_oid = ceph::crypto::digest<ceph::crypto::SHA256>(bl).to_str(); + std::string fp_oid = ceph::crypto::digest<ceph::crypto::SHA256>(bl).to_str(); r = context->low_tier_io_ctx.write(fp_oid, bl, bl.length(), 0); ceph_assert(r == 0); target_oid = fp_oid; @@ -2530,15 +2512,15 @@ public: target_oid = context->prefix+oid_tgt; } - cout << num << ": " << "set_chunk oid " << oid << " offset: " << offset + std::cout << num << ": " << "set_chunk oid " << oid << " offset: " << offset << " length: " << length << " target oid " << target_oid << " offset: " << tgt_offset << " snap " << snap << std::endl; op.set_chunk(offset, length, context->low_tier_io_ctx, target_oid, tgt_offset, CEPH_OSD_OP_FLAG_WITH_REFERENCE); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); @@ -2555,21 +2537,21 @@ public: if (info->id == 0) { ceph_assert(comp->is_complete()); - cout << num << ": finishing set_chunk to oid " << oid << std::endl; + std::cout << num << ": finishing set_chunk to oid " << oid << std::endl; if ((r = comp->get_return_value())) { if (r == -ENOENT && src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else if (r == -ENOENT && context->oid_set_chunk_tgt_pool.find(oid_tgt) != context->oid_set_chunk_tgt_pool.end()) { - cout << num << ": get expected ENOENT tgt oid " << oid_tgt << std::endl; + std::cout << num << ": get expected ENOENT tgt oid " << oid_tgt << std::endl; } else if (r == -ERANGE && src_value.deleted()) { - cout << num << ": got expected ERANGE (src dne)" << std::endl; + std::cout << num << ": got expected ERANGE (src dne)" << std::endl; } else if (r == -EOPNOTSUPP) { - cout << "Range is overlapped: oid " << oid << " set_chunk " << oid_tgt << " returned error code " + std::cout << "Range is overlapped: oid " << oid << " set_chunk " << oid_tgt << " returned error code " << r << " offset: " << offset << " length: " << length << std::endl; context->update_object_version(oid, comp->get_version64()); } else { - cerr << "Error: oid " << oid << " set_chunk " << oid_tgt << " returned error code " + std::cerr << "Error: oid " << oid << " set_chunk " << oid_tgt << " returned error code " << r << std::endl; ceph_abort(); } @@ -2595,7 +2577,7 @@ public: return done == 1; } - string getType() override + std::string getType() override { return "SetChunkOp"; } @@ -2603,7 +2585,7 @@ public: class SetRedirectOp : public TestOp { public: - string oid, oid_tgt, tgt_pool_name; + std::string oid, oid_tgt, tgt_pool_name; ObjectDesc src_value, tgt_value; librados::ObjectWriteOperation op; librados::ObjectReadOperation rd_op; @@ -2613,9 +2595,9 @@ public: int r; SetRedirectOp(int n, RadosTestContext *context, - const string &oid, - const string &oid_tgt, - const string &tgt_pool_name, + const std::string &oid, + const std::string &oid_tgt, + const std::string &tgt_pool_name, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid), oid_tgt(oid_tgt), tgt_pool_name(tgt_pool_name), @@ -2637,14 +2619,14 @@ public: if(!context->redirect_objs[oid].empty()) { /* copy_from oid --> oid_tgt */ comp = context->rados.aio_create_completion(); - string src = context->prefix+oid; + std::string src = context->prefix+oid; op.copy_from(src.c_str(), context->io_ctx, src_value.version, 0); context->low_tier_io_ctx.aio_operate(context->prefix+oid_tgt, comp, &op, librados::OPERATION_ORDER_READS_WRITES); comp->wait_for_complete(); if ((r = comp->get_return_value())) { - cerr << "Error: oid " << oid << " copy_from " << oid_tgt << " returned error code " - << r << std::endl; + std::cerr << "Error: oid " << oid << " copy_from " << oid_tgt << " returned error code " + << r << std::endl; ceph_abort(); } comp->release(); @@ -2659,7 +2641,7 @@ public: comp->wait_for_complete(); if ((r = comp->get_return_value())) { if (!(r == -ENOENT && !present) && r != -EOPNOTSUPP) { - cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; + std::cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; ceph_abort(); } } @@ -2677,7 +2659,7 @@ public: NULL); comp->wait_for_complete(); if ((r = comp->get_return_value()) && !src_value.deleted()) { - cerr << "Error: oid " << oid << " stat returned error code " + std::cerr << "Error: oid " << oid << " stat returned error code " << r << std::endl; ceph_abort(); } @@ -2692,7 +2674,7 @@ public: NULL); comp->wait_for_complete(); if ((r = comp->get_return_value())) { - cerr << "Error: oid " << oid_tgt << " stat returned error code " + std::cerr << "Error: oid " << oid_tgt << " stat returned error code " << r << std::endl; ceph_abort(); } @@ -2706,8 +2688,8 @@ public: op.assert_version(src_value.version); op.set_redirect(context->prefix+oid_tgt, context->low_tier_io_ctx, tgt_version); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp = context->rados.aio_create_completion((void*) cb_arg, &write_callback); context->io_ctx.aio_operate(context->prefix+oid, comp, &op, @@ -2720,12 +2702,12 @@ public: if (info->id == 0) { ceph_assert(comp->is_complete()); - cout << num << ": finishing set_redirect to oid " << oid << std::endl; + std::cout << num << ": finishing set_redirect to oid " << oid << std::endl; if ((r = comp->get_return_value())) { if (r == -ENOENT && src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else { - cerr << "Error: oid " << oid << " set_redirect " << oid_tgt << " returned error code " + std::cerr << "Error: oid " << oid << " set_redirect " << oid_tgt << " returned error code " << r << std::endl; ceph_abort(); } @@ -2747,7 +2729,7 @@ public: return done == 1; } - string getType() override + std::string getType() override { return "SetRedirectOp"; } @@ -2755,13 +2737,13 @@ public: class UnsetRedirectOp : public TestOp { public: - string oid; + std::string oid; librados::ObjectWriteOperation op; librados::AioCompletion *comp = nullptr; UnsetRedirectOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat = 0) : TestOp(n, context, stat), oid(oid) {} @@ -2794,7 +2776,7 @@ public: comp->wait_for_complete(); int r = comp->get_return_value(); if (r && !(r == -ENOENT && !present)) { - cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; + std::cerr << "r is " << r << " while deleting " << oid << " and present is " << present << std::endl; ceph_abort(); } state_locker.lock(); @@ -2803,12 +2785,12 @@ public: if(!context->redirect_objs[oid].empty()) { context->oid_redirect_not_in_use.insert(context->redirect_objs[oid]); context->oid_redirect_in_use.erase(context->redirect_objs[oid]); - context->update_object_redirect_target(oid, string()); + context->update_object_redirect_target(oid, {}); } context->kick(); } - string getType() override + std::string getType() override { return "UnsetRedirectOp"; } @@ -2818,13 +2800,13 @@ class TierPromoteOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectWriteOperation op; - string oid; + std::string oid; std::shared_ptr<int> in_use; ObjectDesc src_value; TierPromoteOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), completion(NULL), @@ -2840,8 +2822,8 @@ public: context->find_object(oid, &src_value); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -2862,11 +2844,11 @@ public: ObjectDesc oid_value; context->find_object(oid, &oid_value); int r = completion->get_return_value(); - cout << num << ": got " << cpp_strerror(r) << std::endl; + std::cout << num << ": got " << cpp_strerror(r) << std::endl; if (r == 0) { // sucess } else if (r == -ENOENT && src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else { ceph_abort_msg("shouldn't happen"); } @@ -2883,7 +2865,7 @@ public: return done; } - string getType() override + std::string getType() override { return "TierPromoteOp"; } @@ -2893,7 +2875,7 @@ class TierFlushOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectReadOperation op; - string oid; + std::string oid; std::shared_ptr<int> in_use; int snap; ObjectDesc src_value; @@ -2901,7 +2883,7 @@ public: TierFlushOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), completion(NULL), @@ -2923,7 +2905,7 @@ public: snap = -1; } - cout << num << ": tier_flush oid " << oid << " snap " << snap << std::endl; + std::cout << num << ": tier_flush oid " << oid << " snap " << snap << std::endl; if (snap >= 0) { context->io_ctx.snap_set_read(context->snaps[snap]); @@ -2931,8 +2913,8 @@ public: context->find_object(oid, &src_value, snap); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -2956,7 +2938,7 @@ public: ceph_assert(completion->is_complete()); int r = completion->get_return_value(); - cout << num << ": got " << cpp_strerror(r) << std::endl; + std::cout << num << ": got " << cpp_strerror(r) << std::endl; if (r == 0) { // sucess context->update_object_tier_flushed(oid, snap); @@ -2967,15 +2949,15 @@ public: } else if (r == -ENOENT) { // could fail if object is removed if (src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else { - cerr << num << ": got unexpected ENOENT" << std::endl; + std::cerr << num << ": got unexpected ENOENT" << std::endl; ceph_abort(); } } else { if (r != -ENOENT && src_value.deleted()) { - cerr << num << ": src dne, but r is not ENOENT" << std::endl; - } + std::cerr << num << ": src dne, but r is not ENOENT" << std::endl; + } ceph_abort_msg("shouldn't happen"); } context->oid_in_use.erase(oid); @@ -2990,7 +2972,7 @@ public: return done; } - string getType() override + std::string getType() override { return "TierFlushOp"; } @@ -3000,14 +2982,14 @@ class TierEvictOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectReadOperation op; - string oid; + std::string oid; std::shared_ptr<int> in_use; int snap; ObjectDesc src_value; TierEvictOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), completion(NULL), @@ -3029,7 +3011,7 @@ public: snap = -1; } - cout << num << ": tier_evict oid " << oid << " snap " << snap << std::endl; + std::cout << num << ": tier_evict oid " << oid << " snap " << snap << std::endl; if (snap >= 0) { context->io_ctx.snap_set_read(context->snaps[snap]); @@ -3037,8 +3019,8 @@ public: context->find_object(oid, &src_value, snap); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -3062,7 +3044,7 @@ public: ceph_assert(completion->is_complete()); int r = completion->get_return_value(); - cout << num << ": got " << cpp_strerror(r) << std::endl; + std::cout << num << ": got " << cpp_strerror(r) << std::endl; if (r == 0) { // ok } else if (r == -EINVAL) { @@ -3072,15 +3054,15 @@ public: } else if (r == -ENOENT) { // could fail if object is removed if (src_value.deleted()) { - cout << num << ": got expected ENOENT (src dne)" << std::endl; + std::cout << num << ": got expected ENOENT (src dne)" << std::endl; } else { - cerr << num << ": got unexpected ENOENT" << std::endl; + std::cerr << num << ": got unexpected ENOENT" << std::endl; ceph_abort(); } } else { if (r != -ENOENT && src_value.deleted()) { - cerr << num << ": src dne, but r is not ENOENT" << std::endl; - } + std::cerr << num << ": src dne, but r is not ENOENT" << std::endl; + } ceph_abort_msg("shouldn't happen"); } context->oid_in_use.erase(oid); @@ -3094,7 +3076,7 @@ public: return done; } - string getType() override + std::string getType() override { return "TierEvictOp"; } @@ -3118,8 +3100,8 @@ public: void _begin() override { - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); comp1 = context->rados.aio_create_completion((void*) cb_arg, &write_callback); @@ -3131,17 +3113,16 @@ public: std::lock_guard l{context->state_lock}; if (!comp2) { if (ls.empty()) { - cerr << num << ": no hitsets" << std::endl; + std::cerr << num << ": no hitsets" << std::endl; done = true; } else { - cerr << num << ": hitsets are " << ls << std::endl; + std::cerr << num << ": hitsets are " << ls << std::endl; int r = rand() % ls.size(); - std::list<pair<time_t,time_t> >::iterator p = ls.begin(); + auto p = ls.begin(); while (r--) ++p; - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, - new TestOp::CallbackInfo(0)); + auto cb_arg = new std::pair<TestOp*, TestOp::CallbackInfo*>( + this, new TestOp::CallbackInfo(0)); comp2 = context->rados.aio_create_completion((void*) cb_arg, &write_callback); r = context->io_ctx.hit_set_get(hash, comp2, p->second, &bl); ceph_assert(r == 0); @@ -3152,9 +3133,9 @@ public: HitSet hitset; auto p = bl.cbegin(); decode(hitset, p); - cout << num << ": got hitset of type " << hitset.get_type_name() - << " size " << bl.length() - << std::endl; + std::cout << num << ": got hitset of type " << hitset.get_type_name() + << " size " << bl.length() + << std::endl; } else { // FIXME: we could verify that we did in fact race with a trim... ceph_assert(r == -ENOENT); @@ -3169,7 +3150,7 @@ public: return done; } - string getType() override { + std::string getType() override { return "HitSetListOp"; } }; @@ -3178,11 +3159,11 @@ class UndirtyOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectWriteOperation op; - string oid; + std::string oid; UndirtyOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat = 0) : TestOp(n, context, stat), completion(NULL), @@ -3192,8 +3173,8 @@ public: void _begin() override { context->state_lock.lock(); - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -3226,7 +3207,7 @@ public: return done; } - string getType() override + std::string getType() override { return "UndirtyOp"; } @@ -3236,7 +3217,7 @@ class IsDirtyOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectReadOperation op; - string oid; + std::string oid; bool dirty; ObjectDesc old_value; int snap = 0; @@ -3244,7 +3225,7 @@ public: IsDirtyOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat = 0) : TestOp(n, context, stat), completion(NULL), @@ -3265,8 +3246,8 @@ public: std::cout << num << ": is_dirty oid " << oid << " snap " << snap << std::endl; - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -3301,11 +3282,11 @@ public: int r = completion->get_return_value(); if (r == 0) { - cout << num << ": " << (dirty ? "dirty" : "clean") << std::endl; + std::cout << num << ": " << (dirty ? "dirty" : "clean") << std::endl; ceph_assert(!old_value.deleted()); ceph_assert(dirty == old_value.dirty); } else { - cout << num << ": got " << r << std::endl; + std::cout << num << ": got " << r << std::endl; ceph_assert(r == -ENOENT); ceph_assert(old_value.deleted()); } @@ -3318,7 +3299,7 @@ public: return done; } - string getType() override + std::string getType() override { return "IsDirtyOp"; } @@ -3330,7 +3311,7 @@ class CacheFlushOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectReadOperation op; - string oid; + std::string oid; bool blocking; int snap; bool can_fail; @@ -3338,7 +3319,7 @@ public: CacheFlushOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat, bool b) : TestOp(n, context, stat), @@ -3365,15 +3346,15 @@ public: // FIXME: we could fail if we've ever removed a snap due to // the async snap trimming. can_fail = true; - cout << num << ": " << (blocking ? "cache_flush" : "cache_try_flush") + std::cout << num << ": " << (blocking ? "cache_flush" : "cache_try_flush") << " oid " << oid << " snap " << snap << std::endl; if (snap >= 0) { context->io_ctx.snap_set_read(context->snaps[snap]); } - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -3405,7 +3386,7 @@ public: context->oid_flushing.erase(oid); context->oid_not_flushing.insert(oid); int r = completion->get_return_value(); - cout << num << ": got " << cpp_strerror(r) << std::endl; + std::cout << num << ": got " << cpp_strerror(r) << std::endl; if (r == 0) { context->update_object_version(oid, 0, snap); } else if (r == -EBUSY) { @@ -3426,7 +3407,7 @@ public: return done; } - string getType() override + std::string getType() override { return "CacheFlushOp"; } @@ -3436,12 +3417,12 @@ class CacheEvictOp : public TestOp { public: librados::AioCompletion *completion; librados::ObjectReadOperation op; - string oid; + std::string oid; std::shared_ptr<int> in_use; CacheEvictOp(int n, RadosTestContext *context, - const string &oid, + const std::string &oid, TestOpStat *stat) : TestOp(n, context, stat), completion(NULL), @@ -3459,14 +3440,14 @@ public: } else { snap = -1; } - cout << num << ": cache_evict oid " << oid << " snap " << snap << std::endl; + std::cout << num << ": cache_evict oid " << oid << " snap " << snap << std::endl; if (snap >= 0) { context->io_ctx.snap_set_read(context->snaps[snap]); } - pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = - new pair<TestOp*, TestOp::CallbackInfo*>(this, + std::pair<TestOp*, TestOp::CallbackInfo*> *cb_arg = + new std::pair<TestOp*, TestOp::CallbackInfo*>(this, new TestOp::CallbackInfo(0)); completion = context->rados.aio_create_completion((void *) cb_arg, &write_callback); @@ -3490,7 +3471,7 @@ public: ceph_assert(completion->is_complete()); int r = completion->get_return_value(); - cout << num << ": got " << cpp_strerror(r) << std::endl; + std::cout << num << ": got " << cpp_strerror(r) << std::endl; if (r == 0) { // yay! } else if (r == -EBUSY) { @@ -3511,7 +3492,7 @@ public: return done; } - string getType() override + std::string getType() override { return "CacheEvictOp"; } diff --git a/src/test/osd/TestOpStat.cc b/src/test/osd/TestOpStat.cc index 48b87b885b0..eb13e1d55e0 100644 --- a/src/test/osd/TestOpStat.cc +++ b/src/test/osd/TestOpStat.cc @@ -17,10 +17,10 @@ void TestOpStat::end(TestOp *in) { stats[in->getType()].end(in); } -void TestOpStat::TypeStatus::export_latencies(map<double,uint64_t> &in) const +void TestOpStat::TypeStatus::export_latencies(std::map<double,uint64_t> &in) const { - map<double,uint64_t>::iterator i = in.begin(); - multiset<uint64_t>::iterator j = latencies.begin(); + auto i = in.begin(); + auto j = latencies.begin(); int count = 0; while (j != latencies.end() && i != in.end()) { count++; @@ -31,22 +31,22 @@ void TestOpStat::TypeStatus::export_latencies(map<double,uint64_t> &in) const ++j; } } - + std::ostream & operator<<(std::ostream &out, const TestOpStat &rhs) { std::lock_guard l{rhs.stat_lock}; for (auto i = rhs.stats.begin(); i != rhs.stats.end(); ++i) { - map<double,uint64_t> latency; + std::map<double,uint64_t> latency; latency[10] = 0; latency[50] = 0; latency[90] = 0; latency[99] = 0; i->second.export_latencies(latency); - + out << i->first << " latency: " << std::endl; - for (map<double,uint64_t>::iterator j = latency.begin(); + for (auto j = latency.begin(); j != latency.end(); ++j) { if (j->second == 0) break; diff --git a/src/tools/rbd/ArgumentTypes.h b/src/tools/rbd/ArgumentTypes.h index 57473f31c65..39d374c64c3 100644 --- a/src/tools/rbd/ArgumentTypes.h +++ b/src/tools/rbd/ArgumentTypes.h @@ -87,7 +87,8 @@ static const std::string SKIP_QUIESCE("skip-quiesce"); static const std::string IGNORE_QUIESCE_ERROR("ignore-quiesce-error"); static const std::set<std::string> SWITCH_ARGUMENTS = { - WHOLE_OBJECT, NO_PROGRESS, PRETTY_FORMAT, VERBOSE, NO_ERR, SKIP_QUIESCE, + WHOLE_OBJECT, IMAGE_SHARED, IMAGE_THICK_PROVISION, IMAGE_FLATTEN, + NO_PROGRESS, PRETTY_FORMAT, VERBOSE, NO_ERR, SKIP_QUIESCE, IGNORE_QUIESCE_ERROR }; diff --git a/src/tools/rbd/action/Children.cc b/src/tools/rbd/action/Children.cc index f459e92b761..58e861b6928 100644 --- a/src/tools/rbd/action/Children.cc +++ b/src/tools/rbd/action/Children.cc @@ -157,6 +157,7 @@ int execute(const po::variables_map &vm, return 0; } +Shell::SwitchArguments switched_arguments({"all", "a", "descendants"}); Shell::Action action( {"children"}, {}, "Display children of an image or its snapshot.", "", &get_arguments, &execute); diff --git a/src/tools/rbd/action/Device.cc b/src/tools/rbd/action/Device.cc index 20cff569f9b..bfe60c273df 100644 --- a/src/tools/rbd/action/Device.cc +++ b/src/tools/rbd/action/Device.cc @@ -247,7 +247,9 @@ int execute_detach(const po::variables_map &vm, return (*get_device_operations(vm)->execute_detach)(vm, ceph_global_init_args); } -Shell::SwitchArguments switched_arguments({"read-only", "exclusive"}); +Shell::SwitchArguments switched_arguments({"exclusive", "force", "quiesce", + "read-only", "show-cookie"}); + Shell::Action action_list( {"device", "list"}, {"showmapped"}, "List mapped rbd images.", "", &get_list_arguments, &execute_list); diff --git a/src/tools/rbd/action/Diff.cc b/src/tools/rbd/action/Diff.cc index 3729469c50d..838ef6cc510 100644 --- a/src/tools/rbd/action/Diff.cc +++ b/src/tools/rbd/action/Diff.cc @@ -132,7 +132,6 @@ int execute(const po::variables_map &vm, return 0; } -Shell::SwitchArguments switched_arguments({at::WHOLE_OBJECT}); Shell::Action action( {"diff"}, {}, "Print extents that differ since a previous snap, or image creation.", "", diff --git a/src/tools/rbd/action/Export.cc b/src/tools/rbd/action/Export.cc index dff10c97e1a..ddcf0f2c30c 100644 --- a/src/tools/rbd/action/Export.cc +++ b/src/tools/rbd/action/Export.cc @@ -311,7 +311,6 @@ int execute_diff(const po::variables_map &vm, return 0; } -Shell::SwitchArguments switched_arguments({at::WHOLE_OBJECT}); Shell::Action action_diff( {"export-diff"}, {}, "Export incremental diff to file.", "", &get_arguments_diff, &execute_diff); diff --git a/src/tools/rbd/action/Migration.cc b/src/tools/rbd/action/Migration.cc index 05b15f1869c..1ce6201d964 100644 --- a/src/tools/rbd/action/Migration.cc +++ b/src/tools/rbd/action/Migration.cc @@ -406,6 +406,8 @@ int execute_commit(const po::variables_map &vm, return 0; } +Shell::SwitchArguments switched_arguments({"import-only"}); + Shell::Action action_prepare( {"migration", "prepare"}, {}, "Prepare image migration.", at::get_long_features_help(), &get_prepare_arguments, &execute_prepare); diff --git a/src/tools/rbd/action/Nbd.cc b/src/tools/rbd/action/Nbd.cc index f36537430c8..68345f43dd6 100644 --- a/src/tools/rbd/action/Nbd.cc +++ b/src/tools/rbd/action/Nbd.cc @@ -415,8 +415,6 @@ int execute_unmap_deprecated(const po::variables_map &vm, return execute_unmap(vm, ceph_global_args); } -Shell::SwitchArguments switched_arguments({"read-only", "exclusive"}); - Shell::Action action_show_deprecated( {"nbd", "list"}, {"nbd", "ls"}, "List the nbd devices already used.", "", &get_list_arguments_deprecated, &execute_list_deprecated, false); diff --git a/src/tools/rbd/action/Trash.cc b/src/tools/rbd/action/Trash.cc index cb4c8b8a93e..53831850857 100644 --- a/src/tools/rbd/action/Trash.cc +++ b/src/tools/rbd/action/Trash.cc @@ -518,7 +518,6 @@ int execute_restore(const po::variables_map &vm, return r; } - Shell::Action action_move( {"trash", "move"}, {"trash", "mv"}, "Move an image to the trash.", "", &get_move_arguments, &execute_move); @@ -531,7 +530,6 @@ Shell::Action action_purge( {"trash", "purge"}, {}, "Remove all expired images from trash.", "", &get_purge_arguments, &execute_purge); -Shell::SwitchArguments switched_arguments({"long", "l"}); Shell::Action action_list( {"trash", "list"}, {"trash", "ls"}, "List trash images.", "", &get_list_arguments, &execute_list); diff --git a/src/tools/rbd/action/TrashPurgeSchedule.cc b/src/tools/rbd/action/TrashPurgeSchedule.cc index f090754c4b9..0f92e762bc2 100644 --- a/src/tools/rbd/action/TrashPurgeSchedule.cc +++ b/src/tools/rbd/action/TrashPurgeSchedule.cc @@ -332,6 +332,8 @@ int execute_status(const po::variables_map &vm, return 0; } +Shell::SwitchArguments switched_arguments({"recursive", "R"}); + Shell::Action add_action( {"trash", "purge", "schedule", "add"}, {}, "Add trash purge schedule.", "", &get_arguments_add, &execute_add); diff --git a/src/tools/rbd/action/Wnbd.cc b/src/tools/rbd/action/Wnbd.cc index 4da6be33b5d..ae40fe538e3 100644 --- a/src/tools/rbd/action/Wnbd.cc +++ b/src/tools/rbd/action/Wnbd.cc @@ -224,8 +224,6 @@ int execute_detach(const po::variables_map &vm, return -EOPNOTSUPP; } -Shell::SwitchArguments switched_arguments({"read-only", "exclusive"}); - } // namespace wnbd } // namespace action } // namespace rbd |