Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# Copyright (C) 2009 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Script for unittesting the confd client module"""

import socket

import unittest

from ganeti import confd

from ganeti import constants

from ganeti import errors

import ganeti.confd.client

import testutils

class ResettableMock(object):

  def __init__(self, *args, **kwargs):

    self.Reset()

  def Reset(self):

    pass

class MockLogger(ResettableMock):

  def Reset(self):

    self.debug_count = 0

    self.warn_count = 0

    self.error_count = 0

  def debug(string):

    self.debug_count += 1

  def warning(string):

    self.warn_count += 1

  def error(string):

    self.error_count += 1

class MockConfdAsyncUDPClient(ResettableMock):

  def Reset(self):

    self.send_count = 0

    self.last_address = ''

    self.last_port = -1

    self.last_sent = ''

  def enqueue_send(self, address, port, payload):

    self.send_count += 1

    self.last_payload = payload

    self.last_port = port

    self.last_address = address

class MockCallback(ResettableMock):

  def Reset(self):

    self.call_count = 0

    self.last_up = None

  def __call__(self, up):

    """Callback

    @type up: L{ConfdUpcallPayload}

    @param up: upper callback

    """

    self.call_count += 1

    self.last_up = up

class MockTime(ResettableMock):

  def Reset(self):

    self.mytime  = 1254213006.5175071

  def time(self):

    return self.mytime

  def increase(self, delta):

    self.mytime += delta

class _BaseClientTest:

  """Base class for client tests"""

  mc_list = None

  new_peers = None

  family = None

  def setUp(self):

    self.mock_time = MockTime()

    confd.client.time = self.mock_time

    confd.client.ConfdAsyncUDPClient = MockConfdAsyncUDPClient

    self.logger = MockLogger()

    hmac_key = "mykeydata"

    self.callback = MockCallback()

    self.client = confd.client.ConfdClient(hmac_key, self.mc_list,

                                           self.callback, logger=self.logger)

  def testRequest(self):

    req1 = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    req2 = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.assertNotEqual(req1.rsalt, req2.rsalt)

    self.assertEqual(req1.protocol, constants.CONFD_PROTOCOL_VERSION)

    self.assertEqual(req2.protocol, constants.CONFD_PROTOCOL_VERSION)

    self.assertRaises(errors.ConfdClientError, confd.client.ConfdClientRequest,

                      type=-33)

  def testClientSend(self):

    req = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req)

    # Cannot send the same request twice

    self.assertRaises(errors.ConfdClientError, self.client.SendRequest, req)

    req2 = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    # Coverage is too big

    self.assertRaises(errors.ConfdClientError, self.client.SendRequest,

                      req2, coverage=15)

    self.assertEquals(self.client._socket.send_count,

                      constants.CONFD_DEFAULT_REQ_COVERAGE)

    # Send with max coverage

    self.client.SendRequest(req2, coverage=-1)

    self.assertEquals(self.client._socket.send_count,

                      constants.CONFD_DEFAULT_REQ_COVERAGE + len(self.mc_list))

    self.assert_(self.client._socket.last_address in self.mc_list)

  def testClientExpire(self):

    req = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req)

    # Make a couple of seconds pass ;)

    self.mock_time.increase(2)

    # Now sending the second request

    req2 = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req2)

    self.mock_time.increase(constants.CONFD_CLIENT_EXPIRE_TIMEOUT - 1)

    # First request should be expired, second one should not

    self.client.ExpireRequests()

    self.assertEquals(self.callback.call_count, 1)

    self.assertEquals(self.callback.last_up.type, confd.client.UPCALL_EXPIRE)

    self.assertEquals(self.callback.last_up.salt, req.rsalt)

    self.assertEquals(self.callback.last_up.orig_request, req)

    self.mock_time.increase(3)

    self.assertEquals(self.callback.call_count, 1)

    self.client.ExpireRequests()

    self.assertEquals(self.callback.call_count, 2)

    self.assertEquals(self.callback.last_up.type, confd.client.UPCALL_EXPIRE)

    self.assertEquals(self.callback.last_up.salt, req2.rsalt)

    self.assertEquals(self.callback.last_up.orig_request, req2)

  def testClientCascadeExpire(self):

    req = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req)

    self.mock_time.increase(constants.CONFD_CLIENT_EXPIRE_TIMEOUT +1)

    req2 = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req2)

    self.assertEquals(self.callback.call_count, 1)

  def testUpdatePeerList(self):

    self.client.UpdatePeerList(self.new_peers)

    self.assertEquals(self.client._peers, self.new_peers)

    req = confd.client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

    self.client.SendRequest(req)

    self.assertEquals(self.client._socket.send_count, len(self.new_peers))

    self.assert_(self.client._socket.last_address in self.new_peers)

  def testSetPeersFamily(self):

    self.client._SetPeersAddressFamily()

    self.assertEquals(self.client._family, self.family)

    mixed_peers = ["192.0.2.99", "2001:db8:beef::13"]

    self.client.UpdatePeerList(mixed_peers)

    self.assertRaises(errors.ConfdClientError,

                      self.client._SetPeersAddressFamily)

class TestIP4Client(unittest.TestCase, _BaseClientTest):

  """Client tests"""

  mc_list = ["192.0.2.1",

             "192.0.2.2",

             "192.0.2.3",

             "192.0.2.4",

             "192.0.2.5",

             "192.0.2.6",

             "192.0.2.7",

             "192.0.2.8",

             "192.0.2.9",

            ]

  new_peers = ["198.51.100.1", "198.51.100.2"]

  family = socket.AF_INET

  def setUp(self):

    unittest.TestCase.setUp(self)

    _BaseClientTest.setUp(self)

class TestIP6Client(unittest.TestCase, _BaseClientTest):

  """Client tests"""

  mc_list = ["2001:db8::1",

             "2001:db8::2",

             "2001:db8::3",

             "2001:db8::4",

             "2001:db8::5",

             "2001:db8::6",

             "2001:db8::7",

             "2001:db8::8",

             "2001:db8::9",

            ]

  new_peers = ["2001:db8:beef::11", "2001:db8:beef::12"]

  family = socket.AF_INET6

  def setUp(self):

    unittest.TestCase.setUp(self)

    _BaseClientTest.setUp(self)

if __name__ == "__main__":

  testutils.GanetiTestProgram()