x/stacktach
Code Issues Proposed changes

Revert "Merge pull request #173 from ramielrowe/master"

Browse Source 
This reverts commit 7e912dafbe5d57c4232232244df2446a37160000, reversing
changes made to 139f9cdbead8ae85af59206b1f14c9d4044da639.
This commit is contained in:
Andrew Melton 2013-08-19 12:08:11 -04:00
parent 61792d4beb
commit 561feedb6d
8 changed files with 58 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
etc/pip-requires.txt
View File

@ -7,4 +7,3 @@ prettytable>=0.7.2
argparse
Pympler
requests
south

53
tests/unit/test_base_verifier.py
View File

@ -2,47 +2,61 @@ import datetime
import time
from django.db import transaction
import mox
import stubout
from stacktach import message_service
from tests.unit import StacktachBaseTestCase
from tests.unit.utils import HOST, PORT, VIRTUAL_HOST, USERID, PASSWORD, TICK_TIME, SETTLE_TIME, SETTLE_UNITS
from tests.unit.utils import make_verifier_config
from verifier import config as verifier_config
from verifier import base_verifier
class BaseVerifierTestCase(StacktachBaseTestCase):
def setUp(self):
self.mox = mox.Mox()
config = make_verifier_config(False)
self.pool = self.mox.CreateMockAnything()
self.stubs = stubout.StubOutForTesting()
self.reconciler = self.mox.CreateMockAnything()
self.verifier_with_reconciler = base_verifier.Verifier(config,
self.verifier_with_reconciler = base_verifier.Verifier(
pool=self.pool, reconciler=self.reconciler)
self.verifier_without_notifications = self\
._verifier_with_notifications_disabled()
self.verifier_with_notifications = self\
._verifier_with_notifications_enabled()
self.stubs = stubout.StubOutForTesting()
self.stubs.Set(verifier_config, 'durable_queue', lambda: True)
self.stubs.Set(verifier_config, 'topics', lambda:
{'exchange': ['notifications.info']})
self.stubs.Set(verifier_config, 'host', lambda: HOST)
self.stubs.Set(verifier_config, 'port', lambda: PORT)
self.stubs.Set(verifier_config, 'virtual_host', lambda: VIRTUAL_HOST)
self.stubs.Set(verifier_config, 'userid', lambda: USERID)
self.stubs.Set(verifier_config, 'password', lambda: PASSWORD)
self.stubs.Set(verifier_config, 'tick_time', lambda: TICK_TIME)
self.stubs.Set(verifier_config, 'settle_time', lambda: SETTLE_TIME)
self.stubs.Set(verifier_config, 'settle_units', lambda: SETTLE_UNITS)
self.stubs.Set(self.verifier_with_notifications, 'exchange',
lambda: 'exchange')
def _verifier_with_notifications_disabled(self):
config = make_verifier_config(False)
reconciler = self.mox.CreateMockAnything()
return base_verifier.Verifier(config,
pool=self.pool,
reconciler=reconciler)
self.stubs.Set(verifier_config, 'enable_notifications', lambda: False)
reconciler = self.mox.CreateMockAnything()
return base_verifier.Verifier(
pool=self.pool, reconciler=reconciler)
def _verifier_with_notifications_enabled(self):
config = make_verifier_config(True)
self.stubs.Set(verifier_config, 'enable_notifications', lambda: True)
reconciler = self.mox.CreateMockAnything()
return base_verifier.Verifier(config,
pool=self.pool,
reconciler=reconciler)
return base_verifier.Verifier(
pool=self.pool, reconciler=reconciler)
def tearDown(self):
self.mox.UnsetStubs()
self.stubs.UnsetAll()
def test_should_create_verifier_with_reconciler(self):
config = make_verifier_config(False)
self.stubs.Set(verifier_config, 'reconcile', lambda: True)
rec = self.mox.CreateMockAnything()
verifier = base_verifier.Verifier(config, pool=None, reconciler=rec)
verifier = base_verifier.Verifier(pool=None, reconciler=rec)
self.assertEqual(verifier.reconciler, rec)
def test_clean_results_full(self):
@ -139,7 +153,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
self.mox.VerifyAll()
def test_run_notifications(self):
self._mock_exchange_create_and_connect(self.verifier_with_notifications)
self._mock_exchange_create_and_connect()
self.mox.StubOutWithMock(self.verifier_with_notifications, '_run')
self.verifier_with_notifications._run(callback=mox.Not(mox.Is(None)))
self.mox.ReplayAll()
@ -147,7 +161,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
self.mox.VerifyAll()
def test_run_notifications_with_routing_keys(self):
self._mock_exchange_create_and_connect(self.verifier_with_notifications)
self._mock_exchange_create_and_connect()
self.mox.StubOutWithMock(self.verifier_with_notifications, '_run')
self.verifier_with_notifications._run(callback=mox.Not(mox.Is(None)))
self.mox.ReplayAll()
@ -202,8 +216,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
tran.__enter__().AndReturn(tran)
tran.__exit__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg())
transaction.commit_on_success().AndReturn(tran)
self._mock_exchange_create_and_connect(self.verifier_with_notifications)
self.verifier_with_notifications.exchange().AndReturn('exchange')
self._mock_exchange_create_and_connect()
self.mox.StubOutWithMock(self.verifier_with_notifications, '_keep_running')
self.verifier_with_notifications._keep_running().AndReturn(True)
start = datetime.datetime.utcnow()
@ -234,9 +247,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
self.mox.VerifyAll()
def _mock_exchange_create_and_connect(self, verifier):
self.mox.StubOutWithMock(verifier, 'exchange')
self.verifier_with_notifications.exchange().AndReturn('exchange')
def _mock_exchange_create_and_connect(self):
self.mox.StubOutWithMock(message_service, 'create_exchange')
exchange = self.mox.CreateMockAnything()
message_service.create_exchange('exchange', 'topic', durable=True) \

