ceph/src/test/client/TestClient.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2021 Red Hat
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include "gtest/gtest.h"
  16
  17 #include "common/async/context_pool.h"
  18 #include "global/global_context.h"
  19
  20 #include "msg/Messenger.h"
  21 #include "mon/MonClient.h"
  22 #include "osdc/ObjectCacher.h"
  23 #include "client/MetaRequest.h"
  24 #include "client/Client.h"
  25 #include "messages/MClientReclaim.h"
  26 #include "messages/MClientSession.h"
  27 #include "common/async/blocked_completion.h"
  28
  29 #define dout_subsys ceph_subsys_client
  30
  31 namespace bs = boost::system;
  32 namespace ca = ceph::async;
  33
  34 class ClientScaffold : public Client {
  35 public:
  36     ClientScaffold(Messenger *m, MonClient *mc, Objecter *objecter_) : Client(m, mc, objecter_) {}
  37     virtual ~ClientScaffold()
  38     { }
  39     int check_dummy_op(const UserPerm& perms){
  40       RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
  41       if (!mref_reader.is_state_satisfied()) {
  42         return -CEPHFS_ENOTCONN;
  43       }
  44       std::scoped_lock l(client_lock);
  45       MetaRequest *req = new MetaRequest(CEPH_MDS_OP_DUMMY);
  46       int res = make_request(req, perms);
  47       ldout(cct, 10) << __func__ << " result=" << res << dendl;
  48       return res;
  49     }
  50     int send_unknown_session_op(int op) {
  51       RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
  52       if (!mref_reader.is_state_satisfied()) {
  53         return -CEPHFS_ENOTCONN;
  54       }
  55       std::scoped_lock l(client_lock);
  56       auto session = _get_or_open_mds_session(0);
  57       auto msg = make_message<MClientSession>(op, session->seq);
  58       int res = session->con->send_message2(std::move(msg));
  59       ldout(cct, 10) << __func__ << " result=" << res << dendl;
  60       return res;
  61     }
  62     bool check_client_blocklisted() {
  63       RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
  64       if (!mref_reader.is_state_satisfied()) {
  65         return -CEPHFS_ENOTCONN;
  66       }
  67       std::scoped_lock l(client_lock);
  68       bs::error_code ec;
  69       ldout(cct, 20) << __func__ << ": waiting for latest osdmap" << dendl;
  70       objecter->wait_for_latest_osdmap(ca::use_blocked[ec]);
  71       ldout(cct, 20) << __func__ << ": got latest osdmap: " << ec << dendl;
  72       const auto myaddrs = messenger->get_myaddrs();
  73       return objecter->with_osdmap([&](const OSDMap& o) {return o.is_blocklisted(myaddrs);});
  74     }
  75     bool check_unknown_reclaim_flag(uint32_t flag) {
  76       RWRef_t mref_reader(mount_state, CLIENT_MOUNTING);
  77       if (!mref_reader.is_state_satisfied()) {
  78         return -CEPHFS_ENOTCONN;
  79       }
  80       std::scoped_lock l(client_lock);
  81       char uuid[256];
  82       sprintf(uuid, "unknownreclaimflag:%x", getpid());
  83       auto session = _get_or_open_mds_session(0);
  84       auto m = make_message<MClientReclaim>(uuid, flag);
  85       ceph_assert(session->con->send_message2(std::move(m)) == 0);
  86       wait_on_list(waiting_for_reclaim);
  87       return session->reclaim_state == MetaSession::RECLAIM_FAIL ? true : false;
  88     }
  89 };
  90
  91 class TestClient : public ::testing::Test {
  92 public:
  93     static void SetUpTestSuite() {
  94       icp.start(g_ceph_context->_conf.get_val<std::uint64_t>("client_asio_thread_count"));
  95     }
  96     static void TearDownTestSuite() {
  97       icp.stop();
  98     }
  99     void SetUp() override {
 100       messenger = Messenger::create_client_messenger(g_ceph_context, "client");
 101       if (messenger->start() != 0) {
 102         throw std::runtime_error("failed to start messenger");
 103       }
 104
 105       mc = new MonClient(g_ceph_context, icp);
 106       if (mc->build_initial_monmap() < 0) {
 107         throw std::runtime_error("build monmap");
 108       }
 109       mc->set_messenger(messenger);
 110       mc->set_want_keys(CEPH_ENTITY_TYPE_MDS | CEPH_ENTITY_TYPE_OSD);
 111       if (mc->init() < 0) {
 112         throw std::runtime_error("init monclient");
 113       }
 114
 115       objecter = new Objecter(g_ceph_context, messenger, mc, icp);
 116       objecter->set_client_incarnation(0);
 117       objecter->init();
 118       messenger->add_dispatcher_tail(objecter);
 119       objecter->start();
 120
 121       client = new ClientScaffold(messenger, mc, objecter);
 122       client->init();
 123       client->mount("/", myperm, true);
 124     }
 125     void TearDown() override {
 126       if (client->is_mounted())
 127         client->unmount();
 128       client->shutdown();
 129       objecter->shutdown();
 130       mc->shutdown();
 131       messenger->shutdown();
 132       messenger->wait();
 133
 134       delete client;
 135       client = nullptr;
 136       delete objecter;
 137       objecter = nullptr;
 138       delete mc;
 139       mc = nullptr;
 140       delete messenger;
 141       messenger = nullptr;
 142     }
 143 protected:
 144     static inline ceph::async::io_context_pool icp;
 145     static inline UserPerm myperm{0,0};
 146     MonClient* mc = nullptr;
 147     Messenger* messenger = nullptr;
 148     Objecter* objecter = nullptr;
 149     ClientScaffold* client = nullptr;
 150 };