[ceph.git] / ceph / src / test / mon / MonMap.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2016 SUSE LINUX GmbH
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software
 * Foundation.  See file COPYING.
 *
 */
#include "mon/MonMap.h"
#include "common/ceph_context.h"
#include "common/dns_resolve.h"
#include "test/common/dns_messages.h"

#include "common/debug.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

#include <boost/smart_ptr/intrusive_ptr.hpp>

#include <sstream>

#define TEST_DEBUG 20

#define dout_subsys ceph_subsys_mon


using ::testing::Return;
using ::testing::_;
using ::testing::SetArrayArgument;
using ::testing::DoAll;
using ::testing::StrEq;


class MonMapTest : public ::testing::Test {
  protected:
    virtual void SetUp() {
      g_ceph_context->_conf->subsys.set_log_level(dout_subsys, TEST_DEBUG);
    }

    virtual void TearDown()  {
      DNSResolver::get_instance(nullptr);
    }
};

TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns) {

  MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  DNSResolver::get_instance(resolvH);

  int len = sizeof(ns_search_msg_ok_payload);
  int lena = sizeof(ns_query_msg_mon_a_payload);
  int lenb = sizeof(ns_query_msg_mon_b_payload);
  int lenc = sizeof(ns_query_msg_mon_c_payload);

  using ::testing::InSequence;
  {
    InSequence s;

#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#endif
  }


  boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
  cct->_conf.set_val("mon_dns_srv_name", "cephmon");
  MonMap monmap;
  int r = monmap.build_initial(cct.get(), false, std::cerr);

  ASSERT_EQ(r, 0);
  ASSERT_EQ(monmap.mon_info.size(), (unsigned int)3);
  auto it = monmap.mon_info.find("mon.a");
  ASSERT_NE(it, monmap.mon_info.end());
  std::ostringstream os;
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
  os.str("");
  it = monmap.mon_info.find("mon.b");
  ASSERT_NE(it, monmap.mon_info.end());
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
  os.str("");
  it = monmap.mon_info.find("mon.c");
  ASSERT_NE(it, monmap.mon_info.end());
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
}

TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns_fail) {
  MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  DNSResolver::get_instance(resolvH);


#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_ceph-mon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(Return(0));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_ceph-mon._tcp"), C_IN, T_SRV, _, _))
      .WillOnce(Return(0));
#endif

  boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
  // using default value of mon_dns_srv_name option
  MonMap monmap;
  int r = monmap.build_initial(cct.get(), false, std::cerr);

  ASSERT_EQ(r, -ENOENT);
  ASSERT_EQ(monmap.mon_info.size(), (unsigned int)0);

}

TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns_with_domain) {

  MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  DNSResolver::get_instance(resolvH);

  int len = sizeof(ns_search_msg_ok_payload);
  int lena = sizeof(ns_query_msg_mon_a_payload);
  int lenb = sizeof(ns_query_msg_mon_b_payload);
  int lenc = sizeof(ns_query_msg_mon_c_payload);

  using ::testing::InSequence;
  {
    InSequence s;

#ifdef HAVE_RES_NQUERY
    EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#else
    EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
            ns_search_msg_ok_payload+len), Return(len)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
            ns_query_msg_mon_a_payload+lena), Return(lena)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
            ns_query_msg_mon_c_payload+lenc), Return(lenc)));

    EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
      .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
            ns_query_msg_mon_b_payload+lenb), Return(lenb)));
#endif
  }


  boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
  cct->_conf.set_val("mon_dns_srv_name", "cephmon_ceph.com");
  MonMap monmap;
  int r = monmap.build_initial(cct.get(), false, std::cerr);

  ASSERT_EQ(r, 0);
  ASSERT_EQ(monmap.mon_info.size(), (unsigned int)3);
  auto it = monmap.mon_info.find("mon.a");
  ASSERT_NE(it, monmap.mon_info.end());
  std::ostringstream os;
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
  os.str("");
  it = monmap.mon_info.find("mon.b");
  ASSERT_NE(it, monmap.mon_info.end());
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
  os.str("");
  it = monmap.mon_info.find("mon.c");
  ASSERT_NE(it, monmap.mon_info.end());
  os << it->second.public_addrs;
  ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
}

TEST(MonMapBuildInitial, build_initial_mon_host_from_dns) {
  boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
  cct->_conf.set_val("mon_host", "ceph.io");
  MonMap monmap;
  int r = monmap.build_initial(cct.get(), false, std::cerr);
  ASSERT_EQ(r, 0);
  ASSERT_GE(monmap.mon_info.size(), 1u);
  for (const auto& [name, info] : monmap.mon_info) {
    std::cerr << info << std::endl;
  }
}

