def __init__(self, options):
self.options = options
model_cls = load_class_by_string(options['model'])
riak_config = {
'bucket_prefix': options['bucket-prefix'],
}
self.manager = self.get_riak_manager(riak_config)
self.model = self.manager.proxy(model_cls)
# The default post-migrate-function does nothing and returns True if
# and only if the object was migrated.
self.post_migrate_function = lambda obj: obj.was_migrated
if options['post-migrate-function'] is not None:
self.post_migrate_function = load_class_by_string(
options['post-migrate-function'])
def __init__(self, options):
self.options = options
model_cls = load_class_by_string(options['model'])
riak_config = {
'bucket_prefix': options['bucket-prefix'],
}
manager = self.get_riak_manager(riak_config)
self.model = manager.proxy(model_cls)
# The default post-migrate-function does nothing and returns True if
# and only if the object was migrated.
self.post_migrate_function = lambda obj: obj.was_migrated
if options['post-migrate-function'] is not None:
self.post_migrate_function = load_class_by_string(
options['post-migrate-function'])
def validate_destination_config(self, config):
"""
Passes the config to the specified worker class for validation
"""
worker_class = load_class_by_string(self._worker_class_name)
return maybeDeferred(
worker_class.validate_destination_config, self.api, config)
def consume_user_message(self, message):
"""
Dynamically contruct menu based on user input.
If no session is found self.initial_menu is constructed.
"""
user_id = message.user()
session = self.session_manager.load_session(user_id)
try:
if not session:
session = self.session_manager.create_session(user_id)
menu_class = self.initial_menu
else:
if 'class' in session:
menu_class = load_class_by_string(session['class'])
else:
menu_class = self.initial_menu
try:
menu = menu_class(message, session, int(message['content']))
except ValueError:
menu = menu_class(message, session, '')
self.session_manager.save_session(user_id, session)
self.reply_to(message, menu.generate_menu(message['content']))
except Exception, e:
self.reply_to(message, str(e))
def consume_user_message(self, message):
"""
Dynamically contruct menu based on user input.
If no session is found self.initial_menu is constructed.
"""
user_id = message.user()
session = self.session_manager.load_session(user_id)
try:
if not session:
session = self.session_manager.create_session(user_id)
menu_class = self.initial_menu
else:
if 'class' in session:
menu_class = load_class_by_string(session['class'])
else:
menu_class = self.initial_menu
try:
menu = menu_class(message, session, int(message['content']))
except ValueError:
menu = menu_class(message, session, '')
self.session_manager.save_session(user_id, session)
self.reply_to(message, menu.generate_menu(message['content']))
except Exception, e:
self.reply_to(message, str(e))
def validate_config(self):
# FIXME: The name of this method is a vicious lie.
# It does not validate configs. It constructs resources objects.
# Fixing that is beyond the scope of this commit, however.
for name, config in self.config.iteritems():
cls = load_class_by_string(config.pop('cls'))
self.resources[name] = cls(name, self.app_worker, config)
def setup(self, redis=None, message_sender=None):
if redis is None:
redis = yield TxRedisManager.from_config(self.redis_config)
if message_sender is None:
message_sender = MessageSender(
'amqp-spec-0-8.xml', self.amqp_config)
self.redis = redis
self.message_sender = message_sender
self.message_sender.setServiceParent(self.service)
self.inbounds = InboundMessageStore(
self.redis, self.config.inbound_message_ttl)
self.outbounds = OutboundMessageStore(
self.redis, self.config.outbound_message_ttl)
self.message_rate = MessageRateStore(self.redis)
self.plugins = []
for plugin_config in self.config.plugins:
cls = load_class_by_string(plugin_config['type'])
plugin = cls()
yield plugin.start_plugin(plugin_config, self.config)
self.plugins.append(plugin)
yield Channel.start_all_channels(
self.redis, self.config, self.service, self.plugins)
def setup(self, redis=None, message_sender=None):
if redis is None:
redis = yield TxRedisManager.from_config(self.redis_config)
if message_sender is None:
message_sender = MessageSender('amqp-spec-0-8.xml',
self.amqp_config)
self.redis = redis
self.message_sender = message_sender
self.message_sender.setServiceParent(self.service)
self.inbounds = InboundMessageStore(self.redis,
self.config.inbound_message_ttl)
self.outbounds = OutboundMessageStore(self.redis,
self.config.outbound_message_ttl)
self.message_rate = MessageRateStore(self.redis)
self.plugins = []
for plugin_config in self.config.plugins:
cls = load_class_by_string(plugin_config['type'])
plugin = cls()
yield plugin.start_plugin(plugin_config, self.config)
self.plugins.append(plugin)
yield Channel.start_all_channels(self.redis, self.config, self.service,
self.plugins)
def __init__(self, options):
self.options = options
model_cls = load_class_by_string(options['model'])
riak_config = {
'bucket_prefix': options['bucket-prefix'],
}
self.manager = self.get_riak_manager(riak_config)
self.model = self.manager.proxy(model_cls)
def do_worker_help(self):
"""Print out a usage message for the worker-class and exit"""
worker_class = load_class_by_string(self.worker_class)
self.emit(worker_class.__doc__)
config_class = getattr(worker_class, 'CONFIG_CLASS', None)
if config_class is not None:
self.emit(config_class.__doc__)
self.emit("")
self.exit()
def do_worker_help(self):
"""Print out a usage message for the worker-class and exit"""
worker_class = load_class_by_string(self.worker_class)
self.emit(worker_class.__doc__)
config_class = getattr(worker_class, 'CONFIG_CLASS', None)
if config_class is not None:
self.emit(config_class.__doc__)
self.emit("")
self.exit()
def create_worker(self, worker_class, config, timeout=30, bindAddress=None):
"""
Create a worker factory, connect to AMQP and return the factory.
Return value is the AmqpFactory instance containing the worker.
"""
return self.create_worker_by_class(
load_class_by_string(worker_class), config, timeout=timeout, bindAddress=bindAddress
)
def create_worker(self, worker_class, config, timeout=30,
bindAddress=None):
"""
Create a worker factory, connect to AMQP and return the factory.
Return value is the AmqpFactory instance containing the worker.
"""
return self.create_worker_by_class(
load_class_by_string(worker_class), config, timeout=timeout,
bindAddress=bindAddress)
def opt_worker_help(self):
worker_class_name = self.opts.pop('worker-class')
if worker_class_name is None:
# fallback to deprecated --worker_class option
worker_class_name = self.opts.pop('worker_class')
if worker_class_name is None:
print "--worker-help requires --worker-class to be set too"
else:
worker_class = load_class_by_string(worker_class_name)
print worker_class.__doc__
sys.exit(0)
def setup_application(self):
self.handlers = {}
self.api_command_publisher = yield self.start_publisher(
ApiCommandPublisher)
self.vumi_api = yield VumiApi.from_config_async(
self.config, self.api_command_publisher)
self.account_config = {}
for name, handler_class in self.handler_config.items():
cls = load_class_by_string(handler_class)
self.handlers[name] = cls(self, self.config.get(name, {}))
yield self.handlers[name].setup_handler()
self.api_event_consumer = yield self.consume(
ApiEventPublisher.routing_key, self.consume_api_event,
message_class=VumiApiEvent)
def setup_application(self):
self.handlers = {}
self.api_command_publisher = yield self.start_publisher(
ApiCommandPublisher)
self.vumi_api = yield VumiApi.from_config_async(
self.config, self.api_command_publisher)
self.account_config = {}
for name, handler_class in self.handler_config.items():
cls = load_class_by_string(handler_class)
self.handlers[name] = cls(self, self.config.get(name, {}))
yield self.handlers[name].setup_handler()
self.api_event_consumer = yield self.consume(
ApiEventPublisher.routing_key,
self.consume_api_event,
message_class=VumiApiEvent)
def __init__(self, message, session, choice=None):
"""
Initiate menu based on incomming choice from previous menu.
Options specific session data for given choice is
added to session data.
"""
self.message = message
self.session = session
if choice:
options = self.get_options()
resolved_choice = options[int(choice) - 1]
session.update(resolved_choice[1])
session['class'] = resolved_choice[2]
self.process_response(choice)
self.response_menu = \
load_class_by_string(resolved_choice[2])(message, session)
else:
self.response_menu = self
def create_middlewares_from_config(worker, config):
"""Return a list of middleware objects created from a worker
configuration.
"""
middlewares = []
for item in config.get("middleware", []):
keys = item.keys()
if len(keys) != 1:
raise ConfigError(
"Middleware items contain only a single key-value pair. The"
" key should be a name for the middleware. The value should be"
" the full dotted name of the class implementing the"
" middleware, or a mapping containing the keys 'class' with a"
" value of the full dotted class name, 'consume_priority' with"
" the priority level for consuming, and 'publish_priority'"
" with the priority level for publishing, both integers.")
middleware_name = keys[0]
middleware_config = config.get(middleware_name, {})
if isinstance(item[middleware_name], basestring):
cls_name = item[middleware_name]
middleware_config['consume_priority'] = 0
middleware_config['publish_priority'] = 0
elif isinstance(item[middleware_name], dict):
conf = item[middleware_name]
cls_name = conf.get('class')
try:
middleware_config['consume_priority'] = int(conf.get(
'consume_priority', 0))
middleware_config['publish_priority'] = int(conf.get(
'publish_priority', 0))
except ValueError:
raise ConfigError(
"Middleware priority level must be an integer")
else:
raise ConfigError(
"Middleware item values must either be a string with the",
" full dotted name of the class implementing the middleware,"
" or a dictionary with 'class', 'consume_priority', and"
" 'publish_priority' keys.")
cls = load_class_by_string(cls_name)
middleware = cls(middleware_name, middleware_config, worker)
middlewares.append(middleware)
return middlewares
def create_middlewares_from_config(worker, config):
"""Return a list of middleware objects created from a worker
configuration.
"""
middlewares = []
for item in config.get("middleware", []):
keys = item.keys()
if len(keys) != 1:
raise ConfigError(
"Middleware items contain only a single key-value pair. The"
" key should be a name for the middleware. The value should be"
" the full dotted name of the class implementing the"
" middleware, or a mapping containing the keys 'class' with a"
" value of the full dotted class name, 'consume_priority' with"
" the priority level for consuming, and 'publish_priority'"
" with the priority level for publishing, both integers.")
middleware_name = keys[0]
middleware_config = config.get(middleware_name, {})
if isinstance(item[middleware_name], basestring):
cls_name = item[middleware_name]
middleware_config['consume_priority'] = 0
middleware_config['publish_priority'] = 0
elif isinstance(item[middleware_name], dict):
conf = item[middleware_name]
cls_name = conf.get('class')
try:
middleware_config['consume_priority'] = int(
conf.get('consume_priority', 0))
middleware_config['publish_priority'] = int(
conf.get('publish_priority', 0))
except ValueError:
raise ConfigError(
"Middleware priority level must be an integer")
else:
raise ConfigError(
"Middleware item values must either be a string with the",
" full dotted name of the class implementing the middleware,"
" or a dictionary with 'class', 'consume_priority', and"
" 'publish_priority' keys.")
cls = load_class_by_string(cls_name)
middleware = cls(middleware_name, middleware_config, worker)
middlewares.append(middleware)
return middlewares
def token_task(request):
api = request.user_api.api
token = request.GET.get('token')
token_data = api.token_manager.verify_get(token)
if not token_data:
raise Http404
params = token_data['extra_params']
callback_name = params['callback_name']
callback_args = params['callback_args']
callback_kwargs = params['callback_kwargs']
return_to = params['return_to']
message = params['message']
message_level = params['message_level']
callback = load_class_by_string(callback_name)
callback(*callback_args, **callback_kwargs)
messages.add_message(request, message_level, message)
return redirect(return_to)
def token_task(request):
api = request.user_api.api
token = request.GET.get('token')
token_data = api.token_manager.verify_get(token)
if not token_data:
raise Http404
params = token_data['extra_params']
callback_name = params['callback_name']
callback_args = params['callback_args']
callback_kwargs = params['callback_kwargs']
return_to = params['return_to']
message = params['message']
message_level = params['message_level']
callback = load_class_by_string(callback_name)
callback(*callback_args, **callback_kwargs)
messages.add_message(request, message_level, message)
return redirect(return_to)
def create_middlewares_from_config(worker, config):
"""Return a list of middleware objects created from a worker
configuration.
"""
middlewares = []
for item in config.get("middleware", []):
keys = item.keys()
if len(keys) != 1:
raise ConfigError("Middleware items contain only a single"
" key-value pair. The key should be a name"
" for the middleware. The value should be"
" the full dotted name of the class"
" implementing the middleware.")
middleware_name = keys[0]
cls_name = item[middleware_name]
middleware_config = config.get(middleware_name, {})
cls = load_class_by_string(cls_name)
middleware = cls(middleware_name, middleware_config, worker)
middlewares.append(middleware)
return middlewares
def create_middlewares_from_config(worker, config):
"""Return a list of middleware objects created from a worker
configuration.
"""
middlewares = []
for item in config.get("middleware", []):
keys = item.keys()
if len(keys) != 1:
raise ConfigError("Middleware items contain only a single"
" key-value pair. The key should be a name"
" for the middleware. The value should be"
" the full dotted name of the class"
" implementing the middleware.")
middleware_name = keys[0]
cls_name = item[middleware_name]
middleware_config = config.get(middleware_name, {})
cls = load_class_by_string(cls_name)
middleware = cls(middleware_name, middleware_config, worker)
middlewares.append(middleware)
return middlewares
def startService(self):
log.msg("Starting VumiService")
host = self.options.pop('hostname')
port = self.options.pop('port')
# the worker creator starts workers, give it what class you
# want to start and what options you want to pass along
worker_class_name = self.options.pop("worker_class")
if not worker_class_name:
raise VumiError, "please specify --worker_class"
# load the config file if specified
config_file = self.options.pop('config')
if config_file:
with file(config_file, 'r') as stream:
self.options.update({
'config': yaml.load(stream)
})
worker_class = load_class_by_string(worker_class_name)
creator = WorkerCreator(worker_class, **self.options)
# after that you connect it to the AMQP server
creator.connectTCP(host, port)
def clean(self, value):
try:
cls = load_class_by_string(value)
except (ValueError, ImportError), e:
# ValueError for empty module name
self.raise_config_error(str(e))
def do_worker_help(self):
"""Print out a usage message for the worker-class and exit"""
worker_class = load_class_by_string(self.worker_class)
print worker_class.__doc__
self.exit()
def do_worker_help(self):
"""Print out a usage message for the worker-class and exit"""
worker_class = load_class_by_string(self.worker_class)
print worker_class.__doc__
self.exit()
def setup_router(self):
router_cls = load_class_by_string(self.config['router_class'])
self._router = router_cls(self, self.config)
return maybeDeferred(self._router.setup_routing)
def setup_router(self):
router_cls = load_class_by_string(self.config['router_class'])
self._router = router_cls(self, self.config)
return maybeDeferred(self._router.setup_routing)
def setup_router(self):
router_cls = load_class_by_string(self.config['router_class'])
self._router = router_cls(self, self.config)
def setup_router(self):
router_cls = load_class_by_string(self.config['router_class'])
self._router = router_cls(self, self.config)
def clean(self, value):
try:
cls = load_class_by_string(value)
except (ValueError, ImportError), e:
# ValueError for empty module name
self.raise_config_error(str(e))
