def _add_item_internally_locked(self, arg):
"""
See _add_item_internally, this is just internal for locked operation.
"""
item, revmeta, revdata, revdata_target, itemmeta = arg
item_id = make_uuid().hex
item_name = item.name
name2id = self._name2id
try:
results = name2id.insert().values(item_id=item_id, item_name=item_name).execute()
except IntegrityError:
raise ItemAlreadyExistsError("Item '%r' already exists!" % item_name)
os.mkdir(self._make_path('meta', item_id))
if revdata is not None:
filesys.rename(revdata, revdata_target)
if revmeta is not None:
rp = self._make_path('meta', item_id, '%d.rev' % 0)
filesys.rename(revmeta, rp)
if itemmeta:
# only write item level metadata file if we have any
mp = self._make_path('meta', item_id, 'item')
f = open(mp, 'wb')
pickle.dump(itemmeta, f, protocol=PICKLEPROTOCOL)
f.close()
item._fs_item_id = item_id
def create_item(self, itemname):
if not isinstance(itemname, (str, unicode)):
raise TypeError("Item names must be of str/unicode type, not %s." % type(itemname))
elif self.has_item(itemname):
raise ItemAlreadyExistsError("An item '%r' already exists!" % itemname)
return Item(self, itemname, _fs_metadata={})
def _rename_item_locked(self, arg):
item, newname = arg
item_id = item._fs_item_id
name2id = self._name2id
try:
results = name2id.update().where(name2id.c.item_id==item_id).values(item_name=newname).execute()
except IntegrityError:
raise ItemAlreadyExistsError("Target item '%r' already exists!" % newname)
def create_item(self, itemname):
"""
@see: Backend.create_item.__doc__
"""
if not isinstance(itemname, (str, unicode)):
raise TypeError("Itemnames must have string type, not %s" % (type(itemname)))
# This 'premature' check is ok since it may take some time until item.commit()
# is invoked and only there can the database raise an IntegrityError if the
# uniqueness-constraint for the item name is violated.
if self.has_item(itemname):
raise ItemAlreadyExistsError("An item with the name %s already exists." % itemname)
item = SQLAItem(self, itemname)
return item
def _publish_item_metadata(self, item):
"""
@see: Backend._publish_item_metadata.__doc__
"""
# XXX This should just be tried and the exception be caught
if item.id is None and self.has_item(item.name):
raise ItemAlreadyExistsError("The Item whose metadata you tried to publish already exists.")
session = self.Session()
session.add(item)
session.commit()
try:
lock = self._item_metadata_lock[item.id]
except KeyError:
# Item hasn't been committed before publish, hence no lock.
pass
else:
lock.release()
def _rename_item(self, item, newname):
"""
@see: Backend._rename_item.__doc__
"""
if item.id is None:
raise AssertionError("Item not yet committed to storage. Cannot be renamed.")
session = self.Session()
item = session.query(SQLAItem).get(item.id)
item._name = newname
# No need to add the item since the session took note that its name was changed
# and so it's in session.dirty and will be changed when committed.
try:
session.commit()
except IntegrityError:
raise ItemAlreadyExistsError("Rename operation failed. There already is " + \
"an item named '%s'." % newname)
finally:
session.close()
def _rename_item_locked(self, arg):
item, newname = arg
nn = newname.encode('utf-8')
npath = os.path.join(self._path, item._fs_item_id, 'name')
c = cdb.init(self._name_db)
maker = cdb.cdbmake(self._name_db + '.ndb', self._name_db + '.tmp')
r = c.each()
while r:
i, v = r
if i == nn:
raise ItemAlreadyExistsError("Target item '%r' already exists!" % newname)
elif v == item._fs_item_id:
maker.add(nn, v)
else:
maker.add(i, v)
r = c.each()
maker.finish()
filesys.rename(self._name_db + '.ndb', self._name_db)
nf = open(npath, mode='wb')
nf.write(nn)
nf.close()
def _commit_item(self, revision):
"""
@see: Backend._commit_item.__doc__
"""
item = revision.item
session = revision.session
# We need to distinguish between different types of uniqueness constraint violations.
# That is why we flush the item first, then we flush the revision and finally we commit.
# Flush would have failed if either of the two was already present (item with the same name
# or revision with the same revno on that item.)
try:
# try to flush item if it's not already persisted
if item.id is None:
session.add(item)
session.flush()
except IntegrityError:
raise ItemAlreadyExistsError("An item with that name already exists.")
except DataError:
raise StorageError("The item's name is too long for this backend. It must be less than %s." % NAME_LEN)
else:
# Flushing of item succeeded. That means we can try to flush the revision.
# Close the item's data container and add potentially pending chunks.
revision._data.close()
session.add(revision)
try:
session.flush()
except IntegrityError:
raise RevisionAlreadyExistsError("A revision with revno %d already exists on the item." \
% (revision.revno))
else:
# Flushing of revision succeeded as well. All is fine. We can now commit()
session.commit()
# After committing, the Item has an id and we can create a metadata lock for it
self._item_metadata_lock[item.id] = Lock()
finally:
session.close()
nn = item.name.encode('utf-8')
c = cdb.init(self._name_db)
maker = cdb.cdbmake(self._name_db + '.ndb', self._name_db + '.tmp')
r = c.each()
while r:
i, v = r
if i == nn:
# Oops. This item already exists! Clean up and error out.
maker.finish()
os.unlink(self._name_db + '.ndb')
os.rmdir(ipath)
if newrev is not None:
os.unlink(newrev)
raise ItemAlreadyExistsError("Item '%r' already exists!" % item.name)
else:
maker.add(i, v)
r = c.each()
maker.add(nn, itemid)
maker.finish()
if newrev is not None:
rp = os.path.join(self._path, itemid, 'rev.0')
filesys.rename(newrev, rp)
if metadata:
# only write metadata file if we have any
meta = os.path.join(self._path, itemid, 'meta')
f = open(meta, 'wb')
pickle.dump(metadata, f, protocol=PICKLEPROTOCOL)
def create_item(self, itemname):
if not isinstance(itemname, (str, unicode)):
raise TypeError("Item names must have string type, not %s" % (type(itemname)))
elif self.has_item(itemname):
raise ItemAlreadyExistsError("An Item with the name %r already exists!" % (itemname))
return Item(self, itemname)
def _rename_item(self, item, newname):
try:
os.rename(self._rev_path(item.name), self._rev_path(newname))
except OSError:
raise ItemAlreadyExistsError('')