TEST(MonMapBuildInitial, build_initial_mon_host_from_dns_fail) {
  boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
  cct->_conf.set_val("mon_host", "ceph.noname");
  MonMap monmap;
  int r = monmap.build_initial(cct.get(), false, std::cerr);
  ASSERT_EQ(r, -EINVAL);
}
Commit	Line	Data
7c673cae FG	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) 2016 SUSE LINUX GmbH
	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	#include "mon/MonMap.h"
	15	#include "common/ceph_context.h"
	16	#include "common/dns_resolve.h"
	17	#include "test/common/dns_messages.h"
	18
	19	#include "common/debug.h"
	20	#include "gmock/gmock.h"
	21	#include "gtest/gtest.h"
	22
f67539c2 TL	23	#include <boost/smart_ptr/intrusive_ptr.hpp>
f67539c2 TL	24
7c673cae FG	25	#include <sstream>
	26
	27	#define TEST_DEBUG 20
	28
	29	#define dout_subsys ceph_subsys_mon
	30
	31
	32	using ::testing::Return;
	33	using ::testing::_;
	34	using ::testing::SetArrayArgument;
	35	using ::testing::DoAll;
	36	using ::testing::StrEq;
	37
	38
	39	class MonMapTest : public ::testing::Test {
	40	protected:
	41	virtual void SetUp() {
	42	g_ceph_context->_conf->subsys.set_log_level(dout_subsys, TEST_DEBUG);
	43	}
	44
	45	virtual void TearDown() {
	46	DNSResolver::get_instance(nullptr);
	47	}
	48	};
	49
f91f0fd5	50	TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns) {
7c673cae FG	51
	52	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	53	DNSResolver::get_instance(resolvH);
	54
	55	int len = sizeof(ns_search_msg_ok_payload);
	56	int lena = sizeof(ns_query_msg_mon_a_payload);
	57	int lenb = sizeof(ns_query_msg_mon_b_payload);
	58	int lenc = sizeof(ns_query_msg_mon_c_payload);
	59
	60	using ::testing::InSequence;
	61	{
	62	InSequence s;
	63
	64	#ifdef HAVE_RES_NQUERY
	65	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
	66	.WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
	67	ns_search_msg_ok_payload+len), Return(len)));
	68
	69	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	70	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
	71	ns_query_msg_mon_a_payload+lena), Return(lena)));
	72
	73	EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	74	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
	75	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	76
	77	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	78	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
	79	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	80	#else
	81	EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
	82	.WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
	83	ns_search_msg_ok_payload+len), Return(len)));
	84
	85	EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	86	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
	87	ns_query_msg_mon_a_payload+lena), Return(lena)));
	88
	89	EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	90	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
	91	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	92
	93	EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	94	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
	95	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	96	#endif
	97	}
	98
	99
	100
f67539c2	101	boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
11fdf7f2	102	cct->_conf.set_val("mon_dns_srv_name", "cephmon");
7c673cae	103	MonMap monmap;
f67539c2	104	int r = monmap.build_initial(cct.get(), false, std::cerr);
7c673cae FG	105
7c673cae FG	106	ASSERT_EQ(r, 0);
f91f0fd5 TL	107	ASSERT_EQ(monmap.mon_info.size(), (unsigned int)3);
	108	auto it = monmap.mon_info.find("mon.a");
	109	ASSERT_NE(it, monmap.mon_info.end());
7c673cae	110	std::ostringstream os;
f91f0fd5	111	os << it->second.public_addrs;
7c673cae FG	112	ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
7c673cae FG	113	os.str("");
f91f0fd5 TL	114	it = monmap.mon_info.find("mon.b");
	115	ASSERT_NE(it, monmap.mon_info.end());
	116	os << it->second.public_addrs;
7c673cae FG	117	ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
7c673cae FG	118	os.str("");
f91f0fd5 TL	119	it = monmap.mon_info.find("mon.c");
	120	ASSERT_NE(it, monmap.mon_info.end());
	121	os << it->second.public_addrs;
7c673cae FG	122	ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
	123	}
	124
