polyseerio 0.0.1

data/lib/resource/definition.rb

@@ -0,0 +1,166 @@
+require 'enum'
+
+module Polyseerio
+  # Defines polyseer.io resources
+  module Resource
+    module Definition
+      STATICS = :statics
+      METHODS = :methods
+
+      CREATABLE_STATICS = [
+        :create
+      ].freeze
+      READABLE_STATICS = [
+        :find,
+        :find_by_id
+      ].freeze
+      DELETABLE_STATICS = [
+        :remove
+      ].freeze
+      UPDATABLE_STATICS = [
+        :update
+      ].freeze
+      CRUD_STATICS = [
+        *CREATABLE_STATICS,
+        *READABLE_STATICS,
+        *DELETABLE_STATICS,
+        *UPDATABLE_STATICS
+      ].freeze
+
+      RESOURCE_INSTANCE = [
+        :to_json
+      ].freeze
+
+      SAVABLE_INSTANCE = [
+        :save
+      ].freeze
+
+      DEFINITION = {
+        Enum::Resource::ALERT => {
+          STATICS => [
+            *CRUD_STATICS,
+            :find_by_name,
+            :trigger
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :trigger,
+            :remove
+          ]
+        },
+        Enum::Resource::CHANNEL => {
+          STATICS => [
+            *CRUD_STATICS,
+            :find_by_name,
+            :message
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :message,
+            :remove
+          ]
+        },
+        Enum::Resource::ENVIRONMENT => {
+          STATICS => [
+            *CRUD_STATICS,
+            :find_by_name,
+            :message
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :message,
+            :remove
+          ]
+        },
+        Enum::Resource::EVENT => {
+          STATICS => [
+            *CREATABLE_STATICS,
+            *READABLE_STATICS
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE
+          ]
+        },
+        Enum::Resource::EXPECTATION => {
+          STATICS => [
+            *CRUD_STATICS,
+            :find_by_name,
+            :check
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :remove,
+            :check
+          ]
+        },
+        Enum::Resource::INSTANCE => {
+          STATICS => [
+            *CRUD_STATICS,
+            :find_by_name,
+            :attach
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :add_gauge,
+            :attach,
+            :detach,
+            :fact,
+            :gauge,
+            :remove,
+            :add_fact
+          ]
+        },
+        Enum::Resource::LOGIC_BLOCK => {
+          STATICS => [
+            *CRUD_STATICS,
+            :execute
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :remove,
+            :execute
+          ]
+        },
+        Enum::Resource::MEMBER => {
+          STATICS => [
+            *CRUD_STATICS
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :remove
+          ]
+        },
+        Enum::Resource::MESSAGE => {
+          STATICS => [
+            *CRUD_STATICS
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE
+          ]
+        },
+        Enum::Resource::SETTING => {
+          STATICS => []
+        },
+        Enum::Resource::TASK => {
+          STATICS => [
+            *CRUD_STATICS
+          ],
+          METHODS => [
+            *SAVABLE_INSTANCE,
+            *RESOURCE_INSTANCE,
+            :remove
+          ]
+        }
+      }.freeze
+    end
+  end
+end

data/lib/resource/factory.rb

@@ -0,0 +1,149 @@
+require 'resource/definition'
+require 'resource/helper'
+require 'resource/base'
+require 'sdk/factory'
+require 'inflection'
+require 'sdk/helper'
+
+module Polyseerio
+  module Resource
+    # Resource building methods.
+    module Factory
+      # Determine if a resource definition represents a singleton.
+      def self.defines_singleton?(definition)
+        !definition.key?(:methods) || definition[:methods].empty?
+      end
+
+      # Add a static method to a Class.
+      def self.add_static(*args)
+        proc do |(name, method), resource|
+          resource.class_eval do
+            define_singleton_method(name, &method)
+          end
+        end.curry.call(*args)
+      end
+
+      # Add an instance method to a Class.
+      def self.add_method(*args)
+        proc do |(name, method), resource|
+          resource.class_eval do
+            define_method(name, &Helper.forward_self(method))
+          end
+        end.curry.call(*args)
+      end
+
+      # Add a collection of static methods to a Class.
+      def self.add_statics(resource, statics = {})
+        return resource if statics.empty?
+
+        statics.each_with_object(resource, &add_static)
+      end
+
+      # Add a collection of instance methods to a Class.
+      def self.add_methods(resource, _request, methods = {})
+        return resource if methods.empty?
+
+        methods.each_with_object(resource, &add_method)
+      end
+
+      # Takes a resource name and creates a class name.
+      def self.to_class_name(resource, cid = '')
+        parts = resource.to_s.split('-').map(&:capitalize)
+
+        parts[parts.size - 1] = Inflection.singular(parts.last)
+
+        name = parts.join ''
+
+        "#{name}#{cid}"
+      end
+
+      # Create a resource.
+      # TODO: copts are not optional
+      def self.create(type, request, cid, copts = {})
+        resource = Object.const_set(to_class_name(type, cid), Class.new(Base))
+        resource.define_singleton_method(:copts) do
+          copts
+        end
+
+        resource.define_singleton_method(:type) do
+          type
+        end
+
+        resource.define_singleton_method(:request) do
+          request
+        end
+
+        resource.define_singleton_method(:cid) do
+          cid
+        end
+
+        resource
+      end
+
+      # Create a resource.
+      def self._make
+        proc do |type, request, cid, options = {}|
+          unless Definition::DEFINITION.key? type
+            raise ArgumentError, 'Could not find definition for resource: ' \
+              "#{type}"
+          end
+
+          definition = Definition::DEFINITION.fetch(type)
+
+          # Create the resource / class.
+          resource = if defines_singleton? definition
+                       {}
+                     else
+                       create(type, request, cid, options)
+                     end
+
+          # Add statics.
+          if definition.key? Definition::STATICS
+            statics = SDK::Static.factory(
+              request,
+              type,
+              definition[Definition::STATICS],
+              options
+            )
+
+            add_statics(resource, statics)
+          end
+
+          # Add methods.
+          if definition.key? Definition::METHODS
+            methods = SDK::Method.factory(
+              request,
+              type,
+              definition[Definition::METHODS],
+              options
+            )
+
+            add_methods(resource, request, methods)
+          end
+
+          resource
+        end
+      end
+
+      # Generate a memoize key based on factory arguments
+      def self.get_memoize_key(resource, _request, cid, _options = {})
+        :"#{resource}_#{cid}"
+      end
+
+      # Convenience for get_memoize_key in proc form.
+      def self.memoize_key
+        proc do |*args|
+          get_memoize_key(*args)
+        end
+      end
+
+      # TODO: ideal API would be memoize(:make, memoize_key) - in future.
+      @make = Polyseerio::Helper.memoize_function(_make, memoize_key)
+
+      # Memoized calls to make. A little ugly, would like a better memoize API.
+      def self.make(*args)
+        @make.call(*args)
+      end
+    end
+  end
+end

