def make_plugin(**config):
if not config.has_key("secret") or not config["secret"]:
raise ValueError("'secret' must not be None.")
if config.has_key("timeout"):
config["timeout"] = int(config["timeout"])
if config.has_key("reissue_time"):
config["reissue_time"] = int(config["reissue_time"])
if config.has_key("timeout") and ( (not config.has_key("reissue_time")) or (config["reissue_time"] > config["timeout"]) ):
raise ValueError('When timeout is specified, reissue_time must '
'be set to a lower value')
return MidgardTokenAuth(config)
def custom_request_classifier(environ):
""" Returns one of the classifiers 'app', 'browser' or any
standard classifiers returned by
repoze.who.classifiers:default_request_classifier
"""
classifier = default_request_classifier(environ)
if classifier == 'browser':
login_form_url = '/login'
login_handler = '/login_handler'
logout_handler = '/logout_handler'
logout_url = '/logout'
# Decide if the client is a (user-driven) browser or an application
if config.has_key("who.config_file"):
config_file = config["who.config_file"]
config_who = ConfigParser.ConfigParser()
config_who.readfp(open(config_file))
login_form_url = config_who.get("plugin:friendlyform", "login_form_url")
login_handler = config_who.get("plugin:friendlyform", "login_handler_path")
logout_handler = config_who.get("plugin:friendlyform", "logout_handler_path")
logout_url = config_who.get("plugin:friendlyform", "post_logout_url")
path_info = environ['PATH_INFO']
#request = Request(environ)
#if not request.accept.best_match(['application/xhtml+xml', 'text/html']):
# # In our view, any client who doesn't support HTML/XHTML is an "app",
# # not a (user-driven) "browser".
# classifier = 'app'
if not path_info in [login_form_url, login_handler, logout_handler, logout_url]:
# In our view, any client who hasn't come in from the login url is an app
classifier = 'app'
return classifier
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
app = CacheMiddleware(app, config)
# Teambox debugging.
if config['debug']:
app = TeamboxDebugMiddleware(app)
# Production setup.
else:
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Handle special status codes.
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
# Change the url scheme when needed.
if config.has_key('url_scheme'):
app = UrlSchemeMiddleware(app, config['url_scheme'])
return app
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
app = CacheMiddleware(app, config)
# Teambox debugging.
if config['debug']: app = TeamboxDebugMiddleware(app)
# Production setup.
else: app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Handle special status codes.
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
# Change the url scheme when needed.
if config.has_key('url_scheme'):
app = UrlSchemeMiddleware(app, config['url_scheme'])
return app
def check_config() :
from pylons import config
class ConfigError(Exception) : pass
error_str = 'fbpylons requires that the following variables be set in your development.ini: %s. For details, see the Facebook API documentation.' % ( ', '.join(REQUIRED), )
if not all( [config.has_key(r) for r in REQUIRED] ) : raise ConfigError(error_str)
if not all( [config[r] for r in REQUIRED] ) : raise ConfigError(error_str)
extraneous = []
for k in config.keys() :
if k.startswith('facebook.') and k not in REQUIRED and k not in OPTIONAL : extraneous.append(k)
if len(extraneous) > 0 : raise ConfigError( extraneous )
def send_mail_toeach(datatuple, fail_silently=False,
auth_user=SMTP_USERNAME,
auth_password=SMTP_PASSWORD):
"""
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of e-mails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
"""
try:
smtp_server = config.has_key('smtp_server') and config['smtp_server'] or None
if smtp_server == None or smtp_server == '':
return
server = smtplib.SMTP(config['smtp_server'], 25)
if auth_user and auth_password:
server.login(auth_user, auth_password)
except:
if fail_silently:
return
raise
num_sent = 0
subject, message, from_email, recipient_list = datatuple
for to_email in recipient_list:
from_email = from_email or DEFAULT_FROM_EMAIL
msg = SafeMIMEText(message, 'plain', DEFAULT_CHARSET)
msg['Subject'] = subject
msg['From'] = from_email
msg['To'] = to_email
msg['Date'] = rfc822.formatdate()
try:
server.sendmail(from_email, recipient_list, msg.as_string())
num_sent += 1
except:
if not fail_silently:
raise
try:
server.quit()
except:
if fail_silently:
return
raise
return num_sent
def load_environment(global_conf, app_conf):
"""Configure the Pylons environment via the ``pylons.config``
object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
top = os.path.abspath(os.path.join(root, '../..'))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[
os.path.join(root, 'templates'),
os.path.join(top, 'templates/base')
])
# Initialize config with the basic options
config.init_app(global_conf, app_conf, package='kwmo', paths=paths)
config['routes.map'] = make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = kwmo.lib.helpers
# Create the Mako TemplateLookup, with the default auto-escaping
config['pylons.app_globals'].mako_lookup = TemplateLookup(
directories=paths['templates'],
module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
input_encoding='utf-8',
output_encoding='utf-8',
imports=['from webhelpers.html import escape'],
default_filters=['escape'])
# Get default master file path (if not defined in the paster configuration file).
if not config.has_key('master_file_path'):
config['master_file_path'] = RootConfigNode.master_file_path
else:
RootConfigNode.master_file_path = config['master_file_path']
# Cache master config.
cache_master_config(path=config['master_file_path'])
# Initialize models.
kcd_model.init_model() # dependency - load before main model
model.init_model()
def load_environment(global_conf, app_conf):
"""Configure the Pylons environment via the ``pylons.config``
object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
top = os.path.abspath(os.path.join(root, '../..'))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates'), os.path.join(top, 'templates/base')])
# Initialize config with the basic options
config.init_app(global_conf, app_conf, package='kwmo', paths=paths)
config['routes.map'] = make_map()
config['pylons.app_globals'] = app_globals.Globals()
config['pylons.h'] = kwmo.lib.helpers
# Create the Mako TemplateLookup, with the default auto-escaping
config['pylons.app_globals'].mako_lookup = TemplateLookup(
directories=paths['templates'],
module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
input_encoding='utf-8', output_encoding='utf-8',
imports=['from webhelpers.html import escape'],
default_filters=['escape'])
# Get default master file path (if not defined in the paster configuration file).
if not config.has_key('master_file_path'):
config['master_file_path'] = RootConfigNode.master_file_path
else:
RootConfigNode.master_file_path = config['master_file_path']
# Cache master config.
cache_master_config(path=config['master_file_path'])
# Initialize models.
kcd_model.init_model() # dependency - load before main model
model.init_model()
def custom_request_classifier(environ):
""" Returns one of the classifiers 'app', 'browser' or any
standard classifiers returned by
repoze.who.classifiers:default_request_classifier
"""
classifier = default_request_classifier(environ)
if classifier == 'browser':
login_form_url = '/login'
login_handler = '/login_handler'
logout_handler = '/logout_handler'
logout_url = '/logout'
# Decide if the client is a (user-driven) browser or an application
if config.has_key("who.config_file"):
config_file = config["who.config_file"]
config_who = ConfigParser.ConfigParser()
config_who.readfp(open(config_file))
login_form_url = config_who.get("plugin:friendlyform",
"login_form_url")
login_handler = config_who.get("plugin:friendlyform",
"login_handler_path")
logout_handler = config_who.get("plugin:friendlyform",
"logout_handler_path")
logout_url = config_who.get("plugin:friendlyform",
"post_logout_url")
path_info = environ['PATH_INFO']
#request = Request(environ)
#if not request.accept.best_match(['application/xhtml+xml', 'text/html']):
# # In our view, any client who doesn't support HTML/XHTML is an "app",
# # not a (user-driven) "browser".
# classifier = 'app'
if not path_info in [
login_form_url, login_handler, logout_handler, logout_url
]:
# In our view, any client who hasn't come in from the login url is an app
classifier = 'app'
return classifier
def __init__(self):
"""
DOI service provided by the British Library on behalf of Datacite.org
API Doc: https://api.datacite.org/
Metadata requirements: http://datacite.org/schema/DataCite-MetadataKernel_v2.0.pdf
"""
#Details pertaining to account with datacite
self.account = "xx.xxxx"
self.description = "Oxford University Library Service Databank"
self.contact = "Name of contact person"
self.email = "email_goes_here"
self.password = "******"
self.domain = "ox.ac.uk"
self.prefix = "10.5072" #test-prefix
self.quota = 500000
if config.has_key("doi.count"):
self.doi_count_file = config['doi.count']
#Datacite api endpoint
#self.endpoint_host = "api.datacite.org"
self.endpoint_host = "mds.datacite.org"
self.endpoint_path_doi = "/doi"
self.endpoint_path_metadata = "/metadata"
import os
import StringIO
import logging
log = logging.getLogger(__name__)
from pylons import config
config_path = config["here"] + '/config'
if config_path not in sys.path:
sys.path.insert(0, config_path)
from localconfig import LocalConfig as cfg
sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from pysvnmanager import hooks
# i18n works only as pysvnmanager (a pylons app) model.
if not config.has_key('unittest'):
from pylons.i18n import _
else:
def _(message): return message
#reload(sys) # in Python2.5, method sys.setdefaultencoding
#will be delete after initialize. we need reload it.
#sys.setdefaultencoding('utf-8')
class Repos:
def __init__(self, repos_root):
if not repos_root or not os.path.exists(repos_root):
raise Exception, _("Repos root does not exist: %s") % repos_root
self.__repos_root = os.path.abspath(repos_root)
def set_defaults(self):
for key in self.__dict__.keys():
if config.has_key(key):
setattr(self, key, config[key])
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = SessionMiddleware(app, config)
app = CacheMiddleware(app, config)
# CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
app = add_auth(app) # Add repoze.what Auth & Auth
app = add_thumbs(app) # Add iw.thumbs Thumbnail generation
if asbool(full_stack):
# Handle Python exceptions
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Display error documents for 401, 403, 404 status codes (and
# 500 when debug is disabled)
if asbool(config['debug']):
app = StatusCodeRedirect(app)
else:
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
if config.has_key('upload_dir'):
upload_app = StaticURLParser(config['upload_dir'])
app = Cascade([upload_app, app])
return app
def __init__(self):
"""One instance of Globals is created during application
initialization and is available during requests via the
'app_globals' variable
"""
self.authz = authz
#self.users = _USERS
self.NAMESPACES = NAMESPACES
self.PREFIXES = PREFIXES
if config.has_key("granary.uri_root"):
self.root = config['granary.uri_root']
if config.has_key("granary.store"):
self.granary = Granary(config['granary.store'])
if config.has_key("redis.host"):
self.redishost = config['redis.host']
try:
self.r = Redis(self.redishost)
except:
self.r = None
if self.r and config.has_key("broadcast.to") and config[
'broadcast.to'] == "redis" and config.has_key(
"broadcast.queue"):
self.b = BroadcastToRedis(config['redis.host'],
config['broadcast.queue'])
else:
self.r = None
self.redishost = None
self.b = None
if config.has_key("solr.host"):
from solr import SolrConnection
self.solrhost = config['solr.host']
try:
self.solr = SolrConnection(self.solrhost)
except:
self.solr = None
else:
self.solrhost = None
self.solr = None
if config.has_key("naming_rule"):
self.naming_rule = config['naming_rule']
if config.has_key("naming_rule_humanized"):
self.naming_rule_humanized = config['naming_rule_humanized']
elif config.has_key("naming_rule"):
self.naming_rule_humanized = config['naming_rule']
if config.has_key("metadata.embargoed"):
self.metadata_embargoed = config['metadata.embargoed']
if isinstance(self.metadata_embargoed, basestring):
if self.metadata_embargoed.lower().strip() == 'true':
self.metadata_embargoed = True
else:
self.metadata_embargoed = False
elif not type(self.metadata_embargoed).__name__ == 'bool':
self.metadata_embargoed = False
else:
self.metadata_embargoed = False
if config.has_key("auth.file"):
pwdfile = config['auth.file']
self.passwdfile = HtpasswdFile(pwdfile)
self.passwdfile.load()
if config.has_key("auth.info"):
self.userfile = config['auth.info']
if config.has_key("doi.count"):
self.doi_count_file = config['doi.count']
if config.has_key("formats_served"):
self.formats_served = config['formats_served']
else:
self.formats_served = [
"text/html", "text/xhtml", "text/plain", "application/json",
"application/rdf+xml", "text/xml"
]
if config.has_key("publisher"):
self.publisher = config['publisher']
else:
self.publisher = "Bodleian Libraries, University of Oxford"
if config.has_key("rights"):
self.rights = config['rights']
if config.has_key("license"):
self.license = config['license']
if config.has_key("api.version"):
self.api_version = config['api.version']
try:
sync_members(self.granary)
except:
pass
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Undefer POST parsing by undoing DeferPOSTParsing middleware work.
app = kwmo.lib.middlewares.UnDeferPOSTParsing(app)
# KWMO session middleware
app = KwmoSessionMiddleware(app, config)
# KWMO middleware - wrap kwmo application.
app = kwmo.lib.middlewares.KWMOMiddleware(app)
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = CacheMiddleware(app, config)
# Catch KJsonifyException exceptions and send a json exception in the body.
app = kwmo.lib.middlewares.JSONErrorMiddleware(app)
# Teambox debugging.
if config['debug']:
app = kwmo.lib.middlewares.TeamboxDebugMiddleware(app)
# Production setup.
else:
app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Handle special status codes.
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
app = kwmo.lib.middlewares.ContentLengthMiddleware(app)
# Defer POST parsing by hiding the real input body file object and providing an empty StringIO() instead.
app = kwmo.lib.middlewares.DeferPOSTParsing(app)
# Change the url scheme when needed.
if config.has_key('url_scheme'):
app = kwmo.lib.middlewares.UrlSchemeMiddleware(app,
config['url_scheme'])
return app
def __init__(self,config):
"""One instance of Globals is created during application
initialization and is available during requests via the
'app_globals' variable
"""
##self.authz = authz
#self.users = _USERS
self.NAMESPACES = NAMESPACES
self.PREFIXES = PREFIXES
self.cache = ""
self.api_version = ""
if config.has_key("granary.uri_root"):
self.root = config['granary.uri_root']
if config.has_key("granary.host"):
self.host = config['granary.host']
if config.has_key("granary.store"):
self.granary = Granary(config['granary.store'])
if config.has_key("redis.host"):
self.redishost = config['redis.host']
try:
self.r = Redis(self.redishost)
except:
self.r = None
if self.r and config.has_key("broadcast.to") and config['broadcast.to'] == "redis" and config.has_key("broadcast.queue"):
self.b = BroadcastToRedis(config['redis.host'], config['broadcast.queue'])
else:
self.r = None
self.redishost = None
self.b = None
if config.has_key("solr.host"):
from solr import SolrConnection
self.solrhost = config['solr.host']
try:
self.solr = SolrConnection(self.solrhost)
except:
self.solr = None
else:
self.solrhost = None
self.solr = None
if config.has_key("naming_rule"):
self.naming_rule = config['naming_rule']
if config.has_key("naming_rule_humanized"):
self.naming_rule_humanized = config['naming_rule_humanized']
elif config.has_key("naming_rule"):
self.naming_rule_humanized = config['naming_rule']
if config.has_key("metadata.embargoed"):
self.metadata_embargoed = config['metadata.embargoed']
if isinstance(self.metadata_embargoed, basestring):
if self.metadata_embargoed.lower().strip() == 'true':
self.metadata_embargoed = True
else:
self.metadata_embargoed = False
elif not type(self.metadata_embargoed).__name__ == 'bool':
self.metadata_embargoed = False
else:
self.metadata_embargoed = False
if config.has_key("auth.file"):
pwdfile = config['auth.file']
self.passwdfile = HtpasswdFile(pwdfile)
self.passwdfile.load()
if config.has_key("auth.info"):
self.userfile = config['auth.info']
if config.has_key("doi.count"):
self.doi_count_file = config['doi.count']
if config.has_key("formats_served"):
self.formats_served = config['formats_served']
else:
self.formats_served = ["text/html", "text/xhtml", "text/plain", "application/json", "application/rdf+xml", "text/xml"]
if config.has_key("publisher"):
self.publisher = config['publisher']
else:
self.publisher = "Bodleian Libraries, University of Oxford"
if config.has_key("rights"):
self.rights = config['rights']
if config.has_key("license"):
self.license = config['license']
if config.has_key("api.version"):
self.api_version = config['api.version']
def make_app(global_conf, full_stack=True, static_files=True, **app_conf):
"""Create a Pylons WSGI application and return it
``global_conf``
The inherited configuration for this application. Normally from
the [DEFAULT] section of the Paste ini file.
``full_stack``
Whether this application provides a full WSGI stack (by default,
meaning it handles its own exceptions and errors). Disable
full_stack when this application is "managed" by another WSGI
middleware.
``static_files``
Whether this application serves its own static files; disable
when another web server is responsible for serving them.
``app_conf``
The application's local configuration. Normally specified in
the [app:<name>] section of the Paste ini file (where <name>
defaults to main).
"""
# Configure the Pylons environment
load_environment(global_conf, app_conf)
# The Pylons WSGI app
app = PylonsApp()
# Undefer POST parsing by undoing DeferPOSTParsing middleware work.
app = kwmo.lib.middlewares.UnDeferPOSTParsing(app)
# KWMO session middleware
app = KwmoSessionMiddleware(app, config)
# KWMO middleware - wrap kwmo application.
app = kwmo.lib.middlewares.KWMOMiddleware(app)
# Routing/Session/Cache Middleware
app = RoutesMiddleware(app, config['routes.map'])
app = CacheMiddleware(app, config)
# Catch KJsonifyException exceptions and send a json exception in the body.
app = kwmo.lib.middlewares.JSONErrorMiddleware(app)
# Teambox debugging.
if config['debug']: app = kwmo.lib.middlewares.TeamboxDebugMiddleware(app)
# Production setup.
else: app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
# Handle special status codes.
app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
# Establish the Registry for this application
app = RegistryManager(app)
if asbool(static_files):
# Serve static files
static_app = StaticURLParser(config['pylons.paths']['static_files'])
app = Cascade([static_app, app])
app = kwmo.lib.middlewares.ContentLengthMiddleware(app)
# Defer POST parsing by hiding the real input body file object and providing an empty StringIO() instead.
app = kwmo.lib.middlewares.DeferPOSTParsing(app)
# Change the url scheme when needed.
if config.has_key('url_scheme'):
app = kwmo.lib.middlewares.UrlSchemeMiddleware(app, config['url_scheme'])
return app
def parseconfig(config, global_conf, app_conf):
"""Configure the Pylons environment via the ``pylons.config`` object"""
global tmplmoddir
config.init_app(global_conf, app_conf, package='zeta', paths=paths)
if config.has_key('zetaversion'):
return
# pylons configuration
config['routes.map'] = make_map(config)
config['pylons.app_globals'] = app_globals.Globals(config)
config['pylons.h'] = h
config['zeta.pkg_path'] = pkg_path
config['zeta.envpath'] = envpath
config['zeta.pageheader'] = config['zeta.pageheader'] == 'True'
# config['pylons.strict_tmpl_context'] = False
# Parse fields that will be persisted in system table.
config['zeta.siteadmin'] = unicode(config['zeta.siteadmin'])
config['pylons.package'] = unicode(config['pylons.package'])
config['zeta.timezone'] = unicode(config['zeta.timezone'])
config['zeta.unicode_encoding'] = unicode(config['zeta.unicode_encoding'])
config['zeta.sitename'] = unicode(config['zeta.sitename'])
config['zeta.envpath'] = unicode(config['zeta.envpath'])
config['zeta.welcomestring'] = unicode(config['zeta.welcomestring'])
config['zeta.userrel_types'] = map(
lambda x: unicode(x), h.parse_csv(config['zeta.userrel_types']))
config['zeta.projteamtypes'] = map(
lambda x: unicode(x), h.parse_csv(config['zeta.projteamtypes']))
config['zeta.ticketstatus'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.ticketstatus']))
config['zeta.tickettypes'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.tickettypes']))
config['zeta.ticketseverity'] = map(
lambda x: unicode(x), h.parse_csv(config['zeta.ticketseverity']))
config['zeta.reviewnatures'] = map(
lambda x: unicode(x), h.parse_csv(config['zeta.reviewnatures']))
config['zeta.reviewactions'] = map(
lambda x: unicode(x), h.parse_csv(config['zeta.reviewactions']))
config['zeta.wikitypes'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.wikitypes']))
config['zeta.vcstypes'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.vcstypes']))
config['zeta.ticketresolv'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.ticketresolv']))
config['zeta.specialtags'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.specialtags']))
config['zeta.def_wikitype'] = unicode(config['zeta.def_wikitype'])
config['zeta.userpanes'] = map(lambda x: unicode(x),
h.parse_csv(config['zeta.userpanes']))
# Fields for run-time.
config['dbversion'] = dbversion
config['zetaversion'] = zetaversion
if not config['zeta.mstnccodes']:
config['zeta.mstnccodes'] = join(envpath, 'public', 'mstnccodes.json')
if not config['zeta.tckccodes']:
config['zeta.tckccodes'] = join(envpath, 'public', 'tckccodes.json')
if not config.get('zeta.tckfilters', None):
config['zeta.tckfilters'] = join(envpath, 'public', 'tckfilters.pyd')
# Create the Mako TemplateLookup, with the default auto-escaping
tmplmoddir = join(app_conf['cache_dir'], 'templates')
config['pylons.app_globals'].mako_lookup = \
TemplateLookup(
directories=paths['templates'],
error_handler=handle_mako_error,
module_directory=tmplmoddir,
input_encoding='utf-8',
output_encoding=config['zeta.unicode_encoding'],
#filesystem_checks=config['mako.filesystem_checks']
imports=['from webhelpers.html import escape'],
default_filters=['escape']
)
# Setup cache object.
#from zeta.lib.upgradeenv import cleardata
#cleardata( envpath )
config['cachemgr'] = cachemanager(envpath)
return config
2. Edit config file to point to a new test database and tell it about a dump
of the database to test migration from.
sqlalchemy.url = postgres://tester:pass@localhost/ckantestmigrate
test_migration_db_dump = ~/db_backup/ckan.net/ckan.net.2010-01-13.pg_dump
To run a test:
$ nosetests ckan/migration/tests/test_15.py --with-pylons=testmigrate.ini
'''
import os
import sys
import subprocess
from pylons import config
assert config.has_key('here'), 'ERROR: You need to run nosetests with option: --with-pylons=testmigrate.ini'
CONFIG_FILE = 'testmigrate.ini'
DB_NAME = 'ckantestmigrate'
DB_USER = '******'
TEST_DUMPS_PATH = os.path.join(config['here'], 'ckan/migration/tests/test_dumps')
RESTORE_FILEPATH = config['test_migration_db_dump']
class TestMigrationBase(object):
psqlbase = 'export PGPASSWORD=pass && psql -q -h localhost --user %s %s' % (DB_USER, DB_NAME)
@classmethod
def setup_db(cls, pg_dump_file=None):
if not pg_dump_file:
pg_dump_file = RESTORE_FILEPATH
assert pg_dump_file
