solr_makr 0.0.4 → 0.5.1

data/lib/solr_makr/meta/pathlike.rb

@@ -0,0 +1,9 @@
+module SolrMakr
+  class Pathlike < Virtus::Attribute
+    # @param [#to_s, Pathname]
+    # @return [Pathname]
+    def coerce(pathy)
+      return Pathname.new(pathy)
+    end
+  end
+end

data/lib/solr_makr/meta/set_global_options.rb

@@ -0,0 +1,23 @@
+module SolrMakr
+  class SetGlobalOptions < ActiveInteraction::Base
+    with_options default: nil do
+      string  :solr_host,   strip: true
+      string  :solr_path,   strip: true
+      integer :solr_port
+
+      string  :zookeeper,   strip: true
+    end
+
+    validates_numericality_of :solr_port, integer_only: true,
+      greater_than_or_equal_to: 1,
+      less_than_or_equal_to: 65535,
+      message: 'must be a valid port',
+      allow_nil: true
+
+    def execute
+      inputs.each do |(setting, value)|
+        SolrMakr.configuration[setting] = value if given?(setting)
+      end
+    end
+  end
+end

data/lib/solr_makr/meta/utility.rb

@@ -0,0 +1,99 @@
+module SolrMakr
+  module Utility
+    module_function
+
+    # These are the minimum files required to configure a collection.
+    REQUIRED_SOLR_NODES = %w[schema.xml solrconfig.xml]
+
+    def default_table_options!(**table_options)
+      table_options[:style] ||= {}
+
+      width = table_options.delete(:width)
+
+      unless width == false
+        table_options[:style].reverse_merge! width: width || 80
+      end
+
+      return table_options
+    end
+
+    # @param [#each] collection
+    # @param [String] if_blank
+    # @param [Hash] table_options option that get passed to the `Terminal::Table` constructor
+    # @yieldparam [Terminal::Table] t
+    # @yieldparam [Array, #to_a, Object] item
+    # @return [Terminal::Table]
+    def default_table(collection:, if_blank: 'n/a', **table_options, &formatter)
+      table_options = default_table_options!(table_options)
+
+      return if_blank if collection.blank?
+
+      Terminal::Table.new table_options do |t|
+        collection.each do |item|
+          if block_given?
+            if formatter.arity == 2
+              formatter.call(t, item)
+            else
+              t << yield(item)
+            end
+          elsif item.respond_to? :to_table_row
+            t << item.to_table_row
+          else
+            t << Array(item)
+          end
+        end
+      end
+    end
+
+    def hash_to_table(hsh, if_blank: 'n/a', **table_options)
+      hsh = hsh.to_h
+
+      table_options = default_table_options!(table_options)
+
+      if hsh.present?
+        Terminal::Table.new table_options do |t|
+          hsh.each do |key, value|
+            t << [key.inspect, value.inspect]
+          end
+        end
+      else
+        if_blank
+      end
+    end
+
+    # It's possible the root directory is not what actually contains the nodes
+    # for configuring solr (e.g. files are in a `conf` directory). For now let's
+    # use `Pathname#find` to figure it out.
+    #
+    # @param [Pathname] root
+    # @return [Pathname]
+    # @return [nil]
+    def path_to_configset(root)
+      root.find do |path|
+        return path.dirname if path.basename.to_s.in?(REQUIRED_SOLR_NODES)
+      end
+
+      return nil
+    end
+
+    # @param [Pathname] conf_path
+    # @yield called once for each missing node
+    # @yieldparam [String] name
+    # @yieldreturn [void]
+    def looks_like_a_valid_configset?(conf_path)
+      if conf_path.present? && conf_path.try(:exist?)
+        missing = REQUIRED_SOLR_NODES.reject do |file|
+          conf_path.join(file).exist?
+        end
+
+        missing.each do |name|
+          yield name if block_given?
+        end
+
+        return missing.none?
+      else
+        false
+      end
+    end
+  end
+end

data/lib/solr_makr/meta/wraps_directory.rb

@@ -0,0 +1,27 @@
+module SolrMakr
+  module WrapsDirectory
+    extend ActiveSupport::Concern
+
+    include SolrMakr::WrapsPath
+
+    included do
+      delegate :join, to: :path
+    end
+
+    # @return [Boolean] if created
+    def create_if_missing!
+      unless exists?
+        path.mkpath
+
+        true
+      else
+        false
+      end
+    end
+
+    # @return [<Pathname>]
+    def subdirectories
+      path.children.select(&:directory?)
+    end
+  end
+end

data/lib/solr_makr/meta/wraps_path.rb

@@ -0,0 +1,18 @@
+module SolrMakr
+  module WrapsPath
+    extend ActiveSupport::Concern
+    include ActiveSupport::Configurable
+
+    included do
+      delegate :exist?, to: :path
+      alias_method :exists?, :exist?
+    end
+
+    # @!attribute [r] path
+    # @return [Pathname]
+
+    def inspect
+      "#<#{self.class.name} :path => '#{path.to_s}'>"
+    end
+  end
+end

data/lib/solr_makr/solr_api.rb

@@ -0,0 +1,12 @@
+module SolrMakr
+  module SolrAPI
+    extend ActiveSupport::Autoload
+
+    autoload :Client
+    autoload :ClientMacros
+    autoload :RequestParams
+    autoload :Response
+    autoload :ClusterResponse
+    autoload :ListResponse
+  end
+end

data/lib/solr_makr/solr_api/client.rb

@@ -0,0 +1,32 @@
+module SolrMakr
+  module SolrAPI
+    class Client
+      include HTTParty
+      include SolrMakr::SolrAPI::ClientMacros
+
+      #logger ::Logger.new(STDOUT)
+
+      # Specify the return type should be JSON, not XML.
+      default_params wt: 'json'
+
+      def initialize
+        self.class.base_uri SolrMakr.configuration.solr_uri
+      end
+
+      define_collection_action! :cluster_status, action: 'CLUSTERSTATUS'
+
+      define_collection_action! :create, requires_name: true do |params, options|
+        params[:numShards]              = options.fetch(:number_of_shards, 1)
+        params[:replicationFactor]      = options.fetch(:replication_factor, 1)
+        params[:maxShardsPerNode]       = options.fetch(:max_shards_per_node, 1)
+        params['collection.configName'] = options.fetch(:config_name, options.fetch(:name))
+      end
+
+      define_collection_action! :delete, requires_name: true
+
+      define_collection_action! :list
+
+      define_collection_action! :reload, requires_name: true
+    end
+  end
+end

data/lib/solr_makr/solr_api/client_macros.rb

@@ -0,0 +1,61 @@
+module SolrMakr
+  module SolrAPI
+    # @api private
+    module ClientMacros
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Generate a method to connect with the solr collections API.
+        #
+        # @param [String] name a ruby-safe name for the generated method
+        # @param [String] action the name of the action on in the solr API, all upper-case
+        # @param [:get, :post, :put, :delete] method the HTTP verb
+        # @param [Boolean] requires_name whether the `action` requires a collection name to be passed.
+        #   Cluster-level actions, like `list` and `cluster_status`, do not.
+        # @param [Class, String, Symbol] response_klass
+        # @yield Allows the method to be further customized by formatting params passed to the
+        #   API based on options provided to the generated method.
+        # @yieldparam [SolrMakr::SolrRequestParams] params
+        # @yieldparam [Hash] options
+        # @yieldreturn [void]
+        # @return [void]
+        # @!macro [attach] define_collection_action!
+        #   @!method $1(options = {})
+        #     @param [Hash] options
+        #     @option options [String] :name the name of the collection
+        #     @return [SolrMakr::SolrAPI::Response]
+        def define_collection_action!(name, action: name.to_s.upcase, method: :get, requires_name: false, response_klass: SolrMakr::SolrAPI::Response, &option_parser)
+          response_klass = parse_response_klass(response_klass)
+
+          define_method(name) do |**options|
+            params = SolrMakr::SolrAPI::RequestParams.new action: action
+
+            if requires_name
+              unless options.key?(:name) && options[:name].present?
+                raise ArgumentError, "missing required option: #{name}"
+              else
+                params[:name] = options[:name]
+              end
+            end
+
+            if option_parser.respond_to?(:call)
+              option_parser.call(params, options)
+            end
+
+            response = self.class.__send__(method, '/admin/collections', params)
+
+            response_klass.new(response)
+          end
+        end
+
+        # @param [Class, String, Symbol] klass
+        # @return [Class]
+        def parse_response_klass(klass)
+          return klass if klass.kind_of?(Class)
+
+          "SolrMakr::SolrAPI::#{klass}".constantize
+        end
+      end
+    end
+  end
+end

data/lib/solr_makr/solr_api/cluster_response.rb

@@ -0,0 +1,21 @@
+module SolrMakr
+  module SolrAPI
+    class ClusterResponse < Response
+      # @!attribute [r] collections
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      attr_lazy_reader :collections do
+        dig(:cluster, :collections) || {}.with_indifferent_access
+      end
+
+      def each_collection
+        return enum_for(__method__) unless block_given?
+
+        collections = dig(:cluster, :collections)
+
+        collections.each do |(key, info)|
+          yield key, info
+        end
+      end
+    end
+  end
+end

data/lib/solr_makr/solr_api/endpoint.rb

@@ -0,0 +1,15 @@
+module SolrMakr
+  module SolrAPI
+    # @abstract
+    class Endpoint
+      include Virtus.model strict: true
+
+      attribute :name, String
+      attribute :path, String
+
+      # @return [SolrMakr::SolrAPI::Response]
+      def request(client:, method:, response_klass:, params:)
+      end
+    end
+  end
+end

data/lib/solr_makr/solr_api/list_response.rb

@@ -0,0 +1,19 @@
+module SolrMakr
+  module SolrAPI
+    class ListResponse < Response
+      # @return [<String>]
+      attr_lazy_reader :collections do
+        array(:collections)
+      end
+
+      # @yieldparam [String]
+      def each_collection
+        return enum_for(__method__) unless block_given?
+
+        collections.each do |collection|
+          yield collection
+        end
+      end
+    end
+  end
+end

data/lib/solr_makr/solr_api/request_params.rb

@@ -0,0 +1,50 @@
+module SolrMakr
+  module SolrAPI
+    # Wrapper around parameters passed to solr api requests.
+    #
+    # Solr requests are not really RESTful, and instead take the action
+    # name in a parameter on the query string.
+    class RequestParams
+      # @param [String] action (see #action)
+      def initialize(action:)
+        @action = action
+        @query  = {}.with_indifferent_access
+        @params = {}.with_indifferent_access
+      end
+
+      # @!attribute [r] action
+      # The name of the solr action, which is automatically applied to the
+      # {#query query string parameters} when the request is made.
+      # @return [String]
+      attr_reader :action
+
+      # @!attribute [r] params
+      # @api private
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      attr_reader :params
+
+      # @!attribute [r] query
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      attr_reader :query
+
+      delegate :[], :[]=, to: :query
+
+      # Set the body for the request.
+      #
+      # @param [String, #to_s]
+      # @return [void]
+      def body(request_body)
+        @params[:body] = request_body
+      end
+
+      def to_h(options = nil)
+        query[:action] = @action
+
+        @params.to_h.merge(query: query)
+      end
+
+      alias_method :to_hash, :to_h
+      alias_method :as_json, :to_h
+    end
+  end
+end

data/lib/solr_makr/solr_api/response.rb

@@ -0,0 +1,69 @@
+module SolrMakr
+  module SolrAPI
+    class Response
+      # @param [Hash] raw_response
+      def initialize(raw_response = {})
+        @raw_response = raw_response.with_indifferent_access
+      end
+
+      # @!attribute [r] raw_response
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      attr_reader :raw_response
+
+      delegate :fetch, to: :raw_response
+
+      # @param [<String, Symbol>] keys path to the desired array
+      # @return [Array]
+      def array(*keys)
+        Array(dig(*keys))
+      end
+
+      # Dig into the response data by a given path.
+      #
+      # @param [<String, Symbol>] keys path to the desired value
+      # @return [Object] if non-hashlike
+      # @return [ActiveSupport::HashWithIndifferentAccess] if hash-like
+      def dig(*keys)
+        keys.reduce raw_response do |hsh, key|
+          hsh[key] if hsh.respond_to?(:[])
+        end
+      end
+
+      alias_method :[], :dig
+
+      # @!attribute [r] response_header
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      attr_lazy_reader :response_header do
+        dig :responseHeader
+      end
+
+      # @!attribute [r] failure
+      # @return [String]
+      attr_lazy_reader :failure do
+        unless success?
+          exception.fetch(:msg) or error.fetch(:msg) or 'unknown failure'
+        end
+      end
+
+      attr_lazy_reader :error do
+        fetch(:error, {})
+      end
+
+      attr_lazy_reader :exception do
+        fetch(:exception, {})
+      end
+
+      def success?
+        status == 0
+      end
+
+      attr_lazy_reader :status do
+        response_header.fetch :status, 500
+      end
+
+      def to_s
+        "#<#{self.class.name} #{JSON.pretty_generate(raw_response)}>"
+      end
+    end
+  end
+end