Sorry, you are not authorized to perform this action
' # # Web application main # # app.secret_key = os.urandom(24) #FIXME: why def main(): # Start the Bottle webapp #bottle.debug(True) app.secret_key = os.urandom(24) app.run(debug=True, use_reloader=True) if __name__ == "__main__": main() bottle-cork-0.12.0/tests/test_webtest_parallel.py 0000644 0001750 0001750 00000020041 12314374426 021756 0 ustar fede fede 0000000 0000000 # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under LGPLv3+ license, see LICENSE.txt # # Functional test using Json backend # # Requires WebTest http://webtest.pythonpaste.org/ # # Run as: nosetests functional_test.py # from nose import SkipTest from time import time from datetime import datetime from webtest import TestApp import glob import json import os import shutil import testutils from cork import Cork REDIR = 302 class Test(testutils.WebFunctional): def __init__(self): self._tmpdir = None self._tmproot = None self._app = None self._starting_dir = os.getcwd() def populate_conf_directory(self): """Populate a directory with valid configuration files, to be run just once The files are not modified by each test """ self._tmpdir = os.path.join(self._tmproot, "cork_functional_test_source") # only do this once, as advertised if os.path.exists(self._tmpdir): return os.mkdir(self._tmpdir) os.mkdir(self._tmpdir + "/example_conf") cork = Cork(os.path.join(self._tmpdir, "example_conf"), initialize=True) cork._store.roles['admin'] = 100 cork._store.roles['editor'] = 60 cork._store.roles['user'] = 50 cork._store.save_roles() tstamp = str(datetime.utcnow()) username = password = 'admin' cork._store.users[username] = { 'role': 'admin', 'hash': cork._hash(username, password), 'email_addr': username + '@localhost.local', 'desc': username + ' test user', 'creation_date': tstamp } username = password = '' cork._store.users[username] = { 'role': 'user', 'hash': cork._hash(username, password), 'email_addr': username + '@localhost.local', 'desc': username + ' test user', 'creation_date': tstamp } cork._store.save_users() def remove_temp_dir(self): p = os.path.join(self._tmproot, 'cork_functional_test_wd') for f in glob.glob('%s*' % p): #shutil.rmtree(f) pass @classmethod def setUpClass(cls): print("Setup class") def setup(self): # create test dir and populate it using the example files # save the directory where the unit testing has been run if self._starting_dir is None: self._starting_dir = os.getcwd() # create json files to be used by Cork self._tmproot = testutils.pick_temp_directory() assert self._tmproot is not None # purge the temporary test directory self.remove_temp_dir() self.populate_temp_dir() self.create_app_instance() self._app.reset() print("Reset done") print("Setup completed") def populate_temp_dir(self): """populate the temporary test dir""" assert self._tmproot is not None assert self._tmpdir is None tstamp = str(time())[5:] self._tmpdir = os.path.join(self._tmproot, "cork_functional_test_wd_%s" % tstamp) try: os.mkdir(self._tmpdir) except OSError: # The directory is already there, purge it print("Deleting %s" % self._tmpdir) shutil.rmtree(self._tmpdir) os.mkdir(self._tmpdir) #p = os.path.join(self._tmproot, 'cork_functional_test_wd') #for f in glob.glob('%s*' % p): # shutil.rmtree(f) # copy the needed files shutil.copytree( os.path.join(self._starting_dir, 'tests/example_conf'), os.path.join(self._tmpdir, 'example_conf') ) shutil.copytree( os.path.join(self._starting_dir, 'tests/views'), os.path.join(self._tmpdir, 'views') ) # change to the temporary test directory # cork relies on this being the current directory os.chdir(self._tmpdir) print("Test directory set up") def create_app_instance(self): """create TestApp instance""" assert self._app is None import simple_webapp self._bottle_app = simple_webapp.app self._app = TestApp(self._bottle_app) print("Test App created") def teardown(self): print("Doing teardown") try: self._app.post('/logout') except: pass # drop the cookie self._app.reset() assert 'beaker.session.id' not in self._app.cookies, "Unexpected cookie found" # drop the cookie self._app.reset() #assert self._app.get('/admin').status != '200 OK' os.chdir(self._starting_dir) #if self._tmproot is not None: # testutils.purge_temp_directory(self._tmproot) self._app.app.options['timeout'] = self._default_timeout self._app = None self._tmproot = None self._tmpdir = None print("Teardown done") def setup(self): # create test dir and populate it using the example files # save the directory where the unit testing has been run if self._starting_dir is None: self._starting_dir = os.getcwd() # create json files to be used by Cork self._tmproot = testutils.pick_temp_directory() assert self._tmproot is not None # purge the temporary test directory self.remove_temp_dir() self.populate_temp_dir() self.create_app_instance() self._app.reset() print("Reset done") self._default_timeout = self._app.app.options['timeout'] print("Setup completed") def assert_200(self, path, match): """Assert that a page returns 200""" p = self._app.get(path) assert p.status_int == 200, "Status: %d, Location: %s" % \ (p.status_int, p.location) if match is not None: assert match in p.body, "'%s' not found in body: '%s'" % (match, p.body) return p def assert_redirect(self, page, redir_page, post=None): """Assert that a page redirects to another one""" # perform GET or POST if post is None: p = self._app.get(page, status=302) else: assert isinstance(post, dict) p = self._app.post(page, post, status=302) dest = p.location.split(':80/')[-1] dest = "/%s" % dest assert dest == redir_page, "%s redirects to %s instead of %s" % \ (page, dest, redir_page) return p def login_as_admin(self): """perform log in""" assert self._app is not None assert 'beaker.session.id' not in self._app.cookies, "Unexpected cookie found" self.assert_200('/login', 'Please insert your credentials') assert 'beaker.session.id' not in self._app.cookies, "Unexpected cookie found" self.assert_redirect('/admin', '/sorry_page') self.assert_200('/user_is_anonymous', 'True') assert 'beaker.session.id' not in self._app.cookies, "Unexpected cookie found" post = {'username': 'admin', 'password': 'admin'} self.assert_redirect('/login', '/', post=post) assert 'beaker.session.id' in self._app.cookies, "Cookie not found" import bottle session = bottle.request.environ.get('beaker.session') print("Session from func. test", repr(session)) self.assert_200('/login', 'Please insert your credentials') p = self._app.get('/admin') assert 'Welcome' in p.body, repr(p) p = self._app.get('/my_role', status=200) assert p.status == '200 OK' assert p.body == 'admin', "Sta" print("Login performed") def test_functional_expiration(self): self.login_as_admin() r = self._app.get('/admin') assert r.status == '200 OK', repr(r) # change the cookie expiration in order to expire it self._app.app.options['timeout'] = 0 assert self._app.get('/admin').status_int == REDIR, "The cookie should have expired" bottle-cork-0.12.0/tests/multiparam.py 0000644 0001750 0001750 00000000645 12453054133 017543 0 ustar fede fede 0000000 0000000 # content of conftest.py import pytest class A(object): pass @pytest.fixture def base(): print 'INST A' return A() @pytest.fixture(params=["merlinux.eu", "mail.python.org"]) def smtp(request, base): print request.param return base @pytest.fixture(params=['user', 'admin', None]) def auth_status(request, base): return base def test_nyan(smtp, auth_status): assert smtp == auth_status bottle-cork-0.12.0/cork/ 0000755 0001750 0001750 00000000000 12617467123 014616 5 ustar fede fede 0000000 0000000 bottle-cork-0.12.0/cork/base_backend.py 0000644 0001750 0001750 00000001360 12512453671 017546 0 ustar fede fede 0000000 0000000 # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under LGPLv3+ license, see LICENSE.txt """ .. module:: backend.py :synopsis: Base Backend. """ class BackendIOException(Exception): """Generic Backend I/O Exception""" pass def ni(*args, **kwargs): raise NotImplementedError class Backend(object): """Base Backend class - to be subclassed by real backends.""" save_users = ni save_roles = ni save_pending_registrations = ni class Table(object): """Base Table class - to be subclassed by real backends.""" __len__ = ni __contains__ = ni __setitem__ = ni __getitem__ = ni __iter__ = ni iteritems = ni bottle-cork-0.12.0/cork/mongodb_backend.py 0000644 0001750 0001750 00000012440 12520166131 020251 0 ustar fede fede 0000000 0000000 # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under LGPLv3+ license, see LICENSE.txt """ .. module:: mongodb_backend :synopsis: MongoDB storage backend. """ from logging import getLogger log = getLogger(__name__) from .base_backend import Backend, Table try: import pymongo is_pymongo_2 = (pymongo.version_tuple[0] == 2) except ImportError: # pragma: no cover pass class MongoTable(Table): """Abstract MongoDB Table. Allow dictionary-like access. """ def __init__(self, name, key_name, collection): self._name = name self._key_name = key_name self._coll = collection def create_index(self): """Create collection index.""" self._coll.create_index( self._key_name, drop_dups=True, unique=True, ) def __len__(self): return self._coll.count() def __contains__(self, value): r = self._coll.find_one({self._key_name: value}) return r is not None def __iter__(self): """Iter on dictionary keys""" if is_pymongo_2: r = self._coll.find(fields=[self._key_name,]) else: r = self._coll.find(projection=[self._key_name,]) return (i[self._key_name] for i in r) def iteritems(self): """Iter on dictionary items. :returns: generator of (key, value) tuples """ r = self._coll.find() for i in r: d = i.copy() d.pop(self._key_name) d.pop('_id') yield (i[self._key_name], d) def pop(self, key_val): """Remove a dictionary item""" r = self[key_val] self._coll.remove({self._key_name: key_val}, w=1) return r class MongoSingleValueTable(MongoTable): """MongoDB table accessible as a simple key -> value dictionary. Used to store roles. """ # Values are stored in a MongoDB "column" named "val" def __init__(self, *args, **kw): super(MongoSingleValueTable, self).__init__(*args, **kw) def __setitem__(self, key_val, data): assert not isinstance(data, dict) spec = {self._key_name: key_val} data = {self._key_name: key_val, 'val': data} if is_pymongo_2: self._coll.update(spec, {'$set': data}, upsert=True, w=1) else: self._coll.update_one(spec, {'$set': data}, upsert=True) def __getitem__(self, key_val): r = self._coll.find_one({self._key_name: key_val}) if r is None: raise KeyError(key_val) return r['val'] class MongoMutableDict(dict): """Represent an item from a Table. Acts as a dictionary. """ def __init__(self, parent, root_key, d): """Create a MongoMutableDict instance. :param parent: Table instance :type parent: :class:`MongoTable` """ super(MongoMutableDict, self).__init__(d) self._parent = parent self._root_key = root_key def __setitem__(self, k, v): super(MongoMutableDict, self).__setitem__(k, v) spec = {self._parent._key_name: self._root_key} if is_pymongo_2: r = self._parent._coll.update(spec, {'$set': {k: v}}, upsert=True) else: r = self._parent._coll.update_one(spec, {'$set': {k: v}}, upsert=True) class MongoMultiValueTable(MongoTable): """MongoDB table accessible as a dictionary. """ def __init__(self, *args, **kw): super(MongoMultiValueTable, self).__init__(*args, **kw) def __setitem__(self, key_val, data): assert isinstance(data, dict) key_name = self._key_name if key_name in data: assert data[key_name] == key_val else: data[key_name] = key_val spec = {key_name: key_val} if u'_id' in data: del(data[u'_id']) if is_pymongo_2: self._coll.update(spec, {'$set': data}, upsert=True, w=1) else: self._coll.update_one(spec, {'$set': data}, upsert=True) def __getitem__(self, key_val): r = self._coll.find_one({self._key_name: key_val}) if r is None: raise KeyError(key_val) return MongoMutableDict(self, key_val, r) class MongoDBBackend(Backend): def __init__(self, db_name='cork', hostname='localhost', port=27017, initialize=False, username=None, password=None): """Initialize MongoDB Backend""" connection = pymongo.MongoClient(host=hostname, port=port) db = connection[db_name] if username and password: db.authenticate(username, password) self.users = MongoMultiValueTable('users', 'login', db.users) self.pending_registrations = MongoMultiValueTable( 'pending_registrations', 'pending_registration', db.pending_registrations ) self.roles = MongoSingleValueTable('roles', 'role', db.roles) if initialize: self._initialize_storage() def _initialize_storage(self): """Create MongoDB indexes.""" for c in (self.users, self.roles, self.pending_registrations): c.create_index() def save_users(self): pass def save_roles(self): pass def save_pending_registrations(self): pass bottle-cork-0.12.0/cork/json_backend.py 0000644 0001750 0001750 00000010536 12517131104 017577 0 ustar fede fede 0000000 0000000 # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under LGPLv3+ license, see LICENSE.txt """ .. module:: json_backend :synopsis: JSON file-based storage backend. """ from logging import getLogger import os import shutil import sys try: import json except ImportError: # pragma: no cover import simplejson as json from .base_backend import BackendIOException is_py3 = (sys.version_info.major == 3) log = getLogger(__name__) try: dict.iteritems py23dict = dict except AttributeError: class py23dict(dict): iteritems = dict.items class BytesEncoder(json.JSONEncoder): def default(self, obj): if is_py3 and isinstance(obj, bytes): return obj.decode() return json.JSONEncoder.default(self, obj) class JsonBackend(object): """JSON file-based storage backend.""" def __init__(self, directory, users_fname='users', roles_fname='roles', pending_reg_fname='register', initialize=False): """Data storage class. Handles JSON files :param users_fname: users file name (without .json) :type users_fname: str. :param roles_fname: roles file name (without .json) :type roles_fname: str. :param pending_reg_fname: pending registrations file name (without .json) :type pending_reg_fname: str. :param initialize: create empty JSON files (defaults to False) :type initialize: bool. """ assert directory, "Directory name must be valid" self._directory = directory self.users = py23dict() self._users_fname = users_fname self.roles = py23dict() self._roles_fname = roles_fname self._mtimes = py23dict() self._pending_reg_fname = pending_reg_fname self.pending_registrations = py23dict() if initialize: self._initialize_storage() self._refresh() # load users and roles def _initialize_storage(self): """Create empty JSON files""" self._savejson(self._users_fname, {}) self._savejson(self._roles_fname, {}) self._savejson(self._pending_reg_fname, {}) def _refresh(self): """Load users and roles from JSON files, if needed""" self._loadjson(self._users_fname, self.users) self._loadjson(self._roles_fname, self.roles) self._loadjson(self._pending_reg_fname, self.pending_registrations) def _loadjson(self, fname, dest): """Load JSON file located under self._directory, if needed :param fname: short file name (without path and .json) :type fname: str. :param dest: destination :type dest: dict """ try: fname = "%s/%s.json" % (self._directory, fname) mtime = os.stat(fname).st_mtime if self._mtimes.get(fname, 0) == mtime: # no need to reload the file: the mtime has not been changed return with open(fname) as f: json_data = f.read() except Exception as e: raise BackendIOException("Unable to read json file %s: %s" % (fname, e)) try: json_obj = json.loads(json_data) dest.clear() dest.update(json_obj) self._mtimes[fname] = os.stat(fname).st_mtime except Exception as e: raise BackendIOException("Unable to parse JSON data from %s: %s" \ % (fname, e)) def _savejson(self, fname, obj): """Save obj in JSON format in a file in self._directory""" fname = "%s/%s.json" % (self._directory, fname) try: with open("%s.tmp" % fname, 'w') as f: json.dump(obj, f, cls=BytesEncoder) f.flush() shutil.move("%s.tmp" % fname, fname) except Exception as e: raise BackendIOException("Unable to save JSON file %s: %s" \ % (fname, e)) def save_users(self): """Save users in a JSON file""" self._savejson(self._users_fname, self.users) def save_roles(self): """Save roles in a JSON file""" self._savejson(self._roles_fname, self.roles) def save_pending_registrations(self): """Save pending registrations in a JSON file""" self._savejson(self._pending_reg_fname, self.pending_registrations) bottle-cork-0.12.0/cork/cork.py 0000644 0001750 0001750 00000101626 12617465100 016125 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # # This package is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 3 of the License, or (at your option) any later version. # # This package is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, seeSorry, you are not authorized to perform this action
' # # Web application main # # def main(): # Start the Bottle webapp bottle.debug(True) bottle.run(app=app, quiet=False, reloader=True) if __name__ == "__main__": main() bottle-cork-0.12.0/examples/recreate_example_conf.py 0000755 0001750 0001750 00000001753 12312136477 022370 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # # Regenerate files in example_conf from datetime import datetime from cork import Cork def populate_conf_directory(): cork = Cork('example_conf', initialize=True) cork._store.roles['admin'] = 100 cork._store.roles['editor'] = 60 cork._store.roles['user'] = 50 cork._store.save_roles() tstamp = str(datetime.utcnow()) username = password = 'admin' cork._store.users[username] = { 'role': 'admin', 'hash': cork._hash(username, password), 'email_addr': username + '@localhost.local', 'desc': username + ' test user', 'creation_date': tstamp } username = password = '' cork._store.users[username] = { 'role': 'user', 'hash': cork._hash(username, password), 'email_addr': username + '@localhost.local', 'desc': username + ' test user', 'creation_date': tstamp } cork._store.save_users() if __name__ == '__main__': populate_conf_directory() bottle-cork-0.12.0/examples/simple_webapp_using_sqlite_mytest.py 0000755 0001750 0001750 00000013671 12312136477 025102 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under GPLv3+ license, see LICENSE.txt # # Cork example web application # # The following users are already available: # admin/admin, demo/demo import bottle from beaker.middleware import SessionMiddleware from cork import Cork from cork.backends import SQLiteBackend import logging logging.basicConfig(format='localhost - - [%(asctime)s] %(message)s', level=logging.DEBUG) log = logging.getLogger(__name__) bottle.debug(True) # Use users.json and roles.json in the local example_conf directory aaa = Cork('example_conf', email_sender='federico.ceratto@gmail.com', smtp_url='smtp://smtp.magnet.ie') def populate_backend(): b = SQLiteBackend('example2.db', initialize=True) b.connection.executescript(""" INSERT INTO users (username, email_addr, desc, role, hash, creation_date) VALUES ( 'admin', 'admin@localhost.local', 'admin test user', 'admin', 'cLzRnzbEwehP6ZzTREh3A4MXJyNo+TV8Hs4//EEbPbiDoo+dmNg22f2RJC282aSwgyWv/O6s3h42qrA6iHx8yfw=', '2012-10-28 20:50:26.286723' ); INSERT INTO roles (role, level) VALUES ('special', 200); INSERT INTO roles (role, level) VALUES ('admin', 100); INSERT INTO roles (role, level) VALUES ('editor', 60); INSERT INTO roles (role, level) VALUES ('user', 50); """) return b b = populate_backend() aaa = Cork(backend=b, email_sender='federico.ceratto@gmail.com', smtp_url='smtp://smtp.magnet.ie') app = bottle.app() session_opts = { 'session.cookie_expires': True, 'session.encrypt_key': 'please use a random key and keep it secret!', 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.type': 'cookie', 'session.validate_key': True, } app = SessionMiddleware(app, session_opts) # # Bottle methods # # def postd(): return bottle.request.forms def post_get(name, default=''): return bottle.request.POST.get(name, default).strip() @bottle.post('/login') def login(): """Authenticate users""" username = post_get('username') password = post_get('password') aaa.login(username, password, success_redirect='/', fail_redirect='/login') @bottle.route('/user_is_anonymous') def user_is_anonymous(): if aaa.user_is_anonymous: return 'True' return 'False' @bottle.route('/logout') def logout(): aaa.logout(success_redirect='/login') @bottle.post('/register') def register(): """Send out registration email""" aaa.register(post_get('username'), post_get('password'), post_get('email_address')) return 'Please check your mailbox.' @bottle.route('/validate_registration/:registration_code') def validate_registration(registration_code): """Validate registration, create user account""" aaa.validate_registration(registration_code) return 'Thanks. Go to login' @bottle.post('/reset_password') def send_password_reset_email(): """Send out password reset email""" aaa.send_password_reset_email( username=post_get('username'), email_addr=post_get('email_address') ) return 'Please check your mailbox.' @bottle.route('/change_password/:reset_code') @bottle.view('password_change_form') def change_password(reset_code): """Show password change form""" return dict(reset_code=reset_code) @bottle.post('/change_password') def change_password(): """Change password""" aaa.reset_password(post_get('reset_code'), post_get('password')) return 'Thanks. Go to login' @bottle.route('/') def index(): """Only authenticated users can see this""" aaa.require(fail_redirect='/login') return 'Welcome! Admin page Logout' @bottle.route('/restricted_download') def restricted_download(): """Only authenticated users can download this file""" aaa.require(fail_redirect='/login') return bottle.static_file('static_file', root='.') @bottle.route('/my_role') def show_current_user_role(): """Show current user role""" session = bottle.request.environ.get('beaker.session') print "Session from simple_webapp", repr(session) aaa.require(fail_redirect='/login') return aaa.current_user.role # Admin-only pages @bottle.route('/admin') @bottle.view('admin_page') def admin(): """Only admin users can see this""" aaa.require(role='admin', fail_redirect='/sorry_page') return dict( current_user=aaa.current_user, users=aaa.list_users(), roles=aaa.list_roles() ) @bottle.post('/create_user') def create_user(): try: aaa.create_user(postd().username, postd().role, postd().password) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) @bottle.post('/delete_user') def delete_user(): try: aaa.delete_user(post_get('username')) return dict(ok=True, msg='') except Exception, e: print repr(e) return dict(ok=False, msg=e.message) @bottle.post('/create_role') def create_role(): try: aaa.create_role(post_get('role'), post_get('level')) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) @bottle.post('/delete_role') def delete_role(): try: aaa.delete_role(post_get('role')) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) # Static pages @bottle.route('/login') @bottle.view('login_form') def login_form(): """Serve login form""" return {} @bottle.route('/sorry_page') def sorry_page(): """Serve sorry page""" return 'Sorry, you are not authorized to perform this action
' # # Web application main # # def main(): # Start the Bottle webapp bottle.debug(True) bottle.run(app=app, port=8877, quiet=False, reloader=False,server="paste") if __name__ == "__main__": main() bottle-cork-0.12.0/examples/simple_webapp_using_mongodb.py 0000755 0001750 0001750 00000012770 12312136477 023620 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # # Cork example web application # # The following users are already available: # admin/admin, demo/demo import bottle from beaker.middleware import SessionMiddleware from cork import Cork from cork.backends import MongoDBBackend import logging logging.basicConfig(format='localhost - - [%(asctime)s] %(message)s', level=logging.DEBUG) log = logging.getLogger(__name__) bottle.debug(True) def populate_mongodb_backend(): mb = MongoDBBackend(db_name='cork-example', initialize=True) mb.users._coll.insert({ "login": "admin", "email_addr": "admin@localhost.local", "desc": "admin test user", "role": "admin", "hash": "cLzRnzbEwehP6ZzTREh3A4MXJyNo+TV8Hs4//EEbPbiDoo+dmNg22f2RJC282aSwgyWv/O6s3h42qrA6iHx8yfw=", "creation_date": "2012-10-28 20:50:26.286723" }) mb.roles._coll.insert({'role': 'admin', 'val': 100}) mb.roles._coll.insert({'role': 'editor', 'val': 60}) mb.roles._coll.insert({'role': 'user', 'val': 50}) return mb mb = populate_mongodb_backend() aaa = Cork(backend=mb, email_sender='federico.ceratto@gmail.com', smtp_url='smtp://smtp.magnet.ie') app = bottle.app() session_opts = { 'session.cookie_expires': True, 'session.encrypt_key': 'please use a random key and keep it secret!', 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.type': 'cookie', 'session.validate_key': True, } app = SessionMiddleware(app, session_opts) # # Bottle methods # # def postd(): return bottle.request.forms def post_get(name, default=''): return bottle.request.POST.get(name, default).strip() @bottle.post('/login') def login(): """Authenticate users""" username = post_get('username') password = post_get('password') aaa.login(username, password, success_redirect='/', fail_redirect='/login') @bottle.route('/user_is_anonymous') def user_is_anonymous(): if aaa.user_is_anonymous: return 'True' return 'False' @bottle.route('/logout') def logout(): aaa.logout(success_redirect='/login') @bottle.post('/register') def register(): """Send out registration email""" aaa.register(post_get('username'), post_get('password'), post_get('email_address')) return 'Please check your mailbox.' @bottle.route('/validate_registration/:registration_code') def validate_registration(registration_code): """Validate registration, create user account""" aaa.validate_registration(registration_code) return 'Thanks. Go to login' @bottle.post('/reset_password') def send_password_reset_email(): """Send out password reset email""" aaa.send_password_reset_email( username=post_get('username'), email_addr=post_get('email_address') ) return 'Please check your mailbox.' @bottle.route('/change_password/:reset_code') @bottle.view('password_change_form') def change_password(reset_code): """Show password change form""" return dict(reset_code=reset_code) @bottle.post('/change_password') def change_password(): """Change password""" aaa.reset_password(post_get('reset_code'), post_get('password')) return 'Thanks. Go to login' @bottle.route('/') def index(): """Only authenticated users can see this""" aaa.require(fail_redirect='/login') return 'Welcome! Admin page Logout' @bottle.route('/restricted_download') def restricted_download(): """Only authenticated users can download this file""" aaa.require(fail_redirect='/login') return bottle.static_file('static_file', root='.') @bottle.route('/my_role') def show_current_user_role(): """Show current user role""" session = bottle.request.environ.get('beaker.session') print "Session from simple_webapp", repr(session) aaa.require(fail_redirect='/login') return aaa.current_user.role # Admin-only pages @bottle.route('/admin') @bottle.view('admin_page') def admin(): """Only admin users can see this""" aaa.require(role='admin', fail_redirect='/sorry_page') return dict( current_user=aaa.current_user, users=aaa.list_users(), roles=aaa.list_roles() ) @bottle.post('/create_user') def create_user(): try: aaa.create_user(postd().username, postd().role, postd().password) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) @bottle.post('/delete_user') def delete_user(): try: aaa.delete_user(post_get('username')) return dict(ok=True, msg='') except Exception, e: print repr(e) return dict(ok=False, msg=e.message) @bottle.post('/create_role') def create_role(): try: aaa.create_role(post_get('role'), post_get('level')) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) @bottle.post('/delete_role') def delete_role(): try: aaa.delete_role(post_get('role')) return dict(ok=True, msg='') except Exception, e: return dict(ok=False, msg=e.message) # Static pages @bottle.route('/login') @bottle.view('login_form') def login_form(): """Serve login form""" return {} @bottle.route('/sorry_page') def sorry_page(): """Serve sorry page""" return 'Sorry, you are not authorized to perform this action
' # # Web application main # # def main(): # Start the Bottle webapp bottle.debug(True) bottle.run(app=app, quiet=False, reloader=True) if __name__ == "__main__": main() bottle-cork-0.12.0/examples/static_file 0000644 0001750 0001750 00000000003 12161350444 017667 0 ustar fede fede 0000000 0000000 hi bottle-cork-0.12.0/examples/cork.py 0000644 0001750 0001750 00000074665 12312136477 017025 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # Cork - Authentication module for the Bottle web framework # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # # This package is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 3 of the License, or (at your option) any later version. # # This package is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, seePlease insert your new password:
Please insert your credentials:
Please insert your credentials:
Please insert your credentials:
Welcome {{current_user.username}}, your role is: {{current_user.role}}, access time: {{current_user.session_accessed_time}}
Create new user:
Delete user:
Create new role:
Delete role:
| Username | Role | Description | |
|---|---|---|---|
| {{u[0]}} | {{u[1]}} | {{u[2]}} | {{u[2]}} |
| Role | Level |
|---|---|
| {{r[0]}} | {{r[1]}} |
(Reload page to refresh)
Ready.
Sorry, you are not authorized to perform this action
' # # Web application main # # def main(): # Start the Bottle webapp bottle.debug(True) bottle.run(app=app, quiet=False, reloader=False) if __name__ == "__main__": main() bottle-cork-0.12.0/examples/example_conf/ 0000755 0001750 0001750 00000000000 12617467123 020136 5 ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/example_conf/register.json 0000644 0001750 0001750 00000000002 12166632355 022645 0 ustar fede fede 0000000 0000000 {} bottle-cork-0.12.0/examples/example_conf/users.json 0000644 0001750 0001750 00000000722 12512453671 022170 0 ustar fede fede 0000000 0000000 {"admin": {"hash": "cLzRnzbEwehP6ZzTREh3A4MXJyNo+TV8Hs4//EEbPbiDoo+dmNg22f2RJC282aSwgyWv/O6s3h42qrA6iHx8yfw=", "email_addr": "admin@localhost.local", "role": "admin", "creation_date": "2012-10-28 20:50:26.286723", "desc": "admin test user"}, "": {"hash": "cFFusHJ5BZ07G3KhrkeVjB6pIyIGoMP6+BtK0JBtpU/EjhY6v3nvnOZgLqoniJQ9OXn2KFV+SJmZSyPH4Og0HiQ=", "email_addr": "@localhost.local", "role": "user", "creation_date": "2012-10-28 20:50:26.286723", "desc": " test user"}} bottle-cork-0.12.0/examples/example_conf/roles.json 0000644 0001750 0001750 00000000050 12302756620 022142 0 ustar fede fede 0000000 0000000 {"admin": 100, "editor": 60, "user": 50} bottle-cork-0.12.0/examples/cork/ 0000755 0001750 0001750 00000000000 12617467123 016434 5 ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/cork/base_backend.py 0000644 0001750 0001750 00000000000 12512453671 030203 1bottle-cork-0.12.0/cork/base_backend.py ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/cork/SUMMARY 0000644 0001750 0001750 00000000112 12312671642 017501 0 ustar fede fede 0000000 0000000 2 3 test.py k mongo k mysql k sqlalch k paralle k sqlite k bottle-cork-0.12.0/examples/cork/mongodb_backend.py 0000644 0001750 0001750 00000000000 12520166131 031420 1bottle-cork-0.12.0/cork/mongodb_backend.py ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/cork/__pycache__/ 0000755 0001750 0001750 00000000000 12617467123 020644 5 ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/cork/__pycache__/__init__.cpython-34.pyc 0000644 0001750 0001750 00000000477 12617463330 025033 0 ustar fede fede 0000000 0000000 e>VS @ s8 d d l m Z m Z m Z m Z m Z m Z m Z d S) )Cork JsonBackend AAAException AuthExceptionMailer FlaskCorkRedirectN)corkr r r r r r r r r >/home/fede/newhome/projects/bottle-cork/tests/cork/__init__.pySorry, you are not authorized to perform this action
' # # Web application main # # def main(): # Start the Bottle webapp bottle.debug(True) bottle.run(app=app, quiet=False, reloader=True) if __name__ == "__main__": main() bottle-cork-0.12.0/examples/bugtest.py 0000644 0001750 0001750 00000003342 12312136477 017524 0 ustar fede fede 0000000 0000000 from bottle import request, route, template, default_app, run from beaker.middleware import SessionMiddleware from cork import Cork app = default_app() aaa = Cork('example_conf') app = SessionMiddleware(app, { 'beaker.session.auto': True, 'beaker.session.type': 'cookie', 'beaker.session.validate_key': True, 'beaker.session.cookie_expires': True, 'beaker.session.timeout': 3600 * 24}) @route('/createuser') def createuser(): tstamp = str(datetime.utcnow()) username = 'root' password = 'pwd' cork._store.users[username] = { 'role': 'admin', 'hash': cork._hash(username, password), 'email_addr': username + '@localhost.local', 'desc': username + ' test user', 'creation_date': tstamp } return "User created" @route('/login', method=['GET', 'POST']) def login(): if request.method == 'GET': return template(""" """) if request.method == 'POST': username = request.POST.get('user','') password = request.POST.get('password','') print username, password aaa.login(username=username, password=password, success_redirect='/', fail_redirect='/login') @route('/') def home(): aaa.require(role='admin', fail_redirect='/login') return 'welcome' run(app=app, host='0.0.0.0', port=8888) bottle-cork-0.12.0/examples/simple_webapp_flask.py 0000755 0001750 0001750 00000012670 12314377543 022070 0 ustar fede fede 0000000 0000000 #!/usr/bin/env python # # Copyright (C) 2013 Federico Ceratto and others, see AUTHORS file. # Released under LGPLv3+ license, see LICENSE.txt # # Cork example web application # # The following users are already available: # admin/admin, demo/demo import flask from beaker.middleware import SessionMiddleware from cork import FlaskCork import logging import os logging.basicConfig(format='localhost - - [%(asctime)s] %(message)s', level=logging.DEBUG) log = logging.getLogger(__name__) # Use users.json and roles.json in the local example_conf directory aaa = FlaskCork('example_conf', email_sender='federico.ceratto@gmail.com', smtp_url='smtp://smtp.magnet.ie') app = flask.Flask(__name__) app.debug = True app.options = {} #FIXME from flask import jsonify #session_opts = { # 'session.cookie_expires': True, # 'session.encrypt_key': 'please use a random key and keep it secret!', # 'session.httponly': True, # 'session.timeout': 3600 * 24, # 1 day # 'session.type': 'cookie', # 'session.validate_key': True, #} #app = SessionMiddleware(app, session_opts) # # Bottle methods # # def post_get(name, default=''): v = flask.request.form.get(name, default).strip() return str(v) from cork import Redirect @app.errorhandler(Redirect) def redirect_exception_handler(e): return flask.redirect(e.message) @app.route('/login', methods=['POST']) def login(): """Authenticate users""" username = post_get('username') password = post_get('password') aaa.login(username, password, success_redirect='/', fail_redirect='/login') @app.route('/user_is_anonymous') def user_is_anonymous(): if aaa.user_is_anonymous: return 'True' return 'False' @app.route('/logout') def logout(): aaa.logout(success_redirect='/login') @app.route('/register', methods=['POST']) def register(): """Send out registration email""" aaa.register(post_get('username'), post_get('password'), post_get('email_address')) return 'Please check your mailbox.' @app.route('/validate_registration/:registration_code') def validate_registration(registration_code): """Validate registration, create user account""" aaa.validate_registration(registration_code) return 'Thanks. Go to login' @app.route('/reset_password', methods=['POST']) def send_password_reset_email(): """Send out password reset email""" aaa.send_password_reset_email( username=post_get('username'), email_addr=post_get('email_address') ) return 'Please check your mailbox.' @app.route('/change_password/:reset_code') def change_password(reset_code): """Show password change form""" return flask.render_template('password_change_form', reset_code=reset_code) @app.route('/change_password', methods=['POST']) def do_change_password(): """Change password""" aaa.reset_password(post_get('reset_code'), post_get('password')) return 'Thanks. Go to login' @app.route('/') def index(): """Only authenticated users can see this""" aaa.require(fail_redirect='/login') return 'Welcome! Admin page Logout' @app.route('/restricted_download') def restricted_download(): """Only authenticated users can download this file""" aaa.require(fail_redirect='/login') return flask.static_file('static_file', root='.') @app.route('/my_role') def show_current_user_role(): """Show current user role""" session = flask.request.environ.get('beaker.session') print "Session from simple_webapp", repr(session) aaa.require(fail_redirect='/login') return aaa.current_user.role # Admin-only pages @app.route('/admin') def admin(): """Only admin users can see this""" aaa.require(role='admin', fail_redirect='/sorry_page') return flask.render_template('admin_page.html', current_user=aaa.current_user, users=aaa.list_users(), roles=aaa.list_roles() ) @app.route('/create_user', methods=['POST']) def create_user(): try: aaa.create_user(post_get('username'), post_get('role'), post_get('password')) return jsonify(ok=True, msg='') except Exception, e: return jsonify(ok=False, msg=e.message) @app.route('/delete_user', methods=['POST']) def delete_user(): try: aaa.delete_user(post_get('username')) return jsonify(ok=True, msg='') except Exception, e: print repr(e) return jsonify(ok=False, msg=e.message) @app.route('/create_role', methods=['POST']) def create_role(): try: aaa.create_role(post_get('role'), post_get('level')) return jsonify(ok=True, msg='') except Exception, e: return jsonify(ok=False, msg=e.message) @app.route('/delete_role', methods=['POST']) def delete_role(): try: aaa.delete_role(post_get('role')) return jsonify(ok=True, msg='') except Exception, e: return jsonify(ok=False, msg=e.message) # Static pages @app.route('/login') def login_form(): """Serve login form""" return flask.render_template('login_form.html') @app.route('/sorry_page') def sorry_page(): """Serve sorry page""" return 'Sorry, you are not authorized to perform this action
' # # Web application main # # app.secret_key = os.urandom(24) #FIXME: why def main(): # Start the Bottle webapp #bottle.debug(True) app.secret_key = os.urandom(24) app.run(debug=True, use_reloader=True) if __name__ == "__main__": main() bottle-cork-0.12.0/examples/views/ 0000755 0001750 0001750 00000000000 12617467123 016633 5 ustar fede fede 0000000 0000000 bottle-cork-0.12.0/examples/views/login_form.tpl 0000644 0001750 0001750 00000003571 12166632355 021515 0 ustar fede fede 0000000 0000000Please insert your credentials:
Please insert your credentials:
Please insert your credentials:
Please insert your new password:
Welcome {{current_user.username}}, your role is: {{current_user.role}}, access time: {{current_user.session_accessed_time}}
Create new user:
Delete user:
Create new role:
Delete role:
| Username | Role | Description | |
|---|---|---|---|
| {{u[0]}} | {{u[1]}} | {{u[2]}} | {{u[2]}} |
| Role | Level |
|---|---|
| {{r[0]}} | {{r[1]}} |
(Reload page to refresh)
Ready.