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 _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 ensure_user_bag(store, userpage):
policy = {}
policy['manage'] = ['R:ADMIN']
for constraint in ['read', 'write', 'create', 'delete']:
policy[constraint] = [userpage]
policy['owner'] = userpage
ensure_bag(userpage, store, policy)
def ensure_user_bag(store, userpage):
policy = {}
policy["manage"] = ["R:ADMIN"]
for constraint in ["read", "write", "create", "delete"]:
policy[constraint] = [userpage]
policy["owner"] = userpage
ensure_bag(userpage, store, policy)
def ensure_user_bag(store, userpage):
policy = {}
policy['manage'] = ['R:ADMIN']
for constraint in ['read', 'write', 'create', 'delete']:
policy[constraint] = [userpage]
policy['owner'] = userpage
ensure_bag(userpage, store, policy)
def set_user_token(store, token_name, token, username, service):
ensure_bag(OAUTH_BAG, store, OAUTH_BAG_POLICY,
description='oauth info', owner=OAUTH_BAG_OWNER)
user_tiddler_title = '%s_%s' % (service['name'], username)
tiddler = Tiddler(user_tiddler_title, OAUTH_BAG)
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # we okay if it isn't there
tiddler.fields[token_name] = token.to_string()
store.put(tiddler)
def get_user_token(store, token_name, username, service):
ensure_bag(OAUTH_BAG, store, OAUTH_BAG_POLICY,
description='oauth info', owner=OAUTH_BAG_OWNER)
user_tiddler_title = '%s_%s' % (service['name'], username)
tiddler = Tiddler(user_tiddler_title, OAUTH_BAG)
print 'getting tiddler', tiddler
try:
tiddler = store.get(tiddler)
print 'got', tiddler.fields
return tiddler.fields[token_name]
except (NoTiddlerError, KeyError):
return None
def get_subscriptions_bag(store, subscription_type):
"""
determine the correct bag requested for the subscription
"""
sub_template = Template(config['email']['subscription_format'])
if subscription_type in SUPPORTED_SUBSCRIPTIONS:
sub_bag = sub_template.safe_substitute(subscription=sub_type)
else:
sub_bag = sub_template.safe_substitute(
subscription=config['email']['default_subscription'])
ensure_bag(sub_bag, store)
return sub_bag
def manifest(args):
"""Make a new manifesto. <manifesto name> <dictionary prefix>"""
store = get_store(config)
try:
recipe_name = args[0]
bag_name = args[1] + '-dictionary'
except IndexError:
usage("manifesto name and dictionary prefix required")
# add policy info later
ensure_bag(recipe_name, store)
ensure_bag(bag_name, store)
recipe = Recipe(recipe_name)
recipe.set_recipe([
(bag_name, ''),
(recipe_name, '')])
recipe = store.put(recipe)
def do(args):
"""Establish a to do item."""
store = get_store(global_config)
bag_name = 'do'
bag = ensure_bag(bag_name, store)
title = ' '.join(args)
tiddler = Tiddler(title, bag_name)
store.put(tiddler)
def weight(args):
"""Record a daily weight."""
store = get_store(global_config)
bag_name = 'weight'
bag = ensure_bag(bag_name, store)
title = str(uuid())
tiddler = Tiddler(title, bag_name)
tiddler.fields['weight'] = args[0]
store.put(tiddler)
def starttime(args):
"""Record start time in a bag: <bag>"""
store = get_store(global_config)
bag_name = "%s-start" % args[0]
bag = ensure_bag(bag_name, store)
tiddler = Tiddler(int(time()), bag_name)
try:
tiddler.text = args[1]
except IndexError:
pass
store.put(tiddler)
def ensure_bags(config):
"""
Ensure that our store has the required bags for operations.
For now this assumes that we're operating on all possible
consumer/provider dimensions. Bags are cheap, so...
"""
store = get_store(config)
# one for storing app info
app_bag = config.get('oauth.app_bag', 'oauth_apps')
# one for storing user authorization codes
token_bag = config.get('oauth.tokens_bag', 'oauth_tokens')
# one for storing user auth tokens
registration_bag = config.get('oauth.registrations_bag',
'oauth_registrations')
for bag in [app_bag, token_bag, registration_bag]:
ensure_bag(bag, store, policy_dict=dict(
read=['NONE'], write=['NONE'], create=['NONE'],
delete=['NONE'], manage=['NONE']))
def done(args):
"""Move a to do item to the done bag."""
store = get_store(global_config)
do_bag_name = 'do'
done_bag_name ='done'
bag = ensure_bag(done_bag_name, store)
title = ' '.join(args)
tiddler = Tiddler(title, do_bag_name)
tiddler = store.get(tiddler)
store.delete(tiddler)
tiddler.bag = done_bag_name
store.put(tiddler)
def init(config):
"""
Initialize the plugin: setting up necessary defaults and globals.
"""
global CACHE
config['special_bag_detectors'].append(is_remote)
HOOKS['recipe']['put'].append(recipe_change_hook)
if config.get('remotebag.use_memcache'):
import memcache
CACHE = memcache.Client(config.get('memcache_hosts',
['127.0.0.1:11211']))
else:
path = config.get('remotebag.cache_dir', '.cache')
if not os.path.isabs(path):
path = os.path.join(config.get('root_dir', ''), path)
CACHE = path
store = get_store(config)
policy = dict(manage=['NONE'], read=['NONE'], write=['NONE'],
create=['NONE'], accept=['NONE'])
ensure_bag(REMOTEURI_BAG, store, policy_dict=policy)
def _make_mapping_tiddler(environ, uri):
"""
Create and store the tiddler that will persist the mapping.
"""
store = environ['tiddlyweb.store']
try:
mapping_bag = ensure_bag(MAPPING_BAG, store, policy_dict=POLICY)
title_uuid = '%s' % uuid.uuid4()
tiddler = Tiddler(title_uuid, mapping_bag.name)
tiddler.fields['uri'] = uri
tiddler.fields['user'] = environ['tiddlyweb.usersign']['name']
store.put(tiddler)
except StoreError, exc:
raise HTTP400('Unable to create mapping: %s' % exc)
def run_tests():
store = get_store(global_config)
start_bag = ensure_bag("test1-start", store)
stop_bag = ensure_bag("test1-stop", store)
store.put(Tiddler("1", "test1-start"))
store.put(Tiddler("2", "test1-stop"))
store.put(Tiddler("3", "test1-start"))
store.put(Tiddler("4", "test1-stop"))
reporttime(["test1"]) # 2
start_bag = ensure_bag("test2-start", store)
stop_bag = ensure_bag("test2-stop", store)
store.put(Tiddler("1", "test2-start"))
store.put(Tiddler("2", "test2-start"))
store.put(Tiddler("5", "test2-stop"))
reporttime(["test2"]) # 4
start_bag = ensure_bag("test3-start", store)
stop_bag = ensure_bag("test3-stop", store)
store.put(Tiddler("1", "test3-start"))
store.put(Tiddler("2", "test3-stop"))
store.put(Tiddler("5", "test3-stop"))
reporttime(["test3"]) # 1
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 ensure_protected_bag(store, username, desc='', name=None):
policy = _protected_policy(username)
if name == None:
name = '%s-protected' % username
return ensure_bag(name, store, policy, description=desc)
def ensure_private_bag(store, username, desc="", name=None):
policy = _private_policy(username)
if name == None:
name = "%s-private" % username
return ensure_bag(name, store, policy, description=desc)
def ensure_private_bag(store, username, desc='', name=None):
policy = _private_policy(username)
if name is None:
name = '%s-private' % username
return ensure_bag(name, store, policy, description=desc)
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 ensure_private_bag(store, username, desc='', name=None):
policy = _private_policy(username)
if name is None:
name = '%s-private' % username
return ensure_bag(name, store, policy, description=desc)
