gettext.install('heat', unicode=1)
-from heat.openstack.common import log as logging
from heat.openstack.common import cfg
-from heat import service
+from heat.openstack.common import log as logging
+from heat.openstack.common import service
+
from heat.common import config
-from heat.common import utils
from heat.db import api as db_api
+from heat.engine import service as engine
+
logger = logging.getLogger('heat.engine')
if __name__ == '__main__':
- default_manager = 'heat.engine.manager.EngineManager'
cfg.CONF(project='heat', prog='heat-engine')
config.setup_logging()
config.register_engine_opts()
db_api.configure()
- #utils.monkey_patch()
- server = service.Service.create(binary='heat-engine',
- topic='engine',
- manager=default_manager,
- config=cfg.CONF)
- service.serve(server)
- service.wait()
+ srv = engine.EngineService(cfg.CONF.host,
+ 'engine')
+ launcher = service.launch(srv)
+ launcher.wait()
# License for the specific language governing permissions and limitations
# under the License.
-
-from copy import deepcopy
-import datetime
import webob
-import json
-import urlparse
-import httplib
-import eventlet
-import collections
-from heat import manager
+from heat.common import context
from heat.db import api as db_api
-from heat.common import config
-from heat.common import utils as heat_utils
from heat.engine import api
from heat.engine import identifier
from heat.engine import parser
from heat.engine import watchrule
-from heat.engine import auth
from heat.openstack.common import cfg
-from heat.openstack.common import timeutils
from heat.openstack.common import log as logging
+from heat.openstack.common import threadgroup
+from heat.openstack.common.gettextutils import _
+from heat.openstack.common.rpc import service
-from novaclient.v1_1 import client
-from novaclient.exceptions import BadRequest
-from novaclient.exceptions import NotFound
-from novaclient.exceptions import AuthorizationFailure
-logger = logging.getLogger('heat.engine.manager')
-greenpool = eventlet.GreenPool()
+logger = logging.getLogger(__name__)
-class EngineManager(manager.Manager):
+class EngineService(service.Service):
"""
Manages the running instances from creation to destruction.
All the methods in here are called from the RPC backend. This is
are also dynamically added and will be named as keyword arguments
by the RPC caller.
"""
-
- def __init__(self, *args, **kwargs):
- """Load configuration options and connect to the hypervisor."""
-
- # Maintain a dict mapping stack ids to in-progress greenthreads
- # allows us to kill any pending create|update before delete_stack
- #
- # Currently we should only ever have one outstanding thread, but
- # the implementation makes this a dict-of-sets so we could use
- # the same method to cancel multiple threads, e.g if long-running
- # query actions need to be spawned instead of run immediately
- self.stack_threads = collections.defaultdict(set)
-
- def _gt_done_callback(self, gt, **kwargs):
- '''
- Callback function to be passed to GreenThread.link() when we spawn()
- Removes the thread ID from the stack_threads set of pending threads
- kwargs should contain 'stack_id'
- '''
- if not 'stack_id' in kwargs:
- logger.error("_gt_done_callback called with no stack_id!")
- else:
- stack_id = kwargs['stack_id']
- if stack_id in self.stack_threads:
- logger.debug("Thread done callback for stack %s, %s" %
- (stack_id, gt))
- self.stack_threads[stack_id].discard(gt)
- if not len(self.stack_threads[stack_id]):
- del self.stack_threads[stack_id]
+ def __init__(self, host, topic, manager=None):
+ super(EngineService, self).__init__(host, topic)
+ # stg == "Stack Thread Groups"
+ self.stg = {}
+
+ def _start_in_thread(self, stack_id, stack_name, func, *args, **kwargs):
+ if stack_id not in self.stg:
+ thr_name = '%s-%s' % (stack_name, stack_id)
+ self.stg[stack_id] = threadgroup.ThreadGroup(thr_name)
+ self.stg[stack_id].add_thread(func, *args, **kwargs)
+
+ def start(self):
+ super(EngineService, self).start()
+ admin_context = context.get_admin_context()
+ self.tg.add_timer(cfg.CONF.periodic_interval,
+ self._periodic_watcher_task,
+ context=admin_context)
def identify_stack(self, context, stack_name):
"""
stack_id = stack.store()
- # Spawn a greenthread to do the create, and register a
- # callback to remove the thread from stack_threads when done
- gt = greenpool.spawn(stack.create)
- gt.link(self._gt_done_callback, stack_id=stack_id)
- self.stack_threads[stack_id].add(gt)
+ self._start_in_thread(stack_id, stack_name, stack.create)
return dict(stack.identifier())
if response:
return {'Description': response}
- # Spawn a greenthread to do the update, and register a
- # callback to remove the thread from stack_threads when done
- gt = greenpool.spawn(current_stack.update, updated_stack)
- gt.link(self._gt_done_callback, stack_id=db_stack.id)
- self.stack_threads[db_stack.id].add(gt)
+ self._start_in_thread(db_stack.id, db_stack.name,
+ current_stack.update,
+ updated_stack)
return dict(current_stack.identifier())
stack = parser.Stack.load(context, st.id)
- # Kill any in-progress create or update threads
- if st.id in self.stack_threads:
- # Note we must use set.copy() here or we get an error when thread
- # rescheduling happens on t.kill() and _gt_done_callback modifies
- # stack_threads[st.id] mid-iteration
- for t in self.stack_threads[st.id].copy():
- logger.warning("Killing running thread %s for stack %s" %
- (t, st.name))
- t.kill()
-
- greenpool.spawn_n(stack.delete)
+ # TODO Angus do we need a kill or will stop do?
+ if st.id in self.stg:
+ self.stg[st.id].stop()
+ self.stg[st.id].wait()
+ del self.stg[st.id]
+ # use the service ThreadGroup for deletes
+ self.tg.add_thread(stack.delete)
return None
def list_events(self, context, stack_identity):
return [None, resource.metadata]
- @manager.periodic_task
def _periodic_watcher_task(self, context):
-
- now = timeutils.utcnow()
try:
wrn = [w.name for w in db_api.watch_rule_get_all(context)]
except Exception as ex:
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-"""Base Manager class.
-
-Managers are responsible for a certain aspect of the system. It is a logical
-grouping of code relating to a portion of the system. In general other
-components should be using the manager to make changes to the components that
-it is responsible for.
-
-For example, other components that need to deal with volumes in some way,
-should do so by calling methods on the VolumeManager instead of directly
-changing fields in the database. This allows us to keep all of the code
-relating to volumes in the same place.
-
-We have adopted a basic strategy of Smart managers and dumb data, which means
-rather than attaching methods to data objects, components should call manager
-methods that act on the data.
-
-Methods on managers that can be executed locally should be called directly. If
-a particular method must execute on a remote host, this should be done via rpc
-to the service that wraps the manager
-
-Managers should be responsible for most of the db access, and
-non-implementation specific data. Anything implementation specific that can't
-be generalized should be done by the Driver.
-
-In general, we prefer to have one manager with multiple drivers for different
-implementations, but sometimes it makes sense to have multiple managers. You
-can think of it this way: Abstract different overall strategies at the manager
-level(FlatNetwork vs VlanNetwork), and different implementations at the driver
-level(LinuxNetDriver vs CiscoNetDriver).
-
-Managers will often provide methods for initial setup of a host or periodic
-tasks to a wrapping service.
-
-This module provides Manager, a base class for managers.
-
-"""
-
-from heat import version
-
-from heat.openstack.common.rpc import dispatcher as rpc_dispatcher
-from heat.openstack.common import log as logging
-from heat.openstack.common import cfg
-
-
-LOG = logging.getLogger(__name__)
-
-
-def periodic_task(*args, **kwargs):
- """Decorator to indicate that a method is a periodic task.
-
- This decorator can be used in two ways:
-
- 1. Without arguments '@periodic_task', this will be run on every tick
- of the periodic scheduler.
-
- 2. With arguments, @periodic_task(ticks_between_runs=N), this will be
- run on every N ticks of the periodic scheduler.
- """
- def decorator(f):
- f._periodic_task = True
- f._ticks_between_runs = kwargs.pop('ticks_between_runs', 0)
- return f
-
- # NOTE(sirp): The `if` is necessary to allow the decorator to be used with
- # and without parens.
- #
- # In the 'with-parens' case (with kwargs present), this function needs to
- # return a decorator function since the interpreter will invoke it like:
- #
- # periodic_task(*args, **kwargs)(f)
- #
- # In the 'without-parens' case, the original function will be passed
- # in as the first argument, like:
- #
- # periodic_task(f)
- if kwargs:
- return decorator
- else:
- return decorator(args[0])
-
-
-class ManagerMeta(type):
- def __init__(cls, names, bases, dict_):
- """Metaclass that allows us to collect decorated periodic tasks."""
- super(ManagerMeta, cls).__init__(names, bases, dict_)
-
- # NOTE(sirp): if the attribute is not present then we must be the base
- # class, so, go ahead an initialize it. If the attribute is present,
- # then we're a subclass so make a copy of it so we don't step on our
- # parent's toes.
- try:
- cls._periodic_tasks = cls._periodic_tasks[:]
- except AttributeError:
- cls._periodic_tasks = []
-
- try:
- cls._ticks_to_skip = cls._ticks_to_skip.copy()
- except AttributeError:
- cls._ticks_to_skip = {}
-
- for value in cls.__dict__.values():
- if getattr(value, '_periodic_task', False):
- task = value
- name = task.__name__
- cls._periodic_tasks.append((name, task))
- cls._ticks_to_skip[name] = task._ticks_between_runs
-
-
-class Manager(object):
- __metaclass__ = ManagerMeta
-
- def __init__(self, host=None, db_driver=None):
- if not host:
- host = cfg.CONF.host
- self.host = host
- super(Manager, self).__init__(db_driver)
-
- def create_rpc_dispatcher(self):
- '''Get the rpc dispatcher for this manager.
-
- If a manager would like to set an rpc API version, or support more than
- one class as the target of rpc messages, override this method.
- '''
- return rpc_dispatcher.RpcDispatcher([self])
-
- def periodic_tasks(self, context, raise_on_error=False):
- """Tasks to be run at a periodic interval."""
- for task_name, task in self._periodic_tasks:
- full_task_name = '.'.join([self.__class__.__name__, task_name])
-
- ticks_to_skip = self._ticks_to_skip[task_name]
- if ticks_to_skip > 0:
- LOG.debug(_("Skipping %(full_task_name)s, %(ticks_to_skip)s"
- " ticks left until next run"), locals())
- self._ticks_to_skip[task_name] -= 1
- continue
-
- self._ticks_to_skip[task_name] = task._ticks_between_runs
- LOG.debug(_("Running periodic task %(full_task_name)s"), locals())
-
- try:
- task(self, context)
- except Exception as e:
- if raise_on_error:
- raise
- LOG.exception(_("Error during %(full_task_name)s: %(e)s"),
- locals())
-
- def init_host(self):
- """Handle initialization if this is a standalone service.
-
- Child classes should override this method.
-
- """
- pass
-
- def service_version(self, context):
- return version.version_string()
-
- def service_config(self, context):
- config = {}
- for key in cfg.CONF:
- config[key] = cfg.CONF.get(key, None)
- return config
+++ /dev/null
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# Copyright 2011 Justin Santa Barbara
-# All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-"""Generic Node base class for all workers that run on hosts."""
-
-import inspect
-import os
-
-import eventlet
-import greenlet
-
-from heat.openstack.common import rpc
-from heat.openstack.common import cfg
-from heat.openstack.common import importutils
-from heat.openstack.common import log as logging
-
-from heat.common import utils as heat_utils
-from heat.common import exception
-from heat.common import context
-
-from heat import version
-
-LOG = logging.getLogger(__name__)
-
-
-class Launcher(object):
- """
- Launch one or more services and wait for them to complete.
- """
-
- def __init__(self):
- """Initialize the service launcher.
-
- :returns: None
-
- """
- self._services = []
-
- @staticmethod
- def run_server(server):
- """Start and wait for a server to finish.
-
- :param service: Server to run and wait for.
- :returns: None
-
- """
- server.start()
- server.wait()
-
- def launch_server(self, server):
- """Load and start the given server.
-
- :param server: The server you would like to start.
- :returns: None
-
- """
- gt = eventlet.spawn(self.run_server, server)
- self._services.append(gt)
-
- def stop(self):
- """Stop all services which are currently running.
-
- :returns: None
-
- """
- for service in self._services:
- service.kill()
-
- def wait(self):
- """Waits until all services have been stopped, and then returns.
-
- :returns: None
-
- """
- for service in self._services:
- try:
- service.wait()
- except greenlet.GreenletExit:
- pass
-
-
-class Service(object):
- """Service object for binaries running on hosts.
-
- A service takes a manager and enables rpc by listening to queues based
- on topic. It also periodically runs tasks on the manager and reports
- it state to the database services table."""
-
- def __init__(self, host, binary, topic, manager,
- periodic_interval=None, *args, **kwargs):
- self.host = host
- self.binary = binary
- self.topic = topic
- self.manager_class_name = manager
- manager_class = importutils.import_class(self.manager_class_name)
- self.manager = manager_class(host=self.host, *args, **kwargs)
- self.periodic_interval = periodic_interval
- super(Service, self).__init__(*args, **kwargs)
- self.saved_args, self.saved_kwargs = args, kwargs
- self.timers = []
-
- def start(self):
- vcs_string = version.version_string(type='long')
- LOG.info(_('Starting %(topic)s node (version %(vcs_string)s)'),
- {'topic': self.topic, 'vcs_string': vcs_string})
- # TODO do we need this ? -> utils.cleanup_file_locks()
- self.manager.init_host()
- self.model_disconnected = False
- ctxt = context.get_admin_context()
- # self._create_service_ref(ctxt)
-
- self.conn = rpc.create_connection(new=True)
- LOG.debug(_("Creating Consumer connection for Service %s") %
- self.topic)
-
- rpc_dispatcher = self.manager.create_rpc_dispatcher()
-
- # Share this same connection for these Consumers
- self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)
-
- node_topic = '%s.%s' % (self.topic, self.host)
- self.conn.create_consumer(node_topic, rpc_dispatcher, fanout=False)
-
- self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=True)
-
- # Consume from all consumers in a thread
- self.conn.consume_in_thread()
-
- if self.periodic_interval:
- periodic = heat_utils.LoopingCall(self.periodic_tasks)
- periodic.start(interval=self.periodic_interval, now=False)
- self.timers.append(periodic)
-
- def __getattr__(self, key):
- manager = self.__dict__.get('manager', None)
- return getattr(manager, key)
-
- @classmethod
- def create(cls, host=None, binary=None, topic=None, manager=None,
- periodic_interval=None, config=None):
- """Instantiates class and passes back application object.
-
- :param host: defaults to cfg.CONF.host
- :param binary: defaults to basename of executable
- :param topic: defaults to bin_name - 'heat-' part
- :param manager: defaults to cfg.CONF.<topic>_manager
- :param periodic_interval: defaults to cfg.CONF.periodic_interval
-
- """
- if not host:
- host = cfg.CONF.host
- if not binary:
- binary = os.path.basename(inspect.stack()[-1][1])
- if not topic:
- topic = binary.rpartition('heat-')[2]
- if not manager:
- manager = cfg.CONF.get('%s_manager' % topic, None)
- if not periodic_interval:
- periodic_interval = cfg.CONF.periodic_interval
- service_obj = cls(host, binary, topic, manager,
- periodic_interval)
-
- return service_obj
-
- def kill(self):
- self.stop()
-
- def stop(self):
- # Try to shut the connection down, but if we get any sort of
- # errors, go ahead and ignore them.. as we're shutting down anyway
- try:
- self.conn.close()
- except Exception:
- pass
- for x in self.timers:
- try:
- x.stop()
- except Exception:
- pass
- self.timers = []
-
- def wait(self):
- for x in self.timers:
- try:
- x.wait()
- except Exception:
- pass
-
- def periodic_tasks(self, raise_on_error=False):
- """Tasks to be run at a periodic interval."""
- ctxt = context.get_admin_context()
- self.manager.periodic_tasks(ctxt, raise_on_error=raise_on_error)
-
-
-# NOTE(vish): the global launcher is to maintain the existing
-# functionality of calling service.serve +
-# service.wait
-_launcher = None
-
-
-def serve(*servers):
- global _launcher
- if not _launcher:
- _launcher = Launcher()
- for server in servers:
- _launcher.launch_server(server)
-
-
-def wait():
- LOG.debug(_('Full set of CONF:'))
- for flag in cfg.CONF:
- flag_get = cfg.CONF.get(flag, None)
- # hide flag contents from log if contains a password
- # should use secret flag when switch over to openstack-common
- if ("_password" in flag or "_key" in flag or
- (flag == "sql_connection" and "mysql:" in flag_get)):
- LOG.debug(_('%(flag)s : FLAG SET ') % locals())
- else:
- LOG.debug('%(flag)s : %(flag_get)s' % locals())
- try:
- _launcher.wait()
- rpc.cleanup()
- except KeyboardInterrupt:
- rpc.cleanup()
- _launcher.stop()
import util
import verify
-import nose
from nose.plugins.attrib import attr
-from heat.common import context
-from heat.engine import manager
import unittest
import os
import util
import verify
-import nose
from nose.plugins.attrib import attr
-from heat.common import context
-from heat.engine import manager
import unittest
import os
import util
import verify
-import nose
from nose.plugins.attrib import attr
-from heat.common import context
-from heat.engine import manager
import unittest
import os
import util
import verify
-import nose
from nose.plugins.attrib import attr
-from heat.common import context
-from heat.engine import manager
import unittest
import os
import util
import verify
-import nose
from nose.plugins.attrib import attr
-from heat.common import context
-from heat.engine import manager
import unittest
import os
import unittest
import mox
import json
-import sqlalchemy
from nose.plugins.attrib import attr
-from nose import with_setup
from heat.common import context
from heat.tests.v1_1 import fakes
import heat.engine.api as engine_api
import heat.db as db_api
from heat.engine import parser
-from heat.engine import manager
-from heat.engine import auth
+from heat.engine import service
from heat.engine.resources import instance as instances
from heat.engine import watchrule
+from heat.openstack.common import threadgroup
tests_dir = os.path.dirname(os.path.realpath(__file__))
meta=None).AndReturn(fc.servers.list()[-1])
-class DummyGreenThread():
- def link(self, gt, **kwargs):
+class DummyThreadGroup(object):
+ def add_thread(self, callback, *args, **kwargs):
+ pass
+
+ def stop(self):
+ pass
+
+ def wait(self):
pass
self.assertEqual(db_s.status, 'DELETE_COMPLETE')
-@attr(tag=['unit', 'engine-api', 'engine-manager'])
+@attr(tag=['unit', 'engine-api', 'engine-service'])
@attr(speed='fast')
-class stackManagerCreateUpdateDeleteTest(unittest.TestCase):
+class stackServiceCreateUpdateDeleteTest(unittest.TestCase):
def setUp(self):
self.m = mox.Mox()
- self.username = 'stack_manager_create_test_user'
- self.tenant = 'stack_manager_create_test_tenant'
+ self.username = 'stack_service_create_test_user'
+ self.tenant = 'stack_service_create_test_tenant'
self.ctx = create_context(self.m, self.username, self.tenant)
- self.man = manager.EngineManager()
+ self.man = service.EngineService('a-host', 'a-topic')
def tearDown(self):
self.m.UnsetStubs()
def test_stack_create(self):
- stack_name = 'manager_create_test_stack'
+ stack_name = 'service_create_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
self.m.StubOutWithMock(stack, 'validate')
stack.validate().AndReturn(None)
- self.m.StubOutWithMock(manager.greenpool, 'spawn')
- manager.greenpool.spawn(stack.create).AndReturn(DummyGreenThread())
+ self.m.StubOutWithMock(threadgroup, 'ThreadGroup')
+ name_match = mox.StrContains(stack.name)
+ threadgroup.ThreadGroup(name_match).AndReturn(DummyThreadGroup())
self.m.ReplayAll()
self.m.VerifyAll()
def test_stack_create_verify_err(self):
- stack_name = 'manager_create_verify_err_test_stack'
+ stack_name = 'service_create_verify_err_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
error = 'fubar'
stack.validate().AndReturn(error)
- self.m.StubOutWithMock(manager.greenpool, 'spawn')
+ #self.m.StubOutWithMock(threadgroup, 'ThreadGroup')
+ #threadgroup.ThreadGroup(stack_name).AndReturn(DummyThreadGroup())
self.m.ReplayAll()
self.m.VerifyAll()
def test_stack_delete(self):
- stack_name = 'manager_delete_test_stack'
+ stack_name = 'service_delete_test_stack'
stack = get_wordpress_stack(stack_name, self.ctx)
stack.store()
self.m.StubOutWithMock(parser.Stack, 'load')
- self.m.StubOutWithMock(manager.greenpool, 'spawn_n')
+ #self.m.StubOutWithMock(threadgroup, 'ThreadGroup')
+ #threadgroup.ThreadGroup(stack_name).AndReturn(DummyThreadGroup())
parser.Stack.load(self.ctx, stack.id).AndReturn(stack)
- manager.greenpool.spawn_n(stack.delete)
self.m.ReplayAll()
self.m.VerifyAll()
def test_stack_delete_nonexist(self):
- stack_name = 'manager_delete_nonexist_test_stack'
+ stack_name = 'service_delete_nonexist_test_stack'
stack = get_wordpress_stack(stack_name, self.ctx)
self.m.ReplayAll()
self.m.VerifyAll()
def test_stack_update(self):
- stack_name = 'manager_update_test_stack'
+ stack_name = 'service_update_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
self.m.StubOutWithMock(stack, 'validate')
stack.validate().AndReturn(None)
- self.m.StubOutWithMock(manager.greenpool, 'spawn')
- manager.greenpool.spawn(old_stack.update, stack).AndReturn(
- DummyGreenThread())
-
self.m.ReplayAll()
result = self.man.update_stack(self.ctx, old_stack.identifier(),
self.m.VerifyAll()
def test_stack_update_verify_err(self):
- stack_name = 'manager_update_verify_err_test_stack'
+ stack_name = 'service_update_verify_err_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
error = 'fubar'
stack.validate().AndReturn(error)
- self.m.StubOutWithMock(manager.greenpool, 'spawn')
-
self.m.ReplayAll()
result = self.man.update_stack(self.ctx, old_stack.identifier(),
self.m.VerifyAll()
def test_stack_update_nonexist(self):
- stack_name = 'manager_update_nonexist_test_stack'
+ stack_name = 'service_update_nonexist_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
stack = get_wordpress_stack(stack_name, self.ctx)
self.m.VerifyAll()
-@attr(tag=['unit', 'engine-api', 'engine-manager'])
+@attr(tag=['unit', 'engine-api', 'engine-service'])
@attr(speed='fast')
-class stackManagerTest(unittest.TestCase):
+class stackServiceTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
m = mox.Mox()
- cls.username = 'stack_manager_test_user'
- cls.tenant = 'stack_manager_test_tenant'
+ cls.username = 'stack_service_test_user'
+ cls.tenant = 'stack_service_test_tenant'
ctx = create_context(m, cls.username, cls.tenant)
- cls.stack_name = 'manager_test_stack'
+ cls.stack_name = 'service_test_stack'
stack = get_wordpress_stack(cls.stack_name, ctx)
setup_mocks(m, stack)
setup_mocks(self.m, self.stack)
self.m.ReplayAll()
- self.man = manager.EngineManager()
+ self.man = service.EngineService('a-host', 'a-topic')
def tearDown(self):
self.m.UnsetStubs()
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
-
-
import sys
-import os
-
import nose
import unittest
import mox
import json
-import sqlalchemy
from nose.plugins.attrib import attr
-from nose import with_setup
from heat.tests.v1_1 import fakes
from heat.engine.resources import instance as instances
-from heat.engine.resources import volume as volumes
-from heat.engine import manager as managers
+from heat.engine import service
import heat.db as db_api
from heat.engine import parser
-from heat.engine import auth
test_template_volumeattach = '''
{
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
- manager = managers.EngineManager()
- res = dict(manager.
+ engine = service.EngineService('a', 't')
+ res = dict(engine.
validate_template(None, t))
print 'res %s' % res
self.assertEqual(res['Description'], 'test.')
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
- manager = managers.EngineManager()
- res = dict(manager.
+ engine = service.EngineService('a', 't')
+ res = dict(engine.
validate_template(None, t))
self.assertNotEqual(res['Description'], 'Successfully validated')
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
- manager = managers.EngineManager()
- res = dict(manager.
+ engine = service.EngineService('a', 't')
+ res = dict(engine.
validate_template(None, t))
self.assertEqual(res['Description'], 'test.')
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
- manager = managers.EngineManager()
- res = dict(manager.
+ engine = service.EngineService('a', 't')
+ res = dict(engine.
validate_template(None, t))
self.assertNotEqual(res['Description'], 'Successfully validated')
Code Review / openstack-build / heat-build.git / commitdiff