def __init__(self, timeout=300, **kwargs):
self.storage_url = project.setting('cache', 'storage_url')
try:
self.engine = StorageEngineMemcache(self.storage_url).get_engine()
except StorageEngineError:
raise
super(Memcache, self).__init__(timeout, **kwargs)
def __init__(self, application, request, status_code, message=None,
format_exc=[]):
super(ErrorPage, self).__init__(application, request)
self.set_status(status_code)
self.status_message = message
self.format_exc = format_exc
self.is_debug = project.setting('application', 'debug', True)
self._headers.update(utils.no_cache_headers())
def _get_log_path():
path = project.setting('profile', 'profile_log_path')
if not path:
prj_path = project.project_directory()
path = os.path.join(prj_path, 'data')
path = os.path.join(path, 'profile')
if not os.path.exists(path):
os.makedirs(path)
logging.debug('Profile store path: %s' % path)
return path
def profile(self):
if not hasattr(self, '_profile_cache'):
profile_module_string = project.setting('auth', 'profile_class', None)
if profile_module_string:
try:
module_name, sep, class_name = profile_module_string.rpartition('.')
except ValueError:
raise UserProfileNotAvailable("'%s' seems not valid."
" " % profile_module_string)
try:
__import__(module_name)
module = sys.modules[module_name]
cls = module.__dict__[class_name]
except ImportError, KeyError:
raise UserProfileNotAvailable("Cannot import %s. "
" " % profile_module_string)
else:
cls = UserProfileDatastore
self._profile_cache = cls.get_by_key_name("profileof%s" % self.username)
def profile(log_name=None):
n = log_name
is_debug = project.setting('application', 'debug', False)
def prof(func, *args, **kwargs):
if HOSTING_TYPE == 'google_appengine':
return func(*args, **kwargs)
if not n:
log_name = _make_profile_name(func)
else:
log_name = n
logfile = os.path.join(PROFILE_LOG_PATH, log_name)
(base, ext) = os.path.splitext(logfile)
if not ext:
ext = '.cprof'
base = "%s-%s" % (base, time.strftime("%Y%m%dT%H%M%S", time.gmtime()))
full_log_file = base + ext
_locals = locals()
cProfile.runctx("func(*args, **kwargs)", globals(), _locals,
full_log_file)
if is_debug:
pstats.Stats(full_log_file).strip_dirs().sort_stats('time').print_stats(20)
return
return decorator(prof)
__all__ = ['profile']
def _get_log_path():
path = project.setting('profile', 'profile_log_path')
if not path:
prj_path = project.project_directory()
path = os.path.join(prj_path, 'data')
path = os.path.join(path, 'profile')
if not os.path.exists(path):
os.makedirs(path)
logging.debug('Profile store path: %s' % path)
return path
HOSTING_TYPE = project.setting('application', 'serve_type')
if HOSTING_TYPE == 'wsgi':
logging.info("Application running on google appengine. Profile "
"function disabled")
PROFILE_LOG_PATH = None
else:
PROFILE_LOG_PATH = _get_log_path()
def _make_profile_name(func):
cls = None
if hasattr(func, 'im_func'):
cls = func.im_class
func = func.im_func
def __init__(self):
if not project.setting('extensions', 'whirly.extensions.session'):
raise Exception("Auth extension need session support. ")
super(NoDB, self).__init__('auth')
def set_password(self, raw_password):
algo = project.setting('auth', 'password_algorithm_type', 'sha1')
salt = get_hexdigest(algo, str(random.random()), str(random.random()))[:5]
hsh = get_hexdigest(algo, salt, raw_password)
self['password'] = u'%s$%s$%s' % (algo, salt, hsh)
import hashlib
from pymongo import GEO2D
from pymongo.objectid import ObjectId
from mongokit import Connection, Document
from whirly import project
from whirly.extensions.base import Extension
from whirly.extensions.authbase.userbase import SESSION_AUTH_KEY
from whirly.extensions.authbase.userbase import AbstractUserHelper
from whirly.extensions.authbase.userbase import local_user, get_hexdigest
from whirly.extensions.authbase.permissionbase import AbstractPermissionHelper
from whirly.extensions.authbase.groupbase import AbstractGroupHelper
conn = Connection()
_db_url = project.setting('database', 'database_url')
_auth_db = re.match('mongodb://([\S|\.]+?)?(?::(\d+))?/(\S+)', _db_url).group(3)
zidb = conn[_auth_db]
user_collection = zidb['whirly_auth_user']
group_collection = zidb['whirly_auth_group']
permission_collection = zidb['whirly_auth_permission']
__all__ = ['User', 'Group', 'Permission', 'Auth']
class Permission(Document):
structure = {
'name': unicode,
'description': unicode,
}
def __init__(self):
self.username = ''
self.is_active = project.setting('auth', 'enable_anonymous_user', True)
import sys
from whirly.extensions.authbase.userbase import UserProfile, AnonymousUser
from whirly.extensions.authbase.decorators import with_permission
from whirly.extensions.authbase.permissionbase import InUsers, IsSuperUser
from whirly.extensions.authbase.permissionbase import IsStaff, Authenticated
from whirly.extensions.authbase.permissionbase import InGroup, FromIP
from whirly.extensions.authbase.permissionbase import BetweenTimes, HasPermission
from whirly.extensions.authbase.permissionbase import All, Any
from whirly.extensions.authbase.permissionbase import PermissionChecker
from whirly import project
serve_type = project.setting("application", "serve_type", "tornado")
if serve_type == "wsgi":
from gaema.auth import OpenIdMixin
from gaema.auth import OAuthMixin
from gaema.auth import TwitterMixin
from gaema.auth import FriendFeedMixin
from gaema.auth import GoogleMixin
from gaema.auth import FacebookMixin
from gaema.webapp_auth import WebappAuth, RequestRedirect, HttpException
else:
from tornado.auth import OpenIdMixin
from tornado.auth import OAuthMixin
from tornado.auth import TwitterMixin
from tornado.auth import FriendFeedMixin
from tornado.auth import GoogleMixin
from tornado.auth import FacebookMixin
def __init__(self, timeout=None, with_query_args=False):
self.timeout = timeout or project.setting('cache', 'default_timeout', 300)
self.anonymous_only = project.setting('cache', 'anonymous_only', False)
self.with_query_args = with_query_args
# under the License.
import sys
import logging
import inspect
import functools
from whirly import project
from whirly import utils
__all__ = ['whirly_cache', 'WC', 'cache', 'nocache']
default_timeout = project.setting('cache', 'default_timeout', 300)
def _get_cache_class():
_cache_settings = project.extension_settings('cache')
_cache_module_string = _cache_settings['extension'][0]
_cls = _cache_settings['extension'][1]
__import__(_cache_module_string)
cache_module = sys.modules[_cache_module_string]
return cache_module.__dict__[_cls]
whirly_cache = WC = _get_cache_class()(default_timeout)()