data/lib/resource/helper.rb

@@ -0,0 +1,91 @@
+module Polyseerio
+  module Resource
+    # Helper methods for building and working with resources
+    module Helper
+      EID_REGEX = Regexp.new('/environments/([\da-z\.-]+)/')
+
+      # Forward self as first argument. Used for method procs.
+      def self.forward_self(func)
+        proc do |*args|
+          func.call(self, *args)
+        end
+      end
+
+      # Given a request path an eid is returned or nil
+      def self.get_eid_from_resource_path(path)
+        result = EID_REGEX.match path
+
+        return result if result.nil?
+
+        result[1]
+      end
+
+      # True if the response is a resource based response
+      def self.resource_response?(body)
+        body.key?(:data) &&
+          (resource?(body[:data]) || resource_collection?(body[:data]))
+      end
+
+      # True if response data is a resource collection (alias)
+      def self.resource_collection?(data)
+        data.is_a? Array
+      end
+
+      # True if response data is a resource collection (alias)
+      def self.resource?(data)
+        data.is_a? Hash
+      end
+
+      # Convert parsed response data into an instance
+      # TODO: hard to unit-test (due to Factory.make)
+      def self.to_instance(data, _meta, _included, cid)
+        type = data.fetch(:type, nil)
+        id = data.fetch(:id, nil)
+        attributes = data.fetch(:attributes, {})
+
+        attributes[:id] = id
+
+        # parse_response would only eve be called once the client has been
+        # constructed meaning in order to get the class we simply need to
+        # pass the type and cid. make is memoized on the type and cid args.
+        resource = Factory.make(type, nil, cid)
+
+        resource.new(attributes) # TODO: need to include meta
+      end
+
+      # Parse a resource response
+      # TODO: hard to unit-test (due to Factory.make)
+      def self.parse_resource_response(response, cid)
+        body = response.body
+        meta = body[:meta] || {}
+        included = body[:included] || {}
+        data = body[:data]
+
+        eid = get_eid_from_resource_path response.request.uri.path
+
+        # attach eid if we have attributes and an id
+        # would need to occur for each?????
+        data[:attributes][:eid] = eid if !eid.nil? && data.key?(:attributes)
+
+        # if resource collection if so map return
+        if resource_collection? data
+          return data.map do |item|
+            to_instance(item, meta, included, cid)
+          end
+        end
+
+        # convert to instance
+        to_instance(data, meta, included, cid)
+      end
+
+      # Parse a response
+      def self.parse_response(response, cid)
+        if resource_response? response.body
+          return parse_resource_response(response, cid)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/resource/routine.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+module Polyseerio
+  module Resource
+    # Reusable resource routines.
+    module Routine
+      DEFAULT_UPSERT_OPTIONS = {
+        key: :name
+      }.freeze
+
+      # Upsert a resource.
+      def self.upsert(resource, attributes)
+        unless attributes.key? :name
+          raise ArgumentError, 'Passed attributes must contain a name.'
+        end
+
+        resource.find_by_name(attributes[:name])
+                .then(proc do |reason|
+                  raise reason if reason.http_code != 404
+
+                  resource.create(attributes).execute.value
+                end)
+      end
+    end
+  end
+end

data/lib/response.rb

@@ -0,0 +1,27 @@
+require 'helper'
+require 'concurrent'
+
+module Polyseerio
+  # HTTP response wrapper.
+  class Response
+    def initialize(rest_response)
+      @rest_response = rest_response
+    end
+
+    # Returns the response body.
+    #
+    # NOTE: This function is memoized.
+    def body
+      @body_result ||= JSON.parse(@rest_response.body, symbolize_names: true)
+    end
+
+    # Returns the original request obect.
+    def request
+      @rest_response.request
+    end
+
+    private
+
+    attr_accessor :rest_response
+  end
+end