def itemAdded(self):
"""
Called to indicate that a new item of the type monitored by this batch
processor is being added to the database.
If this processor is not already scheduled to run, this will schedule
it. It will also start the batch process if it is not yet running and
there are any registered remote listeners.
"""
localCount = self.store.query(
_ReliableListener,
attributes.AND(_ReliableListener.processor == self,
_ReliableListener.style == iaxiom.LOCAL),
limit=1).count()
remoteCount = self.store.query(
_ReliableListener,
attributes.AND(_ReliableListener.processor == self,
_ReliableListener.style == iaxiom.REMOTE),
limit=1).count()
if localCount and self.scheduled is None:
self.scheduled = extime.Time()
iaxiom.IScheduler(self.store).schedule(self, self.scheduled)
if remoteCount:
batchService = iaxiom.IBatchService(self.store, None)
if batchService is not None:
batchService.start()
def removeReliableListener(self, listener):
"""
Remove a previously added listener.
"""
self.store.query(_ReliableListener,
attributes.AND(_ReliableListener.processor == self,
_ReliableListener.listener == listener)).deleteFromStore()
self.store.query(BatchProcessingError,
attributes.AND(BatchProcessingError.processor == self,
BatchProcessingError.listener == listener)).deleteFromStore()
def step(self, style=iaxiom.LOCAL, skip=()):
now = extime.Time()
first = True
for listener in self.store.query(_ReliableListener,
attributes.AND(_ReliableListener.processor == self,
_ReliableListener.style == style,
_ReliableListener.listener.notOneOf(skip)),
sort=_ReliableListener.lastRun.ascending):
if not first:
if VERBOSE:
log.msg("Found more work to do, returning True from %r.step()" % (self,))
return True
listener.lastRun = now
try:
if listener.step():
if VERBOSE:
log.msg("%r.step() reported more work to do, returning True from %r.step()" % (listener, self))
return True
except _NoWorkUnits:
if VERBOSE:
log.msg("%r.step() reported no work units" % (listener,))
else:
first = False
if VERBOSE:
log.msg("No listeners left with work, returning False from %r.step()" % (self,))
return False
def powerupsWithPriorityFor(interface):
for cable in s.query(
item._PowerupConnector,
attributes.AND(item._PowerupConnector.interface == unicode(reflect.qual(interface)),
item._PowerupConnector.item == s),
sort=item._PowerupConnector.priority.descending):
yield cable.powerup, cable.priority
def extractSubStore(self, localpart, domain, destinationPath):
siteStore = self.parent.getStore()
la = siteStore.findFirst(
userbase.LoginMethod,
attributes.AND(userbase.LoginMethod.localpart == localpart,
userbase.LoginMethod.domain == domain)).account
userbase.extractUserStore(la, destinationPath)
def links(self):
d = {}
for t in self.store.query(
objects.Thing,
attributes.AND(Garment.thing == objects.Thing.storeID,
Garment.wearer == self)):
d.setdefault(t.name, []).append(t)
return d
def checkCorrespondents(relation, address):
self.assertEquals(
self.userStore.query(
exmess.Correspondent,
attributes.AND(
exmess.Correspondent.message == msg,
exmess.Correspondent.address == address,
exmess.Correspondent.relation == relation)).count(), 1)
def getExitNamed(self, name, default=_marker):
result = self.store.findUnique(
Exit,
attributes.AND(Exit.fromLocation == self.thing,
Exit.name == name),
default=default)
if result is self._marker:
raise KeyError(name)
return result
def queryMessageSenderPerson(typ):
# having Message.person might speed this up, but it would
# need some kind of notification thing that fires each time
# an email address is associated with a Person item so we
# can update the attribute
sq = MailboxSelector(store)
sq.refineByPerson(person)
return store.query(typ, attributes.AND(
typ.message == exmess.Message.storeID,
sq._getComparison()))
def get_artist_all_tracks(self, start=0, request_count=0):
children = [x[1] for x in list(self.store.query((Album, Track),
attributes.AND(Album.artist == self,
Track.album == Album.storeID),
sort=(Album.title.ascending, Track.track_nr.ascending)
))]
if request_count == 0:
return children[start:]
else:
return children[start:request_count]
def postOptions(self):
for acc in self.store.query(userbase.LoginAccount,
attributes.AND(userbase.LoginAccount.username == self['username'],
userbase.LoginAccount.domain == self['domain'])):
if acc.disabled:
raise usage.UsageError("That account is already disabled.")
else:
acc.disabled = True
break
else:
raise usage.UsageError("No account by that name exists.")
def cancelPersistentSession(self, uid):
username = self._username()
for sess in self.store.parent.query(
websession.PersistentSession,
attributes.AND(
websession.PersistentSession.authenticatedAs == username,
websession.PersistentSession.sessionKey == uid)):
sess.deleteFromStore()
break
else:
raise NoSuchSession()
def getHeaders(self, name, _limit=None):
name = name.lower()
if self.store is not None:
if not isinstance(name, unicode):
name = name.decode("ascii")
return self.store.query(Header,
attributes.AND(Header.part == self,
Header.name == name),
sort=Header.index.ascending,
limit=_limit)
else:
if not hasattr(self, '_headers'):
self._headers = []
return (hdr for hdr in self._headers if hdr.name == name)
def locateChild(self, ctx, segs):
md5 = segs[0]
db = theGlobal["database"]
FM = data.FileMeta
# for now, everyone gets access to everyone else's files
# TODO - implement permissions on files?
_filter = A.AND(FM.md5==unicode(md5))
fileitem = db.findFirst(FM, _filter)
if fileitem is None:
return None, ()
if len(segs) > 1 and segs[1] == 'thumb':
return static.Data(fileitem.thumbnail.data, 'image/png'), ()
else:
mimeType = fileitem.mimeType.encode('utf-8')
return static.Data(fileitem.data.data, mimeType), ()
def show_tracks_by_artist(self, artist_name):
"""
artist = self.db.query(Artist,Artist.name == artist_name)
artist = list(artist)[0]
for album in list(self.db.query(Album, Album.artist == artist)):
for track in list(self.db.query(Track, Track.album == album,sort=Track.title.ascending)):
print track
"""
for track in [x[2] for x in list(self.db.query((Artist, Album, Track),
attributes.AND(Artist.name == artist_name,
Album.artist == Artist.storeID,
Track.album == Album.storeID),
sort=(Track.title.ascending)
))]:
print(track)
def _storeFromUsername(store, username):
"""
Find the user store of the user with username C{store}
@param store: site-store
@type store: L{axiom.store.Store}
@param username: the name a user signed up with
@type username: C{unicode}
@rtype: L{axiom.store.Store} or C{None}
"""
lm = store.findUnique(userbase.LoginMethod,
attributes.AND(
userbase.LoginMethod.localpart == username,
userbase.LoginMethod.internal == True),
default=None)
if lm is not None:
return lm.account.avatars.open()
def addReliableListener(self, listener, style=iaxiom.LOCAL):
"""
Add the given Item to the set which will be notified of Items
available for processing.
Note: Each Item is processed synchronously. Adding too many
listeners to a single batch processor will cause the L{step}
method to block while it sends notification to each listener.
@param listener: An Item instance which provides a
C{processItem} method.
@return: An Item representing L{listener}'s persistent tracking state.
"""
existing = self.store.findUnique(
_ReliableListener,
attributes.AND(_ReliableListener.processor == self,
_ReliableListener.listener == listener),
default=None)
if existing is not None:
return existing
for work in self.store.query(self.workUnitType,
sort=self.workUnitType.storeID.descending,
limit=1):
forwardMark = work.storeID
backwardMark = work.storeID + 1
break
else:
forwardMark = 0
backwardMark = 0
if self.scheduled is None:
self.scheduled = extime.Time()
iaxiom.IScheduler(self.store).schedule(self, self.scheduled)
return _ReliableListener(store=self.store,
processor=self,
listener=listener,
forwardMark=forwardMark,
backwardMark=backwardMark,
style=style)
def findExisting(cls, message, extractedText):
return message.store.findUnique(cls,
attributes.AND(cls.text == extractedText,
cls.message == Message.storeID,
Message.sender == message.sender),
default=None)
def getSubPart(self, partID):
return self.store.findUnique(
Part, attributes.AND(Part.parent == self, Part.partID == partID))
