pager_judy 0.2.0

data/lib/pager_judy/api/fake_api_app.rb

@@ -0,0 +1,171 @@
+require "securerandom"
+require "sinatra/base"
+require "multi_json"
+
+module PagerJudy
+  module API
+
+    # This little Rack app is designed to fake the PagerDuty REST API.
+    #
+    # It's pretty much just CRUD:
+    #
+    #   GET  /COLLECTION
+    #   POST /COLLECTION
+    #   GET  /COLLECTION/ID
+    #   PUT  /COLLECTION/ID
+    #
+    class FakeApp < Sinatra::Base
+
+      def db
+        # The "database" is just a big Hash. We make it an instance variable,
+        # so it sticks around between requests.
+        @db ||= {}
+      end
+
+      attr_writer :db
+
+      def collection_type
+        params["collection_type"]
+      end
+
+      def collection
+        db[collection_type] ||= {}
+      end
+
+      def item_type
+        collection_type.chomp("s")
+      end
+
+      def item_id
+        @item_id ||= params["item_id"]
+      end
+
+      def item
+        return_error(404, "#{item_type} #{item_id} not found") unless collection.key?(item_id)
+        collection.fetch(item_id)
+      end
+
+      def item_data
+        item.merge("id" => item_id)
+      end
+
+      def sub_collection_type
+        params["sub_collection_type"]
+      end
+
+      def sub_collection
+        item[sub_collection_type] ||= {}
+      end
+
+      def sub_item_type
+        sub_collection_type.chomp("s")
+      end
+
+      def sub_item_id
+        @sub_item_id ||= params["sub_item_id"]
+      end
+
+      def sub_item_exists?
+        sub_collection.key?(sub_item_id)
+      end
+
+      def sub_item
+        return_error(404, "#{sub_item_type} #{sub_item_id} not found") unless sub_collection.key?(sub_item_id)
+        sub_collection.fetch(sub_item_id)
+      end
+
+      def sub_item_data
+        sub_collection.fetch(sub_item_id).merge("id" => sub_item_id)
+      end
+
+      # List a collection
+      #
+      get "/:collection_type" do
+        result = {
+          collection_type => collection.map do |id, data|
+            data.merge("id" => id)
+          end,
+          "limit" => collection.size + 10,
+          "offset" => 0,
+          "more" => false
+        }
+        return_json(result)
+      end
+
+      # Show an item
+      #
+      get "/:collection_type/:item_id" do
+        return_json(item_type => item_data)
+      end
+
+      # Create an item
+      #
+      post "/:collection_type" do
+        data = json_body.fetch(item_type)
+        data.delete("id")
+        @item_id = SecureRandom.hex(4)
+        collection[@item_id] = data
+        return_json({ item_type => item_data }, 201)
+      end
+
+      # Update an item
+      #
+      put "/:collection_type/:item_id" do
+        data = json_body.fetch(item_type)
+        data.delete("id")
+        data.delete("type")
+        item.merge!(data)
+        return_json({ item_type => item_data }, 200)
+      end
+
+      # Create a sub-item
+      #
+      post "/:collection_type/:item_id/:sub_collection_type" do
+        data = json_body.fetch(sub_item_type)
+        data.delete("id")
+        @sub_item_id = SecureRandom.hex(4)
+        sub_collection[@sub_item_id] = data
+        return_json({ sub_item_type => sub_item_data }, 201)
+      end
+
+      # Update a sub-item
+      #
+      put "/:collection_type/:item_id/:sub_collection_type/:sub_item_id" do
+        data = json_body.fetch(sub_item_type)
+        data.delete("id")
+        data.delete("type")
+        sub_item.merge!(data)
+        return_json({ sub_item_type => sub_item_data }, 200)
+      end
+
+      not_found do
+        return_error 404, "Not found"
+      end
+
+      private
+
+      def json_body
+        MultiJson.load(request.body)
+      rescue MultiJson::ParseError
+        {}
+      end
+
+      def return_json(data, status = 200)
+        content_type "application/vnd.pagerduty+json;version=2"
+        [status, MultiJson.dump(data)]
+      end
+
+      def return_error(status, message)
+        data = {
+          "error" => {
+            "message" => message
+          }
+        }
+        content_type "application/json"
+        halt status, MultiJson.dump(data)
+      end
+
+    end
+
+  end
+end

data/lib/pager_judy/api/item.rb

@@ -0,0 +1,56 @@
+module PagerJudy
+  module API
+
+    # Represents an item, e.g. a service, a user, ...
+    #
+    class Item
+
+      def initialize(resource, type, id, criteria = {})
+        @resource = resource
+        @type = type
+        @id = id
+        @criteria = criteria
+      end
+
+      attr_reader :resource
+      attr_reader :type
+      attr_reader :id
+      attr_reader :criteria
+
+      def with(more_criteria)
+        more_criteria = Hash[more_criteria.select { |_, v| v }]
+        self.class.new(resource, type, id, criteria.merge(more_criteria))
+      end
+
+      def read
+        resource.get(criteria).fetch(type)
+      end
+
+      def update(data)
+        if dry_run?
+          result = data
+        else
+          result = resource.put(type => data).fetch(type)
+        end
+        name = result.fetch("name")
+        logger.info { "updated #{type} #{name.inspect} [#{id}]" }
+      end
+
+      def to_h
+        read
+      end
+
+      private
+
+      def logger
+        resource.logger
+      end
+
+      def dry_run?
+        resource.dry_run?
+      end
+
+    end
+
+  end
+end

