def delete(self, version, service_slug, sid):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
try:
event = Event.get(db.Key(sid))
except datastore_errors.BadKeyError:
self.error(404, "Event %s not found" % sid)
return
if not event or service.key() != event.service.key():
self.error(404, "No event for Service %s with sid = %s" \
% (service_slug, sid))
return
event.delete()
invalidate_cache()
# Why not JSON?
self.success(event.rest(self.base_url(version)))
def serverisup (service):
# Create a new event with the given status and given service
service = Service.get_by_slug(service)
status = Status.get_by_slug("up")
e = Event(service=service, status=status, message="The server is responding.")
e.put()
def get(self, service_slug, year=None, month=None, day=None):
service = Service.get_by_slug(service_slug)
if not service:
self.not_found()
return
try:
if day:
start_date = date(int(year),int(month),int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year),int(month),1)
days = calendar.monthrange(start_date.year, start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year),1,1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
except ValueError:
self.not_found(404)
return
events = service.events
if start_date and end_date:
events.filter('start >= ', start_date).filter('start <', end_date)
td = default_template_data()
td["service"] = service
td["events"] = events.order("-start").fetch(500)
self.render(td, 'service.html')
def call_api(service, data):
'''Submit service status to API'''
service = Service.get_by_slug(service)
status = Status.get_by_slug(data['status'])
e = Event(service=service, status=status, message=data['message'])
print json.dumps(data, sort_keys=True, skipkeys=True)
e.put()
def delete(self, version, service_slug, sid):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
try:
event = Event.get(db.Key(sid))
except datastore_errors.BadKeyError:
self.error(404, "Event %s not found" % sid)
return
if not event or service.key() != event.service.key():
self.error(404, "No event for Service %s with sid = %s" \
% (service_slug, sid))
return
event.delete()
invalidate_cache()
# Why not JSON?
self.success(event.rest(self.base_url(version)))
def post(self, version):
logging.debug("ServicesListHandler#post")
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if existing_s:
existing_s.description = description
existing_s.put()
self.json(existing_s.rest(self.base_url(version)))
# Create new service
else:
s = Service(name=name, slug=slug, description=description)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(
400, "Bad Data: Name: %s, Description: %s" %
(name, description))
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version, service_slug):
logging.debug("ServiceInstanceHandler#post")
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
region = self.request.get('region', default_value=None)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
if description:
service.description = description
if name:
service.name = name
if region:
service.region = Region.get_by_name(region)
if name or description or region:
service.slug = Service.slugify(service.name, service.region.name)
service.put()
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s does not exist" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version, service_slug):
logging.debug("ServiceInstanceHandler#post")
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
serviceurl = self.request.get('serviceurl', default_value=None)
pattern = self.request.get('pattern', default_value=None)
freq = self.request.get('freq', default_value=None)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
if description:
service.description = description
if name:
service.name = name
if serviceurl:
service.serviceurl = serviceurl
if pattern:
service.pattern = pattern
if freq:
service.freq = int(freq)
if name or description or serviceurl or pattern or freq:
service.put()
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s does not exist" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version, service_slug):
logging.debug("ServiceInstanceHandler#post")
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
serviceurl = self.request.get('serviceurl', default_value=None)
pattern = self.request.get('pattern', default_value=None)
freq = self.request.get('freq', default_value=None)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
if description:
service.description = description
if name:
service.name = name
if serviceurl:
service.serviceurl = serviceurl
if pattern:
service.pattern = pattern
if freq:
service.freq = int(freq)
if name or description or serviceurl or pattern or freq:
service.put()
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s does not exist" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version):
logging.debug("ServicesListHandler#post")
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
serviceurl = self.request.get('serviceurl', default_value=None)
pattern = self.request.get('pattern', default_value=None)
freq = self.request.get('freq', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if existing_s:
existing_s.description = description
existing_s.serviceurl = serviceurl
existing_s.pattern = pattern
existing_s.freq = freq
existing_s.put()
self.json(existing_s.rest(self.base_url(version)))
# Create new service
else:
s = Service(name=name, slug=slug, description=description, serviceurl=serviceurl)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(400, "Bad Data: Name: %s, Description: %s" % (name, description))
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version):
logging.debug("ServicesListHandler#post")
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
region = self.request.get('region', default_value=None)
if name and description and region:
slug = Service.slugify(name, region)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if existing_s:
existing_s.description = description
if region:
existing_s.region = Region.get_by_name(region)
existing_s.slug = Service.slugify(name, region)
existing_s.put()
self.json(existing_s.rest(self.base_url(version)))
# Create new service
else:
region = Region.get_by_name(region)
s = Service(name=name, slug=slug, description=description, region=region)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(400, "Bad Data: Name: %s, Description: %s, Region: %s" % (name, description, region))
else:
self.error(404, "API Version %s not supported" % version)
def serverisdown (service):
# Create a new event with the given status and given service
service = Service.get_by_slug(service)
status = Status.get_by_slug("down")
e = Event(service=service, status=status, message="The server could not be reached")
e.put()
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if not name or not description:
self.error(400, "Bad Data: Name: %s, Description: %s" \
% (name, description))
return
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
if existing_s:
self.error(404, "A sevice with this name already exists")
return
s = Service(name=name, slug=slug, description=description)
s.put()
invalidate_cache()
self.response.set_status(201)
self.json(s.rest(self.base_url(version)))
def get(self):
self.response.headers['Content-Type'] = "application/rss+xml; charset=utf-8"
host = self.request.headers.get('host', 'nohost')
base_url = self.request.scheme + "://" + host
events = []
query = Event.all().order("-start")
# Filter query by requested services, if specified in the 'service' URL parameter.
service_list = []
for service_arg in self.request.get_all('services'):
service_list.extend(service_arg.split(','))
service_list = map(lambda serv_slug: Service.get_by_slug(serv_slug), service_list)
# filter out any non-existent services
service_list = filter(lambda service: not service is None, service_list)
service_string = 'all services'
if len(service_list) > 0:
query.filter('service IN', service_list)
if len(service_list) == 1:
service_string = 'the %s service' % service_list[0].name
elif len(service_list) == 2:
service_string = 'the %s and %s services' % (service_list[0].name, service_list[1].name)
else:
service_string = 'the %s, and %s services' % (', '.join([service.name for service in service_list[:-1]]), service_list[-1].name)
# Create the root 'rss' element
rss_xml = et.Element('rss')
rss_xml.set('version', '2.0')
# Create the channel element and its metadata elements
channel = et.SubElement(rss_xml, 'channel')
title = et.SubElement(channel, 'title')
title.text = '%s Service Events' % settings.SITE_NAME
description = et.SubElement(channel, 'description')
description.text = 'This feed shows the last %d events on %s on %s.' % (settings.RSS_NUM_EVENTS_TO_FETCH, service_string, settings.SITE_NAME)
link = et.SubElement(channel, 'link')
link.text = base_url
# Create each of the feed events.
item_subelements = {
'title': lambda(event): '[%s - %s] %s' % (event.service.name, event.status.name, unicode(event.message)),
'description': lambda(event): '%s' % unicode(event.message),
'link': lambda(event): '%s/services/%s' % (base_url, event.service.slug),
'category': lambda(event): event.service.name,
'pubDate': lambda(event): format_date_time(mktime(event.start.timetuple())),
'guid': lambda(event): '%s/api/v1/services/%s/events/%s' % (base_url, event.service.slug, unicode(event.key()))
}
for event in query.fetch(settings.RSS_NUM_EVENTS_TO_FETCH):
item = et.SubElement(channel, 'item')
for tag, text_func in item_subelements.iteritems():
subelement = et.SubElement(item, tag)
subelement.text = text_func(event)
self.response.out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
self.response.out.write(et.tostring(rss_xml))
def get(self):
self.response.headers['Content-Type'] = "application/rss+xml; charset=utf-8"
host = self.request.headers.get('host', 'nohost')
base_url = self.request.scheme + "://" + host
events = []
query = Event.query().order(-Event.start)
# Filter query by requested services, if specified in the 'service' URL parameter.
service_list = []
for service_arg in self.request.get_all('services'):
service_list.extend(service_arg.split(','))
service_list = map(lambda serv_slug: Service.get_by_slug(serv_slug), service_list)
# filter out any non-existent services
service_list = filter(lambda service: not service is None, service_list)
service_string = 'all services'
if len(service_list) > 0:
query.filter('service IN', service_list)
if len(service_list) == 1:
service_string = 'the %s service' % service_list[0].name
elif len(service_list) == 2:
service_string = 'the %s and %s services' % (service_list[0].name, service_list[1].name)
else:
service_string = 'the %s, and %s services' % (', '.join([service.name for service in service_list[:-1]]), service_list[-1].name)
# Create the root 'rss' element
rss_xml = et.Element('rss')
rss_xml.set('version', '2.0')
# Create the channel element and its metadata elements
channel = et.SubElement(rss_xml, 'channel')
title = et.SubElement(channel, 'title')
title.text = '%s Service Events' % settings.SITE_NAME
description = et.SubElement(channel, 'description')
description.text = 'This feed shows the last %d events on %s on %s.' % (settings.RSS_NUM_EVENTS_TO_FETCH, service_string, settings.SITE_NAME)
link = et.SubElement(channel, 'link')
link.text = base_url
# Create each of the feed events.
item_subelements = {
'title': lambda(event): '[%s - %s] %s' % (event.service.name, event.status.name, unicode(event.message)),
'description': lambda(event): '%s' % unicode(event.message),
'link': lambda(event): '%s/services/%s' % (base_url, event.service.slug),
'category': lambda(event): event.service.name,
'pubDate': lambda(event): format_date_time(mktime(event.start.timetuple())),
'guid': lambda(event): '%s/api/v1/services/%s/events/%s' % (base_url, event.service.slug, unicode(event.key))
}
for event in query.fetch(settings.RSS_NUM_EVENTS_TO_FETCH):
item = et.SubElement(channel, 'item')
for tag, text_func in item_subelements.iteritems():
subelement = et.SubElement(item, tag)
subelement.text = text_func(event)
self.response.out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
self.response.out.write(et.tostring(rss_xml))
def serverisdown(service):
# Create a new event with the given status and given service
service = Service.get_by_slug(service)
status = Status.get_by_slug("down")
e = Event(service=service,
status=status,
message="The server could not be reached")
e.put()
def serverisup(service):
# Create a new event with the given status and given service
service = Service.get_by_slug(service)
status = Status.get_by_slug("up")
e = Event(service=service,
status=status,
message="The server is responding.")
e.put()
def get(self, slug):
service = Service.get_by_slug(slug)
if service:
td = default_template_data()
td["services_selected"] = True
td["service"] = service
td["events"] = service.events.order("-start").fetch(1000)
self.render(td, 'admin/services_instance.html')
else:
self.not_found()
def get(self, slug):
service = Service.get_by_slug(slug)
if service:
td = default_template_data()
td["services_selected"] = True
td["service"] = service
td["events"] = service.events.order("-start").fetch(1000)
self.render(td, 'admin/services_instance.html')
else:
self.not_found()
def get(self, version, service_slug):
logging.debug("StatusesListHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
history_size = config.SITE['history_size']
start = self.request.get('start', default_value=None)
end = self.request.get('end', default_value=None)
query = Event.all()
query.filter('service =', service)
if start:
try:
_start = aware_to_naive(parse(start))
# clip the start date to now - history_size
if datetime.now() - _start > timedelta(days=history_size):
_start = _start - timedelta(days=history_size)
except:
self.error(400, "Invalid Date: %s" % start)
return
else:
_start = datetime.now() - timedelta(days=history_size)
query.filter("start >= ", _start)
if end:
try:
_end = aware_to_naive(parse(end))
query.filter("start <=", _end)
except:
self.error(400, "Invalid Date: %s" % end)
return
query.order('-start')
if query:
data = []
for s in query:
data.append(s.rest(self.base_url(version)))
data = { "events": data }
self.json(data)
else:
self.error(404, "No events for Service %s" % service_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, version, service_slug):
logging.debug("ServiceInstanceHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if (service):
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s does not exist" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def post(self, service_slug=None, options={}):
service_slug = self.request.get("service-slug")
tries_count = self.request.get("tries-count", 0)
last_status_slug = self.request.get("last-status", "")
options = settings.CHECK_SERVICES_TO_CHECK[service_slug]
service = Service.get_by_slug(service_slug)
if not service:
self.error(404)
self.log("Service %(service_name)s not found" % {"service_name": service_slug})
self.check_service(service, tries_count, last_status_slug, options)
def get(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s does not exist" % service_slug)
return
self.json(service.rest(self.base_url(version)))
def get(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s does not exist" % service_slug)
return
self.json(service.rest(self.base_url(version)))
def update_status(service_slug, status_type, message):
service = Service.get_by_slug(service_slug)
status = Status.get_by_slug(status_type)
cur_event = service.events.order('-start').fetch(1)
if cur_event and cur_event[0].status.slug != status.slug:
e = Event(service=service, status=status,
message=message)
e.put()
invalidate_cache()
def get(self, version, service_slug):
logging.debug("ServiceInstanceHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if (service):
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s does not exist" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"service": service,
}
td.update(site.default_template_data())
self.render(td, 'admin/events_note.html')
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"service": service,
}
td.update(site.default_template_data())
self.render(td, 'admin/events_note.html')
def post(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
status_slug = self.request.get("status", default_value=None)
message = self.request.get("message", default_value=None)
informational = self.request.get("informational", default_value=None)
if not message:
self.error(400, "Event message is required")
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
if not status_slug:
event = service.current_event()
if event:
status = event.status
else:
status = Status.get_default()
else:
status = Status.get_by_slug(status_slug)
if not status:
self.error(404, "Status %s not found" % status_slug)
return
e = Event(status=status, service=service, message=message)
e.informational = informational and informational == "true"
e.put()
# Queue up a task that calls the Twitter API to make a tweet.
if self.request.get('tweet'):
logging.info(
'Attempting to post a tweet for the latest event via async GAE task queue.'
)
taskqueue.add(url='/admin/tweet',
params={
'service_name': service.name,
'status_name': status.name,
'message': message
})
invalidate_cache()
self.json(e.rest(self.base_url(version)))
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"service": service,
"statuses": Status.query().fetch(100),
}
td.update(site.default_template_data())
self.render(td, 'admin/events_create.html')
def get(self, version, service_slug):
logging.debug("StatusesListHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
start = self.request.get('start', default_value=None)
end = self.request.get('end', default_value=None)
query = Event.all().filter('service =', service)
if start:
try:
_start = aware_to_naive(parse(start))
query.filter("start >= ", _start)
except:
self.error(400, "Invalid Date: %s" % start)
return
if end:
try:
_end = aware_to_naive(parse(end))
query.filter("start <=", _end)
except:
self.error(400, "Invalid Date: %s" % end)
return
query.order('-start')
if query:
data = []
# Bizarre nonsense involving the query being built.
# For large datasets, must assign a max value to the fetch.
query = query.fetch(100)
for s in query:
data.append(s.rest(self.base_url(version)))
data = { "events": data }
self.json(data)
else:
self.error(404, "No events for Service %s" % service_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, version, service_slug):
logging.debug("StatusesListHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
start = self.request.get('start', default_value=None)
end = self.request.get('end', default_value=None)
query = Event.all().filter('service =', service)
if start:
try:
_start = aware_to_naive(parse(start))
query.filter("start >= ", _start)
except:
self.error(400, "Invalid Date: %s" % start)
return
if end:
try:
_end = aware_to_naive(parse(end))
query.filter("start <=", _end)
except:
self.error(400, "Invalid Date: %s" % end)
return
query.order('-start')
if query:
data = []
# Bizarre nonsense involving the query being built.
# For large datasets, must assign a max value to the fetch.
query = query.fetch(100)
for s in query:
data.append(s.rest(self.base_url(version)))
data = {"events": data}
self.json(data)
else:
self.error(404, "No events for Service %s" % service_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, slug, key_str):
service = Service.get_by_slug(slug)
event = db.get(key_str)
if not service or not isinstance(event, Event):
self.not_found()
return
td = {
"services_selected": True,
"service": service,
"event": event,
}
td.update(site.default_template_data())
self.render(td, 'admin/events_delete.html')
def get(self, slug, key_str):
service = Service.get_by_slug(slug)
event = db.get(key_str)
if not service or not isinstance(event, Event):
self.not_found()
return
td = {
"services_selected": True,
"service": service,
"event": event,
}
td.update(site.default_template_data())
self.render(td, 'admin/events_delete.html')
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"url": "/admin/api/v1/services/" + slug,
"description": service.description,
"name": service.name,
"slug": service.slug,
}
td.update(site.default_template_data())
self.render(td, 'admin/services_delete.html')
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"url": "/admin/api/v1/services/" + slug,
"description": service.description,
"name": service.name,
"slug": service.slug,
}
td.update(site.default_template_data())
self.render(td, 'admin/services_delete.html')
def get(self, version, service_slug, sid):
logging.debug("EventInstanceHandler#get sid=%s" % sid)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if (service):
event = Event.get(db.Key(sid))
if (event and service.key() == event.service.key()):
self.json(event.rest(self.base_url(version)))
else:
self.error(404, "No event for Service %s with sid = %s" % (service_slug,sid))
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
status_slug = self.request.get("status", default_value=None)
message = self.request.get("message", default_value=None)
informational = self.request.get("informational", default_value=None)
if not message:
self.error(400, "Event message is required")
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
if not status_slug:
event = service.current_event()
if event:
status = event.status
else:
status = Status.get_default()
else:
status = Status.get_by_slug(status_slug)
if not status:
self.error(404, "Status %s not found" % status_slug)
return
e = Event(status=status, service=service, message=message)
e.informational = informational and informational == "true"
e.put()
# Queue up a task that calls the Twitter API to make a tweet.
if self.request.get('tweet'):
logging.info('Attempting to post a tweet for the latest event via async GAE task queue.')
taskqueue.add(url='/admin/tweet', params={'service_name': service.name, 'status_name': status.name, 'message': message})
#TODO - insert Hipchat notification here
logging.info('*** Sending update to Hipchat room')
taskqueue.add(url='/admin/hipchat', params={'service_name': service.name, 'status_name': status.name, 'message': message})
invalidate_cache()
self.json(e.rest(self.base_url(version)))
def delete(self, version, service_slug):
logging.debug("ServiceInstanceHandler#delete slug=%s" % service_slug)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
query = Event.all(keys_only=True)
query.filter('service =', service)
db.delete(query)
service.delete()
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, version, service_slug):
logging.debug("StatusesListHandler#get")
if self.valid_version(version):
service = Service.get_by_slug(service_slug)
if service:
start = self.request.get("start", default_value=None)
end = self.request.get("end", default_value=None)
query = Event.all()
query.filter("service =", service)
if start:
try:
_start = aware_to_naive(parse(start))
query.filter("start >= ", _start)
except:
self.error(400, "Invalid Date: %s" % start)
return
if end:
try:
_end = aware_to_naive(parse(end))
query.filter("start <=", _end)
except:
self.error(400, "Invalid Date: %s" % end)
return
query.order("-start")
if query:
data = []
for s in query:
data.append(s.rest(self.base_url(version)))
data = {"events": data}
self.json(data)
else:
self.error(404, "No events for Service %s" % service_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def delete(self, version, service_slug):
logging.debug("ServiceInstanceHandler#delete slug=%s" % service_slug)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if service:
query = Event.all(keys_only=True)
query.filter('service =', service)
db.delete(query)
service.delete()
self.json(service.rest(self.base_url(version)))
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def delete(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
delete_multi(Event.query().filter(Event.service == service.key))
service.key.delete()
invalidate_cache()
self.json(service.rest(self.base_url(version)))
def get(self, service_slug, year=None, month=None, day=None):
user = users.get_current_user()
logging.debug("ServiceHandler#get")
service = Service.get_by_slug(service_slug)
if not service:
self.render({}, "404.html")
return
try:
if day:
start_date = date(int(year),int(month),int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year),int(month),1)
days = calendar.monthrange(start_date.year, start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year),1,1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
except ValueError:
self.render({},'404.html')
return
td = default_template_data()
td["service"] = service_slug
if start_date and end_date:
start_stamp = mktime(start_date.timetuple())
end_stamp = mktime(end_date.timetuple())
# Remove GMT from the string so that the date is
# is parsed in user's time zone
td["start_date"] = start_date
td["end_date"] = end_date
td["start_date_stamp"] = format_date_time(start_stamp)[:-4]
td["end_date_stamp"] = format_date_time(end_stamp)[:-4]
else:
td["start_date"] = None
td["end_date"] = None
self.render(td, 'service.html')
def get(self, service_slug, year=None, month=None, day=None):
user = users.get_current_user()
logging.debug("BasicServiceHandler#get")
service = Service.get_by_slug(service_slug)
if not service:
self.render({}, "404.html")
return
events = service.events
show_admin = False
try:
if day:
start_date = date(int(year),int(month),int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year),int(month),1)
days = calendar.monthrange(start_date.year, start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year),1,1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
show_admin = True
except ValueError:
self.render({},'404.html')
return
if start_date and end_date:
events.filter('start >= ', start_date).filter('start <', end_date)
events.order("-start")
td = default_template_data()
td["service"] = service
td["events"] = events.fetch(100)
td["start_date"] = start_date
td["end_date"] = end_date
self.render(td, 'basic','service.html')
def get(self, service_slug, year=None, month=None, day=None):
user = users.get_current_user()
logging.debug("BasicServiceHandler#get")
service = Service.get_by_slug(service_slug)
if not service:
self.render({}, "404.html")
return
events = service.events
show_admin = False
try:
if day:
start_date = date(int(year),int(month),int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year),int(month),1)
days = calendar.monthrange(start_date.year, start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year),1,1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
show_admin = True
except ValueError:
self.render({},'404.html')
return
if start_date and end_date:
events.filter('start >= ', start_date).filter('start <', end_date)
events.order("-start")
td = default_template_data()
td["service"] = service
td["events"] = events.fetch(100)
td["start_date"] = start_date
td["end_date"] = end_date
self.render(td, 'basic','service.html')
def get(self, service_slug, year=None, month=None, day=None):
user = users.get_current_user()
logging.debug("ServiceHandler#get")
service = Service.get_by_slug(service_slug)
if not service:
self.render({}, "404.html")
return
try:
if day:
start_date = date(int(year),int(month),int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year),int(month),1)
days = calendar.monthrange(start_date.year, start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year),1,1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
except ValueError:
self.render({},'404.html')
return
td = default_template_data()
td["service"] = service_slug
if start_date and end_date:
start_stamp = mktime(start_date.timetuple())
end_stamp = mktime(end_date.timetuple())
# Remove GMT from the string so that the date is
# is parsed in user's time zone
td["start_date"] = start_date
td["end_date"] = end_date
td["start_date_stamp"] = format_date_time(start_stamp)[:-4]
td["end_date_stamp"] = format_date_time(end_stamp)[:-4]
else:
td["start_date"] = None
td["end_date"] = None
self.render(td, 'service.html')
def get(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
event = service.current_event()
if not event:
self.error(404, "No current event for Service %s" % service_slug)
return
self.json(event.rest(self.base_url(version)))
def get(self, version, service_slug, sid):
logging.debug("EventInstanceHandler#get sid=%s" % sid)
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if (service):
event = Event.get(db.Key(sid))
if (event and service.key() == event.service.key()):
self.json(event.rest(self.base_url(version)))
else:
self.error(
404, "No event for Service %s with sid = %s" %
(service_slug, sid))
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def get(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
event = service.current_event()
if not event:
self.error(404, "No current event for Service %s" % service_slug)
return
self.json(event.rest(self.base_url(version)))
def get(self, version, service_slug):
logging.debug("CurrentStatusHandler#get")
if (self.valid_version(version)):
service = Service.get_by_slug(service_slug)
if (service):
event = service.current_event()
if (event):
self.json(event.rest(self.base_url(version)))
else:
self.error(
404, "No current event for Service %s" % service_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(404, "Version %s not supported" % version)
def delete(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
query = Event.all()
query.filter('service =', service)
if query:
for e in query:
e.delete()
invalidate_cache()
service.delete()
self.json(service.rest(self.base_url(version)))
def post(self, version, service_slug):
logging.debug("EventsListHandler#post")
if (self.valid_version(version)):
status_slug = self.request.get("status", default_value=None)
message = self.request.get("message", default_value=None)
informational = self.request.get("informational",
default_value=None)
if message:
service = Service.get_by_slug(service_slug)
if service:
if not status_slug:
event = service.current_event()
if event:
status = event.status
else:
status = Status.default()
else:
status = Status.get_by_slug(status_slug)
if status:
e = Event(status=status,
service=service,
message=message)
e.informational = informational and informational == "true"
e.put()
self.json(e.rest(self.base_url(version)))
else:
self.error(404, "Status %s not found" % status_slug)
else:
self.error(404, "Service %s not found" % service_slug)
else:
self.error(400, "Event message is required")
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
slist = self.request.get('list', default_value=None)
l = None
if slist:
l = List.all().filter("slug =", slist).get()
if not name:
self.error(400, "Bad name: %s" % name)
return
if not description:
self.error(400, "Bad description: %s" % description)
return
if slist and not l:
self.error(400, "Bad list slug: %s" % slist)
return
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
if existing_s:
self.error(404, "A sevice with this name already exists")
return
s = Service(name=name, slug=slug, description=description, list=l)
s.put()
invalidate_cache()
self.response.set_status(201)
self.json(s.rest(self.base_url(version)))
def post(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s does not exist" % service_slug)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
list = self.request.get('list', default_value=None)
if description:
service.description = description
if name:
service.name = name
if list:
l = List.all().filter("slug = ", list).get()
if l is None:
self.error(400, "Can't find list with slug %s" % list)
return
service.list = l
if "" == list:
service.list = None
list = "removed"
if name or description or list:
invalidate_cache()
service.put()
self.json(service.rest(self.base_url(version)))
def post(self, version, service_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
status_slug = self.request.get("status", default_value=None)
message = self.request.get("message", default_value=None)
informational = self.request.get("informational", default_value=None)
if not message:
self.error(400, "Event message is required")
return
service = Service.get_by_slug(service_slug)
if not service:
self.error(404, "Service %s not found" % service_slug)
return
if not status_slug:
event = service.current_event()
if event:
status = event.status
else:
status = Status.get_default()
else:
status = Status.get_by_slug(status_slug)
if not status:
self.error(404, "Status %s not found" % status_slug)
return
e = Event(status=status, service=service, message=message)
e.informational = informational and informational == "true"
e.put()
invalidate_cache()
self.json(e.rest(self.base_url(version)))
def get(self, slug):
service = Service.get_by_slug(slug)
if not service:
self.not_found()
return
td = {
"services_selected": True,
"url": "/admin/api/v1/services/" + slug,
"description": service.description,
"slug": service.slug,
"name": service.name,
"action": "edit",
"service_lists": List.all().fetch(100),
}
if service.list is not None:
td["list"] = service.list.name
else:
td["list"] = ""
td.update(site.default_template_data())
self.render(td, 'admin/services_create.html')
def post(self, version):
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if not existing_s:
s = Service(name=name, slug=slug, description=description)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(404, "A sevice with this name already exists")
else:
self.error(
400, "Bad Data: Name: %s, Description: %s" %
(name, description))
else:
self.error(404, "API Version %s not supported" % version)
