def recv_notif(self, notif):
print("recv_notif %s" % notif)
n = Notif(notif)
h = HipChat()
if n.type == "reminder":
h.sayHtml("@%s, I have to remind you to %s" % (n.to, n.message) if n.to else n.message, n.room)
elif n.type == "notification":
h.sayHtml("@%s %s" % (n.to, n.message) if n.to else n.message, n.room)
def wrapped_function(*args, **kwargs):
try:
sys.stdout = StringIO()
function_to_exec = function(*args,**kwargs)
out = sys.stdout.getvalue()
messager = HipChat(self.token)
messager.message_room(message=out, room_id=self.room_id, message_from=self.message_from, **self.kwargs)
finally:
sys.stdout.close()
sys.stdout = sys.__stdout__
return function_to_exec
def notify_hipchat(self, message):
if 'hipchat' in self.onboarding:
try:
hipchat = HipChat(token=self.onboarding['hipchat']['token'])
hipchat.message_room(
room_id=self.onboarding['hipchat']['room_id'],
message_from='Onboarding',
message=message,
message_format='html',
color='green',
notify=True
)
except Exception:
log.exception("Error during Hipchat message")
def wrapped_function(*args, **kwargs):
try:
sys.stdout = StringIO()
function_to_exec = function(*args, **kwargs)
out = sys.stdout.getvalue()
messager = HipChat(self.token)
messager.message_room(message=out,
room_id=self.room_id,
message_from=self.message_from,
**self.kwargs)
finally:
sys.stdout.close()
sys.stdout = sys.__stdout__
return function_to_exec
def configure(self, context):
super().configure(context)
self.hipster = HC(token=self.token())
if self.room_id is None:
room = self.hipster.find_room(self.room_name())
if room is None:
self.logger.error(
"Hipchat room '{}' does not exist".format(self.room_name())
)
else:
self.room_id = room.get('room_id')
'token' : str(sys.argv[1]),
'room_id' : str(sys.argv[2]),
'from_name' : str(sys.argv[3]),
'message' : str(sys.argv[4]),
'color' : str(sys.argv[5]),
'notify' : str(sys.argv[6]),
'target_branch': str(sys.argv[7]),
'build_branch' : str(sys.argv[8]),
}
is_post = False
if config['notify'] == 'true':
notify = True
if not config['target_branch'] in config['build_branch']:
is_post = False
if config['target_branch'] == 'all' or config['target_branch'] == config['build_branch']:
is_post = True
if not is_post:
print('''Build branch:{build_branch} is not a target of notification.
target_branch: {target_branch}'''.format(
build_branch = config['build_branch'],
target_branch = config['target_branch']
)
)
sys.exit(0)
hipchat = HipChat(config)
hipchat.send_message()
def run():
'''
Worker runner that checks for alerts.
'''
global notifier_proxy, settings
args = get_args_from_cli()
alerts, settings = get_config(args.config)
# setting up logging
if not 'log_level' in settings:
settings['log_level'] = logging.WARNING
else:
settings['log_level'] = settings['log_level'].upper()
if not 'log_format' in settings:
settings[
'log_format'] = '%(asctime)s %(name)s %(levelname)s %(message)s'
if not 'log_datefmt' in settings:
settings['log_datefmt'] = '%Y-%m-%d %H:%M:%S'
logging.basicConfig(filename=settings.get('log_file', None),
level=settings['log_level'],
format=settings['log_format'],
datefmt=settings['log_datefmt'])
log.info('graphite-alerts started')
log.debug('Command line arguments:')
log.debug(args)
log.debug('Initializing redis at %s', args.redisurl)
STORAGE = RedisStorage(redis, args.redisurl)
notifier_proxy.add_notifier(LogNotifier(STORAGE))
notifier_proxy.add_notifier(ConsoleNotifier(STORAGE))
settings['graphite_url'] = args.graphite_url or settings['graphite_url']
if settings['graphite_url'].endswith('/'):
settings['graphite_url'] = settings['graphite_url'][:-1]
settings['pagerduty_key'] = args.pagerduty_key or settings['pagerduty_key']
log.debug('graphite_url: %s', settings['graphite_url'])
log.debug('pagerduty_key: %s', settings['pagerduty_key'])
if settings['pagerduty_key']:
pagerduty_client = PagerDuty(settings['pagerduty_key'])
notifier_proxy.add_notifier(
PagerdutyNotifier(pagerduty_client, STORAGE))
if args.hipchat_key:
hipchat = HipchatNotifier(HipChat(args.hipchat_key), STORAGE)
hipchat.add_room(settings['hipchat_room'])
notifier_proxy.add_notifier(hipchat)
while True:
start_time = time.time()
seen_alert_targets = set()
for alert in alerts:
check_for_alert(alert)
remove_old_seen_alerts()
# what if cron should trigger us ?
time_diff = time.time() - start_time
sleep_for = 60 - time_diff
if sleep_for > 0:
sleep_for = 60 - time_diff
log.info('Sleeping for %s seconds at %s', sleep_for,
datetime.utcnow())
time.sleep(60 - time_diff)
import time
from pins import Pins
from hipchat import HipChat
if __name__ == '__main__':
pins = Pins()
hipchat = HipChat()
pins.setup()
try:
while True:
status = hipchat.get_user_status()
pins.set_color(status.get_color())
time.sleep(5)
except KeyboardInterrupt:
pins.teardown()
from notifier_proxy import NotifierProxy
from pagerduty_notifier import PagerdutyNotifier
from redis_storage import RedisStorage
STORAGE = RedisStorage(redis, os.getenv('REDISTOGO_URL'))
pg_key = os.getenv('PAGERDUTY_KEY')
pagerduty_client = PagerDuty(pg_key)
GRAPHITE_URL = os.getenv('GRAPHITE_URL')
notifier_proxy = NotifierProxy()
notifier_proxy.add_notifier(PagerdutyNotifier(pagerduty_client, STORAGE))
if 'HIPCHAT_KEY' in os.environ:
hipchat = HipchatNotifier(HipChat(os.getenv('HIPCHAT_KEY')), STORAGE)
hipchat.add_room(os.getenv('HIPCHAT_ROOM'))
notifier_proxy.add_notifier(hipchat)
ALERT_TEMPLATE = r"""{{level}} alert for {{alert.name}} {{record.target}}. The
current value is {{current_value}} which passes the {{threshold_level|lower}} value of
{{threshold_value}}. Go to {{graph_url}}.
{% if docs_url %}Documentation: {{docs_url}}{% endif %}.
"""
HTML_ALERT_TEMPLATE = r"""{{level}} alert for {{alert.name}} {{record.target}}.
The current value is {{current_value}} which passes the {{threshold_level|lower}} value of
{{threshold_value}}. Go to <a href="{{graph_url}}">the graph</a>.
{% if docs_url %}<a href="{{docs_url}}">Documentation</a>{% endif %}.
"""
class HipChat(Persistence, TerminatorBlock):
""" A block for sending messages to a HipChat room.
Properties:
token (str): Auth token (distributed by account admin)
message (expr): Message contents.
room_name (str): The plaintext name of the target HipChat room.
sender (expr): Sender name to attach to the message.
message_color (enum): The color of the message.
notify (bool): Whether or not to send a notification to the members
of the room when the message arrives.
"""
version = VersionProperty("1.0.1")
token = StringProperty(title="API Token", default="[[HIPCHAT_TOKEN]]")
message = Property(title="Message contents", default='')
room_name = StringProperty(title="Room Name", default='')
sender = Property(title="Sender Name", default='')
message_color = SelectProperty(
Color, title="Message Color", default=Color.NONE)
notify = BoolProperty(title="Notify Users in Room", default=False)
def __init__(self):
super().__init__()
self.hipster = None
self.room_id = None
def configure(self, context):
super().configure(context)
self.hipster = HC(token=self.token())
if self.room_id is None:
room = self.hipster.find_room(self.room_name())
if room is None:
self.logger.error(
"Hipchat room '{}' does not exist".format(self.room_name())
)
else:
self.room_id = room.get('room_id')
def start(self):
super().start()
def process_signals(self, signals):
for signal in signals:
msg = self.message(signal)
sender = self.sender(signal)
try:
self.hipster.message_room(self.room_id, sender, msg,
color=self.message_color().value,
notify=self.notify())
except Exception as e:
self.logger.error(
"Failed to message HipChat room {}: {}".format(
self.room_name(), str(e))
)
def persisted_values(self):
"""Persist room_name using block mixin."""
return ["room_id"]
def list_rooms(self):
return self.hipster.list_rooms()
def list_users(self):
return self.hipster.list_users()
from hipchat import HipChat
ROOM_ID = 90507
HIPCHAT_API_TOKEN = 'a864d83d6221ad09861b690109a9f7'
hipster = HipChat(token=HIPCHAT_API_TOKEN)
hipster.method('rooms/message', method='POST', parameters={'room_id': ROOM_ID, 'from': 'The Announcer', 'message': 'All your base...'})
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
from hipchat import HipChat, HipChatException
from argparse import ArgumentParser
if __name__ == "__main__":
parser = ArgumentParser(description="Script for create room on HipChat. Script uses config.py")
args = parser.parse_args()
from config import *
print "[*] : Hipchat - creating room"
hipchat = HipChat(HIPCHAT_SERVER, HIPCHAT_TOKEN)
try:
hipchat.create_room(HIPCHAT_ROOM_NAME)
except HipChatException as e:
print "Error: {0}, return code: {1}".format(e.value, e.code)
room_url = "{0}/rooms/tokens/{1}".format(HIPCHAT_SERVER, hipchat.get_room_id_by_name(HIPCHAT_ROOM_NAME))
print "Room '{0}' was created".format(HIPCHAT_ROOM_NAME)
print "Now, you can generate notify token: {0}".format(room_url)