9
tests/unit/test_glance_verifier.py
View File

@ -25,16 +25,17 @@ import uuid
import kombu
import mox
import stubout
from stacktach import datetime_to_decimal as dt
from stacktach import models
from tests.unit import StacktachBaseTestCase
from utils import IMAGE_UUID_1
from utils import make_verifier_config
from verifier import glance_verifier
from verifier import FieldMismatch
from verifier import NotFound
from verifier import VerificationException
from verifier import config as verifier_config
class GlanceVerifierTestCase(StacktachBaseTestCase):
@ -43,14 +44,14 @@ class GlanceVerifierTestCase(StacktachBaseTestCase):
self.mox.StubOutWithMock(models, 'ImageUsage', use_mock_anything=True)
models.ImageUsage.objects = self.mox.CreateMockAnything()
self.pool = self.mox.CreateMockAnything()
config = make_verifier_config(False)
self.glance_verifier = glance_verifier.GlanceVerifier(config,
pool=self.pool)
self.glance_verifier = glance_verifier.GlanceVerifier(pool=self.pool)
self.mox.StubOutWithMock(models, 'ImageDeletes',
use_mock_anything=True)
models.ImageDeletes.objects = self.mox.CreateMockAnything()
self.mox.StubOutWithMock(models, 'ImageExists',
use_mock_anything=True)
self.stubs = stubout.StubOutForTesting()
self.stubs.Set(verifier_config, 'pool_size', lambda: 5)
def tearDown(self):
self.mox.UnsetStubs()

4
tests/unit/test_nova_verifier.py
View File

