def _write_policy(self, policy, base_path):
policy_dict = {}
for key in Policy.attributes:
policy_dict[key] = getattr(policy, key)
json = simplejson.dumps(policy_dict)
policy_path = self._policy_path(base_path)
write_utf8_file(policy_path, json)
def _write_policy(self, policy, bag_path):
"""
Write the policy of a bad to disk.
"""
policy_dict = {}
for key in Policy.attributes:
policy_dict[key] = policy.__getattribute__(key)
policy_string = simplejson.dumps(policy_dict)
policy_filename = os.path.join(bag_path, 'policy')
write_utf8_file(policy_filename, policy_string)
def recipe_put(self, recipe):
"""
Put a recipe into the store.
"""
try:
recipe_path = self._recipe_path(recipe)
self.serializer.object = recipe
write_utf8_file(recipe_path, self.serializer.to_string())
except StoreEncodingError, exc:
raise NoRecipeError(exc)
def _write_policy(self, policy, bag_path):
"""
Write the policy of a bad to disk.
"""
policy_dict = {}
for key in ['read', 'write', 'create', 'delete', 'manage', 'owner']:
policy_dict[key] = policy.__getattribute__(key)
policy_string = simplejson.dumps(policy_dict)
policy_filename = os.path.join(bag_path, 'policy')
write_utf8_file(policy_filename, policy_string)
def tiddler_put(self, tiddler):
logging.debug("put tiddler %s" % tiddler)
tiddler_path = self._tiddler_path(tiddler)
tiddler.revision = 1
self.serializer.object = tiddler
write_utf8_file(tiddler_path, self.serializer.to_string())
self.tiddler_written(tiddler)
def recipe_put(self, recipe):
"""
Put a recipe into the store.
"""
try:
recipe_path = self._recipe_path(recipe)
self.serializer.object = recipe
write_utf8_file(recipe_path, self.serializer.to_string())
except StoreEncodingError, exc:
raise NoRecipeError(exc)
def _write_policy(self, policy, bag_path):
"""
Write the policy of a bad to disk.
"""
policy_dict = {}
for key in Policy.attributes:
policy_dict[key] = policy.__getattribute__(key)
policy_string = simplejson.dumps(policy_dict)
policy_filename = os.path.join(bag_path, 'policy')
write_utf8_file(policy_filename, policy_string)
def recipe_put(self, recipe):
"""
Put :py:class:`recipe <tiddlyweb.model.recipe.Recipe>`
into the store.
"""
try:
recipe_path = self._recipe_path(recipe)
self.serializer.object = recipe
write_utf8_file(recipe_path, self.serializer.to_string())
except StoreEncodingError as exc:
raise NoRecipeError(exc)
def recipe_put(self, recipe):
"""
Put :py:class:`recipe <tiddlyweb.model.recipe.Recipe>`
into the store.
"""
try:
recipe_path = self._recipe_path(recipe)
self.serializer.object = recipe
write_utf8_file(recipe_path, self.serializer.to_string())
except StoreEncodingError as exc:
raise NoRecipeError(exc)
def user_put(self, user):
logging.debug("put user %s" % user.usersign)
user_path = self._user_path(user)
user_dict = {}
for key in ["usersign", "note", "_password", "roles"]:
value = user.__getattribute__(key)
if key == "roles":
user_dict[key] = list(value)
else:
if key == "_password": # XXX: ???
key = "password"
user_dict[key] = value
user_info = simplejson.dumps(user_dict, indent=0)
write_utf8_file(user_path, user_info)
def user_put(self, user):
"""
Put :py:class:`user <tiddlyweb.model.user.User>` data into the store.
"""
user_path = self._user_path(user)
user_dict = {}
for key in ['usersign', 'note', '_password', 'roles']:
value = user.__getattribute__(key)
if key == 'roles':
user_dict[key] = list(value)
continue
if key == '_password':
key = 'password'
user_dict[key] = value
user_info = simplejson.dumps(user_dict, indent=0)
write_utf8_file(user_path, user_info)
def user_put(self, user):
"""
Put :py:class:`user <tiddlyweb.model.user.User>` data into the store.
"""
user_path = self._user_path(user)
user_dict = {}
for key in ['usersign', 'note', '_password', 'roles']:
value = user.__getattribute__(key)
if key == 'roles':
user_dict[key] = list(value)
continue
if key == '_password':
key = 'password'
user_dict[key] = value
user_info = simplejson.dumps(user_dict, indent=0)
write_utf8_file(user_path, user_info)
def user_put(self, user):
"""
Put a user data into the store.
The user's information is store as JSON,
for ease.
"""
user_path = self._user_path(user)
user_dict = {}
for key in ['usersign', 'note', '_password', 'roles']:
value = user.__getattribute__(key)
if key == 'roles':
user_dict[key] = list(value)
continue
if key == '_password':
key = 'password'
user_dict[key] = value
user_info = simplejson.dumps(user_dict, indent=0)
write_utf8_file(user_path, user_info)
def user_put(self, user):
"""
Put a user data into the store.
The user's information is store as JSON,
for ease.
"""
user_path = self._user_path(user)
user_dict = {}
for key in ['usersign', 'note', '_password', 'roles']:
value = user.__getattribute__(key)
if key == 'roles':
user_dict[key] = list(value)
continue
if key == '_password':
key = 'password'
user_dict[key] = value
user_info = simplejson.dumps(user_dict, indent=0)
write_utf8_file(user_path, user_info)
def tiddler_put(self, tiddler):
"""
Write a :py:class:`tiddler <tiddlyweb.model.tiddler.Tiddler>`
into the store. We only write if the tiddler's :py:class:`bag
<tiddlyweb.model.bag.Bag>` already exists. Bag creation is a
separate action.
"""
tiddler_base_filename = self._tiddler_base_filename(tiddler)
if not os.path.exists(tiddler_base_filename):
try:
os.mkdir(tiddler_base_filename)
except OSError as exc:
raise NoTiddlerError('unable to put tiddler: %s' % exc)
locked = 0
lock_attempts = 0
while not locked:
try:
lock_attempts = lock_attempts + 1
write_lock(tiddler_base_filename)
locked = 1
except LockError as exc:
if lock_attempts > 4:
raise StoreLockError(exc)
time.sleep(.1)
# Protect against incoming tiddlers that have revision
# set. Since we are putting a new one, we want the system
# to calculate.
tiddler.revision = None
revision = self._tiddler_revision_filename(tiddler) + 1
tiddler_filename = self._tiddler_full_filename(tiddler, revision)
representation = self.serializer.serialization.tiddler_as(tiddler,
omit_empty=True, omit_members=['creator'])
write_utf8_file(tiddler_filename, representation)
write_unlock(tiddler_base_filename)
tiddler.revision = revision
def tiddler_put(self, tiddler):
"""
Write a :py:class:`tiddler <tiddlyweb.model.tiddler.Tiddler>`
into the store. We only write if the tiddler's :py:class:`bag
<tiddlyweb.model.bag.Bag>` already exists. Bag creation is a
separate action.
"""
tiddler_base_filename = self._tiddler_base_filename(tiddler)
if not os.path.exists(tiddler_base_filename):
try:
os.mkdir(tiddler_base_filename)
except OSError as exc:
raise NoTiddlerError('unable to put tiddler: %s' % exc)
locked = 0
lock_attempts = 0
while not locked:
try:
lock_attempts = lock_attempts + 1
write_lock(tiddler_base_filename)
locked = 1
except LockError as exc:
if lock_attempts > 4:
raise StoreLockError(exc)
time.sleep(.1)
# Protect against incoming tiddlers that have revision
# set. Since we are putting a new one, we want the system
# to calculate.
tiddler.revision = None
revision = self._tiddler_revision_filename(tiddler) + 1
tiddler_filename = self._tiddler_full_filename(tiddler, revision)
representation = self.serializer.serialization.tiddler_as(tiddler,
omit_empty=True, omit_members=['creator'])
write_utf8_file(tiddler_filename, representation)
write_unlock(tiddler_base_filename)
tiddler.revision = revision
write_lock(tiddler_base_filename)
locked = 1
except LockError, exc:
if lock_attempts > 4:
raise StoreLockError(exc)
time.sleep(.1)
# Protect against incoming tiddlers that have revision
# set. Since we are putting a new one, we want the system
# to calculate.
tiddler.revision = None
revision = self._tiddler_revision_filename(tiddler) + 1
tiddler_filename = self._tiddler_full_filename(tiddler, revision)
self.serializer.object = tiddler
write_utf8_file(tiddler_filename, self.serializer.to_string())
write_unlock(tiddler_base_filename)
tiddler.revision = revision
def user_delete(self, user):
"""
Delete a user from the store.
"""
try:
user_path = self._user_path(user)
if not os.path.exists(user_path):
raise NoUserError('%s not present' % user_path)
os.unlink(user_path)
except NoUserError:
raise
except Exception, exc:
def cache_tiddlers(package_name):
"""
creates local cache of instance tiddlers to be included in distribution
reads store_contents from <package>.instance
tiddler files are stored in <package>/resources/<bag>
a complete index is stored in <package>/resources
"""
instance_module = __import__("%s.instance" % package_name, None, None,
["instance"]) # XXX: unnecessarily convoluted and constraining!?
store_contents = instance_module.store_contents
package_path = os.path.join(*package_name.split("."))
sources = {}
for bag, uris in store_contents.items():
sources[bag] = []
for uri in uris:
if uri.endswith(".recipe"):
urls = recipe_to_urls(uri)
sources[bag].extend(urls)
else:
sources[bag].append(uri)
metas = []
for uri in sources[bag]:
metas.append("%s.meta" % uri)
sources[bag].extend(metas)
resources_path = os.path.join(package_path, "resources")
try:
os.mkdir(resources_path)
except OSError: # directory exists
pass
for bag, uris in sources.items():
bag_path = os.path.join(resources_path, bag)
try:
os.mkdir(bag_path)
except OSError: # directory exists
pass
for uri in uris:
filepath = os.path.join(bag_path, os.path.basename(uri))
std_error_message("retrieving %s" % uri)
try: # XXX: duplication of tiddlywebplugins.twimport._get_url_handle
try:
content = urlopen(uri).read()
except (URLError, OSError):
scheme, netloc, path, params, query, fragment = urlparse.urlparse(uri)
path = quote(path)
uri = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
content = urlopen(uri).read()
try:
content = unicode(content, "utf-8")
write_utf8_file(filepath, content)
except UnicodeDecodeError: # assume binary
f = open(filepath, "wb")
f.write(content)
f.close()
except (URLError, OSError):
if uri.endswith(".meta"):
std_error_message("no meta file found for %s" % uri[:-5])
else:
raise
tiddler_index = "tiddlers.index"
tiddler_paths = []
for base_dir, dirs, files in os.walk(resources_path):
bag = os.path.basename(base_dir)
if bag in store_contents:
filepaths = (os.path.join(bag, filename) for filename in files
if not filename.endswith(".meta") and not filename == tiddler_index)
tiddler_paths.extend(filepaths)
filepath = "/".join([resources_path, tiddler_index])
std_error_message("creating %s" % filepath)
write_utf8_file(filepath, "\n".join(tiddler_paths))
locked = 1
except LockError, exc:
if lock_attempts > 4:
raise StoreLockError(exc)
time.sleep(.1)
# Protect against incoming tiddlers that have revision
# set. Since we are putting a new one, we want the system
# to calculate.
tiddler.revision = None
revision = self._tiddler_revision_filename(tiddler) + 1
tiddler_filename = self._tiddler_full_filename(tiddler, revision)
representation = self.serializer.serialization.tiddler_as(tiddler,
omit_empty=True, omit_members=['creator'])
write_utf8_file(tiddler_filename, representation)
write_unlock(tiddler_base_filename)
tiddler.revision = revision
def user_delete(self, user):
"""
Delete a user from the store.
"""
try:
user_path = self._user_path(user)
if not os.path.exists(user_path):
raise NoUserError('%s not present' % user_path)
os.unlink(user_path)
except NoUserError:
raise
def _write_bag_description(self, desc, bag_path):
"""
Write the description of a bag to disk.
"""
desc_filename = os.path.join(bag_path, 'description')
write_utf8_file(desc_filename, desc)
def _write_bag_description(self, desc, bag_path):
"""
Write the description of a bag to disk.
"""
desc_filename = os.path.join(bag_path, 'description')
write_utf8_file(desc_filename, desc)
def recipe_put(self, recipe):
logging.debug("put recipe %s" % recipe.name)
recipe_path = self._recipe_path(recipe)
self.serializer.object = recipe
write_utf8_file(recipe_path, self.serializer.to_string())
def _write_description(self, desc, base_path): desc_path = self._description_path(base_path) write_utf8_file(desc_path, desc)
write_lock(tiddler_base_filename)
locked = 1
except LockError, exc:
if lock_attempts > 4:
raise StoreLockError(exc)
time.sleep(.1)
# Protect against incoming tiddlers that have revision
# set. Since we are putting a new one, we want the system
# to calculate.
tiddler.revision = None
revision = self._tiddler_revision_filename(tiddler) + 1
tiddler_filename = self._tiddler_full_filename(tiddler, revision)
self.serializer.object = tiddler
write_utf8_file(tiddler_filename, self.serializer.to_string())
write_unlock(tiddler_base_filename)
tiddler.revision = revision
def user_delete(self, user):
"""
Delete a user from the store.
"""
try:
user_path = self._user_path(user)
if not os.path.exists(user_path):
raise NoUserError('%s not present' % user_path)
os.unlink(user_path)
except NoUserError:
raise
except Exception, exc:
