ceph/src/test/common/dns_resolve.cc

   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 "common/dns_resolve.h"
  15 #include "test/common/dns_messages.h"
  16
  17 #include "common/debug.h"
  18 #include "gmock/gmock.h"
  19
  20
  21 #include <sstream>
  22
  23 #define TEST_DEBUG 20
  24
  25 #define dout_subsys ceph_subsys_
  26
  27
  28 using ::testing::Return;
  29 using ::testing::_;
  30 using ::testing::SetArrayArgument;
  31 using ::testing::DoAll;
  32 using ::testing::StrEq;
  33
  34 class DNSResolverTest : public ::testing::Test {
  35   protected:
  36     void SetUp() override {
  37       g_ceph_context->_conf->subsys.set_log_level(dout_subsys, TEST_DEBUG);
  38     }
  39
  40     void TearDown() override  {
  41       DNSResolver::get_instance(nullptr);
  42     }
  43 };
  44
  45 TEST_F(DNSResolverTest, resolve_ip_addr) {
  46   MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  47
  48   int lena = sizeof(ns_query_msg_mon_a_payload);
  49 #ifdef HAVE_RES_NQUERY
  50   EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
  51        .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
  52             ns_query_msg_mon_a_payload+lena), Return(lena)));
  53 #else
  54   EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
  55        .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
  56             ns_query_msg_mon_a_payload+lena), Return(lena)));
  57 #endif
  58
  59   entity_addr_t addr;
  60   DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context,
  61       "mon.a.ceph.com", &addr);
  62
  63   std::ostringstream os;
  64   os << addr;
  65   ASSERT_EQ(os.str(), "192.168.1.11:0/0");
  66 }
  67
  68 TEST_F(DNSResolverTest, resolve_ip_addr_fail) {
  69   MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  70
  71 #ifdef HAVE_RES_NQUERY
  72   EXPECT_CALL(*resolvH, res_nquery(_,StrEq("not_exists.com"), C_IN, T_A,_,_))
  73        .WillOnce(Return(0));
  74 #else
  75   EXPECT_CALL(*resolvH, res_query(StrEq("not_exists.com"), C_IN, T_A,_,_))
  76        .WillOnce(Return(0));
  77 #endif
  78
  79   entity_addr_t addr;
  80   int ret = DNSResolver::get_instance(resolvH)->resolve_ip_addr(g_ceph_context,
  81       "not_exists.com", &addr);
  82
  83   ASSERT_EQ(ret, -1);
  84   std::ostringstream os;
  85   os << addr;
  86   ASSERT_EQ(os.str(), "-");
  87 }
  88
  89
  90 TEST_F(DNSResolverTest, resolve_srv_hosts_empty_domain) {
  91   MockResolvHWrapper *resolvH = new MockResolvHWrapper();
  92
  93
  94   int len = sizeof(ns_search_msg_ok_payload);
  95   int lena = sizeof(ns_query_msg_mon_a_payload);
  96   int lenb = sizeof(ns_query_msg_mon_b_payload);
  97   int lenc = sizeof(ns_query_msg_mon_c_payload);
  98
  99   using ::testing::InSequence;
 100   {
 101     InSequence s;
 102
 103 #ifdef HAVE_RES_NQUERY
 104     EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
 105       .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
 106             ns_search_msg_ok_payload+len), Return(len)));
 107
 108     EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
 109       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
 110             ns_query_msg_mon_a_payload+lena), Return(lena)));
 111
 112     EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
 113       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
 114             ns_query_msg_mon_c_payload+lenc), Return(lenc)));
 115
 116     EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
 117       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
 118             ns_query_msg_mon_b_payload+lenb), Return(lenb)));
 119 #else
 120     EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp"), C_IN, T_SRV, _, _))
 121       .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
 122             ns_search_msg_ok_payload+len), Return(len)));
 123
 124     EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
 125       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
 126             ns_query_msg_mon_a_payload+lena), Return(lena)));
 127
 128     EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
 129       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
 130             ns_query_msg_mon_c_payload+lenc), Return(lenc)));
 131
 132     EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
 133       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
 134             ns_query_msg_mon_b_payload+lenb), Return(lenb)));
 135 #endif
 136   }
 137
 138   map<string, DNSResolver::Record> records;
 139   DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon",
 140       DNSResolver::SRV_Protocol::TCP, &records);
 141
 142   ASSERT_EQ(records.size(), (unsigned int)3);
 143   auto it = records.find("mon.a");
 144   ASSERT_NE(it, records.end());
 145   std::ostringstream os;
 146   os << it->second.addr;
 147   ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
 148   os.str("");
 149   it = records.find("mon.b");
 150   ASSERT_NE(it, records.end());
 151   os << it->second.addr;
 152   ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
 153   os.str("");
 154   it = records.find("mon.c");
 155   ASSERT_NE(it, records.end());
 156   os << it->second.addr;
 157   ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
 158 }
 159
 160 TEST_F(DNSResolverTest, resolve_srv_hosts_full_domain) {
 161   MockResolvHWrapper *resolvH = new MockResolvHWrapper();
 162
 163
 164   int len = sizeof(ns_search_msg_ok_payload);
 165   int lena = sizeof(ns_query_msg_mon_a_payload);
 166   int lenb = sizeof(ns_query_msg_mon_b_payload);
 167   int lenc = sizeof(ns_query_msg_mon_c_payload);
 168
 169   using ::testing::InSequence;
 170   {
 171     InSequence s;
 172
 173 #ifdef HAVE_RES_NQUERY
 174     EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
 175       .WillOnce(DoAll(SetArrayArgument<4>(ns_search_msg_ok_payload,
 176             ns_search_msg_ok_payload+len), Return(len)));
 177
 178     EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
 179       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_a_payload,
 180             ns_query_msg_mon_a_payload+lena), Return(lena)));
 181
 182     EXPECT_CALL(*resolvH, res_nquery(_, StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
 183       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_c_payload,
 184             ns_query_msg_mon_c_payload+lenc), Return(lenc)));
 185
 186     EXPECT_CALL(*resolvH, res_nquery(_,StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
 187       .WillOnce(DoAll(SetArrayArgument<4>(ns_query_msg_mon_b_payload,
 188             ns_query_msg_mon_b_payload+lenb), Return(lenb)));
 189 #else
 190     EXPECT_CALL(*resolvH, res_search(StrEq("_cephmon._tcp.ceph.com"), C_IN, T_SRV, _, _))
 191       .WillOnce(DoAll(SetArrayArgument<3>(ns_search_msg_ok_payload,
 192             ns_search_msg_ok_payload+len), Return(len)));
 193
 194     EXPECT_CALL(*resolvH, res_query(StrEq("mon.a.ceph.com"), C_IN, T_A,_,_))
 195       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_a_payload,
 196             ns_query_msg_mon_a_payload+lena), Return(lena)));
 197
 198     EXPECT_CALL(*resolvH, res_query(StrEq("mon.c.ceph.com"), C_IN, T_A,_,_))
 199       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_c_payload,
 200             ns_query_msg_mon_c_payload+lenc), Return(lenc)));
 201
 202     EXPECT_CALL(*resolvH, res_query(StrEq("mon.b.ceph.com"), C_IN, T_A, _,_))
 203       .WillOnce(DoAll(SetArrayArgument<3>(ns_query_msg_mon_b_payload,
 204             ns_query_msg_mon_b_payload+lenb), Return(lenb)));
 205 #endif
 206   }
 207
 208   map<string, DNSResolver::Record> records;
 209   DNSResolver::get_instance(resolvH)->resolve_srv_hosts(g_ceph_context, "cephmon",
 210       DNSResolver::SRV_Protocol::TCP, "ceph.com", &records);
 211
 212   ASSERT_EQ(records.size(), (unsigned int)3);
 213   auto it = records.find("mon.a");
 214   ASSERT_NE(it, records.end());
 215   std::ostringstream os;
 216   os << it->second.addr;
 217   ASSERT_EQ(os.str(), "192.168.1.11:6789/0");
 218   os.str("");
 219   it = records.find("mon.b");
 220   ASSERT_NE(it, records.end());
 221   os << it->second.addr;
 222   ASSERT_EQ(os.str(), "192.168.1.12:6789/0");
 223   os.str("");
 224   it = records.find("mon.c");
 225   ASSERT_NE(it, records.end());
 226   os << it->second.addr;
 227   ASSERT_EQ(os.str(), "192.168.1.13:6789/0");
 228 }
 229
 230 TEST_F(DNSResolverTest, resolve_srv_hosts_fail) {
 231   MockResolvHWrapper *resolvH = new MockResolvHWrapper();
 232
 233
 234   using ::testing::InSequence;
 235   {
 236     InSequence s;
 237
 238 #ifdef HAVE_RES_NQUERY
 239     EXPECT_CALL(*resolvH, res_nsearch(_, StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
 240       .WillOnce(Return(0));
 241 #else
 242     EXPECT_CALL(*resolvH, res_search(StrEq("_noservice._tcp"), C_IN, T_SRV, _, _))
 243       .WillOnce(Return(0));
 244 #endif
 245   }
 246
 247   map<string, DNSResolver::Record> records;
 248   int ret = DNSResolver::get_instance(resolvH)->resolve_srv_hosts(
 249       g_ceph_context, "noservice", DNSResolver::SRV_Protocol::TCP, "", &records);
 250
 251   ASSERT_EQ(0, ret);
 252   ASSERT_TRUE(records.empty());
 253 }
 254