Synnefo » snf-ganeti » ganeti-local

    raise ec(*args) # pylint: disable=W0142

                    ssc=ssconf.SimpleStore,

                    nslookup_fn=netutils.Hostname.GetIP):

  """Return addresses for given node names.

    """

    self._addresses = addresses

    """Returns static addresses for hosts.

    """

  return (name, ip)

  """Calculate node addresses using configuration.

  """

    return results

               _req_process_fn=http.client.ProcessRequests):

    """Makes an RPC request to a number of nodes.

      "Missing RPC read timeout for procedure '%s'" % procedure

    (results, requests) = \

    _req_process_fn(requests.values(), lock_monitor_cb=self._lock_monitor_cb)

      pnbody = dict((n, serializer.DumpJson(prep_fn(n, enc_args)))

                    for n in node_list)

    if postproc_fn:

      return dict(map(lambda (key, value): (key, postproc_fn(value)),

    http_proc = _FakeRequestProcessor(self._GetVersionResponse)

    proc = rpc._RpcProcessor(resolver, 24094)

    result = proc(["localhost"], "version", {"localhost": ""}, 60,

    self.assertEqual(result.keys(), ["localhost"])

    lhresp = result["localhost"]

    self.assertFalse(lhresp.offline)

    proc = rpc._RpcProcessor(resolver, 19176)

    host = "node31856"

    body = {host: ""}

    self.assertEqual(result.keys(), [host])

    lhresp = result[host]

    self.assertFalse(lhresp.offline)

    proc = rpc._RpcProcessor(resolver, 30668)

    host = "n17296"

    body = {host: ""}

    self.assertEqual(result.keys(), [host])

    lhresp = result[host]

    self.assertTrue(lhresp.offline)

    resolver = rpc._StaticResolver(nodes)

    http_proc = _FakeRequestProcessor(self._GetMultiVersionResponse)

    proc = rpc._RpcProcessor(resolver, 23245)

    self.assertEqual(sorted(result.keys()), sorted(nodes))

    for name in nodes:

                                             errinfo))

      host = "aef9ur4i.example.com"

      body = {host: ""}

                    _req_process_fn=http_proc)

      self.assertEqual(result.keys(), [host])

      lhresp = result[host]

    http_proc = \

      _FakeRequestProcessor(compat.partial(self._GetHttpErrorResponse,

                                           httperrnodes, failnodes))

                  _req_process_fn=http_proc)

    self.assertEqual(sorted(result.keys()), sorted(nodes))

      http_proc = _FakeRequestProcessor(fn)

      host = "oqo7lanhly.example.com"

      body = {host: ""}

                    _req_process_fn=http_proc)

      self.assertEqual(result.keys(), [host])

      lhresp = result[host]

    proc = rpc._RpcProcessor(resolver, 18700)

    host = "node19759"

    body = {host: serializer.DumpJson(test_data)}

    self.assertEqual(result.keys(), [host])

    lhresp = result[host]

    self.assertFalse(lhresp.offline)

    node_list = ["node%d.example.com" % n for n in range(0, 255, 13)]

    node_addr_list = [" ".join(t) for t in zip(node_list, addr_list)]

    ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list)

    self.assertEqual(result, zip(node_list, addr_list))

  def testNsLookup(self):

    ssc = GetFakeSimpleStoreClass(lambda _: [])

    node_addr_map = dict(zip(node_list, addr_list))

    nslookup_fn = lambda name, family=None: node_addr_map.get(name)

    self.assertEqual(result, zip(node_list, addr_list))

  def testBothLookups(self):

    ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list)

    node_addr_map = dict(zip(node_list[:n], addr_list[:n]))

    nslookup_fn = lambda name, family=None: node_addr_map.get(name)

    self.assertEqual(result, zip(node_list, addr_list))

  def testAddressLookupIPv6(self):

    node_list = ["node%d.example.com" % n for n in range(0, 255, 11)]

    node_addr_list = [" ".join(t) for t in zip(node_list, addr_list)]

    ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list)

    self.assertEqual(result, zip(node_list, addr_list))

    addresses = ["192.0.2.%d" % n for n in range(0, 123, 7)]

    nodes = ["node%s.example.com" % n for n in range(0, 123, 7)]

    res = rpc._StaticResolver(addresses)

  def testWrongLength(self):

    res = rpc._StaticResolver([])

class TestNodeConfigResolver(unittest.TestCase):

  def testSingleOnline(self):

    self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOnlineNode,

                                             NotImplemented,

                     [("node90.example.com", "192.0.2.90")])

  def testSingleOffline(self):

    self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOfflineNode,

                                             NotImplemented,

                     [("node100.example.com", rpc._OFFLINE)])

  def testUnknownSingleNode(self):

    self.assertEqual(rpc._NodeConfigResolver(lambda _: None, NotImplemented,

                     [("node110.example.com", "node110.example.com")])

  def testMultiEmpty(self):

    self.assertEqual(rpc._NodeConfigResolver(NotImplemented,

                                             lambda: {},

                     [])

  def testMultiSomeOffline(self):

    # Resolve no names

    self.assertEqual(rpc._NodeConfigResolver(NotImplemented,

                                             lambda: nodes,

                     [])

    # Offline, online and unknown hosts

                                             ["node3.example.com",

                                              "node92.example.com",

                                              "node54.example.com",

      ("node3.example.com", rpc._OFFLINE),

      ("node92.example.com", "192.0.2.92"),

      ("node54.example.com", rpc._OFFLINE),