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 :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 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
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 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)