class TestHash(unittest.TestCase):
def setUp(self):
self.growl = GrowlNotifier("GNTP unittest", ["Testing"])
self.growl.register()
def test_lines(self):
for priority in [2, 1, 0, -1, -2]:
msg = "Priority %s" % priority
self.growl.notify("Testing", msg, msg, priority=priority)
class TestHash(unittest.TestCase):
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
def test_lines(self):
for priority in [2, 1, 0, -1, -2]:
msg = 'Priority %s' % priority
self.growl.notify('Testing', msg, msg, priority=priority)
class Notifier(object):
def __init__(self, app_name="autocheck"):
self.growl = GrowlNotifier(
applicationName=app_name, notifications=["New Message"], defaultNotifications=["New Message"]
)
self.growl.register()
def notify(self, title, description, kind="pass", sticky=False):
icon = open(join(dirname(__file__), "images", kind + ".png"), "rb").read()
self.growl.notify(noteType="New Message", title=title, description=description, icon=icon, sticky=sticky)
class TestHash(unittest.TestCase):
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
self.dir = os.path.dirname(__file__)
self.file = os.path.join(self.dir, 'test_lines.txt')
def test_lines(self):
for line in open(self.file):
self.growl.notify('Testing', 'Line', line)
class TestHash(unittest.TestCase):
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
self.dir = os.path.dirname(__file__)
self.file = os.path.join(self.dir, 'test_lines.txt')
def test_lines(self):
for line in open(self.file):
self.growl.notify('Testing', 'Line', line)
class Notifier(object):
def __init__(self, app_name='autorestart'):
self.growl = GrowlNotifier(applicationName=app_name,
notifications=['New Message'],
defaultNotifications=['New Message'])
self.growl.register()
def notify(self, title, description, sticky=False):
self.growl.notify(
noteType='New Message',
title=title,
description=description,
sticky=sticky,
)
class Notifier(object):
def __init__(self, app_name='autocheck'):
self.growl = GrowlNotifier(applicationName=app_name,
notifications=['New Message'],
defaultNotifications=['New Message'])
self.growl.register()
def notify(self, title, description, kind='pass', sticky=False):
icon = open(join(dirname(__file__), 'images', kind + '.png'),
'rb').read()
self.growl.notify(
noteType='New Message',
title=title,
description=description,
icon=icon,
sticky=sticky,
)
def bark(message, host, password):
growl = GrowlNotifier(applicationName=NAME,
notifications=[NOTIFIER],
defaultNotifications=[NOTIFIER],
hostname=host,
port='23053',
password=password)
growl.register()
growl.notify(
noteType=NOTIFIER,
title=TITLE,
description=message,
icon=ICON_URL,
sticky=False,
priority=1,
)
def bark(message, host, password):
growl = GrowlNotifier(
applicationName = NAME,
notifications = [NOTIFIER],
defaultNotifications = [NOTIFIER],
hostname = host,
port = '23053',
password = password
)
growl.register()
growl.notify(
noteType = NOTIFIER,
title = TITLE,
description = message,
icon = ICON_URL,
sticky = False,
priority = 1,
)
def test_client(config, options):
logging.basicConfig(level=options.verbose)
notifier = GrowlNotifier(hostname=config.get('regrowl.server', 'hostname',
'127.0.0.1'),
port=config.getint('regrowl.server', 'port'),
password=config.get('regrowl.server', 'password'),
notifications=['Test'])
if options.test in ['registration', 'all']:
notifier.register()
if options.test in ['notification', 'all']:
notifier.notify(
noteType='Test',
title='Testing',
description='ReGrowl Test',
)
if options.test in ['subscription', 'all']:
notifier.subscribe(
'TestId',
'TestName',
1337,
)
def test_client(config, options):
logging.basicConfig(level=options.verbose)
notifier = GrowlNotifier(
hostname=config.get('regrowl.server', 'hostname', '127.0.0.1'),
port=config.getint('regrowl.server', 'port'),
password=config.get('regrowl.server', 'password'),
notifications=['Test']
)
if options.test in ['registration', 'all']:
notifier.register()
if options.test in ['notification', 'all']:
notifier.notify(
noteType='Test',
title='Testing',
description='ReGrowl Test',
)
if options.test in ['subscription', 'all']:
notifier.subscribe(
'TestId',
'TestName',
1337,
)
class TestHash(unittest.TestCase):
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
def test_english(self):
self.growl.notify('Testing','Testing','Hello')
def test_extra(self):
self.growl.notify('Testing','Testing','allô')
def test_japanese(self):
self.growl.notify('Testing','Testing',u'おはおう')
def main():
(options, message) = ClientParser().parse_args()
logging.basicConfig(level=options.verbose)
if not os.path.exists(DEFAULT_CONFIG):
logging.info('No config read found at %s', DEFAULT_CONFIG)
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
)
result = growl.register()
if result is not True:
exit(result)
# This would likely be better placed within the growl notifier
# class but until I make _checkIcon smarter this is "easier"
if options.icon and growl._checkIcon(options.icon) is False:
logging.info('Loading image %s', options.icon)
f = open(options.icon, 'rb')
options.icon = f.read()
f.close()
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
callback=options.callback,
identifier=options.identifier,
)
if result is not True:
exit(result)
def main():
(options, message) = ClientParser().parse_args()
logging.basicConfig(level=options.verbose)
if not os.path.exists(DEFAULT_CONFIG):
logging.info('No config read found at %s', DEFAULT_CONFIG)
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
)
result = growl.register()
if result is not True:
exit(result)
# This would likely be better placed within the growl notifier
# class but until I make _checkIcon smarter this is "easier"
if options.icon is not None and not options.icon.startswith('http'):
logging.info('Loading image %s', options.icon)
f = open(options.icon)
options.icon = f.read()
f.close()
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
callback=options.callback,
identifier=options.identifier,
)
if result is not True:
exit(result)
def send_gntp_notification(self):
growl_ips = self.growl_ips
gntp_ips = self.gntp_ips
# don't send to gntp if we can use growl
gntp_ips = [ip for ip in gntp_ips if (ip not in growl_ips)]
for ip in gntp_ips:
growl = GrowlNotifier(
applicationName = 'Doorbell',
notifications = ['doorbell'],
defaultNotifications = ['doorbell'],
hostname = ip,
password = self.password,
)
result = growl.register()
if not result:
continue
result = growl.notify(
noteType = 'doorbell',
title = self.title,
description = self.description,
sticky = True,
)
def send_gntp_notification(self):
growl_ips = self.growl_ips
gntp_ips = self.gntp_ips
# don't send to gntp if we can use growl
gntp_ips = [ip for ip in gntp_ips if (ip not in growl_ips)]
for ip in gntp_ips:
growl = GrowlNotifier(
applicationName='Doorbell',
notifications=['doorbell'],
defaultNotifications=['doorbell'],
hostname=ip,
password=self.password,
)
result = growl.register()
if not result:
continue
result = growl.notify(
noteType='doorbell',
title=self.title,
description=self.description,
sticky=True,
)
def main():
(options, message) = ClientParser().parse_args()
logging.basicConfig(level=options.verbose)
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
)
result = growl.register()
if result is not True:
exit(result)
# This would likely be better placed within the growl notifier
# class but until I make _checkIcon smarter this is "easier"
if options.icon is not None and not options.icon.startswith("http"):
logging.info("Loading image %s", options.icon)
f = open(options.icon)
options.icon = f.read()
f.close()
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
callback=options.callback,
identifier=options.identifier,
)
if result is not True:
exit(result)
else:
info[u'lovedIcon'] = u''
# Set the cover art to the program icon when it's missing.
if len(info[u'coverArt']) == 0:
info[u'coverArt'] = info[u'programIcon']
try:
if argc < 1:
sys.exit(1)
elif argv[1] == u'songstart' and NOTIFY_SONG_START:
growl.notify(
noteType=u'Song Start',
icon=info[u'coverArt'],
title=u'{0}{1}'.format(
info[u'title'],
info[u'lovedIcon']),
description=u'{0}\n{1}'.format(
info[u'artist'],
info[u'album']))
elif argv[1] == u'songfinish' and NOTIFY_SONG_END:
growl.notify(
noteType=u'Song End',
icon=info[u'coverArt'],
title=u'{0}{1}'.format(
info[u'title'],
info[u'lovedIcon']),
description=u'{0}\n{1}'.format(
info[u'artist'],
info[u'album']))
elif argv[1] == u'songlove' and NOTIFY_SONG_LOVE:
if values.title == '':
values.title = message[:20]
return values, message
if __name__ == "__main__":
(options,message) = ClientParser('~/.gntp').parse_args()
growl = GrowlNotifier(
applicationName = options.app,
notifications = [options.name],
defaultNotifications = [options.name],
hostname = options.host,
password = options.password,
port = options.port,
debug = options.debug,
)
result = growl.register()
if result is not True: exit(result)
result = growl.notify(
noteType = options.name,
title = options.title,
description = message,
icon = options.icon,
sticky = options.sticky,
priority = options.priority,
)
if result is not True: exit(result)
class NotifyGrowl(NotifyBase):
"""
A wrapper to Growl Notifications
"""
def __init__(self, priority=GrowlPriority.NORMAL, version=2, **kwargs):
"""
Initialize Growl Object
"""
super(NotifyGrowl, self).__init__(title_maxlen=250,
body_maxlen=32768,
image_size=GROWL_IMAGE_XY,
notify_format=NotifyFormat.TEXT,
**kwargs)
# A Global flag that tracks registration
self.is_registered = False
if not self.port:
self.port = GROWL_UDP_PORT
# The Priority of the message
if priority not in GROWL_PRIORITIES:
self.priority = GrowlPriority.NORMAL
else:
self.priority = priority
# Always default the sticky flag to False
self.sticky = False
# Store Version
self.version = version
payload = {
'applicationName': self.app_id,
'notifications': [
GROWL_NOTIFICATION_TYPE,
],
'defaultNotifications': [
GROWL_NOTIFICATION_TYPE,
],
'hostname': self.host,
'port': self.port,
}
if self.password is not None:
payload['password'] = self.password
self.logger.debug('Growl Registration Payload: %s' % str(payload))
self.growl = GrowlNotifier(**payload)
try:
self.growl.register()
# Toggle our flag
self.is_registered = True
self.logger.debug(
'Growl server registration completed successfully.')
except GrowlNetworkError:
self.logger.warning(
'A network error occured sending Growl ' + \
'notification to %s.' % (
self.host,
))
return
except GrowlAuthenticationError:
self.logger.warning(
'An authentication error occured sending Growl ' + \
'notification to %s.' % (
self.host,
))
return
return
def _notify(self, title, body, notify_type, **kwargs):
"""
Perform Growl Notification
"""
if not self.is_registered:
# We can't do anything
return None
icon = None
if self.include_image:
if self.version >= 2:
# URL Based
icon = self.image_url(notify_type)
else:
# Raw
icon = self.image_raw(notify_type)
payload = {
'noteType': GROWL_NOTIFICATION_TYPE,
'title': title,
'description': body,
'icon': icon is not None,
'sticky': False,
'priority': self.priority,
}
self.logger.debug('Growl Payload: %s' % str(payload))
# Update icon of payload to be raw data
payload['icon'] = icon
try:
response = self.growl.notify(**payload)
if not isinstance(response, bool):
self.logger.warning(
'Growl notification failed to send with response: %s' % \
str(response),
)
else:
self.logger.debug('Growl notification sent successfully.')
except GrowlNetworkError as e:
# Since Growl servers listen for UDP broadcasts,
# it's possible that you will never get to this part
# of the code since there is no acknowledgement as to
# whether it accepted what was sent to it or not.
# however, if the host/server is unavailable, you will
# get to this point of the code.
self.logger.warning(
'A Connection error occured sending Growl ' + \
'notification to %s.' % (
self.host,
))
self.logger.debug('Growl Exception: %s' % str(e))
# Return; we're done
return False
return True
class StackOverflowFetcher:
def __init__(self):
self.base_url = 'http://stackoverflow.com/questions/tagged/'
self.get_or_create_database()
self.growl = GrowlNotifier(
applicationName='StackOverflowChecker',
notifications=['new'],
)
self.growl.register()
self.tags = [('django', True), ('python', False)]
self.get_questions()
self.close_connection()
def get_questions(self):
"""
Parse target URL for new questions.
"""
while self.tags:
tag, sticky = self.tags.pop()
url = self.base_url + tag
html = urllib2.urlopen(url).read()
soup = BeautifulSoup.BeautifulSoup(html)
questions = soup.findAll('h3')
for question in questions:
element = question.find('a')
link = element.get('href')
question = element.text
if self.is_new_link(link):
self.growl.notify(
noteType="new",
title=question,
description=question,
icon="http://example.com/icon.png",
sticky=sticky,
priority=1,
callback='http://stackoverflow.com{0}'.format(link),
)
self.record_question(link, question)
def get_or_create_database(self):
"""
Check if database file exists. Create if not.
Open file and send query.
If query fails, create tables.
"""
path = os.path.join(os.path.dirname(__file__), 'questions.db')
try:
f = open(path)
except IOError:
f = open(path, 'w')
f.close()
self.conn = sqlite3.connect(path)
try:
self.conn.execute('SELECT * from questions')
except sqlite3.OperationalError:
self.create_database()
def create_database(self):
self.conn.execute(
'CREATE TABLE questions(link VARCHAR(400), text VARCHAR(300));')
def is_new_link(self, link):
results = self.conn.execute(
'SELECT * FROM questions WHERE questions.link = "%s";' %
link).fetchall()
if not results:
return True
return False
def record_question(self, link, question):
results = self.conn.execute(
'INSERT INTO questions(link, text) VALUES ("%s", "%s");' %
(link, question))
def close_connection(self):
self.conn.commit()
self.conn.close()
cover_art = program_icon
if len(info['coverArt']) > 0:
cover_art = info[u'coverArt']
try:
if argc < 1:
sys.exit(1)
elif event == u'songstart':
if LASTFM_NOW_PLAYING:
network.update_now_playing(artist = artist, album = album, title = title, duration = song_duration)
if NOTIFY_SONG_START:
growl.notify(
noteType=u'Song Start',
icon=cover_art,
title=u'{0}{1}'.format(
title,
loved_icon),
description=u'{0}\n{1}'.format(
artist,
album))
elif event == u'songfinish':
if LASTFM_SCROBBLE and song_duration > 1000*MIN_DURATION and (100.0 * song_played / song_duration > THRESHOLD or song_played > 1000*PLAYED_ENOUGH):
song_started = int(time.time() - song_played / 1000.0)
network.scrobble(artist = artist, title = title, timestamp = song_started)
if (LASTFM_LOVE or LASTFM_BAN) and rating > 0:
track = network.get_track(artist, title)
if LASTFM_LOVE and rating == 1:
track.love()
elif LASTFM_BAN and rating == 2:
track.ban()
if NOTIFY_SONG_END:
dest='password',
default=None)
self.add_option('-A','--appname',
help='GNTP Application Name',
dest='app',
default=APPLICATION_NAME)
self.add_option('-v',dest='debug',
help='Print Debugging to stderr',
action='store_true',
default=False)
if __name__ == "__main__":
signal.signal(signal.SIGINT, signal_exit)
parser = Parser()
(options, args) = parser.parse_args()
growl = GrowlNotifier(
applicationName = options.app,
notifications = [NOTIFICATION_NAME],
hostname = options.host,
password = options.password,
port = options.port,
debug = options.debug,
)
growl.register()
while( True ):
line = sys.stdin.readline()
if not line: break
sys.stdout.write(line)
growl.notify(NOTIFICATION_NAME,NOTIFICATION_NAME,line)
if values.title == '':
values.title = message[:20]
return values, message
if __name__ == "__main__":
(options, message) = ClientParser('~/.gntp').parse_args()
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
debug=options.debug,
)
result = growl.register()
if result is not True: exit(result)
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
)
if result is not True: exit(result)
class StackOverflowFetcher:
def __init__(self):
self.base_url = 'http://stackoverflow.com/questions/tagged/'
self.get_or_create_database()
self.growl = GrowlNotifier(
applicationName='StackOverflowChecker',
notifications=['new'],)
self.growl.register()
self.tags = [('django', True), ('python', False)]
self.get_questions()
self.close_connection()
def get_questions(self):
"""
Parse target URL for new questions.
"""
while self.tags:
tag, sticky = self.tags.pop()
url = self.base_url + tag
html = urllib2.urlopen(url).read()
soup = BeautifulSoup.BeautifulSoup(html)
questions = soup.findAll('h3')
for question in questions:
element = question.find('a')
link = element.get('href')
question = element.text
if self.is_new_link(link):
self.growl.notify(
noteType = "new",
title = question,
description = question,
icon = "http://example.com/icon.png",
sticky = sticky,
priority = 1,
callback = 'http://stackoverflow.com{0}'.format(link),
)
self.record_question(link, question)
def get_or_create_database(self):
"""
Check if database file exists. Create if not.
Open file and send query.
If query fails, create tables.
"""
path = os.path.join(os.path.dirname(__file__), 'questions.db')
try:
f = open(path)
except IOError:
f = open(path, 'w')
f.close()
self.conn = sqlite3.connect(path)
try:
self.conn.execute('SELECT * from questions')
except sqlite3.OperationalError:
self.create_database()
def create_database(self):
self.conn.execute('CREATE TABLE questions(link VARCHAR(400), text VARCHAR(300));')
def is_new_link(self, link):
results = self.conn.execute('SELECT * FROM questions WHERE questions.link = "%s";' % link).fetchall()
if not results:
return True
return False
def record_question(self, link, question):
results = self.conn.execute('INSERT INTO questions(link, text) VALUES ("%s", "%s");' % (link, question))
def close_connection(self):
self.conn.commit()
self.conn.close()
class Core(CorePluginBase):
def growlInit(self):
# addr = (self.config['growl_host'], self.config['growl_port'])
# s = socket(AF_INET,SOCK_DGRAM)
# p = GrowlRegistrationPacket("Deluge", self.config['growl_password'])
# p.addNotification("Download Completed", True)
# p.addNotification("Torrent Added", True)
# s.sendto(p.payload(), addr)
# s.close()
self.growl = GrowlNotifier(
applicationName = "Deluge",
notifications = ["Torrent Added", "Download Completed"],
defaultNotifications = ["Torrent Added"],
hostname = self.config['growl_host'],
password = self.config['growl_password'],
port = self.config['growl_port'],
debug = 0
)
result = self.growl.register()
def sendGrowl(self, noteType, title, description, sticky=False, priority=0):
# p = GrowlNotificationPacket(application="Deluge", notification=noteType, title=title, description=description, priority=priority, sticky=sticky, password=self.config['growl_password']);
# addr = (self.config['growl_host'], self.config['growl_port'])
# s = socket(AF_INET,SOCK_DGRAM)
# s.sendto(p.payload(), addr)
# s.close()
result = self.growl.notify(
noteType = noteType,
title = title,
description = description,
icon = '',
sticky = sticky,
priority = priority
)
def enable(self):
self.config = deluge.configmanager.ConfigManager("growl.conf", DEFAULT_PREFS)
self.growlInit()
#component.get("AlertManager").register_handler("torrent_finished_alert", self.on_torrent_finished)
d = defer.Deferred()
# simulate a delayed result by asking the reactor to schedule
# gotResults in 2 seconds time
reactor.callLater(2, self.connect_events)
log.debug("Growl core plugin enabled!")
return d
def disable(self):
log.debug("Growl core plugin disabled!")
#component.get("AlertManager").deregister_handler(self.on_alert_torrent_finished)
self.disconnect_events();
self.config.save()
def update(self):
pass
def connect_events(self):
event_manager = component.get("EventManager")
event_manager.register_event_handler("TorrentFinishedEvent", self.on_torrent_finished)
event_manager.register_event_handler("TorrentAddedEvent", self.on_torrent_added)
def disconnect_events(self):
event_manager = component.get("EventManager")
event_manager.deregister_event_handler("TorrentFinishedEvent", self.on_torrent_finished)
event_manager.deregister_event_handler("TorrentAddedEvent", self.on_torrent_added)
def on_torrent_added(self, torrent_id):
if (self.config['growl_torrent_added'] == False):
return
try:
#torrent_id = str(alert.handle.info_hash())
torrent = component.get("TorrentManager")[torrent_id]
torrent_status = torrent.get_status({})
message = _("Added Torrent \"%(name)s\"") % torrent_status
d = defer.maybeDeferred(self.sendGrowl, "Torrent Added", "Torrent Added", message, self.config['growl_sticky'], self.config['growl_priority'])
#d.addCallback(self._on_notify_sucess, 'email')
#d.addErrback(self._on_notify_failure, 'email')
return d
except Exception, e:
log.error("error in alert %s" % e)
class Core(CorePluginBase):
def growlInit(self):
# addr = (self.config['growl_host'], self.config['growl_port'])
# s = socket(AF_INET,SOCK_DGRAM)
# p = GrowlRegistrationPacket("Deluge", self.config['growl_password'])
# p.addNotification("Download Completed", True)
# p.addNotification("Torrent Added", True)
# s.sendto(p.payload(), addr)
# s.close()
self.growl = GrowlNotifier(
applicationName="Deluge",
notifications=["Torrent Added", "Download Completed"],
defaultNotifications=["Torrent Added"],
hostname=self.config['growl_host'],
password=self.config['growl_password'],
port=self.config['growl_port'],
debug=0)
result = self.growl.register()
def sendGrowl(self,
noteType,
title,
description,
sticky=False,
priority=0):
# p = GrowlNotificationPacket(application="Deluge", notification=noteType, title=title, description=description, priority=priority, sticky=sticky, password=self.config['growl_password']);
# addr = (self.config['growl_host'], self.config['growl_port'])
# s = socket(AF_INET,SOCK_DGRAM)
# s.sendto(p.payload(), addr)
# s.close()
result = self.growl.notify(noteType=noteType,
title=title,
description=description,
icon='',
sticky=sticky,
priority=priority)
def enable(self):
self.config = deluge.configmanager.ConfigManager(
"growl.conf", DEFAULT_PREFS)
self.growlInit()
#component.get("AlertManager").register_handler("torrent_finished_alert", self.on_torrent_finished)
d = defer.Deferred()
# simulate a delayed result by asking the reactor to schedule
# gotResults in 2 seconds time
reactor.callLater(2, self.connect_events)
log.debug("Growl core plugin enabled!")
return d
def disable(self):
log.debug("Growl core plugin disabled!")
#component.get("AlertManager").deregister_handler(self.on_alert_torrent_finished)
self.disconnect_events()
self.config.save()
def update(self):
pass
def connect_events(self):
event_manager = component.get("EventManager")
event_manager.register_event_handler("TorrentFinishedEvent",
self.on_torrent_finished)
event_manager.register_event_handler("TorrentAddedEvent",
self.on_torrent_added)
def disconnect_events(self):
event_manager = component.get("EventManager")
event_manager.deregister_event_handler("TorrentFinishedEvent",
self.on_torrent_finished)
event_manager.deregister_event_handler("TorrentAddedEvent",
self.on_torrent_added)
def on_torrent_added(self, torrent_id):
if (self.config['growl_torrent_added'] == False):
return
try:
#torrent_id = str(alert.handle.info_hash())
torrent = component.get("TorrentManager")[torrent_id]
torrent_status = torrent.get_status({})
message = _("Added Torrent \"%(name)s\"") % torrent_status
d = defer.maybeDeferred(self.sendGrowl, "Torrent Added",
"Torrent Added", message,
self.config['growl_sticky'],
self.config['growl_priority'])
#d.addCallback(self._on_notify_sucess, 'email')
#d.addErrback(self._on_notify_failure, 'email')
return d
except Exception, e:
log.error("error in alert %s" % e)