data/lib/pager_judy/api/resource.rb

@@ -0,0 +1,81 @@
+require "httpi"
+require "multi_json"
+require "pager_judy/api/errors"
+require "uri"
+
+module PagerJudy
+  module API
+
+    # Represents an API endpoint.
+    #
+    class Resource
+
+      def initialize(api_key:, uri:, logger: nil, dry_run: false)
+        @api_key = api_key
+        @uri = URI(uri.to_s.chomp("/"))
+        @type = @uri.to_s.split("/").last
+        @logger = logger || Logger.new(nil)
+        @dry_run = dry_run
+      end
+
+      attr_reader :api_key
+      attr_reader :uri
+      attr_reader :type
+      attr_reader :logger
+
+      def dry_run?
+        @dry_run
+      end
+
+      def subresource(path)
+        Resource.new(api_key: api_key, uri: "#{uri}/#{path}", logger: logger, dry_run: dry_run?)
+      end
+
+      def get(query = nil)
+        request = new_request
+        request.query = query if query
+        debug("GET", request.url)
+        response = HTTPI.get(request)
+        raise HttpError.new(request, response) if response.error?
+        MultiJson.load(response.body)
+      end
+
+      def post(data)
+        request = new_request
+        request.body = MultiJson.dump(data)
+        debug("POST", request.url, data)
+        response = HTTPI.post(request)
+        raise HttpError.new(request, response) if response.error?
+        MultiJson.load(response.body)
+      end
+
+      def put(data)
+        request = new_request
+        request.body = MultiJson.dump(data)
+        debug("PUT", request.url, data)
+        response = HTTPI.put(request)
+        raise HttpError.new(request, response) if response.error?
+        MultiJson.load(response.body)
+      end
+
+      private
+
+      def debug(operation, url, data = nil)
+        logger.debug do
+          data_dump = MultiJson.dump(data, pretty: true) if data
+          [operation, url, data_dump].join(" ")
+        end
+      end
+
+      def new_request
+        HTTPI::Request.new(uri.to_s).tap do |req|
+          req.headers["Accept"] = "application/vnd.pagerduty+json;version=2"
+          req.headers["Authorization"] = "Token token=#{api_key}"
+          req.headers["Content-Type"] = "application/json"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/pager_judy/cli/collection_behaviour.rb

@@ -0,0 +1,49 @@
+require "pager_judy/cli/data_display"
+
+module PagerJudy
+  module CLI
+
+    # Common behaviour for sub-commands that operate on collections.
+    #
+    module CollectionBehaviour
+
+      def self.included(target)
+        target.default_subcommand = "summary"
+
+        target.subcommand ["summary", "s"], "One-line summary" do
+          include SummarySubcommand
+        end
+
+        target.subcommand ["data", "d"], "Full details" do
+          include DataSubcommand
+        end
+      end
+
+      module SummarySubcommand
+
+        def execute
+          collection.each do |item|
+            puts "#{item.fetch('id')}: #{item.fetch('summary')}"
+          end
+        end
+
+      end
+
+      module DataSubcommand
+
+        include DataDisplay
+
+        def self.included(target)
+          target.parameter "[EXPR]", "JMESPath expression"
+        end
+
+        def execute
+          puts display_data(collection.to_a, expr)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/pager_judy/cli/data_display.rb

@@ -0,0 +1,52 @@
+require "clamp"
+require "jmespath"
+require "multi_json"
+require "yaml"
+
+module PagerJudy
+  module CLI
+
+    module DataDisplay
+
+      extend Clamp::Option::Declaration
+
+      option %w[-f --format], "FORMAT", "format for data output",
+             attribute_name: :output_format,
+             default: "YAML"
+
+      def output_format=(arg)
+        arg = arg.upcase
+        unless %w[JSON YAML].member?(arg)
+          raise ArgumentError, "unrecognised data format: #{arg.inspect}"
+        end
+        @output_format = arg
+      end
+
+      protected
+
+      def format_data(data)
+        case output_format
+        when "JSON"
+          MultiJson.dump(data, pretty: true)
+        when "YAML"
+          YAML.dump(data)
+        else
+          raise "bad output format: #{output_format}"
+        end
+      end
+
+      def select_data(data, jmespath_expression = nil)
+        return data if jmespath_expression.nil?
+        JMESPath.search(jmespath_expression, data)
+      rescue JMESPath::Errors::SyntaxError
+        signal_error("invalid JMESPath expression")
+      end
+
+      def display_data(data, jmespath_expression = nil)
+        format_data(select_data(data, jmespath_expression))
+      end
+
+    end
+
+  end
+end

data/lib/pager_judy/cli/item_behaviour.rb

@@ -0,0 +1,31 @@
+require "pager_judy/cli/data_display"
+
+module PagerJudy
+  module CLI
+
+    # Common behaviour for sub-commands that operate on collection members.
+    #
+    module ItemBehaviour
+
+      def self.included(target)
+        target.default_subcommand = "data"
+
+        target.subcommand ["data", "d"], "Full details" do
+          include DataSubcommand
+        end
+      end
+
+      module DataSubcommand
+
+        include DataDisplay
+
+        def execute
+          puts display_data(item.to_h)
+        end
+
+      end
+
+    end
+
+  end
+end