flapjack 0.7.35 → 0.8.0

data/lib/flapjack/gateways/api/contact_methods.rb

@@ -118,8 +118,7 @@ module Flapjack
           app.get '/contacts/:contact_id/notification_rules' do
             content_type :json
 
-            contact = find_contact(params[:contact_id])
-            contact.notification_rules.to_json
+            "[" + find_contact(params[:contact_id]).notification_rules.map {|r| r.to_json }.join(',') + "]"
           end
 
           # Get the specified notification rule for this user

data/lib/flapjack/gateways/api/entity_methods.rb

@@ -135,7 +135,7 @@ module Flapjack
 
           app.get '/entities' do
             content_type :json
-            ret = Flapjack::Data::Entity.all(:redis => redis).sort_by(&:name).collect {|e|
+            ret = Flapjack::Data::Entity.all(:redis => redis).collect {|e|
               presenter = Flapjack::Gateways::API::EntityPresenter.new(e, :redis => redis)
               {'id' => e.id, 'name' => e.name, 'checks' => presenter.status }
             }
@@ -164,10 +164,10 @@ module Flapjack
             if entity_name
               # compatible with previous data format
               results = results.collect {|status_h| status_h[:status]}
-              (check ? results.first : results).to_json
+              check ? results.first.to_json : "[" + results.map {|r| r.to_json }.join(',') + "]"
             else
               # new and improved data format which reflects the request param structure
-              results.to_json
+              "[" + results.map {|r| r.to_json }.join(',') + "]"
             end
           end
 

data/lib/flapjack/gateways/jsonapi.rb

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+
+# A HTTP-based API server, which provides queries to determine the status of
+# entities and the checks that are reported against them.
+#
+# There's a matching flapjack-diner gem at https://github.com/flpjck/flapjack-diner
+# which consumes data from this API.
+
+require 'time'
+
+require 'rack/fiber_pool'
+require 'sinatra/base'
+
+require 'flapjack/rack_logger'
+require 'flapjack/redis_pool'
+
+require 'flapjack/gateways/jsonapi/rack/json_params_parser'
+
+require 'flapjack/gateways/jsonapi/contact_methods'
+require 'flapjack/gateways/jsonapi/entity_methods'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      include Flapjack::Utility
+
+      JSON_REQUEST_MIME_TYPES = ['application/vnd.api+json', 'application/json']
+
+      class ContactNotFound < RuntimeError
+        attr_reader :contact_id
+        def initialize(contact_id)
+          @contact_id = contact_id
+        end
+      end
+
+      class NotificationRuleNotFound < RuntimeError
+        attr_reader :rule_id
+        def initialize(rule_id)
+          @rule_id = rule_id
+        end
+      end
+
+      class EntityNotFound < RuntimeError
+        attr_reader :entity
+        def initialize(entity)
+          @entity = entity
+        end
+      end
+
+      class EntityCheckNotFound < RuntimeError
+        attr_reader :entity, :check
+        def initialize(entity, check)
+          @entity = entity
+          @check = check
+        end
+      end
+
+      class ResourceLocked < RuntimeError
+        attr_reader :resource
+        def initialize(resource)
+          @resource = resource
+        end
+      end
+
+      set :dump_errors, false
+
+      rescue_error = Proc.new {|status, exception, request_info, *msg|
+        if !msg || msg.empty?
+          trace = exception.backtrace.join("\n")
+          msg = "#{exception.class} - #{exception.message}"
+          msg_str = "#{msg}\n#{trace}"
+        else
+          msg_str = msg.join(", ")
+        end
+        case
+        when status < 500
+          @logger.warn "Error: #{msg_str}"
+        else
+          @logger.error "Error: #{msg_str}"
+        end
+
+        response_body = {:errors => msg}.to_json
+
+        query_string = (request_info[:query_string].respond_to?(:length) &&
+                        request_info[:query_string].length > 0) ? "?#{request_info[:query_string]}" : ""
+        if @logger.debug?
+          @logger.debug("Returning #{status} for #{request_info[:request_method]} " +
+            "#{request_info[:path_info]}#{query_string}, body: #{response_body}")
+        elsif @logger.info?
+          @logger.info("Returning #{status} for #{request_info[:request_method]} " +
+            "#{request_info[:path_info]}#{query_string}")
+        end
+
+        [status, {}, response_body]
+      }
+
+      rescue_exception = Proc.new {|env, e|
+        request_info = {
+          :path_info      => env['REQUEST_PATH'],
+          :request_method => env['REQUEST_METHOD'],
+          :query_string   => env['QUERY_STRING']
+        }
+        case e
+        when Flapjack::Gateways::JSONAPI::ContactNotFound
+          rescue_error.call(404, e, request_info, "could not find contact '#{e.contact_id}'")
+        when Flapjack::Gateways::JSONAPI::NotificationRuleNotFound
+          rescue_error.call(404, e, request_info,"could not find notification rule '#{e.rule_id}'")
+        when Flapjack::Gateways::JSONAPI::EntityNotFound
+          rescue_error.call(404, e, request_info, "could not find entity '#{e.entity}'")
+        when Flapjack::Gateways::JSONAPI::EntityCheckNotFound
+          rescue_error.call(404, e, request_info, "could not find entity check '#{e.check}'")
+        when Flapjack::Gateways::JSONAPI::ResourceLocked
+          rescue_error.call(423, e, request_info, "unable to obtain lock for resource '#{e.resource}'")
+        else
+          rescue_error.call(500, e, request_info)
+        end
+      }
+      use ::Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
+
+      use ::Rack::MethodOverride
+      use Flapjack::Gateways::JSONAPI::Rack::JsonParamsParser
+
+      class << self
+        def start
+          @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
+
+          @logger.info "starting jsonapi - class"
+
+          if @config && @config['access_log']
+            access_logger = Flapjack::AsyncLogger.new(@config['access_log'])
+            use Flapjack::CommonLogger, access_logger
+          end
+
+          @base_url = @config['base_url']
+          dummy_url = "http://api.example.com"
+          if @base_url
+            @base_url = $1 if @base_url.match(/^(.+)\/$/)
+          else
+            @logger.error "base_url must be a valid http or https URI (not configured), setting to dummy value (#{dummy_url})"
+            # FIXME: at this point I'd like to stop this pikelet without bringing down the whole
+            @base_url = dummy_url
+          end
+          if (@base_url =~ /^#{URI::regexp(%w(http https))}$/).nil?
+            @logger.error "base_url must be a valid http or https URI (#{@base_url}), setting to dummy value (#{dummy_url})"
+            # FIXME: at this point I'd like to stop this pikelet without bringing down the whole
+            # flapjack process
+            # For now, set a dummy value
+            @base_url = dummy_url
+          end
+        end
+      end
+
+      def redis
+        self.class.instance_variable_get('@redis')
+      end
+
+      def logger
+        self.class.instance_variable_get('@logger')
+      end
+
+      def base_url
+        self.class.instance_variable_get('@base_url')
+      end
+
+      before do
+        input = nil
+        query_string = (request.query_string.respond_to?(:length) &&
+                        request.query_string.length > 0) ? "?#{request.query_string}" : ""
+        if logger.debug?
+          input = env['rack.input'].read
+          logger.debug("#{request.request_method} #{request.path_info}#{query_string} #{input}")
+        elsif logger.info?
+          input = env['rack.input'].read
+          input_short = input.gsub(/\n/, '').gsub(/\s+/, ' ')
+          logger.info("#{request.request_method} #{request.path_info}#{query_string} #{input_short[0..80]}")
+        end
+        env['rack.input'].rewind unless input.nil?
+      end
+
+      after do
+        return if response.status == 500
+
+        query_string = (request.query_string.respond_to?(:length) &&
+                        request.query_string.length > 0) ? "?#{request.query_string}" : ""
+        if logger.debug?
+          logger.debug("Returning #{response.status} for #{request.request_method} " +
+            "#{request.path_info}#{query_string}, body: #{response.body.join(', ')}")
+        elsif logger.info?
+          logger.info("Returning #{response.status} for #{request.request_method} " +
+            "#{request.path_info}#{query_string}")
+        end
+      end
+
+      register Flapjack::Gateways::JSONAPI::EntityMethods
+
+      register Flapjack::Gateways::JSONAPI::ContactMethods
+
+      # the following should add the cors headers to every request, but is no work
+      #register Sinatra::CrossOrigin
+      #
+      #configure do
+      #  enable :cross_origin
+      #end
+      #set :allow_origin, :any
+      #set :allow_methods, [:get, :post, :put, :patch, :delete, :options]
+
+      options '*' do
+        cors_headers
+        204
+      end
+
+      not_found do
+        err(404, "not routable")
+      end
+
+      def cors_headers
+        allow_headers  = %w(* Content-Type Accept AUTHORIZATION Cache-Control)
+        allow_methods  = %w(GET POST PUT PATCH DELETE OPTIONS)
+        expose_headers = %w(Cache-Control Content-Language Content-Type Expires Last-Modified Pragma)
+        cors_headers   = {
+          'Access-Control-Allow-Origin'   => '*',
+          'Access-Control-Allow-Methods'  => allow_methods.join(', '),
+          'Access-Control-Allow-Headers'  => allow_headers.join(', '),
+          'Access-Control-Expose-Headers' => expose_headers.join(', '),
+          'Access-Control-Max-Age'        => '1728000'
+        }
+        headers(cors_headers)
+      end
+
+      def location(ids)
+        location = "#{base_url}#{request.path_info}#{ids.length == 1 ? '/' + ids.first : '?ids=' + ids.join(',')}"
+        headers({'Location' => location})
+      end
+
+      private
+
+      def err(status, *msg)
+        msg_str = msg.join(", ")
+        logger.info "Error: #{msg_str}"
+        [status, {}, {:errors => msg}.to_json]
+      end
+    end
+
+  end
+
+end

data/lib/flapjack/gateways/jsonapi/contact_methods.rb

@@ -0,0 +1,544 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+require 'flapjack/data/contact'
+require 'flapjack/data/notification_rule'
+require 'flapjack/data/semaphore'
+
+module Flapjack
+
+  module Gateways
+
+    class JSONAPI < Sinatra::Base
+
+      module ContactMethods
+
+        SEMAPHORE_CONTACT_MASS_UPDATE = 'contact_mass_update'
+
+        module Helpers
+
+          def find_contact(contact_id)
+            contact = Flapjack::Data::Contact.find_by_id(contact_id, :logger => logger, :redis => redis)
+            raise Flapjack::Gateways::JSONAPI::ContactNotFound.new(contact_id) if contact.nil?
+            contact
+          end
+
+          def find_rule(rule_id)
+            rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :logger => logger, :redis => redis)
+            raise Flapjack::Gateways::JSONAPI::NotificationRuleNotFound.new(rule_id) if rule.nil?
+            rule
+          end
+
+          def find_tags(tags)
+            halt err(400, "no tags given") if tags.nil? || tags.empty?
+            tags
+          end
+
+          def obtain_semaphore(resource)
+            semaphore = nil
+            strikes = 0
+            begin
+              semaphore = Flapjack::Data::Semaphore.new(resource, {:redis => redis, :expiry => 30})
+            rescue Flapjack::Data::Semaphore::ResourceLocked
+              strikes += 1
+              raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless strikes < 3
+              sleep 1
+              retry
+            end
+            raise Flapjack::Gateways::JSONAPI::ResourceLocked.new(resource) unless semaphore
+            semaphore
+          end
+        end
+
+        def self.registered(app)
+
+          app.helpers Flapjack::Gateways::JSONAPI::ContactMethods::Helpers
+
+          app.post '/contacts' do
+            pass unless Flapjack::Gateways::JSONAPI::JSON_REQUEST_MIME_TYPES.include?(request.content_type)
+            content_type :json
+            cors_headers
+
+            contacts_data = params[:contacts]
+
+            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
+              halt err(422, "No valid contacts were submitted")
+            end
+
+            contacts_ids = contacts_data.reject {|c| c['id'].nil? }.
+              map {|co| co['id'].to_s }
+
+            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
+
+            conflicted_ids = contacts_ids.find_all {|id|
+              Flapjack::Data::Contact.exists_with_id?(id, :redis => redis)
+            }
+
+            unless conflicted_ids.empty?
+              semaphore.release
+              halt err(409, "Contacts already exist with the following IDs: " +
+                conflicted_ids.join(', '))
+            end
+
+            contacts_data.each do |contact_data|
+              unless contact_data['id']
+                contact_data['id'] = SecureRandom.uuid
+              end
+              Flapjack::Data::Contact.add(contact_data, :redis => redis)
+            end
+
+            semaphore.release
+
+            ids = contacts_data.map {|c| c['id']}
+            location(ids)
+
+            contacts_data.map {|cd| cd['id']}.to_json
+          end
+
+          app.post '/contacts_atomic' do
+            pass unless Flapjack::Gateways::JSONAPI::JSON_REQUEST_MIME_TYPES.include?(request.content_type)
+            content_type :json
+
+            contacts_data = params[:contacts]
+            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
+              halt err(422, "No valid contacts were submitted")
+            end
+
+            # stringifying as integer string params are automatically integered,
+            # but our redis ids are strings
+            contacts_data_ids = contacts_data.reject {|c| c['id'].nil? }.
+              map {|co| co['id'].to_s }
+
+            if contacts_data_ids.empty?
+              halt err(422, "No contacts with IDs were submitted")
+            end
+
+            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
+
+            contacts = Flapjack::Data::Contact.all(:redis => redis)
+            contacts_h = hashify(*contacts) {|c| [c.id, c] }
+            contacts_ids = contacts_h.keys
+
+            # delete contacts not found in the bulk list
+            (contacts_ids - contacts_data_ids).each do |contact_to_delete_id|
+              contact_to_delete = contacts.detect {|c| c.id == contact_to_delete_id }
+              contact_to_delete.delete!
+            end
+
+            # add or update contacts found in the bulk list
+            contacts_data.reject {|cd| cd['id'].nil? }.each do |contact_data|
+              if contacts_ids.include?(contact_data['id'].to_s)
+                contacts_h[contact_data['id'].to_s].update(contact_data)
+              else
+                Flapjack::Data::Contact.add(contact_data, :redis => redis)
+              end
+            end
+
+            semaphore.release
+            204
+          end
+
+          # Returns all the contacts
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts
+          app.get '/contacts' do
+            content_type :json
+            cors_headers
+
+            contacts = if params[:ids]
+              Flapjack::Data::Contact.find_by_ids(params[:ids].split(',').uniq, :redis => redis)
+            else
+              Flapjack::Data::Contact.all(:redis => redis)
+            end
+            contacts.compact!
+
+            linked_entity_data, linked_entity_ids = if contacts.empty?
+              [[], []]
+            else
+              Flapjack::Data::Contact.entities_jsonapi(contacts.map(&:id), :redis => redis)
+            end
+
+            contacts_json = contacts.collect {|contact|
+              contact.linked_entity_ids = linked_entity_ids[contact.id]
+              contact.to_json
+            }.join(", ")
+
+            '{"contacts":[' + contacts_json + ']' +
+              ( linked_entity_data.empty? ? '}' :
+                ', "linked": {"entities":' + linked_entity_data.to_json + '}}')
+          end
+
+          # Returns the core information about the specified contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id
+          app.get '/contacts/:contact_id' do
+            content_type :json
+            cors_headers
+            contact = find_contact(params[:contact_id])
+
+            entities = contact.entities.map {|e| e[:entity] }
+
+            '{"contacts":[' + contact.to_json + ']' +
+              ( entities.empty? ? '}' :
+                ', "linked": {"entities":' + entities.values.to_json + '}}')
+          end
+
+          # Updates a contact
+          app.put '/contacts/:contact_id' do
+            content_type :json
+            cors_headers
+
+            contacts_data = params[:contacts]
+
+            if contacts_data.nil? || !contacts_data.is_a?(Enumerable)
+              halt err(422, "No valid contacts were submitted")
+            end
+
+            unless contacts_data.length == 1
+              halt err(422, "Exactly one contact hash must be supplied.")
+            end
+
+            contact_data = contacts_data.first
+
+            if contact_data['id'] && contact_data['id'].to_s != params[:contact_id]
+              halt err(422, "ID, if supplied, must match URL")
+            end
+
+            contact = find_contact(params[:contact_id])
+            #contact_data = hashify('first_name', 'last_name', 'email', 'media', 'tags') {|k| [k, params[k]]}
+            logger.debug("contact_data: #{contact_data}")
+            contact.update(contact_data)
+
+            contact.to_json
+          end
+
+          # Deletes a contact
+          app.delete '/contacts/:contact_id' do
+            cors_headers
+            semaphore = obtain_semaphore(SEMAPHORE_CONTACT_MASS_UPDATE)
+            contact = find_contact(params[:contact_id])
+            contact.delete!
+            semaphore.release
+            status 204
+          end
+
+          # Lists this contact's notification rules
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_notification_rules
+          app.get '/contacts/:contact_id/notification_rules' do
+            content_type :json
+            cors_headers
+
+            "[" + find_contact(params[:contact_id]).notification_rules.map {|r| r.to_json }.join(',') + "]"
+          end
+
+          # Get the specified notification rule for this user
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_notification_rules_id
+          app.get '/notification_rules/:id' do
+            content_type :json
+            cors_headers
+
+            '{"notification_rules":[' +
+              find_rule(params[:id]).to_json +
+              ']}'
+          end
+
+          # Creates a notification rule or rules for a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-post_contacts_id_notification_rules
+          app.post '/notification_rules' do
+            content_type :json
+            cors_headers
+
+            rules_data = params[:notification_rules]
+
+            if rules_data.nil? || !rules_data.is_a?(Enumerable)
+              halt err(422, "No valid notification rules were submitted")
+            end
+
+            if rules_data.any? {|rule| rule['id']}
+              halt err(422, "ID fields may not be generated by you. Remove IDs and POST again")
+            end
+
+            errors = []
+            rules_data.each do |rule_data|
+              errors << Flapjack::Data::NotificationRule.prevalidate_data(symbolize(rule_data), {:logger => logger})
+            end
+            errors.compact!
+
+            unless errors.nil? || errors.empty?
+              halt err(422, *errors)
+            end
+
+            rules = []
+            errors = []
+            rules_data.each do |rule_data|
+              rule_data = symbolize(rule_data)
+              contact   = find_contact(rule_data.delete(:contact_id))
+              rule_or_errors = contact.add_notification_rule(rule_data, :logger => logger)
+              if rule_or_errors.respond_to?(:critical_media)
+                rules << rule_or_errors
+              else
+                errors << rule_or_errors
+              end
+            end
+
+            if rules.empty?
+              halt err(422, *errors)
+            else
+              if errors.empty?
+                status 201
+              else
+                logger.warn("Errors during bulk notification rules creation: " + errors.join(', '))
+                status 200
+              end
+            end
+            ids = rules.map {|r| r.id}
+            location(ids)
+            '{"notification_rules":[' +
+              rules.map {|r| r.to_json}.join(',') +
+              ']}'
+          end
+
+          # Updates a notification rule
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
+          app.put('/notification_rules/:id') do
+            content_type :json
+            cors_headers
+
+            rules_data = params[:notification_rules]
+
+            if rules_data.nil? || !rules_data.is_a?(Enumerable)
+              halt err(422, "No valid notification rules were submitted")
+            end
+
+            unless rules_data.length == 1
+              halt err(422, "Exactly one notification rules hash must be supplied.")
+            end
+
+            rule_data = rules_data.first
+
+            if rule_data['id'] && rule_data['id'].to_s != params[:id]
+              halt err(422, "ID, if supplied, must match URL")
+            end
+
+            rule = find_rule(params[:id])
+            contact = find_contact(rule.contact_id)
+
+            supplied_contact = rule_data.delete('contact_id')
+            if supplied_contact && supplied_contact != contact.id
+              halt err(422, "contact_id cannot be modified")
+            end
+
+            errors = rule.update(symbolize(rule_data), :logger => logger)
+
+            unless errors.nil? || errors.empty?
+              halt err(422, *errors)
+            end
+            '{"notification_rules":[' +
+              rule.to_json +
+              ']}'
+          end
+
+          # Deletes a notification rule
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
+          app.delete('/notification_rules/:id') do
+            cors_headers
+            rule = find_rule(params[:id])
+            logger.debug("rule to delete: #{rule.inspect}, contact_id: #{rule.contact_id}")
+            contact = find_contact(rule.contact_id)
+            contact.delete_notification_rule(rule)
+            status 204
+          end
+
+          # Returns the media of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_media
+          app.get '/contacts/:contact_id/media' do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+
+            media = contact.media
+            media_intervals = contact.media_intervals
+            media_rollup_thresholds = contact.media_rollup_thresholds
+            media_addr_int = hashify(*media.keys) {|k|
+              [k, {'address'          => media[k],
+                   'interval'         => media_intervals[k],
+                   'rollup_threshold' => media_rollup_thresholds[k] }]
+            }
+            media_addr_int.to_json
+          end
+
+          # Returns the specified media of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_media_media
+          app.get('/contacts/:contact_id/media/:id') do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            media = contact.media[params[:id]]
+            if media.nil?
+              halt err(404, "no #{params[:id]} for contact '#{params[:contact_id]}'")
+            end
+            interval = contact.media_intervals[params[:id]]
+            # FIXME: does erroring when no interval found make sense?
+            if interval.nil?
+              halt err(403, "no #{params[:id]} interval for contact '#{params[:contact_id]}'")
+            end
+            rollup_threshold = contact.media_rollup_thresholds[params[:id]]
+            {'address'          => media,
+             'interval'         => interval,
+             'rollup_threshold' => rollup_threshold }.to_json
+          end
+
+          # Creates or updates a media of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_media_media
+          app.put('/contacts/:contact_id/media/:id') do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            errors = []
+
+            if 'pagerduty'.eql?(params[:id])
+              errors = [:service_key, :subdomain, :username, :password].inject([]) do |memo, pdp|
+                memo << "no #{pdp.to_s} for 'pagerduty' media" if params[pdp].nil?
+                memo
+              end
+
+              halt err(422, *errors) unless errors.empty?
+
+              contact.set_pagerduty_credentials('service_key'  => params[:service_key],
+                                                'subdomain'    => params[:subdomain],
+                                                'username'     => params[:username],
+                                                'password'     => params[:password])
+
+              contact.pagerduty_credentials.to_json
+            else
+              if params[:address].nil?
+                errors << "no address for '#{params[:id]}' media"
+              end
+
+              halt err(422, *errors) unless errors.empty?
+
+              contact.set_address_for_media(params[:id], params[:address])
+              contact.set_interval_for_media(params[:id], params[:interval])
+              contact.set_rollup_threshold_for_media(params[:id], params[:rollup_threshold])
+
+              {'address'          => contact.media[params[:id]],
+               'interval'         => contact.media_intervals[params[:id]],
+               'rollup_threshold' => contact.media_rollup_thresholds[params[:id]]}.to_json
+            end
+          end
+
+          # delete a media of a contact
+          app.delete('/contacts/:contact_id/media/:id') do
+            cors_headers
+            contact = find_contact(params[:contact_id])
+            contact.remove_media(params[:id])
+            status 204
+          end
+
+          # Returns the timezone of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-get_contacts_id_timezone
+          app.get('/contacts/:contact_id/timezone') do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            contact.timezone.name.to_json
+          end
+
+          # Sets the timezone of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_timezone
+          app.put('/contacts/:contact_id/timezone') do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            contact.timezone = params[:timezone]
+            contact.timezone.name.to_json
+          end
+
+          # Removes the timezone of a contact
+          # https://github.com/flpjck/flapjack/wiki/API#wiki-put_contacts_id_timezone
+          app.delete('/contacts/:contact_id/timezone') do
+            cors_headers
+            contact = find_contact(params[:contact_id])
+            contact.timezone = nil
+            status 204
+          end
+
+          app.post '/contacts/:contact_id/tags' do
+            content_type :json
+            cors_headers
+
+            tags = find_tags(params[:tags])
+            contact = find_contact(params[:contact_id])
+            contact.add_tags(*tags)
+            '{"tags":' +
+              contact.tags.to_json +
+            '}'
+          end
+
+          app.post '/contacts/:contact_id/entity_tags' do
+            content_type :json
+            cors_headers
+            contact = find_contact(params[:contact_id])
+            contact.entities.map {|e| e[:entity]}.each do |entity|
+              next unless tags = params[:entity][entity.name]
+              entity.add_tags(*tags)
+            end
+            contact_ent_tag = hashify(*contact.entities(:tags => true)) {|et|
+              [et[:entity].name, et[:tags]]
+            }
+            contact_ent_tag.to_json
+          end
+
+          app.delete '/contacts/:contact_id/tags' do
+            cors_headers
+            tags = find_tags(params[:tags])
+            contact = find_contact(params[:contact_id])
+            contact.delete_tags(*tags)
+            status 204
+          end
+
+          app.delete '/contacts/:contact_id/entity_tags' do
+            cors_headers
+            contact = find_contact(params[:contact_id])
+            contact.entities.map {|e| e[:entity]}.each do |entity|
+              next unless tags = params[:entity][entity.name]
+              entity.delete_tags(*tags)
+            end
+            status 204
+          end
+
+          app.get '/contacts/:contact_id/tags' do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            '{"tags":' +
+              contact.tags.to_json +
+              '}'
+
+          end
+
+          app.get '/contacts/:contact_id/entity_tags' do
+            content_type :json
+            cors_headers
+
+            contact = find_contact(params[:contact_id])
+            contact_ent_tag = hashify(*contact.entities(:tags => true)) {|et|
+              [et[:entity].name, et[:tags]]
+            }
+            contact_ent_tag.to_json
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end