def __init__(self):
self._loadConfiguration()
self.sender_plugin_name = config.get('sms.sender.plugin', None)
self.receiver_plugin_name = config.get('sms.receiver.plugin', None)
self._plugin = None
self._preparePlugin()
def __init__(self):
super(QueueStorage, self).__init__()
self.config = config.get('sms.queue.storage.handler_config', {})
self._plugin_name = config.get('sms.queue.storage.plugin', None)
self._plugin = None
self._preparePlugin()
def __init__(self, parent, override_config=None):
super(CherryPyWebExt, self).__init__()
log.debug("CherryPyWebExt::__init__")
self.parent = parent
self.dispatcher = None
self._loadConfiguration()
if override_config:
config['cherrypy'].update(override_config.copy())
cherrypy.config.update(config.get('cherrypy.global', {}))
if not cherrypy.tools.staticdir.root:
cherrypy.config.update({
'tools.staticdir.root': self.parent.base_path
})
route_mounts = config.get('cherrypy.mounts')
self._route_config = {}
for base_path, routes in self.parent.routes.iteritems():
if not self._route_config.has_key(base_path):
self._route_config[base_path] = {}
self._route_config[base_path].update({
'request.dispatch': self._setup_routes(routes)
})
for point, conf in route_mounts.iteritems():
if not self._route_config.has_key(point):
self._route_config[point] = {}
self._route_config[point].update(conf)
multilang_config = config.get('cherrypy.multilang')
localedir = os.path.join(self.parent.base_path, 'i18n')
if multilang_config.get('enabled'):
for key, conf in multilang_config.get('map').iteritems():
cherrypy.tree.apps['/'+key] = InGoMultilangApp(conf.get('lang'), localedir, conf.get('path'), self._route_config)
if multilang_config.get('default') == key:
cherrypy.tree.apps[''] = InGoMultilangApp(conf.get('lang'), localedir, config.get('cherrypy.root_path'), self._route_config)
else:
cherrypy.tree.apps[''] = InGoMultilangApp(multilang_config.get('default'), localedir, config.get('cherrypy.root_path'), self._route_config)
#cherrypy.tree.mount(None, script_name=self.config.get('root_path'), config=self._route_config)
self._env = {
'app': cherrypy.request.app,
'ingo_app': self.parent,
'basedir': self.parent.base_path
}
def _setup_routes(self, routes):
self.dispatcher = cherrypy.dispatch.RoutesDispatcher()
self.dispatcher.mapper.minimization = config.get('route_mapper_minimization', True)
self.dispatcher.mapper.explicit = config.get('route_mapper_explicit', False)
self._set_error_controller()
controllers = {}
for route in routes:
module = None
controller_name = None
if route.has_key('controller'):
controller_name = route.get('controller')
if controller_name and controller_name.count("."):
module = ".".join(controller_name.split(".")[:-1])
try:
exec "import %s" % module
except ImportError, e:
log.error("Failed to import route module %s. Ignored!" % module)
continue
is_resource = False
if route.has_key('collection_name'):
is_resource = True
kwargs = {}
if controller_name:
if not controllers.has_key(controller_name):
controllers[controller_name] = eval(controller_name)()
if is_resource:
self.dispatcher.controllers[route.get('collection_name', None)] = controllers[controller_name]
else:
kwargs['controller'] = controllers[controller_name]
kw_keys = ['action', 'conditions', 'requirements']
if is_resource:
kw_keys += ['collection', 'member', 'new', 'path_prefix', 'name_prefix', 'parent_resource']
for kwk in kw_keys:
if route.has_key(kwk):
kwargs[kwk] = route.get(kwk)
if is_resource:
self.dispatcher.mapper.resource(route.get('name', None), route.get('collection_name', ''), **kwargs)
else:
self.dispatcher.connect(route.get('name', None), route.get('url', ''), **kwargs)
def _preparePlugins(self):
"""docstring for _preparePlugins"""
load_all = config.get('plugins.load_all', False)
if load_all:
ingo.plugin.loader.loadAll()
if not load_all and not config.get('plugins.enabled', None):
return
for name, activate in config.get('plugins.enabled').iteritems():
ingo.plugin.loader.load(name)
if activate:
ingo.plugin.loader.activate(name)
def _loadConfiguration(self):
self._config_loader = Configuration(implementation="yml")
self._config_loader.loadExtension("sms", getDefaultConfigPath())
try:
self._config_loader.load("sms", config.get('project.paths.config'))
except ConfigurationNotFound, e:
log.error(e)
def __init__(self, **kwargs):
super(Message, self).__init__()
self._properties = {
'sender': Contact(None, None),
'receiver': Contact(None, None),
'content': ''
}
self._bindProperties(**kwargs)
self.storage_plugin_name = config.get('sms.message.storage.plugin', None)
self._storage_plugin = None
self._preparePlugins()
def _set_error_controller(self):
from ingo.web.controllers import ErrorController
error_controller = ErrorController()
if config.has_key('web.error_controller'):
error_controller_name = config.get('web.error_controller')
if error_controller_name.count("."):
module = ".".join(error_controller_name.split(".")[:-1])
try:
exec "import %s" % module
except ImportError, e:
log.error("Failed to import error module %s. Ignored!" % module)
error_controller = eval(error_controller_name)()
def __init__(self, lang, localedir, script_name="", app_config=None):
self.lang = lang
self.locale_dir = localedir
self.domain = 'default'
self.domains = []
self.translations = {}
self.default_dict = dict(
app = self
)
self.registerTranslationDomain(self.domain, languages=[lang])
if config.get('web.templating.enabled', False):
self._prepareTemplating()
cherrypy.Application.__init__(self, None, script_name, app_config)
def __init__(self):
super(Project, self).__init__()
self._available_extensions = web_findExtensions()
if len(self._available_extensions) == 0:
raise NoExtensionsAvailable()
self.web_config = config.get('web', {})
self._ext_name = self.web_config.get('preferred_extension', 'cherry')
if self.web_config.has_key('use_extension'):
self._ext_name = self.web_config.get('use_extension')
if not self._ext_name in self._available_extensions:
raise NoExtensionsAvailable("Selected extension %s not available" % self._ext_name)
self._loadExtension(self._ext_name)
self.initialize()
def get_instance(app):
global _instance
if not _instance: _instance = Engine(app, config.get('web.templating.genshi_config', {}))
return _instance
def _prepareQueue(self):
self.queue = createQueue(config.get('sms.queue.handler', 'LocalQueue'))
def __init__(self):
super(MessageQueue, self).__init__()
self._storage = createStorage(config.get('sms.queue.storage.handler', None))
kwargs['controller'] = controllers[controller_name]
kw_keys = ['action', 'conditions', 'requirements']
if is_resource:
kw_keys += ['collection', 'member', 'new', 'path_prefix', 'name_prefix', 'parent_resource']
for kwk in kw_keys:
if route.has_key(kwk):
kwargs[kwk] = route.get(kwk)
if is_resource:
self.dispatcher.mapper.resource(route.get('name', None), route.get('collection_name', ''), **kwargs)
else:
self.dispatcher.connect(route.get('name', None), route.get('url', ''), **kwargs)
if config.get('append_default_routes', True):
self.dispatcher.mapper.connect('_default', '/:controller/:action')
self.dispatcher.mapper.connect('_default_with_id', '/:controller/:action/:id')
self._log_routing_table()
return self.dispatcher
def _set_error_controller(self):
from ingo.web.controllers import ErrorController
error_controller = ErrorController()
if config.has_key('web.error_controller'):
error_controller_name = config.get('web.error_controller')
def _prepareLoggers(self):
ingo.log.loadFromConfig(config.get("logging"))
self.log = ingo.log.getLogger('ingo')
def initialize(self):
log.debug("LabyrinttiSMSGateway :: initialize")
print self.config
self.sender = LabyrinttiSender(config=config.get('sms.sender.plugin_config', {}))
self.receiver = LabyrinttiReceiver(config=config.get('sms.receiver.plugin_config', {}))