@ -31,7 +31,6 @@ import mox
from stacktach import datetime_to_decimal as dt
from stacktach import models
from tests.unit import StacktachBaseTestCase
from utils import make_verifier_config
from utils import INSTANCE_ID_1
from utils import RAX_OPTIONS_1
from utils import RAX_OPTIONS_2
@ -85,8 +84,7 @@ class NovaVerifierTestCase(StacktachBaseTestCase):
def _setup_verifier(self):
self.pool = self.mox.CreateMockAnything()
self.reconciler = self.mox.CreateMockAnything()
config = make_verifier_config(False)
self.verifier = nova_verifier.NovaVerifier(config,
self.verifier = nova_verifier.NovaVerifier(
pool=self.pool, reconciler=self.reconciler)
def tearDown(self):

27
tests/unit/utils.py
View File

@ -145,29 +145,4 @@ def create_tracker(mox, request_id, lifecycle, start, last_timing=None,
tracker.start=start
tracker.last_timing=last_timing
tracker.duration=duration
return tracker
class FakeVerifierConfig(object):
def __init__(self, host, port, virtual_host, userid, password, tick_time,
settle_time, settle_units, durable_queue, topics, notifs):
self.host = lambda: host
self.port = lambda: port
self.virtual_host = lambda: virtual_host
self.userid = lambda: userid
self.password = lambda: password
self.pool_size = lambda: 5
self.tick_time = lambda: tick_time
self.settle_time = lambda: settle_time
self.settle_units = lambda: settle_units
self.durable_queue = lambda: durable_queue
self.topics = lambda: topics
self.enable_notifications = lambda: notifs
def make_verifier_config(notifs):
topics = {'exchange': ['notifications.info']}
config = FakeVerifierConfig(HOST, PORT, VIRTUAL_HOST, USERID,
PASSWORD, TICK_TIME, SETTLE_TIME,
SETTLE_UNITS, True, topics, notifs)
return config
return tracker

34
verifier/base_verifier.py
View File

@ -32,6 +32,8 @@ POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'stacktach')):
sys.path.insert(0, POSSIBLE_TOPDIR)
from verifier import config as verifier_config
from stacktach import stacklog, message_service
LOG = stacklog.get_logger('verifier')
@ -66,10 +68,9 @@ def _verify_date_field(d1, d2, same_second=False):
class Verifier(object):
def __init__(self, config, pool=None, reconciler=None):
self.config = config
self.pool = pool or multiprocessing.Pool(config.pool_size())
self.enable_notifications = config.enable_notifications()
def __init__(self, pool=None, reconciler=None):
self.pool = pool or multiprocessing.Pool(verifier_config.pool_size())
self.enable_notifications = verifier_config.enable_notifications()
self.reconciler = reconciler
self.results = []
self.failed = []
@ -101,9 +102,9 @@ class Verifier(object):
return datetime.datetime.utcnow()
def _run(self, callback=None):
tick_time = self.config.tick_time()
settle_units = self.config.settle_units()
settle_time = self.config.settle_time()
tick_time = verifier_config.tick_time()
settle_units = verifier_config.settle_units()
settle_time = verifier_config.settle_time()
while self._keep_running():
with transaction.commit_on_success():
now = self._utcnow()
@ -119,27 +120,22 @@ class Verifier(object):
def run(self):
if self.enable_notifications:
exchange_name = self.exchange()
exchange = message_service.create_exchange(
exchange_name, 'topic',
durable=self.config.durable_queue())
routing_keys = self.config.topics()[exchange_name]
self.exchange(), 'topic',
durable=verifier_config.durable_queue())
routing_keys = verifier_config.topics()[self.exchange()]
with message_service.create_connection(
self.config.host(), self.config.port(),
self.config.userid(), self.config.password(),
"librabbitmq", self.config.virtual_host()) as conn:
verifier_config.host(), verifier_config.port(),
verifier_config.userid(), verifier_config.password(),
"librabbitmq", verifier_config.virtual_host()) as conn:
def callback(result):
(verified, exist) = result
if verified:
self.send_verified_notification(
exist, conn, exchange, routing_keys=routing_keys)
try:
self._run(callback=callback)
except Exception, e:
print e
raise e
self._run(callback=callback)
else:
self._run()

4
verifier/glance_verifier.py
View File

@ -127,8 +127,8 @@ def _verify(exist):
class GlanceVerifier(Verifier):
def __init__(self, config, pool=None):
super(GlanceVerifier, self).__init__(config, pool=pool)
def __init__(self, pool=None):
super(GlanceVerifier, self).__init__(pool)
def verify_for_range(self, ending_max, callback=None):
exists = models.ImageExists.find(

6
verifier/nova_verifier.py
View File

@ -215,10 +215,8 @@ def _verify(exist):
class NovaVerifier(base_verifier.Verifier):
def __init__(self, config, pool=None, reconciler=None):
super(NovaVerifier, self).__init__(config,
pool=pool,
reconciler=reconciler)
def __init__(self, pool=None, reconciler=None):
super(NovaVerifier, self).__init__(pool, reconciler)
def send_verified_notification(self, exist, connection, exchange,
routing_keys=None):