f91f0fd5	125	TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns_fail) {
7c673cae FG	126	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	127	DNSResolver::get_instance(resolvH);
	128
	129
	130	#ifdef HAVE_RES_NQUERY
	131	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_ceph-mon._tcp"), C_IN, T_SRV, _, _))
	132	.WillOnce(Return(0));
	133	#else
	134	EXPECT_CALL(*resolvH, res_search(StrEq("_ceph-mon._tcp"), C_IN, T_SRV, _, _))
	135	.WillOnce(Return(0));
	136	#endif
	137
f67539c2	138	boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
7c673cae FG	139	// using default value of mon_dns_srv_name option
7c673cae FG	140	MonMap monmap;
f67539c2	141	int r = monmap.build_initial(cct.get(), false, std::cerr);
7c673cae FG	142
7c673cae FG	143	ASSERT_EQ(r, -ENOENT);
f91f0fd5	144	ASSERT_EQ(monmap.mon_info.size(), (unsigned int)0);
7c673cae FG	145
	146	}
	147
f91f0fd5	148	TEST_F(MonMapTest, DISABLED_build_initial_config_from_dns_with_domain) {
7c673cae FG	149
	150	MockResolvHWrapper *resolvH = new MockResolvHWrapper();
	151	DNSResolver::get_instance(resolvH);
	152
	153	int len = sizeof(ns_search_msg_ok_payload);
	154	int lena = sizeof(ns_query_msg_mon_a_payload);
	155	int lenb = sizeof(ns_query_msg_mon_b_payload);
	156	int lenc = sizeof(ns_query_msg_mon_c_payload);
	157
	158	using ::testing::InSequence;
	159	{
	160	InSequence s;
	161
	162	#ifdef HAVE_RES_NQUERY
	163	EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
	164	.WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
	165	ns_search_msg_ok_payload+len), Return(len)));
	166
	167	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	168	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
	169	ns_query_msg_mon_a_payload+lena), Return(lena)));
	170
	171	EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	172	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
	173	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	174
	175	EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	176	.WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
	177	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	178	#else
	179	EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
	180	.WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
	181	ns_search_msg_ok_payload+len), Return(len)));
	182
	183	EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
	184	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
	185	ns_query_msg_mon_a_payload+lena), Return(lena)));
	186
	187	EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
	188	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
	189	ns_query_msg_mon_c_payload+lenc), Return(lenc)));
	190
	191	EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
	192	.WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
	193	ns_query_msg_mon_b_payload+lenb), Return(lenb)));
	194	#endif
	195	}
	196
	197
	198
f67539c2	199	boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
11fdf7f2	200	cct->_conf.set_val("mon_dns_srv_name", "cephmon_ceph.com");
7c673cae	201	MonMap monmap;
f67539c2	202	int r = monmap.build_initial(cct.get(), false, std::cerr);
7c673cae FG	203
7c673cae FG	204	ASSERT_EQ(r, 0);
f91f0fd5 TL	205	ASSERT_EQ(monmap.mon_info.size(), (unsigned int)3);
	206	auto it = monmap.mon_info.find("mon.a");
	207	ASSERT_NE(it, monmap.mon_info.end());
7c673cae	208	std::ostringstream os;
f91f0fd5	209	os << it->second.public_addrs;
7c673cae FG	210	ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
7c673cae FG	211	os.str("");
f91f0fd5 TL	212	it = monmap.mon_info.find("mon.b");
	213	ASSERT_NE(it, monmap.mon_info.end());
	214	os << it->second.public_addrs;
7c673cae FG	215	ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
7c673cae FG	216	os.str("");
f91f0fd5 TL	217	it = monmap.mon_info.find("mon.c");
	218	ASSERT_NE(it, monmap.mon_info.end());
	219	os << it->second.public_addrs;
7c673cae FG	220	ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
	221	}
	222
f91f0fd5	223	TEST(MonMapBuildInitial, build_initial_mon_host_from_dns) {
f67539c2	224	boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
f91f0fd5 TL	225	cct->_conf.set_val("mon_host", "ceph.io");
f91f0fd5 TL	226	MonMap monmap;
f67539c2	227	int r = monmap.build_initial(cct.get(), false, std::cerr);
f91f0fd5 TL	228	ASSERT_EQ(r, 0);
	229	ASSERT_GE(monmap.mon_info.size(), 1u);
	230	for (const auto& [name, info] : monmap.mon_info) {
	231	std::cerr << info << std::endl;
	232	}
	233	}
	234
	235	TEST(MonMapBuildInitial, build_initial_mon_host_from_dns_fail) {
f67539c2	236	boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
f91f0fd5 TL	237	cct->_conf.set_val("mon_host", "ceph.noname");
f91f0fd5 TL	238	MonMap monmap;
f67539c2	239	int r = monmap.build_initial(cct.get(), false, std::cerr);
f91f0fd5 TL	240	ASSERT_EQ(r, -EINVAL);
f91f0fd5 TL	241	}