def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400('unable to put bag: %s' % exc)
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
bag = store.get(bag)
bag.policy.allows(usersign, "manage")
except NoBagError:
create_policy_check(environ, "bag", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
bag.policy.owner = usersign["name"]
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400("unable to put bag: %s" % exc)
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400('unable to put bag: %s' % exc)
def put(environ, start_response):
"""
Handle ``PUT`` on a single recipe URI.
Put a :py:class:`recipe <tiddlyweb.model.recipe.Recipe>` to the server,
meaning the description, policy and recipe list of the recipe,
if :py:class:`policy <tiddlyweb.model.policy.Policy>` allows.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError as exc:
raise HTTP400('unable to put recipe: %s' % exc)
except TypeError as exc:
raise HTTP400('malformed input: %s' % exc)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Handle ``PUT`` on a single recipe URI.
Put a :py:class:`recipe <tiddlyweb.model.recipe.Recipe>` to the server,
meaning the description, policy and recipe list of the recipe,
if :py:class:`policy <tiddlyweb.model.policy.Policy>` allows.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError as exc:
raise HTTP400('unable to put recipe: %s' % exc)
except TypeError as exc:
raise HTTP400('malformed input: %s' % exc)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def test_create_policy_check():
no_environ = {'tiddlyweb.config':{'bag_create_policy':''}}
all_environ = {'tiddlyweb.config':{'recipe_create_policy':''}}
any_environ = {'tiddlyweb.config':{'recipe_create_policy':'ANY'}}
admin_environ = {'tiddlyweb.config':{'recipe_create_policy':'ADMIN'}}
weird_environ = {'tiddlyweb.config':{'recipe_create_policy':'WEIRD'}}
py.test.raises(ForbiddenError, 'create_policy_check(no_environ, "recipe", chris_info)')
assert create_policy_check(all_environ, "recipe", chris_info)
assert create_policy_check(any_environ, "recipe", chris_info)
py.test.raises(UserRequiredError, 'create_policy_check(any_environ, "recipe", {"name":"GUEST"})')
assert create_policy_check(admin_environ, "recipe", chris_info)
py.test.raises(ForbiddenError, 'create_policy_check(admin_environ, "recipe", jeremy_info)')
py.test.raises(ForbiddenError, 'create_policy_check(admin_environ, "recipe", roller_info)')
py.test.raises(ForbiddenError, 'create_policy_check(weird_environ, "recipe", jeremy_info)')
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
bag.skinny = True
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
try:
delattr(bag, 'skinny')
except AttributeError:
pass
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content",
[('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Handle ``PUT`` on a single bag URI.
Put a :py:class:`bag <tiddlyweb.model.bag.Bag>` to the server,
meaning the description and policy of the bag, if :py:class:`policy
<tiddlyweb.model.policy.Policy>` allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError as exc:
raise HTTP400('unable to put bag: %s' % exc)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content",
[('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Handle ``PUT`` on a single bag URI.
Put a :py:class:`bag <tiddlyweb.model.bag.Bag>` to the server,
meaning the description and policy of the bag, if :py:class:`policy
<tiddlyweb.model.policy.Policy>` allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError as exc:
raise HTTP400('unable to put bag: %s' % exc)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content", [('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ["wsgiorg.routing_args"][1]["recipe_name"]
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, "utf-8")
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, "manage")
except NoRecipeError:
create_policy_check(environ, "recipe", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
recipe.policy.owner = usersign["name"]
_validate_recipe(environ, recipe)
store.put(recipe)
except TypeError:
raise HTTP400("Content-type header required")
except NoSerializationError:
raise HTTP415("Content type %s not supported" % serialize_type)
start_response("204 No Content", [("Location", web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
bag.skinny = True
bag = store.get(bag)
bag.policy.allows(usersign, "manage")
delattr(bag, "skinny")
except NoBagError:
create_policy_check(environ, "bag", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
bag.policy.owner = usersign["name"]
store.put(bag)
except NoSerializationError:
raise HTTP415("Content type not supported: %s" % serialize_type)
start_response("204 No Content", [("Location", web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('UTF-8'))
store.put(recipe)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)
def test_create_policy_check():
no_environ = {'tiddlyweb.config': {'bag_create_policy': ''}}
all_environ = {'tiddlyweb.config': {'recipe_create_policy': ''}}
any_environ = {'tiddlyweb.config': {'recipe_create_policy': 'ANY'}}
admin_environ = {'tiddlyweb.config': {'recipe_create_policy': 'ADMIN'}}
weird_environ = {'tiddlyweb.config': {'recipe_create_policy': 'WEIRD'}}
py.test.raises(ForbiddenError,
'create_policy_check(no_environ, "recipe", chris_info)')
assert create_policy_check(all_environ, "recipe", chris_info)
assert create_policy_check(any_environ, "recipe", chris_info)
py.test.raises(
UserRequiredError,
'create_policy_check(any_environ, "recipe", {"name":"GUEST"})')
assert create_policy_check(admin_environ, "recipe", chris_info)
py.test.raises(
ForbiddenError,
'create_policy_check(admin_environ, "recipe", jeremy_info)')
py.test.raises(
ForbiddenError,
'create_policy_check(admin_environ, "recipe", roller_info)')
py.test.raises(
ForbiddenError,
'create_policy_check(weird_environ, "recipe", jeremy_info)')
