def test_users():
userc = User('cdent')
userc.set_password('foobar')
userc.add_role('ADMIN')
userc.note = 'A simple programmer of matter'
store.put(userc)
userf = User('FND')
userf.set_password('I<3whitespace')
store.put(userf)
user2 = store.get(User('cdent'))
assert user2.usersign == userc.usersign
assert user2.check_password('foobar')
assert user2.list_roles() == userc.list_roles()
assert user2.note == userc.note
users = list(store.list_users())
assert len(users) == 2
assert ['FND', 'cdent'] == sorted([user.usersign for user in users])
store.delete(User('FND'))
users = list(store.list_users())
assert len(users) == 1
py.test.raises(NoUserError, "store.get(User('FND'))")
def establish_user_auth(config, store, host, username):
user = User(username)
mapping_username = '******' % username
mapping_tiddler = Tiddler(mapping_username, 'MAPUSER')
mapping_tiddler.fields['mapped_user'] = username
try:
store.delete(user)
except StoreError:
pass
try:
store.delete(mapping_tiddler)
except IOError:
pass
user.add_role('MEMBER')
user.note = '{}'
store.put(user)
ensure_bag('MAPUSER', store)
store.put(mapping_tiddler)
stamp = datetime.utcnow().strftime('%Y%m%d%H')
csrf = gen_nonce(username, host, stamp, config['secret'])
cookie = make_cookie('tiddlyweb_user', mapping_username,
mac_key=config['secret'], httponly=False)
return cookie, csrf
def establish_user_auth(config, store, host, username):
user = User(username)
mapping_username = '******' % username
mapping_tiddler = Tiddler(mapping_username, 'MAPUSER')
mapping_tiddler.fields['mapped_user'] = username
try:
store.delete(user)
except StoreError:
pass
try:
store.delete(mapping_tiddler)
except IOError:
pass
user.add_role('MEMBER')
user.note = '{}'
store.put(user)
ensure_bag('MAPUSER', store)
store.put(mapping_tiddler)
stamp = datetime.utcnow().strftime('%Y%m%d%H')
csrf = gen_nonce(username, host, stamp, config['secret'])
cookie = make_cookie('tiddlyweb_user',
mapping_username,
mac_key=config['secret'],
httponly=False)
return cookie, csrf
def handle(environ, start_response):
"""
Handle a posted request for registration.
If the provided username is blacklisted, ask them to
log in as someone else. Otherwise send closing
material with a link to get started.
"""
pretty_name = environ['tiddlyweb.query'].get('pretty_name', [None])[0]
target_role = environ['tiddlyweb.config'].get('register_role', 'MEMBER')
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
if _blacklisted(environ, username):
return _send_start(environ, start_response,
message='That user has been blocked')
user = User(username)
try:
user = store.get(user)
except NoUserError:
pass # is cool if they don't exist yet
user.add_role('%s' % target_role)
if pretty_name:
user.note = pretty_name
store.put(user)
environ['tiddlyweb.usersign'] = {'name': user.usersign,
'roles': user.list_roles()}
return _send_finish(environ, start_response)
def _init_store(self, struct):
"""
creates basic store structure with bags, recipes and users
(no support for user passwords for security reasons)
"""
store = get_store(self.init_config)
bags = struct.get("bags", {})
for name, data in bags.items():
desc = data.get("desc")
bag = Bag(name, desc=desc)
constraints = data.get("policy", {})
_set_policy(bag, constraints)
store.put(bag)
recipes = struct.get("recipes", {})
for name, data in recipes.items(): # TODO: DRY
desc = data.get("desc")
recipe = Recipe(name, desc=desc)
recipe.set_recipe(data["recipe"])
constraints = data.get("policy", {})
_set_policy(recipe, constraints)
store.put(recipe)
users = struct.get("users", {})
for name, data in users.items():
note = data.get("note")
user = User(name, note=note)
password = data.get("_password")
if password:
user.set_password(password)
for role in data.get("roles", []):
user.add_role(role)
store.put(user)
def handle(environ, start_response):
"""
Handle a posted request for registration.
If the provided username is blacklisted, ask them to
log in as someone else. Otherwise send closing
material with a link to get started.
"""
pretty_name = environ["tiddlyweb.query"].get("pretty_name", [None])[0]
target_role = environ["tiddlyweb.config"].get("register_role", "MEMBER")
store = environ["tiddlyweb.store"]
username = environ["tiddlyweb.usersign"]["name"]
if _blacklisted(environ, username):
return _send_start(environ, start_response, message="That user has been blocked")
user = User(username)
try:
user = store.get(user)
except NoUserError:
pass # is cool if they don't exist yet
user.add_role("%s" % target_role)
if pretty_name:
user.note = pretty_name
store.put(user)
environ["tiddlyweb.usersign"] = {"name": user.usersign, "roles": user.list_roles()}
return _send_finish(environ, start_response)
def handle(environ, start_response):
"""
Handle a posted request for registration.
If the provided username is blacklisted, ask them to
log in as someone else. Otherwise send closing
material with a link to get started.
"""
pretty_name = environ['tiddlyweb.query'].get('pretty_name', [None])[0]
target_role = environ['tiddlyweb.config'].get('register_role', 'MEMBER')
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
if _blacklisted(environ, username):
return _send_start(environ,
start_response,
message='That user has been blocked')
user = User(username)
try:
user = store.get(user)
except NoUserError:
pass # is cool if they don't exist yet
user.add_role('%s' % target_role)
if pretty_name:
user.note = pretty_name
store.put(user)
environ['tiddlyweb.usersign'] = {
'name': user.usersign,
'roles': user.list_roles()
}
return _send_finish(environ, start_response)
def setup_module(module):
try:
shutil.rmtree('store')
except:
pass # !!!
config['server_host'] = {
'host': 'our_test_domain',
'port': '8001',
'scheme': 'http',
}
from tiddlyweb.web import serve
# we have to have a function that returns the callable,
# Selector just _is_ the callable
def app_fn():
return serve.load_app()
#wsgi_intercept.debuglevel = 1
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('our_test_domain', 8001, app_fn)
environ = {'tiddlyweb.config': config}
module.store = Store(config['server_store'][0], config['server_store'][1], environ)
admin = User('admin')
admin.add_role('ADMIN')
admin.set_password('spank')
module.store.put(admin)
module.admin_authorization = b64encode('admin:spank')
module.user_authorization = b64encode('cdent:pigdog')
def test_multi_role_user():
user = User(u'cdent')
user.add_role(u'cow')
user.add_role(u'cow')
store.put(user)
user2 = store.get(User(u'cdent'))
assert list(user2.roles) == ['cow']
def test_multi_role_user():
user = User(u'cdent')
user.add_role('cow')
user.add_role('cow')
store.put(user)
user2 = store.get(User(u'cdent'))
assert list(user2.roles) == ['cow']
def test_simple_put():
user = User('cdent', note='foo')
user.set_password('cowpig')
user.add_role('ADMIN')
user.add_role('BOSS')
store.put(user)
assert os.path.exists(expected_stored_filename)
def _create_user(environ, start_response, creation=0, expiration=0, role='tier1'):
domain = get_domain(environ['HTTP_HOST'])
if creation == 0:
creation = time.time()
store = environ['tiddlyweb.store']
query = environ['tiddlyweb.query']
name = query.get('name', [None])[0]
email = query.get('email', [None])[0]
company = query.get('company', [None])[0]
country = query.get('country', [None])[0]
if not (name and email):
# The form has not been filled out
return _user_form(environ, start_response, role=role, message='Missing Data!',
formdata={'name': name, 'email': email,
'company': company, 'country': country})
user = User(email)
try:
user = store.get(user)
# User exists!
return _user_form(environ, start_response, role=role, message='That account already exists!',
formdata={'name': name, 'email': email,
'company': company, 'country': country})
except NoUserError:
password = _random_pass()
user.set_password(password)
user.add_role(role)
store.put(user)
bag_name = environ['tiddlyweb.config'].get('magicuser.bag', 'MAGICUSER')
ensure_bag(bag_name, store, policy_dict={
'read': ['NONE'], 'write': ['NONE'],
'create': ['NONE'], 'manage': ['NONE']})
tiddler = Tiddler(email, bag_name)
tiddler.fields['country'] = country
tiddler.fields['company'] = company
tiddler.fields['name'] = name
# Set the creation and expiration times.
now = time.time()
tiddler.fields['creation'] = '%s' % creation
tiddler.fields['expiry'] = '%s' % expiration
store.put(tiddler)
to_address = email
subject = domain+" user info"
body = """
Here's your info:
Username: %s
Password: %s
""" % (email, password)
query_string = '?email=%s' % to_address
try:
send_email(to_address, subject=subject, body=body, from_='avox@'+domain)
query_string += '&success=1&role=%s' % role
raise HTTP303(server_base_url(environ)+'/pages/new_account'+query_string)
except socket.error:
logging.debug('failed to send: %s:%s:%s', to_address, subject, body)
query_string += '&failure=1&role=%s' % role
raise HTTP302(server_base_url(environ)+'/pages/new_account'+query_string)
def test_put_get_user():
user = User('testone')
user.add_role('monkey')
store.put(user)
read_user = User('testone')
read_user = store.get(read_user)
assert read_user.list_roles() == ['monkey']
def test_put_get_user():
user = User('testone')
user.add_role('monkey')
store.put(user)
read_user = User('testone')
read_user = store.get(read_user)
assert read_user.list_roles() == ['monkey']
def test_simple_put():
user = User("cdent", note="foo")
user.set_password("cowpig")
user.add_role("ADMIN")
user.add_role("BOSS")
store.put(user)
if type(store.storage) != tiddlyweb.stores.text.Store:
py.test.skip("skipping this test for non-text store")
assert os.path.exists(expected_stored_filename)
def test_simple_put():
user = User('cdent', note='foo')
user.set_password('cowpig')
user.add_role('ADMIN')
user.add_role('BOSS')
store.put(user)
if type(store.storage) != tiddlyweb.stores.text.Store:
py.test.skip('skipping this test for non-text store')
assert os.path.exists(expected_stored_filename)
def test_simple_put():
user = User('cdent', note='foo')
user.set_password('cowpig')
user.add_role('ADMIN')
user.add_role('BOSS')
store.put(user)
if type(store.storage) != tiddlyweb.stores.text.Store:
py.test.skip('skipping this test for non-text store')
assert os.path.exists(expected_stored_filename)
def register(environ, start_response):
"""
register the user
"""
config = environ['tiddlyweb.config']
store = environ['tiddlyweb.store']
query = environ['tiddlyweb.query']
try:
username = query['login'][0]
name = query['name'][0]
email = query['email'][0]
extra = query['extra'][0]
redirect = query['redirect'][0]
except (KeyError, ValueError) as exc:
raise HTTP400('Incomplete form submission: %s' % exc)
announcements = query.get('announcements', [None])[0]
user = User(username)
try:
store.get(user)
raise HTTP400('That username is not available.')
except StoreError: # we expect and want this
pass
user.add_role(DEFAULT_ROLE)
user.note = simplejson.dumps({
'registered': time(),
'name': name,
'email': email,
'extra': extra,
'announcements': announcements is not None
})
store.put(user)
create_wiki(environ, '_%s-data' % username, mode='private',
username=username, desc='Data Files', validate=False)
create_wiki(environ, '%s-notebook' % username, mode='private',
username=username, desc='Private Notebook', validate=False)
create_wiki(environ, '%s' % username, mode='protected',
username=username, desc='Share Stuff', validate=False)
redirect_uri = '%s%s' % (server_base_url(environ), redirect)
secret = config['secret']
cookie_age = config.get('cookie_age', None)
cookie_header_string = make_cookie('tiddlyweb_user', user.usersign,
mac_key=secret, path='/', expires=cookie_age)
start_response('303 See Other',
[('Set-Cookie', cookie_header_string),
('Content-Type', 'text/plain'),
('Location', str(redirect_uri))])
return [redirect_uri]
def test_store_user():
user = User('testuser')
user.set_password('testpass')
user.add_role('testrole')
store.put(user)
assert os.path.exists('store/testuser.user')
loaded_user = User('testuser')
loaded_user = store.get(loaded_user)
assert loaded_user.check_password('testpass')
def test_store_user():
user = User('testuser')
user.set_password('testpass')
user.add_role('testrole')
store.put(user)
assert os.path.exists('store/testuser.user')
loaded_user = User('testuser')
loaded_user = store.get(loaded_user)
assert loaded_user.check_password('testpass')
def test_users():
userc = User(name)
userc.set_password(name)
userc.add_role('ADMIN')
userc.note = 'A simple programmer of matter'
store.put(userc)
user2 = store.get(User(name))
assert user2.usersign == userc.usersign
assert user2.check_password(name)
assert user2.list_roles() == userc.list_roles()
assert user2.note == userc.note
def update_user(environ, start_response):
query = environ['tiddlyweb.query']
store = environ['tiddlyweb.store']
username = query.get('email', [None])[0]
if not username:
return update_user_form(environ, start_response,
message='Must have username/email')
name = query.get('name', [''])[0]
country = query.get('country', [''])[0]
company = query.get('company', [''])[0]
password = query.get('password', [''])[0]
tier = query.get('tier', [''])[0]
expiry = query.get('expiry', ['0'])[0]
now = time.time()
expiry = now + (float(expiry) * 24 * 60 * 60)
user = User(username)
user_new = False
try:
user = store.get(user)
except NoUserError:
user_new = True
roles = [role for role in user.list_roles() if not role.startswith('tier')]
for role in user.list_roles():
user.del_role(role)
roles.append(tier)
for role in roles:
user.add_role(role) # it's a set dupes are handled
if password:
user.set_password(password)
store.put(user)
bag_name = environ['tiddlyweb.config'].get('magicuser.bag', 'MAGICUSER')
tiddler = Tiddler(username, bag_name)
tiddler.fields['country'] = country
tiddler.fields['company'] = company
tiddler.fields['name'] = name
# Set the creation and expiration times.
if user_new:
tiddler.fields['creation'] = '%s' % now
tiddler.fields['expiry'] = '%s' % expiry
store.put(tiddler)
# XXX need to go somewhere useful?
#raise HTTP303(server_base_url(environ))
message = "Update successful"
success = True
logging.debug('going to update_user_form with message: '+message)
return update_user_form(environ, start_response, message, success)
def update_user(environ, start_response):
query = environ["tiddlyweb.query"]
store = environ["tiddlyweb.store"]
username = query.get("email", [None])[0]
if not username:
return update_user_form(environ, start_response, message="Must have username/email")
name = query.get("name", [""])[0]
country = query.get("country", [""])[0]
company = query.get("company", [""])[0]
password = query.get("password", [""])[0]
tier = query.get("tier", [""])[0]
expiry = query.get("expiry", ["0"])[0]
now = time.time()
expiry = now + (float(expiry) * 24 * 60 * 60)
user = User(username)
user_new = False
try:
user = store.get(user)
except NoUserError:
user_new = True
roles = [role for role in user.list_roles() if not role.startswith("tier")]
for role in user.list_roles():
user.del_role(role)
roles.append(tier)
for role in roles:
user.add_role(role) # it's a set dupes are handled
if password:
user.set_password(password)
store.put(user)
bag_name = environ["tiddlyweb.config"].get("magicuser.bag", "MAGICUSER")
tiddler = Tiddler(username, bag_name)
tiddler.fields["country"] = country
tiddler.fields["company"] = company
tiddler.fields["name"] = name
# Set the creation and expiration times.
if user_new:
tiddler.fields["creation"] = "%s" % now
tiddler.fields["expiry"] = "%s" % expiry
store.put(tiddler)
# XXX need to go somewhere useful?
# raise HTTP303(server_base_url(environ))
message = "Update successful"
success = True
logging.debug("going to update_user_form with message: " + message)
return update_user_form(environ, start_response, message, success)
def test_user_role():
user = User('paper')
assert user.list_roles() == []
user.add_role('ADMIN')
assert user.list_roles() == ['ADMIN']
user.del_role('ADMIN')
assert user.list_roles() == []
# add twice to confirm set-ness
user.add_role('ADMIN')
user.add_role('ADMIN')
assert user.list_roles() == ['ADMIN']
def test_user_role():
user = User('paper')
assert user.list_roles() == []
user.add_role('ADMIN')
assert user.list_roles() == ['ADMIN']
user.del_role('ADMIN')
assert user.list_roles() == []
# add twice to confirm set-ness
user.add_role('ADMIN')
user.add_role('ADMIN')
assert user.list_roles() == ['ADMIN']
def addrole(args):
"""Add a role to an existing user. <username> [role] [role] [role]"""
try:
username = args.pop(0)
roles = args[0:]
except (IndexError, ValueError) as exc:
usage('you must provide a user and at least one ' 'role: %s' % exc)
try:
store = _store()
user = User(username)
user = store.get(user)
for role in roles:
user.add_role(role)
store.put(user)
except Exception as exc:
usage('unable to add role to user: %s' % exc)
return True
def addrole(args):
"""Add a role to an existing user. <username> [role] [role] [role]"""
try:
username = args.pop(0)
roles = args[0:]
except (IndexError, ValueError) as exc:
usage('you must provide a user and at least one '
'role: %s' % exc)
try:
store = _store()
user = User(username)
user = store.get(user)
for role in roles:
user.add_role(role)
store.put(user)
except Exception as exc:
usage('unable to add role to user: %s' % exc)
return True
def adduser(args):
"""Add or update a user to the database: <username> <password> [[role] [role] ...]"""
try:
username, password = args[0:2]
except (IndexError, ValueError):
usage('you must include at least a username and password')
try:
roles = args[2:]
except IndexError:
roles = []
# this will raise an except to be caught by the handler
store = _store()
user = User(username)
user.set_password(password)
for role in roles:
user.add_role(role)
store.put(user)
return True
def adduser(args):
"""Add or update a user to the database: <username> <password> [[role] [role] ...]"""
try:
username, password = args[0:2]
except (IndexError, ValueError):
usage('you must include at least a username and password')
try:
roles = args[2:]
except IndexError:
roles = []
# this will raise an except to be caught by the handler
store = _store()
user = User(username)
user.set_password(password)
for role in roles:
user.add_role(role)
store.put(user)
return True
def _downgrade_to_tier1(self, environ, userinfo):
store = environ['tiddlyweb.store']
expiration = (time.time() + DEFAULT_EXPIRE_DAYS * 24 * 60 * 60)
userinfo['roles'].remove('tier2')
userinfo['roles'].append('tier1')
userinfo['fields']['expiry'] = expiration
bag_name = environ['tiddlyweb.config'].get('magicuser.bag', 'MAGICUSER')
username = userinfo['name']
tiddler = Tiddler(username, bag_name)
try:
tiddler = store.get(tiddler)
except StoreError:
pass # tiddler is empty
tiddler.fields['expiry'] = '%s' % expiration
store.put(tiddler)
user = User(username)
user = store.get(user)
user.del_role('tier2')
user.add_role('tier1')
store.put(user)
return userinfo
@make_command()
def addrole(args):
"""Add a role to an existing user. <username> [role] [role] [role]"""
try:
username = args.pop(0)
roles = args[0:]
except (IndexError, ValueError), exc:
usage('you must provide a user and at least one ' 'role: %s' % exc)
try:
store = _store()
user = User(username)
user = store.get(user)
for role in roles:
user.add_role(role)
store.put(user)
except Exception, exc:
usage('unable to add role to user: %s' % exc)
return True
@make_command()
def adduser(args):
"""Add or update a user to the database: <username> <password> [[role] [role] ...]"""
try:
username, password = args[0:2]
except (IndexError, ValueError):
usage('you must include at least a username and password')
try:
def test_make_a_bunch():
for x in xrange(RANGE):
bag_name = u'bag%s' % x
recipe_name = u'recipe%s' % x
tiddler_name = u'tiddler%s' % x
recipe_list = [(bag_name, '')]
tiddler_text = u'hey ho %s' % x
field_name = u'field%s' % x
field_name2 = u'fieldone%s' % x
tag_name = u'tag%s' % x
user_name = u'user%s' % x
user_pass = u'pass%s' % x
user_note = u'note%s' % x
user_roles = [u'rolehold', u'role%s' % x]
bag = Bag(bag_name)
bag.policy.owner = u'owner%s' % x
bag.policy.read = [u'hi%s' % x, u'andextra']
bag.policy.manage = [u'R:hi%s' % x, u'andmanage']
store.put(bag)
recipe = Recipe(recipe_name)
recipe.policy.owner = u'owner%s' % x
recipe.policy.read = [u'hi%s' % x, u'andextra']
recipe.policy.manage = [u'R:hi%s' % x, u'andmanage']
recipe.set_recipe(recipe_list)
store.put(recipe)
tiddler = Tiddler(tiddler_name, bag_name)
tiddler.text = tiddler_text
tiddler.fields[field_name] = field_name
tiddler.fields[field_name2] = field_name2
tiddler.fields['server.host'] = 'gunky'
tiddler.tags = [tag_name]
store.put(tiddler)
store.put(tiddler)
user = User(user_name)
user.set_password(user_pass)
user.note = user_note
for role in user_roles:
user.add_role(role)
store.put(user)
bags = [bag.name for bag in store.list_bags()]
recipes = [recipe.name for recipe in store.list_recipes()]
users = [user.usersign for user in store.list_users()]
assert len(bags) == RANGE
assert len(recipes) == RANGE
assert len(users) == RANGE
for x in xrange(RANGE):
bname = 'bag%s' % x
rname = 'recipe%s' % x
uname = 'user%s' % x
assert bname in bags
assert rname in recipes
assert uname in users
tiddler = store.get(Tiddler(u'tiddler0', u'bag0'))
assert tiddler.fields['field0'] == 'field0'
assert tiddler.fields['fieldone0'] == 'fieldone0'
bag = Bag(u'bag0')
bag = store.get(bag)
tiddlers = []
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.append(store.get(tiddler))
assert len(tiddlers) == 1
assert tiddlers[0].title == 'tiddler0'
assert tiddlers[0].fields['field0'] == 'field0'
assert tiddlers[0].fields['fieldone0'] == 'fieldone0'
assert tiddlers[0].tags == ['tag0']
assert sorted(bag.policy.read) == ['andextra', 'hi0']
assert sorted(bag.policy.manage) == ['R:hi0', u'andmanage']
assert bag.policy.owner == 'owner0'
user = User(u'user1')
user = store.get(user)
assert user.usersign == 'user1'
assert user.check_password('pass1')
assert user.note == 'note1'
assert 'role1' in user.list_roles()
assert 'rolehold' in user.list_roles()
recipe = Recipe(u'recipe2')
recipe = store.get(recipe)
assert recipe.name == 'recipe2'
bags = [bag_name for bag_name, filter in recipe.get_recipe()]
assert len(bags) == 1
assert 'bag2' in bags
assert sorted(recipe.policy.read) == ['andextra', 'hi2']
assert sorted(recipe.policy.manage) == ['R:hi2', u'andmanage']
assert recipe.policy.owner == 'owner2'
recipe.policy.manage = [u'andmanage']
store.put(recipe)
recipe = Recipe (u'recipe2')
recipe = store.get(recipe)
assert recipe.policy.manage == [u'andmanage']
# delete the above things
store.delete(bag)
py.test.raises(NoBagError, 'store.delete(bag)')
py.test.raises(NoBagError, 'store.get(bag)')
store.delete(recipe)
py.test.raises(NoRecipeError, 'store.delete(recipe)')
py.test.raises(NoRecipeError, 'store.get(recipe)')
store.delete(user)
py.test.raises(NoUserError, 'store.delete(user)')
py.test.raises(NoUserError, 'store.get(user)')
tiddler = Tiddler(u'tiddler9', u'bag9')
store.get(tiddler)
assert tiddler.bag == 'bag9'
assert tiddler.text == 'hey ho 9'
assert tiddler.tags == ['tag9']
assert tiddler.fields['field9'] == 'field9'
assert 'server.host' not in tiddler.fields
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.delete(tiddler)')
py.test.raises(NoTiddlerError, 'store.get(tiddler)')
@make_command()
def addrole(args):
"""Add a role to an existing user. <username> [role] [role] [role]"""
try:
username = args.pop(0)
roles = args[0:]
except (IndexError, ValueError), exc:
usage('you must provide a user and at least one '
'role: %s' % exc)
try:
store = _store()
user = User(username)
user = store.get(user)
for role in roles:
user.add_role(role)
store.put(user)
except Exception, exc:
usage('unable to add role to user: %s' % exc)
return True
@make_command()
def adduser(args):
"""Add or update a user to the database: <username> <password> [[role] [role] ...]"""
try:
username, password = args[0:2]
except (IndexError, ValueError):
usage('you must include at least a username and password')
try:
def test_make_a_bunch():
for x in xrange(RANGE):
bag_name = u"bag%s" % x
recipe_name = u"recipe%s" % x
tiddler_name = u"tiddler%s" % x
recipe_list = [(bag_name, "")]
tiddler_text = u"hey ho %s" % x
field_name = u"field%s" % x
tag_name = u"tag%s" % x
user_name = u"user%s" % x
user_pass = u"pass%s" % x
user_note = u"note%s" % x
user_roles = [u"rolehold", u"role%s" % x]
bag = Bag(bag_name)
bag.policy.owner = u"owner%s" % x
bag.policy.read = [u"hi%s" % x, u"andextra"]
bag.policy.manage = [u"R:hi%s" % x, u"andmanage"]
store.put(bag)
recipe = Recipe(recipe_name)
recipe.policy.owner = u"owner%s" % x
recipe.policy.read = [u"hi%s" % x, u"andextra"]
recipe.policy.manage = [u"R:hi%s" % x, u"andmanage"]
recipe.set_recipe(recipe_list)
store.put(recipe)
tiddler = Tiddler(tiddler_name, bag_name)
tiddler.text = tiddler_text
tiddler.fields[field_name] = field_name
tiddler.fields["server.host"] = u"gunky"
tiddler.tags = [tag_name]
store.put(tiddler)
user = User(user_name)
user.set_password(user_pass)
user.note = user_note
for role in user_roles:
user.add_role(role)
store.put(user)
bags = [bag.name for bag in store.list_bags()]
recipes = [recipe.name for recipe in store.list_recipes()]
users = [user.usersign for user in store.list_users()]
assert len(bags) == RANGE
assert len(recipes) == RANGE
assert len(users) == RANGE
for x in xrange(RANGE):
bname = u"bag%s" % x
rname = u"recipe%s" % x
uname = u"user%s" % x
assert bname in bags
assert rname in recipes
assert uname in users
bag = Bag("bag0")
bag = store.get(bag)
tiddlers = []
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.append(store.get(tiddler))
assert len(tiddlers) == 1
assert tiddlers[0].title == "tiddler0"
assert tiddlers[0].fields["field0"] == "field0"
assert tiddlers[0].tags == ["tag0"]
assert sorted(bag.policy.read) == ["andextra", "hi0"]
assert sorted(bag.policy.manage) == ["R:hi0", "andmanage"]
assert bag.policy.owner == "owner0"
bag = Bag("bag0")
bag = store.get(bag)
bag.policy.read.remove("hi0")
store.put(bag)
bag = Bag("bag0")
bag = store.get(bag)
assert bag.policy.read == [u"andextra"]
bag = Bag("bag0")
bag = store.get(bag)
bag.policy.read.append(u"hi0")
store.put(bag)
bag = Bag("bag0")
bag = store.get(bag)
assert sorted(bag.policy.read) == ["andextra", "hi0"]
user = User("user1")
user = store.get(user)
assert user.usersign == "user1"
assert user.check_password("pass1")
assert user.note == "note1"
assert "role1" in user.list_roles()
assert "rolehold" in user.list_roles()
recipe = Recipe("recipe2")
recipe = store.get(recipe)
assert recipe.name == "recipe2"
bags = [bag_name for bag_name, filter in recipe.get_recipe()]
assert len(bags) == 1
assert "bag2" in bags
assert sorted(recipe.policy.read) == ["andextra", "hi2"]
assert sorted(recipe.policy.manage) == ["R:hi2", "andmanage"]
assert recipe.policy.owner == "owner2"
recipe.policy.manage = [u"andmanage"]
store.put(recipe)
recipe = Recipe("recipe2")
recipe = store.get(recipe)
assert recipe.policy.manage == ["andmanage"]
# delete the above things
store.delete(bag)
py.test.raises(NoBagError, "store.delete(bag)")
py.test.raises(NoBagError, "store.get(bag)")
store.delete(recipe)
py.test.raises(NoRecipeError, "store.delete(recipe)")
py.test.raises(NoRecipeError, "store.get(recipe)")
store.delete(user)
py.test.raises(NoUserError, "store.delete(user)")
py.test.raises(NoUserError, "store.get(user)")
tiddler = Tiddler("tiddler9", "bag9")
store.get(tiddler)
assert tiddler.bag == "bag9"
assert tiddler.text == "hey ho 9"
assert tiddler.tags == ["tag9"]
assert tiddler.fields["field9"] == "field9"
assert "server.host" not in tiddler.fields
store.delete(tiddler)
py.test.raises(NoTiddlerError, "store.delete(tiddler)")
py.test.raises(NoTiddlerError, "store.get(tiddler)")
def register(environ, start_response):
"""
register the user
"""
config = environ['tiddlyweb.config']
store = environ['tiddlyweb.store']
query = environ['tiddlyweb.query']
try:
server_name = query['server_name'][0]
server_name_sig = query['server_name_sig'][0]
server_login = query['server_login'][0]
server_login_sig = query['server_login_sig'][0]
username = query['login'][0]
name = query['name'][0]
email = query['email'][0]
extra = query['extra'][0]
redirect = query['redirect'][0]
except (KeyError, ValueError) as exc:
raise HTTP400('Incomplete form submission: %s' % exc)
announcements = query.get('announcements', [None])[0]
# Bail out if someone corrupted the form input.
secret = config['secret']
name_sig = sha('%s%s' % (server_name, secret)).hexdigest()
login_sig = sha('%s%s' % (server_login, secret)).hexdigest()
if name_sig != server_name_sig or login_sig != server_login_sig:
raise HTTP400('Invalid request')
user = User(username)
try:
store.get(user)
raise HTTP400('That username is not available.')
except StoreError: # we expect and want this
pass
user.add_role(DEFAULT_ROLE)
user.note = simplejson.dumps({
'registered': time(),
'name': name,
'email': email,
'extra': extra,
'announcements': announcements is not None
})
map_bag_name = config.get('magicuser.map', 'MAPUSER')
ensure_bag(map_bag_name, store, policy_dict=MAP_USER_POLICY)
tiddler = Tiddler(server_login, map_bag_name)
try:
store.get(tiddler)
raise HTTP400('That remote user is already mapped')
except StoreError:
pass
tiddler.fields['mapped_user'] = username
store.put(tiddler)
store.put(user)
create_wiki(environ,
'_%s-data' % username,
mode='private',
username=username,
desc='Data Files',
validate=False)
create_wiki(environ,
'%s-notebook' % username,
mode='private',
username=username,
desc='Private Notebook',
validate=False)
create_wiki(environ,
'%s' % username,
mode='protected',
username=username,
desc='Share Stuff',
validate=False)
redirect_uri = '%s%s' % (server_base_url(environ), redirect)
secret = config['secret']
cookie_age = config.get('cookie_age', None)
cookie_header_string = make_cookie('tiddlyweb_user',
server_login,
mac_key=secret,
path='/',
expires=cookie_age)
start_response('303 See Other', [('Set-Cookie', cookie_header_string),
('Content-Type', 'text/plain'),
('Location', str(redirect_uri))])
return [redirect_uri]
def _create_user(environ, start_response, creation=0, expiration=0, role="tier1"):
domain = get_domain(environ["HTTP_HOST"])
if creation == 0:
creation = time.time()
store = environ["tiddlyweb.store"]
query = environ["tiddlyweb.query"]
name = query.get("name", [None])[0]
email = query.get("email", [None])[0]
company = query.get("company", [None])[0]
country = query.get("country", [None])[0]
if not (name and email):
# The form has not been filled out
return _user_form(
environ,
start_response,
role=role,
message="Missing Data!",
formdata={"name": name, "email": email, "company": company, "country": country},
)
user = User(email)
try:
user = store.get(user)
# User exists!
return _user_form(
environ,
start_response,
role=role,
message="That account already exists!",
formdata={"name": name, "email": email, "company": company, "country": country},
)
except NoUserError:
password = _random_pass()
user.set_password(password)
user.add_role(role)
store.put(user)
bag_name = environ["tiddlyweb.config"].get("magicuser.bag", "MAGICUSER")
ensure_bag(
bag_name, store, policy_dict={"read": ["NONE"], "write": ["NONE"], "create": ["NONE"], "manage": ["NONE"]}
)
tiddler = Tiddler(email, bag_name)
tiddler.fields["country"] = country
tiddler.fields["company"] = company
tiddler.fields["name"] = name
# Set the creation and expiration times.
now = time.time()
tiddler.fields["creation"] = "%s" % creation
tiddler.fields["expiry"] = "%s" % expiration
store.put(tiddler)
to_address = email
subject = domain + " user info"
body = """
Here's your info:
Username: %s
Password: %s
""" % (
email,
password,
)
query_string = "?email=%s" % to_address
try:
send_email(to_address, subject=subject, body=body, from_="avox@" + domain)
query_string += "&success=1&role=%s" % role
raise HTTP303(server_base_url(environ) + "/pages/new_account" + query_string)
except socket.error:
logging.debug("failed to send: %s:%s:%s", to_address, subject, body)
query_string += "&failure=1&role=%s" % role
raise HTTP302(server_base_url(environ) + "/pages/new_account" + query_string)
def test_make_a_bunch():
for x in xrange(RANGE):
bag_name = u'bag%s' % x
recipe_name = u'recipe%s' % x
tiddler_name = u'tiddler%s' % x
recipe_list = [(bag_name, '')]
tiddler_text = u'hey ho %s' % x
field_name = u'field%s' % x
field_name2 = u'fieldone%s' % x
tag_name = u'tag%s' % x
user_name = u'user%s' % x
user_pass = u'pass%s' % x
user_note = u'note%s' % x
user_roles = [u'rolehold', u'role%s' % x]
bag = Bag(bag_name)
bag.policy.owner = u'owner%s' % x
bag.policy.read = [u'hi%s' % x, u'andextra']
bag.policy.manage = [u'R:hi%s' % x, u'andmanage']
store.put(bag)
recipe = Recipe(recipe_name)
recipe.policy.owner = u'owner%s' % x
recipe.policy.read = [u'hi%s' % x, u'andextra']
recipe.policy.manage = [u'R:hi%s' % x, u'andmanage']
recipe.set_recipe(recipe_list)
store.put(recipe)
tiddler = Tiddler(tiddler_name, bag_name)
tiddler.text = tiddler_text
tiddler.fields[field_name] = field_name
tiddler.fields[field_name2] = field_name2
tiddler.fields['server.host'] = 'gunky'
tiddler.tags = [tag_name]
store.put(tiddler)
store.put(tiddler)
user = User(user_name)
user.set_password(user_pass)
user.note = user_note
for role in user_roles:
user.add_role(role)
store.put(user)
bags = [bag.name for bag in store.list_bags()]
recipes = [recipe.name for recipe in store.list_recipes()]
users = [user.usersign for user in store.list_users()]
assert len(bags) == RANGE
assert len(recipes) == RANGE
assert len(users) == RANGE
for x in xrange(RANGE):
bname = 'bag%s' % x
rname = 'recipe%s' % x
uname = 'user%s' % x
assert bname in bags
assert rname in recipes
assert uname in users
tiddler = store.get(Tiddler(u'tiddler0', u'bag0'))
assert tiddler.fields[u'field0'] == u'field0'
assert tiddler.fields[u'fieldone0'] == u'fieldone0'
bag = Bag(u'bag0')
bag = store.get(bag)
tiddlers = []
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.append(store.get(tiddler))
assert len(tiddlers) == 1
assert tiddlers[0].title == 'tiddler0'
assert tiddlers[0].fields['field0'] == 'field0'
assert tiddlers[0].fields['fieldone0'] == 'fieldone0'
assert tiddlers[0].tags == ['tag0']
assert sorted(bag.policy.read) == ['andextra', 'hi0']
assert sorted(bag.policy.manage) == ['R:hi0', u'andmanage']
assert bag.policy.owner == 'owner0'
user = User(u'user1')
user = store.get(user)
assert user.usersign == 'user1'
assert user.check_password('pass1')
assert user.note == 'note1'
assert 'role1' in user.list_roles()
assert 'rolehold' in user.list_roles()
recipe = Recipe(u'recipe2')
recipe = store.get(recipe)
assert recipe.name == 'recipe2'
bags = [bag_name for bag_name, filter in recipe.get_recipe()]
assert len(bags) == 1
assert 'bag2' in bags
assert sorted(recipe.policy.read) == ['andextra', 'hi2']
assert sorted(recipe.policy.manage) == ['R:hi2', u'andmanage']
assert recipe.policy.owner == 'owner2'
recipe.policy.manage = [u'andmanage']
store.put(recipe)
recipe = Recipe(u'recipe2')
recipe = store.get(recipe)
assert recipe.policy.manage == [u'andmanage']
# delete the above things
store.delete(bag)
py.test.raises(NoBagError, 'store.delete(bag)')
py.test.raises(NoBagError, 'store.get(bag)')
store.delete(recipe)
py.test.raises(NoRecipeError, 'store.delete(recipe)')
py.test.raises(NoRecipeError, 'store.get(recipe)')
store.delete(user)
py.test.raises(NoUserError, 'store.delete(user)')
py.test.raises(NoUserError, 'store.get(user)')
tiddler = Tiddler(u'tiddler9', u'bag9')
store.get(tiddler)
assert tiddler.bag == 'bag9'
assert tiddler.text == 'hey ho 9'
assert tiddler.tags == ['tag9']
assert tiddler.fields['field9'] == 'field9'
assert 'server.host' not in tiddler.fields
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.delete(tiddler)')
py.test.raises(NoTiddlerError, 'store.get(tiddler)')
